create-backlist 6.0.7 → 6.0.8

package/bin/index.js

@@ -0,0 +1,141 @@
+#!/usr/bin/env node
+
+const inquirer = require('inquirer');
+const chalk = require('chalk');
+const fs = require('fs-extra');
+const path = require('path'); // FIX: Correctly require the 'path' module
+const { isCommandAvailable } = require('../src/utils');
+
+// Import ALL generators
+const { generateNodeProject } = require('../src/generators/node');
+const { generateDotnetProject } = require('../src/generators/dotnet');
+const { generateJavaProject } = require('../src/generators/java');
+const { generatePythonProject } = require('../src/generators/python');
+
+async function main() {
+  console.log(chalk.cyan.bold('🚀 Welcome to Backlist! The Polyglot Backend Generator.'));
+  
+  const answers = await inquirer.prompt([
+    // --- General Questions ---
+    {
+      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',
+    },
+
+    // --- Node.js Specific Questions ---
+    {
+      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,
+      // Seeder only makes sense if there's an auth/user model to seed
+      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),
+  };
+
+  try {
+    console.log(chalk.blue(`\n✨ Starting backend generation for: ${chalk.bold(options.stack)}`));
+
+    // --- Dispatcher Logic for ALL Stacks ---
+    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;
+
+      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); 
+        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);
+        break;
+
+      default:
+        throw new Error(`The selected stack '${options.stack}' is not supported yet.`);
+    }
+
+    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 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);
+  }
+}
+
+main();

package/package.json

