create-backlist 10.0.9 → 10.1.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-backlist",
-  "version": "10.0.9",
+  "version": "10.1.1",
   "description": "An advanced, multi-language backend generator based on frontend analysis. Smart Freemium SaaS CLI with Live QA.",
   "type": "module",
   "bin": {

package/src/generators/dotnet.js

@@ -3,132 +3,188 @@ 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';
+
+// ─── 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} (${i + 1}/${attempts}), retrying in ${delay}ms...`));
+        await new Promise(r => setTimeout(r, delay));
+      }
+    }
+  }
+  throw lastErr;
+}
+
+function timer() {
+  const s = Date.now();
+  return () => `${((Date.now() - s) / 1000).toFixed(2)}s`;
+}
 
 export async function generateDotnetProject(options) {
   const { projectDir, projectName, frontendSrcDir } = options;
+  const totalTimer = timer();
 
   try {
-    console.log(chalk.blue('  -> Analyzing frontend for C# 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([
+        'dotnet/partials/Model.cs.ejs',
+        'dotnet/partials/DbContext.cs.ejs',
+        'dotnet/partials/Controller.cs.ejs',
+        'dotnet/partials/Dockerfile.ejs',
+        'dotnet/partials/docker-compose.yml.ejs',
+        'dotnet/partials/README.md.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 }))
+          fields: Object.entries(ep.schemaFields).map(([key, type]) => ({ name: key, type })),
         });
       }
     });
 
     if (modelsToGenerate.size > 0) {
-      console.log(chalk.green(`  -> Identified ${modelsToGenerate.size} models/controllers to generate.`));
+      console.log(chalk.green(`  -> Identified ${modelsToGenerate.size} models. ${chalk.gray(step1())}`));
     } else {
-      console.log(chalk.yellow('  -> No API calls with body data found. A basic API project will be created without models.'));
+      console.log(chalk.yellow(`  -> No models found. Basic API project will be created. ${chalk.gray(step1())}`));
     }
 
-    console.log(chalk.blue('  -> Scaffolding .NET Core Web API project...'));
-    await execa('dotnet', ['new', 'webapi', '-n', projectName, '-o', projectDir, '--no-https']);
+    // ── Step 2: Scaffold .NET project ─────────────────────────────────────────
+    console.log(chalk.blue('  -> [2] Scaffolding .NET Core Web API project...'));
+    const step2 = timer();
+    await withRetry(
+      () => execa('dotnet', ['new', 'webapi', '-n', projectName, '-o', projectDir, '--no-https']),
+      { attempts: 2, baseDelay: 500, label: 'dotnet new' }
+    );
+    console.log(chalk.gray(`     Scaffold done. ${step2()}`));
 
+    // ── Step 3: Add NuGet packages + ensure dirs in parallel ──────────────────
     if (modelsToGenerate.size > 0) {
-      console.log(chalk.blue('  -> Adding NuGet packages (Entity Framework Core)...'));
-      const packages = [
-        'Microsoft.EntityFrameworkCore.Design',
-        'Microsoft.EntityFrameworkCore.InMemory'
-      ];
-      for (const pkg of packages) {
-        await execa('dotnet', ['add', 'package', pkg], { cwd: projectDir });
-      }
-    }
+      const step3 = timer();
+      console.log(chalk.blue('  -> [3] Adding NuGet packages & preparing dirs in parallel...'));
 
