vibecheck-ai 2.0.1 → 5.0.0

package/bin/runners/lib/extractors/fastify-routes.js

@@ -0,0 +1,426 @@
+/**
+ * Fastify Route Extractor v2
+ * 
+ * Spec-compliant extraction with prefix stacking and autoload support.
+ * Two-tier approach: static AST extraction + optional runtime introspection.
+ * 
+ * Patterns supported:
+ * - fastify.route({ method, url, handler })
+ * - fastify.get/post/put/patch/delete(path, handler)
+ * - fastify.register(plugin, { prefix })
+ * - AutoLoad with dir resolution
+ */
+
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const fg = require("fast-glob");
+const crypto = require("crypto");
+
+const FASTIFY_METHODS = ["GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS", "HEAD", "ALL"];
+
+/**
+ * Detect Fastify service and entrypoint
+ */
+function detectFastify(projectRoot) {
+  const result = {
+    present: false,
+    entryFile: null,
+    prefixes: [],
+  };
+
+  // Check package.json for fastify dependency
+  const pkgPath = path.join(projectRoot, "package.json");
+  if (fs.existsSync(pkgPath)) {
+    try {
+      const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+      if (pkg.dependencies?.fastify || pkg.devDependencies?.fastify) {
+        result.present = true;
+      }
+
+      // Try to find entry from scripts
+      const scripts = pkg.scripts || {};
+      for (const [name, cmd] of Object.entries(scripts)) {
+        if (name === "start" || name === "dev" || name === "server") {
+          const entryMatch = cmd.match(/(?:node|tsx|ts-node|npx\s+tsx?)\s+([^\s]+)/);
+          if (entryMatch) {
+            const entryPath = path.join(projectRoot, entryMatch[1]);
+            if (fs.existsSync(entryPath)) {
+              result.entryFile = entryMatch[1];
+            }
+          }
+        }
+      }
+    } catch {}
+  }
+
+  // Fallback: search common entry files
+  if (!result.entryFile) {
+    const commonEntries = [
+      "server.ts", "server.js",
+      "src/server.ts", "src/server.js",
+      "app.ts", "app.js",
+      "src/app.ts", "src/app.js",
+      "index.ts", "index.js",
+      "src/index.ts", "src/index.js",
+    ];
+
+    for (const entry of commonEntries) {
+      const entryPath = path.join(projectRoot, entry);
+      if (fs.existsSync(entryPath)) {
+        const content = fs.readFileSync(entryPath, "utf8");
+        if (/from\s+['"]fastify['"]|require\s*\(\s*['"]fastify['"]\s*\)/.test(content)) {
+          result.entryFile = entry;
+          result.present = true;
+          break;
+        }
+      }
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Extract routes from Fastify project using static AST analysis
+ */
+function extractFastifyRoutes(projectRoot, entryFile = null) {
+  const detection = detectFastify(projectRoot);
+  
+  if (!detection.present) {
+    return {
+      present: false,
+      entryFile: null,
+      routes: [],
+      prefixes: [],
+      autoloadDirs: [],
+      gaps: [],
+    };
+  }
+
+  const entry = entryFile || detection.entryFile;
+  const routes = [];
+  const prefixes = new Set();
+  const autoloadDirs = [];
+  const gaps = [];
+  const visited = new Set();
+
+  // Start extraction from entry file
+  if (entry) {
+    const entryPath = path.join(projectRoot, entry);
+    if (fs.existsSync(entryPath)) {
+      extractFromFile(entryPath, projectRoot, "", routes, prefixes, autoloadDirs, gaps, visited);
+    }
+  }
+
+  // Also scan common route directories
+  const routeDirs = ["routes", "src/routes", "api", "src/api"];
+  for (const dir of routeDirs) {
+    const dirPath = path.join(projectRoot, dir);
+    if (fs.existsSync(dirPath)) {
+      scanRouteDirectory(dirPath, projectRoot, "", routes, prefixes, gaps, visited);
+    }
+  }
+
+  return {
+    present: true,
+    entryFile: entry,
+    routes,
+    prefixes: [...prefixes],
+    autoloadDirs,
+    gaps,
+  };
+}
+
+/**
+ * Extract routes from a single file
+ */
+function extractFromFile(filePath, projectRoot, currentPrefix, routes, prefixes, autoloadDirs, gaps, visited) {
+  if (visited.has(filePath)) return;
+  visited.add(filePath);
+
+  if (!fs.existsSync(filePath)) return;
+
+  const content = fs.readFileSync(filePath, "utf8");
+  const relPath = path.relative(projectRoot, filePath).replace(/\\/g, "/");
+
+  // Pattern A: fastify.route({ method, url, ... })
+  extractRouteMethod(content, relPath, currentPrefix, routes, projectRoot);
+
+  // Pattern B: fastify.get/post/put/... shorthand
+  extractShorthandMethods(content, relPath, currentPrefix, routes, projectRoot);
+
+  // Pattern C: fastify.register with prefix
+  extractRegisterCalls(content, filePath, projectRoot, currentPrefix, routes, prefixes, autoloadDirs, gaps, visited);
+
+  // Pattern D: AutoLoad
+  extractAutoLoad(content, filePath, projectRoot, currentPrefix, routes, prefixes, autoloadDirs, gaps, visited);
+}
+
+/**
+ * Extract fastify.route({ method, url, ... }) patterns
+ */
+function extractRouteMethod(content, relPath, prefix, routes, projectRoot) {
+  // Match fastify.route({ method: "POST", url: "/path", ... })
+  const routePattern = /(?:fastify|app|server)\s*\.\s*route\s*\(\s*\{([^}]+)\}/g;
+  
+  let match;
+  while ((match = routePattern.exec(content)) !== null) {
+    const routeBody = match[1];
+    
+    // Extract method
+    const methodMatch = routeBody.match(/method\s*:\s*(?:['"`](\w+)['"`]|\[([^\]]+)\])/);
+    let methods = ["UNKNOWN"];
+    if (methodMatch) {
+      if (methodMatch[1]) {
+        methods = [methodMatch[1].toUpperCase()];
+      } else if (methodMatch[2]) {
+        methods = methodMatch[2].match(/['"`](\w+)['"`]/g)?.map(m => m.replace(/['"`]/g, "").toUpperCase()) || [];
+      }
+    }
+
+    // Extract url/path
+    const urlMatch = routeBody.match(/(?:url|path)\s*:\s*['"`]([^'"`]+)['"`]/);
+    if (urlMatch) {
+      const rawPath = urlMatch[1];
+      const fullPath = combinePrefixes(prefix, rawPath);
+      const canonicalPath = convertFastifyPathToCanonical(fullPath);
+
+      const lineNum = content.substring(0, match.index).split("\n").length;
+
+      routes.push({
+        id: `R_FASTIFY_${hashPath(canonicalPath)}`,
+        kind: "fastify",
+        methods,
+        rawPath: fullPath,
+        path: canonicalPath,
+        canonicalPath,
+        authRequired: "unknown",
+        confidence: "medium",
+        handler: {
+          file: relPath,
+          export: "route",
+        },
+        evidence: [{
+          id: `E_${crypto.randomBytes(4).toString("hex").toUpperCase()}`,
+          kind: "file",
+          reason: "fastify.route() call",
+          file: relPath,
+          lines: `${lineNum}-${lineNum + 5}`,
+          snippetHash: hashSnippet(match[0]),
+        }],
+      });
+    }
+  }
+}
+
+/**
+ * Extract fastify.get/post/put shorthand methods
+ */
+function extractShorthandMethods(content, relPath, prefix, routes, projectRoot) {
+  for (const method of FASTIFY_METHODS) {
+    const lowerMethod = method.toLowerCase();
+    // Match fastify.get("/path", ...) or fastify.get('/path', ...)
+    const pattern = new RegExp(`(?:fastify|app|server)\\s*\\.\\s*${lowerMethod}\\s*\\(\\s*['"\`]([^'"\`]+)['"\`]`, "g");
+    
+    let match;
+    while ((match = pattern.exec(content)) !== null) {
+      const rawPath = match[1];
+      const fullPath = combinePrefixes(prefix, rawPath);
+      const canonicalPath = convertFastifyPathToCanonical(fullPath);
+
+      const lineNum = content.substring(0, match.index).split("\n").length;
+
+      routes.push({
+        id: `R_FASTIFY_${hashPath(canonicalPath)}_${method}`,
+        kind: "fastify",
+        methods: method === "ALL" ? ["GET", "POST", "PUT", "PATCH", "DELETE"] : [method],
+        rawPath: fullPath,
+        path: canonicalPath,
+        canonicalPath,
+        authRequired: "unknown",
+        confidence: "medium",
+        handler: {
+          file: relPath,
+          export: lowerMethod,
+        },
+        evidence: [{
+          id: `E_${crypto.randomBytes(4).toString("hex").toUpperCase()}`,
+          kind: "file",
+          reason: `fastify.${lowerMethod}() call`,
+          file: relPath,
+          lines: `${lineNum}-${lineNum + 3}`,
+          snippetHash: hashSnippet(match[0]),
+        }],
+      });
+    }
+  }
+}
+
+/**
+ * Extract fastify.register() calls with prefix stacking
+ */
+function extractRegisterCalls(content, filePath, projectRoot, currentPrefix, routes, prefixes, autoloadDirs, gaps, visited) {
+  // Match register(plugin, { prefix: "/api" }) or register(import(...), { prefix })
+  const registerPattern = /(?:fastify|app|server)\s*\.\s*register\s*\(\s*(?:import\s*\(\s*['"`]([^'"`]+)['"`]\s*\)|require\s*\(\s*['"`]([^'"`]+)['"`]\s*\)|(\w+))\s*(?:,\s*\{[^}]*prefix\s*:\s*['"`]([^'"`]+)['"`][^}]*\})?/g;
+
+  let match;
+  while ((match = registerPattern.exec(content)) !== null) {
+    const importPath = match[1] || match[2];
+    const varName = match[3];
+    const newPrefix = match[4] || "";
+
+    const combinedPrefix = combinePrefixes(currentPrefix, newPrefix);
+    if (newPrefix) {
+      prefixes.add(combinedPrefix);
+    }
+
+    // Try to resolve and scan the registered plugin
+    if (importPath) {
+      const resolvedPath = resolveImportPath(filePath, importPath, projectRoot);
+      if (resolvedPath) {
+        extractFromFile(resolvedPath, projectRoot, combinedPrefix, routes, prefixes, autoloadDirs, gaps, visited);
+      }
+    }
+  }
+}
+
+/**
+ * Extract AutoLoad patterns
+ */
+function extractAutoLoad(content, filePath, projectRoot, currentPrefix, routes, prefixes, autoloadDirs, gaps, visited) {
+  // Match AutoLoad registration
+  const autoloadPattern = /register\s*\(\s*(?:AutoLoad|autoLoad|fastifyAutoload)\s*,\s*\{[^}]*dir\s*:\s*(?:path\.join\s*\(\s*__dirname\s*,\s*['"`]([^'"`]+)['"`]\s*\)|['"`]([^'"`]+)['"`])/g;
+
+  let match;
+  while ((match = autoloadPattern.exec(content)) !== null) {
+    const dirRelative = match[1] || match[2];
+    
+    if (dirRelative) {
+      const fileDir = path.dirname(filePath);
+      const autoloadDir = path.resolve(fileDir, dirRelative);
+      
+      if (fs.existsSync(autoloadDir)) {
+        autoloadDirs.push(path.relative(projectRoot, autoloadDir));
+        scanRouteDirectory(autoloadDir, projectRoot, currentPrefix, routes, prefixes, gaps, visited);
+      } else {
+        gaps.push({
+          type: "autoload_dir_not_found",
+          dir: dirRelative,
+          file: path.relative(projectRoot, filePath),
+        });
+      }
+    } else {
+      // Non-literal dir path
+      gaps.push({
+        type: "autoload_dir_not_resolvable",
+        file: path.relative(projectRoot, filePath),
+        message: "AutoLoad directory is not statically resolvable",
+      });
+    }
+  }
+}
+
+/**
+ * Scan a routes directory for plugin files
+ */
+function scanRouteDirectory(dir, projectRoot, prefix, routes, prefixes, gaps, visited) {
+  const pattern = path.join(dir, "**", "*.{js,ts}").replace(/\\/g, "/");
+  const files = fg.sync(pattern, { onlyFiles: true, absolute: true, ignore: ["**/*.test.*", "**/*.spec.*"] });
+
+  for (const file of files) {
+    // Infer prefix from directory structure
+    const relDir = path.relative(dir, path.dirname(file)).replace(/\\/g, "/");
+    const inferredPrefix = relDir ? `/${relDir}` : "";
+    const combinedPrefix = combinePrefixes(prefix, inferredPrefix);
+
+    extractFromFile(file, projectRoot, combinedPrefix, routes, prefixes, [], gaps, visited);
+  }
+}
+
+/**
+ * Convert Fastify path params to canonical format
+ * :id → {id}
+ * :path* → {*path}
+ * /* → {*path}
+ */
+function convertFastifyPathToCanonical(urlPath) {
+  return urlPath
+    // Wildcard catch-all
+    .replace(/\/\*$/, "/{*path}")
+    .replace(/\/:(\w+)\*/, "/{*$1}")
+    // Named params
+    .replace(/:(\w+)/g, "{$1}")
+    // Clean up
+    .replace(/\/+/g, "/")
+    .replace(/(.)\/$/, "$1");
+}
+
+/**
+ * Combine prefix segments
+ */
+function combinePrefixes(base, addition) {
+  if (!addition) return base;
+  if (!base) return addition;
+  
+  const baseTrimmed = base.replace(/\/$/, "");
+  const addTrimmed = addition.startsWith("/") ? addition : "/" + addition;
+  
+  return baseTrimmed + addTrimmed;
+}
+
+/**
+ * Resolve import path to absolute file path
+ */
+function resolveImportPath(fromFile, importPath, projectRoot) {
+  const fromDir = path.dirname(fromFile);
+  
+  // Relative import
+  if (importPath.startsWith(".")) {
+    const extensions = [".ts", ".js", ".tsx", ".jsx", ""];
+    for (const ext of extensions) {
+      const resolved = path.resolve(fromDir, importPath + ext);
+      if (fs.existsSync(resolved)) return resolved;
+      
+      // Try index file
+      const indexResolved = path.resolve(fromDir, importPath, "index" + ext);
+      if (fs.existsSync(indexResolved)) return indexResolved;
+    }
+  }
+  
+  return null;
+}
+
+/**
+ * Runtime introspection for Fastify routes (optional, high-confidence)
+ */
+async function introspectFastifyRoutes(projectRoot, entryFile) {
+  // This would spawn a node process to load and dump routes
+  // For now, return null to indicate runtime introspection not performed
+  return null;
+}
+
+// Helpers
+function hashSnippet(text) {
+  return `sha256:${crypto.createHash("sha256").update(text).digest("hex")}`;
+}
+
+function hashPath(urlPath) {
+  return crypto.createHash("sha256").update(urlPath).digest("hex").slice(0, 12).toUpperCase();
+}
+
+module.exports = {
+  detectFastify,
+  extractFastifyRoutes,
+  extractFromFile,
+  extractRouteMethod,
+  extractShorthandMethods,
+  extractRegisterCalls,
+  extractAutoLoad,
+  convertFastifyPathToCanonical,
+  combinePrefixes,
+  resolveImportPath,
+  introspectFastifyRoutes,
+  FASTIFY_METHODS,
+};