create-backlist 10.1.0 → 10.1.2

package/src/generators/nestjs.js

@@ -4,12 +4,32 @@ import fs from 'fs-extra';
 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 timer() {
+  const s = Date.now();
+  return () => `${((Date.now() - s) / 1000).toFixed(2)}s`;
+}
+
+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} (${i + 1}/${attempts}), retrying in ${delay}ms...`));
+        await new Promise(r => setTimeout(r, delay));
+      }
+    }
+  }
+  throw lastErr;
+}
 
 function safePascalName(name) {
-  const cleaned = String(name || 'Default')
-    .split('?')[0]
-    .replace(/[^a-zA-Z0-9]/g, '');
+  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,69 +45,99 @@ function sanitizeEndpoints(endpoints) {
   });
 }
 
+// ─── Main Generator ───────────────────────────────────────────────────────────
+
 export async function generateNestProject(options) {
-  const {
-    projectDir,
-    projectName,
-    frontendSrcDir,
-    dbType,
-    addAuth,
-    addSeeder,
-    extraFeatures = [],
-  } = options;
+  const { projectDir, projectName, frontendSrcDir, dbType, addAuth, addSeeder, extraFeatures = [] } = options;
+  const totalTimer = timer();
 
   try {
-    console.log(chalk.blue('  -> Analyzing frontend for NestJS backend...'));
-    let endpoints = await analyzeFrontend(frontendSrcDir);
-
-    if (Array.isArray(endpoints) && endpoints.length > 0) {
-      console.log(chalk.green(`  -> Found ${endpoints.length} endpoints.`));
-      endpoints = sanitizeEndpoints(endpoints);
-    } else {
-      endpoints = [];
-      console.log(chalk.yellow('  -> No API endpoints found. A basic project will be created.'));
-    }
+    // ── Step 1: Analyze + preload templates in parallel ────────────────────────
+    const step1 = timer();
+    console.log(chalk.blue('  -> [1] Analyzing frontend & preloading templates in parallel...'));
+
+    const templatePrefetch = [
+      'nestjs/partials/package.json.ejs',
+      'nestjs/partials/module.ts.ejs',
+      'nestjs/partials/controller.ts.ejs',
+      'nestjs/partials/service.ts.ejs',
+      'nestjs/partials/create-dto.ts.ejs',
+      'nestjs/partials/update-dto.ts.ejs',
+      'nestjs/partials/prisma.service.ts.ejs',
+      ...(dbType === 'mongoose' ? ['nestjs/partials/schema.ts.ejs'] : []),
+      ...(addAuth ? ['nestjs/partials/auth.module.ts.ejs', 'nestjs/partials/auth.controller.ts.ejs', 'nestjs/partials/auth.service.ts.ejs', 'nestjs/partials/jwt-guard.ts.ejs'] : []),
+      ...(addSeeder ? ['nestjs/partials/seeder.ts.ejs'] : []),
+    ];
+
+    const [endpointsRaw] = await Promise.all([
+      analyzeFrontend(frontendSrcDir),
+      preloadTemplates(templatePrefetch).catch(() => {}),
+    ]);
+
+    let endpoints = Array.isArray(endpointsRaw) && endpointsRaw.length > 0
+      ? sanitizeEndpoints(endpointsRaw)
+      : [];
+
+    console.log(
+      endpoints.length > 0
+        ? chalk.green(`  -> Found ${endpoints.length} endpoints. ${chalk.gray(step1())}`)
+        : chalk.yellow(`  -> No endpoints found. Basic project will be created. ${chalk.gray(step1())}`)
+    );
 
-    // --- Identify Models ---
+    // ── 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')) {
-      modelsToGenerate.set('User', {
-        name: 'User',
-        fields: [
-          { name: 'name', type: 'String' },
-          { name: 'email', type: 'String', isUnique: true },
-          { name: 'password', type: 'String' },
-        ],
-      });
+      modelsToGenerate.set('User', { name: 'User', fields: [
+        { name: 'name', type: 'String' },
+        { name: 'email', type: 'String', isUnique: true },
+        { name: 'password', type: 'String' },
+      ]});
     }
 
-    // --- Base Scaffolding ---
-    console.log(chalk.blue('  -> Scaffolding NestJS project...'));
-    const srcDir = path.join(projectDir, 'src');
-    await fs.ensureDir(srcDir);
+    // ── Step 3: Scaffold dirs + copy base files in parallel ───────────────────
+    const step3 = timer();
+    console.log(chalk.blue('  -> [3] Scaffolding NestJS project structure in parallel...'));
 
-    await fs.copy(getTemplatePath('nestjs/base/main.ts'), path.join(srcDir, 'main.ts'));
-    await fs.copy(getTemplatePath('nestjs/base/app.module.ts'), path.join(srcDir, 'app.module.ts'));
-    await fs.copy(getTemplatePath('nestjs/base/tsconfig.json'), path.join(projectDir, 'tsconfig.json'));
+    const srcDir = path.join(projectDir, 'src');
 
-    // --- package.json ---
+    // Pre-compute all module dirs
+    const moduleDirs = Array.from(modelsToGenerate.keys())
+      .filter(n => n !== 'Auth')
+      .flatMap(name => [
+        path.join(srcDir, name.toLowerCase()),
+        path.join(srcDir, name.toLowerCase(), 'dto'),
+      ]);
+
+    const extraDirs = [
+      ...(dbType === 'prisma' ? [path.join(srcDir, 'prisma'), path.join(projectDir, 'prisma')] : []),
+      ...(addAuth ? [path.join(srcDir, 'auth')] : []),
+      ...(addSeeder ? [path.join(projectDir, 'scripts')] : []),
+    ];
+
+    await Promise.all([
+      fs.ensureDir(srcDir),
+      ...moduleDirs.map(d => fs.ensureDir(d)),
+      ...extraDirs.map(d => fs.ensureDir(d)),
+      fs.copy(getTemplatePath('nestjs/base/main.ts'), path.join(srcDir, 'main.ts')),
+      fs.copy(getTemplatePath('nestjs/base/app.module.ts'), path.join(srcDir, 'app.module.ts')),
+      fs.copy(getTemplatePath('nestjs/base/tsconfig.json'), path.join(projectDir, 'tsconfig.json')),
+    ]);
+
+    console.log(chalk.gray(`     Scaffolding done. ${step3()}`));
+
+    // ── Step 4: package.json + nest-cli.json ──────────────────────────────────
     const pkgTpl = await fs.readFile(getTemplatePath('nestjs/partials/package.json.ejs'), 'utf-8');
     const packageJsonContent = JSON.parse(ejs.render(pkgTpl, { projectName }));
 
@@ -109,64 +159,43 @@ export async function generateNestProject(options) {
       packageJsonContent.scripts.seed = 'ts-node scripts/seeder.ts';
     }
 
-    await fs.writeJson(path.join(projectDir, 'package.json'), packageJsonContent, { spaces: 2 });
-
-    // --- nest-cli.json ---
-    await fs.writeJson(path.join(projectDir, 'nest-cli.json'), {
+    const nestCliJson = {
       "$schema": "https://json.schemastore.org/nest-cli",
       "collection": "@nestjs/schematics",
       "sourceRoot": "src",
-      "compilerOptions": { "deleteOutDir": true }
-    }, { spaces: 2 });
+      "compilerOptions": { "deleteOutDir": true },
+    };
 
-    // --- Generate Modules ---
+    await Promise.all([
+      fs.writeJson(path.join(projectDir, 'package.json'), packageJsonContent, { spaces: 2 }),
+      fs.writeJson(path.join(projectDir, 'nest-cli.json'), nestCliJson, { spaces: 2 }),
+    ]);
+
+    // ── Step 5: Generate all NestJS modules in PARALLEL ───────────────────────
+    const step5 = timer();
     const moduleImports = [];
     const moduleNames = [];
+    const renderTasks = [];
 
     if (modelsToGenerate.size > 0) {
-      console.log(chalk.blue('  -> Generating NestJS modules (Controller, Service, DTO)...'));
+      console.log(chalk.blue(`  -> [5] Generating ${modelsToGenerate.size} NestJS module(s) in parallel...`));
 
       for (const [modelName, modelData] of modelsToGenerate.entries()) {
         if (modelName === 'Auth') continue;
-
         const moduleDir = path.join(srcDir, modelName.toLowerCase());
         const dtoDir = path.join(moduleDir, 'dto');
-        await fs.ensureDir(dtoDir);
-
         const tplData = { modelName, dbType, fields: modelData.fields || [] };
 
-        await renderAndWrite(
-          getTemplatePath('nestjs/partials/module.ts.ejs'),
-          path.join(moduleDir, `${modelName.toLowerCase()}.module.ts`),
-          tplData
-        );
-        await renderAndWrite(
-          getTemplatePath('nestjs/partials/controller.ts.ejs'),
-          path.join(moduleDir, `${modelName.toLowerCase()}.controller.ts`),
-          tplData
-        );
-        await renderAndWrite(
-          getTemplatePath('nestjs/partials/service.ts.ejs'),
-          path.join(moduleDir, `${modelName.toLowerCase()}.service.ts`),
-          tplData
-        );
-        await renderAndWrite(
-          getTemplatePath('nestjs/partials/create-dto.ts.ejs'),
-          path.join(dtoDir, `create-${modelName.toLowerCase()}.dto.ts`),
-          tplData
-        );
-        await renderAndWrite(
-          getTemplatePath('nestjs/partials/update-dto.ts.ejs'),
-          path.join(dtoDir, `update-${modelName.toLowerCase()}.dto.ts`),
-          tplData
+        renderTasks.push(
+          { templatePath: getTemplatePath('nestjs/partials/module.ts.ejs'),      outPath: path.join(moduleDir, `${modelName.toLowerCase()}.module.ts`),     data: tplData },
+          { templatePath: getTemplatePath('nestjs/partials/controller.ts.ejs'),  outPath: path.join(moduleDir, `${modelName.toLowerCase()}.controller.ts`),  data: tplData },
+          { templatePath: getTemplatePath('nestjs/partials/service.ts.ejs'),     outPath: path.join(moduleDir, `${modelName.toLowerCase()}.service.ts`),     data: tplData },
+          { templatePath: getTemplatePath('nestjs/partials/create-dto.ts.ejs'),  outPath: path.join(dtoDir,    `create-${modelName.toLowerCase()}.dto.ts`),  data: tplData },
+          { templatePath: getTemplatePath('nestjs/partials/update-dto.ts.ejs'),  outPath: path.join(dtoDir,    `update-${modelName.toLowerCase()}.dto.ts`),  data: tplData }
         );
 
         if (dbType === 'mongoose') {
-          await renderAndWrite(
-            getTemplatePath('nestjs/partials/schema.ts.ejs'),
-            path.join(moduleDir, `${modelName.toLowerCase()}.schema.ts`),
-            tplData
-          );
+          renderTasks.push({ templatePath: getTemplatePath('nestjs/partials/schema.ts.ejs'), outPath: path.join(moduleDir, `${modelName.toLowerCase()}.schema.ts`), data: tplData });
         }
 
         moduleImports.push(`import { ${modelName}Module } from './${modelName.toLowerCase()}/${modelName.toLowerCase()}.module';`);
@@ -174,96 +203,80 @@ export async function generateNestProject(options) {
       }
     }
 
-    // --- Prisma module ---
+    // Prisma module tasks
     if (dbType === 'prisma') {
-      const prismaDir = path.join(srcDir, 'prisma');
-      await fs.ensureDir(prismaDir);
-      await renderAndWrite(
-        getTemplatePath('nestjs/partials/prisma.service.ts.ejs'),
-        path.join(prismaDir, 'prisma.service.ts'),
-        {}
+      const prismaModuleContent = `import { Global, Module } from '@nestjs/common';\nimport { PrismaService } from './prisma.service';\n\n@Global()\n@Module({\n  providers: [PrismaService],\n  exports: [PrismaService],\n})\nexport class PrismaModule {}\n`;
+      renderTasks.push(
+        { templatePath: getTemplatePath('nestjs/partials/prisma.service.ts.ejs'), outPath: path.join(srcDir, 'prisma', 'prisma.service.ts'), data: {} },
+        { templatePath: getTemplatePath('js-express/partials/prisma.schema.ejs'), outPath: path.join(projectDir, 'prisma', 'schema.prisma'), data: { models: Array.from(modelsToGenerate.values()) } }
       );
-      const prismaModuleContent = `import { Global, Module } from '@nestjs/common';
-import { PrismaService } from './prisma.service';
-
-@Global()
-@Module({
-  providers: [PrismaService],
-  exports: [PrismaService],
-})
-export class PrismaModule {}
-`;
-      await fs.writeFile(path.join(prismaDir, 'prisma.module.ts'), prismaModuleContent);
+      // Write the prisma module content directly (not via template)
+      renderTasks.push({ _raw: true, outPath: path.join(srcDir, 'prisma', 'prisma.module.ts'), content: prismaModuleContent });
       moduleImports.unshift("import { PrismaModule } from './prisma/prisma.module';");
       moduleNames.unshift('PrismaModule');
-
-      await fs.ensureDir(path.join(projectDir, 'prisma'));
-      await renderAndWrite(
-        getTemplatePath('js-express/partials/prisma.schema.ejs'),
-        path.join(projectDir, 'prisma', 'schema.prisma'),
-        { models: Array.from(modelsToGenerate.values()) }
-      );
     }
 
-    // --- Mongoose config in AppModule ---
     if (dbType === 'mongoose') {
       moduleImports.unshift("import { MongooseModule } from '@nestjs/mongoose';");
       moduleNames.unshift(`MongooseModule.forRoot(process.env.MONGO_URI || 'mongodb://127.0.0.1:27017/${projectName}')`);
     }
 
-    // --- Auth Module ---
+    // Auth tasks
     if (addAuth) {
-      console.log(chalk.blue('  -> Generating Auth module...'));
-      const authDir = path.join(srcDir, 'auth');
-      await fs.ensureDir(authDir);
-
-      await renderAndWrite(
-        getTemplatePath('nestjs/partials/auth.module.ts.ejs'),
-        path.join(authDir, 'auth.module.ts'),
-        { dbType }
-      );
-      await renderAndWrite(
-        getTemplatePath('nestjs/partials/auth.controller.ts.ejs'),
-        path.join(authDir, 'auth.controller.ts'),
-        { dbType }
-      );
-      await renderAndWrite(
-        getTemplatePath('nestjs/partials/auth.service.ts.ejs'),
-        path.join(authDir, 'auth.service.ts'),
-        { dbType }
+      renderTasks.push(
+        { templatePath: getTemplatePath('nestjs/partials/auth.module.ts.ejs'),     outPath: path.join(srcDir, 'auth', 'auth.module.ts'),     data: { dbType } },
+        { templatePath: getTemplatePath('nestjs/partials/auth.controller.ts.ejs'), outPath: path.join(srcDir, 'auth', 'auth.controller.ts'), data: { dbType } },
+        { templatePath: getTemplatePath('nestjs/partials/auth.service.ts.ejs'),    outPath: path.join(srcDir, 'auth', 'auth.service.ts'),    data: { dbType } },
+        { templatePath: getTemplatePath('nestjs/partials/jwt-guard.ts.ejs'),       outPath: path.join(srcDir, 'auth', 'jwt-auth.guard.ts'),  data: {} }
       );
-      await renderAndWrite(
-        getTemplatePath('nestjs/partials/jwt-guard.ts.ejs'),
-        path.join(authDir, 'jwt-auth.guard.ts'),
-        {}
-      );
-
       moduleImports.push("import { AuthModule } from './auth/auth.module';");
       moduleNames.push('AuthModule');
     }
 
-    // --- Inject into app.module.ts ---
+    // Seeder
+    if (addSeeder) {
+      renderTasks.push({
+        templatePath: getTemplatePath('nestjs/partials/seeder.ts.ejs'),
+        outPath: path.join(projectDir, 'scripts', 'seeder.ts'),
+        data: { projectName, models: Array.from(modelsToGenerate.values()) },
+      });
+    }
+
+    // Fire all render tasks in parallel
+    const rawTasks = renderTasks.filter(t => t._raw);
+    const normalTasks = renderTasks.filter(t => !t._raw);
+
+    await Promise.all([
+      renderAndWriteAll(normalTasks, 12),
+      ...rawTasks.map(t => fs.outputFile(t.outPath, t.content)),
+    ]);
+
+    console.log(chalk.gray(`     Modules generated. ${step5()}`));
+
+    // ── Step 6: Inject into app.module.ts ─────────────────────────────────────
     let appModuleContent = await fs.readFile(path.join(srcDir, 'app.module.ts'), 'utf-8');
-    appModuleContent = appModuleContent.replace(
-      '// INJECT:IMPORTS',
-      moduleImports.join('\n')
-    );
-    appModuleContent = appModuleContent.replace(
-      '// INJECT:MODULES',
-      moduleNames.join(',\n    ')
-    );
+    appModuleContent = appModuleContent
+      .replace('// INJECT:IMPORTS', moduleImports.join('\n'))
+      .replace('// INJECT:MODULES', moduleNames.join(',\n    '));
     await fs.writeFile(path.join(srcDir, 'app.module.ts'), appModuleContent);
 
-    // --- Install deps ---
-    console.log(chalk.magenta('  -> Installing dependencies... This may take a moment.'));
-    await execa('npm', ['install'], { cwd: projectDir });
+    // ── Step 7: Install deps (with retry) ─────────────────────────────────────
+    console.log(chalk.magenta('  -> [7] Installing dependencies...'));
+    const step7 = timer();
+
+    await withRetry(() => execa('npm', ['install'], { cwd: projectDir }), {
+      attempts: 2, baseDelay: 1000, label: 'npm install',
+    });
+
+    console.log(chalk.gray(`     npm install done. ${step7()}`));
 
     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',
+      });
     }
 
-    // --- .env.example ---
+    // ── Step 8: .env.example ───────────────────────────────────────────────────
     let envContent = `PORT=8000\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`;
@@ -271,7 +284,7 @@ export class PrismaModule {}
 
     await fs.writeFile(path.join(projectDir, '.env.example'), envContent);
 
-    console.log(chalk.green('  -> NestJS backend generation complete.'));
+    console.log(chalk.green(`  -> ✓ NestJS backend generation complete. Total: ${chalk.bold(totalTimer())}`));
   } catch (error) {
     throw error;
   }