create-backlist 6.0.0 → 6.0.2

package/src/generators/dotnet.js

@@ -5,127 +5,153 @@ const path = require('path');
 const { analyzeFrontend } = require('../analyzer');
 const { renderAndWrite, getTemplatePath } = require('./template');
 
+function groupByController(endpoints) {
+  const map = new Map();
+  for (const ep of endpoints) {
+    const c = ep.controllerName || 'Default';
+    if (!map.has(c)) map.set(c, []);
+    map.get(c).push(ep);
+  }
+  return map;
+}
+
+function collectDtoModels(endpoints) {
+  const models = new Map();
+
+  for (const ep of endpoints) {
+    if (ep.requestBody?.fields && ep.requestBody.modelName) {
+      models.set(ep.requestBody.modelName, { name: ep.requestBody.modelName, fields: ep.requestBody.fields });
+    }
+    if (ep.responseBody?.fields && ep.responseBody.modelName) {
+      models.set(ep.responseBody.modelName, { name: ep.responseBody.modelName, fields: ep.responseBody.fields });
+    }
+  }
+
+  return models;
+}
+
+async function ensureProgramMarkers(programCsPath) {
+  let content = await fs.readFile(programCsPath, 'utf-8');
+
+  if (!content.includes('<backlist:usings>')) {
+    // add marker near top
+    content = content.replace(
+      /^/m,
+      `// <backlist:usings>\n// </backlist:usings>\n\n`
+    );
+  }
+  if (!content.includes('<backlist:services>')) {
+    content = content.replace(
+      'builder.Services.AddControllers();',
+      `builder.Services.AddControllers();\n\n// <backlist:services>\n// </backlist:services>`
+    );
+  }
+  if (!content.includes('<backlist:middleware>')) {
+    content = content.replace(
+      'var app = builder.Build();',
+      `var app = builder.Build();\n\n// <backlist:middleware>\n// </backlist:middleware>\n`
+    );
+  }
+
+  await fs.writeFile(programCsPath, content);
+}
+
+function insertBetweenMarkers(content, markerName, insertText) {
+  const start = `// <backlist:${markerName}>`;
+  const end = `// </backlist:${markerName}>`;
+
+  const s = content.indexOf(start);
+  const e = content.indexOf(end);
+  if (s === -1 || e === -1 || e < s) return content;
+
+  const before = content.slice(0, s + start.length);
+  const after = content.slice(e);
+
+  return `${before}\n${insertText}\n${after}`;
+}
+
 async function generateDotnetProject(options) {
   const { projectDir, projectName, frontendSrcDir } = options;
 
   try {
-    // --- Step 1: Analysis & Model Identification ---
-    console.log(chalk.blue('  -> Analyzing frontend for C# backend...'));
+    console.log(chalk.blue('  -> Analyzing frontend for C# backend (AST)...'));
     const endpoints = await analyzeFrontend(frontendSrcDir);
-    const modelsToGenerate = new Map();
-    endpoints.forEach(ep => {
-      // For C#, we create a model if schemaFields exist for any endpoint related to a controller
-      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 })) 
-        });
-      }
-    });
 
-    if (modelsToGenerate.size > 0) {
-        console.log(chalk.green(`  -> Identified ${modelsToGenerate.size} models/controllers to generate.`));
-    } else {
-        console.log(chalk.yellow('  -> No API calls with body data found. A basic API project will be created without models.'));
-    }
+    const byController = groupByController(endpoints);
+    const dtoModels = collectDtoModels(endpoints);
 
-    // --- Step 2: Create Base .NET Project using `dotnet new` ---
+    console.log(chalk.green(`  -> Found ${endpoints.length} endpoints, ${dtoModels.size} DTO models, ${byController.size} controllers.`));
+
+    // Scaffold base project
     console.log(chalk.blue('  -> Scaffolding .NET Core Web API project...'));
     await execa('dotnet', ['new', 'webapi', '-n', projectName, '-o', projectDir, '--no-https']);
-    
-    // --- Step 3: Add Required NuGet Packages ---
-    if (modelsToGenerate.size > 0) {
-        console.log(chalk.blue('  -> Adding NuGet packages (Entity Framework Core)...'));
-        const packages = [
-            'Microsoft.EntityFrameworkCore.Design',
-            'Microsoft.EntityFrameworkCore.InMemory' // Using InMemory for a simple, runnable setup
-            // For a real DB, a user would add: 'Npgsql.EntityFrameworkCore.PostgreSQL' or 'Microsoft.EntityFrameworkCore.SqlServer'
-        ];
-        for (const pkg of packages) {
-            await execa('dotnet', ['add', 'package', pkg], { cwd: projectDir });
-        }
-    }
 
