create-backlist 1.1.0

package/bin/index.js

@@ -0,0 +1,87 @@
+#!/usr/bin/env node
+
+const inquirer = require('inquirer');
+const chalk = require('chalk');
+const fs = require('fs-extra');
+const path = require('path');
+const { isCommandAvailable } = require('../src/utils');
+
+// Import generators
+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.'));
+  
+  const answers = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'projectName',
+      message: 'Enter a name for your backend directory:',
+      default: 'backend',
+      validate: input => input ? true : 'Project name cannot be empty.'
+    },
+    {
+      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 },
+        { name: 'Java (Spring Boot) - Coming Soon', disabled: true },
+      ],
+    },
+    {
+        type: 'input',
+        name: 'srcPath',
+        message: 'Enter the path to your frontend `src` directory:',
+        default: 'src',
+    }
+  ]);
+
+  const options = {
+    ...answers,
+    projectDir: path.resolve(process.cwd(), answers.projectName),
+    frontendSrcDir: path.resolve(process.cwd(), answers.srcPath),
+  };
+
+  try {
+    console.log(chalk.blue(`\n✨ Starting backend generation for: ${chalk.bold(options.stack)}`));
+
+    // --- Dispatcher Logic ---
+    switch (options.stack) {
+      case 'node-ts-express':
+        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');
+        }
+        await generateDotnetProject(options);
+        break;
+      
+      default:
+        throw new Error(`The selected stack '${options.stack}' is not supported.`);
+    }
+
+    console.log(chalk.green.bold('\n✅ Backend generation complete!'));
+    console.log('\nNext Steps:');
+    console.log(chalk.cyan(`  cd ${options.projectName}`));
+    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}`));
+    
+    if (fs.existsSync(options.projectDir)) {
+      console.log(chalk.yellow('  -> Cleaning up failed installation...'));
+      fs.removeSync(options.projectDir);
+    }
+    process.exit(1);
+  }
+}
+
+main();

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "create-backlist",
+  "version": "1.1.0",
+  "description": "An advanced, multi-language backend generator based on frontend analysis.",
+  "type": "commonjs",
+  "bin": {
+    "create-backlist": "bin/index.js"
+  },
+  "scripts": {
+    "start": "node bin/index.js"
+  },
+  "author": "Your Name",
+  "license": "MIT",
+  "dependencies": {
+    "@babel/parser": "^7.22.7",
+    "@babel/traverse": "^7.22.8",
+    "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"
+  }
+}

package/src/analyzer.js

@@ -0,0 +1,60 @@
+const fs = require('fs-extra');
+const { glob } = require('glob');
+const parser = require('@babel/parser');
+const traverse = require('@babel/traverse').default;
+
+function toTitleCase(str) {
+    if (!str) return 'Default';
+    return str.replace(/\w\S*/g, txt => txt.charAt(0).toUpperCase() + txt.substr(1).toLowerCase())
+              .replace(/[^a-zA-Z0-9]/g, '');
+}
+
+async function analyzeFrontend(srcPath) {
+  if (!fs.existsSync(srcPath)) {
+    throw new Error(`The source directory '${srcPath}' does not exist.`);
+  }
+
+  const files = await glob(`${srcPath}/**/*.{js,ts,jsx,tsx}`, { ignore: 'node_modules/**' });
+  const endpoints = new Map();
+
+  for (const file of files) {
+    const code = await fs.readFile(file, 'utf-8');
+    try {
+      const ast = parser.parse(code, { sourceType: 'module', plugins: ['jsx', 'typescript'] });
+      traverse(ast, {
+        CallExpression(path) {
+          if (path.node.callee.name !== 'fetch') return;
+          const urlNode = path.node.arguments[0];
+          
+          let urlValue;
+          if (urlNode.type === 'StringLiteral') {
+            urlValue = urlNode.value;
+          } else if (urlNode.type === 'TemplateLiteral' && urlNode.quasis.length > 0) {
+            urlValue = urlNode.quasis.map(q => q.value.raw).join('{id}');
+          }
+          
+          if (!urlValue || !urlValue.startsWith('/api/')) return;
+          
+          let method = 'GET';
+
+          const optionsNode = path.node.arguments[1];
+          if (optionsNode && optionsNode.type === 'ObjectExpression') {
+            const methodProp = optionsNode.properties.find(p => p.key.name === 'method');
+            if (methodProp && methodProp.value.type === 'StringLiteral') {
+              method = methodProp.value.value.toUpperCase();
+            }
+          }
+
+          const controllerName = toTitleCase(urlValue.split('/')[2]);
+          const key = `${method}:${urlValue}`;
+          if (!endpoints.has(key)) {
+            endpoints.set(key, { path: urlValue, method, controllerName });
+          }
+        },
+      });
+    } catch (e) { /* Ignore parsing errors */ }
+  }
+  return Array.from(endpoints.values());
+}
+
+module.exports = { analyzeFrontend };

package/src/generators/dotnet.js

@@ -0,0 +1,52 @@
+const chalk = require('chalk');
+const { execa } = require('execa');
+const fs = require('fs-extra');
+const path = require('path');
+const { analyzeFrontend } = require('../analyzer');
+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]
+      }
+    );
+  }
+
+  await renderAndWrite(
+    getTemplatePath('dotnet/partials/README.md.ejs'),
+    path.join(projectDir, 'README.md'),
+    { projectName }
+  );
+}
+
+module.exports = { generateDotnetProject };

package/src/generators/node.js

@@ -0,0 +1,51 @@
+const chalk = require('chalk');
+const { execa } = require('execa');
+const fs = require('fs-extra');
+const path = require('path');
+const { analyzeFrontend } = require('../analyzer');
+const { renderAndWrite, getTemplatePath } = require('./template');
+
+async function generateNodeProject(options) {
+  const { projectDir, projectName, frontendSrcDir } = options;
+
+  console.log(chalk.blue('  -> Analyzing frontend for API endpoints...'));
+  const endpoints = await analyzeFrontend(frontendSrcDir);
+  if (endpoints.length > 0) {
+    console.log(chalk.green(`  -> Found ${endpoints.length} endpoints.`));
+  } else {
+    console.log(chalk.yellow('  -> No API endpoints found. A basic project will be created.'));
+  }
+
+  console.log(chalk.blue('  -> Scaffolding Node.js (Express + TS) project...'));
+  
+  const baseDir = getTemplatePath('node-ts-express/base');
+  await fs.copy(baseDir, projectDir);
+  
+  await renderAndWrite(
+    getTemplatePath('node-ts-express/partials/package.json.ejs'),
+    path.join(projectDir, 'package.json'),
+    { projectName }
+  );
+
+  await renderAndWrite(
+    getTemplatePath('node-ts-express/partials/routes.ts.ejs'),
+    path.join(projectDir, 'src', 'routes.ts'),
+    { endpoints }
+  );
+  
+  const serverFilePath = path.join(projectDir, 'src', 'server.ts');
+  let serverFile = await fs.readFile(serverFilePath, 'utf-8');
+  serverFile = serverFile.replace('// INJECT:ROUTES', `import apiRoutes from './routes';\napp.use(apiRoutes);`);
+  await fs.writeFile(serverFilePath, serverFile);
+
+  console.log(chalk.magenta('  -> Installing dependencies (npm install)...'));
+  await execa('npm', ['install'], { cwd: projectDir });
+
+  await renderAndWrite(
+    getTemplatePath('node-ts-express/partials/README.md.ejs'),
+    path.join(projectDir, 'README.md'),
+    { projectName }
+  );
+}
+
+module.exports = { generateNodeProject };

package/src/generators/template.js

@@ -0,0 +1,15 @@
+const ejs = require('ejs');
+const fs = require('fs-extra');
+const path = require('path');
+
+async function renderAndWrite(templatePath, destinationPath, data) {
+  const template = await fs.readFile(templatePath, 'utf-8');
+  const content = ejs.render(template, data);
+  await fs.outputFile(destinationPath, content);
+}
+
+function getTemplatePath(subpath) {
+  return path.join(__dirname, '..', 'templates', subpath);
+}
+
+module.exports = { renderAndWrite, getTemplatePath };

package/src/templates/dotnet/partials/Controller.cs.ejs

@@ -0,0 +1,24 @@
+using Microsoft.AspNetCore.Mvc;
+
+namespace <%= projectName %>.Controllers;
+
+[ApiController]
+[Route("api/[controller]")]
+public class <%= controllerName %>Controller : ControllerBase
+{
+    // Endpoints for <%= controllerName %> auto-generated by Backlist
+
+<% endpoints.forEach(endpoint => { %>
+    <%# Convert /api/users/{id} to just {id} for the route attribute %>
+    <% const routePath = endpoint.path.replace(`/api/${controllerName.toLowerCase()}`, '').substring(1); %>
+    /**
+     * <%= endpoint.method.toUpperCase() %> <%= endpoint.path %>
+     */
+    [Http<%= endpoint.method.charAt(0) + endpoint.method.slice(1).toLowerCase() %>("<%- routePath %>")]
+    public IActionResult AutoGenerated_<%= endpoint.method %>_<%= routePath.replace(/{|}/g, 'By_').replace(/[^a-zA-Z0-9_]/g, '') || 'Index' %>()
+    {
+        // TODO: Implement logic here. You can access route parameters like: public IActionResult Get(int id)
+        return Ok(new { message = "Auto-generated response for <%= endpoint.method.toUpperCase() %> <%= endpoint.path %>" });
+    }
+<% }); %>
+}

package/src/templates/dotnet/partials/README.md.ejs

@@ -0,0 +1,16 @@
+# <%= projectName %> (.NET Core Web API)
+
+This backend was auto-generated by **Backlist**.
+
+## 🚀 Getting Started
+
+1.  **Navigate to the directory:**
+    ```bash
+    cd <%= projectName %>
+    ```
+
+2.  **Run the development server:**
+    ```bash
+    dotnet watch run
+    ```
+    The server will start on `http://localhost:5XXX`.