-    if (modelsToGenerate.size > 0) {
-      console.log(chalk.blue('  -> Generating EF Core models and DbContext...'));
       const modelsDir = path.join(projectDir, 'Models');
       const dataDir = path.join(projectDir, 'Data');
-      await fs.ensureDir(modelsDir);
-      await fs.ensureDir(dataDir);
-
-      for (const [modelName, modelData] of modelsToGenerate.entries()) {
-        await renderAndWrite(
-          getTemplatePath('dotnet/partials/Model.cs.ejs'),
-          path.join(modelsDir, `${modelName}.cs`),
-          { projectName, modelName, model: modelData }
-        );
-      }
+      const packages = [
+        'Microsoft.EntityFrameworkCore.Design',
+        'Microsoft.EntityFrameworkCore.InMemory',
+      ];
 
-      await renderAndWrite(
-        getTemplatePath('dotnet/partials/DbContext.cs.ejs'),
-        path.join(dataDir, 'ApplicationDbContext.cs'),
-        { projectName, modelsToGenerate: Array.from(modelsToGenerate.values()) }
-      );
+      // Add packages in parallel + ensure dirs simultaneously
+      await Promise.all([
+        ...packages.map(pkg =>
+          withRetry(
+            () => execa('dotnet', ['add', 'package', pkg], { cwd: projectDir }),
+            { attempts: 3, baseDelay: 400, label: `add ${pkg}` }
+          )
+        ),
+        fs.ensureDir(modelsDir),
+        fs.ensureDir(dataDir),
+      ]);
+      console.log(chalk.gray(`     NuGet + dirs done. ${step3()}`));
+
+      // ── Step 4: Generate models + DbContext in parallel ──────────────────────
+      const step4 = timer();
+      console.log(chalk.blue(`  -> [4] Generating ${modelsToGenerate.size} EF Core model(s) + DbContext in parallel...`));
+
+      const modelTasks = Array.from(modelsToGenerate.entries()).map(([modelName, modelData]) => ({
+        templatePath: getTemplatePath('dotnet/partials/Model.cs.ejs'),
+        outPath: path.join(modelsDir, `${modelName}.cs`),
+        data: { projectName, modelName, model: modelData },
+      }));
+
+      await Promise.all([
+        renderAndWriteAll(modelTasks),
+        renderAndWrite(
+          getTemplatePath('dotnet/partials/DbContext.cs.ejs'),
+          path.join(dataDir, 'ApplicationDbContext.cs'),
+          { projectName, modelsToGenerate: Array.from(modelsToGenerate.values()) }
+        ),
+      ]);
+      console.log(chalk.gray(`     Models + DbContext done. ${step4()}`));
     }
 
-    console.log(chalk.blue('  -> Configuring services in Program.cs...'));
+    // ── Step 5: Patch Program.cs ───────────────────────────────────────────────
+    console.log(chalk.blue('  -> [5] Configuring Program.cs...'));
     const programCsPath = path.join(projectDir, 'Program.cs');
     let programCsContent = await fs.readFile(programCsPath, 'utf-8');
 
-    let usingStatements = 'using Microsoft.EntityFrameworkCore;\nusing ' + projectName + '.Data;\n';
-    programCsContent = usingStatements + programCsContent;
+    programCsContent =
+      `using Microsoft.EntityFrameworkCore;\nusing ${projectName}.Data;\n` + programCsContent;
 
-    let dbContextService = '// Configure the database context\nbuilder.Services.AddDbContext<ApplicationDbContext>(opt => opt.UseInMemoryDatabase("MyDb"));';
-    programCsContent = programCsContent.replace('builder.Services.AddControllers();', `builder.Services.AddControllers();\n\n${dbContextService}`);
+    if (modelsToGenerate.size > 0) {
+      programCsContent = programCsContent.replace(
+        'builder.Services.AddControllers();',
+        `builder.Services.AddControllers();\n\n// Configure the database context\nbuilder.Services.AddDbContext<ApplicationDbContext>(opt => opt.UseInMemoryDatabase("MyDb"));`
+      );
+    }
 
     const corsPolicy = `
 builder.Services.AddCors(options =>
 {
-    options.AddDefaultPolicy(
-        policy =>
-        {
-            policy.WithOrigins("http://localhost:3000", "http://localhost:5173")
-                   .AllowAnyHeader()
-                   .AllowAnyMethod();
-        });
+    options.AddDefaultPolicy(policy =>
+    {
+        policy.WithOrigins("http://localhost:3000", "http://localhost:5173")
+               .AllowAnyHeader()
+               .AllowAnyMethod();
+    });
 });`;
-    programCsContent = programCsContent.replace('var app = builder.Build();', `${corsPolicy}\n\nvar app = builder.Build();\n\napp.UseCors();`);
+    programCsContent = programCsContent.replace(
+      'var app = builder.Build();',
+      `${corsPolicy}\n\nvar app = builder.Build();\n\napp.UseCors();`
+    );
 
     await fs.writeFile(programCsPath, programCsContent);
 
