create-backlist 6.0.7 → 6.0.8

package/src/generators/dotnet.js

@@ -5,153 +5,127 @@ 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 {
-    console.log(chalk.blue('  -> Analyzing frontend for C# backend (AST)...'));
+    // --- Step 1: Analysis & Model Identification ---
+    console.log(chalk.blue('  -> Analyzing frontend for C# backend...'));
     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 })) 
+        });
+      }
+    });
 
-    const byController = groupByController(endpoints);
-    const dtoModels = collectDtoModels(endpoints);
-
-    console.log(chalk.green(`  -> Found ${endpoints.length} endpoints, ${dtoModels.size} DTO models, ${byController.size} controllers.`));
+    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.'));
+    }
 
-    // Scaffold base project
+    // --- Step 2: Create Base .NET Project using `dotnet new` ---
     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 });
+        }
+    }
 
-    // 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()) {
+    // --- 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 }
+            );
+        }
+        
         await renderAndWrite(
-          getTemplatePath('dotnet/partials/Dto.cs.ejs'),
-          path.join(dtoDir, `${model.name}.cs`),
-          { projectName, model }
+            getTemplatePath('dotnet/partials/DbContext.cs.ejs'),
+            path.join(dataDir, 'ApplicationDbContext.cs'),
+            { projectName, modelsToGenerate: Array.from(modelsToGenerate.values()) }
         );
-      }
-    }
-
-    // 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 }
-      );
     }
 
-    // Program.cs markers + CORS insert (idempotent)
-    console.log(chalk.blue('  -> Configuring Program.cs (idempotent markers)...'));
+    // --- Step 5: Configure Services in Program.cs ---
+    console.log(chalk.blue('  -> Configuring services in Program.cs...'));
     const programCsPath = path.join(projectDir, 'Program.cs');
-    await ensureProgramMarkers(programCsPath);
-
     let programCsContent = await fs.readFile(programCsPath, 'utf-8');
-
-    const corsBlock = `
+    
+    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 = `
 builder.Services.AddCors(options =>
 {
-    options.AddDefaultPolicy(policy =>
-        policy.WithOrigins("http://localhost:3000", "http://localhost:5173")
-              .AllowAnyHeader()
-              .AllowAnyMethod()
-    );
-});`.trim();
-
-    programCsContent = insertBetweenMarkers(programCsContent, 'services', corsBlock);
-    programCsContent = insertBetweenMarkers(programCsContent, 'middleware', 'app.UseCors();');
+    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();`);
 
     await fs.writeFile(programCsPath, programCsContent);
 
-    // README
+    // --- 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 }
+        );
+    }
+
+    // --- Step 7: Generate 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,4 +1,5 @@
 const chalk = require('chalk');
+const { execa } = require('execa');
 const fs = require('fs-extra');
 const path = require('path');
 const axios = require('axios');
@@ -7,10 +8,8 @@ const { analyzeFrontend } = require('../analyzer');
 const { renderAndWrite, getTemplatePath } = require('./template');
 
 function sanitizeArtifactId(name) {
-  return String(name || 'backend')
-    .toLowerCase()
-    .replace(/[^a-z0-9\-]/g, '-')
-    .replace(/-+/g, '-');
+  // Lowercase, keep letters, numbers and dashes; replace others with dashes
+  return String(name || 'backend').toLowerCase().replace(/[^a-z0-9\-]/g, '-').replace(/-+/g, '-');
 }
 
 async function downloadInitializrZip({ groupId, artifactId, name, bootVersion, dependencies }) {
@@ -20,16 +19,20 @@ async function downloadInitializrZip({ groupId, artifactId, name, bootVersion, d
     groupId,
     artifactId,
     name,
-    packageName: `${groupId}.${artifactId.replace(/-/g, '')}`,
+    packageName: `${groupId}.${artifactId.replace(/-/g, '')}`, // com.example.myapp
     dependencies: dependencies.join(','),
   });
+
   if (bootVersion) params.set('bootVersion', bootVersion);
 
   const url = `https://start.spring.io/starter.zip?${params.toString()}`;
-  return axios.get(url, {
+
+  const res = await axios.get(url, {
     responseType: 'stream',
     headers: { Accept: 'application/zip' }
   });
+
+  return res;
 }
 
 async function extractZipStream(stream, dest) {
@@ -41,186 +44,135 @@ 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 basePackage = `${groupId}.${artifactId.replace(/-/g, '')}`;
+  const name = projectName || 'backend';
 
   try {
-    console.log(chalk.blue('  -> Downloading base Spring Boot project from Initializr...'));
+    console.log(chalk.blue('  -> Contacting Spring Initializr to download a base Spring Boot project...'));
 
-    const deps = ['web', 'data-jpa', 'lombok', 'postgresql'];
+    // Primary attempt: current stable Boot version. If this fails, we’ll retry without bootVersion.
+    const deps = ['web', 'data-jpa', 'lombok', 'postgresql']; // valid Initializr ids
 
     let response;
     try {
       response = await downloadInitializrZip({
-        groupId, artifactId, name: projectName || 'backend',
-        bootVersion: '3.3.4',
+        groupId,
+        artifactId,
+        name,
+        bootVersion: '3.3.4', // current stable; adjust as needed
         dependencies: deps
       });
     } catch (err) {
-      console.log(chalk.yellow('    -> Retry without fixed bootVersion...'));
-      response = await downloadInitializrZip({
-        groupId, artifactId, name: projectName || 'backend',
-        bootVersion: '',
-        dependencies: deps
-      });
+      // 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.blue('  -> Unzipping...'));
+    console.log(chalk.blue('  -> Unzipping the Spring Boot project...'));
     await extractZipStream(response.data, projectDir);
 
-    console.log(chalk.blue('  -> Analyzing frontend (AST) for endpoints/contracts...'));
+    // Analyze frontend and plan entities/controllers
     const endpoints = await analyzeFrontend(frontendSrcDir);
-
-    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 }
-      );
-    }
-
-    // DTOs
-    for (const dto of dtos.values()) {
-      await renderAndWrite(
-        getTemplatePath('java-spring/partials/Dto.java.ejs'),
-        path.join(dtoDir, `${dto.name}.java`),
-        { basePackage, dto }
-      );
+    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 }
+        );
+      }
     }
 
-    // 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)
-        }
-      );
+    // 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).'));
     }
 
-    // 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'));
+    console.log(chalk.cyan('  ./mvnw spring-boot:run   # or use your IDE to run Application class'));
 
   } 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;