@mgamil/mapx 0.2.4

package/dist/frameworks/detectors/fastapi.js

@@ -0,0 +1,203 @@
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { existsSync } from "node:fs";
+class FastAPIDetector {
+  name = "fastapi";
+  language = "python";
+  filePattern = /\.py$/;
+  routerPrefixes = /* @__PURE__ */ new Map();
+  // router variable -> prefix
+  async detect(projectRoot, files) {
+    let isFastAPI = false;
+    for (const file of ["requirements.txt", "Pipfile", "pyproject.toml"]) {
+      const filePath = join(projectRoot, file);
+      if (existsSync(filePath)) {
+        try {
+          const content = await readFile(filePath, "utf-8");
+          if (content.toLowerCase().includes("fastapi")) {
+            isFastAPI = true;
+          }
+        } catch {
+        }
+      }
+    }
+    if (!isFastAPI) {
+      isFastAPI = files.some((f) => f.endsWith("main.py"));
+    }
+    if (isFastAPI) {
+      for (const file of files) {
+        if (!file.endsWith(".py")) continue;
+        try {
+          const content = await readFile(join(projectRoot, file), "utf-8");
+          const routerDefRegex = /(\w+)\s*=\s*APIRouter\s*\(\s*(?:prefix\s*=\s*)?['"]([^'"]+)['"]/g;
+          let match;
+          while ((match = routerDefRegex.exec(content)) !== null) {
+            const varName = match[1];
+            const prefix = match[2];
+            this.routerPrefixes.set(varName, prefix);
+          }
+          const routerIncRegex = /include_router\s*\(\s*([^,\s)]+)(?:,\s*prefix\s*=\s*['"]([^'"]+)['"])?/g;
+          while ((match = routerIncRegex.exec(content)) !== null) {
+            const routerVar = match[1].split(".").pop() || "";
+            const prefix = match[2];
+            if (prefix) {
+              this.routerPrefixes.set(routerVar, prefix);
+            }
+          }
+        } catch {
+        }
+      }
+    }
+    return isFastAPI;
+  }
+  async extractRoutes(filePath, content, ctx) {
+    const routes = [];
+    if (!content.includes("@") || !content.includes(".")) {
+      return [];
+    }
+    let index = 0;
+    while (true) {
+      const match = content.substring(index).match(/@(\w+)\.(get|post|put|delete|patch|options|head|trace)\s*\(/);
+      if (!match) break;
+      const targetVar = match[1];
+      const method = match[2].toUpperCase();
+      const startOfParen = index + match.index + match[0].length - 1;
+      const paren = getParenthesizedContent(content, startOfParen);
+      if (!paren) {
+        index = startOfParen + 1;
+        continue;
+      }
+      const args = parseArgs(paren.content);
+      const routePath = args[0] || "";
+      const postDecoratorText = content.substring(paren.endIndex);
+      const funcMatch = postDecoratorText.match(/^\s*(?:def|async def)\s+(\w+)\s*\(/);
+      if (funcMatch) {
+        const funcName = funcMatch[1];
+        const routerPrefix = this.routerPrefixes.get(targetVar) || "";
+        const cleanPrefix = routerPrefix.replace(/^\/|\/$/g, "");
+        const cleanRoute = routePath.replace(/^\/|\/$/g, "");
+        const fullPath = "/" + [cleanPrefix, cleanRoute].filter(Boolean).join("/");
+        let resolvedFile = filePath;
+        const resolvedPath = ctx.resolveSymbolToFile(funcName);
+        if (resolvedPath) {
+          resolvedFile = resolvedPath;
+        }
+        routes.push({
+          framework: this.name,
+          method,
+          path: fullPath,
+          handlerFile: resolvedFile,
+          handlerSymbol: funcName,
+          metadata: {
+            confidence: "inferred"
+          }
+        });
+      }
+      index = paren.endIndex;
+    }
+    return routes;
+  }
+}
+function getParenthesizedContent(str, startIndex) {
+  let depth = 0;
+  let inString = false;
+  let stringChar = "";
+  let escape = false;
+  for (let i = startIndex; i < str.length; i++) {
+    const char = str[i];
+    if (escape) {
+      escape = false;
+      continue;
+    }
+    if (char === "\\") {
+      escape = true;
+      continue;
+    }
+    if (inString) {
+      if (char === stringChar) {
+        inString = false;
+      }
+      continue;
+    }
+    if (char === "'" || char === '"') {
+      inString = true;
+      stringChar = char;
+      continue;
+    }
+    if (char === "(") {
+      depth++;
+      if (depth === 1) {
+        startIndex = i + 1;
+      }
+    } else if (char === ")") {
+      depth--;
+      if (depth === 0) {
+        return {
+          content: str.substring(startIndex, i),
+          endIndex: i + 1
+        };
+      }
+    }
+  }
+  return null;
+}
+function parseArgs(argsStr) {
+  const args = [];
+  let current = "";
+  let depth = 0;
+  let bracketDepth = 0;
+  let inString = false;
+  let stringChar = "";
+  let escape = false;
+  for (let i = 0; i < argsStr.length; i++) {
+    const char = argsStr[i];
+    if (escape) {
+      escape = false;
+      current += char;
+      continue;
+    }
+    if (char === "\\") {
+      escape = true;
+      current += char;
+      continue;
+    }
+    if (inString) {
+      if (char === stringChar) {
+        inString = false;
+      }
+      current += char;
+      continue;
+    }
+    if (char === "'" || char === '"') {
+      inString = true;
+      stringChar = char;
+      current += char;
+      continue;
+    }
+    if (char === "(") {
+      depth++;
+    } else if (char === ")") {
+      depth--;
+    } else if (char === "[") {
+      bracketDepth++;
+    } else if (char === "]") {
+      bracketDepth--;
+    }
+    if (char === "," && depth === 0 && bracketDepth === 0) {
+      args.push(cleanQuotes(current.trim()));
+      current = "";
+    } else {
+      current += char;
+    }
+  }
+  if (current.trim()) {
+    args.push(cleanQuotes(current.trim()));
+  }
+  return args;
+}
+function cleanQuotes(str) {
+  return str.replace(/^['"]|['"]$/g, "");
+}
+export {
+  FastAPIDetector
+};

package/dist/frameworks/detectors/flask.d.ts

@@ -0,0 +1,12 @@
+import { FrameworkDetector, ScanContext, RouteBinding } from '../../types.js';
+
+declare class FlaskDetector implements FrameworkDetector {
+    readonly name = "flask";
+    readonly language = "python";
+    readonly filePattern: RegExp;
+    private bpPrefixes;
+    detect(projectRoot: string, files: string[]): Promise<boolean>;
+    extractRoutes(filePath: string, content: string, ctx: ScanContext): Promise<RouteBinding[]>;
+}
+
+export { FlaskDetector };

package/dist/frameworks/detectors/flask.js

@@ -0,0 +1,244 @@
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { existsSync } from "node:fs";
+class FlaskDetector {
+  name = "flask";
+  language = "python";
+  filePattern = /\.py$/;
+  bpPrefixes = /* @__PURE__ */ new Map();
+  // blueprint variable/name -> prefix
+  async detect(projectRoot, files) {
+    let isFlask = false;
+    for (const file of ["requirements.txt", "Pipfile", "pyproject.toml"]) {
+      const filePath = join(projectRoot, file);
+      if (existsSync(filePath)) {
+        try {
+          const content = await readFile(filePath, "utf-8");
+          if (content.toLowerCase().includes("flask")) {
+            isFlask = true;
+          }
+        } catch {
+        }
+      }
+    }
+    if (!isFlask) {
+      isFlask = files.some((f) => f.endsWith("wsgi.py") || f.endsWith("app.py"));
+    }
+    if (isFlask) {
+      for (const file of files) {
+        if (!file.endsWith(".py")) continue;
+        try {
+          const content = await readFile(join(projectRoot, file), "utf-8");
+          const bpDefRegex = /(\w+)\s*=\s*Blueprint\s*\(\s*['"]([^'"]+)['"]\s*,\s*__name__(?:,\s*url_prefix\s*=\s*['"]([^'"]+)['"])?/g;
+          let match;
+          while ((match = bpDefRegex.exec(content)) !== null) {
+            const varName = match[1];
+            const prefix = match[3] || "";
+            this.bpPrefixes.set(varName, prefix);
+          }
+          const bpRegRegex = /register_blueprint\s*\(\s*([^,\s)]+)(?:,\s*url_prefix\s*=\s*['"]([^'"]+)['"])?/g;
+          while ((match = bpRegRegex.exec(content)) !== null) {
+            const bpVar = match[1].split(".").pop() || "";
+            const prefix = match[2];
+            if (prefix) {
+              this.bpPrefixes.set(bpVar, prefix);
+            }
+          }
+        } catch {
+        }
+      }
+    }
+    return isFlask;
+  }
+  async extractRoutes(filePath, content, ctx) {
+    const routes = [];
+    if (!content.includes(".route") && !content.includes("add_resource") && !content.includes("Route")) {
+      return [];
+    }
+    let index = 0;
+    while (true) {
+      const match = content.substring(index).match(/@(\w+)\.route\s*\(/);
+      if (!match) break;
+      const targetVar = match[1];
+      const startOfParen = index + match.index + match[0].length - 1;
+      const paren = getParenthesizedContent(content, startOfParen);
+      if (!paren) {
+        index = startOfParen + 1;
+        continue;
+      }
+      const args = parseArgs(paren.content);
+      const routePath = args[0] || "";
+      let methods = ["GET"];
+      const methodsMatch = paren.content.match(/methods\s*=\s*\[([^\]]+)\]/);
+      if (methodsMatch) {
+        methods = (methodsMatch[1].match(/['"]([^'"]+)['"]/g) || []).map((m) => m.replace(/['"]/g, "").toUpperCase());
+      }
+      const postDecoratorText = content.substring(paren.endIndex);
+      const funcMatch = postDecoratorText.match(/^\s*(?:def|async def)\s+(\w+)\s*\(/);
+      if (funcMatch) {
+        const funcName = funcMatch[1];
+        const bpPrefix = this.bpPrefixes.get(targetVar) || "";
+        const cleanPrefix = bpPrefix.replace(/^\/|\/$/g, "");
+        const cleanRoute = routePath.replace(/^\/|\/$/g, "");
+        const fullPath = "/" + [cleanPrefix, cleanRoute].filter(Boolean).join("/");
+        let resolvedFile = filePath;
+        const resolvedPath = ctx.resolveSymbolToFile(funcName);
+        if (resolvedPath) {
+          resolvedFile = resolvedPath;
+        }
+        for (const method of methods) {
+          routes.push({
+            framework: this.name,
+            method,
+            path: fullPath,
+            handlerFile: resolvedFile,
+            handlerSymbol: funcName,
+            metadata: {
+              confidence: "inferred"
+            }
+          });
+        }
+      }
+      index = paren.endIndex;
+    }
+    const restxRegex = /@(\w+)\.route\s*\(\s*['"]([^'"]+)['"]\s*\)\s*class\s+(\w+)/g;
+    let restxMatch;
+    while ((restxMatch = restxRegex.exec(content)) !== null) {
+      const routePath = restxMatch[2];
+      const className = restxMatch[3];
+      const classStart = content.indexOf(`class ${className}`);
+      let classEnd = content.length;
+      const classSlice = content.substring(classStart);
+      const nextClassMatch = classSlice.substring(className.length).match(/\bclass\s+\w+/);
+      if (nextClassMatch && nextClassMatch.index) {
+        classEnd = classStart + className.length + nextClassMatch.index;
+      }
+      const classBlock = content.substring(classStart, classEnd);
+      const methodRegex = /\bdef\s+(get|post|put|delete|patch|options|head)\s*\(\s*self\b/g;
+      let methodMatch;
+      let resolvedFile = filePath;
+      const resolvedPath = ctx.resolveSymbolToFile(className);
+      if (resolvedPath) {
+        resolvedFile = resolvedPath;
+      }
+      while ((methodMatch = methodRegex.exec(classBlock)) !== null) {
+        const httpMethod = methodMatch[1].toUpperCase();
+        routes.push({
+          framework: this.name,
+          method: httpMethod,
+          path: routePath,
+          handlerFile: resolvedFile,
+          handlerSymbol: `${className}.${methodMatch[1]}`,
+          metadata: {
+            confidence: "inferred",
+            resourceType: "flask_restx_resource"
+          }
+        });
+      }
+    }
+    return routes;
+  }
+}
+function getParenthesizedContent(str, startIndex) {
+  let depth = 0;
+  let inString = false;
+  let stringChar = "";
+  let escape = false;
+  for (let i = startIndex; i < str.length; i++) {
+    const char = str[i];
+    if (escape) {
+      escape = false;
+      continue;
+    }
+    if (char === "\\") {
+      escape = true;
+      continue;
+    }
+    if (inString) {
+      if (char === stringChar) {
+        inString = false;
+      }
+      continue;
+    }
+    if (char === "'" || char === '"') {
+      inString = true;
+      stringChar = char;
+      continue;
+    }
+    if (char === "(") {
+      depth++;
+      if (depth === 1) {
+        startIndex = i + 1;
+      }
+    } else if (char === ")") {
+      depth--;
+      if (depth === 0) {
+        return {
+          content: str.substring(startIndex, i),
+          endIndex: i + 1
+        };
+      }
+    }
+  }
+  return null;
+}
+function parseArgs(argsStr) {
+  const args = [];
+  let current = "";
+  let depth = 0;
+  let bracketDepth = 0;
+  let inString = false;
+  let stringChar = "";
+  let escape = false;
+  for (let i = 0; i < argsStr.length; i++) {
+    const char = argsStr[i];
+    if (escape) {
+      escape = false;
+      current += char;
+      continue;
+    }
+    if (char === "\\") {
+      escape = true;
+      current += char;
+      continue;
+    }
+    if (inString) {
+      if (char === stringChar) {
+        inString = false;
+      }
+      current += char;
+      continue;
+    }
+    if (char === "'" || char === '"') {
+      inString = true;
+      stringChar = char;
+      current += char;
+      continue;
+    }
+    if (char === "(") {
+      depth++;
+    } else if (char === ")") {
+      depth--;
+    } else if (char === "[") {
+      bracketDepth++;
+    } else if (char === "]") {
+      bracketDepth--;
+    }
+    if (char === "," && depth === 0 && bracketDepth === 0) {
+      args.push(cleanQuotes(current.trim()));
+      current = "";
+    } else {
+      current += char;
+    }
+  }
+  if (current.trim()) {
+    args.push(cleanQuotes(current.trim()));
+  }
+  return args;
+}
+function cleanQuotes(str) {
+  return str.replace(/^['"]|['"]$/g, "");
+}
+export {
+  FlaskDetector
+};

package/dist/frameworks/detectors/go.d.ts

@@ -0,0 +1,11 @@
+import { FrameworkDetector, ScanContext, RouteBinding } from '../../types.js';
+
+declare class GoDetector implements FrameworkDetector {
+    readonly name = "go-web";
+    readonly language = "go";
+    readonly filePattern: RegExp;
+    detect(projectRoot: string, files: string[]): Promise<boolean>;
+    extractRoutes(filePath: string, content: string, ctx: ScanContext): Promise<RouteBinding[]>;
+}
+
+export { GoDetector };

package/dist/frameworks/detectors/go.js

@@ -0,0 +1,75 @@
+import { join } from "node:path";
+import { existsSync } from "node:fs";
+class GoDetector {
+  name = "go-web";
+  language = "go";
+  filePattern = /\.go$/;
+  async detect(projectRoot, files) {
+    const modPath = join(projectRoot, "go.mod");
+    return existsSync(modPath) || files.some((f) => f.endsWith(".go"));
+  }
+  async extractRoutes(filePath, content, ctx) {
+    const routes = [];
+    const verbRegex = /\b[a-zA-Z0-9_]+\.(GET|POST|PUT|DELETE|PATCH|OPTIONS|HEAD|Get|Post|Put|Delete|Patch|Options|Head)\s*\(\s*['"]([^'"]+)['"]\s*,\s*([a-zA-Z0-9_.]+)/g;
+    let match;
+    while ((match = verbRegex.exec(content)) !== null) {
+      const verb = match[1].toUpperCase();
+      const pathVal = match[2];
+      const handlerSymbol = match[3];
+      let resolvedFile = filePath;
+      const resolvedPath = ctx.resolveSymbolToFile(handlerSymbol);
+      if (resolvedPath) {
+        resolvedFile = resolvedPath;
+      }
+      routes.push({
+        framework: this.name,
+        method: verb,
+        path: pathVal,
+        handlerFile: resolvedFile,
+        handlerSymbol,
+        metadata: {
+          confidence: "inferred",
+          routeType: "server"
+        }
+      });
+    }
+    const muxRegex = /\b[a-zA-Z0-9_]+\.HandleFunc\s*\(\s*['"]([^'"]+)['"]\s*,\s*([a-zA-Z0-9_.]+)\s*\)(?:\.Methods\s*\(\s*([^)]+)\s*\))?/g;
+    while ((match = muxRegex.exec(content)) !== null) {
+      const pathVal = match[1];
+      const handlerSymbol = match[2];
+      const methodsStr = match[3];
+      let resolvedFile = filePath;
+      const resolvedPath = ctx.resolveSymbolToFile(handlerSymbol);
+      if (resolvedPath) {
+        resolvedFile = resolvedPath;
+      }
+      const verbs = [];
+      if (methodsStr) {
+        const verbMatches = methodsStr.match(/['"]([A-Z]+)['"]/g);
+        if (verbMatches) {
+          verbs.push(...verbMatches.map((v) => v.replace(/['"]/g, "")));
+        }
+      }
+      if (verbs.length === 0) {
+        verbs.push("ALL");
+      }
+      for (const verb of verbs) {
+        routes.push({
+          framework: this.name,
+          method: verb,
+          path: pathVal,
+          handlerFile: resolvedFile,
+          handlerSymbol,
+          metadata: {
+            confidence: "inferred",
+            routeType: "server"
+          }
+        });
+      }
+    }
+    return routes;
+  }
+}
+export {
+  GoDetector
+};

package/dist/frameworks/detectors/laravel.d.ts

@@ -0,0 +1,11 @@
+import { FrameworkDetector, ScanContext, RouteBinding } from '../../types.js';
+
+declare class LaravelDetector implements FrameworkDetector {
+    readonly name = "laravel";
+    readonly language = "php";
+    readonly filePattern: RegExp;
+    detect(projectRoot: string, files: string[]): Promise<boolean>;
+    extractRoutes(filePath: string, content: string, ctx: ScanContext): Promise<RouteBinding[]>;
+}
+
+export { LaravelDetector };