create-backlist 6.0.0 → 6.0.3

package/bin/backlist.js

@@ -0,0 +1,227 @@
+#!/usr/bin/env node
+
+const inquirer = require('inquirer');
+const chalk = require('chalk');
+const fs = require('fs-extra');
+const path = require('path');
+const { Command } = require('commander');
+const chokidar = require('chokidar');
+
+const { isCommandAvailable } = require('../src/utils');
+
+const { generateNodeProject } = require('../src/generators/node');
+const { generateDotnetProject } = require('../src/generators/dotnet');
+const { generateJavaProject } = require('../src/generators/java');
+const { generatePythonProject } = require('../src/generators/python');
+
+const { scanFrontend, writeContracts } = require('../src/scanner');
+
+function resolveOptionsFromFlags(flags) {
+  return {
+    projectName: flags.projectName || 'backend',
+    srcPath: flags.srcPath || 'src',
+    stack: flags.stack || 'node-ts-express',
+    dbType: flags.dbType,
+    addAuth: flags.addAuth,
+    addSeeder: flags.addSeeder,
+    extraFeatures: flags.extraFeatures || [],
+    projectDir: path.resolve(process.cwd(), flags.projectName || 'backend'),
+    frontendSrcDir: path.resolve(process.cwd(), flags.srcPath || 'src'),
+  };
+}
+
+async function runGeneration(options, contracts) {
+  switch (options.stack) {
+    case 'node-ts-express':
+      await generateNodeProject({ ...options, contracts });
+      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, contracts });
+      break;
+
+    case 'java-spring':
+      if (!await isCommandAvailable('java')) {
+        throw new Error('Java (JDK 17 or newer) is not installed. Please install a JDK to continue.');
+      }
+      await generateJavaProject({ ...options, contracts });
+      break;
+
+    case 'python-fastapi':
+      if (!await isCommandAvailable('python')) {
+        throw new Error('Python is not installed. Please install Python (3.8+) and pip to continue.');
+      }
+      await generatePythonProject({ ...options, contracts });
+      break;
+
+    default:
+      throw new Error(`The selected stack '${options.stack}' is not supported yet.`);
+  }
+}
+
+async function interactiveMain() {
+  console.log(chalk.cyan.bold('Welcome to Backlist! The Polyglot 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' },
+        { name: 'Java (Spring Boot)', value: 'java-spring' },
+        { name: 'Python (FastAPI)', value: 'python-fastapi' },
+      ],
+    },
+    {
+      type: 'input',
+      name: 'srcPath',
+      message: 'Enter the path to your frontend `src` directory:',
+      default: 'src',
+    },
+    {
+      type: 'list',
+      name: 'dbType',
+      message: 'Select your database type for Node.js:',
+      choices: [
+        { name: 'NoSQL (MongoDB with Mongoose)', value: 'mongoose' },
+        { name: 'SQL (PostgreSQL/MySQL with Prisma)', value: 'prisma' },
+      ],
+      when: (answers) => answers.stack === 'node-ts-express'
+    },
+    {
+      type: 'confirm',
+      name: 'addAuth',
+      message: 'Add JWT authentication boilerplate?',
+      default: true,
+      when: (answers) => answers.stack === 'node-ts-express'
+    },
+    {
+      type: 'confirm',
+      name: 'addSeeder',
+      message: 'Add a database seeder with sample data?',
+      default: true,
+      when: (answers) => answers.stack === 'node-ts-express' && answers.addAuth
+    },
+    {
+      type: 'checkbox',
+      name: 'extraFeatures',
+      message: 'Select additional features for Node.js:',
+      choices: [
+        { name: 'Docker Support (Dockerfile & docker-compose.yml)', value: 'docker', checked: true },
+        { name: 'API Testing Boilerplate (Jest & Supertest)', value: 'testing', checked: true },
+        { name: 'API Documentation (Swagger UI)', value: 'swagger', checked: true },
+      ],
+      when: (answers) => answers.stack === 'node-ts-express'
+    }
+  ]);
+
+  const options = {
+    ...answers,
+    projectDir: path.resolve(process.cwd(), answers.projectName),
+    frontendSrcDir: path.resolve(process.cwd(), answers.srcPath),
+  };
+
+  const contracts = await scanFrontend({ frontendSrcDir: options.frontendSrcDir });
+
+  try {
+    console.log(chalk.blue(`\nStarting backend generation for: ${chalk.bold(options.stack)}`));
+    await runGeneration(options, contracts);
+
+    console.log(chalk.green.bold('\nBackend 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('\nAn error occurred during generation:'));
+    console.error(error);
+
+    if (fs.existsSync(options.projectDir)) {
+      console.log(chalk.yellow('  -> Cleaning up failed installation...'));
+      fs.removeSync(options.projectDir);
+    }
+    process.exit(1);
+  }
+}
+
+async function main() {
+  const program = new Command();
+
+  program
+    .name('backlist')
+    .description('Backlist CLI - generate backend from frontend via AST scan')
+    .version('1.0.0');
+
+  program.command('scan')
+    .description('Scan frontend and write contracts JSON')
+    .option('-s, --srcPath <path>', 'frontend src path', 'src')
+    .option('-o, --out <file>', 'output contracts file', '.backlist/contracts.json')
+    .action(async (flags) => {
+      const frontendSrcDir = path.resolve(process.cwd(), flags.srcPath);
+      const outFile = path.resolve(process.cwd(), flags.out);
+      const contracts = await scanFrontend({ frontendSrcDir });
+      await writeContracts(outFile, contracts);
+      console.log(chalk.green(`Wrote contracts to ${outFile}`));
+    });
+
+  program.command('generate')
+    .description('Generate backend using contracts')
+    .requiredOption('-k, --stack <stack>', 'stack: node-ts-express | dotnet-webapi | java-spring | python-fastapi')
+    .option('-p, --projectName <name>', 'backend directory', 'backend')
+    .option('-s, --srcPath <path>', 'frontend src path', 'src')
+    .option('-c, --contracts <file>', 'contracts file', '.backlist/contracts.json')
+    .action(async (flags) => {
+      const options = resolveOptionsFromFlags(flags);
+      const contractsPath = path.resolve(process.cwd(), flags.contracts);
+      const contracts = fs.existsSync(contractsPath)
+        ? await fs.readJson(contractsPath)
+        : await scanFrontend({ frontendSrcDir: options.frontendSrcDir });
+
+      await runGeneration(options, contracts);
+      console.log(chalk.green('Generation complete.'));
+    });
+
+  program.command('watch')
+    .description('Watch frontend and regenerate backend on changes')
+    .requiredOption('-k, --stack <stack>', 'stack')
+    .option('-p, --projectName <name>', 'backend directory', 'backend')
+    .option('-s, --srcPath <path>', 'frontend src path', 'src')
+    .action(async (flags) => {
+      const options = resolveOptionsFromFlags(flags);
+      const watcher = chokidar.watch(options.frontendSrcDir, { ignoreInitial: true });
+
+      const run = async () => {
+        const contracts = await scanFrontend({ frontendSrcDir: options.frontendSrcDir });
+        await runGeneration(options, contracts);
+        console.log(chalk.green(`[watch] regenerated at ${new Date().toLocaleTimeString()}`));
+      };
+
+      await run();
+      watcher.on('add', run).on('change', run).on('unlink', run);
+      console.log(chalk.cyan(`[watch] watching ${options.frontendSrcDir}`));
+    });
+
+  // If no args => old interactive mode
+  if (process.argv.length <= 2) {
+    await interactiveMain();
+    return;
+  }
+
+  await program.parseAsync(process.argv);
+}
+
+main().catch((e) => {
+  console.error(e);
+  process.exit(1);
+});

package/package.json

@@ -1,14 +1,16 @@
 {
   "name": "create-backlist",
-  "version": "6.0.0",
+  "version": "6.0.3",
   "description": "An advanced, multi-language backend generator based on frontend analysis.",
   "type": "commonjs",
   "bin": {
-    "create-backlist": "bin/index.js"
+    "create-backlist": "bin/index.js",
+    "backlist": "bin/index.js"
   },
   "files": [
     "bin",
-    "src"
+    "src",
+    "templates"
   ],
   "scripts": {
     "start": "node bin/index.js"
@@ -20,11 +22,15 @@
     "@babel/traverse": "^7.22.8",
     "axios": "^1.13.1",
     "chalk": "^4.1.2",
+    "chokidar": "^5.0.0",
+    "commander": "^14.0.2",
     "ejs": "^3.1.9",
     "execa": "^6.1.0",
+    "fast-glob": "^3.3.3",
     "fs-extra": "^11.1.1",
     "glob": "^10.3.3",
     "inquirer": "^8.2.4",
+    "ts-morph": "^27.0.2",
     "unzipper": "^0.12.3"
   }
-}
+}

