create-backlist 5.0.7 → 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,96 +1,226 @@
 const chalk = require('chalk');
-const { execa } = require('execa');
 const fs = require('fs-extra');
 const path = require('path');
-const axios = require('axios'); // For making HTTP requests
-const unzipper = require('unzipper'); // For extracting .zip files
+const axios = require('axios');
+const unzipper = require('unzipper');
 const { analyzeFrontend } = require('../analyzer');
 const { renderAndWrite, getTemplatePath } = require('./template');
 
+function sanitizeArtifactId(name) {
+  return String(name || 'backend')
+    .toLowerCase()
+    .replace(/[^a-z0-9\-]/g, '-')
+    .replace(/-+/g, '-');
+}
+
+async function downloadInitializrZip({ groupId, artifactId, name, bootVersion, dependencies }) {
+  const params = new URLSearchParams({
+    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()}`;
+  return axios.get(url, {
+    responseType: 'stream',
+    headers: { Accept: 'application/zip' }
+  });
+}
+
+async function extractZipStream(stream, dest) {
+  await new Promise((resolve, reject) => {
+    const out = stream.pipe(unzipper.Extract({ path: dest }));
+    out.on('close', resolve);
+    out.on('finish', resolve);
+    out.on('error', reject);
+  });
+}
+
+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 group = 'com.backlist.generated'; // A default Java group ID
+  const groupId = 'com.backlist.generated';
+  const artifactId = sanitizeArtifactId(projectName || 'backend');
+  const basePackage = `${groupId}.${artifactId.replace(/-/g, '')}`;
 
   try {
-    // --- Step 1: Download Base Project from Spring Initializr ---
-    console.log(chalk.blue('  -> Contacting Spring Initializr to download a base Spring Boot project...'));
-    
-    // Define standard dependencies for a web API
-    const dependencies = 'web,data-jpa,lombok,postgresql'; // Using PostgreSQL as an example DB driver
-    const springInitializrUrl = `https://start.spring.io/starter.zip?type=maven-project&language=java&bootVersion=3.2.0&groupId=${group}&artifactId=${projectName}&name=${projectName}&dependencies=${dependencies}`;
-
-    const response = await axios({
-      url: springInitializrUrl,
-      method: 'GET',
-      responseType: 'stream'
-    });
-
-    // --- Step 2: Unzip the Downloaded Project ---
-    console.log(chalk.blue('  -> Unzipping the Spring Boot project...'));
-    await new Promise((resolve, reject) => {
-      const stream = response.data.pipe(unzipper.Extract({ path: projectDir }));
-      stream.on('finish', () => {
-        console.log(chalk.gray('    -> Project unzipped successfully.'));
-        resolve();
+    console.log(chalk.blue('  -> Downloading base Spring Boot project from Initializr...'));
+
+    const deps = ['web', 'data-jpa', 'lombok', 'postgresql'];
+
+    let response;
+    try {
+      response = await downloadInitializrZip({
+        groupId, artifactId, name: projectName || 'backend',
+        bootVersion: '3.3.4',
+        dependencies: deps
       });
-      stream.on('error', reject);
-    });
+    } catch (err) {
+      console.log(chalk.yellow('    -> Retry without fixed bootVersion...'));
+      response = await downloadInitializrZip({
+        groupId, artifactId, name: projectName || 'backend',
+        bootVersion: '',
+        dependencies: deps
+      });
+    }
+
+    console.log(chalk.blue('  -> Unzipping...'));
+    await extractZipStream(response.data, projectDir);
 
-    // --- Step 3: Analyze Frontend ---
+    console.log(chalk.blue('  -> Analyzing frontend (AST) for endpoints/contracts...'));
     const endpoints = await analyzeFrontend(frontendSrcDir);
-    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 })) });
-      }
-    });
-
-    // --- Step 4: Generate Java Entities and Controllers ---
-    if (modelsToGenerate.size > 0) {
-      console.log(chalk.blue('  -> Generating Java entities and controllers...'));
-      
-      const javaSrcPath = path.join(projectDir, 'src', 'main', 'java', ...group.split('.'), projectName);
-      const entityDir = path.join(javaSrcPath, 'model');
-      const controllerDir = path.join(javaSrcPath, 'controller');
-      await fs.ensureDir(entityDir);
-      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, projectName, modelName, model: modelData }
-        );
-        await renderAndWrite(
-          getTemplatePath('java-spring/partials/Controller.java.ejs'),
-          path.join(controllerDir, `${modelName}Controller.java`),
-          { group, projectName, controllerName: modelName }
-        );
-      }
+
+    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 }
+      );
     }
 
-    // --- Step 5: Configure application.properties ---
-    console.log(chalk.blue('  -> Configuring database in application.properties...'));
-    const propsPath = path.join(projectDir, 'src', 'main', 'resources', 'application.properties');
-    const dbProps = [
-      `\n\n# --- Auto-generated by create-backlist ---`,
-      `# --- Database Configuration (PostgreSQL) ---`,
-      `spring.datasource.url=jdbc:postgresql://localhost:5432/${projectName}`,
-      `spring.datasource.username=postgres`,
-      `spring.datasource.password=password`,
-      `spring.jpa.hibernate.ddl-auto=update`,
-      `spring.jpa.show-sql=true`,
-    ];
-    await fs.appendFile(propsPath, dbProps.join('\n'));
-    
-    console.log(chalk.green('  -> Java (Spring Boot) backend generation is complete!'));
-    console.log(chalk.yellow('\nTo run your new Java backend:'));
-    console.log(chalk.cyan('  1. Open the project in a Java IDE (like IntelliJ IDEA or VS Code).'));
-    console.log(chalk.cyan('  2. Run the main application file.'));
+    // 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'));
 
   } catch (error) {
-    if (error.response) {
+    if (error.response && error.response.status) {
       throw new Error(`Failed to download from Spring Initializr. Status: ${error.response.status}`);
     }
     throw error;