nestcraftx 0.2.6 → 0.4.0

package/utils/generators/presentation/controllerGenerator.js

@@ -0,0 +1,142 @@
+/**
+ * utils/generators/presentation/controllerGenerator.js
+ *
+ * Générateur du Controller (présentation) pour le mode Full/Clean Architecture.
+ * Extrait de utils.js — Phase 1B.
+ *
+ * ATTENTION : Ce générateur est UNIQUEMENT pour le mode Full.
+ * Le mode Light a son propre générateur dans setupLightArchitecture.js
+ * avec des différences comportementales :
+ *   - Full  : chemins "presentation/controllers/", méthodes getAll()/getById()
+ *   - Light : chemins "controllers/", méthodes findAll()/findById(), Logger intégré
+ *
+ * Ne jamais fusionner les deux.
+ */
+
+const { capitalize, decapitalize, pluralize } = require("../../helpers");
+
+/**
+ * Génère le contenu TypeScript du Controller NestJS (Full Architecture).
+ *
+ * @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
+ * @returns {Promise<string>} Le code TypeScript du controller
+ */
+async function generateController(entityName, entityPath, useSwagger) {
+  const entityNameLower = decapitalize(entityName);
+  const entityNameCapitalized = capitalize(entityName);
+  const pluralName = pluralize(entityNameLower);
+
+  const swaggerImports = useSwagger
+    ? `import { ApiTags, ApiOperation, ApiResponse, ApiParam } from '@nestjs/swagger';`
+    : "";
+
+  const swaggerClassDecorator = useSwagger
+    ? `@ApiTags('${capitalize(pluralName)}')`
+    : "";
+
+  return `
+import { Controller, Get, Post, Body, Param, Patch, Delete, HttpCode, HttpStatus, Query } from '@nestjs/common';
+${swaggerImports}
+import { ${entityNameCapitalized}Service } from '${entityPath}/application/services/${entityNameLower}.service';
+import { Create${entityNameCapitalized}Dto, Update${entityNameCapitalized}Dto } from 'src/${entityNameLower}/application/dtos/${entityNameLower}.dto';
+
+
+/**
+ * Controller for ${entityNameCapitalized} management.
+ * Handles incoming HTTP requests and delegates logic to the service layer.
+ */
+${swaggerClassDecorator}
+@Controller('${pluralName}')
+export class ${entityNameCapitalized}Controller {
+  constructor(private readonly service: ${entityNameCapitalized}Service) {}
+
+  ${
+    entityNameLower !== "user"
+      ? `
+  @Post()
+  @HttpCode(HttpStatus.CREATED)
+  ${
+    useSwagger
+      ? `
+  @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.' })`
+      : ""
+  }
+  async create(@Body() dto: Create${entityNameCapitalized}Dto) {
+    const result = await this.service.create(dto);
+    return {
+      message: '${entityNameCapitalized} created successfully',
+      data: result
+    };
+  }
+  `
+      : ""
+  }
+
+  @Get()
+  ${
+    useSwagger
+      ? `
+  @ApiOperation({ summary: 'Get all ${pluralName}', description: 'Retrieves a list of all ${pluralName} available.' })
+  @ApiResponse({ status: 200, description: 'Return all ${pluralName}.' })`
+      : ""
+  }
+  async getAll() {
+    return await this.service.getAll();
+  }
+
+  @Get(':id')
+  ${
+    useSwagger
+      ? `
+  @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.' })`
+      : ""
+  }
+  async getById(@Param('id') id: string) {
+    return await this.service.getById(id);
+  }
+
+  @Patch(':id')
+  ${
+    useSwagger
+      ? `
+  @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.' })`
+      : ""
+  }
+  async update(
+    @Param('id') id: string,
+    @Body() dto: Update${entityNameCapitalized}Dto,
+  ) {
+    await this.service.update(id, dto);
+    return { message: '${entityNameCapitalized} updated successfully' };
+  }
+
+  @Delete(':id')
+  @HttpCode(HttpStatus.NO_CONTENT)
+  ${
+    useSwagger
+      ? `
+  @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.' })`
+      : ""
+  }
+  async delete(@Param('id') id: string) {
+    await this.service.delete(id);
+    return { message: '${entityNameCapitalized} deleted successfully' };
+  }
+}
+`;
+}
+
+module.exports = { generateController };

package/utils/helpers.js

@@ -0,0 +1,115 @@
+/**
+ * utils/helpers.js
+ *
+ * Fonctions utilitaires de manipulation de chaînes et de types.
+ * Partagées entre les générateurs full-mode et light-mode.
+ *
+ * Ces fonctions sont purement stateless : aucune dépendance externe,
+ * aucun effet de bord, aucune logique métier.
+ */
+
+/**
+ * Met en majuscule la première lettre d'une chaîne.
+ * @param {string} str
+ * @returns {string}
+ */
+function capitalize(str) {
+  if (!str) return str;
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+
+/**
+ * Met en minuscule la première lettre d'une chaîne.
+ * @param {string} str
+ * @returns {string}
+ */
+function decapitalize(str) {
+  if (!str) return str;
+  return str.charAt(0).toLowerCase() + str.slice(1);
+}
+
+/**
+ * Retourne le pluriel simple d'un nom.
+ * - si finit par 'y' → remplace par 'ies' (category → categories)
+ * - si finit déjà par 's' → retourne tel quel
+ * - sinon → ajoute 's'
+ * @param {string} name
+ * @returns {string}
+ */
+function pluralize(name) {
+  if (name.endsWith("y")) {
+    return name.slice(0, -1) + "ies";
+  } else if (name.endsWith("s")) {
+    return name;
+  }
+  return name + "s";
+}
+
+/**
+ * Mappe le type de champ interne (sélectionné par l'utilisateur) au type
+ * TypeScript correspondant pour la génération de code.
+ *
+ * @param {string} type - Le type de base (string, number, boolean, Date, json, etc.)
+ * @returns {string} Le type formaté TypeScript
+ */
+function formatType(type) {
+  switch (type.toLowerCase()) {
+    case "number":
+    case "decimal":
+      return "number";
+
+    case "boolean":
+      return "boolean";
+
+    case "date":
+      return "Date";
+
+    case "json":
+      return "Record<string, any>";
+
+    case "string":
+    case "text":
+    case "uuid":
+      return "string";
+  }
+
+  // Gère les tableaux (ex: 'string[]', 'number[]')
+  if (type.endsWith("[]")) {
+    return `${formatType(type.slice(0, -2))}[]`;
+  }
+
+  // Laisse passer les types complexes (DTO, Enum, classe custom)
+  if (type.match(/^[A-Za-z][A-Za-z0-9_]*$/)) {
+    return type;
+  }
+
+  return "any";
+}
+
+/**
+ * Gère les cas spéciaux avant l'application de formatType.
+ * Ex: le champ 'role' de type string est traité comme le type 'Role' (enum).
+ *
+ * @param {object} field - L'objet champ { name, type }
+ * @returns {string} Le type final formaté
+ */
+function getFormattedType(field) {
+  let typeStr;
+  if (field.name === "role" && field.type.toLowerCase().startsWith("string")) {
+    typeStr = "Role";
+  } else {
+    typeStr = formatType(field.type);
+  }
+  if (field.nullable) {
+    typeStr += " | null";
+  }
+  return typeStr;
+}
+
+module.exports = {
+  capitalize,
+  decapitalize,
+  pluralize,
+  formatType,
+  getFormattedType,
+};

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;