@@ -1,16 +1,14 @@
 {
   "name": "create-backlist",
-  "version": "6.0.7",
+  "version": "6.0.8",
   "description": "An advanced, multi-language backend generator based on frontend analysis.",
   "type": "commonjs",
   "bin": {
-    "create-backlist": "bin/index.js",
-    "backlist": "bin/index.js"
+    "create-backlist": "bin/index.js"
   },
   "files": [
     "bin",
-    "src",
-    "templates"
+    "src"
   ],
   "scripts": {
     "start": "node bin/index.js"
@@ -22,15 +20,11 @@
     "@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

@@ -1,336 +1,125 @@
-/* eslint-disable @typescript-eslint/no-var-requires */
-const fs = require("fs-extra");
-const path = require("path");
-const { glob } = require("glob");
-
-const parser = require("@babel/parser");
-const traverse = require("@babel/traverse").default;
-
-const HTTP_METHODS = new Set(["get", "post", "put", "patch", "delete"]);
-
-function normalizeSlashes(p) {
-  return String(p || "").replace(/\\/g, "/");
-}
-
-function readJSONSafe(p) {
-  try {
-    return fs.readJsonSync(p);
-  } catch {
-    return null;
-  }
-}
-
-function findAuthUsageInRepo(rootDir) {
-  const pkgPath = path.join(rootDir, "package.json");
-  const pkg = readJSONSafe(pkgPath) || {};
-  const deps = { ...(pkg.dependencies || {}), ...(pkg.devDependencies || {}) };
-
-  const authDeps = [
-    "next-auth",
-    "@auth/core",
-    "@clerk/nextjs",
-    "@supabase/auth-helpers-nextjs",
-    "@supabase/supabase-js",
-    "firebase",
-    "lucia",
-  ];
-
-  if (authDeps.some((d) => deps[d])) return true;
-
-  const scanDirs = ["src", "app", "pages", "components", "lib", "utils"]
-    .map((d) => path.join(rootDir, d))
-    .filter((d) => fs.existsSync(d));
-
-  const patterns = [
-    "next-auth",
-    "getServerSession",
-    "useSession",
-    "SessionProvider",
-    "@clerk/nextjs",
-    "ClerkProvider",
-    "auth()",
-    "currentUser",
-    "createServerClient",
-    "jwt",
-    "bearer",
-  ];
-
-  for (const dir of scanDirs) {
-    const files = glob.sync(`${normalizeSlashes(dir)}/**/*.{js,ts,jsx,tsx}`, {
-      ignore: ["**/node_modules/**", "**/dist/**", "**/build/**", "**/.next/**", "**/coverage/**"],
-    });
-
-    for (const f of files) {
-      try {
-        const content = fs.readFileSync(f, "utf8");
-        if (patterns.some((p) => content.includes(p))) return true;
-      } catch {}
-    }
-  }
-
-  return false;
-}
-
+const fs = require('fs-extra');
+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.
+ */
 function toTitleCase(str) {
-  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 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 deriveControllerNameFromUrl(urlValue) {
-  const parts = String(urlValue || "").split("/").filter(Boolean);
-  const apiIndex = parts.indexOf("api");
-  let seg = null;
-  if (apiIndex >= 0) {
-    seg = parts[apiIndex + 1] || null;
-    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 detectAxiosLikeMethod(node) {
-  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();
-}
-
-function getUrlValue(urlNode) {
-  if (!urlNode) return null;
-  if (urlNode.type === "StringLiteral") return urlNode.value;
-  if (urlNode.type === "TemplateLiteral") {
-    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 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 schema = {};
-  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;
-    schema[key] = inferTypeFromNode(prop.value);
-  }
-  return schema;
-}
-
-function resolveIdentifierToInit(pathObj, identifierName) {
-  try {
-    const binding = pathObj.scope.getBinding(identifierName);
-    if (!binding) return null;
-    const decl = binding.path.node;
-    if (!decl) return null;
-    if (decl.type === "VariableDeclarator") return decl.init || null;
-    return null;
-  } catch {
-    return null;
-  }
+    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, '');
 }
 
+/**
+ * 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 (!srcPath) throw new Error("analyzeFrontend: srcPath is required");
-  if (!fs.existsSync(srcPath)) throw new Error(`Source dir '${srcPath}' does not exist`);
-
-  const files = await glob(`${normalizeSlashes(srcPath)}/**/*.{js,ts,jsx,tsx}`, {
-    ignore: ["**/node_modules/**", "**/dist/**", "**/build/**", "**/.next/**", "**/coverage/**"],
-  });
+  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) {
-    let code;
+    const code = await fs.readFile(file, 'utf-8');
     try {
-      code = await fs.readFile(file, "utf-8");
-    } catch {
-      continue;
-    }
-
-    let ast;
-    try {
-      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;
-
-        if (isFetch) {
-          urlValue = getUrlValue(node.arguments[0]);
-          const optionsNode = node.arguments[1];
-
-          if (optionsNode?.type === "ObjectExpression") {
-            const mProp = optionsNode.properties.find(
-              (p) => p.type === "ObjectProperty" && p.key?.type === "Identifier" && p.key.name === "method"
-            );
-            if (mProp?.value?.type === "StringLiteral") method = mProp.value.value.toUpperCase();
-
-            if (["POST", "PUT", "PATCH"].includes(method)) {
-              const bProp = optionsNode.properties.find(
-                (p) => p.type === "ObjectProperty" && p.key?.type === "Identifier" && p.key.name === "body"
-              );
+      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];
+          if (optionsNode && optionsNode.type === 'ObjectExpression') {
+            // Find the HTTP method
+            const methodProp = optionsNode.properties.find(p => p.key.name === 'method');
+            if (methodProp && methodProp.value.type === 'StringLiteral') {
+              method = methodProp.value.value.toUpperCase();
+            }
 
-              if (bProp) {
-                const v = bProp.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);
-                  }
+            // --- 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'; 
+                    }
+                  });
                 }
               }
             }
           }
-        }
-
-        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);
-            }
+          // 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
+            });
           }
-        }
-
-        const apiPath = urlValue?.includes("/api/") ? urlValue.slice(urlValue.indexOf("/api/")) : null;
-        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: normalizeSlashes(file),
-          });
-        }
-      },
-    });
+        },
+      });
+    } catch (e) { 
+      // Ignore files that babel can't parse (e.g., CSS-in-JS files)
+    }
   }
 
+  // Return all found endpoints as an array
   return Array.from(endpoints.values());
 }
 
-async function analyze(projectRoot = process.cwd()) {
-  const rootDir = path.resolve(projectRoot);
-
-  const frontendSrc = ["src", "app", "pages"]
-    .map((d) => path.join(rootDir, d))
-    .find((d) => fs.existsSync(d));
-
-  const endpoints = frontendSrc ? await analyzeFrontend(frontendSrc) : [];
-  const hasAuth = findAuthUsageInRepo(rootDir);
-
-  return {
-    rootDir: normalizeSlashes(rootDir),
-    hasAuth,
-    addAuth: hasAuth,
-    endpoints,
-  };
-}
-
-module.exports = { analyze, analyzeFrontend };
+module.exports = { analyzeFrontend };