nestcraftx 0.3.0 → 1.0.0

package/utils/configs/setupLightArchitecture.js

@@ -124,6 +124,7 @@ async function setupLightArchitecture(inputs) {
         entityNameCapitalized,
         entityNameLower,
         useSwagger,
+        useAuth || false,
       );
       await createFile({
         path: `${entityPath}/controllers/${entityNameLower}.controller.ts`,
@@ -282,9 +283,19 @@ export class ${entityName}Repository {
 
   ${extraMethods}
 
-  async findAll(): Promise<${entityName}Entity[]> {
-    const results = await this.prisma.${entityLower}.findMany();
-    return results.map(r => this.toEntity(r));
+  async findAll(page: number = 1, limit: number = 10): Promise<{ data: ${entityName}Entity[], total: number }> {
+    const skip = (page - 1) * limit;
+    const [results, total] = await this.prisma.$transaction([
+      this.prisma.${entityLower}.findMany({
+        skip,
+        take: limit,
+      }),
+      this.prisma.${entityLower}.count(),
+    ]);
+    return {
+      data: results.map(r => this.toEntity(r)),
+      total,
+    };
   }
 
   async update(id: string, data: Update${entityName}Dto): Promise<${entityName}Entity | null> {
@@ -346,9 +357,16 @@ export class ${entityName}Repository {
 
   ${extraMethods}
 
-  async findAll(): Promise<${entityName}Entity[]> {
-    const results = await this.repository.find();
-    return results.map(r => this.toEntity(r));
+  async findAll(page: number = 1, limit: number = 10): Promise<{ data: ${entityName}Entity[], total: number }> {
+    const skip = (page - 1) * limit;
+    const [results, total] = await this.repository.findAndCount({
+      skip,
+      take: limit,
+    });
+    return {
+      data: results.map(r => this.toEntity(r)),
+      total,
+    };
   }
 
   async update(id: string, data: Update${entityName}Dto): Promise<${entityName}Entity | null> {
@@ -415,9 +433,16 @@ export class ${entityName}Repository {
 
   ${extraMethods}
 
-  async findAll(): Promise<${entityName}Entity[]> {
-    const results = await this.model.find().exec();
-    return results.map(r => this.toEntity(r));
+  async findAll(page: number = 1, limit: number = 10): Promise<{ data: ${entityName}Entity[], total: number }> {
+    const skip = (page - 1) * limit;
+    const [results, total] = await Promise.all([
+      this.model.find().skip(skip).limit(limit).exec(),
+      this.model.countDocuments().exec(),
+    ]);
+    return {
+      data: results.map(r => this.toEntity(r)),
+      total,
+    };
   }
 
   async update(id: string, data: Update${entityName}Dto): Promise<${entityName}Entity | null> {
@@ -457,7 +482,7 @@ export class ${entityName}Repository {
 
   ${extraMethods}
 
-  async findAll(): Promise<${entityName}Entity[]> {
+  async findAll(page: number = 1, limit: number = 10): Promise<{ data: ${entityName}Entity[], total: number }> {
     throw new Error('Repository not implemented');
   }
 
@@ -513,11 +538,20 @@ export class ${entityName}Service {
     return entity;
   }
 
-  async findAll(): Promise<${entityName}Entity[]> {
-    this.logger.log('Fetching all ${entityName} records');
-    const results = await this.repository.findAll();
-    this.logger.log(\`Successfully retrieved \${results.length} ${entityName}(s)\`);
-    return results;
+  async findAll(page: number = 1, limit: number = 10): Promise<{ data: ${entityName}Entity[], meta: { total: number, page: number, limit: number, totalPages: number } }> {
+    this.logger.log(\`Fetching page \${page} of ${entityName} records (limit: \${limit})\`);
+    const { data, total } = await this.repository.findAll(page, limit);
+    const totalPages = Math.ceil(total / limit);
+    this.logger.log(\`Successfully retrieved \${data.length} of \${total} ${entityName}(s)\`);
+    return {
+      data,
+      meta: {
+        total,
+        page,
+        limit,
+        totalPages,
+      },
+    };
   }
 
   async update(id: string, dto: Update${entityName}Dto): Promise<${entityName}Entity> {
@@ -549,21 +583,46 @@ export class ${entityName}Service {
 }`;
 }
 
-function generateLightController(entityName, entityLower, useSwagger) {
+function generateLightController(entityName, entityLower, useSwagger, useAuth = false) {
   const entityCap = capitalize(entityName);
   const pluralName = pluralize(entityLower);
 
+  // --- Imports NestJS de base ---
+  const nestCoreImports = useAuth
+    ? `import { Controller, Get, Post, Patch, Delete, Body, Param, Query, Logger, HttpCode, HttpStatus, UseGuards } from '@nestjs/common';`
+    : `import { Controller, Get, Post, Patch, Delete, Body, Param, Query, Logger, HttpCode, HttpStatus } from '@nestjs/common';`;
+
+  // --- Imports Swagger ---
   const swaggerImports = useSwagger
-    ? `import { ApiTags, ApiOperation, ApiResponse, ApiParam } from '@nestjs/swagger';\n`
+    ? `import { ApiTags, ApiOperation, ApiResponse, ApiParam, ApiQuery${useAuth ? ', ApiBearerAuth, ApiUnauthorizedResponse, ApiForbiddenResponse' : ''} } from '@nestjs/swagger';\n`
+    : "";
+
+  // --- Imports Guards & Décorateurs (uniquement si auth activé) ---
+  const guardImports = useAuth
+    ? `import { JwtAuthGuard } from 'src/auth/guards/jwt-auth.guard';
+import { RolesGuard } from 'src/auth/guards/role.guard';
+import { Roles } from 'src/common/decorators/role.decorator';
+import { Public } from 'src/common/decorators/public.decorator';`
     : "";
 
   const swaggerDecorators = useSwagger
     ? `@ApiTags('${capitalize(pluralName)}')\n`
     : "";
 
-  return `import { Controller, Get, Post, Patch, Delete, Body, Param, Logger, HttpCode, HttpStatus } from '@nestjs/common';
+  // --- Snippets décorateurs ---
+  const adminGuards = useAuth
+    ? `  @UseGuards(JwtAuthGuard, RolesGuard)\n  @Roles('ADMIN')`
+    : "";
+  const apiBearerAuth = useAuth && useSwagger ? `  @ApiBearerAuth()` : "";
+  const apiUnauthorized = useAuth && useSwagger
+    ? `  @ApiUnauthorizedResponse({ description: 'Missing or invalid JWT token.' })\n  @ApiForbiddenResponse({ description: 'Insufficient permissions (ADMIN required).' })`
+    : "";
+  const publicDecorator = useAuth ? `  @Public()` : "";
+
+  return `${nestCoreImports}
 ${swaggerImports}import { ${entityCap}Service } from '../services/${entityLower}.service';
 import { Create${entityCap}Dto, Update${entityCap}Dto } from '../dtos/${entityLower}.dto';
+${guardImports}
 
 ${swaggerDecorators}@Controller('${pluralName}')
 export class ${entityCap}Controller {
@@ -571,10 +630,12 @@ export class ${entityCap}Controller {
 
   constructor(private readonly service: ${entityCap}Service) {}
 
+${apiBearerAuth}
+${adminGuards}
   @Post()
   ${
     useSwagger
-      ? `@ApiOperation({ summary: 'Create a new ${entityLower}' })\n  @ApiResponse({ status: 201, description: 'The record has been successfully created.' })`
+      ? `@ApiOperation({ summary: 'Create a new ${entityLower}' })\n  @ApiResponse({ status: 201, description: 'The record has been successfully created.' })\n  ${apiUnauthorized}`
       : ""
   }
   async create(@Body() dto: Create${entityCap}Dto) {
@@ -585,17 +646,24 @@ export class ${entityCap}Controller {
     };
   }
 
+${publicDecorator}
   @Get()
   ${
     useSwagger
-      ? `@ApiOperation({ summary: 'Get all ${pluralName}' })\n  @ApiResponse({ status: 200, description: 'List of records retrieved.' })`
+      ? `@ApiOperation({ summary: 'Get all ${pluralName}' })\n  @ApiQuery({ name: 'page', required: false, type: Number, schema: { default: 1 } })\n  @ApiQuery({ name: 'limit', required: false, type: Number, schema: { default: 10 } })\n  @ApiResponse({ status: 200, description: 'List of records retrieved.' })`
       : ""
   }
-  async findAll() {
-    this.logger.log(\`Fetching all ${pluralName}\`);
-    return await this.service.findAll();
+  async findAll(
+    @Query('page') page?: number,
+    @Query('limit') limit?: number,
+  ) {
+    this.logger.log(\`Fetching all ${pluralName} (page: \${page}, limit: \${limit})\`);
+    const pageNum = page ? Number(page) : 1;
+    const limitNum = limit ? Number(limit) : 10;
+    return await this.service.findAll(pageNum, limitNum);
   }
 
+${publicDecorator}
   @Get(':id')
   ${
     useSwagger
@@ -607,10 +675,12 @@ export class ${entityCap}Controller {
     return await this.service.findById(id);
   }
 
+${apiBearerAuth}
+${adminGuards}
   @Patch(':id')
   ${
     useSwagger
-      ? `@ApiOperation({ summary: 'Update ${entityLower}' })\n  @ApiParam({ name: 'id', type: String })\n  @ApiResponse({ status: 200, description: 'Record updated.' })`
+      ? `@ApiOperation({ summary: 'Update ${entityLower}' })\n  @ApiParam({ name: 'id', type: String })\n  @ApiResponse({ status: 200, description: 'Record updated.' })\n  ${apiUnauthorized}`
       : ""
   }
   async update(@Param('id') id: string, @Body() dto: Update${entityCap}Dto) {
@@ -619,11 +689,13 @@ export class ${entityCap}Controller {
     return { message: '${entityCap} updated successfully' };
   }
 
+${apiBearerAuth}
+${adminGuards}
   @Delete(':id')
   @HttpCode(HttpStatus.NO_CONTENT)
   ${
     useSwagger
-      ? `@ApiOperation({ summary: 'Delete ${entityLower}' })\n  @ApiParam({ name: 'id', type: String })\n  @ApiResponse({ status: 204, description: 'Record deleted.' })`
+      ? `@ApiOperation({ summary: 'Delete ${entityLower}' })\n  @ApiParam({ name: 'id', type: String })\n  @ApiResponse({ status: 204, description: 'Record deleted.' })\n  ${apiUnauthorized}`
       : ""
   }
   async delete(@Param('id') id: string) {
@@ -631,7 +703,7 @@ export class ${entityCap}Controller {
     await this.service.delete(id);
     return {
       message: '${entityCap} deleted successfully',
-    };;
+    };
   }
 }`;
 }

package/utils/envGenerator.js

@@ -21,7 +21,8 @@ PORT=3000
 `;
 
   // --- AUTHENTICATION SECTION ---
-  content += `# ------------------------------------------------------------------------------
+  if (inputs.useAuth) {
+    content += `# ------------------------------------------------------------------------------
 # AUTHENTICATION (JWT)
 # ------------------------------------------------------------------------------
 # Auto-generated secrets to secure tokens.
@@ -34,6 +35,7 @@ JWT_EXPIRES_IN=15m
 JWT_REFRESH_EXPIRES_IN=7d
 
 `;
+  }
 
   // --- DATABASE SECTION ---
   content += `# ------------------------------------------------------------------------------
@@ -85,6 +87,12 @@ function buildDatabaseUrl(user, password, host, port, database, orm) {
 }
 
 function writeEnvFile(envContent, projectPath = ".") {
+  const isDryRun = process.argv.includes("--dry-run");
+  if (isDryRun) {
+    console.log(`[DRY-RUN] Simulated: write env file to ${path.join(projectPath, ".env")}`);
+    console.log(`[DRY-RUN] Simulated: write env example file to ${path.join(projectPath, ".env.example")}`);
+    return;
+  }
   // Écriture du .env (avec secrets)
   const envPath = path.join(projectPath, ".env");
   fs.writeFileSync(envPath, envContent, "utf8");

package/utils/file-system.js

@@ -15,6 +15,11 @@ const fs = require("fs");
  * @param {string} directoryPath - Le chemin du répertoire à créer.
  */
 async function createDirectory(directoryPath) {
+  const isDryRun = process.argv.includes("--dry-run");
+  if (isDryRun) {
+    console.log(`[DRY-RUN] Simulated: create directory ${directoryPath}`);
+    return;
+  }
   try {
     if (!fs.existsSync(directoryPath)) {
       fs.mkdirSync(directoryPath, { recursive: true });
@@ -36,6 +41,11 @@ async function createDirectory(directoryPath) {
  * @param {{ path: string, contente: string, overwrite?: boolean }} fileData
  */
 async function createFile(fileData) {
+  const isDryRun = process.argv.includes("--dry-run");
+  if (isDryRun) {
+    console.log(`[DRY-RUN] Simulated: create/write file ${fileData.path}`);
+    return;
+  }
   try {
     if (!fs.existsSync(fileData.path)) {
       fs.writeFileSync(`${fileData.path}`, `${fileData.contente}`);
@@ -59,6 +69,11 @@ async function createFile(fileData) {
  * @param {{ path: string, pattern: string|RegExp, replacement: string }} options
  */
 async function updateFile({ path, pattern, replacement }) {
+  const isDryRun = process.argv.includes("--dry-run");
+  if (isDryRun) {
+    console.log(`[DRY-RUN] Simulated: update file ${path}`);
+    return;
+  }
   try {
     let mainTs = fs.readFileSync(path, "utf8");
     const updatedContent = mainTs.replace(pattern, replacement);

package/utils/file-utils/packageJsonUtils.js

@@ -13,6 +13,12 @@ async function updatePackageJson(inputs, scripts, devDependencies = {}) {
   const projectPath = process.cwd();
   const packageJsonPath = path.join(projectPath, "package.json");
 
+  const isDryRun = process.argv.includes("--dry-run");
+  if (isDryRun) {
+    console.log(`[DRY-RUN] Simulated: update package.json scripts and devDependencies for ${inputs.projectName}`);
+    return;
+  }
+
   try {
     // 1. Lire le contenu actuel
     const fileContent = fs.readFileSync(packageJsonPath, "utf8");

package/utils/file-utils/saveProjectConfig.js

@@ -18,11 +18,20 @@ async function saveProjectConfig(inputs) {
     database: inputs.selectedDB,
     auth: inputs.useAuth,
     swagger: inputs.useSwagger,
+    throttler: inputs.useThrottler,
     packageManager: inputs.packageManager,
     docker: inputs.useDocker,
+    entities: inputs.entitiesData ? inputs.entitiesData.entities : [],
+    relations: inputs.entitiesData ? inputs.entitiesData.relations : [],
     generatedAt: new Date().toISOString(),
   };
 
+  const isDryRun = process.argv.includes("--dry-run");
+  if (isDryRun) {
+    console.log(`[DRY-RUN] Simulated: save project config to ${configFile}`);
+    return;
+  }
+
   try {
     if (!fs.existsSync(configDir)) {
       fs.mkdirSync(configDir, { recursive: true });

package/utils/fullModeInput.js

@@ -4,6 +4,7 @@ const inquirer = require("inquirer");
 const { capitalize } = require("./userInput");
 const { logWarning } = require("./loggers/logWarning");
 const { getPackageManager } = require("./utils");
+const { buildEntityInteractive, buildRelationsInteractive } = require("./interactive/entityBuilder");
 const actualInquirer = inquirer.default || inquirer;
 
 async function getFullModeInputs(projectName, flags) {
@@ -210,6 +211,8 @@ async function getFullModeInputs(projectName, flags) {
     { name: "auth", default: true, prompt: "Add JWT authentication?" },
 
     { name: "swagger", default: true, prompt: "Install Swagger?" },
+
+    { name: "throttler", default: true, prompt: "Enable Rate Limiting (Throttler)?" },
   ];
 
   const booleanResults = {};
@@ -238,6 +241,7 @@ async function getFullModeInputs(projectName, flags) {
   const useDocker = booleanResults.docker;
   const useAuth = booleanResults.auth;
   const useSwagger = booleanResults.swagger;
+  const useThrottler = booleanResults.throttler;
 
   // --- 5. Swagger Configuration (Prioritize flags) ---
   let swaggerInputs;
@@ -334,97 +338,13 @@ async function getFullModeInputs(projectName, flags) {
 
   let addEntity = readline.keyInYNStrict(`${info("[?]")} Add an entity?`);
   while (addEntity) {
-    let name;
-    while (true) {
-      name = readline.question(`\n Entity name : `);
-      if (/^[A-Za-z][A-Za-z0-9_]*$/.test(name)) break;
-      logWarning("Invalid name. Letters, numbers, _ (start with a letter).");
-    }
-
-    const fields = [];
-
-    console.log(` Fields for "${name}" :`);
-    while (true) {
-      let fname = readline.question("  Field name (leave empty to finish) : ");
-      if (!fname) break;
-      if (!/^[A-Za-z][A-Za-z0-9_]*$/.test(fname)) {
-        logWarning("Invalid field name.");
-        continue;
-      }
-
-      const baseTypeChoices = [
-        "string",
-        "text",
-        "number",
-        "decimal",
-        "boolean",
-        "Date",
-        "uuid",
-        "json",
-        "enum",
-        "array",
-        "object",
-      ];
-
-      const typeQuestion = {
-        type: "list",
-        name: "ftype",
-        message: `Type for "${fname}"`,
-        default: "string",
-        choices: baseTypeChoices,
-        transformer: () => "",
-      };
-      const typeAnswer = await actualInquirer.prompt([typeQuestion]);
-      let ftype = typeAnswer.ftype;
-      process.stdout.write("\x1B[1A");
-      process.stdout.write("\x1B[K");
-
-      if (ftype === "array") {
-        const arrayInnerQuestion = {
-          type: "list",
-          name: "innerType",
-          message: `Type of elements for "${fname}[]"`,
-          default: "string",
-          choices: baseTypeChoices.filter(
-            (c) => c !== "array" && c !== "object"
-          ),
-          transformer: () => "",
-        };
-
-        const innerAnswer = await actualInquirer.prompt([arrayInnerQuestion]);
-        ftype = `${innerAnswer.innerType}[]`;
-      } else if (ftype === "enum") {
-        const enumName = capitalize(fname) + "Enum";
-        console.log(
-          `  ${info(
-            "[INFO]"
-          )} Enum type selected. Consider defining ${enumName} in your code.`
-        );
-        ftype = enumName;
-      } else if (ftype === "object") {
-        const objectNameQuestion = {
-          type: "input",
-          name: "objectName",
-
-          message: `Complex type name (DTO/Class or leave 'json') :`,
-          default: "json",
-          transformer: () => "",
-        };
-
-        const objectAnswer = await actualInquirer.prompt([objectNameQuestion]);
-        ftype = capitalize(objectAnswer.objectName.trim() || "json");
-      }
-
-      console.log(`  Type for "${fname}" : ${ftype} ${success("[✓]")}`);
-
-      fields.push({ name: fname, type: ftype });
+    const entity = await buildEntityInteractive();
+    if (entity) {
+      entitiesData.entities.push(entity);
+      console.log(
+        `${success("[✓]")} Entity "${entity.name}" added with ${entity.fields.length} field(s)`
+      );
     }
-
-    entitiesData.entities.push({ name, fields });
-    console.log(
-      `${success("[✓]")} Entity "${name}" added with ${fields.length} field(s)`
-    );
-
     addEntity = readline.keyInYNStrict(`${info("[?]")} Add another entity?`);
   }
 
@@ -432,145 +352,7 @@ async function getFullModeInputs(projectName, flags) {
     `${info("[?]")} Add relationships between entities?`
   );
   if (wantsRelation) {
-    if (entitiesData.entities.length > 1) {
-      console.log(`\n${info("[INFO]")} Configuring relationships`);
-
-      let configuring = true;
-      while (configuring) {
-        const entityNames = entitiesData.entities.map((e) => e.name);
-
-        // 1. Select entities first
-        const selection = await actualInquirer.prompt([
-          {
-            type: "list",
-            name: "fromName",
-            message: "From which entity? (Source)",
-            choices: entityNames,
-          },
-          {
-            type: "list",
-            name: "toName",
-            message: (prev) =>
-              `To which entity should ${prev.fromName} be linked? (Target)`,
-            choices: (prev) =>
-              entityNames.filter((name) => name !== prev.fromName),
-          },
-        ]);
-
-        // --- VERIFICATION: Check if link already exists (A->B or B->A) ---
-        const alreadyExists = entitiesData.relations.find(
-          (rel) =>
-            (rel.from === selection.fromName && rel.to === selection.toName) ||
-            (rel.from === selection.toName && rel.to === selection.fromName)
-        );
-
-        if (alreadyExists) {
-          logWarning(
-            `A relationship already exists between ${selection.fromName} and ${selection.toName} (${alreadyExists.type}).`
-          );
-
-          const { tryAgain } = await actualInquirer.prompt([
-            {
-              type: "confirm",
-              name: "tryAgain",
-              message: "Do you want to choose different entities?",
-              default: true,
-            },
-          ]);
-
-          if (!tryAgain) break;
-          continue; // Restart selection
-        }
-
-        // 2. Select Relationship type only if verification passed
-        const typeAnswer = await actualInquirer.prompt([
-          {
-            type: "list",
-            name: "relType",
-            message: "Relationship type:",
-            choices: [
-              {
-                name: `1-1 (One-to-One)   : ${selection.fromName} has one ${selection.toName}`,
-                value: "1-1",
-              },
-              {
-                name: `1-n (One-to-Many)  : ${selection.fromName} has many ${selection.toName}s`,
-                value: "1-n",
-              },
-              {
-                name: `n-1 (Many-to-One)  : Many ${selection.fromName}s belong to one ${selection.toName}`,
-                value: "n-1",
-              },
-              {
-                name: `n-n (Many-to-Many) : Many ${selection.fromName}s linked to many ${selection.toName}s`,
-                value: "n-n",
-              },
-            ],
-          },
-        ]);
-
-        const from = entitiesData.entities.find(
-          (e) => e.name === selection.fromName
-        );
-        const to = entitiesData.entities.find(
-          (e) => e.name === selection.toName
-        );
-        const relType = typeAnswer.relType;
-
-        // Register Relationship
-        entitiesData.relations.push({
-          from: from.name,
-          to: to.name,
-          type: relType,
-        });
-
-        const fromLow = from.name.toLowerCase();
-        const toLow = to.name.toLowerCase();
-
-        // --- Add fields logic ---
-        if (relType === "1-1") {
-          from.fields.push(
-            { name: `${toLow}Id`, type: "string" },
-            { name: toLow, type: to.name }
-          );
-        } else if (relType === "1-n") {
-          from.fields.push({ name: `${toLow}s`, type: `${to.name}[]` });
-          to.fields.push(
-            { name: `${fromLow}Id`, type: "string" },
-            { name: fromLow, type: from.name }
-          );
-        } else if (relType === "n-1") {
-          from.fields.push(
-            { name: `${toLow}Id`, type: "string" },
-            { name: toLow, type: to.name }
-          );
-          to.fields.push({ name: `${fromLow}s`, type: `${from.name}[]` });
-        } else if (relType === "n-n") {
-          from.fields.push({ name: `${toLow}s`, type: `${to.name}[]` });
-          to.fields.push({ name: `${fromLow}s`, type: `${from.name}[]` });
-        }
-
-        console.log(
-          `\n${success("[✓]")} Relationship added: ${from.name} ${relType} ${
-            to.name
-          }`
-        );
-
-        const { addMore } = await actualInquirer.prompt([
-          {
-            type: "confirm",
-            name: "addMore",
-            message: "Add another relationship?",
-            default: false,
-          },
-        ]);
-        configuring = addMore;
-      }
-    } else {
-      logWarning(
-        "At least two entities are required to configure a relationship."
-      );
-    }
+    await buildRelationsInteractive(entitiesData);
   }
 
   return {
@@ -578,6 +360,7 @@ async function getFullModeInputs(projectName, flags) {
     useDocker,
     useAuth,
     useSwagger,
+    useThrottler,
     swaggerInputs,
     packageManager,
     entitiesData,