package/src/templates/node-ts-express/base/server.ts

@@ -0,0 +1,15 @@
+import express from 'express';
+import cors from 'cors';
+import dotenv from 'dotenv';
+
+dotenv.config();
+const app = express();
+app.use(cors());
+app.use(express.json());
+
+app.get('/', (req, res) => res.send('Node.js Backend says Hello! Generated by Backlist.'));
+
+// INJECT:ROUTES
+
+const PORT = process.env.PORT || 8000;
+app.listen(PORT, () => console.log(`⚡️ Server running on http://localhost:${PORT}`));

package/src/templates/node-ts-express/base/tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "compilerOptions": {
+    "target": "es6",
+    "module": "commonjs",
+    "rootDir": "./src",
+    "outDir": "./dist",
+    "esModuleInterop": true,
+    "strict": true
+  }
+}

package/src/templates/node-ts-express/partials/README.md.ejs

@@ -0,0 +1,16 @@
+# <%= projectName %> (Node.js + Express + TypeScript)
+
+This backend was auto-generated by **Backlist**.
+
+## 🚀 Getting Started
+
+1.  **Navigate to the directory:**
+    ```bash
+    cd <%= projectName %>
+    ```
+
+2.  **Run the development server:**
+    ```bash
+    npm run dev
+    ```
+    The server will start on `http://localhost:8000`.

