devlensio 0.4.2 → 0.4.4

package/dist/graph/edges/apiFetchEdges.js

@@ -1,6 +1,7 @@
 // This file detects the backend routes of the NEXTjs only
 import { Project, SyntaxKind } from "ts-morph";
 import path from "node:path";
+import { extractUrlFromArg, normalizeUrl, urlPathtoRegex } from "./helpers/routeMatching.js";
 const CALLER_CONFIG = {
     "fetch": { inferMethod: "from-options", defaultMethod: "GET" },
     "axios.get": { inferMethod: "fixed", method: "GET" },
@@ -20,16 +21,6 @@ const CALLER_CONFIG = {
     "useSWR": { inferMethod: "fixed", method: "GET" },
     "useSWRMutation": { inferMethod: "fixed", method: "UNKNOWN" },
 };
-function urlPathtoRegex(urlPath) {
-    const pattern = urlPath.split("/").map(segment => {
-        if (segment.startsWith(":") && segment.endsWith("*"))
-            return ".+"; // catch-all :slug*
-        if (segment.startsWith(":"))
-            return "[^/]+"; // dynamic :id
-        return segment.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"); // escape static segments
-    }).join("\\/");
-    return new RegExp(`^${pattern}$`);
-}
 // Groups Next.js API ROUTE nodes by HTTP method for efficient lookup.
 // Each route node carries a concrete method, so it is indexed under that one
 // method key. Callers with an UNKNOWN method (e.g. useSWRMutation) are handled
@@ -54,97 +45,6 @@ function buildRouteIndex(nodes) {
     }
     return index;
 }
-/*
-Extracts string value from an initializer node.
-Handles 3 cases:
-  'string literal'           → returns value directly
-  `no-substitution template` → returns value directly
-  `template ${expr} literal` → preserves ${...} as-is so normalizeUrl handles it later
-*/
-function resolveVariableValue(initializer) {
-    const kind = initializer.getKind();
-    if (kind === SyntaxKind.StringLiteral) {
-        return initializer.getLiteralText();
-    }
-    if (kind === SyntaxKind.NoSubstitutionTemplateLiteral) {
-        return initializer.getLiteralText();
-    }
-    if (kind === SyntaxKind.TemplateExpression) {
-        const head = initializer.getHead().getLiteralText();
-        const spans = initializer.getTemplateSpans().map((span) => `\${${span.getExpression().getText()}}${span.getLiteral().getLiteralText()}`);
-        return head + spans.join("");
-    }
-    return null; // object, function, computed — can't resolve
-}
-/*
-Resolves a variable name to its string value.
-Strategy:
-  1. Look in the same file
-  2. Walk named imports → find the source file → look there
-  Files not yet in the project are added lazily so we don't pre-load everything.
- */
-function resolveUrlVariable(varName, sourceFile, project) {
-    //case 1 -> Variable exists in same file
-    const localDecl = sourceFile.getVariableDeclaration(varName);
-    if (localDecl) {
-        const init = localDecl.getInitializer();
-        if (init)
-            return resolveVariableValue(init);
-    }
-    //case 2 -> named imports
-    for (const importDecl of sourceFile.getImportDeclarations()) {
-        const match = importDecl.getNamedImports().find(n => n.getName() === varName);
-        if (!match)
-            continue;
-        // Try to get the source file — it may not be in the project yet
-        let importedFile = importDecl.getModuleSpecifierSourceFile();
-        if (!importedFile) {
-            // Lazily add the file to the project
-            const specifier = importDecl.getModuleSpecifierValue();
-            const currentDir = path.dirname(sourceFile.getFilePath());
-            const base = path.resolve(currentDir, specifier);
-            for (const ext of [".ts", ".tsx", ".js", ".jsx"]) {
-                try {
-                    importedFile = project.addSourceFileAtPath(base + ext);
-                    break;
-                }
-                catch {
-                    continue;
-                }
-            }
-        }
-        if (!importedFile)
-            continue;
-        const importedDecl = importedFile.getVariableDeclaration(varName);
-        if (importedDecl) {
-            const init = importedDecl.getInitializer();
-            if (init)
-                return resolveVariableValue(init);
-        }
-    }
-    return null;
-}
-//  URL Normalization 
-// Converts a raw URL string from the call site into a normalized form
-// that can be compared against route index entries.
-// Examples:
-//   `/api/users/${id}`        → /api/users/:dynamic
-//   `/api/users/${org}/${id}` → /api/users/:dynamic/:dynamic
-//   /api/users?foo=bar        → /api/users
-//   /api/users/               → /api/users
-function normalizeUrl(rawUrl) {
-    // Skip external URLs
-    if (rawUrl.startsWith("http://") || rawUrl.startsWith("https://"))
-        return null;
-    // Must start with /
-    if (!rawUrl.startsWith("/"))
-        return null;
-    return rawUrl
-        .split("?")[0] // strip query string
-        .replace(/\$\{[^}]+\}/g, ":dynamic") // ${anything} → :dynamic
-        .replace(/\/+$/, "") // strip trailing slash
-        || "/"; // fallback to root if empty
-}
 //  Route Matching 
 // Matches a normalized URL + HTTP method against the route index.
 // Rules:
