nestcraftx 0.2.6 → 0.4.0

package/utils/cliParser.js

@@ -1,48 +1,3 @@
-/* function parseCliArgs(args) {
-  const parsed = {
-    command: null,
-    projectName: null,
-    flags: {},
-    positional: [],
-    errors: []
-  };
-
-  for (let i = 2; i < args.length; i++) {
-    const arg = args[i];
-
-    if (i === 2 && !arg.startsWith('--')) {
-      parsed.command = arg;
-      continue;
-    }
-
-    if (i === 3 && !arg.startsWith('--') && parsed.command === 'new') {
-      if (!isValidProjectName(arg)) {
-        parsed.errors.push(`Nom de projet invalide: "${arg}". Utilisez uniquement des lettres, chiffres, tirets et underscores.`);
-      }
-      parsed.projectName = arg;
-      continue;
-    }
-
-    if (arg.startsWith('--')) {
-      const [key, value] = parseFlag(arg);
-      const nextArg = args[i + 1];
-
-      if (value !== null) {
-        parsed.flags[key] = value;
-      } else if (nextArg && !nextArg.startsWith('--')) {
-        parsed.flags[key] = nextArg;
-        i++;
-      } else {
-        parsed.flags[key] = true;
-      }
-    } else {
-      parsed.positional.push(arg);
-    }
-  }
-
-  validateFlags(parsed);
-  return parsed;
-} */
 
 function parseCliArgs(args) {
   const parsed = {

package/utils/configs/setupCleanArchitecture.js

@@ -128,7 +128,7 @@ async function setupCleanArchitecture(inputs) {
 
       // 4. Use Cases
       const useCases = ["Create", "GetById", "GetAll", "Update", "Delete"];
-      useCases.forEach(async (useCase) => {
+      for (const useCase of useCases) {
         let content = "";
         const entityName = capitalize(entity.name);
         const entityNameLower = decapitalize(entity.name);
@@ -302,7 +302,7 @@ export class Delete${entityName}UseCase {
           }.use-case.ts`,
           contente: content.trim(),
         });
-      });
+      }
 
       // 5. DTOs
       const DtoFileContent = await generateDto(entity, useSwagger);

package/utils/envGenerator.js

@@ -85,6 +85,12 @@ function buildDatabaseUrl(user, password, host, port, database, orm) {
 }
 
 function writeEnvFile(envContent, projectPath = ".") {
+  const isDryRun = process.argv.includes("--dry-run");
+  if (isDryRun) {
+    console.log(`[DRY-RUN] Simulated: write env file to ${path.join(projectPath, ".env")}`);
+    console.log(`[DRY-RUN] Simulated: write env example file to ${path.join(projectPath, ".env.example")}`);
+    return;
+  }
   // Écriture du .env (avec secrets)
   const envPath = path.join(projectPath, ".env");
   fs.writeFileSync(envPath, envContent, "utf8");

package/utils/file-system.js

@@ -0,0 +1,90 @@
+/**
+ * utils/file-system.js
+ *
+ * Fonctions d'accès au système de fichiers utilisées par tous les générateurs.
+ * Extraites de userInput.js pour centraliser les opérations I/O.
+ *
+ * Les fichiers qui importent depuis userInput.js continuent de fonctionner
+ * sans modification grâce aux ré-exports dans userInput.js.
+ */
+
+const fs = require("fs");
+
+/**
+ * Crée un répertoire de manière récursive s'il n'existe pas déjà.
+ * @param {string} directoryPath - Le chemin du répertoire à créer.
+ */
+async function createDirectory(directoryPath) {
+  const isDryRun = process.argv.includes("--dry-run");
+  if (isDryRun) {
+    console.log(`[DRY-RUN] Simulated: create directory ${directoryPath}`);
+    return;
+  }
+  try {
+    if (!fs.existsSync(directoryPath)) {
+      fs.mkdirSync(directoryPath, { recursive: true });
+    }
+  } catch (error) {
+    console.error(
+      `Erreur lors de la création du dossier ${directoryPath}:`,
+      error,
+    );
+  }
+}
+
+/**
+ * Crée un fichier avec le contenu fourni.
+ * Si le fichier existe déjà :
+ *   - Si `fileData.overwrite === false` : skip silencieusement
+ *   - Sinon : écrase le fichier existant
+ *
+ * @param {{ path: string, contente: string, overwrite?: boolean }} fileData
+ */
+async function createFile(fileData) {
+  const isDryRun = process.argv.includes("--dry-run");
+  if (isDryRun) {
+    console.log(`[DRY-RUN] Simulated: create/write file ${fileData.path}`);
+    return;
+  }
+  try {
+    if (!fs.existsSync(fileData.path)) {
+      fs.writeFileSync(`${fileData.path}`, `${fileData.contente}`);
+    } else {
+      if (fileData.overwrite === false) {
+        console.log(`File already exists, skipping: ${fileData.path}`);
+        return;
+      }
+      console.log(`Existing file : ${fileData.path}`);
+      fs.writeFileSync(`${fileData.path}`, `${fileData.contente}`);
+    }
+  } catch (error) {
+    console.error(`Erreur creating file ${fileData.path}:`, error);
+  }
+}
+
+/**
+ * Met à jour un fichier existant en remplaçant un pattern par un remplacement.
+ * Utilise `String.prototype.replace` : supporte les chaînes et les RegExp.
+ *
+ * @param {{ path: string, pattern: string|RegExp, replacement: string }} options
+ */
+async function updateFile({ path, pattern, replacement }) {
+  const isDryRun = process.argv.includes("--dry-run");
+  if (isDryRun) {
+    console.log(`[DRY-RUN] Simulated: update file ${path}`);
+    return;
+  }
+  try {
+    let mainTs = fs.readFileSync(path, "utf8");
+    const updatedContent = mainTs.replace(pattern, replacement);
+    fs.writeFileSync(path, updatedContent, "utf-8");
+  } catch (error) {
+    console.error(` Error updating file ${path}:`, error);
+  }
+}
+
+module.exports = {
+  createDirectory,
+  createFile,
+  updateFile,
+};

package/utils/file-utils/packageJsonUtils.js

@@ -13,6 +13,12 @@ async function updatePackageJson(inputs, scripts, devDependencies = {}) {
   const projectPath = process.cwd();
   const packageJsonPath = path.join(projectPath, "package.json");
 
+  const isDryRun = process.argv.includes("--dry-run");
+  if (isDryRun) {
+    console.log(`[DRY-RUN] Simulated: update package.json scripts and devDependencies for ${inputs.projectName}`);
+    return;
+  }
+
   try {
     // 1. Lire le contenu actuel
     const fileContent = fs.readFileSync(packageJsonPath, "utf8");

package/utils/file-utils/saveProjectConfig.js

@@ -23,6 +23,12 @@ async function saveProjectConfig(inputs) {
     generatedAt: new Date().toISOString(),
   };
 
+  const isDryRun = process.argv.includes("--dry-run");
+  if (isDryRun) {
+    console.log(`[DRY-RUN] Simulated: save project config to ${configFile}`);
+    return;
+  }
+
   try {
     if (!fs.existsSync(configDir)) {
       fs.mkdirSync(configDir, { recursive: true });

package/utils/fullModeInput.js

@@ -4,6 +4,7 @@ const inquirer = require("inquirer");
 const { capitalize } = require("./userInput");
 const { logWarning } = require("./loggers/logWarning");
 const { getPackageManager } = require("./utils");
+const { buildEntityInteractive, buildRelationsInteractive } = require("./interactive/entityBuilder");
 const actualInquirer = inquirer.default || inquirer;
 
 async function getFullModeInputs(projectName, flags) {
@@ -334,97 +335,13 @@ async function getFullModeInputs(projectName, flags) {
 
   let addEntity = readline.keyInYNStrict(`${info("[?]")} Add an entity?`);
   while (addEntity) {
-    let name;
-    while (true) {
-      name = readline.question(`\n Entity name : `);
-      if (/^[A-Za-z][A-Za-z0-9_]*$/.test(name)) break;
-      logWarning("Invalid name. Letters, numbers, _ (start with a letter).");
-    }
-
-    const fields = [];
-
-    console.log(` Fields for "${name}" :`);
-    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",
-        "decimal",
-        "boolean",
-        "Date",
-        "uuid",
-        "json",
-        "enum",
-        "array",
-        "object",
-      ];
-
-      const typeQuestion = {
-        type: "list",
-        name: "ftype",
-        message: `Type for "${fname}"`,
-        default: "string",
-        choices: baseTypeChoices,
-        transformer: () => "",
-      };
-      const typeAnswer = await actualInquirer.prompt([typeQuestion]);
-      let ftype = typeAnswer.ftype;
-      process.stdout.write("\x1B[1A");
-      process.stdout.write("\x1B[K");
-
-      if (ftype === "array") {
-        const arrayInnerQuestion = {
-          type: "list",
-          name: "innerType",
-          message: `Type of elements for "${fname}[]"`,
-          default: "string",
-          choices: baseTypeChoices.filter(
-            (c) => c !== "array" && c !== "object"
-          ),
-          transformer: () => "",
-        };
-
-        const innerAnswer = await actualInquirer.prompt([arrayInnerQuestion]);
-        ftype = `${innerAnswer.innerType}[]`;
-      } else if (ftype === "enum") {
-        const enumName = capitalize(fname) + "Enum";
-        console.log(
-          `  ${info(
-            "[INFO]"
-          )} Enum type selected. Consider defining ${enumName} in your code.`
-        );
-        ftype = enumName;
-      } else if (ftype === "object") {
-        const objectNameQuestion = {
-          type: "input",
-          name: "objectName",
-
-          message: `Complex type name (DTO/Class or leave 'json') :`,
-          default: "json",
-          transformer: () => "",
-        };
-
-        const objectAnswer = await actualInquirer.prompt([objectNameQuestion]);
-        ftype = capitalize(objectAnswer.objectName.trim() || "json");
-      }
-
-      console.log(`  Type for "${fname}" : ${ftype} ${success("[✓]")}`);
-
-      fields.push({ name: fname, type: ftype });
+    const entity = await buildEntityInteractive();
+    if (entity) {
+      entitiesData.entities.push(entity);
+      console.log(
+        `${success("[✓]")} Entity "${entity.name}" added with ${entity.fields.length} field(s)`
+      );
     }
-
-    entitiesData.entities.push({ name, fields });
-    console.log(
-      `${success("[✓]")} Entity "${name}" added with ${fields.length} field(s)`
-    );
-
     addEntity = readline.keyInYNStrict(`${info("[?]")} Add another entity?`);
   }
 
@@ -432,145 +349,7 @@ async function getFullModeInputs(projectName, flags) {
     `${info("[?]")} Add relationships between entities?`
   );
   if (wantsRelation) {
-    if (entitiesData.entities.length > 1) {
-      console.log(`\n${info("[INFO]")} Configuring relationships`);
-
-      let configuring = true;
-      while (configuring) {
-        const entityNames = entitiesData.entities.map((e) => e.name);
-
-        // 1. Select entities first
-        const selection = await actualInquirer.prompt([
-          {
-            type: "list",
-            name: "fromName",
-            message: "From which entity? (Source)",
-            choices: entityNames,
-          },
-          {
-            type: "list",
-            name: "toName",
-            message: (prev) =>
-              `To which entity should ${prev.fromName} be linked? (Target)`,
-            choices: (prev) =>
-              entityNames.filter((name) => name !== prev.fromName),
-          },
-        ]);
-
-        // --- VERIFICATION: Check if link already exists (A->B or B->A) ---
-        const alreadyExists = entitiesData.relations.find(
-          (rel) =>
-            (rel.from === selection.fromName && rel.to === selection.toName) ||
-            (rel.from === selection.toName && rel.to === selection.fromName)
-        );
-
-        if (alreadyExists) {
-          logWarning(
-            `A relationship already exists between ${selection.fromName} and ${selection.toName} (${alreadyExists.type}).`
-          );
-
-          const { tryAgain } = await actualInquirer.prompt([
-            {
-              type: "confirm",
-              name: "tryAgain",
-              message: "Do you want to choose different entities?",
-              default: true,
-            },
-          ]);
-
-          if (!tryAgain) break;
-          continue; // Restart selection
-        }
-
-        // 2. Select Relationship type only if verification passed
-        const typeAnswer = await actualInquirer.prompt([
-          {
-            type: "list",
-            name: "relType",
-            message: "Relationship type:",
-            choices: [
-              {
-                name: `1-1 (One-to-One)   : ${selection.fromName} has one ${selection.toName}`,
-                value: "1-1",
-              },
-              {
-                name: `1-n (One-to-Many)  : ${selection.fromName} has many ${selection.toName}s`,
-                value: "1-n",
-              },
-              {
-                name: `n-1 (Many-to-One)  : Many ${selection.fromName}s belong to one ${selection.toName}`,
-                value: "n-1",
-              },
-              {
-                name: `n-n (Many-to-Many) : Many ${selection.fromName}s linked to many ${selection.toName}s`,
-                value: "n-n",
-              },
-            ],
-          },
-        ]);
-
-        const from = entitiesData.entities.find(
-          (e) => e.name === selection.fromName
-        );
-        const to = entitiesData.entities.find(
-          (e) => e.name === selection.toName
-        );
-        const relType = typeAnswer.relType;
-
-        // Register Relationship
-        entitiesData.relations.push({
-          from: from.name,
-          to: to.name,
-          type: relType,
-        });
-
-        const fromLow = from.name.toLowerCase();
-        const toLow = to.name.toLowerCase();
-
-        // --- Add fields logic ---
-        if (relType === "1-1") {
-          from.fields.push(
-            { name: `${toLow}Id`, type: "string" },
-            { name: toLow, type: to.name }
-          );
-        } else if (relType === "1-n") {
-          from.fields.push({ name: `${toLow}s`, type: `${to.name}[]` });
-          to.fields.push(
-            { name: `${fromLow}Id`, type: "string" },
-            { name: fromLow, type: from.name }
-          );
-        } else if (relType === "n-1") {
-          from.fields.push(
-            { name: `${toLow}Id`, type: "string" },
-            { name: toLow, type: to.name }
-          );
-          to.fields.push({ name: `${fromLow}s`, type: `${from.name}[]` });
-        } else if (relType === "n-n") {
-          from.fields.push({ name: `${toLow}s`, type: `${to.name}[]` });
-          to.fields.push({ name: `${fromLow}s`, type: `${from.name}[]` });
-        }
-
-        console.log(
-          `\n${success("[✓]")} Relationship added: ${from.name} ${relType} ${
-            to.name
-          }`
-        );
-
-        const { addMore } = await actualInquirer.prompt([
-          {
-            type: "confirm",
-            name: "addMore",
-            message: "Add another relationship?",
-            default: false,
-          },
-        ]);
-        configuring = addMore;
-      }
-    } else {
-      logWarning(
-        "At least two entities are required to configure a relationship."
-      );
-    }
+    await buildRelationsInteractive(entitiesData);
   }
 
   return {