@mgamil/mapx 0.2.4

package/dist/frameworks/detectors/django.js

@@ -0,0 +1,135 @@
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { existsSync } from "node:fs";
+class DjangoDetector {
+  name = "django";
+  language = "python";
+  filePattern = /urls\.py$/;
+  projectFiles = [];
+  async detect(projectRoot, files) {
+    this.projectFiles = files;
+    const hasManagePy = files.some((f) => f.endsWith("manage.py"));
+    if (hasManagePy) return true;
+    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("django")) {
+            return true;
+          }
+        } catch {
+        }
+      }
+    }
+    return false;
+  }
+  async extractRoutes(filePath, content, ctx) {
+    const routes = [];
+    const visitedFiles = /* @__PURE__ */ new Set();
+    await this.parseUrlsFile(filePath, content, "", ctx, routes, visitedFiles);
+    return routes;
+  }
+  async parseUrlsFile(filePath, content, prefix, ctx, routes, visitedFiles) {
+    if (visitedFiles.has(filePath)) return;
+    visitedFiles.add(filePath);
+    const pathRegex = /\b(path|re_path|url)\s*\(\s*['"]([^'"]*)['"]\s*,\s*([^)]+)\)/g;
+    let match;
+    while ((match = pathRegex.exec(content)) !== null) {
+      const routePath = match[2];
+      const handlerStr = match[3].trim();
+      const cleanPrefix = prefix.replace(/^\/|\/$/g, "");
+      const cleanRoute = routePath.replace(/^\/|\/$/g, "");
+      const fullPath = "/" + [cleanPrefix, cleanRoute].filter(Boolean).join("/");
+      const includeMatch = handlerStr.match(/include\s*\(\s*['"]([^'"]+)['"]/);
+      if (includeMatch) {
+        const includedModule = includeMatch[1];
+        const resolvedPath = this.resolveModulePath(includedModule);
+        if (resolvedPath) {
+          const absResolvedPath = join(ctx.workspaceRoot, resolvedPath);
+          if (existsSync(absResolvedPath)) {
+            try {
+              const subContent = await readFile(absResolvedPath, "utf-8");
+              await this.parseUrlsFile(resolvedPath, subContent, fullPath, ctx, routes, visitedFiles);
+            } catch {
+            }
+          }
+        }
+      } else {
+        let handlerSymbol = handlerStr.split(",")[0].trim();
+        handlerSymbol = handlerSymbol.replace(/\.as_view\s*\([^)]*\)/, "");
+        let resolvedFile = filePath;
+        const resolvedPath = ctx.resolveSymbolToFile(handlerSymbol);
+        if (resolvedPath) {
+          resolvedFile = resolvedPath;
+        }
+        routes.push({
+          framework: this.name,
+          method: "GET",
+          // Django defaults to GET/any unless method-check decorators are used
+          path: fullPath,
+          handlerFile: resolvedFile,
+          handlerSymbol,
+          metadata: {
+            confidence: "inferred"
+          }
+        });
+      }
+    }
+    const routerRegex = /router\.register\s*\(\s*r?['"]([^'"]+)['"]\s*,\s*([a-zA-Z0-9_]+)/g;
+    while ((match = routerRegex.exec(content)) !== null) {
+      const routerPath = match[1];
+      const viewSetSymbol = match[2];
+      const cleanPrefix = prefix.replace(/^\/|\/$/g, "");
+      const cleanRoute = routerPath.replace(/^\/|\/$/g, "");
+      const fullPath = "/" + [cleanPrefix, cleanRoute].filter(Boolean).join("/");
+      let resolvedFile = filePath;
+      const resolvedPath = ctx.resolveSymbolToFile(viewSetSymbol);
+      if (resolvedPath) {
+        resolvedFile = resolvedPath;
+      }
+      const verbs = [
+        { method: "GET", suffix: "/", symbolSuffix: ".list" },
+        { method: "POST", suffix: "/", symbolSuffix: ".create" },
+        { method: "GET", suffix: "/{id}/", symbolSuffix: ".retrieve" },
+        { method: "PUT", suffix: "/{id}/", symbolSuffix: ".update" },
+        { method: "PATCH", suffix: "/{id}/", symbolSuffix: ".partial_update" },
+        { method: "DELETE", suffix: "/{id}/", symbolSuffix: ".destroy" }
+      ];
+      for (const v of verbs) {
+        const cleanSuffix = v.suffix.replace(/^\/|\/$/g, "");
+        const finalPath = "/" + [fullPath.replace(/^\/|\/$/g, ""), cleanSuffix].filter(Boolean).join("/");
+        routes.push({
+          framework: this.name,
+          method: v.method,
+          path: finalPath,
+          handlerFile: resolvedFile,
+          handlerSymbol: `${viewSetSymbol}${v.symbolSuffix}`,
+          metadata: {
+            confidence: "inferred",
+            resourceType: "drf_viewset"
+          }
+        });
+      }
+    }
+  }
+  resolveModulePath(moduleStr) {
+    const targetRelPath = moduleStr.replace(/\./g, "/") + ".py";
+    for (const f of this.projectFiles) {
+      if (f.endsWith(targetRelPath)) {
+        return f;
+      }
+    }
+    const parts = moduleStr.split(".");
+    const lastPart = parts[parts.length - 1] + ".py";
+    for (const f of this.projectFiles) {
+      if (f.endsWith(lastPart)) {
+        return f;
+      }
+    }
+    return null;
+  }
+}
+export {
+  DjangoDetector
+};

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

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

