create-backlist 10.0.9 → 10.1.1

package/src/generators/python.js

@@ -3,18 +3,65 @@ import { execa } from 'execa';
 import fs from 'fs-extra';
 import path from 'node:path';
 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;
+}
+
+// ─── Main Generator ───────────────────────────────────────────────────────────
 
 export async function generatePythonProject(options) {
   const { projectDir, projectName, frontendSrcDir } = options;
+  const totalTimer = timer();
 
   try {
-    console.log(chalk.blue('  -> Analyzing frontend for Python (FastAPI) backend...'));
-    const endpoints = await analyzeFrontend(frontendSrcDir);
+    // ── Step 1: Analyze + preload templates in parallel ────────────────────────
+    const step1 = timer();
+    console.log(chalk.blue('  -> [1] Analyzing frontend & preloading templates in parallel...'));
+
+    const [endpoints] = await Promise.all([
+      analyzeFrontend(frontendSrcDir),
+      preloadTemplates([
+        'python-fastapi/main.py.ejs',
+        'python-fastapi/requirements.txt.ejs',
+        'python-fastapi/app/core/config.py.ejs',
+        'python-fastapi/app/core/security.py.ejs',
+        'python-fastapi/app/db.py.ejs',
+        'python-fastapi/app/models/user.py.ejs',
+        'python-fastapi/app/schemas/user.py.ejs',
+        'python-fastapi/app/routers/auth.py.ejs',
+        'python-fastapi/app/routers/model_routes.py.ejs',
+        'python-fastapi/Dockerfile.ejs',
+        'python-fastapi/docker-compose.yml.ejs',
+      ]).catch(() => {}),
+    ]);
+
     const modelsToGenerate = new Map();
     endpoints.forEach(ep => {
       if (ep.schemaFields && ep.controllerName !== 'Default' && !modelsToGenerate.has(ep.controllerName)) {
-        modelsToGenerate.set(ep.controllerName, { name: ep.controllerName, fields: Object.entries(ep.schemaFields).map(([key, type]) => ({ name: key, type })) });
+        modelsToGenerate.set(ep.controllerName, {
+          name: ep.controllerName,
+          fields: Object.entries(ep.schemaFields).map(([key, type]) => ({ name: key, type })),
+        });
       }
     });
 
@@ -22,65 +69,103 @@ export async function generatePythonProject(options) {
       modelsToGenerate.set('User', { name: 'User', fields: [{ name: 'name', type: 'String' }, { name: 'email', type: 'String' }] });
     }
 
-    console.log(chalk.blue('  -> Scaffolding Python (FastAPI) project structure...'));
-    const appDir = path.join(projectDir, 'app');
-    const coreDir = path.join(appDir, 'core');
-    const dbDir = path.join(appDir, 'db');
-    const modelsDir = path.join(appDir, 'models');
-    const schemasDir = path.join(appDir, 'schemas');
-    const routesDir = path.join(appDir, 'routers');
+    console.log(chalk.green(`  -> Found ${endpoints.length} endpoints, ${modelsToGenerate.size} model(s). ${chalk.gray(step1())}`));
 
-    await fs.ensureDir(appDir);
-    await fs.ensureDir(coreDir);
-    await fs.ensureDir(dbDir);
-    await fs.ensureDir(modelsDir);
-    await fs.ensureDir(schemasDir);
-    await fs.ensureDir(routesDir);
+    // ── Step 2: Create all directories in parallel ─────────────────────────────
+    const step2 = timer();
+    console.log(chalk.blue('  -> [2] Creating project directories in parallel...'));
 
-    const controllers = Array.from(modelsToGenerate.keys());
+    const appDir     = path.join(projectDir, 'app');
+    const coreDir    = path.join(appDir, 'core');
+    const modelsDir  = path.join(appDir, 'models');
+    const schemasDir = path.join(appDir, 'schemas');
+    const routesDir  = path.join(appDir, 'routers');
 
-    await renderAndWrite(getTemplatePath('python-fastapi/main.py.ejs'), path.join(projectDir, 'app', 'main.py'), { projectName, controllers });
-    await renderAndWrite(getTemplatePath('python-fastapi/requirements.txt.ejs'), path.join(projectDir, 'requirements.txt'), {});
+    await Promise.all([
+      fs.ensureDir(appDir),
+      fs.ensureDir(coreDir),
+      fs.ensureDir(path.join(appDir, 'db')),
+      fs.ensureDir(modelsDir),
+      fs.ensureDir(schemasDir),
+      fs.ensureDir(routesDir),
+    ]);
 
-    await renderAndWrite(getTemplatePath('python-fastapi/app/core/config.py.ejs'), path.join(coreDir, 'config.py'), { projectName });
-    await renderAndWrite(getTemplatePath('python-fastapi/app/core/security.py.ejs'), path.join(coreDir, 'security.py'), {});
+    console.log(chalk.gray(`     Dirs created. ${step2()}`));
 
-    await renderAndWrite(getTemplatePath('python-fastapi/app/db.py.ejs'), path.join(appDir, 'db.py'), {});
+    // ── Step 3: Generate ALL Python files in parallel ─────────────────────────
+    const step3 = timer();
+    console.log(chalk.blue('  -> [3] Generating all Python source files in parallel...'));
+
+    const controllers = Array.from(modelsToGenerate.keys());
 
-    await renderAndWrite(getTemplatePath('python-fastapi/app/models/user.py.ejs'), path.join(modelsDir, 'user.py'), {});
-    await renderAndWrite(getTemplatePath('python-fastapi/app/schemas/user.py.ejs'), path.join(schemasDir, 'user.py'), {});
+    const renderTasks = [
+      // Top-level files
+      { templatePath: getTemplatePath('python-fastapi/main.py.ejs'),                   outPath: path.join(appDir, 'main.py'),           data: { projectName, controllers } },
+      { templatePath: getTemplatePath('python-fastapi/requirements.txt.ejs'),           outPath: path.join(projectDir, 'requirements.txt'), data: {} },
+      // Core
+      { templatePath: getTemplatePath('python-fastapi/app/core/config.py.ejs'),         outPath: path.join(coreDir, 'config.py'),         data: { projectName } },
+      { templatePath: getTemplatePath('python-fastapi/app/core/security.py.ejs'),       outPath: path.join(coreDir, 'security.py'),       data: {} },
+      // DB
+      { templatePath: getTemplatePath('python-fastapi/app/db.py.ejs'),                  outPath: path.join(appDir, 'db.py'),              data: {} },
+      // User model + schema + auth router (always present)
+      { templatePath: getTemplatePath('python-fastapi/app/models/user.py.ejs'),         outPath: path.join(modelsDir, 'user.py'),         data: {} },
+      { templatePath: getTemplatePath('python-fastapi/app/schemas/user.py.ejs'),        outPath: path.join(schemasDir, 'user.py'),        data: {} },
+      { templatePath: getTemplatePath('python-fastapi/app/routers/auth.py.ejs'),        outPath: path.join(routesDir, 'auth.py'),         data: {} },
+      // Docker
+      { templatePath: getTemplatePath('python-fastapi/Dockerfile.ejs'),                  outPath: path.join(projectDir, 'Dockerfile'),     data: {} },
+      { templatePath: getTemplatePath('python-fastapi/docker-compose.yml.ejs'),          outPath: path.join(projectDir, 'docker-compose.yml'), data: { projectName } },
+      // Non-user model routes
+      ...Array.from(modelsToGenerate.entries())
+        .filter(([modelName]) => modelName.toLowerCase() !== 'user')
+        .map(([modelName, modelData]) => ({
+          templatePath: getTemplatePath('python-fastapi/app/routers/model_routes.py.ejs'),
+          outPath: path.join(routesDir, `${modelName.toLowerCase()}_routes.py`),
+          data: { modelName, schema: modelData },
+        })),
+    ];
+
+    await renderAndWriteAll(renderTasks, 12);
+
+    // .env files (no template needed, write directly)
+    const envContent = `DATABASE_URL="postgresql://postgres:password@db:5432/${projectName}"\nJWT_SECRET="a_very_secret_key_change_this"`;
+    await Promise.all([
+      fs.writeFile(path.join(projectDir, '.env'), envContent),
+      fs.writeFile(path.join(projectDir, '.env.example'), envContent),
+    ]);
 
-    await renderAndWrite(getTemplatePath('python-fastapi/app/routers/auth.py.ejs'), path.join(routesDir, 'auth.py'), {});
+    console.log(chalk.gray(`     All Python files generated. ${step3()}`));
 
-    for (const [modelName, modelData] of modelsToGenerate.entries()) {
-      if (modelName.toLowerCase() !== 'user') {
-        await renderAndWrite(getTemplatePath('python-fastapi/app/routers/model_routes.py.ejs'), path.join(routesDir, `${modelName.toLowerCase()}_routes.py`), { modelName, schema: modelData });
-      }
-    }
+    // ── Step 4: Create venv + install deps ────────────────────────────────────
+    const step4 = timer();
+    console.log(chalk.magenta('  -> [4] Setting up virtual environment...'));
 
-    console.log(chalk.magenta('  -> Setting up virtual environment and installing dependencies...'));
-    await execa('python', ['-m', 'venv', 'venv'], { cwd: projectDir });
+    await withRetry(
+      () => execa('python', ['-m', 'venv', 'venv'], { cwd: projectDir }),
+      { attempts: 2, baseDelay: 500, label: 'python -m venv' }
+    );
 
-    const pipPath = process.platform === 'win32' ? path.join('venv', 'Scripts', 'pip') : path.join('venv', 'bin', 'pip');
-    await execa(path.join(projectDir, pipPath), ['install', '-r', 'requirements.txt'], { cwd: projectDir });
+    const pipPath = process.platform === 'win32'
+      ? path.join('venv', 'Scripts', 'pip')
+      : path.join('venv', 'bin', 'pip');
 
-    await renderAndWrite(getTemplatePath('python-fastapi/Dockerfile.ejs'), path.join(projectDir, 'Dockerfile'), {});
-    await renderAndWrite(getTemplatePath('python-fastapi/docker-compose.yml.ejs'), path.join(projectDir, 'docker-compose.yml'), { projectName });
+    console.log(chalk.magenta('  -> [4] Installing Python dependencies...'));
+    await withRetry(
+      () => execa(path.join(projectDir, pipPath), ['install', '-r', 'requirements.txt'], { cwd: projectDir }),
+      { attempts: 2, baseDelay: 1000, label: 'pip install' }
+    );
 
-    const envContent = `DATABASE_URL="postgresql://postgres:password@db:5432/${projectName}"\nJWT_SECRET="a_very_secret_key_change_this"`;
-    await fs.writeFile(path.join(projectDir, '.env'), envContent);
-    await fs.writeFile(path.join(projectDir, '.env.example'), envContent);
+    console.log(chalk.gray(`     venv + pip install done. ${step4()}`));
+    console.log(chalk.green(`  -> ✓ Python (FastAPI) backend generation complete. Total: ${chalk.bold(totalTimer())}`));
 
-    console.log(chalk.green('  -> Python (FastAPI) backend generation is complete!'));
-    console.log(chalk.yellow('\nTo run your new Python backend with Docker:'));
+    console.log(chalk.yellow('\nTo run your Python backend with Docker:'));
     console.log(chalk.cyan('  1. Make sure Docker Desktop is running.'));
     console.log(chalk.cyan('  2. Run: `docker-compose up --build`'));
-    console.log(chalk.cyan('  3. API will be available at http://localhost:8000 and docs at http://localhost:8000/docs'));
+    console.log(chalk.cyan('  3. API: http://localhost:8000  |  Docs: http://localhost:8000/docs'));
 
   } catch (error) {
     if (error.code === 'ENOENT') {
-      throw new Error(`'${error.command}' command not found. Please ensure Python and venv are installed and in your system's PATH.`);
+      throw new Error(`'${error.command}' not found. Ensure Python and venv are installed and in your PATH.`);
     }
     throw error;
   }
-}
+}

