create-backlist 6.0.6 → 6.0.7

package/bin/backlist.js

@@ -1,130 +1,132 @@
 #!/usr/bin/env node
+/* eslint-disable @typescript-eslint/no-var-requires */
 
-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 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');
+// FIX: repo has utils.js at root
+const { isCommandAvailable } = require("../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 { 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');
+const { scanFrontend, writeContracts } = require("../src/scanner");
 
 function resolveOptionsFromFlags(flags) {
   return {
-    projectName: flags.projectName || 'backend',
-    srcPath: flags.srcPath || 'src',
-    stack: flags.stack || 'node-ts-express',
+    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'),
+    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':
+    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');
+    case "dotnet-webapi":
+      if (!(await isCommandAvailable("dotnet"))) {
+        throw new Error(".NET SDK is not installed. Install: 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.');
+    case "java-spring":
+      if (!(await isCommandAvailable("java"))) {
+        throw new Error("Java (JDK 17+) is not installed. 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.');
+    case "python-fastapi":
+      if (!(await isCommandAvailable("python"))) {
+        throw new Error("Python is not installed. Please install Python (3.8+) and pip.");
       }
       await generatePythonProject({ ...options, contracts });
       break;
 
     default:
-      throw new Error(`The selected stack '${options.stack}' is not supported yet.`);
+      throw new Error(`Unsupported stack '${options.stack}'.`);
   }
 }
 
 async function interactiveMain() {
-  console.log(chalk.cyan.bold('Welcome to Backlist! The Polyglot Backend Generator.'));
+  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: "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:',
+      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' },
+        { 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: "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:',
+      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' },
+        { name: "NoSQL (MongoDB with Mongoose)", value: "mongoose" },
+        { name: "SQL (PostgreSQL/MySQL with Prisma)", value: "prisma" },
       ],
-      when: (answers) => answers.stack === 'node-ts-express'
+      when: (a) => a.stack === "node-ts-express",
     },
     {
-      type: 'confirm',
-      name: 'addAuth',
-      message: 'Add JWT authentication boilerplate?',
+      type: "confirm",
+      name: "addAuth",
+      message: "Add JWT authentication boilerplate?",
       default: true,
-      when: (answers) => answers.stack === 'node-ts-express'
+      when: (a) => a.stack === "node-ts-express",
     },
     {
-      type: 'confirm',
-      name: 'addSeeder',
-      message: 'Add a database seeder with sample data?',
+      type: "confirm",
+      name: "addSeeder",
+      message: "Add a database seeder with sample data?",
       default: true,
-      when: (answers) => answers.stack === 'node-ts-express' && answers.addAuth
+      when: (a) => a.stack === "node-ts-express" && a.addAuth,
     },
     {
-      type: 'checkbox',
-      name: 'extraFeatures',
-      message: 'Select additional features for Node.js:',
+      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 },
+        { name: "Docker Support", 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'
-    }
+      when: (a) => a.stack === "node-ts-express",
+    },
   ]);
 
   const options = {
@@ -139,16 +141,15 @@ async function interactiveMain() {
     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.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(chalk.red.bold("\nAn error occurred during generation:"));
     console.error(error);
 
     if (fs.existsSync(options.projectDir)) {
-      console.log(chalk.yellow('  -> Cleaning up failed installation...'));
+      console.log(chalk.yellow("  -> Cleaning up failed installation..."));
       fs.removeSync(options.projectDir);
     }
     process.exit(1);
@@ -158,15 +159,13 @@ async function interactiveMain() {
 async function main() {
   const program = new Command();
 
+  program.name("backlist").description("Backlist CLI").version("5.1.0");
+
   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')
+    .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);
@@ -175,28 +174,31 @@ async function main() {
       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')
+  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.'));
+      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')
+  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 });
@@ -208,11 +210,10 @@ async function main() {
       };
 
       await run();
-      watcher.on('add', run).on('change', run).on('unlink', 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;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-backlist",
-  "version": "6.0.6",
+  "version": "6.0.7",
   "description": "An advanced, multi-language backend generator based on frontend analysis.",
   "type": "commonjs",
   "bin": {

package/src/analyzer.js

@@ -8,9 +8,6 @@ const traverse = require("@babel/traverse").default;
 
 const HTTP_METHODS = new Set(["get", "post", "put", "patch", "delete"]);
 
-// -------------------------
-// Small utils
-// -------------------------
 function normalizeSlashes(p) {
   return String(p || "").replace(/\\/g, "/");
 }
@@ -23,9 +20,6 @@ function readJSONSafe(p) {
   }
 }
 
-// -------------------------
-// AUTH detection (for addAuth)
-// -------------------------
 function findAuthUsageInRepo(rootDir) {
   const pkgPath = path.join(rootDir, "package.json");
   const pkg = readJSONSafe(pkgPath) || {};
@@ -57,35 +51,26 @@ function findAuthUsageInRepo(rootDir) {
     "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/**",
-      ],
+      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 {
-        // ignore read errors
-      }
+      } catch {}
     }
   }
 
   return false;
 }
 
-// -------------------------
-// Helper functions for frontend API scan
-// -------------------------
 function toTitleCase(str) {
   if (!str) return "Default";
   return String(str)
@@ -126,9 +111,7 @@ function deriveControllerNameFromUrl(urlValue) {
   let seg = null;
   if (apiIndex >= 0) {
     seg = parts[apiIndex + 1] || null;
-    if (seg && /^v\d+$/i.test(seg)) {
-      seg = parts[apiIndex + 2] || seg;
-    }
+    if (seg && /^v\d+$/i.test(seg)) seg = parts[apiIndex + 2] || seg;
   } else {
     seg = parts[0] || null;
   }
@@ -141,9 +124,6 @@ function deriveActionName(method, route) {
   return `${String(method).toLowerCase()}${toTitleCase(last)}`;
 }
 
-// -------------------------
-// Axios/Fetch detection
-// -------------------------
 function detectAxiosLikeMethod(node) {
   if (!node.callee || node.callee.type !== "MemberExpression") return null;
   const prop = node.callee.property;
@@ -172,16 +152,19 @@ function getUrlValue(urlNode) {
   return null;
 }
 
-// -------------------------
-// Extract request schema (simple)
 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";
+    case "StringLiteral":
+      return "String";
+    case "NumericLiteral":
+      return "Number";
+    case "BooleanLiteral":
+      return "Boolean";
+    case "NullLiteral":
+      return "String";
+    default:
+      return "String";
   }
 }
 
@@ -190,7 +173,13 @@ function extractObjectSchema(objExpr) {
   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.value;
+    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;
@@ -209,9 +198,6 @@ function resolveIdentifierToInit(pathObj, identifierName) {
   }
 }
 
-// -------------------------
-// Main frontend scanner
-// -------------------------
 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`);
@@ -224,13 +210,23 @@ async function analyzeFrontend(srcPath) {
 
   for (const file of files) {
     let code;
-    try { code = await fs.readFile(file, "utf-8"); } catch { continue; }
+    try {
+      code = await fs.readFile(file, "utf-8");
+    } catch {
+      continue;
+    }
+
     let ast;
-    try { ast = parser.parse(code, { sourceType: "module", plugins: ["jsx","typescript"] }); } catch { continue; }
+    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;
@@ -242,19 +238,33 @@ async function analyzeFrontend(srcPath) {
         if (isFetch) {
           urlValue = getUrlValue(node.arguments[0]);
           const optionsNode = node.arguments[1];
+
           if (optionsNode?.type === "ObjectExpression") {
-            const mProp = optionsNode.properties.find(p => 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.key?.name==="body");
+            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"
+              );
+
               if (bProp) {
                 const v = bProp.value;
-                if (v.type==="CallExpression" && v.callee.object?.name==="JSON" && v.callee.property?.name==="stringify") {
+                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") {
+                  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);
+                    if (init?.type === "ObjectExpression") schemaFields = extractObjectSchema(init);
                   }
                 }
               }
@@ -265,12 +275,13 @@ async function analyzeFrontend(srcPath) {
         if (axiosMethod) {
           method = axiosMethod;
           urlValue = getUrlValue(node.arguments[0]);
-          if (["POST","PUT","PATCH"].includes(method)) {
+
+          if (["POST", "PUT", "PATCH"].includes(method)) {
             const dataArg = node.arguments[1];
-            if (dataArg?.type==="ObjectExpression") schemaFields = extractObjectSchema(dataArg);
-            else if (dataArg?.type==="Identifier") {
+            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);
+              if (init?.type === "ObjectExpression") schemaFields = extractObjectSchema(init);
             }
           }
         }
@@ -292,37 +303,34 @@ async function analyzeFrontend(srcPath) {
             actionName,
             pathParams: extractPathParams(route),
             queryParams: extractQueryParamsFromUrl(apiPath),
+            schemaFields,
             requestBody: schemaFields ? { fields: schemaFields } : null,
             sourceFile: normalizeSlashes(file),
           });
         }
-      }
+      },
     });
   }
 
   return Array.from(endpoints.values());
 }
 
-// -------------------------
-// Main analyze() for CLI
-// -------------------------
 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));
+    .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: findAuthUsageInRepo(rootDir),
-    addAuth: findAuthUsageInRepo(rootDir),
-    endpoints
+    hasAuth,
+    addAuth: hasAuth,
+    endpoints,
   };
 }
 
-module.exports = {
-  analyze,
-  analyzeFrontend
-};
+module.exports = { analyze, analyzeFrontend };

package/src/utils.js

@@ -1,27 +1,24 @@
-const { execa } = require('execa');
+/* eslint-disable @typescript-eslint/no-var-requires */
+const { execa } = require("execa");
 
 const VERSION_ARGS = {
-  java: ['-version'],
-  python: ['--version'],
-  python3: ['--version'],
-  node: ['--version'],
-  npm: ['--version'],
-  dotnet: ['--version'],
-  mvn: ['-v'],
-  git: ['--version'],
+  java: ["-version"],
+  python: ["--version"],
+  python3: ["--version"],
+  node: ["--version"],
+  npm: ["--version"],
+  dotnet: ["--version"],
+  mvn: ["-v"],
+  git: ["--version"],
 };
 
 async function isCommandAvailable(command) {
-  const args = VERSION_ARGS[command] || ['--version'];
-
+  const args = VERSION_ARGS[command] || ["--version"];
   try {
-    // Reject false only if spawn fails (ENOENT). Non-zero exit still counts as "available".
     await execa(command, args, { reject: false });
     return true;
   } catch (err) {
-    // If command not found, execa throws with code 'ENOENT'
-    if (err && err.code === 'ENOENT') return false;
-    // Other unexpected errors: treat as not available
+    if (err && err.code === "ENOENT") return false;
     return false;
   }
 }