vibecheck-ai 2.0.1 → 5.0.0

package/bin/runners/lib/agent-firewall/simulator/route-validator.js

@@ -0,0 +1,380 @@
+/**
+ * Route Validator
+ * 
+ * Validates route definitions after simulated changes.
+ * Checks for orphaned routes, duplicate routes, and broken route handlers.
+ */
+
+"use strict";
+
+const path = require("path");
+
+/**
+ * Extract route definitions from source code
+ * @param {string} content - File content
+ * @param {string} filePath - File path for context
+ * @returns {Array} Array of route objects
+ */
+function extractRoutes(content, filePath) {
+  const routes = [];
+  const fileType = detectFileType(filePath, content);
+  
+  switch (fileType) {
+    case "fastify":
+      routes.push(...extractFastifyRoutes(content, filePath));
+      break;
+    case "express":
+      routes.push(...extractExpressRoutes(content, filePath));
+      break;
+    case "nextjs-api":
+      routes.push(...extractNextJsApiRoutes(content, filePath));
+      break;
+    case "nextjs-app":
+      routes.push(...extractNextJsAppRoutes(content, filePath));
+      break;
+    default:
+      // Try all extractors
+      routes.push(...extractGenericRoutes(content, filePath));
+  }
+  
+  return routes;
+}
+
+/**
+ * Detect the type of routing framework used
+ */
+function detectFileType(filePath, content) {
+  const lowerPath = filePath.toLowerCase();
+  
+  // Next.js App Router
+  if (lowerPath.includes("/app/") && (lowerPath.endsWith("route.ts") || lowerPath.endsWith("route.js"))) {
+    return "nextjs-app";
+  }
+  
+  // Next.js Pages API
+  if (lowerPath.includes("/pages/api/") || lowerPath.includes("/api/")) {
+    return "nextjs-api";
+  }
+  
+  // Fastify
+  if (content.includes("fastify.") || content.includes("app.register") || content.includes(".route({")) {
+    return "fastify";
+  }
+  
+  // Express
+  if (content.includes("express.Router") || content.includes("router.get") || content.includes("app.use")) {
+    return "express";
+  }
+  
+  return "unknown";
+}
+
+/**
+ * Extract Fastify routes
+ */
+function extractFastifyRoutes(content, filePath) {
+  const routes = [];
+  const methods = ["get", "post", "put", "patch", "delete", "head", "options"];
+  
+  for (const method of methods) {
+    // Pattern: fastify.get('/path', handler) or app.get('/path', handler)
+    const regex = new RegExp(`(?:fastify|app|server)\\.${method}\\s*\\(\\s*['"\`]([^'"\`]+)['"\`]`, "gi");
+    let match;
+    
+    while ((match = regex.exec(content)) !== null) {
+      routes.push({
+        method: method.toUpperCase(),
+        path: match[1],
+        file: filePath,
+        line: content.substring(0, match.index).split("\n").length,
+        type: "fastify",
+      });
+    }
+  }
+  
+  // Pattern: .route({ method: 'GET', url: '/path' })
+  const routeObjRegex = /\.route\s*\(\s*\{[^}]*method:\s*['"](\w+)['"][^}]*url:\s*['"]([^'"]+)['"][^}]*\}/gi;
+  let match;
+  
+  while ((match = routeObjRegex.exec(content)) !== null) {
+    routes.push({
+      method: match[1].toUpperCase(),
+      path: match[2],
+      file: filePath,
+      line: content.substring(0, match.index).split("\n").length,
+      type: "fastify",
+    });
+  }
+  
+  return routes;
+}
+
+/**
+ * Extract Express routes
+ */
+function extractExpressRoutes(content, filePath) {
+  const routes = [];
+  const methods = ["get", "post", "put", "patch", "delete", "head", "options", "all"];
+  
+  for (const method of methods) {
+    // Pattern: router.get('/path', handler) or app.get('/path', handler)
+    const regex = new RegExp(`(?:router|app)\\.${method}\\s*\\(\\s*['"\`]([^'"\`]+)['"\`]`, "gi");
+    let match;
+    
+    while ((match = regex.exec(content)) !== null) {
+      routes.push({
+        method: method.toUpperCase(),
+        path: match[1],
+        file: filePath,
+        line: content.substring(0, match.index).split("\n").length,
+        type: "express",
+      });
+    }
+  }
+  
+  // Pattern: app.use('/prefix', router)
+  const useRegex = /(?:router|app)\.use\s*\(\s*['"]([^'"]+)['"]\s*,/g;
+  let match;
+  
+  while ((match = useRegex.exec(content)) !== null) {
+    routes.push({
+      method: "USE",
+      path: match[1],
+      file: filePath,
+      line: content.substring(0, match.index).split("\n").length,
+      type: "express-middleware",
+    });
+  }
+  
+  return routes;
+}
+
+/**
+ * Extract Next.js API routes
+ */
+function extractNextJsApiRoutes(content, filePath) {
+  const routes = [];
+  
+  // Derive route path from file path
+  const apiMatch = filePath.match(/(?:pages\/api|app)\/(.+?)\.(ts|js|tsx|jsx)$/);
+  if (apiMatch) {
+    let routePath = "/" + apiMatch[1].replace(/\\/g, "/");
+    
+    // Handle index files
+    if (routePath.endsWith("/index")) {
+      routePath = routePath.slice(0, -6) || "/";
+    }
+    
+    // Handle dynamic routes
+    routePath = routePath.replace(/\[([^\]]+)\]/g, ":$1");
+    
+    // Check for exported methods
+    const methods = [];
+    if (content.includes("export default") || content.includes("export async function handler")) {
+      methods.push("GET", "POST", "PUT", "DELETE", "PATCH");
+    }
+    if (content.match(/export\s+(?:async\s+)?function\s+GET/)) methods.push("GET");
+    if (content.match(/export\s+(?:async\s+)?function\s+POST/)) methods.push("POST");
+    if (content.match(/export\s+(?:async\s+)?function\s+PUT/)) methods.push("PUT");
+    if (content.match(/export\s+(?:async\s+)?function\s+DELETE/)) methods.push("DELETE");
+    if (content.match(/export\s+(?:async\s+)?function\s+PATCH/)) methods.push("PATCH");
+    
+    // Default to GET if no explicit methods found
+    if (methods.length === 0) {
+      methods.push("ALL");
+    }
+    
+    for (const method of [...new Set(methods)]) {
+      routes.push({
+        method,
+        path: `/api${routePath}`,
+        file: filePath,
+        line: 1,
+        type: "nextjs-api",
+      });
+    }
+  }
+  
+  return routes;
+}
+
+/**
+ * Extract Next.js App Router routes
+ */
+function extractNextJsAppRoutes(content, filePath) {
+  const routes = [];
+  
+  // Derive route path from file path
+  const appMatch = filePath.match(/app\/(.+?)\/route\.(ts|js)$/);
+  if (appMatch) {
+    let routePath = "/" + appMatch[1].replace(/\\/g, "/");
+    
+    // Handle dynamic routes
+    routePath = routePath.replace(/\[([^\]]+)\]/g, ":$1");
+    
+    // Check for exported methods
+    const methods = [];
+    if (content.match(/export\s+(?:async\s+)?function\s+GET/)) methods.push("GET");
+    if (content.match(/export\s+(?:async\s+)?function\s+POST/)) methods.push("POST");
+    if (content.match(/export\s+(?:async\s+)?function\s+PUT/)) methods.push("PUT");
+    if (content.match(/export\s+(?:async\s+)?function\s+DELETE/)) methods.push("DELETE");
+    if (content.match(/export\s+(?:async\s+)?function\s+PATCH/)) methods.push("PATCH");
+    if (content.match(/export\s+(?:async\s+)?function\s+HEAD/)) methods.push("HEAD");
+    if (content.match(/export\s+(?:async\s+)?function\s+OPTIONS/)) methods.push("OPTIONS");
+    
+    for (const method of methods) {
+      routes.push({
+        method,
+        path: routePath,
+        file: filePath,
+        line: 1,
+        type: "nextjs-app",
+      });
+    }
+  }
+  
+  return routes;
+}
+
+/**
+ * Extract generic routes
+ */
+function extractGenericRoutes(content, filePath) {
+  const routes = [];
+  const methods = ["get", "post", "put", "patch", "delete"];
+  
+  for (const method of methods) {
+    // Generic pattern: .method('path' or .method('/path'
+    const regex = new RegExp(`\\.${method}\\s*\\(\\s*['"\`](/[^'"\`]*|[^'"\`]+)['"\`]`, "gi");
+    let match;
+    
+    while ((match = regex.exec(content)) !== null) {
+      const routePath = match[1];
+      if (routePath.startsWith("/") || routePath.includes("api")) {
+        routes.push({
+          method: method.toUpperCase(),
+          path: routePath,
+          file: filePath,
+          line: content.substring(0, match.index).split("\n").length,
+          type: "generic",
+        });
+      }
+    }
+  }
+  
+  return routes;
+}
+
+/**
+ * Validate routes after changes
+ * @param {Array} originalRoutes - Original routes
+ * @param {Map} changedFiles - Changed files (path -> content)
+ * @param {Set} deletedFiles - Deleted files
+ * @returns {Object} Validation result
+ */
+function validateRoutes(originalRoutes, changedFiles, deletedFiles) {
+  const issues = [];
+  const newRoutes = [];
+  const orphanedRoutes = [];
+  const duplicates = [];
+  
+  // Extract routes from changed files
+  for (const [filePath, content] of changedFiles) {
+    const routes = extractRoutes(content, filePath);
+    newRoutes.push(...routes);
+  }
+  
+  // Check for orphaned routes (routes whose handlers are deleted)
+  for (const route of originalRoutes) {
+    if (deletedFiles.has(route.file)) {
+      orphanedRoutes.push({
+        route,
+        issue: "Route handler file was deleted",
+      });
+    }
+  }
+  
+  // Check for duplicates
+  const routeMap = new Map();
+  for (const route of newRoutes) {
+    const key = `${route.method}:${route.path}`;
+    if (routeMap.has(key)) {
+      duplicates.push({
+        route,
+        existingRoute: routeMap.get(key),
+        issue: "Duplicate route definition",
+      });
+    } else {
+      routeMap.set(key, route);
+    }
+  }
+  
+  // Build issues list
+  for (const orphan of orphanedRoutes) {
+    issues.push({
+      type: "orphaned_route",
+      severity: "error",
+      message: `Route ${orphan.route.method} ${orphan.route.path} is orphaned - handler file '${orphan.route.file}' was deleted`,
+      route: orphan.route,
+    });
+  }
+  
+  for (const dup of duplicates) {
+    issues.push({
+      type: "duplicate_route",
+      severity: "warning",
+      message: `Duplicate route ${dup.route.method} ${dup.route.path} in '${dup.route.file}' (already defined in '${dup.existingRoute.file}')`,
+      route: dup.route,
+      existingRoute: dup.existingRoute,
+    });
+  }
+  
+  return {
+    valid: issues.filter(i => i.severity === "error").length === 0,
+    issues,
+    newRoutes,
+    orphanedRoutes,
+    duplicates,
+    summary: {
+      totalRoutes: newRoutes.length,
+      orphanedCount: orphanedRoutes.length,
+      duplicateCount: duplicates.length,
+      errorCount: issues.filter(i => i.severity === "error").length,
+      warningCount: issues.filter(i => i.severity === "warning").length,
+    },
+  };
+}
+
+/**
+ * Check if a route is referenced somewhere
+ * @param {Object} route - Route to check
+ * @param {Map} files - All files
+ * @returns {Array} References found
+ */
+function findRouteReferences(route, files) {
+  const references = [];
+  const pathPattern = route.path.replace(/:[^/]+/g, "[^/]+");
+  const regex = new RegExp(`['"\`]${pathPattern}['"\`]|fetch\\s*\\([^)]*${pathPattern}`);
+  
+  for (const [filePath, content] of files) {
+    if (regex.test(content)) {
+      references.push({
+        file: filePath,
+        route,
+      });
+    }
+  }
+  
+  return references;
+}
+
+module.exports = {
+  extractRoutes,
+  validateRoutes,
+  findRouteReferences,
+  detectFileType,
+  extractFastifyRoutes,
+  extractExpressRoutes,
+  extractNextJsApiRoutes,
+  extractNextJsAppRoutes,
+};