vibecheck-ai 2.0.2 → 5.0.0

package/bin/runners/lib/reality/request-mapper.js

@@ -0,0 +1,453 @@
+/**
+ * Request Mapper v2
+ * 
+ * Maps runtime requests to client calls with specificity scoring.
+ * Handles URL normalization, basePath, proxies, tRPC/GraphQL operations.
+ */
+
+"use strict";
+
+const crypto = require("crypto");
+
+// =============================================================================
+// IGNORE PATTERNS
+// =============================================================================
+
+const IGNORE_PATTERNS = {
+  // Asset extensions
+  assets: /\.(js|css|png|jpg|jpeg|gif|svg|ico|woff2?|ttf|eot|map|webp|avif)(\?.*)?$/i,
+  
+  // Dev/HMR patterns
+  hmr: /(_next\/static|__webpack_hmr|hot-update|\.hot-update\.|webpack|turbopack)/i,
+  
+  // Analytics/tracking
+  analytics: /(analytics|gtag|ga\.js|gtm\.js|pixel|clarity|hotjar|segment|mixpanel|amplitude)/i,
+  
+  // Third party
+  thirdParty: /^https?:\/\/(fonts\.googleapis|cdn\.|unpkg\.com|cdnjs\.|jsdelivr)/i,
+  
+  // Browser internals
+  browser: /^(chrome-extension|moz-extension|safari-extension|about:|data:|blob:)/i,
+  
+  // Favicon
+  favicon: /favicon\.ico/i,
+  
+  // Source maps
+  sourceMaps: /\.map$/i,
+  
+  // WebSocket
+  websocket: /^wss?:/i,
+};
+
+/**
+ * Check if request should be ignored
+ */
+function shouldIgnoreRequest(url, method = "GET") {
+  if (!url) return true;
+  
+  // Always include mutations
+  if (["POST", "PUT", "PATCH", "DELETE"].includes(method?.toUpperCase())) {
+    // But still ignore analytics POST
+    if (IGNORE_PATTERNS.analytics.test(url)) return true;
+    return false;
+  }
+  
+  for (const pattern of Object.values(IGNORE_PATTERNS)) {
+    if (pattern.test(url)) return true;
+  }
+  
+  return false;
+}
+
+// =============================================================================
+// URL NORMALIZATION
+// =============================================================================
+
+/**
+ * Normalize URL for matching
+ */
+function normalizeRequestUrl(url, options = {}) {
+  const { basePath = "", stripHost = true, stripQuery = true } = options;
+  
+  if (!url) return null;
+  
+  let normalized = url;
+  
+  // Strip host if absolute URL
+  if (stripHost && /^https?:\/\//.test(normalized)) {
+    try {
+      const parsed = new URL(normalized);
+      normalized = parsed.pathname + (stripQuery ? "" : parsed.search);
+    } catch {
+      // Invalid URL, try to extract path
+      normalized = normalized.replace(/^https?:\/\/[^/]+/, "");
+    }
+  }
+  
+  // Strip query string
+  if (stripQuery) {
+    normalized = normalized.split("?")[0].split("#")[0];
+  }
+  
+  // Strip basePath prefix
+  if (basePath && normalized.startsWith(basePath)) {
+    normalized = normalized.slice(basePath.length) || "/";
+  }
+  
+  // Ensure leading slash
+  if (!normalized.startsWith("/")) {
+    normalized = "/" + normalized;
+  }
+  
+  // Remove trailing slash except for root
+  if (normalized.length > 1 && normalized.endsWith("/")) {
+    normalized = normalized.slice(0, -1);
+  }
+  
+  // Normalize multiple slashes
+  normalized = normalized.replace(/\/+/g, "/");
+  
+  return normalized;
+}
+
+/**
+ * Extract tRPC operation from URL
+ */
+function extractTrpcOperation(url) {
+  // /api/trpc/user.get?batch=1&input=...
+  const match = url.match(/\/trpc\/([^?]+)/);
+  if (!match) return null;
+  
+  const procedure = match[1];
+  // Handle batch queries
+  const procedures = procedure.split(",").map(p => p.trim());
+  
+  return {
+    type: "trpc",
+    procedures,
+    isBatch: procedures.length > 1,
+  };
+}
+
+/**
+ * Extract GraphQL operation from request
+ */
+function extractGraphqlOperation(url, body) {
+  // Check if it's a GraphQL endpoint
+  if (!url.includes("graphql")) return null;
+  
+  if (!body) return { type: "graphql", operationName: null };
+  
+  try {
+    const parsed = typeof body === "string" ? JSON.parse(body) : body;
+    return {
+      type: "graphql",
+      operationName: parsed.operationName || null,
+      operationType: parsed.query?.trim().startsWith("mutation") ? "mutation" : "query",
+    };
+  } catch {
+    return { type: "graphql", operationName: null };
+  }
+}
+
+// =============================================================================
+// REQUEST → CLIENT CALL MATCHING
+// =============================================================================
+
+/**
+ * Match a runtime request to client calls
+ */
+function matchRequestToClientCalls(request, clientCalls, options = {}) {
+  const { basePath = "", rewrites = [] } = options;
+  
+  const normalizedPath = normalizeRequestUrl(request.url, { basePath });
+  if (!normalizedPath) return null;
+  
+  const method = (request.method || "GET").toUpperCase();
+  
+  // Check for tRPC
+  const trpcOp = extractTrpcOperation(request.url);
+  if (trpcOp) {
+    return matchTrpcRequest(trpcOp, clientCalls, request);
+  }
+  
+  // Check for GraphQL
+  const gqlOp = extractGraphqlOperation(request.url, request.body);
+  if (gqlOp) {
+    return matchGraphqlRequest(gqlOp, clientCalls, request);
+  }
+  
+  // Standard HTTP matching
+  const candidates = [];
+  
+  for (const call of clientCalls) {
+    if (call.kind !== "http") continue;
+    
+    const score = calculateMatchScore(normalizedPath, method, call, { basePath, rewrites });
+    if (score > 0) {
+      candidates.push({ call, score });
+    }
+  }
+  
+  // Sort by score descending
+  candidates.sort((a, b) => b.score - a.score);
+  
+  if (candidates.length === 0) {
+    return {
+      matched: false,
+      request,
+      normalizedPath,
+      method,
+      candidates: [],
+    };
+  }
+  
+  return {
+    matched: true,
+    request,
+    normalizedPath,
+    method,
+    bestMatch: candidates[0].call,
+    score: candidates[0].score,
+    candidates: candidates.slice(0, 3),
+  };
+}
+
+/**
+ * Match tRPC request to client calls
+ */
+function matchTrpcRequest(trpcOp, clientCalls, request) {
+  const trpcCalls = clientCalls.filter(c => c.kind === "trpc");
+  
+  for (const call of trpcCalls) {
+    const callProcedure = call.meta?.procedure;
+    if (!callProcedure) continue;
+    
+    // Check if any procedure matches
+    for (const proc of trpcOp.procedures) {
+      if (proc === callProcedure || proc.endsWith(callProcedure)) {
+        return {
+          matched: true,
+          request,
+          matchType: "trpc",
+          procedure: proc,
+          bestMatch: call,
+          score: 1.0,
+        };
+      }
+    }
+  }
+  
+  return {
+    matched: false,
+    request,
+    matchType: "trpc",
+    procedures: trpcOp.procedures,
+  };
+}
+
+/**
+ * Match GraphQL request to client calls
+ */
+function matchGraphqlRequest(gqlOp, clientCalls, request) {
+  const gqlCalls = clientCalls.filter(c => c.kind === "graphql");
+  
+  if (gqlOp.operationName) {
+    for (const call of gqlCalls) {
+      if (call.meta?.operationName === gqlOp.operationName) {
+        return {
+          matched: true,
+          request,
+          matchType: "graphql",
+          operationName: gqlOp.operationName,
+          bestMatch: call,
+          score: 1.0,
+        };
+      }
+    }
+  }
+  
+  // Fallback: match any GraphQL call
+  if (gqlCalls.length > 0) {
+    return {
+      matched: true,
+      request,
+      matchType: "graphql",
+      operationName: gqlOp.operationName,
+      bestMatch: gqlCalls[0],
+      score: 0.5,
+    };
+  }
+  
+  return {
+    matched: false,
+    request,
+    matchType: "graphql",
+    operationName: gqlOp.operationName,
+  };
+}
+
+/**
+ * Calculate match score between request and client call
+ */
+function calculateMatchScore(requestPath, requestMethod, call, options = {}) {
+  const { basePath = "", rewrites = [] } = options;
+  
+  let callPath = call.canonicalPath;
+  if (!callPath) return 0;
+  
+  // Apply rewrites
+  for (const rewrite of rewrites) {
+    if (rewrite.source && rewrite.destination) {
+      const sourceRegex = new RegExp("^" + rewrite.source.replace(/:(\w+)/g, "([^/]+)") + "$");
+      if (sourceRegex.test(requestPath)) {
+        // Rewrite matches, adjust call path expectation
+        callPath = requestPath.replace(sourceRegex, rewrite.destination);
+        break;
+      }
+    }
+  }
+  
+  let score = 0;
+  
+  // Exact path match
+  if (requestPath === callPath) {
+    score += 1.0;
+  }
+  // Parameterized match
+  else if (callPath.includes("{") || callPath.includes(":")) {
+    const pattern = "^" + callPath
+      .replace(/\{[^}]+\}/g, "[^/]+")
+      .replace(/:(\w+)/g, "[^/]+") + "$";
+    const regex = new RegExp(pattern);
+    if (regex.test(requestPath)) {
+      score += 0.9;
+    }
+  }
+  // Prefix match (less confident)
+  else if (requestPath.startsWith(callPath) || callPath.startsWith(requestPath)) {
+    score += 0.5;
+  }
+  
+  if (score === 0) return 0;
+  
+  // Method match bonus
+  const callMethod = (call.method || "UNKNOWN").toUpperCase();
+  if (callMethod === requestMethod) {
+    score += 0.1;
+  } else if (callMethod === "UNKNOWN" || callMethod === "*") {
+    // No penalty for unknown
+  } else {
+    score -= 0.2; // Method mismatch penalty
+  }
+  
+  // Confidence bonus
+  if (call.confidence === "high") {
+    score += 0.05;
+  } else if (call.confidence === "low") {
+    score -= 0.05;
+  }
+  
+  return Math.max(0, Math.min(1, score));
+}
+
+// =============================================================================
+// BATCH MAPPING
+// =============================================================================
+
+/**
+ * Map all runtime requests to client calls
+ */
+function mapAllRequests(requests, clientCalls, options = {}) {
+  const { basePath = "", rewrites = [], includeIgnored = false } = options;
+  
+  const results = {
+    mapped: [],
+    unmapped: [],
+    ignored: [],
+    stats: {
+      total: requests.length,
+      mapped: 0,
+      unmapped: 0,
+      ignored: 0,
+      byMatchType: {},
+    },
+  };
+  
+  for (const request of requests) {
+    // Check if should ignore
+    if (shouldIgnoreRequest(request.url, request.method)) {
+      if (includeIgnored) {
+        results.ignored.push(request);
+      }
+      results.stats.ignored++;
+      continue;
+    }
+    
+    const match = matchRequestToClientCalls(request, clientCalls, { basePath, rewrites });
+    
+    if (match.matched) {
+      results.mapped.push(match);
+      results.stats.mapped++;
+      
+      const matchType = match.matchType || "http";
+      results.stats.byMatchType[matchType] = (results.stats.byMatchType[matchType] || 0) + 1;
+    } else {
+      results.unmapped.push(match);
+      results.stats.unmapped++;
+    }
+  }
+  
+  return results;
+}
+
+/**
+ * Group mapped requests by client call
+ */
+function groupRequestsByClientCall(mappedResults) {
+  const groups = new Map();
+  
+  for (const match of mappedResults) {
+    if (!match.bestMatch) continue;
+    
+    const callId = match.bestMatch.id;
+    if (!groups.has(callId)) {
+      groups.set(callId, {
+        clientCall: match.bestMatch,
+        requests: [],
+        statuses: [],
+      });
+    }
+    
+    const group = groups.get(callId);
+    group.requests.push(match.request);
+    if (match.request.status) {
+      group.statuses.push(match.request.status);
+    }
+  }
+  
+  return groups;
+}
+
+// =============================================================================
+// EXPORTS
+// =============================================================================
+
+module.exports = {
+  // Ignore patterns
+  IGNORE_PATTERNS,
+  shouldIgnoreRequest,
+  
+  // URL normalization
+  normalizeRequestUrl,
+  extractTrpcOperation,
+  extractGraphqlOperation,
+  
+  // Matching
+  matchRequestToClientCalls,
+  calculateMatchScore,
+  
+  // Batch operations
+  mapAllRequests,
+  groupRequestsByClientCall,
+};