@@ -167,46 +67,19 @@ function matchRouteEntries(normalizedUrl, method, routeIndex) {
     // e.g. "/api/users/:dynamic" matches the regex for route "/api/users/:id".
     return candidates.filter(e => e.isDynamic && e.urlRegex.test(normalizedUrl));
 }
-//  URL Argument Extraction 
-// Shared helper — reconstructs a template literal preserving ${...} as-is
-// so normalizeUrl can replace them with :dynamic later.
-// Same logic as resolveVariableValue's TemplateExpression branch.
-function reconstructTemplate(templateExpr) {
-    const head = templateExpr.getHead().getLiteralText();
-    const spans = templateExpr.getTemplateSpans().map((span) => `\${${span.getExpression().getText()}}${span.getLiteral().getLiteralText()}`);
-    return head + spans.join("");
-}
-// Extracts a URL string from a call argument.
-// Handles 4 cases:
-//   '/api/users'          → string literal      → return directly
-//   `/api/users`          → no-sub template     → return directly
-//   `/api/users/${id}`    → template expression → preserve ${...}
-//   API_URL               → identifier          → resolve via resolveUrlVariable
-// Returns null if the arg is an object / array / expression we can't resolve.
-function extractUrlFromArg(arg, sourceFile, project) {
-    const kind = arg.getKind();
-    if (kind === SyntaxKind.StringLiteral ||
-        kind === SyntaxKind.NoSubstitutionTemplateLiteral) {
-        const url = arg.getLiteralText();
-        return { rawUrl: url, resolvedUrl: url };
-    }
-    if (kind === SyntaxKind.TemplateExpression) {
-        const url = reconstructTemplate(arg);
-        return { rawUrl: url, resolvedUrl: url };
-    }
-    if (kind === SyntaxKind.Identifier) {
-        const varName = arg.getText();
-        const resolved = resolveUrlVariable(varName, sourceFile, project);
-        if (!resolved)
-            return null;
-        return { rawUrl: varName, resolvedUrl: resolved };
-    }
-    return null;
-}
 // Scans EVERY call expression in a source file exactly once.
 // For each call matching CALLER_CONFIG:
 //   - infers the HTTP method
 //   - extracts and resolves the URL argument
+// It additionally scans for backend routes used as a resource URL:
+//   - JSX src/href attributes — tag-agnostic, so it covers native elements
+//     (<video src="/api/..">, <iframe src={url}>, <a href={`/api/${id}`}>)
+//     AND third-party player components (<HlsPlayer src={url} />,
+//     <ReactHlsPlayer src={...} />).
+//   - object-literal src/href properties — config-object style usage where a
+//     route is handed to a third-party player/function, e.g.
+//     loadPlayer({ src: '/api/stream' }).
+// The browser issues a GET for any such resource, so these are emitted as GET.
 // The expensive AST traversal happens once per file here; callers then
 // attribute the resulting calls to nodes by line range (see detectNextjsApiCallEdges).
 // Note: useQuery/useMutation inner fetch/axios calls are captured naturally
@@ -270,6 +143,64 @@ function extractApiCallsFromFile(sourceFile, project) {
             },
         });
     }
