nestcraftx 0.2.6 → 0.4.0

package/utils/interactive/entityBuilder.js

@@ -0,0 +1,400 @@
+const readline = require("readline-sync");
+const inquirer = require("inquirer");
+const { info, success, warning } = require("../colors");
+const { logWarning } = require("../loggers/logWarning");
+const { capitalize } = require("../helpers");
+const actualInquirer = inquirer.default || inquirer;
+
+/**
+ * Interactive entity builder with full revision capabilities.
+ * @param {string} [initialName] - Optional starting name for the entity.
+ * @returns {Promise<{name: string, fields: Array<{name: string, type: string, unique: boolean, nullable: boolean, default: string|null>}|null>}
+ */
+async function buildEntityInteractive(initialName) {
+  let entityName = initialName;
+  while (!entityName || !/^[A-Za-z][A-Za-z0-9_]*$/.test(entityName)) {
+    entityName = readline.question(`\n${info("[?]")} Entity name : `);
+    if (!/^[A-Za-z][A-Za-z0-9_]*$/.test(entityName)) {
+      logWarning("Invalid name. Letters, numbers, _ (start with a letter).");
+    }
+  }
+
+  const fields = [];
+
+  console.log(`\n Fields for "${entityName}" :`);
+
+  // Initial field prompting loop
+  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 field = await promptFieldDetails(fname);
+    fields.push(field);
+    const defaultText = field.default !== null && field.default !== "" ? `, default=${field.default}` : " (no default)";
+    console.log(`  Field "${fname}" added: type=${field.type}, unique=${field.unique}, nullable=${field.nullable}${defaultText} ${success("[✓]")}`);
+  }
+
+  // Revision Loop
+  while (true) {
+    console.log(`\n--------------------------------------------`);
+    console.log(`📋 Current Entity: "${entityName}"`);
+    if (fields.length === 0) {
+      console.log("  (No fields added yet)");
+    } else {
+      fields.forEach((f, idx) => {
+        const constraints = [];
+        if (f.unique) constraints.push("unique");
+        if (f.nullable) constraints.push("nullable");
+        if (f.default !== null && f.default !== "") constraints.push(`default: ${f.default}`);
+        const constraintStr = constraints.length > 0 ? ` (${constraints.join(", ")})` : "";
+        console.log(`  ${idx + 1}. ${f.name} : ${f.type}${constraintStr}`);
+      });
+    }
+    console.log(`--------------------------------------------`);
+
+    const answers = await actualInquirer.prompt([
+      {
+        type: "list",
+        name: "action",
+        message: "Select an option:",
+        choices: [
+          { name: "✅ Confirm and continue", value: "confirm" },
+          { name: "➕ Add another field", value: "add" },
+          { name: "✏️  Edit an existing field", value: "edit" },
+          { name: "🗑️  Delete a field", value: "delete" },
+          { name: "✏️  Rename the entity", value: "rename" },
+          { name: "❌ Cancel this entity", value: "cancel" },
+        ],
+      },
+    ]);
+
+    switch (answers.action) {
+      case "confirm":
+        return { name: entityName, fields };
+
+      case "add": {
+        let fname = readline.question("\n  Field name (leave empty to cancel) : ");
+        if (!fname) break;
+        if (!/^[A-Za-z][A-Za-z0-9_]*$/.test(fname)) {
+          logWarning("Invalid field name.");
+          break;
+        }
+        const field = await promptFieldDetails(fname);
+        fields.push(field);
+        const defaultText = field.default !== null && field.default !== "" ? `, default=${field.default}` : " (no default)";
+        console.log(`  Field "${fname}" added: type=${field.type}, unique=${field.unique}, nullable=${field.nullable}${defaultText} ${success("[✓]")}`);
+        break;
+      }
+
+      case "delete": {
+        if (fields.length === 0) {
+          logWarning("No fields to delete.");
+          break;
+        }
+        const deleteAns = await actualInquirer.prompt([
+          {
+            type: "list",
+            name: "targetIndex",
+            message: "Select the field to delete:",
+            choices: fields.map((f, idx) => ({
+              name: `${f.name} (${f.type})`,
+              value: idx,
+            })),
+          },
+        ]);
+        const deletedField = fields.splice(deleteAns.targetIndex, 1)[0];
+        console.log(`${success("[✓]")} Field "${deletedField.name}" deleted.`);
+        break;
+      }
+
+      case "rename": {
+        let newName = readline.question(`\n${info("[?]")} New Entity name [${entityName}]: `);
+        if (!newName) break;
+        if (/^[A-Za-z][A-Za-z0-9_]*$/.test(newName)) {
+          entityName = newName;
+          console.log(`${success("[✓]")} Entity renamed to "${entityName}"`);
+        } else {
+          logWarning("Invalid name.");
+        }
+        break;
+      }
+
+      case "edit": {
+        if (fields.length === 0) {
+          logWarning("No fields to edit.");
+          break;
+        }
+        const selectAns = await actualInquirer.prompt([
+          {
+            type: "list",
+            name: "targetIndex",
+            message: "Select the field to edit:",
+            choices: fields.map((f, idx) => ({
+              name: `${f.name} (${f.type})`,
+              value: idx,
+            })),
+          },
+        ]);
+        const fIdx = selectAns.targetIndex;
+        const currentField = fields[fIdx];
+
+        console.log(`\n✏️ Editing field "${currentField.name}":`);
+        let newName = readline.question(`  New field name [${currentField.name}]: `) || currentField.name;
+        while (!/^[A-Za-z][A-Za-z0-9_]*$/.test(newName)) {
+          logWarning("Invalid field name.");
+          newName = readline.question(`  New field name [${currentField.name}]: `) || currentField.name;
+        }
+
+        const editedField = await promptFieldDetails(newName, currentField);
+        fields[fIdx] = editedField;
+        console.log(`${success("[✓]")} Field successfully updated.`);
+        break;
+      }
+
+      case "cancel": {
+        const confirmCancel = readline.keyInYNStrict(`${warning("[warning]")} Are you sure you want to cancel and discard this entity?`);
+        if (confirmCancel) {
+          return null;
+        }
+        break;
+      }
+    }
+  }
+}
+
+/**
+ * Prompts the user for all details and constraints of a field.
+ * @private
+ */
+async function promptFieldDetails(fieldName, existingField = null) {
+  const baseTypeChoices = [
+    "string",
+    "text",
+    "number",
+    "boolean",
+    "Date",
+    "uuid",
+    "json",
+    "enum",
+    "array",
+    "object",
+  ];
+
+  let defaultType = "string";
+  if (existingField) {
+    if (existingField.type.endsWith("[]")) defaultType = "array";
+    else if (existingField.type.endsWith("Enum")) defaultType = "enum";
+    else if (baseTypeChoices.includes(existingField.type)) defaultType = existingField.type;
+    else defaultType = "object";
+  }
+
+  const typeQuestion = {
+    type: "list",
+    name: "ftype",
+    message: `Type for "${fieldName}"`,
+    default: defaultType,
+    choices: baseTypeChoices,
+  };
+
+  const typeAnswer = await actualInquirer.prompt([typeQuestion]);
+  let ftype = typeAnswer.ftype;
+
+  if (ftype === "array") {
+    let defaultInner = "string";
+    if (existingField && existingField.type.endsWith("[]")) {
+      defaultInner = existingField.type.slice(0, -2);
+    }
+    const arrayInnerQuestion = {
+      type: "list",
+      name: "innerType",
+      message: `Type of elements for "${fieldName}[]"`,
+      default: defaultInner,
+      choices: baseTypeChoices.filter((c) => c !== "array" && c !== "object"),
+    };
+    const innerAnswer = await actualInquirer.prompt([arrayInnerQuestion]);
+    ftype = `${innerAnswer.innerType}[]`;
+  } else if (ftype === "enum") {
+    const enumName = capitalize(fieldName) + "Enum";
+    console.log(`  ${info("[INFO]")} Enum type selected: ${enumName}`);
+    ftype = enumName;
+  } else if (ftype === "object") {
+    let defaultObj = "json";
+    if (existingField && !baseTypeChoices.includes(existingField.type) && !existingField.type.endsWith("[]") && !existingField.type.endsWith("Enum")) {
+      defaultObj = existingField.type;
+    }
+    const objectNameQuestion = {
+      type: "input",
+      name: "objectName",
+      message: `Complex type name (DTO/Class or leave 'json') :`,
+      default: defaultObj,
+    };
+    const objectAnswer = await actualInquirer.prompt([objectNameQuestion]);
+    ftype = capitalize(objectAnswer.objectName.trim() || "json");
+  }
+
+  // Ask constraints: unique, nullable, default
+  const isUnique = readline.keyInYNStrict(`  Is "${fieldName}" unique?`, {
+    defaultInput: existingField && existingField.unique ? "y" : "n",
+  });
+
+  const isNullable = readline.keyInYNStrict(`  Is "${fieldName}" nullable/optional?`, {
+    defaultInput: existingField && existingField.nullable ? "y" : "n",
+  });
+
+  let defaultValuePrompt = "  Default value (press Enter for none): ";
+  if (existingField && existingField.default !== null) {
+    defaultValuePrompt = `  Default value [${existingField.default}]: `;
+  }
+  let defaultValue = readline.question(defaultValuePrompt);
+  if (defaultValue === "") {
+    defaultValue = existingField ? existingField.default : null;
+  } else if (defaultValue.toLowerCase() === "none" || defaultValue.toLowerCase() === "null") {
+    defaultValue = null;
+  }
+
+  return {
+    name: fieldName,
+    type: ftype,
+    unique: isUnique,
+    nullable: isNullable,
+    default: defaultValue,
+  };
+}
+
+/**
+ * Manages adding relationships between entities via an interactive interface.
+ * @param {Object} entitiesData - The object containing entities and relations.
+ */
+async function buildRelationsInteractive(entitiesData) {
+  if (entitiesData.entities.length < 2) {
+    logWarning("At least two entities are required to configure a relationship.");
+    return;
+  }
+
+  let configuring = true;
+  while (configuring) {
+    const entityNames = entitiesData.entities.map((e) => e.name);
+
+    // 1. Select entities
+    const selection = await actualInquirer.prompt([
+      {
+        type: "list",
+        name: "fromName",
+        message: "Select the source entity (From) :",
+        choices: entityNames,
+      },
+      {
+        type: "list",
+        name: "toName",
+        message: (prev) => `To which entity should "${prev.fromName}" be linked?`,
+        choices: (prev) => entityNames.filter((name) => name !== prev.fromName),
+      },
+    ]);
+
+    // Check if link already exists
+    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;
+    }
+
+    // 2. Select Relationship type
+    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;
+  }
+}
+
+module.exports = {
+  buildEntityInteractive,
+  buildRelationsInteractive,
+};

