create-backlist 4.0.0 → 5.0.1

package/bin/index.js

@@ -11,7 +11,7 @@ const { generateNodeProject } = require('../src/generators/node');
 const { generateDotnetProject } = require('../src/generators/dotnet');
 
 async function main() {
-  console.log(chalk.cyan.bold('🚀 Welcome to Backlist! The Intelligent Backend Generator.'));
+  console.log(chalk.cyan.bold('🚀 Welcome to Backlist! The Production-Ready Backend Generator.'));
   
   const answers = await inquirer.prompt([
     {
@@ -29,37 +29,91 @@ async function main() {
         { name: 'Node.js (TypeScript, Express)', value: 'node-ts-express' },
         { name: 'C# (ASP.NET Core Web API)', value: 'dotnet-webapi' },
         new inquirer.Separator(),
-        { name: 'Python (FastAPI) - Coming Soon', disabled: true },
-        { name: 'Java (Spring Boot) - Coming Soon', disabled: true },
+        { name: 'Python (FastAPI) - Coming Soon', disabled: true, value: 'python-fastapi' },
+        { name: 'Java (Spring Boot) - Coming Soon', disabled: true, value: 'java-spring' },
       ],
     },
+    // --- V5.0: Database Choice for Node.js ---
+    {
+      type: 'list',
+      name: 'dbType',
+      message: 'Select your database type:',
+      choices: [
+        { name: 'NoSQL (MongoDB with Mongoose)', value: 'mongoose' },
+        { name: 'SQL (PostgreSQL/MySQL with Prisma)', value: 'prisma' },
+      ],
+      when: (answers) => answers.stack === 'node-ts-express'
+    },
     {
       type: 'input',
       name: 'srcPath',
       message: 'Enter the path to your frontend `src` directory:',
       default: 'src',
     },
+    // --- V3.0: Auth Boilerplate for Node.js ---
     {
       type: 'confirm',
       name: 'addAuth',
-      message: 'Do you want to add basic JWT authentication? (generates a User model, login/register routes)',
+      message: 'Add JWT authentication boilerplate?',
       default: true,
       when: (answers) => answers.stack === 'node-ts-express'
     },
-    // --- NEW QUESTION FOR V4.0 ---
+    // --- V4.0: Seeder for Node.js ---
     {
       type: 'confirm',
       name: 'addSeeder',
-      message: 'Do you want to add a database seeder with sample user data?',
+      message: 'Add a database seeder with sample data?',
       default: true,
-      // Only ask this if Node.js is selected AND authentication is being added
-      when: (answers) => answers.stack === 'node-ts-express' && answers.addAuth
-    }
+      when: (answers) => answers.addAuth // Seeder is useful when there's an auth/user model
+    },
+    // --- V5.0: Extra Features for Node.js ---
+    {
+      type: 'checkbox',
+      name: 'extraFeatures',
+      message: 'Select additional features to include:',
+      choices: [
+          { name: 'Docker Support (Dockerfile & docker-compose.yml)', value: 'docker', checked: true },
+          { name: 'API Testing Boilerplate (Jest & Supertest)', value: 'testing' },
+          { name: 'API Documentation (Swagger UI)', value: 'swagger' },
+      ],
+      when: (answers) => answers.stack === 'node-ts-express'
+    },
+     {
+      type: 'list',
+      name: 'dbType',
+      message: 'Select your database type:',
+      choices: [
+        { name: 'NoSQL (MongoDB with Mongoose)', value: 'mongoose' },
+        { name: 'SQL (PostgreSQL/MySQL with Prisma)', value: 'prisma' },
+      ],
+      when: (answers) => answers.stack === 'node-ts-express'
+    },
+    {
+        type: 'checkbox',
+        name: 'extraFeatures',
+        message: 'Select additional features to include:',
+        choices: [
+            { name: 'Docker Support (Dockerfile & docker-compose.yml)', value: 'docker', checked: true },
+            // ... other features
+        ],
+        when: (answers) => answers.stack === 'node-ts-express'
+    },
+     {
+      type: 'list',
+      name: 'stack',
+      message: 'Select the backend stack:',
+      choices: [
+        { name: 'Node.js (TypeScript, Express)', value: 'node-ts-express' },
+        { name: 'C# (ASP.NET Core Web API)', value: 'dotnet-webapi' },
+        new inquirer.Separator(),
+        { name: 'Python (FastAPI) - Coming Soon', disabled: true, value: 'python-fastapi' },
+        { name: 'Java (Spring Boot)', value: 'java-spring' }, // <-- ENABLED!
+      ],
+    },
   ]);
 
-  // Pass all answers to the options object
   const options = {
-    ...answers, 
+    ...answers,
     projectDir: path.resolve(process.cwd(), answers.projectName),
     frontendSrcDir: path.resolve(process.cwd(), answers.srcPath),
   };
