nestcraftx 0.1.6 → 0.1.8

package/utils/configs/setupCleanArchitecture.js

@@ -13,6 +13,8 @@ const {
   generateDto,
   generateMiddlewares,
   generateRepository,
+  generateController,
+  generateMongooseSchemaFileContent,
 } = require("../utils");
 
 async function setupCleanArchitecture(inputs) {
@@ -21,6 +23,7 @@ async function setupCleanArchitecture(inputs) {
 
   const entitiesData = inputs.entitiesData;
   const dbConfig = inputs.dbConfig;
+  const useSwagger = inputs.useSwagger;
 
   const srcPath = "src";
   const baseFolders = [
@@ -81,6 +84,16 @@ export class AppModule {}`,
         await createDirectory(`${entityPath}/${folder}`);
       }
 
+      if (dbConfig.orm === "mongoose") {
+        const mongooseSchemaContent = await generateMongooseSchemaFileContent(
+          entity
+        );
+        await createFile({
+          path: `src/${entity.name}/domain/entities/${entity.name}.schema.ts`,
+          contente: mongooseSchemaContent,
+        });
+      }
+
       // 📌 1. Entité
       const entityContent = await generateEntityFileContent(entity);
       await createFile({
@@ -105,136 +118,168 @@ export interface I${entityNameCapitalized}Repository {
 
       // 📌 3. Repository Implémentation
       await generateRepository(entity.name, dbConfig.orm);
-      /* await createFile({
-        path: `${entityPath}/infrastructure/repositories/${entityNameLower}.repository.ts`,
-        contente: repositoryContent,
-      }); */
 
       // 📌 4. Use Cases
       const useCases = ["Create", "GetById", "GetAll", "Update", "Delete"];
       useCases.forEach(async (useCase) => {
         let content = "";
+        const entityName = capitalize(entity.name);
+        const entityNameLower = decapitalize(entity.name);
 
         switch (useCase) {
           case "Create":
             content = `/**
- * Use Case pour créer un ${capitalize(entity.name)}.
+ * Use Case pour créer un ${entityName}.
  */
-import { Inject } from '@nestjs/common';
-import { Create${capitalize(entity.name)}Dto } from 'src/${
-              entity.name
-            }/application/dtos/${entity.name}.dto';
-import { I${capitalize(entity.name)}Repository } from 'src/${
-              entity.name
-            }/application/interfaces/${entity.name}.repository.interface';
-
-export class ${useCase}${capitalize(entity.name)}UseCase {
+import { Inject, Logger } from '@nestjs/common';
+import { Create${entityName}Dto } from 'src/${entity.name}/application/dtos/${entity.name}.dto';
+import { I${entityName}Repository } from 'src/${entity.name}/application/interfaces/${entity.name}.repository.interface';
+import { ${entityName}Entity } from 'src/${entity.name}/domain/entities/${entityNameLower}.entity';
+
+export class Create${entityName}UseCase {
+  private readonly logger = new Logger(Create${entityName}UseCase.name);
+
   constructor(
-    @Inject("I${capitalize(entity.name)}Repository")
-    private readonly ${decapitalize(entity.name)}Repository: I${capitalize(
-              entity.name
-            )}Repository,
+    @Inject("I${entityName}Repository")
+    private readonly ${entityNameLower}Repository: I${entityName}Repository,
   ) {}
 
-  execute(data: Create${capitalize(entity.name)}Dto) {
-    return this.${decapitalize(entity.name)}Repository.create(data);
+  async execute(data: Create${entityName}Dto): Promise<${entityName}Entity> {
+    this.logger.log('Début création ${entityName}');
+    try {
+      const result = await this.${entityNameLower}Repository.create(data);
+      this.logger.log('Création réussie');
+      return result;
+    } catch (error) {
+      this.logger.error('Erreur lors de la création', error.stack);
+      throw error;
+    }
   }
-}`;
+}
+`;
             break;
 
           case "GetById":
             content = `/**
- * Use Case pour récupérer un ${capitalize(entity.name)} par son ID.
+ * Use Case pour récupérer un ${entityName} par son ID.
  */
-import { Inject } from '@nestjs/common';
-import { I${capitalize(entity.name)}Repository } from 'src/${
-              entity.name
-            }/application/interfaces/${entity.name}.repository.interface';
+import { Inject, Logger } from '@nestjs/common';
+import { I${entityName}Repository } from 'src/${entity.name}/application/interfaces/${entity.name}.repository.interface';
+import { ${entityName}Entity } from 'src/${entity.name}/domain/entities/${entityNameLower}.entity';
+
+export class GetById${entityName}UseCase {
+  private readonly logger = new Logger(GetById${entityName}UseCase.name);
 
-export class ${useCase}${capitalize(entity.name)}UseCase {
   constructor(
-    @Inject("I${capitalize(entity.name)}Repository")
-    private readonly ${decapitalize(entity.name)}Repository: I${capitalize(
-              entity.name
-            )}Repository,
+    @Inject("I${entityName}Repository")
+    private readonly ${entityNameLower}Repository: I${entityName}Repository,
   ) {}
 
-  execute(id: string) {
-    return this.${decapitalize(entity.name)}Repository.findById(id);
+  async execute(id: string): Promise<${entityName}Entity | null> {
+    this.logger.log(\`Recherche de ${entityName} par id: \${id}\`);
+    try {
+      const result = await this.${entityNameLower}Repository.findById(id);
+      this.logger.log('Recherche réussie');
+      return result;
+    } catch (error) {
+      this.logger.error('Erreur lors de la recherche', error.stack);
+      throw error;
+    }
   }
-}`;
+}
+`;
             break;
 
           case "GetAll":
             content = `/**
- * Use Case pour récupérer tous les ${capitalize(entity.name)}s.
+ * Use Case pour récupérer tous les ${entityName}s.
  */
-import { Inject } from '@nestjs/common';
-import { I${capitalize(entity.name)}Repository } from 'src/${
-              entity.name
-            }/application/interfaces/${entity.name}.repository.interface';
+import { Inject, Logger } from '@nestjs/common';
+import { I${entityName}Repository } from 'src/${entity.name}/application/interfaces/${entity.name}.repository.interface';
+import { ${entityName}Entity } from 'src/${entity.name}/domain/entities/${entityNameLower}.entity';
+
+export class GetAll${entityName}UseCase {
+  private readonly logger = new Logger(GetAll${entityName}UseCase.name);
 
-export class ${useCase}${capitalize(entity.name)}UseCase {
   constructor(
-    @Inject("I${capitalize(entity.name)}Repository")
-    private readonly ${decapitalize(entity.name)}Repository: I${capitalize(
-              entity.name
-            )}Repository,
+    @Inject("I${entityName}Repository")
+    private readonly ${entityNameLower}Repository: I${entityName}Repository,
   ) {}
 
-  execute() {
-    return this.${decapitalize(entity.name)}Repository.findAll();
+  async execute(): Promise<${entityName}Entity[]> {
+    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');
+      return result;
+    } catch (error) {
+      this.logger.error('Erreur lors de la récupération', error.stack);
+      throw error;
+    }
   }
-}`;
+}
+`;
             break;
 
           case "Update":
             content = `/**
- * Use Case pour mettre à jour un ${capitalize(entity.name)} existant.
+ * Use Case pour mettre à jour un ${entityName} existant.
  */
-import { Inject } from '@nestjs/common';
-import { Update${capitalize(entity.name)}Dto } from 'src/${
-              entity.name
-            }/application/dtos/${entity.name}.dto';
-import { I${capitalize(entity.name)}Repository } from 'src/${
-              entity.name
-            }/application/interfaces/${entity.name}.repository.interface';
-
-export class ${useCase}${capitalize(entity.name)}UseCase {
+import { Inject, Logger } from '@nestjs/common';
+import { Update${entityName}Dto } from 'src/${entity.name}/application/dtos/${entity.name}.dto';
+import { I${entityName}Repository } from 'src/${entity.name}/application/interfaces/${entity.name}.repository.interface';
+import { ${entityName}Entity } from 'src/${entity.name}/domain/entities/${entityNameLower}.entity';
+
+export class Update${entityName}UseCase {
+  private readonly logger = new Logger(Update${entityName}UseCase.name);
+
   constructor(
-    @Inject("I${capitalize(entity.name)}Repository")
-    private readonly ${decapitalize(entity.name)}Repository: I${capitalize(
-              entity.name
-            )}Repository,
+    @Inject("I${entityName}Repository")
+    private readonly ${entityNameLower}Repository: I${entityName}Repository,
   ) {}
 
-  execute(id: string, data: Update${capitalize(entity.name)}Dto) {
-    return this.${decapitalize(entity.name)}Repository.update(id, data);
+  async execute(id: string, data: Update${entityName}Dto): Promise<${entityName}Entity | null> {
+    this.logger.log(\`Mise à jour de ${entityName} id: \${id}\`);
+    try {
+      const result = await this.${entityNameLower}Repository.update(id, data);
+      this.logger.log('Mise à jour réussie');
+      return result;
+    } catch (error) {
+      this.logger.error('Erreur lors de la mise à jour', error.stack);
+      throw error;
+    }
   }
-}`;
+}
+`;
             break;
 
           case "Delete":
             content = `/**
- * Use Case pour supprimer un ${capitalize(entity.name)}.
+ * Use Case pour supprimer un ${entityName}.
  */
-import { Inject } from '@nestjs/common';
-import { I${capitalize(entity.name)}Repository } from 'src/${
-              entity.name
-            }/application/interfaces/${entity.name}.repository.interface';
+import { Inject, Logger } from '@nestjs/common';
+import { I${entityName}Repository } from 'src/${entity.name}/application/interfaces/${entity.name}.repository.interface';
+
+export class Delete${entityName}UseCase {
+  private readonly logger = new Logger(Delete${entityName}UseCase.name);
 
-export class ${useCase}${capitalize(entity.name)}UseCase {
   constructor(
-    @Inject("I${capitalize(entity.name)}Repository")
-    private readonly ${decapitalize(entity.name)}Repository: I${capitalize(
-              entity.name
-            )}Repository,
+    @Inject("I${entityName}Repository")
+    private readonly ${entityNameLower}Repository: I${entityName}Repository,
   ) {}
 
-  execute(id: string) {
-    return this.${decapitalize(entity.name)}Repository.delete(id);
+  async execute(id: string): Promise<void> {
+    this.logger.log(\`Suppression de ${entityName} id: \${id}\`);
+    try {
+      await this.${entityNameLower}Repository.delete(id);
+      this.logger.log('Suppression réussie');
+    } catch (error) {
+      this.logger.error('Erreur lors de la suppression', error.stack);
+      throw error;
+    }
   }
-}`;
+}
+`;
             break;
         }
 
@@ -247,7 +292,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,
@@ -283,7 +328,7 @@ export enum Role {
       // 📌 7. Mapper
       const mapperFileContent = await generateMapper(entity);
       await createFile({
-        path: `${entityPath}/domain/mappers/${entity.name}.mapper.ts`,
+        path: `${entityPath}/domain/mappers/${entityNameLower}.mapper.ts`,
         contente: mapperFileContent,
       });
 
@@ -291,53 +336,42 @@ export enum Role {
       await createFile({
         path: `${entityPath}/infrastructure/services/${entityNameLower}.service.ts`,
         contente: `
-// Le service est responsable de la logique métier de l'application. Il agit comme un orchestrateur entre
-// différents composants tels que les repositories, les use cases et les adaptateurs.
-
-import { Inject } from '@nestjs/common';
-import { I${entityNameCapitalized}Repository } from 'src/${entityNameLower}/application/interfaces/${entityNameLower}.repository.interface';
+import { Injectable } from '@nestjs/common';
+import { Create${entityNameCapitalized}UseCase } from 'src/${entityNameLower}/application/use-cases/create-${entityNameLower}.use-case';
+import { Update${entityNameCapitalized}UseCase } from 'src/${entityNameLower}/application/use-cases/update-${entityNameLower}.use-case';
+import { GetById${entityNameCapitalized}UseCase } from 'src/${entityNameLower}/application/use-cases/getById-${entityNameLower}.use-case';
+import { GetAll${entityNameCapitalized}UseCase } from 'src/${entityNameLower}/application/use-cases/getAll-${entityNameLower}.use-case';
+import { Delete${entityNameCapitalized}UseCase } from 'src/${entityNameLower}/application/use-cases/delete-${entityNameLower}.use-case';
+import { Create${entityNameCapitalized}Dto, Update${entityNameCapitalized}Dto } from 'src/${entityNameLower}/application/dtos/${entityNameLower}.dto';
+import { ${entityNameCapitalized}Entity } from 'src/${entityNameLower}/domain/entities/${entityNameLower}.entity';
 
+@Injectable()
 export class ${entityNameCapitalized}Service {
   constructor(
-    @Inject("I${entityNameCapitalized}Repository")
-    private readonly repository: I${entityNameCapitalized}Repository,
+    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,
   ) {}
 
-  // La méthode 'process' prend en charge la logique pour traiter les données.
-  async process(data: any) {
-    if (!data || !data.id) {
-      throw new Error('Données invalides, ID requis');
-    }
-
-    const entityFromDb = await this.repository.findById(data.id);
-
-    if (!entityFromDb) {
-      throw new Error('Entité non trouvée avec cet ID');
-    }
-
-    const processedData = {
-      ...entityFromDb,
-      updatedAt: new Date(),
-      processedBy: 'System',
-    };
-
-    return processedData;
+  async create(dto: Create${entityNameCapitalized}Dto): Promise<${entityNameCapitalized}Entity> {
+    return await this.createUseCase.execute(dto);
   }
-
-  // Vous pouvez ajouter d'autres méthodes métier ici si nécessaire.
-  async create(data: any) {
-    // Logique pour créer une nouvelle entité
+  async update(id: string, dto: Update${entityNameCapitalized}Dto): Promise<${entityNameCapitalized}Entity | null> {
+    return await this.updateUseCase.execute(id, dto);
   }
-
-  async update(id: string, data: any) {
-    // Logique pour mettre à jour une entité existante
+  async getById(id: string): Promise<${entityNameCapitalized}Entity | null> {
+    return await this.getByIdUseCase.execute(id);
   }
-
-  async delete(id: string) {
-    // Logique pour supprimer une entité
+  async getAll(): Promise<${entityNameCapitalized}Entity[]> {
+    return await this.getAllUseCase.execute();
+  }
+  async delete(id: string): Promise<void> {
+    return await this.deleteUseCase.execute(id);
   }
 }
-`,
+`.trim(),
       });
 
       // 📌 9. Adapter
@@ -372,99 +406,56 @@ 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}])`
+        );
+      } else if (dbConfig.orm === "mongoose") {
+        extraImports = `import { MongooseModule } from '@nestjs/mongoose';
+import { ${entityNameCapitalized}, ${entityNameCapitalized}Schema } from '${entityPath}/domain/entities/${entityNameLower}.schema';`;
+        importsBlock.push(
+          `MongooseModule.forFeature([{ name: ${entityNameCapitalized}.name, schema: ${entityNameCapitalized}Schema }])`
+        );
       }
 
+      // Ajoute l'import du service
+      extraImports += `\nimport { ${entityNameCapitalized}Service } from '${entityPath}/infrastructure/services/${entityNameLower}.service';`;
+
+      // Always necessary providers
+      providersBlock.push(
+        `{
+        provide: 'I${entityNameCapitalized}Repository',
+        useClass: ${entityNameCapitalized}Repository,
+        }`,
+        `${entityNameCapitalized}Service`,
+        `${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 +463,13 @@ 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
+ * - Service
  */
 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 +478,21 @@ 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    ")}
   ],
+  exports: [
+    ${entityNameCapitalized}Service
+  ]
 })
-/**
- * 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(),
       });
@@ -562,7 +524,7 @@ import { APP_INTERCEPTOR } from '@nestjs/core';`,
   },`,
     });
 
-    logSuccess("structure Clean Architecture générée avec succès !");
+    logSuccess(`structure generé avec succes !`);
   } catch (error) {
     logError(`process currency have error: ${error}`);
   }

package/utils/setups/orms/typeOrmSetup.js

@@ -39,7 +39,7 @@ DB_DATABASE=${dbConfig.POSTGRES_DB}
 TypeOrmModule.forRoot({
   type: 'postgres',
   host: process.env.DB_HOST,
-  port: process.env.DB_PORT ? parseInt(process.env.DB_PORT, 10) : 3000,
+  port: process.env.DB_PORT ? parseInt(process.env.DB_PORT, 10) : 5432,
   username: process.env.DB_USERNAME,
   password: process.env.DB_PASSWORD,
   database: process.env.DB_DATABASE,