fix: resolve linter warnings and improve TypeScript types

src/cache/cache.module.ts

@@ -24,7 +24,7 @@ import { CacheController } from './controllers/cache.controller';
           url: redisUrl,
           ttl,
           prefix,
-          retryStrategy: (times: number) => {
+          retryStrategy: (times: number): number => {
             const delay = Math.min(times * 50, 2000);
             return delay;
           },

src/cache/cache.service.ts

@@ -21,7 +21,7 @@ export class CacheService {
   /**
    * Generate a cache key with proper naming convention
    */
-  private generateKey(entity: string, action: string, params?: Record<string, any>): string {
+  private generateKey(entity: string, action: string, params?: Record<string, unknown>): string {
     const baseKey = `${this.prefix}${entity}:${action}`;
 
     if (!params || Object.keys(params).length === 0) {
@@ -38,7 +38,7 @@ export class CacheService {
   /**
    * Get data from cache
    */
-  async get<T>(entity: string, action: string, params?: Record<string, any>): Promise<T | null> {
+  async get<T>(entity: string, action: string, params?: Record<string, unknown>): Promise<T | null> {
     const key = this.generateKey(entity, action, params);
 
     try {
@@ -67,7 +67,7 @@ export class CacheService {
     action: string, 
     data: T, 
     ttl?: number,
-    params?: Record<string, any>
+    params?: Record<string, unknown>
   ): Promise<void> {
     const key = this.generateKey(entity, action, params);
 
@@ -85,7 +85,7 @@ export class CacheService {
   /**
    * Delete specific cache entry
    */
-  async delete(entity: string, action: string, params?: Record<string, any>): Promise<void> {
+  async delete(entity: string, action: string, params?: Record<string, unknown>): Promise<void> {
     const key = this.generateKey(entity, action, params);
 
     try {
@@ -154,7 +154,7 @@ export class CacheService {
   /**
    * Get cache statistics (if available)
    */
-  async getStats(): Promise<Record<string, any>> {
+  async getStats(): Promise<Record<string, unknown>> {
     try {
       // This would return Redis INFO command results in production
       return {

src/cache/controllers/cache.controller.ts

@@ -17,7 +17,7 @@ export class CacheController {
   @ApiOperation({ summary: 'Get cache statistics' })
   @ApiResponse({ status: 200, description: 'Cache statistics retrieved successfully' })
   @ApiResponse({ status: 403, description: 'Forbidden - Admin access required' })
-  async getStats() {
+  async getStats(): Promise<Record<string, unknown>> {
     return await this.cacheService.getStats();
   }
 
@@ -27,7 +27,7 @@ export class CacheController {
   @ApiOperation({ summary: 'Clear entire cache' })
   @ApiResponse({ status: 200, description: 'Cache cleared successfully' })
   @ApiResponse({ status: 403, description: 'Forbidden - Admin access required' })
-  async resetCache() {
+  async resetCache(): Promise<{ message: string }> {
     await this.cacheService.reset();
     return { message: 'Cache cleared successfully' };
   }
@@ -38,7 +38,7 @@ export class CacheController {
   @ApiOperation({ summary: 'Invalidate cache for specific entity' })
   @ApiResponse({ status: 200, description: 'Entity cache invalidated successfully' })
   @ApiResponse({ status: 403, description: 'Forbidden - Admin access required' })
-  async invalidateEntity(entity: string) {
+  async invalidateEntity(entity: string): Promise<{ message: string }> {
     await this.cacheService.invalidateEntity(entity);
     return { message: `Cache invalidated for entity: ${entity}` };
   }
@@ -49,7 +49,7 @@ export class CacheController {
   @ApiOperation({ summary: 'Invalidate cache for specific entity action' })
   @ApiResponse({ status: 200, description: 'Entity action cache invalidated successfully' })
   @ApiResponse({ status: 403, description: 'Forbidden - Admin access required' })
-  async invalidateAction(entity: string, action: string) {
+  async invalidateAction(entity: string, action: string): Promise<{ message: string }> {
     await this.cacheService.invalidateAction(entity, action);
     return { message: `Cache invalidated for entity: ${entity}, action: ${action}` };
   }

src/cache/decorators/cache.decorator.ts

@@ -13,8 +13,8 @@ export interface CacheOptions {
 /**
  * Decorator to mark a method for caching
  */
-export const Cacheable = (options: CacheOptions) => {
-  return (target: any, propertyKey: string, descriptor: PropertyDescriptor) => {
+export const Cacheable = (options: CacheOptions): MethodDecorator => {
+  return (target: unknown, propertyKey: string, descriptor: PropertyDescriptor) => {
     SetMetadata(CACHE_KEY_METADATA, {
       key: options.key,
       entity: options.entity,
@@ -32,8 +32,8 @@ export const Cacheable = (options: CacheOptions) => {
 /**
  * Decorator to mark a method that should invalidate cache
  */
-export const CacheInvalidate = (entity: string, action?: string) => {
-  return (target: any, propertyKey: string, descriptor: PropertyDescriptor) => {
+export const CacheInvalidate = (entity: string, action?: string): MethodDecorator => {
+  return (target: unknown, propertyKey: string, descriptor: PropertyDescriptor) => {
     SetMetadata('cache_invalidate', { entity, action })(target, propertyKey, descriptor);
     return descriptor;
   };
@@ -42,8 +42,8 @@ export const CacheInvalidate = (entity: string, action?: string) => {
 /**
  * Decorator to mark a method that should clear all cache
  */
-export const CacheClear = () => {
-  return (target: any, propertyKey: string, descriptor: PropertyDescriptor) => {
+export const CacheClear = (): MethodDecorator => {
+  return (target: unknown, propertyKey: string, descriptor: PropertyDescriptor) => {
     SetMetadata('cache_clear', true)(target, propertyKey, descriptor);
     return descriptor;
   };

src/cache/interceptors/cache.interceptor.ts

@@ -6,7 +6,7 @@ import {
   Inject,
 } from '@nestjs/common';
 import { Observable, of } from 'rxjs';
-import { tap, map } from 'rxjs/operators';
+import { tap } from 'rxjs/operators';
 import { Reflector } from '@nestjs/core';
 import { CACHE_MANAGER } from '@nestjs/cache-manager';
 import { Cache } from 'cache-manager';
@@ -21,7 +21,7 @@ export class CacheInterceptor implements NestInterceptor {
     private cacheService: CacheService,
   ) {}
 
-  async intercept(context: ExecutionContext, next: CallHandler): Promise<Observable<any>> {
+  async intercept(context: ExecutionContext, next: CallHandler): Promise<Observable<unknown>> {
     const request = context.switchToHttp().getRequest();
     const handler = context.getHandler();
 
@@ -51,7 +51,7 @@ export class CacheInterceptor implements NestInterceptor {
     );
   }
 
-  private generateCacheKey(metadata: any, request: any): string {
+  private generateCacheKey(metadata: unknown, request: unknown): string {
     const { key, entity, action } = metadata;
 
     // Extract parameters from request

src/cache/tests/cache.service.spec.ts

@@ -5,8 +5,8 @@ import { CacheService } from '../cache.service';
 
 describe('CacheService', () => {
   let service: CacheService;
-  let mockCacheManager: any;
-  let mockConfigService: any;
+  let mockCacheManager: Record<string, unknown>;
+  let mockConfigService: Record<string, unknown>;
 
   beforeEach(async () => {
     mockCacheManager = {

src/common/decorators/api-response.decorator.ts

@@ -12,9 +12,9 @@ import { GlobalSuccessResponse, GlobalErrorResponse } from '../../types/global-r
 export function ApiSuccessResponse(
   status: number,
   description: string,
-  model?: Type<any>,
+  model?: Type<unknown>,
   isArray = false
-) {
+): MethodDecorator {
   const schema = model
     ? {
         allOf: [
@@ -47,7 +47,7 @@ export function ApiSuccessResponse(
  * @param status - HTTP status code
  * @param description - Error description
  */
-export function ApiErrorResponse(status: number, description: string) {
+export function ApiErrorResponse(status: number, description: string): MethodDecorator {
   return applyDecorators(
     ApiResponse({
       status,
@@ -66,8 +66,8 @@ export function ApiErrorResponse(status: number, description: string) {
 export function ApiAuthResponse(
   status: number,
   description: string,
-  model: Type<any>
-) {
+  model: Type<unknown>
+): MethodDecorator {
   return applyDecorators(
     ApiResponse({
       status,

src/common/filters/http-exception.filter.ts

@@ -10,7 +10,7 @@ import logger from '../utils/logger';
 
 @Catch()
 export class HttpExceptionFilter implements ExceptionFilter {
-  catch(exception: any, host: ArgumentsHost) {
+  catch(exception: unknown, host: ArgumentsHost): void {
     const ctx = host.switchToHttp();
     const response = ctx.getResponse<Response>();
     const request = ctx.getRequest();
@@ -29,7 +29,7 @@ export class HttpExceptionFilter implements ExceptionFilter {
       if (typeof exceptionResponse === 'string') {
         message = exceptionResponse;
       } else if (typeof exceptionResponse === 'object' && exceptionResponse !== null) {
-        message = (exceptionResponse as any).message || exception.message || message;
+        message = (exceptionResponse as { message?: string }).message || (exception as { message?: string }).message || message;
       }
     } else if (exception.message) {
       message = exception.message;

src/common/interceptors/response.interceptor.spec.ts

@@ -24,12 +24,12 @@ describe('ResponseInterceptor', () => {
           locals: {},
         }),
       }),
-    } as any;
+    } as ExecutionContext;
 
     // Mock CallHandler
     mockCallHandler = {
       handle: jest.fn(),
-    } as any;
+    } as CallHandler;
   });
 
   it('should be defined', () => {

src/common/interceptors/response.interceptor.ts

@@ -11,7 +11,7 @@ import { Response } from 'express';
 
 @Injectable()
 export class ResponseInterceptor implements NestInterceptor {
-  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
+  intercept(context: ExecutionContext, next: CallHandler): Observable<Record<string, unknown>> {
     const ctx = context.switchToHttp();
     const res = ctx.getResponse<Response>();
     const req = ctx.getRequest();
@@ -40,7 +40,7 @@ export class ResponseInterceptor implements NestInterceptor {
         const token = res?.locals?.token;
 
         // Format response with global standard
-        const formattedResponse: any = {
+        const formattedResponse: Record<string, unknown> = {
           success: true,
           data,
         };

src/dtos/ProductVariantDTO.ts

@@ -4,5 +4,5 @@ export class ProductVariantDTO {
   sku: string;
   price: number;
   stock: number;
-  attributes?: any[];
+  attributes?: Record<string, unknown>[];
 }

src/dtos/UserDTO.ts

@@ -14,16 +14,16 @@ import {
 import { ApiPropertyOptional } from '@nestjs/swagger';
 
 // Custom validator to ensure role-specific data rules
-function IsRoleSpecificData(validationOptions?: ValidationOptions) {
-  return function (object: Object, propertyName: string) {
+function IsRoleSpecificData(validationOptions?: ValidationOptions): PropertyDecorator {
+  return function (object: Record<string, unknown>, propertyName: string): void {
     registerDecorator({
       name: 'isRoleSpecificData',
       target: object.constructor,
       propertyName: propertyName,
       options: validationOptions,
       validator: {
-        validate(value: any, args: ValidationArguments) {
-          const obj = args.object as any;
+        validate(value: unknown, args: ValidationArguments): boolean {
+          const obj = args.object as Record<string, unknown>;
           const role = obj.role;
 
           if (propertyName === 'buyerData') {
@@ -89,7 +89,7 @@ export class CreateUserDto {
   @IsRoleSpecificData({ message: 'buyerData is only allowed for buyers' })
   @IsObject({ message: 'Buyer data must be an object' })
   @IsOptional()
-  buyerData?: any;
+  buyerData?: Record<string, unknown>;
 
   @ApiPropertyOptional({
     description: 'Seller-specific data (only allowed if role is seller)',
@@ -98,7 +98,7 @@ export class CreateUserDto {
   @IsRoleSpecificData({ message: 'sellerData is only allowed for sellers' })
   @IsObject({ message: 'Seller data must be an object' })
   @IsOptional()
-  sellerData?: any;
+  sellerData?: Record<string, unknown>;
 }
 
 export class UpdateUserDto {

src/middleware/async-handler.ts

@@ -1,7 +1,7 @@
 import { Request, Response, NextFunction, RequestHandler } from 'express';
 
 export const asyncHandler =
-  (fn: (req: Request, res: Response, next: NextFunction) => Promise<any>): RequestHandler =>
+  (fn: (req: Request, res: Response, next: NextFunction) => Promise<unknown>): RequestHandler =>
   (req, res, next) => {
     fn(req, res, next).catch(next);
   };

src/middleware/async.middleware.ts

@@ -2,8 +2,8 @@ import { Request, Response, NextFunction } from 'express';
 
 export default function asyncHandler(
   fn: (req: Request, res: Response, next: NextFunction) => Promise<void>
-) {
-  return (req: Request, res: Response, next: NextFunction) => {
+): (req: Request, res: Response, next: NextFunction) => void {
+  return (req: Request, res: Response, next: NextFunction): void => {
     Promise.resolve(fn(req, res, next)).catch(next);
   };
 }

src/middleware/auth.middleware.ts

@@ -2,13 +2,13 @@ import { Request, Response, NextFunction } from 'express';
 import { AuthenticatedRequest } from '../types/auth-request.type';
 import { Role } from '../types/role';
 
-export const authMiddleware = (req: Request, res: Response, next: NextFunction) => {
+export const authMiddleware = (req: Request, res: Response, next: NextFunction): void => {
   // Implementación del middleware
   next();
 };
 
 export const requireRole = (roleName: Role) => {
-  return (req: AuthenticatedRequest, res: Response, next: NextFunction) => {
+  return (req: AuthenticatedRequest, res: Response, next: NextFunction): void => {
     if (!req.user || !req.user.role.some(role => role === roleName)) {
       return res.status(403).json({ message: 'Forbidden' });
     }

src/middleware/paramValidation.middleware.ts

@@ -1,11 +1,12 @@
 import { param } from 'express-validator';
 import { validateRequest } from '../middleware/validateRequest.middleware';
+import { Request, Response, NextFunction } from 'express';
 
 export const paramValidators = {
   isPositiveInt: param('id').isInt({ min: 1 }).toInt(),
   // Agrega más validadores según sea necesario
 };
 
-export const paramValidationMiddleware = (validators: Record<string, any>) => {
+export const paramValidationMiddleware = (validators: Record<string, unknown>): ((req: Request, res: Response, next: NextFunction) => Promise<void>) => {
   return validateRequest(Object.values(validators));
 };

src/middleware/userValidation.middleware.ts

@@ -6,7 +6,7 @@ import { Request, Response, NextFunction } from 'express';
  * A validation middleware for validating request body data against a DTO class.
  * @param dtoClass The DTO class to validate against.
  */
-export function validationMiddleware(dtoClass: any) {
+export function validationMiddleware(dtoClass: new (...args: unknown[]) => unknown): (req: Request, res: Response, next: NextFunction) => Promise<void> {
   return async (req: Request, res: Response, next: NextFunction): Promise<void> => {
     const dtoInstance = plainToInstance(dtoClass, req.body);
     const errors: ValidationError[] = await validate(dtoInstance);

src/middleware/validateRequest.middleware.ts

@@ -1,8 +1,8 @@
 import { Request, Response, NextFunction } from 'express';
 import { validationResult } from 'express-validator';
 
-export const validateRequest = (validations: any[]) => {
-  return async (req: Request, res: Response, next: NextFunction) => {
+export const validateRequest = (validations: unknown[]): ((req: Request, res: Response, next: NextFunction) => Promise<void>) => {
+  return async (req: Request, res: Response, next: NextFunction): Promise<void> => {
     await Promise.all(validations.map((validation) => validation.run(req)));
 
     const errors = validationResult(req);