create-backlist 6.0.2 → 6.0.3

package/package.json

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

package/src/analyzer.js

@@ -3,19 +3,17 @@ const { glob } = require('glob');
 const parser = require('@babel/parser');
 const traverse = require('@babel/traverse').default;
 
-/**
- * Convert segment -> ControllerName (Users -> Users, user-orders -> UserOrders)
- */
+const HTTP_METHODS = new Set(['get', 'post', 'put', 'patch', 'delete']);
+
 function toTitleCase(str) {
   if (!str) return 'Default';
   return String(str)
-    .replace(/[-_]+(\w)/g, (_, c) => c.toUpperCase()) // kebab/snake to camel
+    .replace(/[-_]+(\w)/g, (_, c) => c.toUpperCase())
     .replace(/^\w/, c => c.toUpperCase())
     .replace(/[^a-zA-Z0-9]/g, '');
 }
 
 function normalizeRouteForBackend(urlValue) {
-  // Convert template placeholders {id} -> :id
   return urlValue.replace(/\{(\w+)\}/g, ':$1');
 }
 
@@ -43,26 +41,19 @@ function extractObjectSchema(objExpr) {
       null;
 
     if (!key) continue;
-
     schemaFields[key] = inferTypeFromNode(prop.value);
   }
   return schemaFields;
 }
 
-/**
- * Try to resolve Identifier -> its init value if it's const payload = {...}
- */
 function resolveIdentifierToInit(path, identifierName) {
   try {
     const binding = path.scope.getBinding(identifierName);
     if (!binding) return null;
-    const declPath = binding.path; // VariableDeclarator path usually
+    const declPath = binding.path;
     if (!declPath || !declPath.node) return null;
 
-    // VariableDeclarator: id = init
-    if (declPath.node.type === 'VariableDeclarator') {
-      return declPath.node.init || null;
-    }
+    if (declPath.node.type === 'VariableDeclarator') return declPath.node.init || null;
     return null;
   } catch {
     return null;
@@ -75,7 +66,7 @@ function getUrlValue(urlNode) {
   if (urlNode.type === 'StringLiteral') return urlNode.value;
 
   if (urlNode.type === 'TemplateLiteral') {
-    // `/api/users/${id}` -> `/api/users/{id}`
+    // `/api/users/${id}` -> `/api/users/{id}` or `{param1}`
     const quasis = urlNode.quasis || [];
     const exprs = urlNode.expressions || [];
     let out = '';
@@ -83,7 +74,7 @@ function getUrlValue(urlNode) {
       out += quasis[i].value.raw;
       if (exprs[i]) {
         if (exprs[i].type === 'Identifier') out += `{${exprs[i].name}}`;
-        else out += `{param}`;
+        else out += `{param${i + 1}}`;
       }
     }
     return out;
@@ -92,34 +83,52 @@ function getUrlValue(urlNode) {
   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) {
-  // supports: /api/users, /api/v1/users, /api/admin/users
-  const parts = urlValue.split('/').filter(Boolean); // ["api","v1","users"]
+  const apiPath = extractApiPath(urlValue) || urlValue;
+  const parts = String(apiPath).split('/').filter(Boolean); // ["api","v1","products"]
   const apiIndex = parts.indexOf('api');
-  const seg = (apiIndex >= 0 && parts.length > apiIndex + 1)
-    ? parts[apiIndex + 1]
-    : parts[0];
+
+  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) {
-  // method + last segment heuristic
-  const cleaned = route.replace(/^\/api\//, '/').replace(/[/:{}-]/g, ' ');
+  const cleaned = String(route).replace(/^\/api\//, '/').replace(/[/:{}-]/g, ' ');
   const last = cleaned.trim().split(/\s+/).filter(Boolean).pop() || 'Action';
-  return `${method.toLowerCase()}${toTitleCase(last)}`;
+  return `${String(method).toLowerCase()}${toTitleCase(last)}`;
 }
 
 function extractPathParams(route) {
   const params = [];
-  const re = /[:{]([a-zA-Z0-9_]+)[}]/g; // matches :id or {id}
+  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) {
-  // if url has ?a=b&c=d as string literal
   try {
     const qIndex = urlValue.indexOf('?');
     if (qIndex === -1) return [];
@@ -130,12 +139,28 @@ function extractQueryParamsFromUrl(urlValue) {
   }
 }
 
+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();
+}
+
 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/**', '**/dist/**', '**/build/**'] });
+  const files = await glob(`${srcPath}/**/*.{js,ts,jsx,tsx}`, {
+    ignore: ['**/node_modules/**', '**/dist/**', '**/build/**', '**/.next/**']
+  });
+
   const endpoints = new Map();
 
   for (const file of files) {
@@ -152,58 +177,64 @@ async function analyzeFrontend(srcPath) {
       CallExpression(callPath) {
         const node = callPath.node;
 
-        // --- Detect fetch(url, options) ---
         const isFetch = node.callee.type === 'Identifier' && node.callee.name === 'fetch';
+        const axiosMethod = detectAxiosLikeMethod(node);
 
-        // --- Detect axios.<method>(url, data?, config?) ---
-        const isAxiosMethod =
-          node.callee.type === 'MemberExpression' &&
-          node.callee.object.type === 'Identifier' &&
-          node.callee.object.name === 'axios' &&
-          node.callee.property.type === 'Identifier';
-
-        if (!isFetch && !isAxiosMethod) return;
+        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') {
-            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();
-
-            const bodyProp = optionsNode.properties.find(p => p.type === 'ObjectProperty' && p.key.type === 'Identifier' && p.key.name === 'body');
-
-            if (bodyProp) {
-              // body: JSON.stringify(objOrVar)
-              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);
+            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();
+            }
+
+            // 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);
+                  }
                 }
               }
             }
           }
         }
 
-        if (isAxiosMethod) {
-          method = node.callee.property.name.toUpperCase();
+        // ---- axios-like client ----
+        if (axiosMethod) {
+          method = axiosMethod;
           urlValue = getUrlValue(node.arguments[0]);
 
-          // axios.post(url, data)
           if (['POST', 'PUT', 'PATCH'].includes(method)) {
             const dataArg = node.arguments[1];
             if (dataArg?.type === 'ObjectExpression') {
@@ -215,32 +246,34 @@ async function analyzeFrontend(srcPath) {
           }
         }
 
-        if (!urlValue || !urlValue.startsWith('/api/')) return;
+        // accept only URLs that contain /api/
+        const apiPath = extractApiPath(urlValue);
+        if (!apiPath) return;
 
-        const route = normalizeRouteForBackend(urlValue.split('?')[0]); // drop query string
-        const controllerName = deriveControllerNameFromUrl(urlValue);
+        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: urlValue,
-            route,              // normalized for backend: /api/users/:id
+            path: apiPath,
+            route,
             method,
             controllerName,
             actionName,
             pathParams: extractPathParams(route),
-            queryParams: extractQueryParamsFromUrl(urlValue),
-            schemaFields,       // backward compat (your generators use this)
+            queryParams: extractQueryParamsFromUrl(apiPath),
+            schemaFields,
             requestBody: schemaFields ? { fields: schemaFields } : null,
             sourceFile: file
           });
         }
-      },
+      }
     });
   }
 
   return Array.from(endpoints.values());
 }
 
-module.exports = { analyzeFrontend };
+module.exports = { analyzeFrontend };