package/dist/frameworks/detectors/drupal.js

@@ -0,0 +1,94 @@
+import { join, basename } from "node:path";
+import { existsSync } from "node:fs";
+class DrupalDetector {
+  name = "drupal";
+  language = "php";
+  filePattern = /\.(yml|module|php)$/;
+  async detect(projectRoot, files) {
+    const corePath = join(projectRoot, "core/lib/Drupal.php");
+    if (existsSync(corePath)) return true;
+    const hasRoutingYml = files.some((f) => f.endsWith(".routing.yml"));
+    if (hasRoutingYml) return true;
+    return false;
+  }
+  async extractRoutes(filePath, content, ctx) {
+    const routes = [];
+    if (!filePath.endsWith(".routing.yml")) {
+      return [];
+    }
+    const lines = content.split("\n");
+    let currentRouteId = "";
+    let currentPath = "";
+    let currentController = "";
+    for (const line of lines) {
+      const routeMatch = line.match(/^([a-z0-9_.-]+):/);
+      if (routeMatch) {
+        if (currentPath && currentController) {
+          routes.push(this.createRouteBinding(currentPath, currentController, filePath, ctx));
+        }
+        currentRouteId = routeMatch[1];
+        currentPath = "";
+        currentController = "";
+        continue;
+      }
+      const pathMatch = line.match(/^\s+path:\s*['"]?([^'"]+)['"]?/);
+      if (pathMatch) {
+        currentPath = pathMatch[1];
+        continue;
+      }
+      const controllerMatch = line.match(/^\s+_(?:controller|form):\s*['"]?([^'"]+)['"]?/);
+      if (controllerMatch) {
+        currentController = controllerMatch[1];
+      }
+    }
+    if (currentPath && currentController) {
+      routes.push(this.createRouteBinding(currentPath, currentController, filePath, ctx));
+    }
+    return routes;
+  }
+  createRouteBinding(path, controller, filePath, ctx) {
+    const parts = controller.split("::");
+    const controllerClass = parts[0];
+    const controllerMethod = parts[1] || "default";
+    const symbol = controllerClass.split("\\").pop() || "Controller";
+    let resolvedFile = filePath;
+    const resolvedPath = ctx.resolveSymbolToFile(symbol);
+    if (resolvedPath) {
+      resolvedFile = resolvedPath;
+    }
+    return {
+      framework: this.name,
+      method: "ALL",
+      path,
+      handlerFile: resolvedFile,
+      handlerSymbol: `${symbol}::${controllerMethod}`,
+      metadata: {
+        confidence: "inferred",
+        routeType: "server"
+      }
+    };
+  }
+  async extractHooks(filePath, content, ctx) {
+    if (!filePath.endsWith(".module")) {
+      return [];
+    }
+    const hooks = [];
+    const moduleName = basename(filePath, ".module");
+    const functionRegex = new RegExp(`function\\s+(${moduleName})_([a-zA-Z0-9_]+)\\s*\\(`, "g");
+    let match;
+    while ((match = functionRegex.exec(content)) !== null) {
+      const hookName = match[2];
+      hooks.push({
+        framework: this.name,
+        hookName,
+        handlerFile: filePath,
+        handlerSymbol: `${moduleName}_${hookName}`,
+        hookType: "hook"
+      });
+    }
+    return hooks;
+  }
+}
+export {
+  DrupalDetector
+};

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

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

package/dist/frameworks/detectors/express.js