package/src/analyzer.js

@@ -3,123 +3,277 @@ const { glob } = require('glob');
 const parser = require('@babel/parser');
 const traverse = require('@babel/traverse').default;
 
-/**
- * Converts a string to TitleCase, which is suitable for model and controller names.
- * e.g., 'user-orders' -> 'UserOrders'
- * @param {string} str The input string.
- * @returns {string} The TitleCased string.
- */
+const HTTP_METHODS = new Set(['get', 'post', 'put', 'patch', 'delete']);
+
 function toTitleCase(str) {
-    if (!str) return 'Default';
-    return str.replace(/-_(\w)/g, g => g[1].toUpperCase()) // handle snake_case and kebab-case
-              .replace(/\w\S*/g, txt => txt.charAt(0).toUpperCase() + txt.substr(1).toLowerCase())
-              .replace(/[^a-zA-Z0-9]/g, '');
+  if (!str) return 'Default';
+  return String(str)
+    .replace(/[-_]+(\w)/g, (_, c) => c.toUpperCase())
+    .replace(/^\w/, c => c.toUpperCase())
+    .replace(/[^a-zA-Z0-9]/g, '');
+}
+
+function normalizeRouteForBackend(urlValue) {
+  return urlValue.replace(/\{(\w+)\}/g, ':$1');
+}
+
+function inferTypeFromNode(node) {
+  if (!node) return 'String';
+  switch (node.type) {
+    case 'StringLiteral': return 'String';
+    case 'NumericLiteral': return 'Number';
+    case 'BooleanLiteral': return 'Boolean';
+    case 'NullLiteral': return 'String';
+    default: return 'String';
+  }
+}
+
+function extractObjectSchema(objExpr) {
+  const schemaFields = {};
+  if (!objExpr || objExpr.type !== 'ObjectExpression') return null;
+
+  for (const prop of objExpr.properties) {
+    if (prop.type !== 'ObjectProperty') continue;
+
+    const key =
+      prop.key.type === 'Identifier' ? prop.key.name :
+      prop.key.type === 'StringLiteral' ? prop.key.value :
+      null;
+
+    if (!key) continue;
+    schemaFields[key] = inferTypeFromNode(prop.value);
+  }
+  return schemaFields;
+}
+
+function resolveIdentifierToInit(path, identifierName) {
+  try {
+    const binding = path.scope.getBinding(identifierName);
+    if (!binding) return null;
+    const declPath = binding.path;
+    if (!declPath || !declPath.node) return null;
+
+    if (declPath.node.type === 'VariableDeclarator') return declPath.node.init || null;
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+function getUrlValue(urlNode) {
+  if (!urlNode) return null;
+
+  if (urlNode.type === 'StringLiteral') return urlNode.value;
+
+  if (urlNode.type === 'TemplateLiteral') {
+    // `/api/users/${id}` -> `/api/users/{id}` or `{param1}`
+    const quasis = urlNode.quasis || [];
+    const exprs = urlNode.expressions || [];
+    let out = '';
+    for (let i = 0; i < quasis.length; i++) {
+      out += quasis[i].value.raw;
+      if (exprs[i]) {
+        if (exprs[i].type === 'Identifier') out += `{${exprs[i].name}}`;
+        else out += `{param${i + 1}}`;
+      }
+    }
+    return out;
+  }
+
+  return null;
+}
+
+function extractApiPath(urlValue) {
+  // supports:
+  // - /api/...
+  // - http://localhost:5000/api/...
+  if (!urlValue) return null;
+  const idx = urlValue.indexOf('/api/');
+  if (idx === -1) return null;
+  return urlValue.slice(idx); // => /api/...
+}
+
+function deriveControllerNameFromUrl(urlValue) {
+  const apiPath = extractApiPath(urlValue) || urlValue;
+  const parts = String(apiPath).split('/').filter(Boolean); // ["api","v1","products"]
+  const apiIndex = parts.indexOf('api');
+
+  let seg = null;
+
+  if (apiIndex >= 0) {
+    seg = parts[apiIndex + 1] || null;
+
+    // skip version segment (v1, v2, v10...)
+    if (seg && /^v\d+$/i.test(seg)) {
+      seg = parts[apiIndex + 2] || seg;
+    }
+  } else {
+    seg = parts[0] || null;
+  }
+
+  return toTitleCase(seg);
+}
+
+function deriveActionName(method, route) {
+  const cleaned = String(route).replace(/^\/api\//, '/').replace(/[/:{}-]/g, ' ');
+  const last = cleaned.trim().split(/\s+/).filter(Boolean).pop() || 'Action';
+  return `${String(method).toLowerCase()}${toTitleCase(last)}`;
+}
+
+function extractPathParams(route) {
+  const params = [];
+  const re = /[:{]([a-zA-Z0-9_]+)[}]/g;
+  let m;
+  while ((m = re.exec(route))) params.push(m[1]);
+  return Array.from(new Set(params));
+}
+
+function extractQueryParamsFromUrl(urlValue) {
+  try {
+    const qIndex = urlValue.indexOf('?');
+    if (qIndex === -1) return [];
+    const qs = urlValue.slice(qIndex + 1);
+    return qs.split('&').map(p => p.split('=')[0]).filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+
+function detectAxiosLikeMethod(node) {
+  // axios.get(...) / api.get(...) / httpClient.post(...) etc
+  if (!node.callee || node.callee.type !== 'MemberExpression') return null;
+
+  const prop = node.callee.property;
+  if (!prop || prop.type !== 'Identifier') return null;
+
+  const name = prop.name.toLowerCase();
+  if (!HTTP_METHODS.has(name)) return null;
+
+  return name.toUpperCase();
 }
 
-/**
- * Analyzes frontend source files to find API endpoints and their details.
- * @param {string} srcPath The path to the frontend source directory.
- * @returns {Promise<Array<object>>} A promise that resolves to an array of endpoint objects.
- */
 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 files = await glob(`${srcPath}/**/*.{js,ts,jsx,tsx}`, {
+    ignore: ['**/node_modules/**', '**/dist/**', '**/build/**', '**/.next/**']
+  });
+
   const endpoints = new Map();
 
   for (const file of files) {
     const code = await fs.readFile(file, 'utf-8');
+
+    let ast;
     try {
-      const ast = parser.parse(code, { sourceType: 'module', plugins: ['jsx', 'typescript'] });
-      
-      traverse(ast, {
-        CallExpression(path) {
-          // We are only interested in 'fetch' calls
-          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) {
-            // Reconstruct path for dynamic URLs like `/api/users/${id}` -> `/api/users/{id}`
-            urlValue = urlNode.quasis.map((q, i) => {
-              return q.value.raw + (urlNode.expressions[i] ? `{${urlNode.expressions[i].name || 'id'}}` : '');
-            }).join('');
-          }
-          
-          // Only process API calls that start with '/api/'
-          if (!urlValue || !urlValue.startsWith('/api/')) return;
-          
-          let method = 'GET';
-          let schemaFields = null;
-
-          const optionsNode = path.node.arguments[1];
+      ast = parser.parse(code, { sourceType: 'module', plugins: ['jsx', 'typescript'] });
+    } catch {
+      continue;
+    }
+
+    traverse(ast, {
+      CallExpression(callPath) {
+        const node = callPath.node;
+
+        const isFetch = node.callee.type === 'Identifier' && node.callee.name === 'fetch';
+        const axiosMethod = detectAxiosLikeMethod(node);
+
+        if (!isFetch && !axiosMethod) return;
+
+        let urlValue = null;
+        let method = 'GET';
+        let schemaFields = null;
+
+        // ---- fetch() ----
+        if (isFetch) {
+          urlValue = getUrlValue(node.arguments[0]);
+          const optionsNode = node.arguments[1];
+
           if (optionsNode && optionsNode.type === 'ObjectExpression') {
-            // Find the HTTP method
-            const methodProp = optionsNode.properties.find(p => p.key.name === 'method');
+            const methodProp = optionsNode.properties.find(
+              p => p.type === 'ObjectProperty' && p.key.type === 'Identifier' && p.key.name === 'method'
+            );
             if (methodProp && methodProp.value.type === 'StringLiteral') {
               method = methodProp.value.value.toUpperCase();
             }
 
-            // --- NEW LOGIC: Analyze the 'body' for POST/PUT requests ---
-            if (method === 'POST' || method === 'PUT') {
-              const bodyProp = optionsNode.properties.find(p => p.key.name === 'body');
-              
-              // Check if body is wrapped in JSON.stringify
-              if (bodyProp && bodyProp.value.callee && bodyProp.value.callee.name === 'JSON.stringify') {
-                const dataObjectNode = bodyProp.value.arguments[0];
-
-                // This is a simplified analysis assuming the object is defined inline.
-                // A more robust solution would trace variables back to their definition.
-                if (dataObjectNode.type === 'ObjectExpression') {
-                  schemaFields = {};
-                  dataObjectNode.properties.forEach(prop => {
-                    const key = prop.key.name;
-                    const valueNode = prop.value;
-                    
-                    // Infer Mongoose schema type based on the value's literal type
-                    if (valueNode.type === 'StringLiteral') {
-                      schemaFields[key] = 'String';
-                    } else if (valueNode.type === 'NumericLiteral') {
-                      schemaFields[key] = 'Number';
-                    } else if (valueNode.type === 'BooleanLiteral') {
-                      schemaFields[key] = 'Boolean';
-                    } else {
-                      // Default to String if the type is complex or a variable
-                      schemaFields[key] = 'String'; 
-                    }
-                  });
+            // body schema for POST/PUT/PATCH
+            if (['POST', 'PUT', 'PATCH'].includes(method)) {
+              const bodyProp = optionsNode.properties.find(
+                p => p.type === 'ObjectProperty' && p.key.type === 'Identifier' && p.key.name === 'body'
+              );
+
+              if (bodyProp) {
+                const v = bodyProp.value;
+
+                if (
+                  v.type === 'CallExpression' &&
+                  v.callee.type === 'MemberExpression' &&
+                  v.callee.object.type === 'Identifier' &&
+                  v.callee.object.name === 'JSON' &&
+                  v.callee.property.type === 'Identifier' &&
+                  v.callee.property.name === 'stringify'
+                ) {
+                  const arg0 = v.arguments[0];
+
+                  if (arg0?.type === 'ObjectExpression') {
+                    schemaFields = extractObjectSchema(arg0);
+                  } else if (arg0?.type === 'Identifier') {
+                    const init = resolveIdentifierToInit(callPath, arg0.name);
+                    if (init?.type === 'ObjectExpression') schemaFields = extractObjectSchema(init);
+                  }
                 }
               }
             }
           }
+        }
 
-          // Generate a clean controller name (e.g., /api/user-orders -> UserOrders)
-          const controllerName = toTitleCase(urlValue.split('/')[2]);
-          const key = `${method}:${urlValue}`;
-
-          // Avoid adding duplicate endpoints
-          if (!endpoints.has(key)) {
-            endpoints.set(key, { 
-              path: urlValue, 
-              method, 
-              controllerName, 
-              schemaFields // This will be null for GET/DELETE, and an object for POST/PUT
-            });
+        // ---- axios-like client ----
+        if (axiosMethod) {
+          method = axiosMethod;
+          urlValue = getUrlValue(node.arguments[0]);
+
+          if (['POST', 'PUT', 'PATCH'].includes(method)) {
+            const dataArg = node.arguments[1];
+            if (dataArg?.type === 'ObjectExpression') {
+              schemaFields = extractObjectSchema(dataArg);
+            } else if (dataArg?.type === 'Identifier') {
+              const init = resolveIdentifierToInit(callPath, dataArg.name);
+              if (init?.type === 'ObjectExpression') schemaFields = extractObjectSchema(init);
+            }
           }
-        },
-      });
-    } catch (e) { 
-      // Ignore files that babel can't parse (e.g., CSS-in-JS files)
-    }
+        }
+
+        // accept only URLs that contain /api/
+        const apiPath = extractApiPath(urlValue);
+        if (!apiPath) return;
+
+        const route = normalizeRouteForBackend(apiPath.split('?')[0]);
+        const controllerName = deriveControllerNameFromUrl(apiPath);
+        const actionName = deriveActionName(method, route);
+
+        const key = `${method}:${route}`;
+        if (!endpoints.has(key)) {
+          endpoints.set(key, {
+            path: apiPath,
+            route,
+            method,
+            controllerName,
+            actionName,
+            pathParams: extractPathParams(route),
+            queryParams: extractQueryParamsFromUrl(apiPath),
+            schemaFields,
+            requestBody: schemaFields ? { fields: schemaFields } : null,
+            sourceFile: file
+          });
+        }
+      }
+    });
   }
 
-  // Return all found endpoints as an array
   return Array.from(endpoints.values());
 }
 
-module.exports = { analyzeFrontend };
+module.exports = { analyzeFrontend };

package/src/db/prisma.ts

@@ -0,0 +1,4 @@
+// Auto-generated by create-backlist
+import { PrismaClient } from '@prisma/client';
+
+export const prisma = new PrismaClient();