nestcraftx 0.3.0 → 1.0.0

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/helpers.js

@@ -94,10 +94,16 @@ function formatType(type) {
  * @returns {string} Le type final formaté
  */
 function getFormattedType(field) {
+  let typeStr;
   if (field.name === "role" && field.type.toLowerCase().startsWith("string")) {
-    return "Role";
+    typeStr = "Role";
+  } else {
+    typeStr = formatType(field.type);
   }
-  return formatType(field.type);
+  if (field.nullable) {
+    typeStr += " | null";
+  }
+  return typeStr;
 }
 
 module.exports = {

package/utils/interactive/askEntityInputs.js

@@ -6,78 +6,15 @@ const inquirer = require("inquirer");
 const { info, success } = require("../colors");
 const { logWarning } = require("../loggers/logWarning");
 const { capitalize } = require("../userInput");
+const { buildEntityInteractive } = require("./entityBuilder");
 const actualInquirer = inquirer.default || inquirer;
 
 async function askEntityInputs(targetName) {
-  const entity = { name: targetName, fields: [], relation: null };
-
-  console.log(
-    `\n${info("[ENTITY DESIGN]")} Define fields for "${targetName}" :`,
-  );
-
-  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",
-      "boolean",
-      "Date",
-      "uuid",
-      "json",
-      "enum",
-      "array",
-      "object",
-    ];
-
-    const typeAnswer = await actualInquirer.prompt([
-      {
-        type: "list",
-        name: "ftype",
-        message: `Type for "${fname}"`,
-        choices: baseTypeChoices,
-      },
-    ]);
-
-    let ftype = typeAnswer.ftype;
-
-    // Logique de raffinement des types (identique à ton script original)
-    if (ftype === "array") {
-      const inner = await actualInquirer.prompt([
-        {
-          type: "list",
-          name: "innerType",
-          message: `Type of elements for "${fname}[]"`,
-          choices: baseTypeChoices.filter(
-            (c) => c !== "array" && c !== "object",
-          ),
-        },
-      ]);
-      ftype = `${inner.innerType}[]`;
-    } else if (ftype === "enum") {
-      ftype = capitalize(fname) + "Enum";
-    } else if (ftype === "object") {
-      const obj = await actualInquirer.prompt([
-        {
-          type: "input",
-          name: "val",
-          message: "Complex type name :",
-          default: "json",
-        },
-      ]);
-      ftype = capitalize(obj.val);
-    }
-
-    entity.fields.push({ name: fname, type: ftype });
-    console.log(`  Type for "${fname}" : ${ftype} ${success("[✓]")}`);
+  const result = await buildEntityInteractive(targetName);
+  if (!result) {
+    throw new Error("Module generation cancelled by user.");
   }
+  const entity = { name: result.name, fields: result.fields, relation: null };
 
   const relationData = await askRelationInputs(entity.name);
   entity.relation = relationData;

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 };