@@ -0,0 +1,234 @@
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { existsSync } from "node:fs";
+class ExpressDetector {
+  name = "express";
+  language = "typescript";
+  filePattern = /\.(js|ts)$/;
+  routerPrefixes = /* @__PURE__ */ new Map();
+  // router variable -> prefix
+  async detect(projectRoot, files) {
+    let isExpress = false;
+    const packageJsonPath = join(projectRoot, "package.json");
+    if (existsSync(packageJsonPath)) {
+      try {
+        const pkg = JSON.parse(await readFile(packageJsonPath, "utf-8"));
+        const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+        if (deps && deps.express) {
+          isExpress = true;
+        }
+      } catch {
+      }
+    }
+    if (isExpress) {
+      for (const file of files) {
+        if (!file.match(this.filePattern) || file.includes("node_modules")) continue;
+        try {
+          const content = await readFile(join(projectRoot, file), "utf-8");
+          const useRegex = /([a-zA-Z0-9_]+)\.use\s*\(\s*['"]([^'"]+)['"]\s*,\s*([a-zA-Z0-9_]+)\)/g;
+          let match;
+          while ((match = useRegex.exec(content)) !== null) {
+            const prefix = match[2];
+            const routerVar = match[3];
+            this.routerPrefixes.set(routerVar, prefix);
+          }
+        } catch {
+        }
+      }
+    }
+    return isExpress;
+  }
+  async extractRoutes(filePath, content, ctx) {
+    const routes = [];
+    if (!content.includes("express") && !content.includes("Router") && !content.includes(".get") && !content.includes(".post")) {
+      return [];
+    }
+    let index = 0;
+    while (true) {
+      const match = content.substring(index).match(/([a-zA-Z0-9_]+)\.(get|post|put|delete|patch|options|use)\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] || "";
+      if (args.length >= 2 && method !== "USE") {
+        const handlerSymbol = args[args.length - 1];
+        const middlewares = args.slice(1, args.length - 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(handlerSymbol);
+        if (resolvedPath) {
+          resolvedFile = resolvedPath;
+        }
+        routes.push({
+          framework: this.name,
+          method,
+          path: fullPath,
+          handlerFile: resolvedFile,
+          handlerSymbol,
+          metadata: {
+            confidence: "inferred",
+            middlewares: middlewares.filter((m) => !m.includes("function") && !m.includes("=>"))
+            // filter inline callbacks
+          }
+        });
+      }
+      index = paren.endIndex;
+    }
+    let routeIndex = 0;
+    while (true) {
+      const routeMatch = content.substring(routeIndex).match(/([a-zA-Z0-9_]+)\.route\s*\(\s*['"]([^'"]+)['"]\s*\)/);
+      if (!routeMatch) break;
+      const routePath = routeMatch[2];
+      const startOfChain = routeIndex + routeMatch.index + routeMatch[0].length;
+      const trailingSlice = content.substring(startOfChain);
+      const chainRegex = /\s*\.(get|post|put|delete|patch|options)\s*\(\s*([^)]+)\)/g;
+      let chainMatch;
+      let lastMatchEnd = 0;
+      while ((chainMatch = chainRegex.exec(trailingSlice)) !== null) {
+        const matchIndex = chainMatch.index;
+        const skipped = trailingSlice.substring(lastMatchEnd, matchIndex);
+        if (skipped.trim() !== "") {
+          break;
+        }
+        const method = chainMatch[1].toUpperCase();
+        const handlerSymbol = chainMatch[2].trim();
+        let resolvedFile = filePath;
+        const resolvedPath = ctx.resolveSymbolToFile(handlerSymbol);
+        if (resolvedPath) {
+          resolvedFile = resolvedPath;
+        }
+        routes.push({
+          framework: this.name,
+          method,
+          path: routePath,
+          handlerFile: resolvedFile,
+          handlerSymbol,
+          metadata: {
+            confidence: "inferred"
+          }
+        });
+        lastMatchEnd = chainRegex.lastIndex;
+      }
+      routeIndex = startOfChain;
+    }
+    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 === '"' || 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 braceDepth = 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 === '"' || char === "`") {
+      inString = true;
+      stringChar = char;
+      current += char;
+      continue;
+    }
+    if (char === "(") {
+      depth++;
+    } else if (char === ")") {
+      depth--;
+    } else if (char === "[") {
+      bracketDepth++;
+    } else if (char === "]") {
+      bracketDepth--;
+    } else if (char === "{") {
+      braceDepth++;
+    } else if (char === "}") {
+      braceDepth--;
+    }
+    if (char === "," && depth === 0 && bracketDepth === 0 && braceDepth === 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 {
+  ExpressDetector
+};

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

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