package/src/generators/template.js

@@ -6,10 +6,25 @@ import { fileURLToPath } from 'node:url';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
+// ─── Template Cache (avoids re-reading same file from disk) ───────────────────
+const _templateCache = new Map();
+
+async function readTemplateCached(templatePath) {
+  if (_templateCache.has(templatePath)) return _templateCache.get(templatePath);
+  const tpl = await fs.readFile(templatePath, 'utf-8');
+  _templateCache.set(templatePath, tpl);
+  return tpl;
+}
+
+export function clearTemplateCache() {
+  _templateCache.clear();
+}
+
+// ─── Core render + write (now cached) ─────────────────────────────────────────
 export async function renderAndWrite(templatePath, outPath, data) {
   try {
-    const tpl = await fs.readFile(templatePath, 'utf-8');
-    const code = ejs.render(tpl, data || {}, { filename: templatePath }); // filename helps with EJS errors
+    const tpl = await readTemplateCached(templatePath);
+    const code = ejs.render(tpl, data || {}, { filename: templatePath });
     await fs.outputFile(outPath, code);
   } catch (err) {
     console.error('EJS render failed for:', templatePath);
@@ -18,6 +33,36 @@ export async function renderAndWrite(templatePath, outPath, data) {
   }
 }
 
+// ─── Parallel batch render: fire all templates simultaneously ─────────────────
+/**
+ * @param {Array<{templatePath: string, outPath: string, data: object}>} tasks
+ * @param {number} concurrency  max simultaneous writes (default 8)
+ */
+export async function renderAndWriteAll(tasks, concurrency = 8) {
+  const results = [];
+  for (let i = 0; i < tasks.length; i += concurrency) {
+    const batch = tasks.slice(i, i + concurrency);
+    const batchResults = await Promise.allSettled(
+      batch.map(({ templatePath, outPath, data }) =>
+        renderAndWrite(templatePath, outPath, data)
+      )
+    );
+    results.push(...batchResults);
+  }
+
+  const failed = results.filter(r => r.status === 'rejected');
+  if (failed.length > 0) {
+    failed.forEach(f => console.error('  [WARN] Render failed:', f.reason?.message));
+  }
+  return results;
+}
+
+// ─── Template path helper ──────────────────────────────────────────────────────
 export function getTemplatePath(subpath) {
   return path.join(__dirname, '..', 'templates', subpath);
+}
+
+// ─── Preload a set of templates into cache (call early in generation) ──────────
+export async function preloadTemplates(subpaths) {
+  await Promise.all(subpaths.map(sp => readTemplateCached(getTemplatePath(sp))));
 }