nestcraftx 0.4.0 → 1.0.0

package/utils/generators/infrastructure/mongooseSchemaGenerator.js

@@ -226,4 +226,81 @@ ${allFields}
 export const ${entityName}Schema = SchemaFactory.createForClass(${entityName});`.trim();
 }
 
-module.exports = { generateMongooseSchemaFileContent };
+/**
+ * Ajoute une relation entre deux schémas Mongoose EXISTANTS.
+ * Patche les deux fichiers .schema.ts pour ajouter les champs de référence.
+ *
+ * @param {string} source - Nom du module source (ex: "post")
+ * @param {string} target - Nom du module cible (ex: "user")
+ * @param {string} relationType - "n-1" | "1-n" | "1-1" | "n-n"
+ * @param {string} mode - "full" | "light"
+ */
+async function addMongooseRelation(source, target, relationType, mode = "full") {
+  const fs = require("fs");
+  const { updateFile } = require("../../userInput");
+
+  const sourceLow = source.toLowerCase();
+  const targetLow = target.toLowerCase();
+  const sourceCap = capitalize(source);
+  const targetCap = capitalize(target);
+
+  const isFull = mode === "full";
+
+  const sourceSchemaPath = isFull
+    ? `src/${sourceLow}/infrastructure/persistence/mongoose/${sourceLow}.schema.ts`
+    : `src/${sourceLow}/entities/${sourceLow}.schema.ts`;
+
+  const targetSchemaPath = isFull
+    ? `src/${targetLow}/infrastructure/persistence/mongoose/${targetLow}.schema.ts`
+    : `src/${targetLow}/entities/${targetLow}.schema.ts`;
+
+  // --- Champs à injecter dans SOURCE ---
+  let sourceField = "";
+  switch (relationType) {
+    case "n-1":
+    case "1-1":
+      // FK : référence vers un document cible
+      sourceField = `\n  @Prop({ type: 'ObjectId', ref: '${targetCap}' })\n  ${targetLow}Id: string;\n`;
+      break;
+    case "1-n":
+    case "n-n":
+      // Tableau de références vers la cible
+      sourceField = `\n  @Prop([{ type: 'ObjectId', ref: '${targetCap}' }])\n  ${targetLow}Ids: string[];\n`;
+      break;
+  }
+
+  // --- Champs inverses à injecter dans TARGET ---
+  let targetField = "";
+  switch (relationType) {
+    case "n-1":
+    case "n-n":
+      // Le target a un tableau de sources
+      targetField = `\n  @Prop([{ type: 'ObjectId', ref: '${sourceCap}' }])\n  ${sourceLow}Ids: string[];\n`;
+      break;
+    case "1-n":
+    case "1-1":
+      // Le target a une référence unique vers source
+      targetField = `\n  @Prop({ type: 'ObjectId', ref: '${sourceCap}' })\n  ${sourceLow}Id: string;\n`;
+      break;
+  }
+
+  // Patch source schema
+  if (fs.existsSync(sourceSchemaPath) && sourceField) {
+    await updateFile({
+      path: sourceSchemaPath,
+      pattern: new RegExp(`(export class ${sourceCap} \\{)`),
+      replacement: `$1${sourceField}`,
+    });
+  }
+
+  // Patch target schema
+  if (fs.existsSync(targetSchemaPath) && targetField) {
+    await updateFile({
+      path: targetSchemaPath,
+      pattern: new RegExp(`(export class ${targetCap} \\{)`),
+      replacement: `$1${targetField}`,
+    });
+  }
+}
+
+module.exports = { generateMongooseSchemaFileContent, addMongooseRelation };

package/utils/generators/infrastructure/repositoryGenerator.js

@@ -26,11 +26,54 @@ const { createFile } = require("../../file-system");
  * @param {"prisma"|"typeorm"|"mongoose"|"sequelize"} orm - L'ORM cible
  * @returns {Promise<void>}
  */
-async function generateRepository(entityName, orm) {
+async function generateRepository(entityName, orm, entityData = null) {
   const entityNameCapitalized = capitalize(entityName);
   const entityNameLower = entityName.toLowerCase();
   const entityPath = `src/${entityNameLower}`;
 
+  const path = require("path");
+  const fs = require("fs");
+
+  const configPath = path.join(process.cwd(), ".nestcraftx", ".nestcraftxrc");
+  let stringFields = [];
+  if (entityData && entityData.fields) {
+    stringFields = entityData.fields
+      .filter(f => f.type && (f.type.toLowerCase() === "string" || f.type.toLowerCase() === "text"))
+      .map(f => f.name);
+  } else if (fs.existsSync(configPath)) {
+    try {
+      const config = JSON.parse(fs.readFileSync(configPath, "utf8"));
+      const entity = config.entities?.find(e => e.name.toLowerCase() === entityNameLower);
+      if (entity && entity.fields) {
+        stringFields = entity.fields
+          .filter(f => f.type && (f.type.toLowerCase() === "string" || f.type.toLowerCase() === "text"))
+          .map(f => f.name);
+      }
+    } catch (e) {
+      // fallback
+    }
+  }
+
+  if (stringFields.length === 0) {
+    if (entityNameLower === "user") {
+      stringFields = ["email", "username"];
+    } else {
+      stringFields = ["name", "title"];
+    }
+  }
+
+  const prismaWhereClause = stringFields.length > 0
+    ? `where.OR = [\n        ` + stringFields.map(f => '{ ' + f + ': { contains: search, mode: \'insensitive\' } }').join(',\n        ') + `\n      ];`
+    : `// No searchable string fields defined`;
+
+  const typeormWhereClause = stringFields.length > 0
+    ? `where.push(\n        ` + stringFields.map(f => '{ ' + f + ': Like(`%' + '${search}' + '%`) }').join(',\n        ') + `\n      );`
+    : `// No searchable string fields defined`;
+
+  const mongooseWhereClause = stringFields.length > 0
+    ? `query.$or = [\n        ` + stringFields.map(f => '{ ' + f + ': { $regex: search, $options: \'i\' } }').join(',\n        ') + `\n      ];`
+    : `// No searchable string fields defined`;
+
   // Méthode supplémentaire findByEmail pour l'entité User
   const isUser = entityNameLower === "user";
   const getExtraMethods = (ormType) => {
@@ -81,7 +124,7 @@ async findByEmail(email: string): Promise<${entityNameCapitalized}Entity | null>
  */
 
 import { Injectable, NotFoundException } from '@nestjs/common';
-import { Repository } from 'typeorm';
+import { Repository, Like } from 'typeorm';
 import { InjectRepository } from '@nestjs/typeorm';
 import { ${entityNameCapitalized}Entity } from '${entityPath}/domain/entities/${entityNameLower}.entity';
 import { ${entityNameCapitalized} } from 'src/entities/${entityNameCapitalized}.entity';
@@ -125,9 +168,28 @@ export class ${entityNameCapitalized}Repository implements I${entityNameCapitali
   }
 
   // find all
-  async findAll(): Promise<${entityNameCapitalized}Entity[]> {
-    const records = await this.repository.find();
-    return records.map(record => this.mapper.toDomain(record));
+  async findAll(page: number = 1, limit: number = 10, search?: string, sortBy?: string, sortOrder?: string): Promise<{ data: ${entityNameCapitalized}Entity[], total: number }> {
+    const skip = (page - 1) * limit;
+    const where: any = [];
+    if (search) {
+      ${typeormWhereClause}
+    }
+    const order: any = {};
+    if (sortBy) {
+      order[sortBy] = sortOrder?.toUpperCase() === 'ASC' ? 'ASC' : 'DESC';
+    } else {
+      order.createdAt = 'DESC';
+    }
+    const [records, total] = await this.repository.findAndCount({
+      skip,
+      take: limit,
+      where: where.length > 0 ? where : undefined,
+      order,
+    });
+    return {
+      data: records.map(record => this.mapper.toDomain(record)),
+      total,
+    };
   }
 
   // delete
@@ -188,9 +250,31 @@ export class ${entityNameCapitalized}Repository implements I${entityNameCapitali
   }
 
   // find all
-  async findAll(): Promise<${entityNameCapitalized}Entity[]> {
-    const records = await this.prisma.${entityNameLower}.findMany();
-    return records.map(record => this.mapper.toDomain(record));
+  async findAll(page: number = 1, limit: number = 10, search?: string, sortBy?: string, sortOrder?: string): Promise<{ data: ${entityNameCapitalized}Entity[], total: number }> {
+    const skip = (page - 1) * limit;
+    const where: any = {};
+    if (search) {
+      ${prismaWhereClause}
+    }
+    const orderBy: any = {};
+    if (sortBy) {
+      orderBy[sortBy] = sortOrder === 'asc' ? 'asc' : 'desc';
+    } else {
+      orderBy.createdAt = 'desc';
+    }
+    const [records, total] = await this.prisma.$transaction([
+      this.prisma.${entityNameLower}.findMany({
+        skip,
+        take: limit,
+        where,
+        orderBy,
+      }),
+      this.prisma.${entityNameLower}.count({ where }),
+    ]);
+    return {
+      data: records.map(record => this.mapper.toDomain(record)),
+      total,
+    };
   }
 
   // delete
@@ -250,9 +334,26 @@ export class ${entityNameCapitalized}Repository implements I${entityNameCapitali
   }
 
   // find all
-  async findAll(): Promise<${entityNameCapitalized}Entity[]> {
-    const records = await this.model.find().exec();
-    return records.map(record => this.mapper.toDomain(record));
+  async findAll(page: number = 1, limit: number = 10, search?: string, sortBy?: string, sortOrder?: string): Promise<{ data: ${entityNameCapitalized}Entity[], total: number }> {
+    const skip = (page - 1) * limit;
+    const query: any = {};
+    if (search) {
+      ${mongooseWhereClause}
+    }
+    const sort: any = {};
+    if (sortBy) {
+      sort[sortBy] = sortOrder === 'asc' ? 1 : -1;
+    } else {
+      sort.createdAt = -1;
+    }
+    const [records, total] = await Promise.all([
+      this.model.find(query).sort(sort).skip(skip).limit(limit).exec(),
+      this.model.countDocuments(query).exec(),
+    ]);
+    return {
+      data: records.map(record => this.mapper.toDomain(record)),
+      total,
+    };
   }
 
   // delete
@@ -311,9 +412,8 @@ export class ${entityNameCapitalized}Repository implements I${entityNameCapitali
   }
 
   // find all
-  async findAll(): Promise<${entityNameCapitalized}Entity[]> {
-    const records = await this.model.find();
-    return records.map(record => this.mapper.toDomain(record));
+  async findAll(page: number = 1, limit: number = 10, search?: string, sortBy?: string, sortOrder?: string): Promise<{ data: ${entityNameCapitalized}Entity[], total: number }> {
+    throw new Error('Repository not implemented');
   }
 
   // delete

package/utils/generators/lightModuleGenerator.js

@@ -54,6 +54,19 @@ async function lightModuleGenerator(entity, config) {
       contente: dtoContent,
     });
 
+    if (entityNameLow === "user") {
+      await createDirectory(`src/common/enums`);
+      await createFile({
+        path: `src/common/enums/role.enum.ts`,
+        contente: `export enum Role {
+  USER = 'USER',
+  ADMIN = 'ADMIN',
+  SUPER_ADMIN = 'SUPER_ADMIN',
+}
+`,
+      });
+    }
+
     // 4️⃣ Générer le repository
     const repositoryContent = generateLightRepository(
       entityNameCap,
@@ -78,6 +91,7 @@ async function lightModuleGenerator(entity, config) {
       entityNameCap,
       entityNameLow,
       config.swagger,
+      config.auth || false,
     );
     await createFile({
       path: `${entityPath}/controllers/${entityNameLow}.controller.ts`,

package/utils/generators/presentation/controllerGenerator.js

@@ -21,27 +21,59 @@ const { capitalize, decapitalize, pluralize } = require("../../helpers");
  * @param {string} entityName - Le nom de l'entité (ex: "Post")
  * @param {string} entityPath - Le chemin de base (ex: "src/post")
  * @param {boolean} useSwagger - Inclure les décorateurs Swagger
+ * @param {boolean} useAuth - Inclure les guards RBAC (JwtAuthGuard + RolesGuard)
  * @returns {Promise<string>} Le code TypeScript du controller
  */
-async function generateController(entityName, entityPath, useSwagger) {
+async function generateController(entityName, entityPath, useSwagger, useAuth = false) {
   const entityNameLower = decapitalize(entityName);
   const entityNameCapitalized = capitalize(entityName);
   const pluralName = pluralize(entityNameLower);
 
+  // --- Imports NestJS de base ---
+  const nestImports = useAuth
+    ? `import { Controller, Get, Post, Body, Param, Patch, Delete, HttpCode, HttpStatus, Query, UseGuards } from '@nestjs/common';`
+    : `import { Controller, Get, Post, Body, Param, Patch, Delete, HttpCode, HttpStatus, Query } from '@nestjs/common';`;
+
+  // --- Imports Swagger ---
   const swaggerImports = useSwagger
-    ? `import { ApiTags, ApiOperation, ApiResponse, ApiParam } from '@nestjs/swagger';`
+    ? `import { ApiTags, ApiOperation, ApiResponse, ApiParam, ApiQuery${useAuth ? ', ApiBearerAuth, ApiUnauthorizedResponse, ApiForbiddenResponse' : ''} } from '@nestjs/swagger';`
+    : "";
+
+  // --- Imports Guards & Décorateurs (uniquement si auth activé) ---
+  const guardImports = useAuth
+    ? `import { JwtAuthGuard } from 'src/auth/infrastructure/guards/jwt-auth.guard';
+import { RolesGuard } from 'src/auth/infrastructure/guards/role.guard';
+import { Roles } from 'src/common/decorators/role.decorator';
+import { Public } from 'src/common/decorators/public.decorator';`
     : "";
 
+  // --- Décorateur de classe Swagger ---
   const swaggerClassDecorator = useSwagger
     ? `@ApiTags('${capitalize(pluralName)}')`
     : "";
 
+  // --- Snippet pour les routes protégées (ADMIN) ---
+  const adminGuards = useAuth
+    ? `  @UseGuards(JwtAuthGuard, RolesGuard)
+  @Roles('ADMIN')`
+    : "";
+
+  // --- Snippet @ApiBearerAuth pour les routes protégées ---
+  const apiBearerAuth = useAuth && useSwagger ? `  @ApiBearerAuth()` : "";
+  const apiUnauthorized = useAuth && useSwagger
+    ? `  @ApiUnauthorizedResponse({ description: 'Missing or invalid JWT token.' })
+  @ApiForbiddenResponse({ description: 'Insufficient permissions (ADMIN required).' })`
+    : "";
+
+  // --- Snippet @Public() pour les routes de lecture ---
+  const publicDecorator = useAuth ? `  @Public()` : "";
+
   return `
-import { Controller, Get, Post, Body, Param, Patch, Delete, HttpCode, HttpStatus, Query } from '@nestjs/common';
+${nestImports}
 ${swaggerImports}
 import { ${entityNameCapitalized}Service } from '${entityPath}/application/services/${entityNameLower}.service';
 import { Create${entityNameCapitalized}Dto, Update${entityNameCapitalized}Dto } from 'src/${entityNameLower}/application/dtos/${entityNameLower}.dto';
-
+${guardImports}
 
 /**
  * Controller for ${entityNameCapitalized} management.
@@ -55,14 +87,16 @@ export class ${entityNameCapitalized}Controller {
   ${
     entityNameLower !== "user"
       ? `
+${apiBearerAuth}
+${adminGuards}
   @Post()
   @HttpCode(HttpStatus.CREATED)
   ${
     useSwagger
-      ? `
-  @ApiOperation({ summary: 'Create a new ${entityNameLower}', description: 'Creates a new record for ${entityNameLower} in the database.' })
+      ? `@ApiOperation({ summary: 'Create a new ${entityNameLower}', description: 'Creates a new record for ${entityNameLower} in the database.' })
   @ApiResponse({ status: 201, description: 'The ${entityNameLower} has been successfully created.' })
-  @ApiResponse({ status: 400, description: 'Invalid input data.' })`
+  @ApiResponse({ status: 400, description: 'Invalid input data.' })
+  ${apiUnauthorized}`
       : ""
   }
   async create(@Body() dto: Create${entityNameCapitalized}Dto) {
@@ -76,23 +110,36 @@ export class ${entityNameCapitalized}Controller {
       : ""
   }
 
+${publicDecorator}
   @Get()
   ${
     useSwagger
-      ? `
-  @ApiOperation({ summary: 'Get all ${pluralName}', description: 'Retrieves a list of all ${pluralName} available.' })
+      ? `@ApiOperation({ summary: 'Get all ${pluralName}', description: 'Retrieves a list of all ${pluralName} available.' })
+  @ApiQuery({ name: 'page', required: false, type: Number, schema: { default: 1 } })
+  @ApiQuery({ name: 'limit', required: false, type: Number, schema: { default: 10 } })
+  @ApiQuery({ name: 'search', required: false, type: String, description: 'Search term' })
+  @ApiQuery({ name: 'sortBy', required: false, type: String, description: 'Field to sort by' })
+  @ApiQuery({ name: 'sortOrder', required: false, enum: ['asc', 'desc'], description: 'Sort order' })
   @ApiResponse({ status: 200, description: 'Return all ${pluralName}.' })`
       : ""
   }
-  async getAll() {
-    return await this.service.getAll();
+  async getAll(
+    @Query('page') page?: number,
+    @Query('limit') limit?: number,
+    @Query('search') search?: string,
+    @Query('sortBy') sortBy?: string,
+    @Query('sortOrder') sortOrder?: string,
+  ) {
+    const pageNum = page ? Number(page) : 1;
+    const limitNum = limit ? Number(limit) : 10;
+    return await this.service.getAll(pageNum, limitNum, search, sortBy, sortOrder);
   }
 
+${publicDecorator}
   @Get(':id')
   ${
     useSwagger
-      ? `
-  @ApiOperation({ summary: 'Get ${entityNameLower} by ID' })
+      ? `@ApiOperation({ summary: 'Get ${entityNameLower} by ID' })
   @ApiParam({ name: 'id', description: 'The unique identifier of the ${entityNameLower}' })
   @ApiResponse({ status: 200, description: 'The ${entityNameLower} has been found.' })
   @ApiResponse({ status: 404, description: '${entityNameCapitalized} not found.' })`
@@ -102,14 +149,16 @@ export class ${entityNameCapitalized}Controller {
     return await this.service.getById(id);
   }
 
+${apiBearerAuth}
+${adminGuards}
   @Patch(':id')
   ${
     useSwagger
-      ? `
-  @ApiOperation({ summary: 'Update an existing ${entityNameLower}' })
+      ? `@ApiOperation({ summary: 'Update an existing ${entityNameLower}' })
   @ApiParam({ name: 'id', description: 'The unique identifier of the ${entityNameLower} to update' })
   @ApiResponse({ status: 200, description: 'The ${entityNameLower} has been successfully updated.' })
-  @ApiResponse({ status: 404, description: '${entityNameCapitalized} not found.' })`
+  @ApiResponse({ status: 404, description: '${entityNameCapitalized} not found.' })
+  ${apiUnauthorized}`
       : ""
   }
   async update(
@@ -120,15 +169,17 @@ export class ${entityNameCapitalized}Controller {
     return { message: '${entityNameCapitalized} updated successfully' };
   }
 
+${apiBearerAuth}
+${adminGuards}
   @Delete(':id')
   @HttpCode(HttpStatus.NO_CONTENT)
   ${
     useSwagger
-      ? `
-  @ApiOperation({ summary: 'Delete a ${entityNameLower}' })
+      ? `@ApiOperation({ summary: 'Delete a ${entityNameLower}' })
   @ApiParam({ name: 'id', description: 'The unique identifier of the ${entityNameLower} to delete' })
   @ApiResponse({ status: 204, description: 'The ${entityNameLower} has been successfully deleted.' })
-  @ApiResponse({ status: 404, description: '${entityNameCapitalized} not found.' })`
+  @ApiResponse({ status: 404, description: '${entityNameCapitalized} not found.' })
+  ${apiUnauthorized}`
       : ""
   }
   async delete(@Param('id') id: string) {

package/utils/interactive/askRelationCommand.js

@@ -0,0 +1,98 @@
+// utils/interactive/askRelationCommand.js
+//
+// Prompt interactif autonome pour `nestcraftx g relation`.
+// Contrairement à askRelationInputs (qui s'intègre à la création d'un module),
+// cette fonction demande AUSSI la source, car les deux modules existent déjà.
+
+const inquirer = require("inquirer");
+const { capitalize } = require("../userInput");
+const { logWarning } = require("../loggers/logWarning");
+const { logError } = require("../loggers/logError");
+
+const actualInquirer = inquirer.default || inquirer;
+
+/**
+ * Demande interactivement la source, la cible et le type de relation.
+ * Valide que les deux modules existent dans config.entities[].
+ * Vérifie l'idempotence (relation déjà enregistrée dans config.relations[]).
+ *
+ * @param {object} config - La config lue depuis .nestcraftxrc
+ * @returns {Promise<{source: string, target: string, type: string} | null>}
+ */
+async function askRelationCommand(config) {
+  const entities = (config.entities || []).map((e) => capitalize(e.name));
+
+  if (entities.length < 2) {
+    logError(
+      "❌ Vous devez avoir au moins 2 modules générés pour créer une relation.\n" +
+      "   Lancez d'abord : nestcraftx g module <NomEntité>",
+    );
+    return null;
+  }
+
+  // 1. Demander la source
+  const { source } = await actualInquirer.prompt([
+    {
+      type: "list",
+      name: "source",
+      message: "Module SOURCE (le module qui porte la relation) :",
+      choices: entities,
+    },
+  ]);
+
+  // 2. Demander la cible (exclure la source)
+  const targetChoices = entities.filter((e) => e !== source);
+
+  if (targetChoices.length === 0) {
+    logError("❌ Aucun autre module disponible comme cible.");
+    return null;
+  }
+
+  const { target } = await actualInquirer.prompt([
+    {
+      type: "list",
+      name: "target",
+      message: `Module CIBLE (lié à ${source}) :`,
+      choices: targetChoices,
+    },
+  ]);
+
+  // 3. Demander le type de relation
+  const { type } = await actualInquirer.prompt([
+    {
+      type: "list",
+      name: "type",
+      message: `Type de relation (${source} → ${target}) :`,
+      choices: [
+        { name: `n-1  (Many-to-One  : chaque ${source} appartient à un ${target})`, value: "n-1" },
+        { name: `1-n  (One-to-Many  : un ${source} possède plusieurs ${target}s)`, value: "1-n" },
+        { name: `1-1  (One-to-One   : un ${source} est lié à exactement un ${target})`, value: "1-1" },
+        { name: `n-n  (Many-to-Many : plusieurs ${source}s liés à plusieurs ${target}s)`, value: "n-n" },
+      ],
+    },
+  ]);
+
+  // 4. Vérification d'idempotence — relation déjà enregistrée ?
+  const existing = (config.relations || []).find(
+    (r) =>
+      r.from.toLowerCase() === source.toLowerCase() &&
+      r.to.toLowerCase() === target.toLowerCase() &&
+      r.type === type,
+  );
+
+  if (existing) {
+    logWarning(
+      `⚠️  La relation ${source} →(${type})→ ${target} existe déjà dans .nestcraftxrc.\n` +
+      "   Aucune modification effectuée.",
+    );
+    return null;
+  }
+
+  return {
+    source: source.toLowerCase(),
+    target: target.toLowerCase(),
+    type,
+  };
+}
+
+module.exports = { askRelationCommand };

package/utils/interactive/entityBuilder.js

@@ -50,6 +50,7 @@ async function buildEntityInteractive(initialName) {
         if (f.unique) constraints.push("unique");
         if (f.nullable) constraints.push("nullable");
         if (f.default !== null && f.default !== "") constraints.push(`default: ${f.default}`);
+        if (f.description) constraints.push(`desc: "${f.description}"`);
         const constraintStr = constraints.length > 0 ? ` (${constraints.join(", ")})` : "";
         console.log(`  ${idx + 1}. ${f.name} : ${f.type}${constraintStr}`);
       });
@@ -256,12 +257,22 @@ async function promptFieldDetails(fieldName, existingField = null) {
     defaultValue = null;
   }
 
+  let descriptionPrompt = "  Description (press Enter for auto): ";
+  if (existingField && existingField.description) {
+    descriptionPrompt = `  Description [${existingField.description}]: `;
+  }
+  let descriptionValue = readline.question(descriptionPrompt);
+  if (descriptionValue === "") {
+    descriptionValue = existingField ? existingField.description : null;
+  }
+
   return {
     name: fieldName,
     type: ftype,
     unique: isUnique,
     nullable: isNullable,
     default: defaultValue,
+    description: descriptionValue || null,
   };
 }
 

package/utils/lightModeInput.js

@@ -94,12 +94,16 @@ async function getLightModeInputs(projectName, flags) {
   // JWT Auth config
   const useAuth = getAuthChoice(flags);
 
+  // Throttler config
+  const useThrottler = getThrottlerChoice(flags);
+
   const packageManager = await getPackageManager(flags);
   inputs.packageManager = packageManager;
 
   inputs.useAuth = useAuth;
   inputs.useSwagger = useSwagger;
   inputs.useDocker = useDocker;
+  inputs.useThrottler = useThrottler;
 
   if (useAuth) {
     console.log(
@@ -224,4 +228,14 @@ function getDockerChoice(flags) {
   return readline.keyInYNStrict(`${info("[?]")} Generate Docker files ?`);
 }
 
+function getThrottlerChoice(flags) {
+  if (flags.throttler !== undefined) {
+    console.log(
+      `${info("[INFO]")} Throttler: ${flags.throttler ? "Yes" : "No"} (via flag)`
+    );
+    return flags.throttler === true || flags.throttler === "true";
+  }
+  return readline.keyInYNStrict(`${info("[?]")} Enable Rate Limiting (Throttler) ?`);
+}
+
 module.exports = { getLightModeInputs };

package/utils/setups/orms/typeOrmSetup.js

@@ -21,8 +21,11 @@ async function setupTypeORM(inputs) {
   logInfo("📦 Installing TypeORM and PostgreSQL dependencies...");
 
   const mode = inputs.mode;
+  const pkgManager = inputs.packageManager || "npm";
+  const installCmd = pkgManager === "yarn" || pkgManager === "pnpm" ? `${pkgManager} add` : "npm install";
+
   await runCommand(
-    "npm install @nestjs/typeorm typeorm pg reflect-metadata",
+    `${installCmd} @nestjs/typeorm@^10.0.2 typeorm@^0.3.20 pg@^8.11.3 reflect-metadata@^0.2.1`,
     "TypeORM and PostgreSQL dependencies installed successfully"
   ); // Updating app.module.ts with TypeORM
 
@@ -446,13 +449,17 @@ async function setupTypeOrmSeeding(inputs) {
     "typeorm-extension",
   ];
 
+  const pkgManager = inputs.packageManager || "npm";
+  const installDevCmd = pkgManager === "yarn" || pkgManager === "pnpm" ? `${pkgManager} add -D` : "npm install -D";
+  const installCmd = pkgManager === "yarn" || pkgManager === "pnpm" ? `${pkgManager} add` : "npm install";
+
   await runCommand(
-    `${inputs.packageManager} add -D ${typeOrmDevDeps.join(" ")}`,
+    `${installDevCmd} ${typeOrmDevDeps.join(" ")}`,
     "❌ Failed to install TypeORM seeding dependencies"
   );
 
   await runCommand(
-    `${inputs.packageManager} install bcrypt`,
+    `${installCmd} bcrypt`,
     "❌ Failed to install bcrypt"
   );
 
@@ -462,7 +469,7 @@ async function setupTypeOrmSeeding(inputs) {
       "typeorm-ts-node-commonjs migration:run -d ./src/database/typeorm.config.ts",
     "typeorm:seed":
       "typeorm-extension seed:run -d src/database/typeorm.config.ts",
-    seed: "npm run typeorm:seed",
+    seed: `${pkgManager} run typeorm:seed`,
   };
 
   await updatePackageJson(inputs, typeOrmScripts);