nestcraftx 0.2.5 → 0.3.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/generators/relation/relation.engine.js

@@ -0,0 +1,64 @@
+const { patchDtoWithRelation } = require("../application/dtoUpdater");
+const { patchMapperWithRelation } = require("../infrastructure/mapperUpdater");
+
+function resolveForeignKeyOwner(newEntityName, target, relationType) {
+  switch (relationType) {
+    case "1-n":
+      // FK on the N side → target
+      return null /*  {
+        ownerEntity: target,
+        relatedEntity: newEntityName,
+      } */;
+
+    case "n-1":
+      // FK on the N side → source
+      return {
+        ownerEntity: target,
+        relatedEntity: newEntityName,
+      };
+
+    case "1-1":
+      // Convention: FK on source side
+      return {
+        ownerEntity: target,
+        relatedEntity: newEntityName,
+      };
+
+    case "n-n":
+      // Pivot table → no FK field
+      return null;
+
+    default:
+      throw new Error(`❌ Unknown relation type: ${relationType}`);
+  }
+}
+
+async function applyRelationPatches(
+  newEntityName,
+  target,
+  relationType,
+  useSwagger,
+  mode = "full",
+) {
+  const owner = resolveForeignKeyOwner(newEntityName, target, relationType);
+
+  if (!owner) {
+    // console.log("ℹ️ n-n relation detected → pivot table, skipping DTO patch");
+    return;
+  }
+
+  // Patch DTO
+  await patchDtoWithRelation(
+    owner.ownerEntity,
+    owner.relatedEntity,
+    useSwagger,
+    mode,
+  );
+
+  await patchMapperWithRelation(owner.ownerEntity, owner.relatedEntity, mode);
+}
+
+module.exports = {
+  resolveForeignKeyOwner,
+  applyRelationPatches,
+};

package/utils/helpers.js

@@ -0,0 +1,109 @@
+/**
+ * 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) {
+  if (field.name === "role" && field.type.toLowerCase().startsWith("string")) {
+    return "Role";
+  }
+  return formatType(field.type);
+}
+
+module.exports = {
+  capitalize,
+  decapitalize,
+  pluralize,
+  formatType,
+  getFormattedType,
+};

package/utils/interactive/askEntityInputs.js

@@ -0,0 +1,165 @@
+// src/utils/interactive/askEntityInputs.js
+const fs = require("fs");
+const path = require("path");
+const readline = require("readline-sync");
+const inquirer = require("inquirer");
+const { info, success } = require("../colors");
+const { logWarning } = require("../loggers/logWarning");
+const { capitalize } = require("../userInput");
+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 relationData = await askRelationInputs(entity.name);
+  entity.relation = relationData;
+
+  return entity;
+}
+
+async function askRelationInputs(newEntityName) {
+  const srcPath = path.join(process.cwd(), "src");
+
+  // Sécurité : Vérifie si le dossier src existe
+  if (!fs.existsSync(srcPath)) return null;
+
+  const blacklist = [
+    "common",
+    "prisma",
+    "auth",
+    "mail",
+    "infrastructure",
+    "shared",
+  ];
+
+  const modules = fs.readdirSync(srcPath).filter((folder) => {
+    const fullPath = path.join(srcPath, folder);
+
+    // 1. D'abord vérifier si c'est un dossier (important pour éviter ENOTDIR)
+    const isDirectory = fs.lstatSync(fullPath).isDirectory();
+    if (!isDirectory) return false;
+
+    // 2. Ensuite les autres filtres
+    const isNotBlacklisted = !blacklist.includes(folder.toLowerCase());
+    const isNotCurrent = folder.toLowerCase() !== newEntityName.toLowerCase();
+
+    // 3. Enfin vérifier s'il y a un fichier .module.ts à l'intérieur
+    const hasModuleFile = fs
+      .readdirSync(fullPath)
+      .some((file) => file.endsWith(".module.ts"));
+
+    return isNotBlacklisted && isNotCurrent && hasModuleFile;
+  });
+
+  if (modules.length === 0) {
+    console.log(info("\n[INFO] No existing modules found for relations."));
+    return null;
+  }
+
+  const { wantRelation } = await actualInquirer.prompt([
+    {
+      type: "confirm",
+      name: "wantRelation",
+      message: "Add relation with an existing module?",
+      default: false,
+    },
+  ]);
+
+  if (!wantRelation) return null;
+
+  // On demande les détails de la relation
+  const relation = await actualInquirer.prompt([
+    {
+      type: "list",
+      name: "target",
+      message: "Select the target module:",
+      choices: modules,
+    },
+    {
+      type: "list",
+      name: "type",
+      message: "Relation type (NewEntity -> Target):",
+      choices: [
+        { name: "1-n (One-to-Many: This has many of those)", value: "1-n" },
+        {
+          name: "n-1 (Many-to-One: This belongs to one of those)",
+          value: "n-1",
+        },
+        { name: "1-1 (One-to-One)", value: "1-1" },
+        { name: "n-n (Many-to-Many)", value: "n-n" },
+      ],
+    },
+  ]);
+
+  return relation;
+}
+
+module.exports = { askEntityInputs };

package/utils/loggers/logError.js

@@ -1,7 +1,7 @@
-const { error } = require("../colors");
-
-function logError(message) {
-  console.error(`\n${error("❌[ERROR]")} ${message}`);
-}
-
-module.exports = { logError };
+const { error } = require("../colors");
+
+function logError(message) {
+  console.error(`\n${error("❌[ERROR]")} ${message}`);
+}
+
+module.exports = { logError };

package/utils/loggers/logInfo.js

@@ -1,7 +1,7 @@
-const { info } = require("../colors");
-
-function logInfo(message) {
-  console.log(`\n${info("[INFO]")} ${message}`);
-}
-
-module.exports = { logInfo };
+const { info } = require("../colors");
+
+function logInfo(message) {
+  console.log(`\n${info("[INFO]")} ${message}`);
+}
+
+module.exports = { logInfo };

package/utils/loggers/logSuccess.js

@@ -1,7 +1,7 @@
-const { success } = require("../colors");
-
-function logSuccess(message) {
-  console.log(`\n${success("✅[SUCCESS]")} ${message}`);
-}
-
-module.exports = { logSuccess };
+const { success } = require("../colors");
+
+function logSuccess(message) {
+  console.log(`\n${success("✅[SUCCESS]")} ${message}`);
+}
+
+module.exports = { logSuccess };

package/utils/loggers/logWarning.js

@@ -1,7 +1,7 @@
-const { warning } = require("../colors");
-
-function logWarning(message) {
-  console.log(`\n${warning("⚠️[INFO]")} ${message}`);
-}
-
-module.exports = { logWarning };
+const { warning } = require("../colors");
+
+function logWarning(message) {
+  console.log(`\n${warning("⚠️[Warning]")} ${message}`);
+}
+
+module.exports = { logWarning };