create-backlist 6.0.4 → 6.0.6

package/package.json

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

package/src/analyzer.js

@@ -27,7 +27,6 @@ function readJSONSafe(p) {
 // AUTH detection (for addAuth)
 // -------------------------
 function findAuthUsageInRepo(rootDir) {
-  // 1) package.json quick check
   const pkgPath = path.join(rootDir, "package.json");
   const pkg = readJSONSafe(pkgPath) || {};
   const deps = { ...(pkg.dependencies || {}), ...(pkg.devDependencies || {}) };
@@ -44,7 +43,6 @@ function findAuthUsageInRepo(rootDir) {
 
   if (authDeps.some((d) => deps[d])) return true;
 
-  // 2) Source scan for common auth identifiers
   const scanDirs = ["src", "app", "pages", "components", "lib", "utils"]
     .map((d) => path.join(rootDir, d))
     .filter((d) => fs.existsSync(d));
@@ -86,7 +84,7 @@ function findAuthUsageInRepo(rootDir) {
 }
 
 // -------------------------
-// Frontend API call analyzer (your code)
+// Helper functions for frontend API scan
 // -------------------------
 function toTitleCase(str) {
   if (!str) return "Default";
@@ -100,61 +98,64 @@ 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 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 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;
+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 [];
+  }
+}
 
-    if (!key) continue;
-    schemaFields[key] = inferTypeFromNode(prop.value);
+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 schemaFields;
+  return toTitleCase(seg);
 }
 
-function resolveIdentifierToInit(pathObj, identifierName) {
-  try {
-    const binding = pathObj.scope.getBinding(identifierName);
-    if (!binding) return null;
-    const declPath = binding.path;
-    if (!declPath || !declPath.node) return null;
+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)}`;
+}
 
-    if (declPath.node.type === "VariableDeclarator") return declPath.node.init || null;
-    return null;
-  } catch {
-    return null;
-  }
+// -------------------------
+// Axios/Fetch detection
+// -------------------------
+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 || [];
@@ -168,81 +169,52 @@ function getUrlValue(urlNode) {
     }
     return out;
   }
-
   return null;
 }
 
-function extractApiPath(urlValue) {
-  if (!urlValue) return null;
-  const idx = urlValue.indexOf("/api/");
-  if (idx === -1) return null;
-  return urlValue.slice(idx);
-}
-
-function deriveControllerNameFromUrl(urlValue) {
-  const apiPath = extractApiPath(urlValue) || urlValue;
-  const parts = String(apiPath).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;
+// -------------------------
+// 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";
   }
-
-  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 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.value;
+    schema[key] = inferTypeFromNode(prop.value);
+  }
+  return schema;
 }
 
-function extractQueryParamsFromUrl(urlValue) {
+function resolveIdentifierToInit(pathObj, identifierName) {
   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);
+    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 [];
+    return null;
   }
 }
 
-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();
-}
-
+// -------------------------
+// Main frontend scanner
+// -------------------------
 async function analyzeFrontend(srcPath) {
   if (!srcPath) throw new Error("analyzeFrontend: srcPath is required");
-  if (!fs.existsSync(srcPath)) {
-    throw new Error(`The source directory '${srcPath}' does not exist.`);
-  }
+  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/**"],
@@ -252,26 +224,15 @@ 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;
 
         let urlValue = null;
@@ -281,44 +242,19 @@ async function analyzeFrontend(srcPath) {
         if (isFetch) {
           urlValue = getUrlValue(node.arguments[0]);
           const optionsNode = node.arguments[1];
-
-          if (optionsNode && optionsNode.type === "ObjectExpression") {
-            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();
-            }
-
-            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"
-                ) {
+          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");
+              if (bProp) {
+                const v = bProp.value;
+                if (v.type==="CallExpression" && v.callee.object?.name==="JSON" && 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);
                   }
                 }
               }
@@ -329,26 +265,24 @@ 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);
             }
           }
         }
 
-        const apiPath = extractApiPath(urlValue);
+        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,
@@ -358,12 +292,11 @@ async function analyzeFrontend(srcPath) {
             actionName,
             pathParams: extractPathParams(route),
             queryParams: extractQueryParamsFromUrl(apiPath),
-            schemaFields,
             requestBody: schemaFields ? { fields: schemaFields } : null,
             sourceFile: normalizeSlashes(file),
           });
         }
-      },
+      }
     });
   }
 
@@ -371,20 +304,25 @@ async function analyzeFrontend(srcPath) {
 }
 
 // -------------------------
-// Main analyze() exported for CLI
+// Main analyze() for CLI
 // -------------------------
-function analyze(projectRoot = process.cwd()) {
+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) : [];
 
   return {
     rootDir: normalizeSlashes(rootDir),
     hasAuth: findAuthUsageInRepo(rootDir),
-    // If CLI expects addAuth directly, keep both:
     addAuth: findAuthUsageInRepo(rootDir),
+    endpoints
   };
 }
 
 module.exports = {
   analyze,
-  analyzeFrontend,
-};
+  analyzeFrontend
+};

package/src/scanner/analyzeFrontend.js

@@ -0,0 +1,146 @@
+/* eslint-disable @typescript-eslint/no-var-requires */
+const fs = require("fs-extra");
+const path = require("path");
+
+/**
+ * Normalize paths (Windows → Unix style)
+ */
+function normalizeSlashes(p) {
+  return String(p || "").replace(/\\/g, "/");
+}
+
+/**
+ * Detect auth usage in entire repo
+ * (basic heuristic – good enough for competition demo)
+ */
+function findAuthUsageInRepo(rootDir) {
+  const keywords = ["auth", "jwt", "token", "passport", "oauth"];
+  let found = false;
+
+  function walk(dir) {
+    if (found) return;
+
+    const files = fs.readdirSync(dir);
+    for (const file of files) {
+      const fullPath = path.join(dir, file);
+
+      if (fs.statSync(fullPath).isDirectory()) {
+        walk(fullPath);
+      } else if (file.endsWith(".js") || file.endsWith(".ts")) {
+        const content = fs.readFileSync(fullPath, "utf8").toLowerCase();
+        if (keywords.some(k => content.includes(k))) {
+          found = true;
+          return;
+        }
+      }
+    }
+  }
+
+  walk(rootDir);
+  return found;
+}
+
+/**
+ * Derive a controller name from URL
+ */
+function deriveControllerName(urlPath) {
+  if (!urlPath) return "Default";
+  const parts = urlPath.split("/").filter(Boolean);
+  const apiIndex = parts.indexOf("api");
+  if (apiIndex >= 0) return parts[apiIndex + 1] || "Default";
+  return parts[0] || "Default";
+}
+
+/**
+ * Derive an action name from method + URL
+ */
+function deriveActionName(method, urlPath) {
+  if (!urlPath) return `${method.toLowerCase()}Action`;
+  const cleaned = urlPath.replace(/^\/api\//, "/").replace(/[/:{}-]/g, " ");
+  const lastSegment = cleaned.trim().split(/\s+/).filter(Boolean).pop() || "Action";
+  return `${method.toLowerCase()}${lastSegment.charAt(0).toUpperCase()}${lastSegment.slice(1)}`;
+}
+
+/**
+ * Analyze frontend source to extract API endpoints
+ * (axios / fetch based – simple & safe)
+ */
+function analyzeFrontend(frontendDir) {
+  const endpoints = [];
+
+  function walk(dir) {
+    const files = fs.readdirSync(dir);
+
+    for (const file of files) {
+      const fullPath = path.join(dir, file);
+
+      if (fs.statSync(fullPath).isDirectory()) {
+        walk(fullPath);
+      } else if (
+        file.endsWith(".js") ||
+        file.endsWith(".ts") ||
+        file.endsWith(".jsx") ||
+        file.endsWith(".tsx")
+      ) {
+        const content = fs.readFileSync(fullPath, "utf8");
+
+        // --- axios ---
+        const axiosRegex = /axios\.(get|post|put|delete|patch)\(\s*['"`](.*?)['"`]/g;
+        let match;
+        while ((match = axiosRegex.exec(content)) !== null) {
+          const url = match[2].startsWith("/") ? match[2] : "/" + match[2];
+          const method = match[1].toUpperCase();
+          endpoints.push({
+            method,
+            path: url,
+            controllerName: deriveControllerName(url),
+            actionName: deriveActionName(method, url),
+            source: normalizeSlashes(fullPath)
+          });
+        }
+
+        // --- fetch ---
+        const fetchRegex = /fetch\(\s*['"`](.*?)['"`]/g;
+        while ((match = fetchRegex.exec(content)) !== null) {
+          const url = match[1].startsWith("/") ? match[1] : "/" + match[1];
+          const method = "GET";
+          endpoints.push({
+            method,
+            path: url,
+            controllerName: deriveControllerName(url),
+            actionName: deriveActionName(method, url),
+            source: normalizeSlashes(fullPath)
+          });
+        }
+      }
+    }
+  }
+
+  walk(frontendDir);
+  return endpoints;
+}
+
+/**
+ * MAIN analyzer function (used by CLI)
+ */
+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 ? analyzeFrontend(frontendSrc) : [];
+
+  return {
+    rootDir: normalizeSlashes(rootDir),
+    hasAuth: findAuthUsageInRepo(rootDir),
+    addAuth: findAuthUsageInRepo(rootDir),
+    endpoints
+  };
+}
+
+module.exports = {
+  analyze,
+  analyzeFrontend
+};

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

@@ -26,4 +26,4 @@ const PORT: number | string = process.env.PORT || 8000;
 
 app.listen(PORT, () => {
   console.log(`Server running on http://localhost:${PORT}`);
-});
+});