create-backlist 10.0.9 → 10.1.1

package/src/generators/node.js

@@ -5,7 +5,14 @@ import path from "node:path";
 import ejs from "ejs";
 
 import { analyzeFrontend } from "../analyzer.js";
-import { renderAndWrite, getTemplatePath } from "./template.js";
+import {
+  renderAndWrite,
+  renderAndWriteAll,
+  getTemplatePath,
+  preloadTemplates,
+} from "./template.js";
+
+// ─── Helpers ──────────────────────────────────────────────────────────────────
 
 function stripQuery(p) {
   return String(p || "").split("?")[0];
@@ -15,7 +22,6 @@ function safePascalName(name) {
   const cleaned = String(name || "Default")
     .split("?")[0]
     .replace(/[^a-zA-Z0-9]/g, "");
-
   if (!cleaned) return "Default";
   return cleaned.charAt(0).toUpperCase() + cleaned.slice(1);
 }
@@ -25,7 +31,6 @@ function sanitizeEndpoints(endpoints) {
 
   return endpoints.map((ep) => {
     const rawPath = stripQuery(ep.path || ep.route || "/");
-
     const parts = rawPath
       .split("/")
       .filter(Boolean)
@@ -33,7 +38,6 @@ function sanitizeEndpoints(endpoints) {
 
     const resource = parts[0] || "Default";
     const controllerName = safePascalName(resource);
-
     let functionName = "";
 
     if (controllerName.toLowerCase() === "auth") {
@@ -43,15 +47,12 @@ function sanitizeEndpoints(endpoints) {
     } else {
       const singularName = resource.endsWith("s") ? resource.slice(0, -1) : resource;
       const pluralName = resource.endsWith("s") ? resource : `${resource}s`;
-
       const pascalSingular = safePascalName(singularName);
       const pascalPlural = safePascalName(pluralName);
-
       const method = String(ep.method || "GET").toUpperCase();
-
       const hasId =
-        rawPath.includes(":") || 
-        rawPath.includes("{") || 
+        rawPath.includes(":") ||
+        rawPath.includes("{") ||
         /\/\d+/.test(rawPath);
 
       if (method === "GET") {
@@ -71,6 +72,32 @@ function sanitizeEndpoints(endpoints) {
   });
 }
 
+// ─── Performance timer util ────────────────────────────────────────────────────
+function timer() {
+  const start = Date.now();
+  return () => `${((Date.now() - start) / 1000).toFixed(2)}s`;
+}
+
+// ─── Retry with exponential backoff ───────────────────────────────────────────
+async function withRetry(fn, { attempts = 3, baseDelay = 300, label = "task" } = {}) {
+  let lastErr;
+  for (let i = 0; i < attempts; i++) {
+    try {
+      return await fn();
+    } catch (err) {
+      lastErr = err;
+      if (i < attempts - 1) {
+        const delay = baseDelay * 2 ** i;
+        console.log(chalk.yellow(`  [RETRY] ${label} failed (attempt ${i + 1}/${attempts}), retrying in ${delay}ms...`));
+        await new Promise(r => setTimeout(r, delay));
+      }
+    }
+  }
+  throw lastErr;
+}
+
+// ─── Main Generator ───────────────────────────────────────────────────────────
+
 export async function generateNodeProject(options) {
   const {
     projectDir,
@@ -83,43 +110,63 @@ export async function generateNodeProject(options) {
   } = options;
 
   const port = 8000;
+  const totalTimer = timer();
 
   try {
-    // --- Step 1: Analyze Frontend ---
-    console.log(chalk.blue("  -> Analyzing frontend for API endpoints..."));
-    let endpoints = await analyzeFrontend(frontendSrcDir);
-
-    if (Array.isArray(endpoints) && endpoints.length > 0) {
-      console.log(chalk.green(`  -> Found ${endpoints.length} endpoints.`));
-      endpoints = sanitizeEndpoints(endpoints);
+    // ── Step 1: Analyze + Preload templates in PARALLEL ────────────────────────
+    const step1 = timer();
+    console.log(chalk.blue("  -> [1/11] Analyzing frontend & preloading templates in parallel..."));
+
+    const templatePrefetch = [
+      "node-ts-express/partials/package.json.ejs",
+      "node-ts-express/partials/routes.ts.ejs",
+      ...(addAuth ? [
+        "node-ts-express/partials/Auth.controller.ts.ejs",
+        "node-ts-express/partials/Auth.routes.ts.ejs",
+        "node-ts-express/partials/Auth.middleware.ts.ejs",
+      ] : []),
+      ...(addSeeder ? ["node-ts-express/partials/Seeder.ts.ejs"] : []),
+      ...(extraFeatures.includes("swagger") ? ["node-ts-express/partials/ApiDocs.ts.ejs"] : []),
+      ...(extraFeatures.includes("testing") ? ["node-ts-express/partials/App.test.ts.ejs"] : []),
+      ...(extraFeatures.includes("docker") ? [
+        "node-ts-express/partials/Dockerfile.ejs",
+        "node-ts-express/partials/docker-compose.yml.ejs",
+      ] : []),
+    ];
+
+    const [endpointsRaw] = await Promise.all([
+      analyzeFrontend(frontendSrcDir),
+      preloadTemplates(templatePrefetch).catch(() => {}), // non-fatal prefetch
+    ]);
+
+    let endpoints = Array.isArray(endpointsRaw) && endpointsRaw.length > 0
+      ? sanitizeEndpoints(endpointsRaw)
+      : [];
+
+    if (endpoints.length > 0) {
+      console.log(chalk.green(`  -> Found ${endpoints.length} endpoints. ${chalk.gray(step1())}`));
     } else {
-      endpoints = [];
-      console.log(chalk.yellow("  -> No API endpoints found. A basic project will be created."));
+      console.log(chalk.yellow(`  -> No API endpoints found. Basic project will be created. ${chalk.gray(step1())}`));
     }
 
-    // --- Step 2: Identify Models to Generate ---
+    // ── Step 2: Build model map ────────────────────────────────────────────────
     const modelsToGenerate = new Map();
-
     endpoints.forEach((ep) => {
       if (!ep) return;
       const ctrl = safePascalName(ep.controllerName);
       if (ctrl === "Default" || ctrl === "Auth") return;
-
       if (!modelsToGenerate.has(ctrl)) {
-        let fields = [];
-        if (ep.schemaFields) {
-          fields = Object.entries(ep.schemaFields).map(([key, type]) => ({
-            name: key,
-            type,
-            isUnique: key === "email",
-          }));
-        }
+        const fields = ep.schemaFields
+          ? Object.entries(ep.schemaFields).map(([key, type]) => ({
+              name: key, type, isUnique: key === "email",
+            }))
+          : [];
         modelsToGenerate.set(ctrl, { name: ctrl, fields });
       }
     });
 
     if (addAuth && !modelsToGenerate.has("User")) {
-      console.log(chalk.yellow('  -> Authentication requires a "User" model. Creating a default one.'));
+      console.log(chalk.yellow('  -> Auth requires "User" model. Creating default.'));
       modelsToGenerate.set("User", {
         name: "User",
         fields: [
@@ -130,15 +177,39 @@ export async function generateNodeProject(options) {
       });
     }
 
-    // --- Step 3: Base Scaffolding ---
-    console.log(chalk.blue("  -> Scaffolding Node.js project..."));
-    const destSrcDir = path.join(projectDir, "src");
-    await fs.ensureDir(destSrcDir);
+    // ── Step 3: Scaffold dirs + copy base files in PARALLEL ───────────────────
+    const step3 = timer();
+    console.log(chalk.blue("  -> [3/11] Scaffolding directory structure in parallel..."));
 
-    await fs.copy(getTemplatePath("node-ts-express/base/server.ts"), path.join(destSrcDir, "server.ts"));
-    await fs.copy(getTemplatePath("node-ts-express/base/tsconfig.json"), path.join(projectDir, "tsconfig.json"));
+    const destSrcDir = path.join(projectDir, "src");
 
-    // --- Step 4: package.json ---
+    const dirsToCreate = [
+      destSrcDir,
+      ...(modelsToGenerate.size > 0 ? [
+        path.join(destSrcDir, "application", "ports", "controllers"),
+        path.join(destSrcDir, "domain", "services"),
+        path.join(destSrcDir, "infrastructure", "adapters", "repositories"),
+        path.join(destSrcDir, "domain", "models"),
+        path.join(destSrcDir, "routes"),
+        path.join(destSrcDir, "middleware"),
+        path.join(destSrcDir, "controllers"),
+      ] : []),
+      ...(addSeeder ? [path.join(projectDir, "scripts")] : []),
+      ...(extraFeatures.includes("swagger") ? [path.join(destSrcDir, "utils")] : []),
+      ...(extraFeatures.includes("testing") ? [path.join(projectDir, "src", "__tests__")] : []),
+      ...(extraFeatures.includes("docker") ? [] : []),
+      ...(dbType === "prisma" ? [path.join(projectDir, "prisma")] : []),
+    ];
+
+    await Promise.all([
+      ...dirsToCreate.map(d => fs.ensureDir(d)),
+      fs.copy(getTemplatePath("node-ts-express/base/server.ts"), path.join(destSrcDir, "server.ts")),
+      fs.copy(getTemplatePath("node-ts-express/base/tsconfig.json"), path.join(projectDir, "tsconfig.json")),
+    ]);
+
+    console.log(chalk.gray(`     Scaffolding done. ${step3()}`));
+
+    // ── Step 4: package.json (build + write) ───────────────────────────────────
     const packageJsonContent = JSON.parse(
       await ejs.renderFile(getTemplatePath("node-ts-express/partials/package.json.ejs"), { projectName })
     );
@@ -149,30 +220,26 @@ export async function generateNodeProject(options) {
       packageJsonContent.devDependencies.prisma = "^5.6.0";
       packageJsonContent.prisma = { seed: `ts-node ${addSeeder ? "scripts/seeder.ts" : "prisma/seed.ts"}` };
     }
-
     if (addAuth) {
       packageJsonContent.dependencies.jsonwebtoken = "^9.0.2";
       packageJsonContent.dependencies.bcryptjs = "^2.4.3";
       packageJsonContent.devDependencies["@types/jsonwebtoken"] = "^9.0.5";
       packageJsonContent.devDependencies["@types/bcryptjs"] = "^2.4.6";
     }
-
     if (addSeeder) {
       packageJsonContent.devDependencies["@faker-js/faker"] = "^8.3.1";
       if (!packageJsonContent.dependencies.chalk) packageJsonContent.dependencies.chalk = "^4.1.2";
       packageJsonContent.scripts.seed = "ts-node scripts/seeder.ts";
       packageJsonContent.scripts.destroy = "ts-node scripts/seeder.ts -d";
     }
-
     if (extraFeatures.includes("testing")) {
-      packageJsonContent.devDependencies.jest = "^29.7.0";
-      packageJsonContent.devDependencies.supertest = "^6.3.3";
-      packageJsonContent.devDependencies["@types/jest"] = "^29.5.10";
-      packageJsonContent.devDependencies["@types/supertest"] = "^2.0.16";
-      packageJsonContent.devDependencies["ts-jest"] = "^29.1.1";
+      Object.assign(packageJsonContent.devDependencies, {
+        jest: "^29.7.0", supertest: "^6.3.3",
+        "@types/jest": "^29.5.10", "@types/supertest": "^2.0.16",
+        "ts-jest": "^29.1.1",
+      });
       packageJsonContent.scripts.test = "jest --detectOpenHandles --forceExit";
     }
-
     if (extraFeatures.includes("swagger")) {
       packageJsonContent.dependencies["swagger-ui-express"] = "^5.0.0";
       packageJsonContent.dependencies["swagger-jsdoc"] = "^6.2.8";
@@ -181,216 +248,167 @@ export async function generateNodeProject(options) {
 
     await fs.writeJson(path.join(projectDir, "package.json"), packageJsonContent, { spaces: 2 });
 
-    // --- Step 5: DB + Hexagonal Architecture Scaffolding ---
+    // ── Step 5: Generate DB schema / models (parallel per model) ──────────────
     if (modelsToGenerate.size > 0) {
+      const step5 = timer();
+      console.log(chalk.blue(`  -> [5/11] Generating ${modelsToGenerate.size} model(s) in parallel...`));
+
       const portDir = path.join(destSrcDir, "application", "ports", "controllers");
       const serviceDir = path.join(destSrcDir, "domain", "services");
       const repoDir = path.join(destSrcDir, "infrastructure", "adapters", "repositories");
       const modelDir = path.join(destSrcDir, "domain", "models");
-      
-      await fs.ensureDir(portDir);
-      await fs.ensureDir(serviceDir);
-      await fs.ensureDir(repoDir);
+
+      const hexTasks = [];
 
       if (dbType === "mongoose") {
-        console.log(chalk.blue("  -> Generating Mongoose domain models..."));
         await fs.ensureDir(modelDir);
-
         for (const [modelName, modelData] of modelsToGenerate.entries()) {
-          const schema = (modelData.fields || []).reduce((acc, field) => {
-            acc[field.name] = field.type;
+          const schema = (modelData.fields || []).reduce((acc, f) => {
+            acc[f.name] = f.type;
             return acc;
           }, {});
-          await renderAndWrite(
-            getTemplatePath("node-ts-express/partials/Model.ts.ejs"),
-            path.join(modelDir, `${modelName}.model.ts`),
-            { modelName, schema, projectName }
-          );
+          hexTasks.push({
+            templatePath: getTemplatePath("node-ts-express/partials/Model.ts.ejs"),
+            outPath: path.join(modelDir, `${modelName}.model.ts`),
+            data: { modelName, schema, projectName },
+          });
         }
       } else if (dbType === "prisma") {
-        console.log(chalk.blue("  -> Generating Prisma schema..."));
-        await fs.ensureDir(path.join(projectDir, "prisma"));
-        // Check if we already have a generated schema from AI Pass 1 (options.aiBlocks.prismaSchema)
-        if (options.aiBlocks && options.aiBlocks.prismaSchema) {
-           await fs.writeFile(path.join(projectDir, "prisma", "schema.prisma"), options.aiBlocks.prismaSchema);
+        const prismaOutPath = path.join(projectDir, "prisma", "schema.prisma");
+        if (options.aiBlocks?.prismaSchema) {
+          hexTasks.push({ _raw: true, outPath: prismaOutPath, content: options.aiBlocks.prismaSchema });
         } else {
-           await renderAndWrite(
-             getTemplatePath("node-ts-express/partials/PrismaSchema.prisma.ejs"),
-             path.join(projectDir, "prisma", "schema.prisma"),
-             { modelsToGenerate: Array.from(modelsToGenerate.values()) }
-           );
+          hexTasks.push({
+            templatePath: getTemplatePath("node-ts-express/partials/PrismaSchema.prisma.ejs"),
+            outPath: prismaOutPath,
+            data: { modelsToGenerate: Array.from(modelsToGenerate.values()) },
+          });
         }
       }
 
-      console.log(chalk.blue("  -> Generating Hexagonal Architecture layers (Controllers, Services, Repositories)..."));
       for (const [modelName] of modelsToGenerate.entries()) {
-        if (modelName !== "Auth") {
-          const blockData = { 
-            modelName, 
-            projectName, 
-            dbType,
-            aiSecurityConfig: options.aiBlocks?.aiSecurityConfig,
-            aiDbRelations: options.aiBlocks?.aiDbRelations,
-            aiValidationLogic: options.aiBlocks?.aiValidationLogic
-          };
-
-          // Controller (Port)
-          await renderAndWrite(
-            getTemplatePath(`node-ts-express/partials/HexController.ts.ejs`),
-            path.join(portDir, `${modelName}.controller.ts`),
-            blockData
-          );
-          // Service (Domain)
-          await renderAndWrite(
-            getTemplatePath(`node-ts-express/partials/HexService.ts.ejs`),
-            path.join(serviceDir, `${modelName}.service.ts`),
-            blockData
-          );
-          // Repository (Adapter)
-          await renderAndWrite(
-            getTemplatePath(`node-ts-express/partials/HexRepository.ts.ejs`),
-            path.join(repoDir, `${modelName}.repository.ts`),
-            blockData
-          );
-        }
+        if (modelName === "Auth") continue;
+        const blockData = {
+          modelName, projectName, dbType,
+          aiSecurityConfig: options.aiBlocks?.aiSecurityConfig,
+          aiDbRelations: options.aiBlocks?.aiDbRelations,
+          aiValidationLogic: options.aiBlocks?.aiValidationLogic,
+        };
+        hexTasks.push(
+          { templatePath: getTemplatePath("node-ts-express/partials/HexController.ts.ejs"), outPath: path.join(portDir, `${modelName}.controller.ts`), data: blockData },
+          { templatePath: getTemplatePath("node-ts-express/partials/HexService.ts.ejs"), outPath: path.join(serviceDir, `${modelName}.service.ts`), data: blockData },
+          { templatePath: getTemplatePath("node-ts-express/partials/HexRepository.ts.ejs"), outPath: path.join(repoDir, `${modelName}.repository.ts`), data: blockData }
+        );
       }
+
+      // Execute all hex tasks in parallel batches
+      const rawTasks = hexTasks.filter(t => t._raw);
+      const renderTasks = hexTasks.filter(t => !t._raw);
+
+      await Promise.all([
+        renderAndWriteAll(renderTasks),
+        ...rawTasks.map(t => fs.outputFile(t.outPath, t.content)),
+      ]);
+
+      console.log(chalk.gray(`     Models/Hex layers done. ${step5()}`));
     }
 
-    // --- Step 6: Auth ---
+    // ── Step 6: Auth, Seeder, Swagger, Docker, Testing — ALL IN PARALLEL ───────
+    const step6 = timer();
+    const parallelExtras = [];
+
     if (addAuth) {
-      console.log(chalk.blue("  -> Generating authentication boilerplate..."));
-      await fs.ensureDir(path.join(destSrcDir, "routes"));
-      await fs.ensureDir(path.join(destSrcDir, "middleware"));
-
-      await renderAndWrite(
-        getTemplatePath("node-ts-express/partials/Auth.controller.ts.ejs"),
-        path.join(destSrcDir, "controllers", "Auth.controller.ts"),
-        { dbType, projectName }
-      );
-      await renderAndWrite(
-        getTemplatePath("node-ts-express/partials/Auth.routes.ts.ejs"),
-        path.join(destSrcDir, "routes", "Auth.routes.ts"),
-        { projectName }
-      );
-      await renderAndWrite(
-        getTemplatePath("node-ts-express/partials/Auth.middleware.ts.ejs"),
-        path.join(destSrcDir, "middleware", "Auth.middleware.ts"),
-        { projectName }
+      console.log(chalk.blue("  -> [6a] Queuing auth boilerplate..."));
+      parallelExtras.push(
+        renderAndWrite(getTemplatePath("node-ts-express/partials/Auth.controller.ts.ejs"), path.join(destSrcDir, "controllers", "Auth.controller.ts"), { dbType, projectName }),
+        renderAndWrite(getTemplatePath("node-ts-express/partials/Auth.routes.ts.ejs"), path.join(destSrcDir, "routes", "Auth.routes.ts"), { projectName }),
+        renderAndWrite(getTemplatePath("node-ts-express/partials/Auth.middleware.ts.ejs"), path.join(destSrcDir, "middleware", "Auth.middleware.ts"), { projectName })
       );
     }
 
-    // --- Step 7: Seeder ---
     if (addSeeder) {
-      console.log(chalk.blue("  -> Generating database seeder script..."));
-      await fs.ensureDir(path.join(projectDir, "scripts"));
-      await renderAndWrite(
-        getTemplatePath("node-ts-express/partials/Seeder.ts.ejs"),
-        path.join(projectDir, "scripts", "seeder.ts"),
-        { projectName, models: Array.from(modelsToGenerate.values()) }
+      console.log(chalk.blue("  -> [6b] Queuing seeder..."));
+      parallelExtras.push(
+        renderAndWrite(getTemplatePath("node-ts-express/partials/Seeder.ts.ejs"), path.join(projectDir, "scripts", "seeder.ts"), { projectName, models: Array.from(modelsToGenerate.values()) })
       );
     }
 
-    // --- Step 8: Extras (FIXED) ---
     if (extraFeatures.includes("docker")) {
-      console.log(chalk.blue("  -> Generating Docker files..."));
-      await renderAndWrite(
-        getTemplatePath("node-ts-express/partials/Dockerfile.ejs"),
-        path.join(projectDir, "Dockerfile"),
-        { dbType, port }
-      );
-      await renderAndWrite(
-        getTemplatePath("node-ts-express/partials/docker-compose.yml.ejs"),
-        path.join(projectDir, "docker-compose.yml"),
-        { projectName, dbType, port, addAuth, extraFeatures }
+      console.log(chalk.blue("  -> [6c] Queuing Docker files..."));
+      parallelExtras.push(
+        renderAndWrite(getTemplatePath("node-ts-express/partials/Dockerfile.ejs"), path.join(projectDir, "Dockerfile"), { dbType, port }),
+        renderAndWrite(getTemplatePath("node-ts-express/partials/docker-compose.yml.ejs"), path.join(projectDir, "docker-compose.yml"), { projectName, dbType, port, addAuth, extraFeatures })
       );
     }
 
     if (extraFeatures.includes("swagger")) {
-      console.log(chalk.blue("  -> Generating API documentation setup..."));
-      await fs.ensureDir(path.join(destSrcDir, "utils"));
-      // FIX: Added 'paths' to the EJS data object
-      await renderAndWrite(
-        getTemplatePath("node-ts-express/partials/ApiDocs.ts.ejs"),
-        path.join(destSrcDir, "utils", "swagger.ts"),
-        { projectName, port, addAuth, paths: endpoints }
+      console.log(chalk.blue("  -> [6d] Queuing Swagger setup..."));
+      parallelExtras.push(
+        renderAndWrite(getTemplatePath("node-ts-express/partials/ApiDocs.ts.ejs"), path.join(destSrcDir, "utils", "swagger.ts"), { projectName, port, addAuth, paths: endpoints })
       );
     }
 
     if (extraFeatures.includes("testing")) {
-      console.log(chalk.blue("  -> Generating testing boilerplate..."));
-      const jestConfig =
-        "/** @type {import('ts-jest').JestConfigWithTsJest} */\nmodule.exports = {\n  preset: 'ts-jest',\n  testEnvironment: 'node',\n  verbose: true,\n};";
-
-      await fs.writeFile(path.join(projectDir, "jest.config.js"), jestConfig);
-      await fs.ensureDir(path.join(projectDir, "src", "__tests__"));
-
-      await renderAndWrite(
-        getTemplatePath("node-ts-express/partials/App.test.ts.ejs"),
-        path.join(projectDir, "src", "__tests__", "api.test.ts"),
-        { addAuth, endpoints }
+      console.log(chalk.blue("  -> [6e] Queuing test boilerplate..."));
+      const jestConfig = "/** @type {import('ts-jest').JestConfigWithTsJest} */\nmodule.exports = {\n  preset: 'ts-jest',\n  testEnvironment: 'node',\n  verbose: true,\n};";
+      parallelExtras.push(
+        fs.writeFile(path.join(projectDir, "jest.config.js"), jestConfig),
+        renderAndWrite(getTemplatePath("node-ts-express/partials/App.test.ts.ejs"), path.join(projectDir, "src", "__tests__", "api.test.ts"), { addAuth, endpoints })
       );
     }
 
-    // --- Step 9: routes.ts + server inject ---
+    // Non-auth routes (always needed)
     const nonAuthEndpoints = endpoints.filter((ep) => safePascalName(ep.controllerName) !== "Auth");
-
-    await renderAndWrite(
-      getTemplatePath("node-ts-express/partials/routes.ts.ejs"),
-      path.join(destSrcDir, "routes.ts"),
-      { endpoints: nonAuthEndpoints, addAuth, dbType }
+    parallelExtras.push(
+      renderAndWrite(getTemplatePath("node-ts-express/partials/routes.ts.ejs"), path.join(destSrcDir, "routes.ts"), { endpoints: nonAuthEndpoints, addAuth, dbType })
     );
 
+    await Promise.allSettled(parallelExtras);
+    console.log(chalk.gray(`     Extras (auth/seeder/docker/swagger/tests/routes) done. ${step6()}`));
+
+    // ── Step 7: Patch server.ts ────────────────────────────────────────────────
     let serverFileContent = await fs.readFile(path.join(destSrcDir, "server.ts"), "utf-8");
 
     let dbConnectionCode = "";
-    let swaggerInjector = "";
-    let authRoutesInjector = "";
-
     if (dbType === "mongoose") {
-      dbConnectionCode = `
-import mongoose from 'mongoose';
-const MONGO_URI = process.env.MONGO_URI || 'mongodb://127.0.0.1:27017/${projectName}';
-mongoose.connect(MONGO_URI)
-  .then(() => console.log('MongoDB Connected...'))
-  .catch(err => console.error(err));
-`;
+      dbConnectionCode = `\nimport mongoose from 'mongoose';\nconst MONGO_URI = process.env.MONGO_URI || 'mongodb://127.0.0.1:27017/${projectName}';\nmongoose.connect(MONGO_URI).then(() => console.log('MongoDB Connected...')).catch(err => console.error(err));\n`;
     } else if (dbType === "prisma") {
-      dbConnectionCode = `
-import { PrismaClient } from '@prisma/client';
-export const prisma = new PrismaClient();
-`;
+      dbConnectionCode = `\nimport { PrismaClient } from '@prisma/client';\nexport const prisma = new PrismaClient();\n`;
     }
 
-    if (extraFeatures.includes("swagger")) {
-      swaggerInjector = "\nimport { setupSwagger } from './utils/swagger';\nsetupSwagger(app);\n";
-    }
+    const swaggerInjector = extraFeatures.includes("swagger")
+      ? "\nimport { setupSwagger } from './utils/swagger';\nsetupSwagger(app);\n"
+      : "";
 
-    if (addAuth) {
-      authRoutesInjector = "import authRoutes from './routes/Auth.routes';\napp.use('/api/auth', authRoutes);\n\n";
-    }
+    const authRoutesInjector = addAuth
+      ? "import authRoutes from './routes/Auth.routes';\napp.use('/api/auth', authRoutes);\n\n"
+      : "";
 
     serverFileContent = serverFileContent
       .replace("dotenv.config();", `dotenv.config();${dbConnectionCode}`)
-      .replace(
-        "// INJECT:ROUTES",
-        `${authRoutesInjector}import apiRoutes from './routes';
-app.use('/api', apiRoutes);`
-      );
-
-    serverFileContent = serverFileContent.replace(/(app\.listen\()/, `${swaggerInjector}\n$1`);
+      .replace("// INJECT:ROUTES", `${authRoutesInjector}import apiRoutes from './routes';\napp.use('/api', apiRoutes);`)
+      .replace(/(app\.listen\()/, `${swaggerInjector}\n$1`);
 
     await fs.writeFile(path.join(destSrcDir, "server.ts"), serverFileContent);
 
-    // --- Step 10: Install deps ---
-    console.log(chalk.magenta("  -> Installing dependencies... This may take a moment."));
-    await execa("npm", ["install"], { cwd: projectDir });
+    // ── Step 8: Install deps + prisma generate in sequence ────────────────────
+    console.log(chalk.magenta("  -> [8/11] Installing dependencies..."));
+    const step8 = timer();
+
+    await withRetry(() => execa("npm", ["install"], { cwd: projectDir }), {
+      attempts: 2, baseDelay: 1000, label: "npm install",
+    });
+
+    console.log(chalk.gray(`     npm install done. ${step8()}`));
 
     if (dbType === "prisma") {
       console.log(chalk.blue("  -> Running `prisma generate`..."));
-      await execa("npx", ["prisma", "generate"], { cwd: projectDir });
+      await withRetry(() => execa("npx", ["prisma", "generate"], { cwd: projectDir }), {
+        attempts: 2, baseDelay: 500, label: "prisma generate",
+      });
     }
 
-    // --- Step 11: .env.example ---
+    // ── Step 9: .env.example ───────────────────────────────────────────────────
     let envContent = `PORT=${port}\n`;
     if (dbType === "mongoose") envContent += `MONGO_URI=mongodb://127.0.0.1:27017/${projectName}\n`;
     if (dbType === "prisma") envContent += `DATABASE_URL="postgresql://user:password@localhost:5432/${projectName}?schema=public"\n`;
@@ -398,7 +416,7 @@ app.use('/api', apiRoutes);`
 
     await fs.writeFile(path.join(projectDir, ".env.example"), envContent);
 
-    console.log(chalk.green("  -> Node backend generation complete."));
+    console.log(chalk.green(`  -> ✓ Node backend generation complete. Total: ${chalk.bold(totalTimer())}`));
   } catch (error) {
     throw error;
   }