nestcraftx 0.2.6 → 0.3.0

package/utils/generators/infrastructure/middlewareGenerator.js

@@ -0,0 +1,645 @@
+/**
+ * utils/generators/infrastructure/middlewareGenerator.js
+ *
+ * Générateur des middlewares, interceptors, filters et decorators globaux.
+ * Extrait de utils.js — Phase 1B.
+ *
+ * Crée dans src/common/ :
+ *   - middlewares/logger.middleware.ts
+ *   - filters/all-exceptions.filter.ts  (contenu adapté selon l'ORM)
+ *   - interceptors/response.interceptor.ts
+ *   - decorators/public.decorator.ts
+ *   - decorators/current-user.decorator.ts
+ *   - decorators/role.decorator.ts
+ *
+ * Met également à jour :
+ *   - src/main.ts (imports + injection dans bootstrap)
+ *   - src/app.module.ts (providers APP_INTERCEPTOR)
+ */
+
+const { logInfo } = require("../../loggers/logInfo");
+const { logSuccess } = require("../../loggers/logSuccess");
+const { createDirectory, createFile, updateFile } = require("../../file-system");
+
+// ---------------------------------------------------------------------------
+// Contenu du filtre d'exception selon l'ORM (helper privé)
+// ---------------------------------------------------------------------------
+
+/**
+ * Génère le contenu TypeScript du filtre global d'exceptions.
+ * Adapté selon l'ORM pour capturer les erreurs spécifiques.
+ *
+ * @param {"prisma"|"mongoose"|"typeorm"|"sequelize"|string} orm
+ * @returns {string}
+ */
+function getExceptionFilterContent(orm) {
+  if (orm === "prisma") {
+    return `
+import {
+  ExceptionFilter,
+  Catch,
+  ArgumentsHost,
+  HttpException,
+  HttpStatus,
+  Logger,
+} from '@nestjs/common';
+import { Request, Response } from 'express';
+
+@Catch()
+export class AllExceptionsFilter implements ExceptionFilter {
+  private readonly logger = new Logger(AllExceptionsFilter.name);
+
+  catch(exception: unknown, host: ArgumentsHost) {
+    const ctx = host.switchToHttp();
+    const response = ctx.getResponse<Response>();
+    const request = ctx.getRequest<Request>();
+
+    let status = HttpStatus.INTERNAL_SERVER_ERROR;
+    let message: string | string[] = 'Internal server error';
+    let errorDetails: any = null;
+
+    if (exception instanceof HttpException) {
+      status = exception.getStatus();
+      const res = exception.getResponse();
+      if (typeof res === 'string') {
+        message = res;
+      } else if (typeof res === 'object' && res !== null) {
+        const resObj = res as any;
+        message = resObj.message || resObj.error || 'HttpException';
+        errorDetails = resObj;
+      }
+    } else if (
+      typeof exception === 'object' &&
+      exception &&
+      exception.constructor &&
+      (
+        exception.constructor.name === 'PrismaClientKnownRequestError' ||
+        exception.constructor.name === 'PrismaClientValidationError'
+      )
+    ) {
+      status = HttpStatus.BAD_REQUEST;
+      message = (exception as any).message || 'Prisma error';
+      errorDetails = exception;
+    } else if (exception instanceof Error) {
+      message = exception.message;
+      errorDetails = {
+        name: exception.name,
+        stack: exception.stack,
+      };
+    } else {
+      message = 'Une erreur inattendue est survenue';
+      errorDetails = exception;
+    }
+
+    if (process.env.NODE_ENV !== 'production') {
+      this.logger.error(
+        \`Exception on \${request.method} \${request.url}\`,
+        JSON.stringify({ message, status, errorDetails, exception }),
+      );
+    }
+
+    response.status(status).json({
+      statusCode: status,
+      timestamp: new Date().toISOString(),
+      path: request.url,
+      method: request.method,
+      message,
+      error: errorDetails,
+    });
+  }
+}
+`.trim();
+  }
+
+  if (orm === "mongoose") {
+    return `
+import {
+  ExceptionFilter,
+  Catch,
+  ArgumentsHost,
+  HttpException,
+  HttpStatus,
+  Logger,
+} from '@nestjs/common';
+import { Request, Response } from 'express';
+
+@Catch()
+export class AllExceptionsFilter implements ExceptionFilter {
+  private readonly logger = new Logger(AllExceptionsFilter.name);
+
+  catch(exception: unknown, host: ArgumentsHost) {
+    const ctx = host.switchToHttp();
+    const response = ctx.getResponse<Response>();
+    const request = ctx.getRequest<Request>();
+
+    let status = HttpStatus.INTERNAL_SERVER_ERROR;
+    let message: string | string[] = 'Internal server error';
+    let errorDetails: any = null;
+
+    if (exception instanceof HttpException) {
+      status = exception.getStatus();
+      const res = exception.getResponse();
+      if (typeof res === 'string') {
+        message = res;
+      } else if (typeof res === 'object' && res !== null) {
+        const resObj = res as any;
+        message = resObj.message || resObj.error || 'HttpException';
+        errorDetails = resObj;
+      }
+    } else if (
+      typeof exception === 'object' &&
+      exception &&
+      'name' in exception &&
+      (
+        (exception as any).name === 'MongoError' ||
+        (exception as any).name === 'MongooseError'
+      )
+    ) {
+      status = HttpStatus.BAD_REQUEST;
+      message = (exception as any).message || 'MongoDB error';
+      errorDetails = exception;
+    } else if (exception instanceof Error) {
+      message = exception.message;
+      errorDetails = {
+        name: exception.name,
+        stack: exception.stack,
+      };
+    } else {
+      message = 'Une erreur inattendue est survenue';
+      errorDetails = exception;
+    }
+
+    if (process.env.NODE_ENV !== 'production') {
+      this.logger.error(
+        \`Exception on \${request.method} \${request.url}\`,
+        JSON.stringify({ message, status, errorDetails, exception }),
+      );
+    }
+
+    response.status(status).json({
+      statusCode: status,
+      timestamp: new Date().toISOString(),
+      path: request.url,
+      method: request.method,
+      message,
+      error: errorDetails,
+    });
+  }
+}
+`.trim();
+  }
+
+  if (orm === "typeorm") {
+    return `
+import {
+  ExceptionFilter,
+  Catch,
+  ArgumentsHost,
+  HttpException,
+  HttpStatus,
+  Logger,
+} from '@nestjs/common';
+import { Request, Response } from 'express';
+
+@Catch()
+export class AllExceptionsFilter implements ExceptionFilter {
+  private readonly logger = new Logger(AllExceptionsFilter.name);
+
+  catch(exception: unknown, host: ArgumentsHost) {
+    const ctx = host.switchToHttp();
+    const response = ctx.getResponse<Response>();
+    const request = ctx.getRequest<Request>();
+
+    let status = HttpStatus.INTERNAL_SERVER_ERROR;
+    let message: string | string[] = 'Internal server error';
+    let errorDetails: any = null;
+
+    if (exception instanceof HttpException) {
+      status = exception.getStatus();
+      const res = exception.getResponse();
+      if (typeof res === 'string') {
+        message = res;
+      } else if (typeof res === 'object' && res !== null) {
+        const resObj = res as any;
+        message = resObj.message || resObj.error || 'HttpException';
+        errorDetails = resObj;
+      }
+    } else if (
+      typeof exception === 'object' &&
+      exception &&
+      'name' in exception &&
+      (
+        (exception as any).name === 'QueryFailedError' ||
+        (exception as any).name === 'EntityNotFoundError' ||
+        (exception as any).name === 'CannotCreateEntityIdMapError'
+      )
+    ) {
+      status = HttpStatus.BAD_REQUEST;
+      message = (exception as any).message || 'TypeORM error';
+      errorDetails = exception;
+    } else if (exception instanceof Error) {
+      message = exception.message;
+      errorDetails = {
+        name: exception.name,
+        stack: exception.stack,
+      };
+    } else {
+      message = 'Une erreur inattendue est survenue';
+      errorDetails = exception;
+    }
+
+    if (process.env.NODE_ENV !== 'production') {
+      this.logger.error(
+        \`Exception on \${request.method} \${request.url}\`,
+        JSON.stringify({ message, status, errorDetails, exception }),
+      );
+    }
+
+    response.status(status).json({
+      statusCode: status,
+      timestamp: new Date().toISOString(),
+      path: request.url,
+      method: request.method,
+      message,
+      error: errorDetails,
+    });
+  }
+}
+`.trim();
+  }
+
+  if (orm === "sequelize") {
+    return `
+import {
+  ExceptionFilter,
+  Catch,
+  ArgumentsHost,
+  HttpException,
+  HttpStatus,
+  Logger,
+} from '@nestjs/common';
+import { Request, Response } from 'express';
+
+@Catch()
+export class AllExceptionsFilter implements ExceptionFilter {
+  private readonly logger = new Logger(AllExceptionsFilter.name);
+
+  catch(exception: unknown, host: ArgumentsHost) {
+    const ctx = host.switchToHttp();
+    const response = ctx.getResponse<Response>();
+    const request = ctx.getRequest<Request>();
+
+    let status = HttpStatus.INTERNAL_SERVER_ERROR;
+    let message: string | string[] = 'Internal server error';
+    let errorDetails: any = null;
+
+    if (exception instanceof HttpException) {
+      status = exception.getStatus();
+      const res = exception.getResponse();
+      if (typeof res === 'string') {
+        message = res;
+      } else if (typeof res === 'object' && res !== null) {
+        const resObj = res as any;
+        message = resObj.message || resObj.error || 'HttpException';
+        errorDetails = resObj;
+      }
+    } else if (
+      typeof exception === 'object' &&
+      exception &&
+      exception.constructor &&
+      (
+        exception.constructor.name === 'SequelizeDatabaseError' ||
+        exception.constructor.name === 'SequelizeValidationError'
+      )
+    ) {
+      status = HttpStatus.BAD_REQUEST;
+      message = (exception as any).message || 'Sequelize error';
+      errorDetails = exception;
+    } else if (exception instanceof Error) {
+      message = exception.message;
+      errorDetails = {
+        name: exception.name,
+        stack: exception.stack,
+      };
+    } else {
+      message = 'Une erreur inattendue est survenue';
+      errorDetails = exception;
+    }
+
+    if (process.env.NODE_ENV !== 'production') {
+      this.logger.error(
+        \`Exception on \${request.method} \${request.url}\`,
+        JSON.stringify({ message, status, errorDetails, exception }),
+      );
+    }
+
+    response.status(status).json({
+      statusCode: status,
+      timestamp: new Date().toISOString(),
+      path: request.url,
+      method: request.method,
+      message,
+      error: errorDetails,
+    });
+  }
+}
+`.trim();
+  }
+
+  // Version universelle (multi-ORM / fallback)
+  return `
+import {
+  ExceptionFilter,
+  Catch,
+  ArgumentsHost,
+  HttpException,
+  HttpStatus,
+  Logger,
+} from '@nestjs/common';
+import { Request, Response } from 'express';
+
+@Catch()
+export class AllExceptionsFilter implements ExceptionFilter {
+  private readonly logger = new Logger(AllExceptionsFilter.name);
+
+  catch(exception: unknown, host: ArgumentsHost) {
+    const ctx = host.switchToHttp();
+    const response = ctx.getResponse<Response>();
+    const request = ctx.getRequest<Request>();
+
+    let status = HttpStatus.INTERNAL_SERVER_ERROR;
+    let message: string | string[] = 'Internal server error';
+    let errorDetails: any = null;
+
+    if (exception instanceof HttpException) {
+      status = exception.getStatus();
+      const res = exception.getResponse();
+      if (typeof res === 'string') {
+        message = res;
+      } else if (typeof res === 'object' && res !== null) {
+        const resObj = res as any;
+        message = resObj.message || resObj.error || 'HttpException';
+        errorDetails = resObj;
+      }
+    }
+    // Prisma
+    else if (
+      typeof exception === 'object' &&
+      exception &&
+      exception.constructor &&
+      (
+        exception.constructor.name === 'PrismaClientKnownRequestError' ||
+        exception.constructor.name === 'PrismaClientValidationError'
+      )
+    ) {
+      status = HttpStatus.BAD_REQUEST;
+      message = (exception as any).message || 'Prisma error';
+      errorDetails = exception;
+    }
+    // Mongoose/Mongo
+    else if (
+      typeof exception === 'object' &&
+      exception &&
+      'name' in exception &&
+      (
+        (exception as any).name === 'MongoError' ||
+        (exception as any).name === 'MongooseError'
+      )
+    ) {
+      status = HttpStatus.BAD_REQUEST;
+      message = (exception as any).message || 'MongoDB error';
+      errorDetails = exception;
+    }
+    // Sequelize
+    else if (
+      typeof exception === 'object' &&
+      exception &&
+      exception.constructor &&
+      (
+        exception.constructor.name === 'SequelizeDatabaseError' ||
+        exception.constructor.name === 'SequelizeValidationError'
+      )
+    ) {
+      status = HttpStatus.BAD_REQUEST;
+      message = (exception as any).message || 'Sequelize error';
+      errorDetails = exception;
+    }
+    else if (exception instanceof Error) {
+      message = exception.message;
+      errorDetails = {
+        name: exception.name,
+        stack: exception.stack,
+      };
+    } else {
+      message = 'Une erreur inattendue est survenue';
+      errorDetails = exception;
+    }
+
+    this.logger.error(
+      \`Exception on \${request.method} \${request.url}\`,
+      JSON.stringify({ message, status, errorDetails, exception }),
+    );
+
+    response.status(status).json({
+      statusCode: status,
+      timestamp: new Date().toISOString(),
+      path: request.url,
+      method: request.method,
+      message,
+      error: errorDetails,
+    });
+  }
+}
+`.trim();
+}
+
+// ---------------------------------------------------------------------------
+// Fonction principale
+// ---------------------------------------------------------------------------
+
+/**
+ * Génère et écrit tous les middlewares, interceptors, filters et decorators.
+ * Met également à jour src/main.ts et src/app.module.ts.
+ *
+ * @param {"prisma"|"mongoose"|"typeorm"|"sequelize"|"global"} orm
+ * @returns {Promise<void>}
+ */
+async function generateMiddlewares(orm = "global") {
+  logInfo(
+    "\u2728 Génération des middlewares, interceptors, guards et filters personnalisés...",
+  );
+
+  const basePath = "src/common";
+  await createDirectory(`${basePath}/middlewares`);
+  await createDirectory(`${basePath}/interceptors`);
+  await createDirectory(`${basePath}/filters`);
+  await createDirectory(`${basePath}/decorators`);
+
+  // Logger Middleware
+  await createFile({
+    path: `${basePath}/middlewares/logger.middleware.ts`,
+    contente: `import { Request, Response, NextFunction } from 'express';
+
+export function LoggerMiddleware(
+  req: Request,
+  res: Response,
+  next: NextFunction,
+) {
+  if (process.env.NODE_ENV === 'production') {
+    return next();
+  }
+
+  res.on('finish', () => {
+    console.log(
+      \`[Request] \${req.method} \${req.originalUrl} - \${res.statusCode}\`,
+    );
+  });
+
+  next();
+}
+`,
+  });
+
+  // Error Handling Filter (personnalisé selon l'ORM)
+  await createFile({
+    path: `${basePath}/filters/all-exceptions.filter.ts`,
+    contente: getExceptionFilterContent(orm),
+  });
+
+  // Response Interceptor
+  await createFile({
+    path: `${basePath}/interceptors/response.interceptor.ts`,
+    contente: `import {
+  CallHandler,
+  ExecutionContext,
+  Injectable,
+  NestInterceptor,
+} from '@nestjs/common';
+import { Observable } from 'rxjs';
+import { map } from 'rxjs/operators';
+
+@Injectable()
+export class ResponseInterceptor<T> implements NestInterceptor<T, any> {
+  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
+    const httpContext = context.switchToHttp();
+    const response = httpContext.getResponse();
+    const request = httpContext.getRequest();
+
+    return next.handle().pipe(
+      map((data) => {
+        const message =
+          response.locals.message || this.getDefaultMessage(request.method);
+
+        return {
+          statusCode: response.statusCode,
+          message,
+          path: request.url,
+          method: request.method,
+          timestamp: new Date().toISOString(),
+          data: data ?? null,
+        };
+      }),
+    );
+  }
+
+  private getDefaultMessage(method: string): string {
+    switch (method.toUpperCase()) {
+      case 'POST':
+        return 'Resource created successfully';
+      case 'PUT':
+      case 'PATCH':
+        return 'Resource updated successfully';
+      case 'DELETE':
+        return 'Resource deleted successfully';
+      case 'GET':
+        return 'Request processed successfully';
+      default:
+        return 'Request processed successfully';
+    }
+  }
+}
+`,
+  });
+
+  // Public Decorator
+  await createFile({
+    path: `${basePath}/decorators/public.decorator.ts`,
+    contente: `import { SetMetadata } from '@nestjs/common';
+
+export const IS_PUBLIC_KEY = 'isPublic';
+export const Public = () => SetMetadata(IS_PUBLIC_KEY, true);
+`,
+  });
+
+  await createFile({
+    path: `${basePath}/decorators/current-user.decorator.ts`,
+    contente: `import { createParamDecorator, ExecutionContext } from '@nestjs/common';\nexport const CurrentUser = createParamDecorator((data, ctx: ExecutionContext) => ctx.switchToHttp().getRequest().user);`,
+  });
+
+  // Auth Role Decorator
+  await createFile({
+    path: `${basePath}/decorators/role.decorator.ts`,
+    contente: `import { SetMetadata } from '@nestjs/common';
+
+export const ROLES_KEY = 'roles';
+export const Roles = (...roles: string[]) => SetMetadata('roles', roles);
+`,
+  });
+
+  // Mise à jour de main.ts
+  const mainTsPath = "src/main.ts";
+
+  const importPattern = "import { AppModule } from './app.module';";
+  const importReplacer = `import { AppModule } from 'src/app.module'
+import { AllExceptionsFilter } from 'src/common/filters/all-exceptions.filter'
+import { ResponseInterceptor } from 'src/common/interceptors/response.interceptor'
+import { LoggerMiddleware } from 'src/common/middlewares/logger.middleware'
+import { ValidationPipe } from '@nestjs/common';`;
+
+  const contentPattern = `const app = await NestFactory.create(AppModule);`;
+  const contentReplacer = `
+  const app = await NestFactory.create(AppModule);
+
+  // 🔒 Global filter pour gérer toutes les exceptions
+  app.useGlobalFilters(new AllExceptionsFilter())
+
+  // 🔁 Global interceptor pour structurer les réponses
+  // app.useGlobalInterceptors(new ResponseInterceptor()); //deja appliquer dans le app.module.ts par convention (ne choisir que l'un des deux)
+
+  // 📋 Middleware pour logger toutes les requêtes entrantes
+  app.use(LoggerMiddleware);`;
+
+  await updateFile({
+    path: mainTsPath,
+    pattern: importPattern,
+    replacement: importReplacer,
+  });
+
+  await updateFile({
+    path: mainTsPath,
+    pattern: contentPattern,
+    replacement: contentReplacer,
+  });
+
+  // Mise à jour de app.module.ts
+  const appModulePath = "src/app.module.ts";
+
+  const addNestModuleInterface = `providers: [`;
+  const replaceWithNestModule = `providers: [
+    {
+      provide: APP_INTERCEPTOR,
+      useClass: ResponseInterceptor,   // 🔁 Global interceptor pour structurer les réponses
+    },`;
+
+  await updateFile({
+    path: appModulePath,
+    pattern: addNestModuleInterface,
+    replacement: replaceWithNestModule,
+  });
+
+  logSuccess(
+    "\u2705 Middlewares, filters, interceptors et guards générés avec succès !",
+  );
+}
+
+module.exports = { generateMiddlewares };