nestcraftx 0.1.8 → 0.1.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nestcraftx",
-  "version": "0.1.8",
+  "version": "0.1.9",
   "description": "CLI to generate scalable NestJS projects with Clean Architecture and Clean Code",
   "main": "bin/nestcraft.js",
   "bin": {

package/utils/configs/setupCleanArchitecture.js

@@ -148,7 +148,7 @@ export class Create${entityName}UseCase {
     this.logger.log('Début création ${entityName}');
     try {
       const result = await this.${entityNameLower}Repository.create(data);
-      this.logger.log('Création réussie');
+      this.logger.log('Création réussie: ', result.getId());
       return result;
     } catch (error) {
       this.logger.error('Erreur lors de la création', error.stack);
@@ -176,7 +176,7 @@ export class GetById${entityName}UseCase {
   ) {}
 
   async execute(id: string): Promise<${entityName}Entity | null> {
-    this.logger.log(\`Recherche de ${entityName} par id: \${id}\`);
+    // this.logger.log(\`Recherche de ${entityName} par id: \${id}\`);
     try {
       const result = await this.${entityNameLower}Repository.findById(id);
       this.logger.log('Recherche réussie');
@@ -207,7 +207,7 @@ export class GetAll${entityName}UseCase {
   ) {}
 
   async execute(): Promise<${entityName}Entity[]> {
-    this.logger.log('Récupération de tous les ${entityName}s');
+    // this.logger.log('Récupération de tous les ${entityName}s');
     try {
       const result = await this.${entityNameLower}Repository.findAll();
       this.logger.log('Récupération réussie');
@@ -239,8 +239,15 @@ export class Update${entityName}UseCase {
   ) {}
 
   async execute(id: string, data: Update${entityName}Dto): Promise<${entityName}Entity | null> {
-    this.logger.log(\`Mise à jour de ${entityName} id: \${id}\`);
+    // this.logger.log(\`Mise à jour de ${entityName} id: \${id}\`);
+
     try {
+      // Vérifier l'existence de l'élément
+      const existing = await this.${entityNameLower}Repository.findById(id);
+      if (!existing) {
+        this.logger.warn(\`${entityName} avec l'id \${id} non trouvé pour la mise à jour\`);
+        throw new Error('${entityName} non trouvé');
+      }
       const result = await this.${entityNameLower}Repository.update(id, data);
       this.logger.log('Mise à jour réussie');
       return result;
@@ -269,8 +276,14 @@ export class Delete${entityName}UseCase {
   ) {}
 
   async execute(id: string): Promise<void> {
-    this.logger.log(\`Suppression de ${entityName} id: \${id}\`);
+    // this.logger.log(\`Suppression de ${entityName} id: \${id}\`);
     try {
+      // Vérifier l'existence de l'élément
+      const existing = await this.${entityNameLower}Repository.findById(id);
+      if (!existing) {
+        this.logger.warn(\`${entityName} avec l'id \${id} non trouvé !\`);
+        throw new Error('${entityName} non trouvé');
+      }
       await this.${entityNameLower}Repository.delete(id);
       this.logger.log('Suppression réussie');
     } catch (error) {
@@ -490,7 +503,7 @@ import { ${entityNameCapitalized}Mapper } from '${entityPath}/domain/mappers/${e
     ${providersBlock.join(",\n    ")}
   ],
   exports: [
-    ${entityNameCapitalized}Service
+    ${entityNameCapitalized}Service, 'I${entityNameCapitalized}Repository'
   ]
 })
 export class ${entityNameCapitalized}Module {}
@@ -499,7 +512,8 @@ export class ${entityNameCapitalized}Module {}
 
       await safeUpdateAppModule(entityNameLower);
     }
-    await generateMiddlewares();
+
+    await generateMiddlewares(dbConfig.orm);
 
     // modification de AppModule
     const appModulePath = "src/app.module.ts";

package/utils/setups/projectSetup.js

@@ -21,7 +21,7 @@ async function createProject(inputs) {
   // installation des dependances
   logInfo("Installation des dépendances...");
   await runCommand(
-    `${inputs.packageManager} add @nestjs/config @nestjs/typeorm typeorm pg class-validator class-transformer`,
+    `${inputs.packageManager} add @nestjs/config class-validator class-transformer`,
     "Échec de l'installation des dépendances"
   );
 }

package/utils/setups/setupAuth.js

@@ -12,11 +12,11 @@ async function setupAuth(inputs) {
   const useSwagger = inputs.useSwagger;
 
   await runCommand(
-    `npm install @nestjs/jwt @nestjs/passport passport passport-jwt bcrypt`,
+    `npm install @nestjs/jwt @nestjs/passport passport passport-jwt bcrypt uuid`,
     "Échec de l'installation des dépendances d'authentification"
   );
   await runCommand(
-    `npm install -D @types/passport-jwt @types/bcrypt`,
+    `npm install -D @types/passport-jwt @types/bcrypt @types/uuid`,
     "Échec de l'installation des dépendances de dev"
   );
 
@@ -41,12 +41,11 @@ async function setupAuth(inputs) {
   if (dbConfig.orm === "typeorm") {
     ormImports = `import { TypeOrmModule } from '@nestjs/typeorm';
 import { User } from 'src/entities/User.entity';`;
-    ormModuleImport = `TypeOrmModule.forFeature([User]),`;
-    prismaProvider = "PrismaService,";
+    ormModuleImport = `TypeOrmModule.forFeature([User])`;
   } else if (dbConfig.orm === "mongoose") {
     ormImports = `import { MongooseModule } from '@nestjs/mongoose';
 import { User, UserSchema } from 'src/user/domain/entities/user.schema';`;
-    ormModuleImport = `MongooseModule.forFeature([{ name: User.name, schema: UserSchema }]),`;
+    ormModuleImport = `MongooseModule.forFeature([{ name: User.name, schema: UserSchema }])`;
     prismaProvider = ""; // Ne pas ajouter PrismaService
   } else if (dbConfig.orm === "prisma") {
     ormImports = "";
@@ -58,9 +57,9 @@ import { User, UserSchema } from 'src/user/domain/entities/user.schema';`;
     path: `${authPath}/auth.module.ts`,
     contente: `
 import { Module } from '@nestjs/common';
-import { JwtModule } from '@nestjs/jwt';
+import { JwtModule, JwtService } from '@nestjs/jwt';
 import { PassportModule } from '@nestjs/passport';
-import { UserMapper } from 'src/user/domain/mappers/user.mapper';
+// import { UserMapper } from 'src/user/domain/mappers/user.mapper';
 ${ormImports}
 import { AuthService } from '${authPaths.authServicesPath}/auth.service';
 ${
@@ -71,13 +70,14 @@ ${
 import { AuthController } from '${
       authPaths.authControllersPath
     }/auth.controller';
+import { UserModule } from 'src/user/user.module';
 import { JwtStrategy } from '${authPaths.authStrategyPath}/jwt.strategy';
 import { AuthGuard } from '${authPaths.authGuardsPath}/auth.guard';
-import { UserRepository } from 'src/user/infrastructure/repositories/user.repository';
 
 @Module({
   imports: [
-    ${ormModuleImport}
+   UserModule,
+    ${ormModuleImport},
     PassportModule,
     JwtModule.register({ secret: 'your-secret-key', signOptions: { expiresIn: '1h' } }),
   ],
@@ -86,7 +86,8 @@ import { UserRepository } from 'src/user/infrastructure/repositories/user.reposi
     ${prismaProvider}
     AuthService,
     JwtStrategy,
-    AuthGuard
+    AuthGuard,
+    JwtService
   ],
   exports: [AuthService],
 })

package/utils/setups/setupMongoose.js

@@ -34,7 +34,7 @@ MONGO_DB=${inputs.dbConfig.MONGO_DB}
     pattern: importsPattern,
     replacement: (match) =>
       `${match}
-    MongooseModule.forRoot(process.env.MONGO_URI, {
+    MongooseModule.forRoot(process.env.MONGO_URI || " ", {
       dbName: process.env.MONGO_DB,
     }),`,
   });

package/utils/setups/setupPrisma.js

@@ -110,29 +110,117 @@ model ${entity.name} {
         new RegExp(`model ${from} \\{`),
         (match) => {
           if (type === "1-n") {
-            return `${match}\n  ${to}s ${to}[]`;
-          } else if (type === "1-1") {
-            /*             return `${match}\n  ${to} ${to}? @relation(fields: [${to}Id], references: [id])\n  ${to}Id String?`;
-             */
-            return `${match}\n  ${to} ${to}? @relation(fields: [${to}Id], references: [id])\n  ${to}Id String? @unique`;
-          } else if (type === "n-n") {
-            return `${match}\n  ${to}s ${to}[]`;
+            // Côté "one" (source) : ajoute la liste
+            schemaContent = schemaContent.replace(
+              new RegExp(`model ${from} {([\\s\\S]*?)}`),
+              (match) => {
+                const fieldLine = `${to}s ${to}[]`;
+                return match.includes(fieldLine)
+                  ? match
+                  : `${match}\n  ${fieldLine}`;
+              }
+            );
+            // Côté "many" (cible) : ajoute la relation et la clé étrangère si absente
+            schemaContent = schemaContent.replace(
+              new RegExp(`model ${to} {([\\s\\S]*?)}`),
+              (match) => {
+                const relationLine = `${from} ${from} @relation(fields: [${from}Id], references: [id])`;
+                const fkLine = `${from}Id String`;
+                let result = match.includes(relationLine)
+                  ? match
+                  : `${match}\n  ${relationLine}`;
+                result = result.includes(fkLine)
+                  ? result
+                  : `${result}\n  ${fkLine}`;
+                return result;
+              }
+            );
           }
-          return match;
-        }
-      );
 
-      // Mise à jour du modèle cible
-      schemaContent = schemaContent.replace(
-        new RegExp(`model ${to} \\{`),
-        (match) => {
-          if (type === "1-n") {
-            return `${match}\n  ${from} ${from} @relation(fields: [${from}Id], references: [id])\n  ${from}Id String`;
-          } else if (type === "1-1") {
-            return `${match}\n  ${from} ${from}?`;
-          } else if (type === "n-n") {
-            return `${match}\n  ${from}s ${from}[]`;
+          if (type === "n-1") {
+            // Côté "many" (source) : ajoute la relation et la clé étrangère si absente
+            schemaContent = schemaContent.replace(
+              new RegExp(`model ${from} {([\\s\\S]*?)}`),
+              (match) => {
+                const relationLine = `${to} ${to} @relation(fields: [${to}Id], references: [id])`;
+                const fkLine = `${to}Id String`;
+                let result = match.includes(relationLine)
+                  ? match
+                  : `${match}\n  ${relationLine}`;
+                result = result.includes(fkLine)
+                  ? result
+                  : `${result}\n  ${fkLine}`;
+                return result;
+              }
+            );
+            // Côté "one" (cible) : ajoute la liste
+            schemaContent = schemaContent.replace(
+              new RegExp(`model ${to} {([\\s\\S]*?)}`),
+              (match) => {
+                const fieldLine = `${from}s ${from}[]`;
+                return match.includes(fieldLine)
+                  ? match
+                  : `${match}\n  ${fieldLine}`;
+              }
+            );
           }
+
+          if (type === "1-1") {
+            // Côté A
+            schemaContent = schemaContent.replace(
+              new RegExp(`model ${from} {([\\s\\S]*?)}`),
+              (match) => {
+                const relationLine = `${to} ${to} @relation(fields: [${to}Id], references: [id])`;
+                const fkLine = `${to}Id String @unique`;
+                let result = match.includes(relationLine)
+                  ? match
+                  : `${match}\n  ${relationLine}`;
+                result = result.includes(fkLine)
+                  ? result
+                  : `${result}\n  ${fkLine}`;
+                return result;
+              }
+            );
+            // Côté B
+            schemaContent = schemaContent.replace(
+              new RegExp(`model ${to} {([\\s\\S]*?)}`),
+              (match) => {
+                const relationLine = `${from} ${from}? @relation(fields: [${from}Id], references: [id])`;
+                const fkLine = `${from}Id String? @unique`;
+                let result = match.includes(relationLine)
+                  ? match
+                  : `${match}\n  ${relationLine}`;
+                result = result.includes(fkLine)
+                  ? result
+                  : `${result}\n  ${fkLine}`;
+                return result;
+              }
+            );
+          }
+
+          if (type === "n-n" || type === "m-n") {
+            // Pour n-n, généralement, il faut créer une table de jointure à la main.
+            // Ici, on ajoute juste les listes de chaque côté si absentes.
+            schemaContent = schemaContent.replace(
+              new RegExp(`model ${from} {([\\s\\S]*?)}`),
+              (match) => {
+                const fieldLine = `${to}s ${to}[]`;
+                return match.includes(fieldLine)
+                  ? match
+                  : `${match}\n  ${fieldLine}`;
+              }
+            );
+            schemaContent = schemaContent.replace(
+              new RegExp(`model ${to} {([\\s\\S]*?)}`),
+              (match) => {
+                const fieldLine = `${from}s ${from}[]`;
+                return match.includes(fieldLine)
+                  ? match
+                  : `${match}\n  ${fieldLine}`;
+              }
+            );
+          }
+
           return match;
         }
       );

package/utils/userInput.js

@@ -244,6 +244,33 @@ export async function getUserInputs2() {
         type: relType,
       });
 
+      if (relType === "1-1") {
+        from.fields.push({
+          name: `${to.name.toLowerCase()}Id`,
+          type: "string",
+        });
+        to.fields.push({
+          name: `${from.name.toLowerCase()}Id`,
+          type: "string",
+        });
+      } else if (relType === "1-n") {
+        to.fields.push({
+          name: `${from.name.toLowerCase()}Id`,
+          type: "string",
+        }); // ex: video.userId
+        // pas de champ inverse dans from (user)
+      } else if (relType === "n-n") {
+        // pour n-n tu peux gérer ça plus tard avec une table pivot
+        from.fields.push({
+          name: `${to.name.toLowerCase()}Ids`,
+          type: "string[]",
+        });
+        to.fields.push({
+          name: `${from.name.toLowerCase()}Ids`,
+          type: "string[]",
+        });
+      }
+
       const again = readline.keyInYNStrict("Ajouter une autre relation ?");
       if (!again) break;
     }

package/utils/utils.js

@@ -198,6 +198,9 @@ export async function generateDto(entity, useSwagger, isAuthDto = false) {
     if (fieldName.includes("discount")) {
       return 10;
     }
+    if (fieldName.includes("Id")) {
+      return "UID-exemple-4f06-bd56-f4021b541c57";
+    }
 
     // 🛠 Sinon fallback basique selon le type
     switch (f.type) {
@@ -249,6 +252,11 @@ ${
     ? "import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';"
     : ""
 }
+${
+  entityName == "User"
+    ? "import { Role } from 'src/user/domain/enums/role.enum';"
+    : ""
+}
 `;
 
   // ✅ Cas AUTH DTO : une seule classe + nom déjà donné (pas de Create/Update)
@@ -266,8 +274,6 @@ ${dtoFields}
   return `
 ${commonImports}
 
-// Vous pouvez décommenter ce champ si vous voulez gérer le rôle de l'utilisateur.
-import { Role } from 'src/user/domain/enums/role.enum';
 
 export class Create${entityName}Dto {
 ${dtoFields}
@@ -382,7 +388,7 @@ export class ${entityNameCapitalized}Controller {
 `;
 }
 
-export async function generateMiddlewares() {
+export async function generateMiddlewares(orm = "global") {
   logInfo(
     "\u2728 G\u00e9n\u00e9ration des middlewares, interceptors, guards et filters personnalis\u00e9s..."
   );
@@ -409,8 +415,13 @@ export function LoggerMiddleware(
 `,
   });
 
-  // Error Handling Filter
+  // Error Handling Filter (personnalisé selon l'ORM)
   await createFile({
+    path: `${basePath}/filters/all-exceptions.filter.ts`,
+    contente: getExceptionFilterContent(orm),
+  });
+  // Error Handling Filter
+  /*  await createFile({
     path: `${basePath}/filters/all-exceptions.filter.ts`,
     contente: `import {
   ExceptionFilter,
@@ -418,29 +429,118 @@ export function LoggerMiddleware(
   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>();
-    const status = exception instanceof HttpException ? exception.getStatus() : HttpStatus.INTERNAL_SERVER_ERROR;
 
-    const message = exception instanceof HttpException ? exception.getResponse() : 'Internal server error';
-    console.log('exception: ', exception);
+    let status = HttpStatus.INTERNAL_SERVER_ERROR;
+    let message: string | string[] = 'Internal server error';
+    let errorDetails: any = null;
+
+    // Handle NestJS HttpExceptions (BadRequest, NotFound, etc.)
+    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;
+      }
+    }
+
+    // Handle Prisma errors dynamiquement (sans import bloquant)
+    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;
+    }
+
+    // Handle Mongoose/Mongo errors dynamiquement
+    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;
+    }
+
+    // Handle Sequelize errors dynamiquement
+    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;
+    }
+
+    // Handle unknown errors
+    else if (exception instanceof Error) {
+      message = exception.message;
+      errorDetails = {
+        name: exception.name,
+        stack: exception.stack,
+      };
+    } else {
+      message = 'Une erreur inattendue est survenue';
+      errorDetails = exception;
+    }
+
+    // Log the full exception on the server
+    this.logger.error(
+      \`Exception on \${request.method} \${request.url}\`,
+      JSON.stringify({
+        message,
+        status,
+        errorDetails,
+        exception,
+      }),
+    );
 
+    // Send clean error to client
     response.status(status).json({
       statusCode: status,
       timestamp: new Date().toISOString(),
       path: request.url,
-      message: message,
+      method: request.method,
+      message,
+      error: errorDetails,
     });
   }
-}`,
-  });
+}
+`,
+  }); */
 
   // Response Interceptor
   await createFile({
@@ -521,18 +621,19 @@ export const Roles = (...roles: string[]) => SetMetadata('roles', roles);
 
   // ✅ 1. Mise à jour des imports
   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';
+  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';`;
 
   // ✅ 2. Injection dans le contenu de bootstrap()
   const contentPattern = `const app = await NestFactory.create(AppModule);`;
-  const contentReplacer = `const app = await NestFactory.create(AppModule);
+
+  const contentReplacer = `
 
   // 🔒 Global filter pour gérer toutes les exceptions
-  app.useGlobalFilters(new AllExceptionsFilter());
+  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)
@@ -717,7 +818,7 @@ export class ${entityNameCapitalized}Repository implements I${entityNameCapitali
         contente: `import { Injectable, NotFoundException } from '@nestjs/common';
 import { InjectModel } from '@nestjs/mongoose';
 import { Model } from 'mongoose';
-import { UserEntity } from '${entityPath}/domain/entities/${entityNameLower}.entity';
+import { ${entityNameCapitalized}Entity } from '${entityPath}/domain/entities/${entityNameLower}.entity';
 import { Create${entityNameCapitalized}Dto, Update${entityNameCapitalized}Dto } from 'src/${entityNameLower}/application/dtos/${entityNameLower}.dto';
 import { I${entityNameCapitalized}Repository } from 'src/${entityNameLower}/application/interfaces/${entityNameLower}.repository.interface';
 import { ${entityNameCapitalized} } from 'src/${entityNameLower}/domain/entities/${entityNameLower}.schema';
@@ -882,3 +983,417 @@ function getFormattedType(field) {
   }
   return formatType(field.type);
 }
+
+// Génère le contenu du filtre d'exception selon l'ORM
+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;
+    }
+
+    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;
+    }
+
+    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;
+    }
+
+    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;
+    }
+
+    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)
+  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();
+}