nestcraftx 0.3.0 → 1.0.0

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) {
@@ -93,12 +94,16 @@ async function getLightModeInputs(projectName, flags) {
   // JWT Auth config
   const useAuth = getAuthChoice(flags);
 
+  // Throttler config
+  const useThrottler = getThrottlerChoice(flags);
+
   const packageManager = await getPackageManager(flags);
   inputs.packageManager = packageManager;
 
   inputs.useAuth = useAuth;
   inputs.useSwagger = useSwagger;
   inputs.useDocker = useDocker;
+  inputs.useThrottler = useThrottler;
 
   if (useAuth) {
     console.log(
@@ -139,7 +144,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 +164,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 +228,14 @@ 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}[]` });
-    }
+function getThrottlerChoice(flags) {
+  if (flags.throttler !== undefined) {
     console.log(
-      `${success("[✓]")} Relationship added: ${from.name} ${relType} ${to.name}`
+      `${info("[INFO]")} Throttler: ${flags.throttler ? "Yes" : "No"} (via flag)`
     );
-
-    // 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;
+    return flags.throttler === true || flags.throttler === "true";
   }
+  return readline.keyInYNStrict(`${info("[?]")} Enable Rate Limiting (Throttler) ?`);
 }
 
 module.exports = { getLightModeInputs };

package/utils/setups/orms/typeOrmSetup.js

@@ -21,8 +21,11 @@ async function setupTypeORM(inputs) {
   logInfo("📦 Installing TypeORM and PostgreSQL dependencies...");
 
   const mode = inputs.mode;
+  const pkgManager = inputs.packageManager || "npm";
+  const installCmd = pkgManager === "yarn" || pkgManager === "pnpm" ? `${pkgManager} add` : "npm install";
+
   await runCommand(
-    "npm install @nestjs/typeorm typeorm pg reflect-metadata",
+    `${installCmd} @nestjs/typeorm@^10.0.2 typeorm@^0.3.20 pg@^8.11.3 reflect-metadata@^0.2.1`,
     "TypeORM and PostgreSQL dependencies installed successfully"
   ); // Updating app.module.ts with TypeORM
 
@@ -162,12 +165,39 @@ async function setupTypeORM(inputs) {
         columnOptions.push("default: Role.USER");
       }
 
-      if (field.optional) {
+      if (field.unique || field.name.toLowerCase() === "email") {
+        columnOptions.push("unique: true");
+      }
+
+      const isNullable = field.nullable || field.optional;
+      if (isNullable) {
         columnOptions.push("nullable: true");
       }
 
-      if (field.name.toLowerCase() === "email") {
-        columnOptions.push("unique: true");
+      if (field.default !== undefined && field.default !== null && field.default !== "") {
+        let defaultVal = field.default;
+        if (typeof defaultVal === "string") {
+          if (defaultVal === "true") defaultVal = true;
+          else if (defaultVal === "false") defaultVal = false;
+          else if (defaultVal.toLowerCase() === "now" || defaultVal.toLowerCase() === "now()") {
+            defaultVal = "CURRENT_TIMESTAMP";
+          } else if (!isNaN(defaultVal) && defaultVal.trim() !== "") {
+            defaultVal = Number(defaultVal);
+          }
+        }
+        if (defaultVal === "CURRENT_TIMESTAMP") {
+          columnOptions.push(`default: () => 'CURRENT_TIMESTAMP'`);
+        } else if (typeof defaultVal === "boolean" || typeof defaultVal === "number") {
+          columnOptions.push(`default: ${defaultVal}`);
+        } else if (mapping.type === "enum") {
+          if (mapping.tsType && /^[A-Z]/.test(mapping.tsType)) {
+            columnOptions.push(`default: ${mapping.tsType}.${defaultVal.toUpperCase()}`);
+          } else {
+            columnOptions.push(`default: '${defaultVal}'`);
+          }
+        } else {
+          columnOptions.push(`default: '${defaultVal}'`);
+        }
       }
 
       // 2. Gestion des Imports d'Enums Custom
@@ -186,7 +216,7 @@ async function setupTypeORM(inputs) {
       // 3. Construction du champ
       fieldsContent += `
           @Column({ ${columnOptions.join(", ")} })
-          ${field.name}${field.optional ? "?" : ""}: ${mapping.tsType};
+          ${field.name}${isNullable ? "?" : ""}: ${mapping.tsType};
           `;
     }
 
@@ -419,13 +449,17 @@ async function setupTypeOrmSeeding(inputs) {
     "typeorm-extension",
   ];
 
+  const pkgManager = inputs.packageManager || "npm";
+  const installDevCmd = pkgManager === "yarn" || pkgManager === "pnpm" ? `${pkgManager} add -D` : "npm install -D";
+  const installCmd = pkgManager === "yarn" || pkgManager === "pnpm" ? `${pkgManager} add` : "npm install";
+
   await runCommand(
-    `${inputs.packageManager} add -D ${typeOrmDevDeps.join(" ")}`,
+    `${installDevCmd} ${typeOrmDevDeps.join(" ")}`,
     "❌ Failed to install TypeORM seeding dependencies"
   );
 
   await runCommand(
-    `${inputs.packageManager} install bcrypt`,
+    `${installCmd} bcrypt`,
     "❌ Failed to install bcrypt"
   );
 
@@ -435,7 +469,7 @@ async function setupTypeOrmSeeding(inputs) {
       "typeorm-ts-node-commonjs migration:run -d ./src/database/typeorm.config.ts",
     "typeorm:seed":
       "typeorm-extension seed:run -d src/database/typeorm.config.ts",
-    seed: "npm run typeorm:seed",
+    seed: `${pkgManager} run typeorm:seed`,
   };
 
   await updatePackageJson(inputs, typeOrmScripts);

package/utils/setups/projectSetup.js

@@ -1,8 +1,24 @@
 const readline = require("readline-sync");
-const { logInfo } = require("../loggers/logInfo");
-const { runCommand } = require("../shell");
 const fs = require("fs");
+const path = require("path");
 const { info } = require("../colors");
+const { logInfo } = require("../loggers/logInfo");
+const { logError } = require("../loggers/logError");
+const { runCommand } = require("../shell");
+
+// Pipeline imports
+const { setupCleanArchitecture } = require("../configs/setupCleanArchitecture");
+const { setupLightArchitecture } = require("../configs/setupLightArchitecture");
+const { setupAuth } = require("./setupAuth");
+const { setupSwagger } = require("./setupSwagger");
+const { setupThrottler } = require("./setupThrottler");
+const { setupHealth } = require("./setupHealth");
+const { setupDatabase } = require("./setupDatabase");
+const { configureDocker } = require("../configs/configureDocker");
+const { setupBootstrapLogger } = require("./setupLogger");
+const { generateEnvFile, writeEnvFile } = require("../envGenerator");
+const { saveProjectConfig } = require("../file-utils/saveProjectConfig");
+const { printSetupWarnings } = require("../shell");
 
 async function createProject(inputs) {
   if (fs.existsSync(inputs.projectName)) {
@@ -13,34 +29,96 @@ async function createProject(inputs) {
     );
 
     if (confirmation) {
-      // confirmation is true if the user presses 'y'
       console.log("Deleting existing project...");
       fs.rmSync(inputs.projectName, { recursive: true, force: true });
     } else {
       console.log("Operation cancelled by user. Exiting.");
-      return; // Stop function execution if the user cancels
+      throw new Error("Operation cancelled by user.");
     }
   }
 
   logInfo(`Creating NestJS project: ${inputs.projectName}`);
 
-  // Remains asynchronous as runCommand likely involves external processes (npm/npx)
   await runCommand(
-    `npx @nestjs/cli new ${inputs.projectName} --package-manager ${inputs.packageManager}`,
+    `npx @nestjs/cli new ${inputs.projectName} --package-manager ${inputs.packageManager} --skip-install`,
     "Failed to create NestJS project"
   );
 
   // Changing the current process directory to the project root
-  process.chdir(inputs.projectName);
+  const isDryRun = process.argv.includes("--dry-run");
+  if (!isDryRun) {
+    process.chdir(inputs.projectName);
+  } else {
+    console.log(`[DRY-RUN] Simulated: change directory to ${inputs.projectName}`);
+  }
 
   // Installing dependencies
   logInfo("Installing dependencies...");
 
-  // Remains asynchronous as runCommand likely involves external processes (npm/npx)
   await runCommand(
-    `${inputs.packageManager} add @nestjs/config class-validator class-transformer dotenv`,
+    `${inputs.packageManager} add @nestjs/config@^3.2.0 class-validator@^0.14.1 class-transformer@^0.5.1 dotenv@^16.4.5`,
     "Failed to install dependencies"
   );
 }
 
-module.exports = { createProject };
+/**
+ * Runs the complete project scaffolding and setup pipeline in sequence.
+ * Handles CWD tracking and restores the working directory on failure.
+ * @param {object} inputs
+ */
+async function runProjectSetupPipeline(inputs) {
+  const originalCwd = process.cwd();
+  try {
+    logInfo("Starting project generation...");
+
+    await createProject(inputs);
+
+    if (inputs.mode === "light") {
+      await setupLightArchitecture(inputs);
+    } else {
+      await setupCleanArchitecture(inputs);
+    }
+
+    if (inputs.useThrottler) {
+      await setupThrottler(inputs);
+    }
+
+    await setupHealth();
+
+    if (inputs.useAuth) {
+      await setupAuth(inputs);
+    }
+
+    if (inputs.useSwagger) {
+      await setupSwagger(inputs.swaggerInputs);
+    } else {
+      setupBootstrapLogger();
+    }
+
+    if (inputs.useDocker) {
+      await configureDocker(inputs);
+    }
+
+    await setupDatabase(inputs);
+
+    const envContent = await generateEnvFile(inputs);
+    writeEnvFile(envContent);
+
+    await saveProjectConfig(inputs);
+
+    // Show warnings
+    printSetupWarnings();
+
+  } catch (error) {
+    logError(`Error during project creation: ${error.message}`);
+    if (process.cwd() !== originalCwd) {
+      process.chdir(originalCwd);
+    }
+    throw error;
+  }
+}
+
+module.exports = {
+  createProject,
+  runProjectSetupPipeline,
+};