-    // --- Step 4: Generate Models and DbContext from Templates ---
-    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 }
-            );
-        }
-        
+    // Remove WeatherForecast
+    await fs.remove(path.join(projectDir, 'Controllers', 'WeatherForecastController.cs'));
+    await fs.remove(path.join(projectDir, 'WeatherForecast.cs'));
+
+    // Generate DTOs
+    if (dtoModels.size > 0) {
+      console.log(chalk.blue('  -> Generating DTO models...'));
+      const dtoDir = path.join(projectDir, 'Models', 'DTOs');
+      await fs.ensureDir(dtoDir);
+
+      for (const model of dtoModels.values()) {
         await renderAndWrite(
-            getTemplatePath('dotnet/partials/DbContext.cs.ejs'),
-            path.join(dataDir, 'ApplicationDbContext.cs'),
-            { projectName, modelsToGenerate: Array.from(modelsToGenerate.values()) }
+          getTemplatePath('dotnet/partials/Dto.cs.ejs'),
+          path.join(dtoDir, `${model.name}.cs`),
+          { projectName, model }
         );
+      }
+    }
+
+    // Generate Controllers from endpoints (not CRUD stub)
+    console.log(chalk.blue('  -> Generating controllers from detected endpoints...'));
+    const controllersDir = path.join(projectDir, 'Controllers');
+    await fs.ensureDir(controllersDir);
+
+    for (const [controllerName, controllerEndpoints] of byController.entries()) {
+      if (controllerName === 'Default') continue;
+
+      await renderAndWrite(
+        getTemplatePath('dotnet/partials/Controller.FromEndpoints.cs.ejs'),
+        path.join(controllersDir, `${controllerName}Controller.cs`),
+        { projectName, controllerName, endpoints: controllerEndpoints }
+      );
     }
 
-    // --- Step 5: Configure Services in Program.cs ---
-    console.log(chalk.blue('  -> Configuring services in Program.cs...'));
+    // Program.cs markers + CORS insert (idempotent)
+    console.log(chalk.blue('  -> Configuring Program.cs (idempotent markers)...'));
     const programCsPath = path.join(projectDir, 'Program.cs');
+    await ensureProgramMarkers(programCsPath);
+
     let programCsContent = await fs.readFile(programCsPath, 'utf-8');
