nestcraftx 0.2.4 → 0.2.6

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

package/utils/generators/lightModuleGenerator.js

@@ -0,0 +1,131 @@
+const {
+  createDirectory,
+  createFile,
+  safeUpdateAppModule,
+  capitalize,
+  decapitalize,
+} = require("../userInput");
+const { generateEntityFileContent, generateDto } = require("../utils");
+const {
+  generateLightRepository,
+  generateLightService,
+  generateLightController,
+  generateLightModule,
+} = require("../configs/setupLightArchitecture");
+const { logSuccess } = require("../loggers/logSuccess");
+const { logError } = require("../loggers/logError");
+const setupDatabase = require("./database/setupDatabase");
+const { logInfo } = require("../loggers/logInfo");
+const { updateExistingEntityRelation } = require("./domain/entityUpdater");
+const { applyRelationPatches } = require("./relation/relation.engine");
+
+async function lightModuleGenerator(entity, config) {
+  try {
+    const entityNameCap = capitalize(entity.name);
+    const entityNameLow = decapitalize(entity.name);
+    const entityPath = `src/${entityNameLow}`;
+    const mode = "light";
+
+    logInfo(`🚀 Generating light module for ${entityNameCap}`);
+
+    // 1️⃣ Créer les dossiers
+    await createDirectory(`${entityPath}/entities`);
+    await createDirectory(`${entityPath}/dtos`);
+    await createDirectory(`${entityPath}/services`);
+    await createDirectory(`${entityPath}/repositories`);
+    await createDirectory(`${entityPath}/controllers`);
+
+    // 2️⃣ Générer l'entité
+    const entityContent = await generateEntityFileContent(entity, "light");
+    await createFile({
+      path: `${entityPath}/entities/${entityNameLow}.entity.ts`,
+      contente: entityContent,
+    });
+
+    // 3️⃣ Générer les DTOs
+    const dtoContent = await generateDto(
+      entity,
+      config.swagger,
+      false,
+      "light",
+    );
+    await createFile({
+      path: `${entityPath}/dtos/${entityNameLow}.dto.ts`,
+      contente: dtoContent,
+    });
+
+    // 4️⃣ Générer le repository
+    const repositoryContent = generateLightRepository(
+      entityNameCap,
+      entityNameLow,
+      config.orm,
+      entity,
+    );
+    await createFile({
+      path: `${entityPath}/repositories/${entityNameLow}.repository.ts`,
+      contente: repositoryContent,
+    });
+
+    // 5️⃣ Générer le service
+    const serviceContent = generateLightService(entityNameCap, entityNameLow);
+    await createFile({
+      path: `${entityPath}/services/${entityNameLow}.service.ts`,
+      contente: serviceContent,
+    });
+
+    // 6️⃣ Générer le controller
+    const controllerContent = generateLightController(
+      entityNameCap,
+      entityNameLow,
+      config.swagger,
+    );
+    await createFile({
+      path: `${entityPath}/controllers/${entityNameLow}.controller.ts`,
+      contente: controllerContent,
+    });
+
+    // 7️⃣ Générer le module
+    const moduleContent = generateLightModule(
+      entityNameCap,
+      entityNameLow,
+      entityPath,
+      config.orm,
+      config.auth,
+    );
+    await createFile({
+      path: `${entityPath}/${entityNameLow}.module.ts`,
+      contente: moduleContent,
+    });
+
+    // ÉTAPE RELATIONS : Patching des fichiers si une relation existe
+    if (entity.relation) {
+      const { target, type } = entity.relation;
+      logInfo(
+        `🔗 Linking ${entityNameCap} with ${capitalize(target)} (${type})...`,
+      );
+
+      await updateExistingEntityRelation(target, entity.name, type);
+
+      await applyRelationPatches(
+        entity.name,
+        target,
+        type,
+        config.swagger,
+        mode,
+      );
+    }
+
+    // 8️  Auto-enregistrement dans AppModule
+    await safeUpdateAppModule(entityNameLow);
+
+    // 9
+    await setupDatabase(config, entity);
+
+    logSuccess(`✨ Light module ${entityNameCap} generated successfully!`);
+  } catch (error) {
+    logError(`Error generating light module: ${error}`);
+    throw error;
+  }
+}
+
+module.exports = lightModuleGenerator;

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