@@ -70,18 +124,19 @@ async function main() {
     // --- Dispatcher Logic ---
     switch (options.stack) {
       case 'node-ts-express':
-        await generateNodeProject(options); // Pass the entire options object
+        await generateNodeProject(options);
         break;
 
       case 'dotnet-webapi':
         if (!await isCommandAvailable('dotnet')) {
           throw new Error('.NET SDK is not installed. Please install it from https://dotnet.microsoft.com/download');
         }
+        // Note: The dotnet generator currently only supports basic route generation (v1.0 features).
         await generateDotnetProject(options);
         break;
       
       default:
-        throw new Error(`The selected stack '${options.stack}' is not supported.`);
+        throw new Error(`The selected stack '${options.stack}' is not supported yet.`);
     }
 
     console.log(chalk.green.bold('\n✅ Backend generation complete!'));
@@ -90,8 +145,9 @@ async function main() {
     console.log(chalk.cyan('  (Check the generated README.md for instructions)'));
 
   } catch (error) {
-    console.error(chalk.red.bold('\n❌ An error occurred:'));
-    console.error(chalk.red(`  ${error.message}`));
+    console.error(chalk.red.bold('\n❌ An error occurred during generation:'));
+    // Make sure we print the full error for debugging
+    console.error(error); 
     
     if (fs.existsSync(options.projectDir)) {
       console.log(chalk.yellow('  -> Cleaning up failed installation...'));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-backlist",
-  "version": "4.0.0",
+  "version": "5.0.1",
   "description": "An advanced, multi-language backend generator based on frontend analysis.",
   "type": "commonjs",
   "bin": {
@@ -18,11 +18,13 @@
   "dependencies": {
     "@babel/parser": "^7.22.7",
     "@babel/traverse": "^7.22.8",
+    "axios": "^1.13.1",
     "chalk": "^4.1.2",
     "ejs": "^3.1.9",
     "execa": "^6.1.0",
     "fs-extra": "^11.1.1",
     "glob": "^10.3.3",
-    "inquirer": "^8.2.4"
+    "inquirer": "^8.2.4",
+    "unzipper": "^0.12.3"
   }
-}
+}

package/src/generators/dotnet.js

@@ -8,45 +8,126 @@ const { renderAndWrite, getTemplatePath } = require('./template');
 async function generateDotnetProject(options) {
   const { projectDir, projectName, frontendSrcDir } = options;
 
-  console.log(chalk.blue('  -> Analyzing frontend for API endpoints...'));
-  const endpoints = await analyzeFrontend(frontendSrcDir);
-
-  const controllers = endpoints.reduce((acc, ep) => {
-    (acc[ep.controllerName] = acc[ep.controllerName] || []).push(ep);
-    return acc;
-  }, {});
-  
-  if (Object.keys(controllers).length > 0) {
-    console.log(chalk.green(`  -> Found endpoints for ${Object.keys(controllers).length} controllers.`));
-  } else {
-    console.log(chalk.yellow('  -> No API endpoints found. A basic project will be created.'));
-  }
-  
-  console.log(chalk.blue('  -> Scaffolding .NET Core Web API project...'));
-  await execa('dotnet', ['new', 'webapi', '-n', projectName, '-o', projectDir, '--no-https']);
-  
-  await fs.remove(path.join(projectDir, 'Controllers', 'WeatherForecastController.cs'));
-  await fs.remove(path.join(projectDir, 'WeatherForecast.cs'));
-  
-  console.log(chalk.blue('  -> Generating custom controllers...'));
-  for (const controllerName of Object.keys(controllers)) {
-    if (controllerName === 'Default') continue; // Skip if no proper controller name was found
-    await renderAndWrite(
-      getTemplatePath('dotnet/partials/Controller.cs.ejs'),
-      path.join(projectDir, 'Controllers', `${controllerName}Controller.cs`),
-      { 
-        projectName,
-        controllerName,
-        endpoints: controllers[controllerName]
+  try {
+    // --- 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 })) 
+        });
       }
+    });
+
+    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.'));
+    }
+
+    // --- 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 });
+        }
+    }
+
+    // --- 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/DbContext.cs.ejs'),
+            path.join(dataDir, 'ApplicationDbContext.cs'),
+            { projectName, modelsToGenerate: Array.from(modelsToGenerate.values()) }
+        );
+    }
+
+    // --- Step 5: Configure Services in Program.cs ---
+    console.log(chalk.blue('  -> Configuring services in 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;
+    
+    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") // 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);
+
+    // --- 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 }
     );
-  }
 
-  await renderAndWrite(
-    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;
+  }
 }
 
 module.exports = { generateDotnetProject };

package/src/generators/java.js

@@ -0,0 +1,100 @@
+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 { analyzeFrontend } = require('../analyzer');
+const { renderAndWrite, getTemplatePath } = require('./template');
+
+async function generateJavaProject(options) {
+  const { projectDir, projectName, frontendSrcDir } = options;
+  const group = 'com.backlist.generated'; // A default Java group ID
+
+  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();
+      });
+      stream.on('error', reject);
+    });
+
+    // --- Step 3: Analyze Frontend ---
+    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 }
+        );
+      }
+    }
+
+    // --- 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.'));
+
+
+  } catch (error) {
+    if (error.response) {
+      throw new Error(`Failed to download from Spring Initializr. Status: ${error.response.status}`);
+    }
+    throw error;
+  }
+}
+
+module.exports = { generateJavaProject };