create-backlist 7.3.0 → 7.3.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-backlist",
-  "version": "7.3.0",
+  "version": "7.3.1",
   "description": "An advanced, multi-language backend generator based on frontend analysis. Smart Freemium SaaS CLI.",
   "type": "module",
   "bin": {

package/src/analyzer.js

@@ -8,6 +8,12 @@ const traverse = _traverse.default || _traverse;
 
 const HTTP_METHODS = new Set(["get", "post", "put", "patch", "delete"]);
 
+const STATIC_ASSET_EXTENSIONS = new Set([
+  ".png", ".jpg", ".jpeg", ".gif", ".svg", ".webp", ".ico",
+  ".css", ".scss", ".less", ".woff", ".woff2", ".ttf", ".eot",
+  ".mp3", ".mp4", ".webm", ".pdf",
+]);
+
 // -------------------------
 // Utils
 // -------------------------
@@ -28,14 +34,43 @@ function normalizeRouteForBackend(urlValue) {
   return String(urlValue || "").replace(/\{(\w+)\}/g, ":$1");
 }
 
-function extractApiPath(urlValue) {
-  // supports:
-  // - /api/...
-  // - http://localhost:5000/api/...
+function extractApiPath(urlValue, envMap = new Map()) {
   if (!urlValue) return null;
+
+  // 1. Original behavior: if URL contains /api/, extract from there
   const idx = urlValue.indexOf("/api/");
-  if (idx === -1) return null;
-  return urlValue.slice(idx); // => /api/...
+  if (idx !== -1) return urlValue.slice(idx);
+
+  // 2. Resolve env variable placeholders left by getUrlValue
+  let resolved = urlValue;
+  const envPattern = /\{(NEXT_PUBLIC_|REACT_APP_|VITE_)[^}]+\}/g;
+  resolved = resolved.replace(envPattern, (match) => {
+    const varName = match.slice(1, -1);
+    return envMap.get(varName) || "";
+  });
+
+  // Re-check after resolution
+  const idx2 = resolved.indexOf("/api/");
+  if (idx2 !== -1) return resolved.slice(idx2);
+
+  // 3. If resolved URL starts with http(s), extract the path portion
+  if (/^https?:\/\//.test(resolved)) {
+    try {
+      const url = new URL(resolved);
+      const pathname = url.pathname;
+      if (pathname && pathname !== "/") return pathname;
+    } catch {}
+  }
+
+  // 4. If it's a relative path starting with /, accept it
+  if (resolved.startsWith("/") && resolved.length > 1) {
+    // Filter out static assets
+    const ext = path.extname(resolved.split("?")[0]).toLowerCase();
+    if (STATIC_ASSET_EXTENSIONS.has(ext)) return null;
+    return resolved;
+  }
+
+  return null;
 }
 
 function extractPathParams(route) {
@@ -89,26 +124,80 @@ function deriveActionName(method, route) {
 // -------------------------
 // URL extraction
 // -------------------------
-function getUrlValue(urlNode) {
+function extractEnvVarName(node) {
+  // process.env.NEXT_PUBLIC_API_URL
+  if (
+    node.type === "MemberExpression" &&
+    node.object?.type === "MemberExpression" &&
+    node.object.object?.type === "Identifier" &&
+    node.object.object.name === "process" &&
+    node.object.property?.name === "env" &&
+    node.property?.type === "Identifier"
+  ) {
+    return node.property.name;
+  }
+  // import.meta.env.VITE_API_URL
+  if (
+    node.type === "MemberExpression" &&
+    node.object?.type === "MemberExpression" &&
+    node.object.object?.type === "MetaProperty" &&
+    node.object.property?.name === "env" &&
+    node.property?.type === "Identifier"
+  ) {
+    return node.property.name;
+  }
+  return null;
+}
+
+function getUrlValue(urlNode, envMap = new Map()) {
   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}}`;
+        if (exprs[i].type === "Identifier") {
+          out += `{${exprs[i].name}}`;
+        } else if (exprs[i].type === "MemberExpression") {
+          const envName = extractEnvVarName(exprs[i]);
+          if (envName && envMap.has(envName)) {
+            out += envMap.get(envName);
+          } else if (envName) {
+            out += `{${envName}}`;
+          } else {
+            out += `{param${i + 1}}`;
+          }
+        } else {
+          out += `{param${i + 1}}`;
+        }
       }
     }
     return out;
   }
 
+  // Handle string concatenation: baseUrl + "/users"
+  if (urlNode.type === "BinaryExpression" && urlNode.operator === "+") {
+    const left = getUrlValue(urlNode.left, envMap);
+    const right = getUrlValue(urlNode.right, envMap);
+    if (left || right) return (left || "") + (right || "");
+  }
+
+  // Handle process.env.X / import.meta.env.X directly as URL
+  if (urlNode.type === "MemberExpression") {
+    const envName = extractEnvVarName(urlNode);
+    if (envName && envMap.has(envName)) {
+      return envMap.get(envName);
+    }
+    if (envName) {
+      return `{${envName}}`;
+    }
+  }
+
   return null;
 }
 
@@ -343,19 +432,29 @@ function generateSeedsFromModels(models, perModel = 3) {
 // -------------------------
 // MAIN frontend analyzer
 // -------------------------
-export async function analyzeFrontend(srcPath) {
+export async function analyzeFrontend(srcPath, options = {}) {
   if (!srcPath) throw new Error("analyzeFrontend: srcPath is required");
   if (!fs.existsSync(srcPath)) {
     throw new Error(`The source directory '${srcPath}' does not exist.`);
   }
+  return analyzeFrontendMulti([srcPath], options);
+}
 
-  const files = await glob(`${normalizeSlashes(srcPath)}/**/*.{js,ts,jsx,tsx}`, {
-    ignore: ["**/node_modules/**", "**/dist/**", "**/build/**", "**/.next/**", "**/coverage/**"],
-  });
+export async function analyzeFrontendMulti(scanDirs, options = {}) {
+  const { envMap = new Map() } = options;
+
+  const allFiles = new Set();
+  for (const dir of scanDirs) {
+    if (!fs.existsSync(dir)) continue;
+    const files = await glob(`${normalizeSlashes(dir)}/**/*.{js,ts,jsx,tsx}`, {
+      ignore: ["**/node_modules/**", "**/dist/**", "**/build/**", "**/.next/**", "**/coverage/**"],
+    });
+    files.forEach((f) => allFiles.add(path.resolve(f)));
+  }
 
   const endpoints = new Map();
 
-  for (const file of files) {
+  for (const file of allFiles) {
     let code;
     try {
       code = await fs.readFile(file, "utf-8");
@@ -383,9 +482,8 @@ export async function analyzeFrontend(srcPath) {
         let method = "GET";
         let schemaFields = null;
 
-        // ---- fetch(url, options) ----
         if (isFetch) {
-          urlValue = getUrlValue(node.arguments[0]);
+          urlValue = getUrlValue(node.arguments[0], envMap);
           const optionsNode = node.arguments[1];
 
           if (optionsNode && optionsNode.type === "ObjectExpression") {
@@ -425,10 +523,9 @@ export async function analyzeFrontend(srcPath) {
           }
         }
 
-        // ---- axios-like client ----
         if (axiosMethod) {
           method = axiosMethod;
-          urlValue = getUrlValue(node.arguments[0]);
+          urlValue = getUrlValue(node.arguments[0], envMap);
 
           if (["POST", "PUT", "PATCH"].includes(method)) {
             const dataArg = node.arguments[1];
@@ -441,8 +538,7 @@ export async function analyzeFrontend(srcPath) {
           }
         }
 
-        // accept only URLs that contain /api/ anywhere
-        const apiPath = extractApiPath(urlValue);
+        const apiPath = extractApiPath(urlValue, envMap);
         if (!apiPath) return;
 
         const route = normalizeRouteForBackend(apiPath.split("?")[0]);
@@ -501,6 +597,110 @@ export async function analyze(projectRoot = process.cwd()) {
   };
 }
 
+// -------------------------
+// Next.js API Route Detection
+// -------------------------
+const NEXTJS_HTTP_EXPORTS = new Set(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"]);
+
+export async function detectNextjsApiRoutes(apiRouteDirs) {
+  const routes = [];
+
+  for (const dir of apiRouteDirs) {
+    if (!fs.existsSync(dir)) continue;
+
+    // App Router: app/**/route.{ts,js}
+    const appRouterFiles = await glob(
+      `${normalizeSlashes(dir)}/**/route.{ts,js,tsx,jsx}`,
+      { ignore: ["**/node_modules/**"] }
+    );
+
+    for (const file of appRouterFiles) {
+      const relativePath = path.relative(dir, path.dirname(file));
+      let routePath = "/" + relativePath
+        .replace(/\\/g, "/")
+        .replace(/\(([^)]+)\)\//g, "")
+        .replace(/\[\.\.\.([^\]]+)\]/g, ":$1")
+        .replace(/\[([^\]]+)\]/g, ":$1");
+
+      if (routePath === "/.") routePath = "/";
+
+      const methods = await extractExportedHttpMethods(file);
+      for (const method of methods) {
+        routes.push({
+          route: routePath,
+          method,
+          controllerName: deriveControllerNameFromUrl(routePath),
+          sourceFile: normalizeSlashes(file),
+          isServerRoute: true,
+        });
+      }
+    }
+
+    // Pages Router: pages/api/**/*.{ts,js}
+    const pagesApiDir = path.join(dir, "api");
+    if (fs.existsSync(pagesApiDir)) {
+      const pagesApiFiles = await glob(
+        `${normalizeSlashes(pagesApiDir)}/**/*.{ts,js,tsx,jsx}`,
+        { ignore: ["**/node_modules/**"] }
+      );
+
+      for (const file of pagesApiFiles) {
+        const relativePath = path.relative(pagesApiDir, file);
+        let routePath = "/api/" + relativePath
+          .replace(/\\/g, "/")
+          .replace(/\.(ts|js|tsx|jsx)$/, "")
+          .replace(/\/index$/, "")
+          .replace(/\[\.\.\.([^\]]+)\]/g, ":$1")
+          .replace(/\[([^\]]+)\]/g, ":$1");
+
+        routes.push({
+          route: routePath,
+          method: "ALL",
+          controllerName: deriveControllerNameFromUrl(routePath),
+          sourceFile: normalizeSlashes(file),
+          isServerRoute: true,
+        });
+      }
+    }
+  }
+
+  return routes;
+}
+
+async function extractExportedHttpMethods(file) {
+  const methods = [];
+  try {
+    const code = await fs.readFile(file, "utf-8");
+    const ast = parser.parse(code, {
+      sourceType: "module",
+      plugins: ["jsx", "typescript"],
+    });
+
+    traverse(ast, {
+      ExportNamedDeclaration(nodePath) {
+        const decl = nodePath.node.declaration;
+        if (!decl) return;
+
+        if (decl.type === "FunctionDeclaration" && decl.id) {
+          const name = decl.id.name;
+          if (NEXTJS_HTTP_EXPORTS.has(name)) methods.push(name);
+        }
+
+        if (decl.type === "VariableDeclaration") {
+          for (const declarator of decl.declarations) {
+            if (declarator.id?.type === "Identifier") {
+              const name = declarator.id.name;
+              if (NEXTJS_HTTP_EXPORTS.has(name)) methods.push(name);
+            }
+          }
+        }
+      },
+    });
+  } catch {}
+
+  return methods.length > 0 ? methods : ["GET"];
+}
+
 // -------------------------
 // NEW v7.0: Low-Cost Path Scanner (Standard Tier)
 // -------------------------

package/src/env-resolver.js

@@ -0,0 +1,70 @@
+import fs from "fs-extra";
+import path from "node:path";
+
+const ENV_FILES = [
+  ".env.local",
+  ".env.development",
+  ".env.development.local",
+  ".env",
+];
+
+const API_URL_PATTERNS = [
+  "API_URL",
+  "API_BASE_URL",
+  "API_BASE",
+  "BASE_URL",
+  "BACKEND_URL",
+  "SERVER_URL",
+];
+
+export async function parseEnvFiles(projectRoot) {
+  const envMap = new Map();
+
+  for (const envFile of ENV_FILES) {
+    const filePath = path.join(projectRoot, envFile);
+    if (!(await fs.pathExists(filePath))) continue;
+
+    let content;
+    try {
+      content = await fs.readFile(filePath, "utf-8");
+    } catch {
+      continue;
+    }
+
+    for (const line of content.split("\n")) {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith("#")) continue;
+
+      const eqIndex = trimmed.indexOf("=");
+      if (eqIndex === -1) continue;
+
+      const key = trimmed.slice(0, eqIndex).trim();
+      let value = trimmed.slice(eqIndex + 1).trim();
+
+      if (
+        (value.startsWith('"') && value.endsWith('"')) ||
+        (value.startsWith("'") && value.endsWith("'"))
+      ) {
+        value = value.slice(1, -1);
+      }
+
+      if (key && value && !envMap.has(key)) {
+        envMap.set(key, value);
+      }
+    }
+  }
+
+  return envMap;
+}
+
+export function extractBaseUrlFromEnv(envMap) {
+  for (const [key, value] of envMap) {
+    const upperKey = key.toUpperCase();
+    for (const pattern of API_URL_PATTERNS) {
+      if (upperKey.includes(pattern) && value.startsWith("http")) {
+        return value.replace(/\/$/, "");
+      }
+    }
+  }
+  return null;
+}

package/src/project-detector.js

@@ -0,0 +1,131 @@
+import fs from "fs-extra";
+import path from "node:path";
+
+const NEXTJS_SCAN_DIRS = [
+  "app",
+  "pages",
+  "src",
+  "components",
+  "lib",
+  "hooks",
+  "services",
+  "utils",
+  "features",
+  "modules",
+];
+
+const REACT_SCAN_DIRS = ["src"];
+
+export async function detectProjectType(projectRoot) {
+  const result = {
+    type: "unknown",
+    scanDirs: [],
+    apiRouteDirs: [],
+    framework: "unknown",
+  };
+
+  const pkgPath = path.join(projectRoot, "package.json");
+  let pkg = null;
+  if (await fs.pathExists(pkgPath)) {
+    try {
+      pkg = await fs.readJson(pkgPath);
+    } catch {}
+  }
+
+  const deps = pkg
+    ? { ...(pkg.dependencies || {}), ...(pkg.devDependencies || {}) }
+    : {};
+
+  const hasNext = !!deps.next || (await hasNextConfig(projectRoot));
+  const hasReact = !!deps.react;
+  const hasVite = !!deps.vite;
+
+  const hasAppDir = await fs.pathExists(path.join(projectRoot, "app"));
+  const hasPagesDir = await fs.pathExists(path.join(projectRoot, "pages"));
+  const hasSrcApp = await fs.pathExists(path.join(projectRoot, "src", "app"));
+  const hasSrcPages = await fs.pathExists(
+    path.join(projectRoot, "src", "pages")
+  );
+
+  if (hasNext) {
+    result.framework = "next";
+
+    if ((hasAppDir || hasSrcApp) && (hasPagesDir || hasSrcPages)) {
+      result.type = "nextjs-hybrid";
+    } else if (hasAppDir || hasSrcApp) {
+      result.type = "nextjs-app";
+    } else if (hasPagesDir || hasSrcPages) {
+      result.type = "nextjs-pages";
+    } else {
+      result.type = "nextjs-app";
+    }
+
+    const candidateDirs = [...NEXTJS_SCAN_DIRS];
+    for (const dir of candidateDirs) {
+      const abs = path.join(projectRoot, dir);
+      if (await fs.pathExists(abs)) {
+        result.scanDirs.push(abs);
+      }
+      const srcNested = path.join(projectRoot, "src", dir);
+      if (dir !== "src" && (await fs.pathExists(srcNested))) {
+        result.scanDirs.push(srcNested);
+      }
+    }
+
+    if (hasAppDir) {
+      const appApiDir = path.join(projectRoot, "app", "api");
+      if (await fs.pathExists(appApiDir)) result.apiRouteDirs.push(appApiDir);
+      result.apiRouteDirs.push(path.join(projectRoot, "app"));
+    }
+    if (hasSrcApp) {
+      const srcAppApiDir = path.join(projectRoot, "src", "app", "api");
+      if (await fs.pathExists(srcAppApiDir))
+        result.apiRouteDirs.push(srcAppApiDir);
+      result.apiRouteDirs.push(path.join(projectRoot, "src", "app"));
+    }
+    if (hasPagesDir) {
+      const pagesApiDir = path.join(projectRoot, "pages", "api");
+      if (await fs.pathExists(pagesApiDir))
+        result.apiRouteDirs.push(pagesApiDir);
+    }
+    if (hasSrcPages) {
+      const srcPagesApiDir = path.join(projectRoot, "src", "pages", "api");
+      if (await fs.pathExists(srcPagesApiDir))
+        result.apiRouteDirs.push(srcPagesApiDir);
+    }
+  } else if (hasReact) {
+    result.framework = hasVite ? "vite" : "react";
+    result.type = hasVite ? "vite-react" : "react";
+
+    for (const dir of REACT_SCAN_DIRS) {
+      const abs = path.join(projectRoot, dir);
+      if (await fs.pathExists(abs)) {
+        result.scanDirs.push(abs);
+      }
+    }
+  }
+
+  if (result.scanDirs.length === 0) {
+    const fallback = path.join(projectRoot, "src");
+    if (await fs.pathExists(fallback)) {
+      result.scanDirs.push(fallback);
+    }
+  }
+
+  result.scanDirs = [...new Set(result.scanDirs)];
+  result.apiRouteDirs = [...new Set(result.apiRouteDirs)];
+
+  return result;
+}
+
+async function hasNextConfig(projectRoot) {
+  const configs = [
+    "next.config.js",
+    "next.config.mjs",
+    "next.config.ts",
+  ];
+  for (const cfg of configs) {
+    if (await fs.pathExists(path.join(projectRoot, cfg))) return true;
+  }
+  return false;
+}