nestcraftx 0.1.7 → 0.1.8

package/utils/configs/setupCleanArchitecture.js

@@ -14,6 +14,7 @@ const {
   generateMiddlewares,
   generateRepository,
   generateController,
+  generateMongooseSchemaFileContent,
 } = require("../utils");
 
 async function setupCleanArchitecture(inputs) {
@@ -83,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({
@@ -107,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;
         }
 
@@ -285,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,
       });
 
@@ -293,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
@@ -397,14 +429,24 @@ export class ${entityNameCapitalized}Adapter {
         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,
-  }`,
+        provide: 'I${entityNameCapitalized}Repository',
+        useClass: ${entityNameCapitalized}Repository,
+        }`,
+        `${entityNameCapitalized}Service`,
         `${entityNameCapitalized}Repository`,
         `Create${entityNameCapitalized}UseCase`,
         `Update${entityNameCapitalized}UseCase`,
@@ -424,6 +466,7 @@ export class ${entityNameCapitalized}Adapter {
  * - Repository
  * - Use Cases
  * - Mapper
+ * - Service
  */
 import { Module } from '@nestjs/common';
 ${extraImports}
@@ -446,6 +489,9 @@ import { ${entityNameCapitalized}Mapper } from '${entityPath}/domain/mappers/${e
   providers: [
     ${providersBlock.join(",\n    ")}
   ],
+  exports: [
+    ${entityNameCapitalized}Service
+  ]
 })
 export class ${entityNameCapitalized}Module {}
 `.trim(),
@@ -477,6 +523,8 @@ import { APP_INTERCEPTOR } from '@nestjs/core';`,
     useClass: ResponseInterceptor,
   },`,
     });
+
+    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,

package/utils/setups/setupAuth.js

@@ -34,53 +34,64 @@ async function setupAuth(inputs) {
     await createDirectory(path);
   });
 
-  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';`
-      : "";
+  let ormImports = "";
+  let ormModuleImport = "";
+  let prismaProvider = ""; // Pour n'ajouter PrismaService que si besoin
+
+  if (dbConfig.orm === "typeorm") {
+    ormImports = `import { TypeOrmModule } from '@nestjs/typeorm';
+import { User } from 'src/entities/User.entity';`;
+    ormModuleImport = `TypeOrmModule.forFeature([User]),`;
+    prismaProvider = "PrismaService,";
+  } 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 }]),`;
+    prismaProvider = ""; // Ne pas ajouter PrismaService
+  } else if (dbConfig.orm === "prisma") {
+    ormImports = "";
+    ormModuleImport = "";
+    prismaProvider = "PrismaService,";
+  }
 
   await createFile({
     path: `${authPath}/auth.module.ts`,
-    contente: `import { Module } from '@nestjs/common';
+    contente: `
+import { Module } from '@nestjs/common';
 import { JwtModule } from '@nestjs/jwt';
 import { PassportModule } from '@nestjs/passport';
 import { UserMapper } from 'src/user/domain/mappers/user.mapper';
-${typeormImports}
+${ormImports}
 import { AuthService } from '${authPaths.authServicesPath}/auth.service';
-import { PrismaService } from 'src/prisma/prisma.service';
-import { AuthController } from '${authPaths.authControllersPath}/auth.controller';
+${
+  dbConfig.orm === "prisma"
+    ? "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}
+    ${ormModuleImport}
+    PassportModule,
+    JwtModule.register({ secret: 'your-secret-key', signOptions: { expiresIn: '1h' } }),
   ],
   controllers: [AuthController],
   providers: [
-    PrismaService,
-    UserMapper,
-    {
-      provide: 'IUserRepository',
-      useClass: UserRepository,
-    },
+    ${prismaProvider}
     AuthService,
     JwtStrategy,
     AuthGuard
   ],
   exports: [AuthService],
 })
-export class AuthModule {}`,
+export class AuthModule {}
+`.trim(),
   });
 
   // 📌 Auth Service

package/utils/setups/setupDatabase.js

@@ -1,6 +1,7 @@
 const { logInfo } = require("../loggers/logInfo");
 const { runCommand } = require("../shell");
 const { setupTypeORM } = require("./orms/typeOrmSetup");
+const { setupMongoose } = require("./setupMongoose");
 const { setupPrisma } = require("./setupPrisma");
 
 async function setupDatabase(inputs) {
@@ -36,8 +37,7 @@ async function setupDatabase(inputs) {
 }
 async function setupMongoDB(inputs) {
   logInfo("Configuration de MongoDB...");
-  // Appelle un script spécifique à MongoDB
-  // await setupMongoDBConfig(inputs);
+  await setupMongoose(inputs);
 }
 async function setupSQLite(inputs) {
   logInfo("Configuration de SQLite...");

package/utils/setups/setupMongoose.js

@@ -0,0 +1,45 @@
+const { execSync } = require("child_process");
+const path = require("path");
+const { createFile, updateFile } = require("../userInput");
+const { logSuccess } = require("../loggers/logSuccess");
+const { logInfo } = require("../loggers/logInfo");
+
+async function setupMongoose(inputs) {
+  logInfo("📦 Installation de Mongoose et @nestjs/mongoose...");
+  execSync("npm install @nestjs/mongoose mongoose", { stdio: "inherit" });
+
+  // Génération du fichier .env
+  const envContent = `
+MONGO_URI=${inputs.dbConfig.MONGO_URI}
+MONGO_DB=${inputs.dbConfig.MONGO_DB}
+  `.trim();
+  await createFile({ path: ".env", contente: envContent });
+
+  // Ajout de l'import et de la configuration Mongoose dans app.module.ts
+  const appModulePath = path.join("src", "app.module.ts");
+  const mongooseImport = `import { MongooseModule } from '@nestjs/mongoose';`;
+
+  // Ajoute l'import si absent
+  await updateFile({
+    path: appModulePath,
+    pattern: /import {[\s\S]*?} from '@nestjs\/config';/,
+    replacement: (match) => `${match}\n${mongooseImport}`,
+  });
+
+  // Ajoute la configuration MongooseModule dans les imports
+  const importsPattern =
+    /imports:\s*\[[\s\S]*?ConfigModule\.forRoot\([\s\S]*?\),/;
+  await updateFile({
+    path: appModulePath,
+    pattern: importsPattern,
+    replacement: (match) =>
+      `${match}
+    MongooseModule.forRoot(process.env.MONGO_URI, {
+      dbName: process.env.MONGO_DB,
+    }),`,
+  });
+
+  logSuccess("Mongoose configuré et injecté dans app.module.ts !");
+}
+
+module.exports = { setupMongoose };

package/utils/setups/setupPrisma.js

@@ -210,8 +210,12 @@ function mapTypeToPrisma(type) {
   switch (type.toLowerCase()) {
     case "string":
       return "String";
+    case "int":
+      return "Int";
+    case "float":
+      return "Float";
     case "number":
-      return "Float"; // Tu peux aussi choisir Int si tu veux
+      return "Float"; // ou "Int" selon le besoin
     case "boolean":
       return "Boolean";
     case "date":