-    
-    let usingStatements = 'using Microsoft.EntityFrameworkCore;\nusing '+projectName+'.Data;\n';
-    programCsContent = usingStatements + 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}`);
-    
-    // Enable CORS to allow frontend communication
-    const corsPolicy = `
+
+    const corsBlock = `
 builder.Services.AddCors(options =>
 {
-    options.AddDefaultPolicy(
-        policy =>
-        {
-            policy.WithOrigins("http://localhost:3000", "http://localhost:5173") // Common frontend dev ports
-                   .AllowAnyHeader()
-                   .AllowAnyMethod();
-        });
-});`;
-    programCsContent = programCsContent.replace('var app = builder.Build();', `${corsPolicy}\n\nvar app = builder.Build();\n\napp.UseCors();`);
+    options.AddDefaultPolicy(policy =>
+        policy.WithOrigins("http://localhost:3000", "http://localhost:5173")
+              .AllowAnyHeader()
+              .AllowAnyMethod()
+    );
+});`.trim();
 
-    await fs.writeFile(programCsPath, programCsContent);
+    programCsContent = insertBetweenMarkers(programCsContent, 'services', corsBlock);
+    programCsContent = insertBetweenMarkers(programCsContent, 'middleware', 'app.UseCors();');
 
-    // --- Step 6: Generate Controllers with full CRUD ---
-    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'));
-    
-    const controllersToGenerate = new Set(Array.from(modelsToGenerate.keys()));
-    // Also add controllers for endpoints that didn't have a body but were detected
-    endpoints.forEach(ep => {
-        if (ep.controllerName !== 'Default') controllersToGenerate.add(ep.controllerName);
-    });
-
-    for (const controllerName of controllersToGenerate) {
-        await renderAndWrite(
-            getTemplatePath('dotnet/partials/Controller.cs.ejs'),
-            path.join(projectDir, 'Controllers', `${controllerName}Controller.cs`),
-            { projectName, controllerName }
-        );
-    }
+    await fs.writeFile(programCsPath, programCsContent);
 
-    // --- Step 7: Generate README ---
+    // README
     await renderAndWrite(
-        getTemplatePath('dotnet/partials/README.md.ejs'),
-        path.join(projectDir, 'README.md'),
-        { projectName }
+      getTemplatePath('dotnet/partials/README.md.ejs'),
+      path.join(projectDir, 'README.md'),
+      { projectName }
     );
 
     console.log(chalk.green('  -> C# backend generation is complete!'));
 
   } catch (error) {
-    // Re-throw the error to be caught by the main CLI handler
     throw error;
   }
 }

package/src/generators/java.js

@@ -1,5 +1,4 @@
 const chalk = require('chalk');
-const { execa } = require('execa');
 const fs = require('fs-extra');
 const path = require('path');
 const axios = require('axios');
@@ -8,8 +7,10 @@ const { analyzeFrontend } = require('../analyzer');
 const { renderAndWrite, getTemplatePath } = require('./template');
 
 function sanitizeArtifactId(name) {
-  // Lowercase, keep letters, numbers and dashes; replace others with dashes
-  return String(name || 'backend').toLowerCase().replace(/[^a-z0-9\-]/g, '-').replace(/-+/g, '-');
+  return String(name || 'backend')
+    .toLowerCase()
+    .replace(/[^a-z0-9\-]/g, '-')
+    .replace(/-+/g, '-');
 }
 
 async function downloadInitializrZip({ groupId, artifactId, name, bootVersion, dependencies }) {
@@ -19,20 +20,16 @@ async function downloadInitializrZip({ groupId, artifactId, name, bootVersion, d
     groupId,
     artifactId,
     name,
-    packageName: `${groupId}.${artifactId.replace(/-/g, '')}`, // com.example.myapp
+    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, {
+  return axios.get(url, {
     responseType: 'stream',
     headers: { Accept: 'application/zip' }
   });
-
-  return res;
 }
 
 async function extractZipStream(stream, dest) {
@@ -44,135 +41,186 @@ async function extractZipStream(stream, dest) {
   });
 }
 
+function groupByController(endpoints) {
+  const map = new Map();
+  for (const ep of endpoints || []) {
+    const c = ep.controllerName || 'Default';
+    if (!map.has(c)) map.set(c, []);
+    map.get(c).push(ep);
+  }
+  return map;
+}
+
+function collectModelsForJava(endpointsByController) {
+  // Produces one Entity per controller + DTOs per endpoint body/response if provided by analyzer.
+  const entities = new Map(); // controllerName -> {name, fields}
+  const dtos = new Map();     // dtoName -> {name, fields}
+
+  for (const [controllerName, eps] of endpointsByController.entries()) {
+    if (controllerName === 'Default') continue;
+
+    // Entity fields heuristic: merge requestBody fields across endpoints
+    const mergedFields = {};
+    for (const ep of eps) {
+      if (ep.requestBody?.fields) {
+        for (const [k, t] of Object.entries(ep.requestBody.fields)) mergedFields[k] = t;
+      }
+    }
+
+    if (Object.keys(mergedFields).length > 0) {
+      entities.set(controllerName, { name: controllerName, fields: mergedFields });
+    }
+
+    // DTOs from analyzer if exists
+    for (const ep of eps) {
+      if (ep.requestBody?.modelName && ep.requestBody?.fields) {
+        dtos.set(ep.requestBody.modelName, { name: ep.requestBody.modelName, fields: ep.requestBody.fields });
+      }
+      if (ep.responseBody?.modelName && ep.responseBody?.fields) {
+        dtos.set(ep.responseBody.modelName, { name: ep.responseBody.modelName, fields: ep.responseBody.fields });
+      }
+    }
+  }
+
+  return { entities, dtos };
+}
+
+async function upsertApplicationProperties(projectDir, artifactId) {
+  const propsPath = path.join(projectDir, 'src', 'main', 'resources', 'application.properties');
+  if (!await fs.pathExists(propsPath)) return;
+
+  const start = '# <backlist:db>';
+  const end = '# </backlist:db>';
+
+  const dbProps = [
+    start,
+    `spring.datasource.url=jdbc:postgresql://localhost:5432/${artifactId}`,
+    `spring.datasource.username=postgres`,
+    `spring.datasource.password=password`,
+    `spring.jpa.hibernate.ddl-auto=update`,
+    `spring.jpa.show-sql=true`,
+    end,
+    ''
+  ].join('\n');
+
+  const current = await fs.readFile(propsPath, 'utf-8');
+
+  if (current.includes(start) && current.includes(end)) {
+    // replace existing block
+    const replaced = current.replace(new RegExp(`${start}[\\s\\S]*?${end}`), dbProps.trim());
+    await fs.writeFile(propsPath, replaced);
+  } else {
+    await fs.appendFile(propsPath, `\n\n${dbProps}`);
+  }
+}
+
 async function generateJavaProject(options) {
   const { projectDir, projectName, frontendSrcDir } = options;
   const groupId = 'com.backlist.generated';
   const artifactId = sanitizeArtifactId(projectName || 'backend');
-  const name = projectName || 'backend';
+  const basePackage = `${groupId}.${artifactId.replace(/-/g, '')}`;
 
   try {
-    console.log(chalk.blue('  -> Contacting Spring Initializr to download a base Spring Boot project...'));
+    console.log(chalk.blue('  -> Downloading base Spring Boot project from Initializr...'));
 
-    // Primary attempt: current stable Boot version. If this fails, we’ll retry without bootVersion.
-    const deps = ['web', 'data-jpa', 'lombok', 'postgresql']; // valid Initializr ids
+    const deps = ['web', 'data-jpa', 'lombok', 'postgresql'];
 
     let response;
     try {
       response = await downloadInitializrZip({
-        groupId,
-        artifactId,
-        name,
-        bootVersion: '3.3.4', // current stable; adjust as needed
+        groupId, artifactId, name: projectName || 'backend',
+        bootVersion: '3.3.4',
         dependencies: deps
       });
     } catch (err) {
-      // Fallback – remove bootVersion and also try smaller dependency set if needed
-      const fallbackDeps = ['web', 'data-jpa', 'lombok'];
-      try {
-        console.log(chalk.yellow('    -> Initial attempt failed. Retrying with default Boot version...'));
-        response = await downloadInitializrZip({
-          groupId,
-          artifactId,
-          name,
-          bootVersion: '', // let Initializr pick latest
-          dependencies: deps
-        });
-      } catch {
-        console.log(chalk.yellow('    -> Second attempt failed. Retrying with minimal dependencies...'));
-        response = await downloadInitializrZip({
-          groupId,
-          artifactId,
-          name,
-          bootVersion: '',
-          dependencies: fallbackDeps
-        });
-      }
+      console.log(chalk.yellow('    -> Retry without fixed bootVersion...'));
+      response = await downloadInitializrZip({
+        groupId, artifactId, name: projectName || 'backend',
+        bootVersion: '',
+        dependencies: deps
+      });
     }
 
-    console.log(chalk.blue('  -> Unzipping the Spring Boot project...'));
+    console.log(chalk.blue('  -> Unzipping...'));
     await extractZipStream(response.data, projectDir);
 
-    // Analyze frontend and plan entities/controllers
+    console.log(chalk.blue('  -> Analyzing frontend (AST) for endpoints/contracts...'));
     const endpoints = await analyzeFrontend(frontendSrcDir);
-    const modelsToGenerate = new Map();
-    (Array.isArray(endpoints) ? endpoints : []).forEach(ep => {
-      if (ep && ep.schemaFields && ep.controllerName && 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 }))
-        });
-      }
-    });
-
-    // Generate Entities/Repositories/Controllers (basic)
-    if (modelsToGenerate.size > 0) {
-      console.log(chalk.blue('  -> Generating Java entities, repositories, and controllers...'));
-
-      // Spring Initializr zips project as <artifactId> root folder; if you extracted to projectDir,
-      // files are already in the right place. Compute Java src path:
-      const javaSrcRoot = path.join(projectDir, 'src', 'main', 'java', ...groupId.split('.'), artifactId.replace(/-/g, ''));
-      const entityDir = path.join(javaSrcRoot, 'model');
-      const repoDir = path.join(javaSrcRoot, 'repository');
-      const controllerDir = path.join(javaSrcRoot, 'controller');
-
-      await fs.ensureDir(entityDir);
-      await fs.ensureDir(repoDir);
-      await fs.ensureDir(controllerDir);
-
-      for (const [modelName, modelData] of modelsToGenerate.entries()) {
-        await renderAndWrite(
-          getTemplatePath('java-spring/partials/Entity.java.ejs'),
-          path.join(entityDir, `${modelName}.java`),
-          { group: groupId, projectName: artifactId.replace(/-/g, ''), modelName, model: modelData }
-        );
-        await renderAndWrite(
-          getTemplatePath('java-spring/partials/Repository.java.ejs'),
-          path.join(repoDir, `${modelName}Repository.java`),
-          { group: groupId, projectName: artifactId.replace(/-/g, ''), modelName }
-        );
-        await renderAndWrite(
-          getTemplatePath('java-spring/partials/Controller.java.ejs'),
-          path.join(controllerDir, `${modelName}Controller.java`),
-          { group: groupId, projectName: artifactId.replace(/-/g, ''), controllerName: modelName, model: modelData }
-        );
-      }
+
+    const endpointsByController = groupByController(endpoints);
+    const { entities, dtos } = collectModelsForJava(endpointsByController);
+
+    console.log(chalk.green(`  -> Found ${Array.isArray(endpoints) ? endpoints.length : 0} endpoints`));
+    console.log(chalk.green(`  -> Will generate ${entities.size} entities, ${dtos.size} DTOs, ${endpointsByController.size} controllers`));
+
+    // Compute java src root
+    const javaSrcRoot = path.join(
+      projectDir,
+      'src', 'main', 'java',
+      ...groupId.split('.'),
+      artifactId.replace(/-/g, '')
+    );
+
+    const entityDir = path.join(javaSrcRoot, 'model');
+    const dtoDir = path.join(javaSrcRoot, 'dto');
+    const repoDir = path.join(javaSrcRoot, 'repository');
+    const controllerDir = path.join(javaSrcRoot, 'controller');
+
+    await fs.ensureDir(entityDir);
+    await fs.ensureDir(dtoDir);
+    await fs.ensureDir(repoDir);
+    await fs.ensureDir(controllerDir);
+
+    // Entities + Repos
+    for (const ent of entities.values()) {
+      await renderAndWrite(
+        getTemplatePath('java-spring/partials/Entity.java.ejs'),
+        path.join(entityDir, `${ent.name}.java`),
+        { basePackage, model: ent }
+      );
+
+      await renderAndWrite(
+        getTemplatePath('java-spring/partials/Repository.java.ejs'),
+        path.join(repoDir, `${ent.name}Repository.java`),
+        { basePackage, entityName: ent.name }
+      );
     }
 
-    // Append DB config (PostgreSQL) to application.properties (non-fatal if fails)
-    try {
-      const propsPath = path.join(projectDir, 'src', 'main', 'resources', 'application.properties');
-      const dbProps = [
-        `\n\n# --- Auto-generated by create-backlist ---`,
-        `spring.datasource.url=jdbc:postgresql://localhost:5432/${artifactId}`,
-        `spring.datasource.username=postgres`,
-        `spring.datasource.password=password`,
-        `spring.jpa.hibernate.ddl-auto=update`,
-        `spring.jpa.show-sql=true`,
-      ].join('\n');
-      await fs.appendFile(propsPath, dbProps);
-    } catch (e) {
-      console.log(chalk.yellow('  -> Could not update application.properties (continuing).'));
+    // DTOs
+    for (const dto of dtos.values()) {
+      await renderAndWrite(
+        getTemplatePath('java-spring/partials/Dto.java.ejs'),
+        path.join(dtoDir, `${dto.name}.java`),
+        { basePackage, dto }
+      );
     }
 
+    // Controllers from endpoints
+    for (const [controllerName, eps] of endpointsByController.entries()) {
+      if (controllerName === 'Default') continue;
+
+      await renderAndWrite(
+        getTemplatePath('java-spring/partials/Controller.FromEndpoints.java.ejs'),
+        path.join(controllerDir, `${controllerName}Controller.java`),
+        {
+          basePackage,
+          controllerName,
+          endpoints: eps,
+          hasEntity: entities.has(controllerName)
+        }
+      );
+    }
+
+    // application.properties idempotent update
+    await upsertApplicationProperties(projectDir, artifactId);
+
     console.log(chalk.green('  -> Java (Spring Boot) backend generation is complete!'));
     console.log(chalk.yellow('\nNext steps:'));
     console.log(chalk.cyan(`  cd ${path.basename(projectDir)}`));
-    console.log(chalk.cyan('  ./mvnw spring-boot:run   # or use your IDE to run Application class'));
+    console.log(chalk.cyan('  ./mvnw spring-boot:run'));
 
   } catch (error) {
     if (error.response && error.response.status) {
-      console.error(chalk.red(`  -> Initializr error status: ${error.response.status}`));
-      if (error.response.data) {
-        try {
-          // Try read error text body for hints
-          const text = (await (async () => {
-            let buf = '';
-            for await (const chunk of error.response.data) buf += chunk.toString();
-            return buf;
-          })());
-          console.error(chalk.yellow('  -> Initializr response body:'), text);
-        } catch {}
-      }
       throw new Error(`Failed to download from Spring Initializr. Status: ${error.response.status}`);
     }
     throw error;