package/utils/lightModeInput.js

@@ -6,6 +6,7 @@ const { capitalize } = require("./userInput");
 const { logWarning } = require("./loggers/logWarning");
 const { logInfo } = require("./loggers/logInfo");
 const { getPackageManager } = require("./utils");
+const { buildEntityInteractive, buildRelationsInteractive } = require("./interactive/entityBuilder");
 const actualInquirer = inquirer.default || inquirer;
 
 async function getLightModeInputs(projectName, flags) {
@@ -139,7 +140,17 @@ async function getLightModeInputs(projectName, flags) {
   );
   if (addEntities) {
     console.log(`\n${info("[INFO]")} Entity input (simplified mode)`);
-    await addCustomEntities(inputs.entitiesData);
+    while (true) {
+      const entity = await buildEntityInteractive();
+      if (entity) {
+        inputs.entitiesData.entities.push(entity);
+        console.log(
+          `${info("[INFO]")} Entity "${entity.name}" added with ${entity.fields.length} field(s)`
+        );
+      }
+      const addMore = readline.keyInYNStrict("Add another entity?");
+      if (!addMore) break;
+    }
   }
 
   // Demander les relations entre entités
@@ -149,7 +160,7 @@ async function getLightModeInputs(projectName, flags) {
     );
     if (wantsRelation) {
       console.log(`\n${info("[INFO]")} Configuring relationships`);
-      await addRelations(inputs.entitiesData);
+      await buildRelationsInteractive(inputs.entitiesData);
     }
   }
 