-    console.log(chalk.blue('  -> Generating controllers with CRUD logic...'));
-    await fs.remove(path.join(projectDir, 'Controllers', 'WeatherForecastController.cs'));
-    await fs.remove(path.join(projectDir, 'WeatherForecast.cs'));
+    // ── Step 6: Generate controllers + remove boilerplate + Docker + README in parallel ──
+    const step6 = timer();
+    console.log(chalk.blue('  -> [6] Generating controllers, Docker files & README in parallel...'));
 
     const controllersToGenerate = new Set(Array.from(modelsToGenerate.keys()));
     endpoints.forEach(ep => {
       if (ep.controllerName !== 'Default') controllersToGenerate.add(ep.controllerName);
     });
 
-    for (const controllerName of controllersToGenerate) {
-      const controllerEndpoints = endpoints.filter(
-        ep => ep.controllerName === controllerName
-      );
-      await renderAndWrite(
-        getTemplatePath('dotnet/partials/Controller.cs.ejs'),
-        path.join(projectDir, 'Controllers', `${controllerName}Controller.cs`),
-        { projectName, controllerName, endpoints: controllerEndpoints }
-      );
-    }
-
-    console.log(chalk.blue('  -> Generating Docker files...'));
-    await renderAndWrite(
-      getTemplatePath('dotnet/partials/Dockerfile.ejs'),
-      path.join(projectDir, 'Dockerfile'),
-      { projectName }
-    );
-    await renderAndWrite(
-      getTemplatePath('dotnet/partials/docker-compose.yml.ejs'),
-      path.join(projectDir, 'docker-compose.yml'),
-      { projectName }
-    );
-
-    await renderAndWrite(
-      getTemplatePath('dotnet/partials/README.md.ejs'),
-      path.join(projectDir, 'README.md'),
-      { projectName }
-    );
-
-    console.log(chalk.green('  -> C# backend generation is complete!'));
+    const controllerTasks = Array.from(controllersToGenerate).map(controllerName => ({
+      templatePath: getTemplatePath('dotnet/partials/Controller.cs.ejs'),
+      outPath: path.join(projectDir, 'Controllers', `${controllerName}Controller.cs`),
+      data: {
+        projectName,
+        controllerName,
+        endpoints: endpoints.filter(ep => ep.controllerName === controllerName),
+      },
+    }));
+
+    await Promise.all([
+      // Remove default boilerplate files
+      fs.remove(path.join(projectDir, 'Controllers', 'WeatherForecastController.cs')),
+      fs.remove(path.join(projectDir, 'WeatherForecast.cs')),
+      // Generate all controllers in parallel
+      renderAndWriteAll(controllerTasks),
+      // Docker + README in parallel
+      renderAndWrite(getTemplatePath('dotnet/partials/Dockerfile.ejs'), path.join(projectDir, 'Dockerfile'), { projectName }),
+      renderAndWrite(getTemplatePath('dotnet/partials/docker-compose.yml.ejs'), path.join(projectDir, 'docker-compose.yml'), { projectName }),
+      renderAndWrite(getTemplatePath('dotnet/partials/README.md.ejs'), path.join(projectDir, 'README.md'), { projectName }),
+    ]);
+
+    console.log(chalk.gray(`     Controllers + Docker + README done. ${step6()}`));
+    console.log(chalk.green(`  -> ✓ C# backend generation complete. Total: ${chalk.bold(totalTimer())}`));
 
   } catch (error) {
     throw error;
   }
-}
+}

package/src/generators/java.js