+    // JSX src/href attributes — tag-agnostic, so native elements (video, iframe,
+    // a) and third-party player components (HlsPlayer, ReactHlsPlayer, …) are all
+    // covered. The browser fetches the resource with GET.
+    for (const attr of sourceFile.getDescendantsOfKind(SyntaxKind.JsxAttribute)) {
+        const attrName = attr.getNameNode().getText();
+        if (attrName !== "src" && attrName !== "href")
+            continue;
+        const initializer = attr.getInitializer();
+        if (!initializer)
+            continue;
+        // value is either a bare string (src="/api/x") or a JSX expression
+        // container (src={url} / src={`/api/${id}`})
+        let valueNode;
+        const initKind = initializer.getKind();
+        if (initKind === SyntaxKind.StringLiteral) {
+            valueNode = initializer;
+        }
+        else if (initKind === SyntaxKind.JsxExpression) {
+            valueNode = initializer.getExpression();
+        }
+        if (!valueNode)
+            continue;
+        const urlResult = extractUrlFromArg(valueNode, sourceFile, project);
+        if (!urlResult)
+            continue;
+        results.push({
+            startLine: attr.getStartLineNumber(),
+            call: {
+                callerType: `jsx-${attrName}`,
+                rawUrl: urlResult.rawUrl,
+                resolvedUrl: urlResult.resolvedUrl,
+                method: "GET",
+            },
+        });
+    }
+    // Object-literal src/href properties — config-object style usage where a
+    // backend route is passed to a third-party player/function, e.g.
+    // loadPlayer({ src: '/api/stream' }). Same GET semantics.
+    for (const prop of sourceFile.getDescendantsOfKind(SyntaxKind.PropertyAssignment)) {
+        const name = prop.getName();
+        if (name !== "src" && name !== "href")
+            continue;
+        const init = prop.getInitializer();
+        if (!init)
+            continue;
+        const urlResult = extractUrlFromArg(init, sourceFile, project);
+        if (!urlResult)
+            continue;
+        results.push({
+            startLine: prop.getStartLineNumber(),
+            call: {
+                callerType: `prop-${name}`,
+                rawUrl: urlResult.rawUrl,
+                resolvedUrl: urlResult.resolvedUrl,
+                method: "GET",
+            },
+        });
+    }
     return results;
 }
 //MAIN FUNCTION 

package/dist/graph/edges/helpers/routeMatching.d.ts

@@ -0,0 +1,8 @@
+import { Project, SourceFile } from "ts-morph";
+export declare function urlPathtoRegex(urlPath: string): RegExp;
+export declare function normalizeUrl(rawUrl: string): string | null;
+export declare function reconstructTemplate(templateExpr: any): string;
+export declare function extractUrlFromArg(arg: any, sourceFile: SourceFile, project: Project): {
+    rawUrl: string;
+    resolvedUrl: string;
+} | null;

package/dist/graph/edges/helpers/routeMatching.js

