nestcraftx 0.2.5 → 0.3.0

package/utils/generators/domain/entityUpdater.js

@@ -0,0 +1,78 @@
+// src/utils/generators/domain/entityUpdater.js
+const { updateFile, capitalize } = require("../../userInput");
+const fs = require("fs");
+
+async function updateExistingEntityRelation(
+  targetName,
+  newEntityName,
+  relationType,
+  mode,
+) {
+  const targetLow = targetName.toLowerCase();
+  const newCap = capitalize(newEntityName);
+  const newLow = newEntityName.toLowerCase();
+
+  const entityPath =
+    mode === "full"
+      ? `src/${targetLow}/domain/entities/${targetLow}.entity.ts`
+      : `src/${targetLow}/entities/${targetLow}.entity.ts`;
+
+  if (!fs.existsSync(entityPath)) return;
+
+  // Déterminer le champ à ajouter selon la relation
+  let fieldToAdd = "";
+  let typeToAdd = "";
+
+  switch (relationType) {
+    case "n-1": // L'inverse d'un n-1 est un 1-n (donc une liste)
+      /* fieldToAdd = `${newLow}s`;
+      typeToAdd = `${newCap}Entity[]`; */
+      break;
+    case "1-n": // L'inverse d'un 1-n est un n-1 (donc un ID ou l'objet)
+      fieldToAdd = `${newLow}Id`;
+      typeToAdd = `string`;
+      break;
+    case "1-1":
+      fieldToAdd = `${newLow}Id`;
+      typeToAdd = `string`;
+      break;
+    case "n-n":
+      /*  fieldToAdd = `${newLow}s`;
+      typeToAdd = `${newCap}Entity[]`; */
+      break;
+  }
+
+  // 1. Ajouter l'import de la nouvelle entité au début du fichier (si c'est un type complexe)
+  if (typeToAdd.includes("Entity")) {
+    const importLine = `import { ${newCap}Entity } from 'src/${newLow}/domain/entities/${newLow}.entity';\n`;
+    await updateFile({
+      path: entityPath,
+      pattern: /^/, // Début du fichier
+      replacement: importLine,
+    });
+  }
+
+  // 2. Injecter dans le constructeur (avant la parenthèse fermante)
+  await updateFile({
+    path: entityPath,
+    pattern: /(constructor\([\s\S]*?)\n\s+\)/m,
+    replacement: `$1\n    private readonly ${fieldToAdd}?: ${typeToAdd}, \n  )`,
+  });
+
+  // 3. Injecter le Getter (avant la méthode toJSON)
+  const getterMethod = `\n  get${capitalize(fieldToAdd)}(): ${typeToAdd} | undefined {\n    return this.${fieldToAdd};\n  }\n`;
+  await updateFile({
+    path: entityPath,
+    pattern: /toJSON\(\)/,
+    replacement: `${getterMethod}\n  toJSON()`,
+  });
+
+  // 4. Injecter dans toJSON
+  await updateFile({
+    path: entityPath,
+    pattern: /(toJSON\(\) \{[\s\S]*?return \{[\s\S]*?)\n\s+\};/m,
+    replacement: `$1\n      ${fieldToAdd}: this.${fieldToAdd},}`,
+  });
+}
+
+module.exports = { updateExistingEntityRelation };

package/utils/generators/infrastructure/mapperGenerator.js

@@ -0,0 +1,114 @@
+/**
+ * utils/generators/infrastructure/mapperGenerator.js
+ *
+ * Générateur du Mapper infrastructure (Full/Clean Architecture uniquement).
+ * Extrait de utils.js — Phase 1B.
+ *
+ * Le mapper n'est JAMAIS utilisé en mode light :
+ * - light : le repository utilise une méthode `private toEntity()` inline
+ * - full  : le mapper découple persistence <-> domaine <-> DTO
+ */
+
+const { capitalize, decapitalize } = require("../../helpers");
+
+/**
+ * Génère le contenu TypeScript du Mapper pour une entité.
+ *
+ * @param {object} entity - L'objet entité { name, fields[] }
+ * @returns {Promise<string>} Le code TypeScript du mapper
+ */
+async function generateMapper(entity) {
+  const entityName = capitalize(entity.name);
+
+  // 1. Types scalaires / primitifs autorisés dans le mapper
+  const SCALAR_TYPES = [
+    "string",
+    "text",
+    "uuid",
+    "json",
+    "number",
+    "int",
+    "float",
+    "decimal",
+    "boolean",
+    "date",
+    "role",
+  ];
+
+  // 2. Filtrage cohérent : scalaires + IDs techniques
+  const filterDomainFields = (f) => {
+    const typeName = f.type.toLowerCase().replace("[]", "");
+    return (
+      SCALAR_TYPES.includes(typeName) || f.name.toLowerCase().endsWith("id")
+    );
+  };
+
+  // 3. Champs filtrés pour le constructeur de l'Entity
+  const filteredFields = entity.fields.filter(filterDomainFields);
+
+  const domainArgs = ["data.id"]
+    .concat(["data.createdAt", "data.updatedAt"])
+    .concat(filteredFields.map((f) => `data.${f.name}`))
+    .join(",\n    ");
+
+  // 4. Champs pour la persistence
+  const toPersistenceFields = filteredFields
+    .map((f) => `${f.name}: dto.${f.name},`)
+    .join("\n    ");
+
+  const toUpdateFields = filteredFields
+    .map(
+      (f) => `if (dto.${f.name} !== undefined) data.${f.name} = dto.${f.name};`,
+    )
+    .join("\n   ");
+
+  return `/**
+ * ${entityName}Mapper transforms data between
+ * different layers (Persistence <-> Domain <-> DTO).
+ *
+ * Ensures that the internal database structure
+ * never leaks into the API responses.
+ */
+
+import { Injectable } from '@nestjs/common';
+import { ${entityName}Entity } from 'src/${decapitalize(
+    entity.name,
+  )}/domain/entities/${decapitalize(entity.name)}.entity';
+import { Create${entityName}Dto, Update${entityName}Dto } from 'src/${decapitalize(
+    entity.name,
+  )}/application/dtos/${decapitalize(entity.name)}.dto';
+
+@Injectable()
+export class ${entityName}Mapper {
+
+  /**
+   * Transforme les données (Prisma/TypeORM) en Entité de Domaine
+   */
+  toDomain(data: any): ${entityName}Entity {
+    return new ${entityName}Entity(
+      ${domainArgs}
+    );
+  }
+
+  /**
+   * Transforme le DTO en objet pour la création en base de données
+   */
+  toPersistence(dto: Create${entityName}Dto): any {
+    return {
+      ${toPersistenceFields}
+    };
+  }
+
+  /**
+   * Prépare l'objet de mise à jour partielle
+   */
+  toUpdatePersistence(dto: Update${entityName}Dto): any {
+    const data: any = {};
+    ${toUpdateFields}
+    return data;
+  }
+}
+`;
+}
+
+module.exports = { generateMapper };

package/utils/generators/infrastructure/mapperUpdater.js

@@ -0,0 +1,65 @@
+const { updateFile } = require("../../userInput");
+
+// src/utils/generators/infrastructure/mapperUpdater.js
+async function patchMapperWithRelation(source, targetName, mode = "full") {
+  const targetLow = targetName.toLowerCase();
+
+  if (mode === "full") {
+    return patchCleanMapper(source, targetLow);
+  } else {
+    return patchLightRepositoryMapper(source, targetLow);
+  }
+}
+
+async function patchCleanMapper(source, targetName) {
+  const mapperPath = `src/${source.toLowerCase()}/infrastructure/mappers/${source.toLowerCase()}.mapper.ts`;
+  const targetLow = targetName.toLowerCase();
+
+  // 1. ToDomain : Ajouter l'argument au constructeur de l'entité
+  await updateFile({
+    path: mapperPath,
+    pattern:
+      /(toDomain\(data: any\): .* \{[\s\S]*?return new .*?\()([\s\S]*?)(\);)/m,
+    replacement: `$1$2 data.${targetLow}Id$3`,
+  });
+
+  // 2. ToPersistence : Ajouter le champ pour Prisma
+  await updateFile({
+    path: mapperPath,
+    pattern: /(toPersistence\(dto: .* \{[\s\S]*?return \{)/m,
+    replacement: `$1\n      ${targetLow}Id: dto.${targetLow}Id,`,
+  });
+
+  // 3. PATCH toUpdatePersistence → add FK update condition
+  await updateFile({
+    path: mapperPath,
+    pattern: /(toUpdatePersistence\(dto: .*?\{\s*const data: any = \{\};)/m,
+    replacement: `$1\n\n    if (dto.${targetLow}Id !== undefined) data.${targetLow}Id = dto.${targetLow}Id;`,
+  });
+}
+
+/**
+ * LIGHT MODE → patch repository.ts (toEntity + create/update)
+ */
+async function patchLightRepositoryMapper(entityName, targetLow) {
+  const repoPath = `src/${entityName.toLowerCase()}/repositories/${entityName.toLowerCase()}.repository.ts`;
+  // const targetRepoPath = `src/${targetLow.toLowerCase()}/repositories/${targetLow.toLowerCase()}.repository.ts`;
+
+  // 1. Patch toEntity constructor
+  /* await updateFile({
+    path: repoPath,
+    pattern:
+      /(private toEntity\(raw: any\): .*?\{\s*return new .*?\([\s\S]*?)(\);\s*\})/m,
+    replacement: `$1,\n      raw.${targetLow}Id$2`,
+  }); */
+
+  // 2. Patch toEntity constructor in target
+  await updateFile({
+    path: repoPath,
+    pattern:
+      /(private toEntity\(raw: any\): .*?\{\s*return new .*?\([\s\S]*?)(\);\s*\})/m,
+    replacement: `$1\n      raw.${targetLow}Id$2`,
+  });
+}
+
+module.exports = { patchMapperWithRelation };