nestcraftx 0.1.5 → 0.1.7

package/package.json

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

package/setup.js

@@ -10,6 +10,7 @@ const { createProject } = require("./utils/setups/projectSetup");
 const { setupAuth } = require("./utils/setups/setupAuth");
 const { setupSwagger } = require("./utils/setups/setupSwagger");
 const { setupDatabase } = require("./utils/setups/setupDatabase");
+const { setupBootstrapLogger } = require("./utils/setups/setupLogger");
 
 async function main() {
   const inputs = await getUserInputs2();
@@ -17,8 +18,12 @@ async function main() {
   await createProject(inputs);
   await setupCleanArchitecture(inputs);
 
-  if (inputs.useAuth) await setupAuth();
-  if (inputs.useSwagger) await setupSwagger(inputs.swaggerInputs);
+  if (inputs.useAuth) await setupAuth(inputs);
+  if (inputs.useSwagger) {
+    await setupSwagger(inputs.swaggerInputs);
+  } else {
+    setupBootstrapLogger();
+  }
   if (inputs.useDocker) await configureDocker(inputs);
 
   // await setupPrisma(inputs);

package/unutils.txt

@@ -171,3 +171,80 @@ export class ${entityNameCapitalized}Repository implements I${entityNameCapitali
   }
 }
 `
+
+
+`
+/**
+ * ${entityNameCapitalized}Controller gère les endpoints de l'API pour l'entité ${entityNameCapitalized}.
+ * Il utilise les cas d'utilisation (Use Cases) pour orchestrer les différentes actions métiers liées à l'entité.
+ * Ce contrôleur est responsable des actions HTTP telles que la création, la mise à jour, la récupération, et la suppression de ${entityNameCapitalized}.
+ */
+
+import { Controller, Get, Post, Body, Param, Put, Delete, Injectable } from "@nestjs/common";
+import { ApiTags, ApiOperation } from '@nestjs/swagger';
+// Importation des cas d'utilisation (Use Cases) spécifiques à ${entityNameCapitalized}
+import { Create${entityNameCapitalized}UseCase } from "${entityPath}/application/use-cases/create-${entityNameLower}.use-case";
+import { Update${entityNameCapitalized}UseCase } from "${entityPath}/application/use-cases/update-${entityNameLower}.use-case";
+import { GetById${entityNameCapitalized}UseCase } from "${entityPath}/application/use-cases/getById-${entityNameLower}.use-case";
+import { GetAll${entityNameCapitalized}UseCase } from "${entityPath}/application/use-cases/getAll-${entityNameLower}.use-case";
+import { Delete${entityNameCapitalized}UseCase } from "${entityPath}/application/use-cases/delete-${entityNameLower}.use-case";
+// Importation des DTOs pour la validation et la transformation des données entrantes
+import { Create${entityNameCapitalized}Dto, Update${entityNameCapitalized}Dto } from 'src/${entityNameLower}/application/dtos/${entityNameLower}.dto';
+
+/**
+ * Le contrôleur est annoté avec @ApiTags pour la documentation Swagger.
+ * Il regroupe les opérations HTTP relatives à l'entité ${entityNameCapitalized}.
+ */
+@Injectable()
+@ApiTags('${entityNameCapitalized}')
+@Controller('${entityNameLower}')
+export class ${entityNameCapitalized}Controller {
+  constructor(
+    private readonly createUseCase: Create${entityNameCapitalized}UseCase,
+    private readonly updateUseCase: Update${entityNameCapitalized}UseCase,
+    private readonly getByIdUseCase: GetById${entityNameCapitalized}UseCase,
+    private readonly getAllUseCase: GetAll${entityNameCapitalized}UseCase,
+    private readonly deleteUseCase: Delete${entityNameCapitalized}UseCase,
+  ) {}
+
+  // 📌 Créer un ${entityNameLower}
+  @Post()
+  @ApiOperation({ summary: 'Create a new ${entityNameLower}' })
+  async create${entityNameCapitalized}(
+    @Body() create${entityNameCapitalized}Dto: Create${entityNameCapitalized}Dto,
+  ) {
+    return this.createUseCase.execute(create${entityNameCapitalized}Dto);
+  }
+
+  // 📌 Mettre à jour un ${entityNameLower}
+  @Put(':id')
+  @ApiOperation({ summary: 'Update a ${entityNameLower}' })
+  async update${entityNameCapitalized}(
+    @Param('id') id: string,
+    @Body() update${entityNameCapitalized}Dto: Update${entityNameCapitalized}Dto,
+  ) {
+    return this.updateUseCase.execute(id, update${entityNameCapitalized}Dto);
+  }
+
+  // 📌 Récupérer un ${entityNameLower} par ID
+  @Get(':id')
+  @ApiOperation({ summary: 'Get a ${entityNameLower} by ID' })
+  async getById${entityNameCapitalized}(@Param('id') id: string) {
+    return this.getByIdUseCase.execute(id);
+  }
+
+  // 📌 Récupérer tous les ${entityNameLower}s
+  @Get()
+  @ApiOperation({ summary: 'Get all ${entityNameLower}s' })
+  async getAll${entityNameCapitalized}() {
+    return this.getAllUseCase.execute();
+  }
+
+  // 📌 Supprimer un ${entityNameLower}
+  @Delete(':id')
+  @ApiOperation({ summary: 'Delete a ${entityNameLower} by ID' })
+  async delete${entityNameCapitalized}(@Param('id') id: string) {
+    return this.deleteUseCase.execute(id);
+  }
+}
+`

package/utils/configs/setupCleanArchitecture.js

@@ -13,6 +13,7 @@ const {
   generateDto,
   generateMiddlewares,
   generateRepository,
+  generateController,
 } = require("../utils");
 
 async function setupCleanArchitecture(inputs) {
@@ -21,6 +22,7 @@ async function setupCleanArchitecture(inputs) {
 
   const entitiesData = inputs.entitiesData;
   const dbConfig = inputs.dbConfig;
+  const useSwagger = inputs.useSwagger;
 
   const srcPath = "src";
   const baseFolders = [
@@ -247,7 +249,7 @@ export class ${useCase}${capitalize(entity.name)}UseCase {
       });
 
       // 📌 5. DTOs
-      const DtoFileContent = await generateDto(entity);
+      const DtoFileContent = await generateDto(entity, useSwagger);
       await createFile({
         path: `${entityPath}/application/dtos/${entity.name}.dto.ts`,
         contente: DtoFileContent,
@@ -372,99 +374,46 @@ export class ${entityNameCapitalized}Adapter {
       });
 
       // 📌 10. Controller
+      const controllerContente = await generateController(
+        entity.name,
+        entityPath,
+        useSwagger
+      );
       await createFile({
         path: `${entityPath}/presentation/controllers/${entityNameLower}.controller.ts`,
-        contente: `
-/**
- * ${entityNameCapitalized}Controller gère les endpoints de l'API pour l'entité ${entityNameCapitalized}.
- * Il utilise les cas d'utilisation (Use Cases) pour orchestrer les différentes actions métiers liées à l'entité.
- * Ce contrôleur est responsable des actions HTTP telles que la création, la mise à jour, la récupération, et la suppression de ${entityNameCapitalized}.
- */
-
-import { Controller, Get, Post, Body, Param, Put, Delete, Injectable } from "@nestjs/common";
-import { ApiTags, ApiOperation } from '@nestjs/swagger';
-// Importation des cas d'utilisation (Use Cases) spécifiques à ${entityNameCapitalized}
-import { Create${entityNameCapitalized}UseCase } from "${entityPath}/application/use-cases/create-${entityNameLower}.use-case";
-import { Update${entityNameCapitalized}UseCase } from "${entityPath}/application/use-cases/update-${entityNameLower}.use-case";
-import { GetById${entityNameCapitalized}UseCase } from "${entityPath}/application/use-cases/getById-${entityNameLower}.use-case";
-import { GetAll${entityNameCapitalized}UseCase } from "${entityPath}/application/use-cases/getAll-${entityNameLower}.use-case";
-import { Delete${entityNameCapitalized}UseCase } from "${entityPath}/application/use-cases/delete-${entityNameLower}.use-case";
-// Importation des DTOs pour la validation et la transformation des données entrantes
-import { Create${entityNameCapitalized}Dto, Update${entityNameCapitalized}Dto } from 'src/${entityNameLower}/application/dtos/${entityNameLower}.dto';
-
-/**
- * Le contrôleur est annoté avec @ApiTags pour la documentation Swagger.
- * Il regroupe les opérations HTTP relatives à l'entité ${entityNameCapitalized}.
- */
-@Injectable()
-@ApiTags('${entityNameCapitalized}')
-@Controller('${entityNameLower}')
-export class ${entityNameCapitalized}Controller {
-  constructor(
-    private readonly createUseCase: Create${entityNameCapitalized}UseCase,
-    private readonly updateUseCase: Update${entityNameCapitalized}UseCase,
-    private readonly getByIdUseCase: GetById${entityNameCapitalized}UseCase,
-    private readonly getAllUseCase: GetAll${entityNameCapitalized}UseCase,
-    private readonly deleteUseCase: Delete${entityNameCapitalized}UseCase,
-  ) {}
-
-  // 📌 Créer un ${entityNameLower}
-  @Post()
-  @ApiOperation({ summary: 'Create a new ${entityNameLower}' })
-  async create${entityNameCapitalized}(
-    @Body() create${entityNameCapitalized}Dto: Create${entityNameCapitalized}Dto,
-  ) {
-    return this.createUseCase.execute(create${entityNameCapitalized}Dto);
-  }
-
-  // 📌 Mettre à jour un ${entityNameLower}
-  @Put(':id')
-  @ApiOperation({ summary: 'Update a ${entityNameLower}' })
-  async update${entityNameCapitalized}(
-    @Param('id') id: string,
-    @Body() update${entityNameCapitalized}Dto: Update${entityNameCapitalized}Dto,
-  ) {
-    return this.updateUseCase.execute(id, update${entityNameCapitalized}Dto);
-  }
-
-  // 📌 Récupérer un ${entityNameLower} par ID
-  @Get(':id')
-  @ApiOperation({ summary: 'Get a ${entityNameLower} by ID' })
-  async getById${entityNameCapitalized}(@Param('id') id: string) {
-    return this.getByIdUseCase.execute(id);
-  }
-
-  // 📌 Récupérer tous les ${entityNameLower}s
-  @Get()
-  @ApiOperation({ summary: 'Get all ${entityNameLower}s' })
-  async getAll${entityNameCapitalized}() {
-    return this.getAllUseCase.execute();
-  }
-
-  // 📌 Supprimer un ${entityNameLower}
-  @Delete(':id')
-  @ApiOperation({ summary: 'Delete a ${entityNameLower} by ID' })
-  async delete${entityNameCapitalized}(@Param('id') id: string) {
-    return this.deleteUseCase.execute(id);
-  }
-}
-`,
+        contente: controllerContente,
       });
 
       // 📌 11. Module
-      let Import = "";
-      let prismaProvider = "";
-      let importTormM = `imports: [
-  TypeOrmModule.forFeature([${entityNameCapitalized}]), // Injection de l'entité
-  ],`;
+      let importsBlock = [];
+      let providersBlock = [];
+      let extraImports = "";
 
       if (dbConfig.orm === "prisma") {
-        prismaImport = `import { PrismaService } from 'src/prisma/prisma.service';`;
-        prismaProvider = `    PrismaService,`;
+        extraImports = `import { PrismaService } from 'src/prisma/prisma.service';`;
+        providersBlock.push("PrismaService");
       } else if (dbConfig.orm === "typeorm") {
-        Import = `import { ${entityNameCapitalized} } from 'src/entities/${entityNameCapitalized}.entity';`;
+        extraImports = `import { ${entityNameCapitalized} } from 'src/entities/${entityNameCapitalized}.entity';\nimport { TypeOrmModule } from '@nestjs/typeorm';`;
+        importsBlock.push(
+          `TypeOrmModule.forFeature([${entityNameCapitalized}])`
+        );
       }
 
+      // Always necessary providers
+      providersBlock.push(
+        `{
+    provide: 'I${entityNameCapitalized}Repository',
+    useClass: ${entityNameCapitalized}Repository,
+  }`,
+        `${entityNameCapitalized}Repository`,
+        `Create${entityNameCapitalized}UseCase`,
+        `Update${entityNameCapitalized}UseCase`,
+        `GetById${entityNameCapitalized}UseCase`,
+        `GetAll${entityNameCapitalized}UseCase`,
+        `Delete${entityNameCapitalized}UseCase`,
+        `${entityNameCapitalized}Mapper`
+      );
+
       await createFile({
         path: `${entityPath}/${entityNameLower}.module.ts`,
         contente: `
@@ -472,12 +421,12 @@ export class ${entityNameCapitalized}Controller {
  * ${entityNameCapitalized}Module est le module principal qui gère l'entité ${entityNameCapitalized}.
  * Il regroupe tous les composants nécessaires pour traiter cette entité :
  * - Contrôleur
- * - Répository
+ * - Repository
  * - Use Cases
  * - Mapper
  */
 import { Module } from '@nestjs/common';
-import { TypeOrmModule } from '@nestjs/typeorm';
+${extraImports}
 import { ${entityNameCapitalized}Controller } from '${entityPath}/presentation/controllers/${entityNameLower}.controller';
 import { ${entityNameCapitalized}Repository } from '${entityPath}/infrastructure/repositories/${entityNameLower}.repository';
 import { Create${entityNameCapitalized}UseCase } from '${entityPath}/application/use-cases/create-${entityNameLower}.use-case';
@@ -486,51 +435,18 @@ import { GetById${entityNameCapitalized}UseCase } from '${entityPath}/applicatio
 import { GetAll${entityNameCapitalized}UseCase } from '${entityPath}/application/use-cases/getAll-${entityNameLower}.use-case';
 import { Delete${entityNameCapitalized}UseCase } from '${entityPath}/application/use-cases/delete-${entityNameLower}.use-case';
 import { ${entityNameCapitalized}Mapper } from '${entityPath}/domain/mappers/${entityNameLower}.mapper';
-${Import}
 
 @Module({
-
-  ${importTormM}
-
-  /**
-   * Déclare le contrôleur qui gère les requêtes HTTP relatives à ${entityNameCapitalized}.
-   * Ce contrôleur contient les actions d'API pour manipuler l'entité ${entityNameCapitalized}.
-   */
-  controllers: [${entityNameCapitalized}Controller],
-
-  /**
-   * Liste des providers nécessaires à la gestion de ${entityNameCapitalized}.
-   * Cela inclut :
-   * - Repository : Fournisseur pour accéder aux données de ${entityNameCapitalized}.
-   * - Use Cases : Logique métier pour la gestion de ${entityNameCapitalized}.
-   * - Mapper : Permet la transformation entre les DTOs et les entités.
-   */
+  imports: [
+    ${importsBlock.join(",\n    ")}
+  ],
+  controllers: [
+    ${entityNameCapitalized}Controller
+  ],
   providers: [
-    ${prismaProvider}
-
-    // Repository : Permet d'interagir avec la base de données
-    {
-      provide: 'I${entityNameCapitalized}Repository',  // Interface du repository
-      useClass: ${entityNameCapitalized}Repository,  // Classe qui implémente l'interface
-    },
-    ${entityNameCapitalized}Repository,  // Fournisseur pour l'accès aux données
-
-    // Use Cases : Logique métier pour la gestion de ${entityNameCapitalized}
-    Create${entityNameCapitalized}UseCase,  // Use Case pour créer un ${entityNameLower}
-    Update${entityNameCapitalized}UseCase,  // Use Case pour mettre à jour un ${entityNameLower}
-    GetById${entityNameCapitalized}UseCase,  // Use Case pour récupérer un ${entityNameLower} par son ID
-    GetAll${entityNameCapitalized}UseCase,  // Use Case pour récupérer tous les ${entityNameLower}s
-    Delete${entityNameCapitalized}UseCase,  // Use Case pour supprimer un ${entityNameLower}
-
-    // Mapper : Convertit entre les entités et les DTOs
-    ${entityNameCapitalized}Mapper,  // Mapper pour la transformation des données
+    ${providersBlock.join(",\n    ")}
   ],
 })
-/**
- * Le module ${entityNameCapitalized} est une unité logique regroupant toutes les dépendances nécessaires
- * pour le bon fonctionnement de l'entité ${entityNameCapitalized}.
- * Il gère l'injection des services, les actions métier, ainsi que la transformation des données.
- */
 export class ${entityNameCapitalized}Module {}
 `.trim(),
       });
@@ -561,8 +477,6 @@ import { APP_INTERCEPTOR } from '@nestjs/core';`,
     useClass: ResponseInterceptor,
   },`,
     });
-
-    logSuccess("structure Clean Architecture générée avec succès !");
   } catch (error) {
     logError(`process currency have error: ${error}`);
   }

package/utils/setups/setupAuth.js

@@ -3,9 +3,14 @@ const { logInfo } = require("../loggers/logInfo");
 const { runCommand } = require("../shell");
 const { createDirectory, createFile, updateFile } = require("../userInput");
 const { logSuccess } = require("../loggers/logSuccess");
+const { generateDto } = require("../utils");
 
-async function setupAuth() {
+async function setupAuth(inputs) {
   logInfo("Ajout de l'authentification avec JWT et Passport...");
+
+  const dbConfig = inputs.dbConfig;
+  const useSwagger = inputs.useSwagger;
+
   await runCommand(
     `npm install @nestjs/jwt @nestjs/passport passport passport-jwt bcrypt`,
     "Échec de l'installation des dépendances d'authentification"
@@ -29,26 +34,53 @@ async function setupAuth() {
     await createDirectory(path);
   });
 
-  // 📌 Auth Module
+  const importsArray = [
+    dbConfig.orm === "typeorm" ? `TypeOrmModule.forFeature([User])` : null,
+    `PassportModule`,
+    `JwtModule.register({ secret: 'your-secret-key', signOptions: { expiresIn: '1h' } })`,
+  ]
+    .filter(Boolean)
+    .join(",\n          ");
+
+  const typeormImports =
+    dbConfig.orm === "typeorm"
+      ? `import { TypeOrmModule } from '@nestjs/typeorm';
+import { User } from 'src/entities/User.entity';`
+      : "";
+
   await createFile({
     path: `${authPath}/auth.module.ts`,
     contente: `import { Module } from '@nestjs/common';
-      import { JwtModule } from '@nestjs/jwt';
-      import { PassportModule } from '@nestjs/passport';
-      import { AuthService } from '${authPaths.authServicesPath}/auth.service';
-      import { AuthController } from '${authPaths.authControllersPath}/auth.controller';
-      import { JwtStrategy } from '${authPaths.authStrategyPath}/jwt.strategy';
-      import { AuthGuard } from '${authPaths.authGuardsPath}/auth.guard';
-      @Module({
-        imports: [
-          PassportModule,
-          JwtModule.register({ secret: 'your-secret-key', signOptions: { expiresIn: '1h' } }),
-        ],
-        controllers: [AuthController],
-        providers: [AuthService, JwtStrategy, AuthGuard],
-        exports: [AuthService],
-      })
-      export class AuthModule {}`,
+import { JwtModule } from '@nestjs/jwt';
+import { PassportModule } from '@nestjs/passport';
+import { UserMapper } from 'src/user/domain/mappers/user.mapper';
+${typeormImports}
+import { AuthService } from '${authPaths.authServicesPath}/auth.service';
+import { PrismaService } from 'src/prisma/prisma.service';
+import { AuthController } from '${authPaths.authControllersPath}/auth.controller';
+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: [
+    ${importsArray}
+  ],
+  controllers: [AuthController],
+  providers: [
+    PrismaService,
+    UserMapper,
+    {
+      provide: 'IUserRepository',
+      useClass: UserRepository,
+    },
+    AuthService,
+    JwtStrategy,
+    AuthGuard
+  ],
+  exports: [AuthService],
+})
+export class AuthModule {}`,
   });
 
   // 📌 Auth Service