package/src/templates/node-ts-express/partials/package.json.ejs

@@ -0,0 +1,23 @@
+{
+  "name": "<%= projectName %>",
+  "version": "1.0.0",
+  "private": true,
+  "main": "dist/server.js",
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/server.js",
+    "dev": "ts-node-dev --respawn --transpile-only src/server.ts"
+  },
+  "dependencies": {
+    "cors": "^2.8.5",
+    "dotenv": "^16.3.1",
+    "express": "^4.18.2"
+  },
+  "devDependencies": {
+    "@types/cors": "^2.8.13",
+    "@types/express": "^4.17.17",
+    "@types/node": "^20.4.2",
+    "ts-node-dev": "^2.0.0",
+    "typescript": "^5.1.6"
+  }
+}

package/src/templates/node-ts-express/partials/routes.ts.ejs

@@ -0,0 +1,23 @@
+// Auto-generated by Backlist on <%= new Date().toISOString() %>
+import { Router, Request, Response } from 'express';
+
+const router = Router();
+
+<% if (endpoints.length === 0) { %>
+// No API endpoints were detected in the frontend code. Add your routes here.
+<% } else { %>
+<% endpoints.forEach(endpoint => { %>
+<%# Convert /api/users/{id} to /users/:id %>
+<% const expressPath = endpoint.path.replace('/api', '').replace(/{(\w+)}/g, ':$1'); %>
+/**
+ * Handler for <%= endpoint.method.toUpperCase() %> <%= endpoint.path %>
+ */
+router.<%= endpoint.method.toLowerCase() %>('<%- expressPath %>', (req: Request, res: Response) => {
+  console.log(`Request received for: ${req.method} ${req.path}`);
+  // TODO: Implement your logic here.
+  res.status(200).json({ message: 'Auto-generated response for <%= endpoint.path %>' });
+});
+<% }); %>
+<% } %>
+
+export default router;

package/src/utils.js

@@ -0,0 +1,14 @@
+const { execa } = require('execa');
+
+async function isCommandAvailable(command) {
+  try {
+    // Using a harmless version command to check for presence
+    const checkCommand = command === 'java' ? '-version' : '--version';
+    await execa(command, [checkCommand]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+module.exports = { isCommandAvailable };