@mgamil/mapx 0.2.4

package/dist/frameworks/detectors/laravel.js

@@ -0,0 +1,462 @@
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { existsSync } from "node:fs";
+class LaravelDetector {
+  name = "laravel";
+  language = "php";
+  filePattern = /\.php$/;
+  async detect(projectRoot, files) {
+    const hasArtisan = files.some((f) => f.endsWith("artisan"));
+    if (hasArtisan) return true;
+    const composerPath = join(projectRoot, "composer.json");
+    if (existsSync(composerPath)) {
+      try {
+        const composerContent = JSON.parse(await readFile(composerPath, "utf-8"));
+        const deps = { ...composerContent.require, ...composerContent["require-dev"] };
+        if (deps && deps["laravel/framework"]) {
+          return true;
+        }
+      } catch {
+      }
+    }
+    return false;
+  }
+  async extractRoutes(filePath, content, ctx) {
+    const normalizedPath = filePath.replace(/\\/g, "/");
+    const isRouteFile = normalizedPath.includes("routes/");
+    const hasRouteAttributes = content.includes("RouteAttributes") || content.includes("#[Route") || content.includes("#[Get") || content.includes("#[Post") || content.includes("#[Put") || content.includes("#[Patch") || content.includes("#[Delete") || content.includes("#[Options") || content.includes("#[Any") || content.includes("#[Head") || content.includes("#[Prefix") || content.includes("#[Middleware");
+    if (!isRouteFile && !hasRouteAttributes) {
+      return [];
+    }
+    if (isRouteFile) {
+      const routes2 = [];
+      let braceDepth = 0;
+      const groupStack = [];
+      for (let i = 0; i < content.length; i++) {
+        const char = content[i];
+        if (char === "{") {
+          braceDepth++;
+        } else if (char === "}") {
+          braceDepth--;
+          while (groupStack.length > 0 && groupStack[groupStack.length - 1].startDepth > braceDepth) {
+            groupStack.pop();
+          }
+        }
+        if (content.substring(i, i + 7) === "Route::") {
+          const parsed = parseRouteChain(content, i);
+          if (parsed) {
+            const skippedText = content.substring(i, parsed.endIndex);
+            for (const c of skippedText) {
+              if (c === "{") braceDepth++;
+              else if (c === "}") braceDepth--;
+            }
+            i = parsed.endIndex - 1;
+            processRouteChain(parsed.calls, groupStack, braceDepth, filePath, ctx, routes2, this.name);
+          }
+        }
+      }
+      return routes2;
+    }
+    const routes = [];
+    const namespaceMatch = content.match(/namespace\s+([^;]+);/);
+    const namespace = namespaceMatch ? namespaceMatch[1].trim() : "";
+    const classMatch = content.match(/class\s+(\w+)/);
+    if (!classMatch) return [];
+    const className = classMatch[1];
+    const classFqn = namespace ? `${namespace}\\${className}` : className;
+    const classIndex = content.indexOf(`class ${className}`);
+    const beforeClass = content.substring(0, classIndex);
+    let classPrefix = "";
+    const classMiddlewares = [];
+    const classAttrs = extractAttributes(beforeClass);
+    for (const attr of classAttrs) {
+      if (attr.startsWith("Prefix")) {
+        const match = attr.match(/Prefix\s*\(\s*['"]([^'"]+)['"]/);
+        if (match) classPrefix = match[1];
+      } else if (attr.startsWith("Route")) {
+        const prefixMatch = attr.match(/prefix\s*:\s*['"]([^'"]+)['"]/);
+        if (prefixMatch) {
+          classPrefix = prefixMatch[1];
+        } else {
+          const argsMatch = attr.match(/Route\s*\(\s*['"]([^'"]+)['"]/);
+          if (argsMatch && !attr.includes("method")) {
+            classPrefix = argsMatch[1];
+          }
+        }
+        const mwMatch = attr.match(/middleware\s*:\s*['"]([^'"]+)['"]/);
+        if (mwMatch) {
+          classMiddlewares.push(mwMatch[1]);
+        } else {
+          const mwsMatch = attr.match(/middleware\s*:\s*\[([^\]]+)\]/);
+          if (mwsMatch) {
+            const matches = mwsMatch[1].match(/['"]([^'"]+)['"]/g) || [];
+            classMiddlewares.push(...matches.map((m) => m.replace(/['"]/g, "")));
+          }
+        }
+      } else if (attr.startsWith("Middleware")) {
+        if (attr.includes("[")) {
+          const matches = attr.match(/['"]([^'"]+)['"]/g) || [];
+          classMiddlewares.push(...matches.map((m) => m.replace(/['"]/g, "")));
+        } else {
+          const match = attr.match(/Middleware\s*\(\s*['"]([^'"]+)['"]/);
+          if (match) classMiddlewares.push(match[1]);
+        }
+      }
+    }
+    const parts = content.substring(classIndex).split(/\bfunction\s+/);
+    let previousText = parts[0];
+    for (let idx = 1; idx < parts.length; idx++) {
+      const part = parts[idx];
+      const nameMatch = part.match(/^(\w+)\s*\(/);
+      if (!nameMatch) {
+        previousText += " function " + part;
+        continue;
+      }
+      const methodName = nameMatch[1];
+      const methodAttrs = extractAttributes(previousText);
+      for (const attr of methodAttrs) {
+        const verbMatch = attr.match(/^(Get|Post|Put|Patch|Delete|Options|Any|Head|Route)\b/);
+        if (!verbMatch) continue;
+        const attrName = verbMatch[1];
+        let verb = attrName === "Route" ? "GET" : attrName.toUpperCase();
+        let uri = "";
+        const methodMiddlewares = [];
+        if (attrName === "Route") {
+          const verbParamMatch = attr.match(/Route\s*\(\s*['"]([^'"]+)['"]/);
+          if (verbParamMatch) {
+            verb = verbParamMatch[1].toUpperCase();
+          }
+          const uriParamMatch = attr.match(/Route\s*\(\s*['"][^'"]+['"]\s*,\s*['"]([^'"]+)['"]/);
+          if (uriParamMatch) {
+            uri = uriParamMatch[1];
+          } else {
+            const uriNamedMatch = attr.match(/uri\s*:\s*['"]([^'"]+)['"]/);
+            if (uriNamedMatch) uri = uriNamedMatch[1];
+          }
+        } else {
+          const uriParamMatch = attr.match(/^[a-zA-Z]+\s*\(\s*['"]([^'"]+)['"]/);
+          if (uriParamMatch) uri = uriParamMatch[1];
+        }
+        const mwAttrs = methodAttrs.filter((a) => a.startsWith("Middleware"));
+        for (const mwAttr of mwAttrs) {
+          if (mwAttr.includes("[")) {
+            const matches = mwAttr.match(/['"]([^'"]+)['"]/g) || [];
+            methodMiddlewares.push(...matches.map((m) => m.replace(/['"]/g, "")));
+          } else {
+            const match = mwAttr.match(/Middleware\s*\(\s*['"]([^'"]+)['"]/);
+            if (match) methodMiddlewares.push(match[1]);
+          }
+        }
+        const cleanClassPrefix = classPrefix.replace(/^\/|\/$/g, "").trim();
+        const cleanUri = uri.replace(/^\/|\/$/g, "").trim();
+        const fullPath = "/" + [cleanClassPrefix, cleanUri].filter(Boolean).join("/");
+        const allMiddlewares = Array.from(/* @__PURE__ */ new Set([...classMiddlewares, ...methodMiddlewares]));
+        routes.push({
+          framework: this.name,
+          method: verb,
+          path: fullPath,
+          handlerFile: filePath,
+          handlerSymbol: `${classFqn}@${methodName}`,
+          metadata: {
+            confidence: "inferred",
+            middlewares: allMiddlewares
+          }
+        });
+      }
+      previousText = part;
+    }
+    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 parseRouteChain(content, startIndex) {
+  let index = startIndex;
+  const calls = [];
+  const initMatch = content.substring(index).match(/^Route::([a-zA-Z0-9_]+)\s*\(/);
+  if (!initMatch) return null;
+  const name = initMatch[1];
+  index += initMatch[0].length - 1;
+  if (name === "group") {
+    calls.push({ name: "group", args: "" });
+    return { calls, endIndex: index + 1 };
+  }
+  const paren = getParenthesizedContent(content, index);
+  if (!paren) return null;
+  calls.push({ name, args: paren.content });
+  index = paren.endIndex;
+  while (true) {
+    const wsMatch = content.substring(index).match(/^\s+/);
+    if (wsMatch) {
+      index += wsMatch[0].length;
+    }
+    if (content.substring(index, index + 2) !== "->") {
+      break;
+    }
+    const methodMatch = content.substring(index + 2).match(/^([a-zA-Z0-9_]+)\s*\(/);
+    if (!methodMatch) {
+      break;
+    }
+    const methodName = methodMatch[1];
+    index += 2 + methodMatch[0].length - 1;
+    if (methodName === "group") {
+      calls.push({ name: "group", args: "" });
+      return { calls, endIndex: index + 1 };
+    }
+    const methodParen = getParenthesizedContent(content, index);
+    if (!methodParen) {
+      break;
+    }
+    calls.push({ name: methodName, args: methodParen.content });
+    index = methodParen.endIndex;
+  }
+  return { calls, endIndex: index };
+}
+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, "");
+}
+function getBracketedContent(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 extractAttributes(text) {
+  const attrs = [];
+  let index = 0;
+  while (true) {
+    const start = text.indexOf("#[", index);
+    if (start === -1) break;
+    const bracket = getBracketedContent(text, start + 1);
+    if (!bracket) {
+      index = start + 2;
+      continue;
+    }
+    attrs.push(bracket.content);
+    index = bracket.endIndex;
+  }
+  return attrs;
+}
+function processRouteChain(calls, groupStack, currentBraceDepth, filePath, ctx, routes, frameworkName) {
+  let verb = null;
+  let uri = null;
+  let handlerStr = null;
+  const chainPrefixes = [];
+  const chainMiddlewares = [];
+  let isGroup = false;
+  for (const call of calls) {
+    if (call.name === "group") {
+      isGroup = true;
+    } else if (["get", "post", "put", "patch", "delete", "options", "any", "match", "resource", "apiResource"].includes(call.name)) {
+      verb = call.name.toUpperCase();
+      const args = parseArgs(call.args);
+      uri = args[0] || null;
+      handlerStr = args[1] || null;
+    } else if (call.name === "prefix") {
+      const args = parseArgs(call.args);
+      if (args[0]) chainPrefixes.push(args[0]);
+    } else if (call.name === "middleware") {
+      if (call.args.trim().startsWith("[")) {
+        const matches = call.args.match(/['"]([^'"]+)['"]/g) || [];
+        chainMiddlewares.push(...matches.map((m) => m.replace(/['"]/g, "")));
+      } else {
+        const args = parseArgs(call.args);
+        if (args[0]) chainMiddlewares.push(args[0]);
+      }
+    }
+  }
+  const groupPrefixes = groupStack.flatMap((g) => g.prefixes);
+  const groupMiddlewares = groupStack.flatMap((g) => g.middlewares);
+  const fullPrefixes = [...groupPrefixes, ...chainPrefixes];
+  const fullMiddlewares = [...groupMiddlewares, ...chainMiddlewares];
+  if (isGroup) {
+    groupStack.push({
+      prefixes: chainPrefixes,
+      middlewares: chainMiddlewares,
+      startDepth: currentBraceDepth + 1
+    });
+  } else if (verb && uri && handlerStr) {
+    let controllerClass = null;
+    let controllerMethod = null;
+    let resourceType = null;
+    if (verb === "RESOURCE" || verb === "APIRESOURCE") {
+      resourceType = verb.toLowerCase();
+      const classMatch = handlerStr.match(/([a-zA-Z0-9_\\]+)(?:::class)?/);
+      if (classMatch) {
+        controllerClass = classMatch[1];
+      }
+    } else {
+      if (handlerStr.includes("::class")) {
+        const classAndMethod = handlerStr.match(/\[\s*([a-zA-Z0-9_\\]+)::class\s*,\s*['"]([^'"]+)['"]\s*\]/);
+        if (classAndMethod) {
+          controllerClass = classAndMethod[1];
+          controllerMethod = classAndMethod[2];
+        }
+      } else if (handlerStr.includes("@")) {
+        const cleanHandler = handlerStr.replace(/['"]/g, "");
+        const strMatch = cleanHandler.match(/^([a-zA-Z0-9_\\]+)@([a-zA-Z0-9_]+)$/);
+        if (strMatch) {
+          controllerClass = strMatch[1];
+          controllerMethod = strMatch[2];
+        }
+      }
+    }
+    if (controllerClass) {
+      let resolvedFile = filePath;
+      const resolvedPath = ctx.resolveSymbolToFile(controllerClass);
+      if (resolvedPath) {
+        resolvedFile = resolvedPath;
+      }
+      const cleanPrefixes = fullPrefixes.map((p) => p.replace(/^\/|\/$/g, "")).filter(Boolean);
+      const cleanUri = uri.replace(/^\/|\/$/g, "");
+      const fullPath = "/" + [...cleanPrefixes, cleanUri].join("/");
+      routes.push({
+        framework: frameworkName,
+        method: verb,
+        path: fullPath,
+        handlerFile: resolvedFile,
+        handlerSymbol: controllerMethod ? `${controllerClass}@${controllerMethod}` : controllerClass,
+        metadata: {
+          confidence: "inferred",
+          resourceType,
+          middlewares: fullMiddlewares
+        }
+      });
+    }
+  }
+}
+export {
+  LaravelDetector
+};

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

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

package/dist/frameworks/detectors/nestjs.js

@@ -0,0 +1,155 @@
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { existsSync } from "node:fs";
+class NestJSDetector {
+  name = "nestjs";
+  language = "typescript";
+  filePattern = /\.(ts|js)$/;
+  async detect(projectRoot, files) {
+    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["@nestjs/core"] || deps["@nestjs/common"])) {
+          return true;
+        }
+      } catch {
+      }
+    }
+    return false;
+  }
+  async extractRoutes(filePath, content, ctx) {
+    const routes = [];
+    if (!content.includes("@Controller") && !content.includes("@Get") && !content.includes("@Post")) {
+      return [];
+    }
+    const classes = content.split(/\bclass\s+/);
+    for (let i = 1; i < classes.length; i++) {
+      const classBlock = classes[i];
+      const classNameMatch = classBlock.match(/^([a-zA-Z0-9_]+)/);
+      if (!classNameMatch) continue;
+      const className = classNameMatch[1];
+      const classHeaderStart = content.indexOf(`class ${className}`);
+      const lookbackText = content.substring(Math.max(0, classHeaderStart - 300), classHeaderStart);
+      const controllerMatch = lookbackText.match(/@Controller\s*\(\s*(?:['"]([^'"]*)['"])?\s*\)/);
+      if (controllerMatch) {
+        const classPrefix = controllerMatch[1] || "";
+        const methodRegex = /@(Get|Post|Put|Delete|Patch|Options|All|Head)\s*\(\s*(?:['"]([^'"]*)['"])?\s*\)\s*(?:async\s+)?(\w+)\s*\(/g;
+        let match;
+        while ((match = methodRegex.exec(classBlock)) !== null) {
+          const verb = match[1].toUpperCase();
+          const routePath = match[2] || "";
+          const methodName = match[3];
+          const cleanPrefix = classPrefix.replace(/^\/|\/$/g, "");
+          const cleanRoute = routePath.replace(/^\/|\/$/g, "");
+          const fullPath = "/" + [cleanPrefix, cleanRoute].filter(Boolean).join("/");
+          let resolvedFile = filePath;
+          const resolvedPath = ctx.resolveSymbolToFile(className);
+          if (resolvedPath) {
+            resolvedFile = resolvedPath;
+          }
+          routes.push({
+            framework: this.name,
+            method: verb,
+            path: fullPath,
+            handlerFile: resolvedFile,
+            handlerSymbol: `${className}@${methodName}`,
+            metadata: {
+              confidence: "inferred"
+            }
+          });
+        }
+      }
+    }
+    return routes;
+  }
+  async extractHooks(filePath, content, ctx) {
+    const hooks = [];
+    const classes = content.split(/\bclass\s+/);
+    for (let i = 1; i < classes.length; i++) {
+      const classBlock = classes[i];
+      const classNameMatch = classBlock.match(/^([a-zA-Z0-9_]+)/);
+      if (!classNameMatch) continue;
+      const className = classNameMatch[1];
+      const classHeaderStart = content.indexOf(`class ${className}`);
+      const lookbackText = content.substring(Math.max(0, classHeaderStart - 300), classHeaderStart);
+      let resolvedFile = filePath;
+      const resolvedPath = ctx.resolveSymbolToFile(className);
+      if (resolvedPath) {
+        resolvedFile = resolvedPath;
+      }
+      const classGuardMatch = lookbackText.match(/@UseGuards\s*\(\s*([^)]+)\)/);
+      if (classGuardMatch) {
+        const guardSymbols = classGuardMatch[1].split(",").map((s) => s.trim());
+        for (const guardSymbol of guardSymbols) {
+          let guardFile = filePath;
+          const resolvedGuard = ctx.resolveSymbolToFile(guardSymbol);
+          if (resolvedGuard) {
+            guardFile = resolvedGuard;
+          }
+          hooks.push({
+            framework: this.name,
+            hookName: `guard:${guardSymbol}`,
+            hookType: "middleware",
+            handlerFile: guardFile,
+            handlerSymbol: guardSymbol
+          });
+        }
+      }
+      const isResolver = /@Resolver\s*\(/.test(lookbackText);
+      if (isResolver) {
+        const resolverRegex = /@(Query|Mutation|Subscription)\s*\(\s*(?:['"]([^'"]*)['"])?\s*\)\s*(?:async\s+)?(\w+)\s*\(/g;
+        let match2;
+        while ((match2 = resolverRegex.exec(classBlock)) !== null) {
+          const type = match2[1].toLowerCase();
+          const opName = match2[2] || match2[3];
+          const methodName = match2[3];
+          hooks.push({
+            framework: this.name,
+            hookName: opName,
+            hookType: "graphql_resolver",
+            handlerFile: resolvedFile,
+            handlerSymbol: `${className}@${methodName}`,
+            metadata: {
+              operationType: type
+            }
+          });
+        }
+      }
+      const messageRegex = /@(MessagePattern|EventPattern)\s*\(\s*([^)]+)\)\s*(?:async\s+)?(\w+)\s*\(/g;
+      let match;
+      while ((match = messageRegex.exec(classBlock)) !== null) {
+        const type = match[1] === "MessagePattern" ? "request-response" : "event-driven";
+        const pattern = match[2].replace(/['"{}]/g, "").trim();
+        const methodName = match[3];
+        hooks.push({
+          framework: this.name,
+          hookName: pattern,
+          hookType: "message_handler",
+          handlerFile: resolvedFile,
+          handlerSymbol: `${className}@${methodName}`,
+          metadata: {
+            patternType: type
+          }
+        });
+      }
+      const wsRegex = /@SubscribeMessage\s*\(\s*['"]([^'"]+)['"]\s*\)\s*(?:async\s+)?(\w+)\s*\(/g;
+      while ((match = wsRegex.exec(classBlock)) !== null) {
+        const event = match[1];
+        const methodName = match[2];
+        hooks.push({
+          framework: this.name,
+          hookName: event,
+          hookType: "websocket_handler",
+          handlerFile: resolvedFile,
+          handlerSymbol: `${className}@${methodName}`
+        });
+      }
+    }
+    return hooks;
+  }
+}
+export {
+  NestJSDetector
+};

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

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