@@ -63,11 +95,17 @@ async function setupAuth() {
 } from '@nestjs/common';
 import { JwtService } from '@nestjs/jwt';
 import * as bcrypt from 'bcrypt';
-import { CreateUserDto } from 'src/user/application/dtos/user.dto';
-import { IUserRepository } from 'src/user/application/interfaces/user.repository.interface';
-import { UserEntity } from 'src/user/domain/entities/user.entity';
 import { v4 as uuidv4 } from 'uuid';
 
+import { IUserRepository } from 'src/user/application/interfaces/user.repository.interface';
+import { CreateUserDto } from 'src/user/application/dtos/user.dto';
+import { LoginCredentialDto } from 'src/user/application/dtos/loginCredential.dto';
+import { RefreshTokenDto } from 'src/user/application/dtos/refreshToken.dto';
+import { SendOtpDto } from 'src/user/application/dtos/sendOtp.dto';
+import { VerifyOtpDto } from 'src/user/application/dtos/verifyOtp.dto';
+import { ForgotPasswordDto } from 'src/user/application/dtos/forgotPassword.dto';
+import { ResetPasswordDto } from 'src/user/application/dtos/resetPassword.dto';
+
 @Injectable()
 export class AuthService {
   private refreshTokens = new Map<string, string>();
@@ -75,19 +113,21 @@ export class AuthService {
 
   constructor(
     private readonly jwtService: JwtService,
-    @Inject('UserRepository') private readonly userRepository: IUserRepository,
+    @Inject('IUserRepository')
+    private readonly userRepository: IUserRepository,
   ) {}
 
-  // ✅ Hash & verify
+  // 🔒 Hasher le mot de passe utilisateur
   async hashPassword(password: string): Promise<string> {
     return bcrypt.hash(password, 10);
   }
 
+  // 🧪 Comparer un mot de passe en clair avec un hash
   async comparePassword(password: string, hash: string): Promise<boolean> {
     return bcrypt.compare(password, hash);
   }
 
-  // 🧾 Register
+  // 🧾 Inscription (register)
   async register(dto: CreateUserDto): Promise<{ message: string }> {
     const existing = await this.userRepository.findAll();
     if (existing.find((user) => user.getEmail() === dto.email)) {
@@ -100,11 +140,11 @@ export class AuthService {
     return { message: 'Registration successful' };
   }
 
-  // 🔑 Login
-  async login({ email, password }: { email: string; password: string }) {
+  // 🔑 Connexion (login)
+  async login(dto: LoginCredentialDto) {
     const users = await this.userRepository.findAll();
-    const user = users.find((u) => u.getEmail() === email);
-    if (!user || !(await this.comparePassword(password, user.getPassword()))) {
+    const user = users.find((u) => u.getEmail() === dto.email);
+    if (!user || !(await this.comparePassword(dto.password, user.getPassword()))) {
       throw new UnauthorizedException('Invalid credentials');
     }
 
@@ -117,12 +157,12 @@ export class AuthService {
     return { accessToken, refreshToken };
   }
 
-  // 🔁 Refresh token
-  async refreshToken(refreshToken: string) {
+  // 🔁 Rafraîchir un token d'accès
+  async refreshToken(dto: RefreshTokenDto) {
     try {
-      const payload = this.jwtService.verify(refreshToken);
+      const payload = this.jwtService.verify(dto.refreshToken);
       const stored = this.refreshTokens.get(payload.sub);
-      if (stored !== refreshToken) throw new UnauthorizedException();
+      if (stored !== dto.refreshToken) throw new UnauthorizedException();
 
       const accessToken = this.jwtService.sign(
         { sub: payload.sub, email: payload.email },
@@ -134,135 +174,146 @@ export class AuthService {
     }
   }
 
-  // 🚪 Logout
-  async logout(refreshToken: string) {
-    const payload = this.jwtService.verify(refreshToken);
+  // 🚪 Déconnexion
+  async logout(dto: RefreshTokenDto) {
+    const payload = this.jwtService.verify(dto.refreshToken);
     this.refreshTokens.delete(payload.sub);
     return { message: 'Logged out successfully' };
   }
 
-  // 📲 Send OTP
-  async sendOtp(email: string) {
+  // 📲 Envoyer un OTP
+  async sendOtp(dto: SendOtpDto) {
     const otp = Math.floor(100000 + Math.random() * 900000).toString();
-    this.otps.set(email, otp);
-    console.log(\`[OTP] for ${email} is ${otp}\`);
+    this.otps.set(dto.email, otp);
+    console.log(\`[OTP] for \${dto.email} is \${otp}\`);
     return { message: 'OTP sent' };
   }
 
-  // ✅ Verify OTP
-  async verifyOtp(email: string, otp: string) {
-    const valid = this.otps.get(email);
-    if (valid === otp) {
-      this.otps.delete(email);
+  // ✅ Vérifier un OTP
+  async verifyOtp(dto: VerifyOtpDto) {
+    const valid = this.otps.get(dto.email);
+    if (valid === dto.otp) {
+      this.otps.delete(dto.email);
       return { message: 'OTP verified' };
     }
     throw new UnauthorizedException('Invalid OTP');
   }
 
-  // 🔐 Forgot password
-  async forgotPassword(email: string) {
+  // 📬 Mot de passe oublié
+  async forgotPassword(dto: ForgotPasswordDto) {
     const users = await this.userRepository.findAll();
-    const user = users.find((u) => u.getEmail() === email);
+    const user = users.find((u) => u.getEmail() === dto.email);
     if (!user) throw new NotFoundException('User not found');
 
     const token = uuidv4();
-    // await this.userRepository.update(user.getId(), {});
-    console.log(\`[ResetToken] for ${email} is ${token}\`);
-
+    console.log(\`[ResetToken] for \${dto.email} is \${token}\`);
     return { message: 'Reset token sent' };
   }
 
-  // 🔐 Reset password
-  async resetPassword({
-    email,
-    newPassword,
-  }: {
-    email: string;
-    newPassword: string;
-  }) {
+  // 🔄 Réinitialiser le mot de passe
+  async resetPassword(dto: ResetPasswordDto) {
     const users = await this.userRepository.findAll();
-    const user = users.find((u) => u.getEmail() === email);
+    const user = users.find((u) => u.getEmail() === dto.email);
     if (!user) throw new UnauthorizedException('Invalid reset token');
 
-    const password = await this.hashPassword(newPassword);
+    const password = await this.hashPassword(dto.newPassword);
     await this.userRepository.update(user.getId(), { password });
 
     return { message: 'Password reset successful' };
   }
 
-  // 👤 Profile
-  async getProfile(user: UserEntity) {
-    const found = await this.userRepository.findById(user.getId());
+    // 👤 Obtenir le profil
+  async getProfile(user: any) {
+    const found = await this.userRepository.findById(user.userId);
     if (!found) throw new NotFoundException('User not found');
-    return found;
+    const email = found.getEmail();
+    return { email: email };
   }
 
-  // Token utils
+  // 🔧 Générer un token manuellement
   generateToken(payload: any) {
     return this.jwtService.sign(payload);
   }
 }
 `,
   });
-
   // 📌 Auth Controller
   await createFile({
     path: `${authPaths.authControllersPath}/auth.controller.ts`,
     contente: `import { Controller, Post, Body, UseGuards, Get, Req } from '@nestjs/common';
 import { Request } from 'express';
-import { AuthService } from '${authPaths.authServicesPath}/auth.service';
-import { JwtAuthGuard } from '${authPaths.authGuardsPath}/jwt-auth.guard';
+import { AuthService } from "${authPaths.authServicesPath}/auth.service";
+import { JwtAuthGuard } from "${authPaths.authGuardsPath}/jwt-auth.guard";
+import { CreateUserDto } from 'src/user/application/dtos/user.dto';
+import { LoginCredentialDto } from 'src/user/application/dtos/loginCredential.dto';
+import { RefreshTokenDto } from 'src/user/application/dtos/refreshToken.dto';
+import { SendOtpDto } from 'src/user/application/dtos/sendOtp.dto';
+import { VerifyOtpDto } from 'src/user/application/dtos/verifyOtp.dto';
+import { ForgotPasswordDto } from 'src/user/application/dtos/forgotPassword.dto';
+import { ResetPasswordDto } from 'src/user/application/dtos/resetPassword.dto';
+${useSwagger ? "import { ApiBearerAuth } from '@nestjs/swagger';" : ""}
 
 @Controller('auth')
 export class AuthController {
   constructor(private readonly authService: AuthService) {}
 
+  // 📝 Créer un compte utilisateur (👤)
   @Post('register')
-  async register(@Body() body: any) {
+  async register(@Body() body: CreateUserDto) {
     return this.authService.register(body);
   }
 
+  // 🔐 Connexion utilisateur (🔑)
   @Post('login')
-  async login(@Body() body: any) {
+  async login(@Body() body: LoginCredentialDto) {
     return this.authService.login(body);
   }
 
+  // ♻️ Rafraîchir le token d'accès (🔁)
   @Post('refresh')
-  async refreshToken(@Body() body: any) {
-    return this.authService.refreshToken(body.refreshToken);
+  async refreshToken(@Body() body: RefreshTokenDto) {
+    return this.authService.refreshToken(body);
   }
 
+  // 🚪 Déconnexion utilisateur (🚫)
   @Post('logout')
-  async logout(@Body() body: any) {
-    return this.authService.logout(body.refreshToken);
+  async logout(@Body() body: RefreshTokenDto) {
+    return this.authService.logout(body);
   }
 
+  // 📤 Envoyer un OTP au mail (📧)
   @Post('send-otp')
-  async sendOtp(@Body() body: any) {
+  async sendOtp(@Body() body: SendOtpDto) {
     return this.authService.sendOtp(body);
   }
 
+  // ✅ Vérifier l'OTP envoyé (✔️)
   @Post('verify-otp')
-  async verifyOtp(@Body() body: { email: string; otp: string }) {
-    return this.authService.verifyOtp(body.email, body.otp);
+  async verifyOtp(@Body() body: VerifyOtpDto) {
+    return this.authService.verifyOtp(body);
   }
 
+  // 🔁 Mot de passe oublié (📨)
   @Post('forgot-password')
-  async forgotPassword(@Body() body: any) {
-    return this.authService.forgotPassword(body.email);
+  async forgotPassword(@Body() body: ForgotPasswordDto) {
+    return this.authService.forgotPassword(body);
   }
 
+  // 🔄 Réinitialiser le mot de passe (🔓)
   @Post('reset-password')
-  async resetPassword(@Body() body: any) {
+  async resetPassword(@Body() body: ResetPasswordDto) {
     return this.authService.resetPassword(body);
   }
 
+  // 👤 Obtenir le profil utilisateur connecté (🧑‍💼)
+  ${useSwagger ? "@ApiBearerAuth()" : ""}
   @UseGuards(JwtAuthGuard)
   @Get('me')
   async getProfile(@Req() req: Request) {
     if (req.user) return this.authService.getProfile(req.user);
   }
 }
+
 `,
   });
 
@@ -282,8 +333,10 @@ export class AuthController {
           });
         }
         async validate(payload: any) {
-          return { userId: payload.sub, username: payload.username };
-        }
+          return {
+            userId: payload.sub,
+            email: payload.email,
+          };        }
       }`,
   });
 
@@ -400,6 +453,70 @@ export class JwtAuthGuard extends AuthGuard('jwt') {
 `,
   });
 
+  // 📌 auth DTOs in user entity
+  const dtos = [
+    {
+      name: "loginCredential",
+      fields: [
+        { name: "email", type: "string", swaggerExample: "user@example.com" },
+        {
+          name: "password",
+          type: "string",
+          swaggerExample: "StrongPassword123!",
+        },
+      ],
+    },
+    {
+      name: "refreshToken",
+      fields: [
+        {
+          name: "refreshToken",
+          type: "string",
+          swaggerExample: "eyJhbGciOiJIUzI1NiIsInR5cCI6...",
+        },
+      ],
+    },
+    {
+      name: "sendOtp",
+      fields: [
+        { name: "email", type: "string", swaggerExample: "user@example.com" },
+      ],
+    },
+    {
+      name: "verifyOtp",
+      fields: [
+        { name: "email", type: "string", swaggerExample: "user@example.com" },
+        { name: "otp", type: "string", swaggerExample: "123456" },
+      ],
+    },
+    {
+      name: "forgotPassword",
+      fields: [
+        { name: "email", type: "string", swaggerExample: "user@example.com" },
+      ],
+    },
+    {
+      name: "resetPassword",
+      fields: [
+        { name: "email", type: "string", swaggerExample: "user@example.com" },
+        {
+          name: "newPassword",
+          type: "string",
+          swaggerExample: "NewStrongPass123!",
+        },
+      ],
+    },
+  ];
+
+  // ✅ Génération de chaque DTO
+  for (const dto of dtos) {
+    const DtoFileContent = await generateDto(dto, useSwagger, true); // tu dois adapter ta fonction generateDto pour recevoir un dto avec `name` et `fields`
+    await createFile({
+      path: `src/user/application/dtos/${dto.name}.dto.ts`,
+      contente: DtoFileContent,
+    });
+  }
+
   // modification de AppModule
   const appModulePath = "src/app.module.ts";
 

package/utils/setups/setupDatabase.js

@@ -37,7 +37,7 @@ async function setupDatabase(inputs) {
 async function setupMongoDB(inputs) {
   logInfo("Configuration de MongoDB...");
   // Appelle un script spécifique à MongoDB
-  await setupMongoDBConfig(inputs);
+  // await setupMongoDBConfig(inputs);
 }
 async function setupSQLite(inputs) {
   logInfo("Configuration de SQLite...");

package/utils/setups/setupLogger.js

@@ -0,0 +1,53 @@
+const fs = require("fs");
+
+async function setupBootstrapLogger() {
+  // Modification de main.ts pour intégrer Swagger
+  const mainTsPath = "src/main.ts";
+  let mainTs = fs.readFileSync(mainTsPath, "utf8");
+
+  if (!mainTs.includes("await app.listen")) return mainTs;
+
+  // Injecte les imports si non présents
+  if (!mainTs.includes("Logger")) {
+    mainTs = mainTs.replace(
+      "import { NestFactory",
+      "import { Logger } from '@nestjs/common';\nimport { NestFactory"
+    );
+  }
+  if (!mainTs.includes("ConfigService")) {
+    mainTs = mainTs.replace(
+      "import { NestFactory",
+      "import { ConfigService } from '@nestjs/config';\nimport { NestFactory"
+    );
+  }
+
+  // Injecte la récupération des variables
+  if (!mainTs.includes("const host = configService.get<string>('HOST'")) {
+    mainTs = mainTs.replace(
+      "const app = await NestFactory.create(AppModule);",
+      `const app = await NestFactory.create(AppModule);
+
+  const configService = app.get(ConfigService);
+  const port = configService.get<number>('PORT', 3000);
+  const host = configService.get<string>('HOST', '0.0.0.0');`
+    );
+  }
+
+  // Remplace le démarrage de l'app par le bloc stylisé
+  return mainTs.replace(
+    "await app.listen(process.env.PORT ?? 3000);",
+    `try {
+    await app.listen(port, host);
+
+    const logger = new Logger('Bootstrap');
+    logger.log(\`🚀 Application running on: \${await app.getUrl()}\`);
+    logger.log(\`🌐 Environment: \${process.env.NODE_ENV || 'development'}\`);
+    logger.log(\`📡 Listening on \${host}:\${port}\`);
+  } catch (error) {
+    const logger = new Logger('Bootstrap');
+    logger.error('❌ Failed to start the server', error);
+    process.exit(1);
+  }`
+  );
+}
+module.exports = { setupBootstrapLogger };

package/utils/setups/setupSwagger.js

@@ -45,14 +45,15 @@ async function setupSwagger(inputs) {
       .setTitle('${inputs.title}')
       .setDescription('${inputs.description}')
       .setVersion('${inputs.version}')
-      .addBearerAuth(
-        { type: 'http', scheme: 'bearer', bearerFormat: 'JWT', in: 'header' },
-        'access-token'
-      )
+      .addBearerAuth()
       .build();
 
     const document = SwaggerModule.createDocument(app, config);
-    SwaggerModule.setup('${inputs.endpoint}', app, document);
+    SwaggerModule.setup('${inputs.endpoint}', app, document,{
+    swaggerOptions: {
+      persistAuthorization: true,
+    },
+  });
 
     const configService = app.get(ConfigService);
     const port = configService.get<number>('PORT', 3000);

package/utils/utils.js

@@ -154,31 +154,32 @@ export class ${entityName}Mapper {
 `;
 }
 
-export async function generateDto(entity) {
+/* export async function generateDto(entity, useSwagger) {
   const entityName = capitalize(entity.name);
 
   const getExampleForField = (f) => {
-    // Dynamique et plus réaliste, basé sur le type de champ et des exemples courants
     switch (f.type) {
       case "string":
-        return `"${f.name}_example"`; // Exemple générique basé sur le nom du champ
+        return `"${f.name}_example"`;
       case "number":
-        return f.name === "price" ? 199.99 : 123; // Exemple spécifique pour 'price'
+        return f.name === "price" ? 199.99 : 123;
       case "boolean":
-        return true; // Exemple générique pour les booléens
+        return true;
       case "Date":
       case "date":
-        return `"2024-01-01T00:00:00Z"`; // Exemple générique pour les dates
+        return `"2024-01-01T00:00:00Z"`;
       case "role":
-        return `"user"`; // Exemple pour les rôles, par défaut 'user'
+        return `"user"`;
       case "discount":
-        return 10; // Exemple pour une valeur de type discount
+        return 10;
       case "account":
-        return `"acc_${f.name}_12345"`; // Exemple pour un compte
+        return `"acc_${f.name}_12345"`;
       case "amount":
-        return 500.75; // Exemple pour un montant
+        return 500.75;
+      case "email":
+        return "user@example.com";
       default:
-        return `"sample_${f.name}"`; // Fallback générique pour les autres types
+        return `"sample_${f.name}"`;
     }
   };
 
@@ -191,17 +192,19 @@ export async function generateDto(entity) {
         date: "IsDate",
       }[f.type] || "IsString";
 
-    const apiPropertyDecorator = f.optional
-      ? `@ApiPropertyOptional({ example: ${getExampleForField(f)}, type: '${
-          f.type
-        }' })`
-      : `@ApiProperty({ example: ${getExampleForField(f)}, type: '${
-          f.type
-        }' })`;
-
-    return `${apiPropertyDecorator}
-  @${typeDecorator}()
-  ${f.name}${f.optional ? "?" : ""}: ${f.type};`;
+    const swaggerDecorator = useSwagger
+      ? f.optional
+        ? `@ApiPropertyOptional({ example: ${getExampleForField(f)}, type: '${
+            f.type
+          }' })\n`
+        : `@ApiProperty({ example: ${getExampleForField(f)}, type: '${
+            f.type
+          }' })\n`
+      : "";
+
+    return `${swaggerDecorator}  @${typeDecorator}()\n  ${f.name}${
+      f.optional ? "?" : ""
+    }: ${f.type};`;
   };
 
   const dtoFields = entity.fields
@@ -213,8 +216,12 @@ export async function generateDto(entity) {
     .join("\n\n");
 
   return `
-import { IsOptional, IsString, IsInt, IsBoolean, IsDate } from 'class-validator';
-import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
+import { IsOptional, IsString, IsEnum, IsInt, IsBoolean, IsDate, MinLength } from 'class-validator';
+${
+  useSwagger
+    ? "import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';"
+    : ""
+}
 
 // Vous pouvez décommenter ce champ si vous voulez gérer le rôle de l'utilisateur.
 // import { Role } from 'src/modules/user/domain/enums/role.enum';
@@ -222,19 +229,284 @@ import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
 export class Create${entityName}Dto {
 ${dtoFields}
 
-  // Décommentez et ajustez le rôle si nécessaire.
-  // @ApiProperty({ example: 'admin', type: 'string' })
-  // @IsString()
-  // role: Role;
+   // Ajustez le rôle si nécessaire.
+   ${
+     useSwagger && entityName == "User"
+       ? "@ApiPropertyOptional({ example: 'admin', type: 'string' })\n  "
+       : ""
+   }${
+    useSwagger && entityName == "User"
+      ? `@IsEnum(Role)
+  role?: Role.ADMIN;
+    `
+      : ""
+  }
 }
 
 export class Update${entityName}Dto {
 ${updateDtoFields}
 
-  // Décommentez et ajustez le rôle si nécessaire.
-  // @ApiPropertyOptional({ example: 'admin', type: 'string' })
-  // @IsString()
-  // role?: Role;
+   ${
+     useSwagger && entityName == "User"
+       ? "@ApiPropertyOptional({ example: 'admin', type: 'string' })\n  "
+       : ""
+   }${
+    useSwagger && entityName == "User"
+      ? `@IsEnum(Role)
+  role?: Role.ADMIN;
+    `
+      : ""
+  }
+}
+`;
+} */
+
+export async function generateDto(entity, useSwagger, isAuthDto = false) {
+  const entityName = capitalize(entity.name);
+
+  const getExampleForField = (f) => {
+    const fieldName = f.name.toLowerCase();
+
+    // 🚀 Cas spécifiques pour AUTH DTO (exemples réalistes)
+    if (isAuthDto) {
+      if (fieldName.includes("newpassword")) {
+        return `"NewStrongPass123!"`;
+      }
+      if (fieldName.includes("otp")) {
+        return `"123456"`;
+      }
+      if (fieldName.includes("token")) {
+        return `"eyJhbGciOiJIUzI1NiIsInR5cCI6..."`;
+      }
+    }
+
+    if (fieldName.includes("email")) {
+      return `"user@example.com"`;
+    }
+    if (fieldName.includes("password")) {
+      return `"StrongPassword123!"`;
+    }
+    // 🌐 Cas génériques applicables à tout
+    if (fieldName.includes("price")) {
+      return 199.99;
+    }
+    if (fieldName.includes("amount")) {
+      return 500.75;
+    }
+    if (fieldName.includes("role")) {
+      return `"user"`;
+    }
+    if (fieldName.includes("date")) {
+      return `"2024-01-01T00:00:00Z"`;
+    }
+    if (fieldName.includes("account")) {
+      return `"acc_${f.name}_12345"`;
+    }
+    if (fieldName.includes("discount")) {
+      return 10;
+    }
+
+    // 🛠 Sinon fallback basique selon le type
+    switch (f.type) {
+      case "string":
+        return `"${f.name}_example"`;
+      case "number":
+        return 123;
+      case "boolean":
+        return true;
+      case "Date":
+      case "date":
+        return `"2024-01-01T00:00:00Z"`;
+      default:
+        return `"sample_${f.name}"`;
+    }
+  };
+
+  const generateFieldLine = (f) => {
+    const typeDecorator =
+      {
+        string: "IsString",
+        number: "IsInt",
+        boolean: "IsBoolean",
+        date: "IsDate",
+      }[f.type] || "IsString";
+
+    const swaggerDecorator = useSwagger
+      ? f.optional
+        ? `@ApiPropertyOptional({ example: ${getExampleForField(f)}, type: '${
+            f.type
+          }' })\n`
+        : `@ApiProperty({ example: ${getExampleForField(f)}, type: '${
+            f.type
+          }' })\n`
+      : "";
+
+    return `${swaggerDecorator}  @${typeDecorator}()\n  ${f.name}${
+      f.optional ? "?" : ""
+    }: ${f.type};`;
+  };
+
+  const dtoFields = entity.fields
+    .map((f) => generateFieldLine({ ...f, optional: false }))
+    .join("\n\n");
+
+  const updateDtoFields = entity.fields
+    .map((f) => generateFieldLine({ ...f, optional: true }))
+    .join("\n\n");
+
+  const commonImports = `import { IsOptional, IsString, IsEnum, IsInt, IsBoolean, IsDate, MinLength } from 'class-validator';
+${
+  useSwagger
+    ? "import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';"
+    : ""
+}
+`;
+
+  // ✅ Cas AUTH DTO : une seule classe + nom déjà donné (pas de Create/Update)
+  if (isAuthDto) {
+    return `
+${commonImports}
+
+export class ${entityName}Dto {
+${dtoFields}
+}
+`;
+  }
+
+  // ✅ Cas général : Create + Update
+  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}
+
+   // Ajustez le rôle si nécessaire.
+   ${
+     useSwagger && entityName == "User"
+       ? "@ApiPropertyOptional({ example: 'admin', type: 'string' })\n  "
+       : ""
+   }${
+    useSwagger && entityName == "User"
+      ? `@IsEnum(Role)
+  role?: Role.ADMIN;
+    `
+      : ""
+  }
+}
+
+export class Update${entityName}Dto {
+${updateDtoFields}
+
+   ${
+     useSwagger && entityName == "User"
+       ? "@ApiPropertyOptional({ example: 'admin', type: 'string' })\n  "
+       : ""
+   }${
+    useSwagger && entityName == "User"
+      ? `@IsEnum(Role)
+  role?: Role.ADMIN;
+    `
+      : ""
+  }
+}
+`;
+}
+
+export async function generateController(entityName, entityPath, useSwagger) {
+  const entityNameLower = decapitalize(entityName);
+  const entityNameCapitalized = capitalize(entityName);
+
+  const swaggerImports = useSwagger
+    ? `import { ApiTags, ApiOperation } from '@nestjs/swagger';`
+    : "";
+
+  const swaggerClassDecorator = useSwagger
+    ? `@ApiTags('${entityNameCapitalized}')`
+    : "";
+
+  const swaggerMethodDecorator = (summary) =>
+    useSwagger ? `@ApiOperation({ summary: '${summary}' })\n  ` : "";
+
+  return `
+/**
+ * ${entityNameCapitalized}Controller gère les endpoints de l'API pour l'entité ${entityNameCapitalized}.
+ * Il utilise les cas d'utilisation (Use Cases) pour orchestrer les différentes actions métiers liées à l'entité.
+ */
+
+import { Controller, Get, Post, Body, Param, Put, Delete, Injectable } from "@nestjs/common";
+${swaggerImports}
+// Importation des cas d'utilisation
+import { Create${entityNameCapitalized}UseCase } from "${entityPath}/application/use-cases/create-${entityNameLower}.use-case";
+import { Update${entityNameCapitalized}UseCase } from "${entityPath}/application/use-cases/update-${entityNameLower}.use-case";
+import { GetById${entityNameCapitalized}UseCase } from "${entityPath}/application/use-cases/getById-${entityNameLower}.use-case";
+import { GetAll${entityNameCapitalized}UseCase } from "${entityPath}/application/use-cases/getAll-${entityNameLower}.use-case";
+import { Delete${entityNameCapitalized}UseCase } from "${entityPath}/application/use-cases/delete-${entityNameLower}.use-case";
+// DTOs
+import { Create${entityNameCapitalized}Dto, Update${entityNameCapitalized}Dto } from 'src/${entityNameLower}/application/dtos/${entityNameLower}.dto';
+
+@Injectable()
+${swaggerClassDecorator}
+@Controller('${entityNameLower}')
+export class ${entityNameCapitalized}Controller {
+  constructor(
+    private readonly createUseCase: Create${entityNameCapitalized}UseCase,
+    private readonly updateUseCase: Update${entityNameCapitalized}UseCase,
+    private readonly getByIdUseCase: GetById${entityNameCapitalized}UseCase,
+    private readonly getAllUseCase: GetAll${entityNameCapitalized}UseCase,
+    private readonly deleteUseCase: Delete${entityNameCapitalized}UseCase,
+  ) {}
+
+  ${
+    entityNameLower != "user"
+      ? `// 📌 Créer un ${entityNameLower}
+  @Post()
+  ${swaggerMethodDecorator(
+    `Create a new ${entityNameLower}`
+  )}async create${entityNameCapitalized}(
+    @Body() create${entityNameCapitalized}Dto: Create${entityNameCapitalized}Dto,
+  ) {
+    return this.createUseCase.execute(create${entityNameCapitalized}Dto);
+  }`
+      : ""
+  }
+
+  // 📌 Mettre à jour un ${entityNameLower}
+  @Put(':id')
+  ${swaggerMethodDecorator(
+    `Update a ${entityNameLower}`
+  )}async update${entityNameCapitalized}(
+    @Param('id') id: string,
+    @Body() update${entityNameCapitalized}Dto: Update${entityNameCapitalized}Dto,
+  ) {
+    return this.updateUseCase.execute(id, update${entityNameCapitalized}Dto);
+  }
+
+  // 📌 Récupérer un ${entityNameLower} par ID
+  @Get(':id')
+  ${swaggerMethodDecorator(
+    `Get a ${entityNameLower} by ID`
+  )}async getById${entityNameCapitalized}(@Param('id') id: string) {
+    return this.getByIdUseCase.execute(id);
+  }
+
+  // 📌 Récupérer tous les ${entityNameLower}s
+  @Get()
+  ${swaggerMethodDecorator(
+    `Get all ${entityNameLower}s`
+  )}async getAll${entityNameCapitalized}() {
+    return this.getAllUseCase.execute();
+  }
+
+  // 📌 Supprimer un ${entityNameLower}
+  @Delete(':id')
+  ${swaggerMethodDecorator(
+    `Delete a ${entityNameLower} by ID`
+  )}async delete${entityNameCapitalized}(@Param('id') id: string) {
+    return this.deleteUseCase.execute(id);
+  }
 }
 `;
 }
@@ -436,8 +708,6 @@ export async function generateRepository(entityName, orm) {
   const entityNameLower = entityName.toLowerCase();
   const entityPath = `src/${entityNameLower}`;
 
-  console.log(`entity name: ${entityNameLower} \n omr selected: ${orm}`);
-
   // Gère le switch en fonction de l'ORM choisi
   switch (orm) {
     case "typeorm":