@@ -0,0 +1,122 @@
+// Shared route/URL matching helpers used by both the Next.js API-call detector
+// (apiFetchEdges.ts) and the navigation detector (navigationEdges.ts).
+import { SyntaxKind } from "ts-morph";
+import path from "node:path";
+// Converts a route urlPath into a matching RegExp.
+//   :id    → [^/]+   (dynamic segment)
+//   :slug* → .+      (catch-all)
+//   static → escaped literally
+export function urlPathtoRegex(urlPath) {
+    const pattern = urlPath.split("/").map(segment => {
+        if (segment.startsWith(":") && segment.endsWith("*"))
+            return ".+"; // catch-all :slug*
+        if (segment.startsWith(":"))
+            return "[^/]+"; // dynamic :id
+        return segment.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"); // escape static segments
+    }).join("\\/");
+    return new RegExp(`^${pattern}$`);
+}
+// Converts a raw URL string from a call site into a normalized form comparable
+// against route index entries.
+//   `/api/users/${id}` → /api/users/:dynamic
+//   /api/users?foo=bar → /api/users
+//   /api/users/        → /api/users
+// Returns null for external (http/https) or non-"/"-prefixed URLs.
+export function normalizeUrl(rawUrl) {
+    if (rawUrl.startsWith("http://") || rawUrl.startsWith("https://"))
+        return null;
+    if (!rawUrl.startsWith("/"))
+        return null;
+    return rawUrl
+        .split("?")[0] // strip query string
+        .replace(/\$\{[^}]+\}/g, ":dynamic") // ${anything} → :dynamic
+        .replace(/\/+$/, "") // strip trailing slash
+        || "/"; // fallback to root if empty
+}
+// Reconstructs a template literal preserving ${...} as-is so normalizeUrl can
+// replace them with :dynamic later.
+export function reconstructTemplate(templateExpr) {
+    const head = templateExpr.getHead().getLiteralText();
+    const spans = templateExpr.getTemplateSpans().map((span) => `\${${span.getExpression().getText()}}${span.getLiteral().getLiteralText()}`);
+    return head + spans.join("");
+}
+// Extracts a string value from an initializer node (literal / template / etc).
+function resolveVariableValue(initializer) {
+    const kind = initializer.getKind();
+    if (kind === SyntaxKind.StringLiteral) {
+        return initializer.getLiteralText();
+    }
+    if (kind === SyntaxKind.NoSubstitutionTemplateLiteral) {
+        return initializer.getLiteralText();
+    }
+    if (kind === SyntaxKind.TemplateExpression) {
+        const head = initializer.getHead().getLiteralText();
+        const spans = initializer.getTemplateSpans().map((span) => `\${${span.getExpression().getText()}}${span.getLiteral().getLiteralText()}`);
+        return head + spans.join("");
+    }
+    return null; // object, function, computed — can't resolve
+}
+// Resolves a variable name to its string value (same file first, then named imports).
+function resolveUrlVariable(varName, sourceFile, project) {
+    const localDecl = sourceFile.getVariableDeclaration(varName);
+    if (localDecl) {
+        const init = localDecl.getInitializer();
+        if (init)
+            return resolveVariableValue(init);
+    }
+    for (const importDecl of sourceFile.getImportDeclarations()) {
+        const match = importDecl.getNamedImports().find(n => n.getName() === varName);
+        if (!match)
+            continue;
+        let importedFile = importDecl.getModuleSpecifierSourceFile();
+        if (!importedFile) {
+            const specifier = importDecl.getModuleSpecifierValue();
+            const currentDir = path.dirname(sourceFile.getFilePath());
+            const base = path.resolve(currentDir, specifier);
+            for (const ext of [".ts", ".tsx", ".js", ".jsx"]) {
+                try {
+                    importedFile = project.addSourceFileAtPath(base + ext);
+                    break;
+                }
+                catch {
+                    continue;
+                }
+            }
+        }
+        if (!importedFile)
+            continue;
+        const importedDecl = importedFile.getVariableDeclaration(varName);
+        if (importedDecl) {
+            const init = importedDecl.getInitializer();
+            if (init)
+                return resolveVariableValue(init);
+        }
+    }
+    return null;
+}
+// Extracts a URL string from a call/attr argument node.
+//   '/api/users'        → string literal      → return directly
+//   `/api/users`        → no-sub template     → return directly
+//   `/api/users/${id}`  → template expression → preserve ${...}
+//   API_URL             → identifier          → resolve via resolveUrlVariable
+// Returns null for objects/arrays/expressions we can't resolve.
+export function extractUrlFromArg(arg, sourceFile, project) {
+    const kind = arg.getKind();
+    if (kind === SyntaxKind.StringLiteral ||
+        kind === SyntaxKind.NoSubstitutionTemplateLiteral) {
+        const url = arg.getLiteralText();
+        return { rawUrl: url, resolvedUrl: url };
+    }
+    if (kind === SyntaxKind.TemplateExpression) {
+        const url = reconstructTemplate(arg);
+        return { rawUrl: url, resolvedUrl: url };
+    }
+    if (kind === SyntaxKind.Identifier) {
+        const varName = arg.getText();
+        const resolved = resolveUrlVariable(varName, sourceFile, project);
+        if (!resolved)
+            return null;
+        return { rawUrl: varName, resolvedUrl: resolved };
+    }
+    return null;
+}

package/dist/graph/edges/navigationEdges.d.ts

@@ -0,0 +1,5 @@
+import { CodeEdge, CodeNode } from "../../types.js";
+export declare function detectNavigationEdges(nodes: CodeNode[], repoPath: string): {
+    edges: CodeEdge[];
+    ghostNodes: CodeNode[];
+};