@@ -213,248 +224,4 @@ function getDockerChoice(flags) {
   return readline.keyInYNStrict(`${info("[?]")} Generate Docker files ?`);
 }
 
-async function addCustomEntities(entitiesData) {
-  while (true) {
-    let name;
-    while (true) {
-      name = readline.question("\nEntity name (empty to finish) : ");
-      if (!name) return;
-      if (/^[A-Za-z][A-Za-z0-9_]*$/.test(name)) break;
-      logWarning("Invalid name. Use letters, numbers, and _ only.");
-    }
-
-    const fields = [];
-    console.log(` Fields for entity "${name}" :`);
-
-    while (true) {
-      const fieldName = readline.question("  Field name (empty to finish) : ");
-      if (!fieldName) break;
-
-      if (!/^[A-Za-z][A-Za-z0-9_]*$/.test(fieldName)) {
-        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 of "${fieldName}"`,
-        default: "string",
-        choices: baseTypeChoices,
-      };
-
-      const typeAnswer = await actualInquirer.prompt([typeQuestion]);
-      let fieldType = typeAnswer.ftype; // --- ADVANCED LOGIC FOR ARRAY, ENUM, AND OBJECT ---
-      // Déplace le curseur d'une ligne vers le haut :
-      process.stdout.write("\x1B[1A");
-      // Efface la ligne (où se trouvait le "√ Type for...") :
-      process.stdout.write("\x1B[K");
-
-      if (fieldType === "array") {
-        // Prompt spécifique pour le type interne du tableau
-        const arrayInnerQuestion = {
-          type: "list",
-          name: "innerType",
-          message: `Type of elements in "${fieldName}[]"`,
-          default: "string", // Exclure array et object du sous-type pour simplifier
-          choices: baseTypeChoices.filter(
-            (c) => c !== "array" && c !== "object"
-          ),
-        };
-
-        const innerAnswer = await actualInquirer.prompt([arrayInnerQuestion]);
-        fieldType = `${innerAnswer.innerType}[]`;
-      } else if (fieldType === "enum") {
-        const enumName = capitalize(fieldName) + "Enum";
-        logInfo(
-          `Enum type selected. Remember to define ${enumName} in your code.`
-        );
-        fieldType = enumName;
-      } else if (fieldType === "object") {
-        // Prompt pour nommer l'objet (ou 'json' par défaut)
-        const objectNameQuestion = {
-          type: "input",
-          name: "objectName",
-          message: `Complex type name (DTO/Class or leave 'json') :`,
-          default: "json",
-        };
-
-        const objectAnswer = await actualInquirer.prompt([objectNameQuestion]);
-        fieldType = capitalize(objectAnswer.objectName.trim() || "json");
-      }
-
-      console.log(
-        `  Field type for "${fieldName}" : ${fieldType} ${success("[✓]")}`
-      );
-
-      fields.push({ name: fieldName, type: fieldType });
-    }
-
-    if (fields.length > 0) {
-      entitiesData.entities.push({ name, fields });
-      console.log(
-        `${info("[INFO]")} Entity "${name}" added with ${
-          fields.length
-        } field(s)`
-      );
-    }
-
-    const addMore = readline.keyInYNStrict("Add another entity?");
-    if (!addMore) break;
-  }
-}
-
-/**
- * Manages adding relationships between entities via an interactive interface.
- * All prompts and logs are in English.
- * @param {Object} entitiesData - The object containing entities and relations.
- */
-async function addRelations(entitiesData) {
-  if (entitiesData.entities.length < 2) {
-    logInfo("At least two entities are required to create a relationship.");
-    return;
-  }
-
-  let configuring = true;
-
-  while (configuring) {
-    const entityNames = entitiesData.entities.map((e) => e.name);
-
-    // 1. Interactive selection of entities
-    const answers = await actualInquirer.prompt([
-      {
-        type: "list",
-        name: "fromName",
-        message: "Select the source entity (From) :",
-        choices: entityNames,
-      },
-      {
-        type: "list",
-        name: "toName",
-        message: (prev) =>
-          `To which entity do you want to link ${prev.fromName} ?`,
-        choices: (prev) => entityNames.filter((name) => name !== prev.fromName),
-      },
-    ]);
-
-    // --- CHECK FOR EXISTING RELATIONSHIPS ---
-    const alreadyExists = entitiesData.relations.find(
-      (rel) =>
-        (rel.from === answers.fromName && rel.to === answers.toName) ||
-        (rel.from === answers.toName && rel.to === answers.fromName)
-    );
-
-    if (alreadyExists) {
-      logWarning(
-        `A relationship already exists between ${answers.fromName} and ${answers.toName} (${alreadyExists.type}).`
-      );
-
-      const { tryAgain } = await actualInquirer.prompt([
-        {
-          type: "confirm",
-          name: "tryAgain",
-          message: "Would you like to choose different entities ?",
-          default: true,
-        },
-      ]);
-
-      if (!tryAgain) break;
-      // Restart the loop
-      continue;
-    }
-
-    // 2. Select Relationship Type
-    const typeAnswer = await actualInquirer.prompt([
-      {
-        type: "list",
-        name: "relType",
-        message: "What is the relationship type?",
-        choices: [
-          {
-            name: `1-1 (One-to-One)   : ${answers.fromName} is linked to exactly one ${answers.toName}`,
-            value: "1-1",
-          },
-          {
-            name: `1-n (One-to-Many)  : ${answers.fromName} owns multiple ${answers.toName}s`,
-            value: "1-n",
-          },
-          {
-            name: `n-1 (Many-to-One)  : Multiple ${answers.fromName}s belong to one ${answers.toName}`,
-            value: "n-1",
-          },
-          {
-            name: `n-n (Many-to-Many) : Multiple ${answers.fromName}s are linked to multiple ${answers.toName}s`,
-            value: "n-n",
-          },
-        ],
-      },
-    ]);
-
-    const from = entitiesData.entities.find((e) => e.name === answers.fromName);
-    const to = entitiesData.entities.find((e) => e.name === answers.toName);
-    const relType = typeAnswer.relType;
-
-    // 3. Register relationship
-    entitiesData.relations.push({
-      from: from.name,
-      to: to.name,
-      type: relType,
-    });
-
-    // 4. Automatic field injection
-    const fromLow = from.name.toLowerCase();
-    const toLow = to.name.toLowerCase();
-    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(
-      `${success("[✓]")} Relationship added: ${from.name} ${relType} ${to.name}`
-    );
-
-    // 5. Ask to continue
-    const { addMore } = await actualInquirer.prompt([
-      {
-        type: "confirm",
-        name: "addMore",
-        message: "Do you want to add another relationship ?",
-        default: false,
-      },
-    ]);
-
-    configuring = addMore;
-  }
-}
-
 module.exports = { getLightModeInputs };