@@ -5,7 +5,29 @@ import axios from "axios";
 import unzipper from "unzipper";
 
 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 sanitizeArtifactId(name) {
   return String(name || "backend")
@@ -17,24 +39,18 @@ function sanitizeArtifactId(name) {
 
 async function downloadInitializrZip({ groupId, artifactId, name, bootVersion, dependencies }) {
   const params = new URLSearchParams({
-    type: "maven-project",
-    language: "java",
-    groupId,
-    artifactId,
-    name,
+    type: "maven-project", language: "java",
+    groupId, artifactId, name,
     packageName: `${groupId}.${artifactId.replace(/-/g, "")}`,
     dependencies: dependencies.join(","),
   });
-
   if (bootVersion) params.set("bootVersion", bootVersion);
 
-  const url = `https://start.spring.io/starter.zip?${params.toString()}`;
-
-  const res = await axios.get(url, {
+  const res = await axios.get(`https://start.spring.io/starter.zip?${params.toString()}`, {
     responseType: "stream",
     headers: { Accept: "application/zip" },
+    timeout: 30_000,
   });
-
   return res;
 }
 
@@ -51,8 +67,7 @@ async function appendApplicationProperties(projectDir, artifactId) {
   try {
     const propsPath = path.join(projectDir, "src", "main", "resources", "application.properties");
     const dbProps = [
-      "",
-      "",
+      "", "",
       "# --- Auto-generated by create-backlist ---",
       `spring.datasource.url=jdbc:postgresql://localhost:5432/${artifactId}`,
       "spring.datasource.username=postgres",
@@ -60,7 +75,6 @@ async function appendApplicationProperties(projectDir, artifactId) {
       "spring.jpa.hibernate.ddl-auto=update",
       "spring.jpa.show-sql=true",
     ].join("\n");
-
     await fs.appendFile(propsPath, dbProps);
   } catch {
     console.log(chalk.yellow("  -> Could not update application.properties (continuing)."));
@@ -69,88 +83,79 @@ async function appendApplicationProperties(projectDir, artifactId) {
 
 function buildModelsFromEndpoints(endpoints) {
   const modelsToGenerate = new Map();
-
   (Array.isArray(endpoints) ? endpoints : []).forEach((ep) => {
-    if (!ep || !ep.controllerName || ep.controllerName === "Default") return;
-
+    if (!ep?.controllerName || ep.controllerName === "Default") return;
     if (!modelsToGenerate.has(ep.controllerName)) {
-      modelsToGenerate.set(ep.controllerName, {
-        name: ep.controllerName,
-        fields: [],
-        endpoints: [],
-      });
+      modelsToGenerate.set(ep.controllerName, { name: ep.controllerName, fields: [], endpoints: [] });
     }
-
     const m = modelsToGenerate.get(ep.controllerName);
-
-    m.endpoints.push({
-      method: ep.method,
-      route: ep.route || ep.path,
-      actionName: ep.actionName,
-    });
-
+    m.endpoints.push({ method: ep.method, route: ep.route || ep.path, actionName: ep.actionName });
     if (ep.schemaFields) {
       for (const [key, type] of Object.entries(ep.schemaFields)) {
-        if (!m.fields.find((f) => f.name === key)) {
-          m.fields.push({ name: key, type });
-        }
+        if (!m.fields.find((f) => f.name === key)) m.fields.push({ name: key, type });
       }
     }
   });
-
   return modelsToGenerate;
 }
 
+// ─── Main Generator ───────────────────────────────────────────────────────────
+
 export async function generateJavaProject(options) {
   const { projectDir, projectName, frontendSrcDir } = options;
 
   const groupId = "com.backlist.generated";
   const artifactId = sanitizeArtifactId(projectName || "backend");
   const name = projectName || "backend";
+  const totalTimer = timer();
 
   try {
-    console.log(chalk.blue("  -> Contacting Spring Initializr to download a base Spring Boot project..."));
+    // ── Step 1: Download Initializr zip + analyze frontend + preload templates in parallel ──
+    const step1 = timer();
+    console.log(chalk.blue("  -> [1] Downloading Spring Initializr zip & analyzing frontend in parallel..."));
 
     const deps = ["web", "data-jpa", "lombok", "postgresql"];
-    let response;
-
-    try {
-      response = await downloadInitializrZip({
-        groupId,
-        artifactId,
-        name,
-        bootVersion: "3.3.4",
-        dependencies: deps,
-      });
-    } catch {
-      console.log(chalk.yellow("    -> Initial attempt failed. Retrying with default Boot version..."));
-      try {
-        response = await downloadInitializrZip({
-          groupId,
-          artifactId,
-          name,
-          bootVersion: "",
-          dependencies: deps,
-        });
-      } catch {
-        console.log(chalk.yellow("    -> Second attempt failed. Retrying with minimal dependencies..."));
-        const fallbackDeps = ["web", "data-jpa", "lombok"];
-        response = await downloadInitializrZip({
-          groupId,
-          artifactId,
-          name,
-          bootVersion: "",
-          dependencies: fallbackDeps,
-        });
-      }
-    }
 
-    console.log(chalk.blue("  -> Unzipping the Spring Boot project..."));
+    const downloadWithFallback = () =>
+      withRetry(
+        async () => {
+          // Try with specific boot version first, fall back gracefully
+          const attempts = [
+            { bootVersion: "3.3.4", dependencies: deps },
+            { bootVersion: "", dependencies: deps },
+            { bootVersion: "", dependencies: ["web", "data-jpa", "lombok"] },
+          ];
+          for (const params of attempts) {
+            try {
+              return await downloadInitializrZip({ groupId, artifactId, name, ...params });
+            } catch { /* try next */ }
+          }
+          throw new Error("All Spring Initializr attempts failed.");
+        },
+        { attempts: 2, baseDelay: 1000, label: "Spring Initializr download" }
+      );
+
+    const [response, endpoints] = await Promise.all([
+      downloadWithFallback(),
+      analyzeFrontend(frontendSrcDir),
+      preloadTemplates([
+        "java-spring/partials/Entity.java.ejs",
+        "java-spring/partials/Repository.java.ejs",
+        "java-spring/partials/Service.java.ejs",
+        "java-spring/partials/Controller.java.ejs",
+        "java-spring/partials/Dockerfile.ejs",
+        "java-spring/partials/docker-compose.yml.ejs",
+      ]).catch(() => {}),
+    ]);
+
+    console.log(chalk.gray(`     Download + analysis done. ${step1()}`));
+
+    // ── Step 2: Extract zip + ensure project dir ───────────────────────────────
+    const step2 = timer();
+    console.log(chalk.blue("  -> [2] Unzipping Spring Boot project..."));
     await fs.ensureDir(projectDir);
     await extractZipStream(response.data, projectDir);
-
-    console.log(chalk.blue("  -> Analyzing frontend for API endpoints..."));
-    const endpoints = await analyzeFrontend(frontendSrcDir);
+    console.log(chalk.gray(`     Unzip done. ${step2()}`));
 
     if (!Array.isArray(endpoints) || endpoints.length === 0) {
       console.log(chalk.yellow("  -> No endpoints found. Only base Spring project created."));
@@ -160,89 +165,72 @@ export async function generateJavaProject(options) {
 
     const modelsToGenerate = buildModelsFromEndpoints(endpoints);
 
+    // ── Step 3: Prepare Java source directories in parallel ────────────────────
     const javaSrcRoot = path.join(
-      projectDir,
-      "src",
-      "main",
-      "java",
+      projectDir, "src", "main", "java",
       ...groupId.split("."),
       artifactId.replace(/-/g, "")
     );
 
-    await fs.ensureDir(javaSrcRoot);
+    const entityDir = path.join(javaSrcRoot, "model");
+    const repoDir = path.join(javaSrcRoot, "repository");
+    const serviceDir = path.join(javaSrcRoot, "service");
+    const controllerDir = path.join(javaSrcRoot, "controller");
 
-    if (modelsToGenerate.size > 0) {
-      console.log(chalk.blue("  -> Generating Java entities, repositories, services, and controllers..."));
+    await Promise.all([
+      fs.ensureDir(javaSrcRoot),
+      fs.ensureDir(entityDir),
+      fs.ensureDir(repoDir),
+      fs.ensureDir(serviceDir),
+      fs.ensureDir(controllerDir),
+    ]);
 
-      const entityDir = path.join(javaSrcRoot, "model");
-      const repoDir = path.join(javaSrcRoot, "repository");
-      const serviceDir = path.join(javaSrcRoot, "service");
-      const controllerDir = path.join(javaSrcRoot, "controller");
+    // ── Step 4: Generate all Java layers in parallel ───────────────────────────
+    if (modelsToGenerate.size > 0) {
+      const step4 = timer();
+      console.log(chalk.blue(`  -> [4] Generating ${modelsToGenerate.size} Java entity/repo/service/controller sets in parallel...`));
 
-      await fs.ensureDir(entityDir);
-      await fs.ensureDir(repoDir);
-      await fs.ensureDir(serviceDir);
-      await fs.ensureDir(controllerDir);
+      const allTasks = [];
 
       for (const model of modelsToGenerate.values()) {
         const commonData = {
-          projectName,
-          groupId,
-          artifactId,
-          group: groupId,
-          model,
+          projectName, groupId, artifactId,
+          group: groupId, model,
           modelName: model.name,
-          controllerName: model.name
+          controllerName: model.name,
         };
-
-        await renderAndWrite(
-          getTemplatePath("java-spring/partials/Entity.java.ejs"),
-          path.join(entityDir, `${model.name}.java`),
-          commonData
-        );
-
-        await renderAndWrite(
-          getTemplatePath("java-spring/partials/Repository.java.ejs"),
-          path.join(repoDir, `${model.name}Repository.java`),
-          commonData
-        );
-
-        await renderAndWrite(
-          getTemplatePath("java-spring/partials/Service.java.ejs"),
-          path.join(serviceDir, `${model.name}Service.java`),
-          commonData
-        );
-
-        await renderAndWrite(
-          getTemplatePath("java-spring/partials/Controller.java.ejs"),
-          path.join(controllerDir, `${model.name}Controller.java`),
-          commonData
+        allTasks.push(
+          { templatePath: getTemplatePath("java-spring/partials/Entity.java.ejs"),     outPath: path.join(entityDir,     `${model.name}.java`),           data: commonData },
+          { templatePath: getTemplatePath("java-spring/partials/Repository.java.ejs"), outPath: path.join(repoDir,       `${model.name}Repository.java`),  data: commonData },
+          { templatePath: getTemplatePath("java-spring/partials/Service.java.ejs"),    outPath: path.join(serviceDir,    `${model.name}Service.java`),     data: commonData },
+          { templatePath: getTemplatePath("java-spring/partials/Controller.java.ejs"), outPath: path.join(controllerDir, `${model.name}Controller.java`),  data: commonData }
         );
       }
+
+      await renderAndWriteAll(allTasks, 12); // high concurrency — mostly CPU-bound EJS
+      console.log(chalk.gray(`     Java layers done. ${step4()}`));
     } else {
       console.log(chalk.yellow("  -> No models inferred. Skipping entity/controller generation."));
     }
 
-    await appendApplicationProperties(projectDir, artifactId);
+    // ── Step 5: application.properties + Docker files in parallel ─────────────
+    const step5 = timer();
+    console.log(chalk.blue("  -> [5] Writing application.properties & Docker files in parallel..."));
 
-    console.log(chalk.blue("  -> Generating Docker files..."));
-    await renderAndWrite(
-      getTemplatePath("java-spring/partials/Dockerfile.ejs"),
-      path.join(projectDir, "Dockerfile"),
-      { projectName, artifactId }
-    );
-    await renderAndWrite(
-      getTemplatePath("java-spring/partials/docker-compose.yml.ejs"),
-      path.join(projectDir, "docker-compose.yml"),
-      { projectName, artifactId }
-    );
+    await Promise.all([
+      appendApplicationProperties(projectDir, artifactId),
+      renderAndWrite(getTemplatePath("java-spring/partials/Dockerfile.ejs"),          path.join(projectDir, "Dockerfile"),         { projectName, artifactId }),
+      renderAndWrite(getTemplatePath("java-spring/partials/docker-compose.yml.ejs"),  path.join(projectDir, "docker-compose.yml"), { projectName, artifactId }),
+    ]);
+
+    console.log(chalk.gray(`     Configs done. ${step5()}`));
+    console.log(chalk.green(`  -> ✓ Java (Spring Boot) backend generation complete. Total: ${chalk.bold(totalTimer())}`));
 
-    console.log(chalk.green("  -> Java (Spring Boot) backend generation is complete!"));
   } catch (error) {
-    if (error && error.response && error.response.status) {
+    if (error?.response?.status) {
       console.error(chalk.red(`  -> Initializr error status: ${error.response.status}`));
       throw new Error(`Failed to download from Spring Initializr. Status: ${error.response.status}`);
     }
     throw error;
   }
-}
+}