Chore/891 eliminate any usage

src/admin/admin-audit.interceptor.spec.ts

@@ -1,21 +1,28 @@
 import { AdminAuditInterceptor } from './admin-audit.interceptor';
 import { ExecutionContext, CallHandler } from '@nestjs/common';
 import { of } from 'rxjs';
+import { PrismaService } from '../database/prisma.service';
+
+interface MockPrisma {
+  activityLog: {
+    create: jest.Mock;
+  };
+}
 
 describe('AdminAuditInterceptor', () => {
   let interceptor: AdminAuditInterceptor;
-  let mockPrisma: any;
+  let mockPrisma: MockPrisma;
 
   beforeEach(() => {
     mockPrisma = {
       activityLog: {
         create: jest.fn().mockResolvedValue({}),
       },
     };
-    interceptor = new AdminAuditInterceptor(mockPrisma);
+    interceptor = new AdminAuditInterceptor(mockPrisma as unknown as PrismaService);
   });
 
-  function makeContext(overrides: Partial<any> = {}): ExecutionContext {
+  function makeContext(overrides: Record<string, unknown> = {}): ExecutionContext {
     const request = {
       authUser: { sub: 'admin-1' },
       headers: { 'user-agent': 'test-agent' },

src/admin/admin-audit.interceptor.ts

@@ -6,7 +6,7 @@ import { PrismaService } from '../database/prisma.service';
 export class AdminAuditInterceptor implements NestInterceptor {
   constructor(private readonly prisma: PrismaService) {}
 
-  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
+  intercept(context: ExecutionContext, next: CallHandler): Observable<unknown> {
     const request = context.switchToHttp().getRequest();
     const user = request.authUser;
     const ip =

src/admin/admin.controller.ts

@@ -256,11 +256,7 @@ export class AdminController {
   }
 
   @Get('email/preview/:templateName')
-  async previewEmailTemplate(@Param('templateName') templateName: string): Promise<{
-    templateName: string;
-    sampleData: Record<string, unknown>;
-    note: string;
-  }> {
+  async previewEmailTemplate(@Param('templateName') templateName: string) {
     const sampleDataMap: Record<string, Record<string, unknown>> = {
       'password-reset': {
         resetUrl: 'http://localhost:3000/reset-password?token=sample-token-123',

src/admin/interceptors/admin-access-logging.interceptor.ts

@@ -11,7 +11,7 @@ import { AuditService } from '../../audit/audit.service';
 export class AdminAccessLoggingInterceptor implements NestInterceptor {
   constructor(private readonly auditService: AuditService) {}
 
-  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
+  intercept(context: ExecutionContext, next: CallHandler): Observable<unknown> {
     const request = context.switchToHttp().getRequest();
 
     const response = context.switchToHttp().getResponse();

src/analytics/analytics.interceptor.ts

@@ -11,7 +11,7 @@ import { AuthUserPayload } from '../auth/types/auth-user.type';
 export class AnalyticsInterceptor implements NestInterceptor {
   constructor(private readonly analytics: AnalyticsService) {}
 
-  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
+  intercept(context: ExecutionContext, next: CallHandler): Observable<unknown> {
     const req = context.switchToHttp().getRequest();
     const res = context.switchToHttp().getResponse();
     const start = Date.now();

src/auth/auth.service.ts

@@ -7,7 +7,7 @@ import {
   UnauthorizedException,
 } from '@nestjs/common';
 import { ConfigService } from '@nestjs/config';
-import { Prisma } from '@prisma/client';
+import { Prisma, BlacklistedToken, Document, ApiKey, PasswordHistory } from '@prisma/client';
 import { randomUUID } from 'crypto';
 import * as jwt from 'jsonwebtoken';
 import { PrismaService } from '../database/prisma.service';
@@ -63,6 +63,23 @@ type JwtPayload = {
   exp?: number;
 };
 
+type TransactionWithPropertyTitle = Prisma.TransactionGetPayload<{
+  include: { property: { select: { title: true } } };
+}>;
+
+type PropertyWithOwnerName = Prisma.PropertyGetPayload<{
+  include: { owner: { select: { firstName: true; lastName: true } } };
+}>;
+
+interface RecaptchaVerifyResponse {
+  success: boolean;
+  score?: number;
+  action?: string;
+  challenge_ts?: string;
+  hostname?: string;
+  'error-codes'?: string[];
+}
+
 @Injectable()
 export class AuthService {
   private readonly logger = new Logger(AuthService.name);
@@ -123,7 +140,10 @@ export class AuthService {
   /**
    * Helper to map transactions to activity items for dashboard
    */
-  private transactionsToActivityItems(transactions: any[], type: 'purchase' | 'sale') {
+  private transactionsToActivityItems(
+    transactions: TransactionWithPropertyTitle[],
+    type: 'purchase' | 'sale',
+  ) {
     return transactions.map((tx) => ({
       type: 'transaction' as const,
       id: tx.id,
@@ -495,7 +515,7 @@ export class AuthService {
    * Handle token reuse detection - invalidate entire token family
    */
   private async handleTokenReuse(
-    blacklistedToken: any,
+    blacklistedToken: BlacklistedToken,
     reusedJti: string,
     ipAddress?: string,
     userAgent?: string,
@@ -776,7 +796,7 @@ export class AuthService {
     const recentActivity = [
       ...this.transactionsToActivityItems(buyerTransactions, 'purchase'),
       ...this.transactionsToActivityItems(sellerTransactions, 'sale'),
-      ...documents.map((doc: any) => ({
+      ...documents.map((doc: Document) => ({
         type: 'document' as const,
         id: doc.id,
         title: doc.fileName,
@@ -800,7 +820,7 @@ export class AuthService {
         apiKeysCount: apiKeys.length,
       },
       recentActivity,
-      recommendations: recommendationProperties.map((p: any) => ({
+      recommendations: recommendationProperties.map((p: PropertyWithOwnerName) => ({
         id: p.id,
         title: p.title,
         address: p.address,
@@ -1061,7 +1081,7 @@ export class AuthService {
       orderBy: { createdAt: 'desc' },
     });
 
-    return apiKeys.map((apiKey: any) => this.toApiKeyResponse(apiKey));
+    return apiKeys.map((apiKey: ApiKey) => this.toApiKeyResponse(apiKey));
   }
 
   async rotateApiKey(user: AuthUserPayload, apiKeyId: string) {
@@ -1431,7 +1451,7 @@ export class AuthService {
     return `pc_${randomToken(24)}`;
   }
 
-  private toApiKeyResponse(apiKey: any) {
+  private toApiKeyResponse(apiKey: ApiKey) {
     return {
       id: apiKey.id,
       name: apiKey.name,
@@ -1575,7 +1595,7 @@ export class AuthService {
       if (historyEntries.length > 0) {
         await tx.passwordHistory.deleteMany({
           where: {
-            id: { in: historyEntries.map((entry: any) => entry.id) },
+            id: { in: historyEntries.map((entry: PasswordHistory) => entry.id) },
           },
         });
       }
@@ -1652,7 +1672,7 @@ export class AuthService {
         body: `secret=${secret}&response=${token}`,
       });
 
-      const data = (await response.json()) as any;
+      const data = (await response.json()) as RecaptchaVerifyResponse;
 
       // reCAPTCHA v3 returns a score between 0.0 and 1.0. Typically, 0.5 is a good threshold.
       if (data.success && data.score !== undefined && data.score >= 0.5) {

src/auth/guards/rate-limit.guard.ts

@@ -10,6 +10,7 @@ import {
   Logger,
 } from '@nestjs/common';
 import { Reflector } from '@nestjs/core';
+import { Request } from 'express';
 import { RateLimitService } from '../rate-limit.service';
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 import { RATE_LIMIT_HEADERS } from '../rate-limit.config';
@@ -159,7 +160,7 @@ export class RateLimitGuard implements CanActivate {
   /**
    * Extract client IP from request
    */
-  private getClientIp(request: any): string {
+  private getClientIp(request: Request): string {
     return (
       request.headers['x-forwarded-for']?.split(',')[0].trim() ||
       request.connection?.remoteAddress ||

src/auth/interceptors/rate-limit-headers.interceptor.ts

@@ -11,9 +11,7 @@ import { RATE_LIMIT_HEADERS } from '../rate-limit.config';
  */
 @Injectable()
 export class RateLimitHeadersInterceptor implements NestInterceptor {
-  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    const request = context.switchToHttp().getRequest();
+  intercept(context: ExecutionContext, next: CallHandler): Observable<unknown> {
     const response = context.switchToHttp().getResponse();
 
     return next.handle().pipe(

src/auth/login-rate-limit.service.spec.ts

@@ -1,8 +1,18 @@
 import { LoginRateLimitService } from './login-rate-limit.service';
+import { PrismaService } from '../database/prisma.service';
+
+interface MockPrisma {
+  loginAttempt: {
+    findFirst: jest.Mock;
+    count: jest.Mock;
+    create: jest.Mock;
+    updateMany: jest.Mock;
+  };
+}
 
 describe('LoginRateLimitService', () => {
   let service: LoginRateLimitService;
-  let mockPrisma: any;
+  let mockPrisma: MockPrisma;
 
   const email = 'test@example.com';
   const ip = '1.2.3.4';
@@ -16,7 +26,7 @@ describe('LoginRateLimitService', () => {
         updateMany: jest.fn().mockResolvedValue({ count: 1 }),
       },
     };
-    service = new LoginRateLimitService(mockPrisma);
+    service = new LoginRateLimitService(mockPrisma as unknown as PrismaService);
   });
 
   describe('isAccountLocked', () => {

src/auth/rate-limit.guard.spec.ts

@@ -3,7 +3,7 @@ import { RateLimitService } from './rate-limit.service';
 import { ExecutionContext, HttpException } from '@nestjs/common';
 import { Reflector } from '@nestjs/core';
 
-function makeContext(overrides: Partial<any> = {}): ExecutionContext {
+function makeContext(overrides: Record<string, unknown> = {}): ExecutionContext {
   const request = {
     method: 'POST',
     url: '/auth/login',
@@ -41,7 +41,7 @@ describe('RateLimitGuard - auth/signup endpoints', () => {
       checkUserIpRateLimit: jest.fn().mockResolvedValue(notExceeded),
       checkEndpointRateLimit: jest.fn().mockResolvedValue({ ...notExceeded, limit: 0 }),
       getHeaders: jest.fn().mockReturnValue({}),
-    } as any;
+    } as unknown as jest.Mocked<RateLimitService>;
 
     guard = new RateLimitGuard(reflector, rateLimitService);
   });
@@ -69,10 +69,11 @@ describe('RateLimitGuard - auth/signup endpoints', () => {
     try {
       await guard.canActivate(ctx);
       fail('should have thrown');
-    } catch (e: any) {
+    } catch (e: unknown) {
       expect(e).toBeInstanceOf(HttpException);
-      expect(e.getStatus()).toBe(429);
-      const body = e.getResponse();
+      const httpException = e as HttpException;
+      expect(httpException.getStatus()).toBe(429);
+      const body = httpException.getResponse();
       expect(body).toMatchObject({ retryAfter: 60 });
     }
   });