api-tests-coverage 1.0.0

package/dist/src/coverage/deep-analysis/callGraph.js

@@ -0,0 +1,275 @@
+"use strict";
+/**
+ * Deep Code Analysis — Call Graph Construction
+ *
+ * Builds a lightweight per-file call graph that maps function/method names to
+ * their bodies and the other local functions they call.
+ *
+ * This call graph is used by wrapper-method and helper-method resolution to
+ * follow call chains up to a configurable depth.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractJsFunctions = extractJsFunctions;
+exports.extractJavaKotlinFunctions = extractJavaKotlinFunctions;
+exports.extractPythonFunctions = extractPythonFunctions;
+exports.buildJsCallGraph = buildJsCallGraph;
+exports.buildJavaCallGraph = buildJavaCallGraph;
+exports.buildPythonCallGraph = buildPythonCallGraph;
+exports.extractBalancedBraces = extractBalancedBraces;
+// ─── Function body extraction ─────────────────────────────────────────────────
+/**
+ * Extract top-level function definitions and their bodies from
+ * TypeScript/JavaScript source.
+ *
+ * Handles:
+ *   function foo() { ... }
+ *   const foo = () => { ... }
+ *   const foo = (params) => { ... }
+ *   const foo = function() { ... }
+ */
+function extractJsFunctions(content) {
+    const functions = [];
+    // Named function declarations: function foo(...) { body }
+    extractBracedFunctions(content, /\bfunction\s+([A-Za-z_$][A-Za-z0-9_$]*)\s*\([^)]*\)\s*\{/, functions);
+    // Arrow functions: const foo = (...) => { body }
+    extractBracedFunctions(content, /\b(?:const|let|var)\s+([A-Za-z_$][A-Za-z0-9_$]*)\s*=\s*(?:\([^)]*\)|[A-Za-z_$][A-Za-z0-9_$]*)\s*=>\s*\{/, functions);
+    // Function expressions: const foo = function(...) { body }
+    extractBracedFunctions(content, /\b(?:const|let|var)\s+([A-Za-z_$][A-Za-z0-9_$]*)\s*=\s*function\s*\([^)]*\)\s*\{/, functions);
+    return functions;
+}
+/**
+ * Extract method definitions from Java / Kotlin source.
+ *
+ * Handles:
+ *   [modifiers] returnType methodName([params]) { body }
+ *   fun methodName([params]): ReturnType { body }
+ */
+function extractJavaKotlinFunctions(content) {
+    const functions = [];
+    // Java-style: ... MethodName(...) { body }
+    extractBracedFunctions(content, /\b([a-z_][A-Za-z0-9_]*)\s*\([^)]*\)\s*(?:throws\s+\w+(?:\s*,\s*\w+)*)?\s*\{/, functions);
+    // Kotlin fun: fun methodName(...) { body }
+    extractBracedFunctions(content, /\bfun\s+([A-Za-z_][A-Za-z0-9_]*)\s*\([^)]*\)/s, functions);
+    return functions;
+}
+/**
+ * Extract Python function definitions.
+ *
+ * Handles:
+ *   def function_name(params):
+ *       body (indented block)
+ */
+function extractPythonFunctions(content) {
+    var _a, _b;
+    const functions = [];
+    const defPattern = /^( *)def\s+([A-Za-z_][A-Za-z0-9_]*)\s*\([^)]*\)\s*:/gm;
+    let m;
+    while ((m = defPattern.exec(content)) !== null) {
+        const indent = m[1];
+        const name = m[2];
+        const startIdx = m.index + m[0].length;
+        // Find the end of the function body by looking for a line at the same or
+        // lesser indentation after the definition
+        const bodyLines = [];
+        const remaining = content.slice(startIdx);
+        const lines = remaining.split('\n');
+        // Determine body indentation (first non-empty line after def)
+        let bodyIndent = '';
+        for (const line of lines) {
+            if (line.trim() === '')
+                continue;
+            const lineIndentMatch = line.match(/^(\s+)/);
+            bodyIndent = lineIndentMatch ? lineIndentMatch[1] : '';
+            break;
+        }
+        if (!bodyIndent || bodyIndent.length <= indent.length) {
+            // No body or inline expression — skip
+            continue;
+        }
+        for (const line of lines) {
+            if (line.trim() === '') {
+                bodyLines.push(line);
+                continue;
+            }
+            const li = (_b = (_a = line.match(/^(\s*)/)) === null || _a === void 0 ? void 0 : _a[1]) !== null && _b !== void 0 ? _b : '';
+            if (li.length < bodyIndent.length && line.trim() !== '')
+                break;
+            bodyLines.push(line);
+        }
+        functions.push({ name, body: bodyLines.join('\n') });
+    }
+    return functions;
+}
+// ─── Call graph construction ──────────────────────────────────────────────────
+/**
+ * Build a call graph from JavaScript/TypeScript source.
+ */
+function buildJsCallGraph(content) {
+    const graph = new Map();
+    const funcs = extractJsFunctions(content);
+    for (const { name, body } of funcs) {
+        const node = {
+            name,
+            body,
+            calls: extractLocalCallsFromBody(body, funcs.map((f) => f.name)),
+            directHttpCalls: extractDirectHttpCallsFromBody(body),
+            returnValue: extractReturnStringLiteral(body),
+        };
+        graph.set(name, node);
+    }
+    return graph;
+}
+/**
+ * Build a call graph from Java/Kotlin source.
+ */
+function buildJavaCallGraph(content) {
+    const graph = new Map();
+    const funcs = extractJavaKotlinFunctions(content);
+    for (const { name, body } of funcs) {
+        const node = {
+            name,
+            body,
+            calls: extractLocalCallsFromBody(body, funcs.map((f) => f.name)),
+            directHttpCalls: extractDirectHttpCallsFromBody(body),
+            returnValue: extractReturnStringLiteralJava(body),
+        };
+        graph.set(name, node);
+    }
+    return graph;
+}
+/**
+ * Build a call graph from Python source.
+ */
+function buildPythonCallGraph(content) {
+    const graph = new Map();
+    const funcs = extractPythonFunctions(content);
+    for (const { name, body } of funcs) {
+        const node = {
+            name,
+            body,
+            calls: extractLocalCallsFromBody(body, funcs.map((f) => f.name)),
+            directHttpCalls: extractDirectHttpCallsFromBody(body),
+            returnValue: extractReturnStringLiteralPython(body),
+        };
+        graph.set(name, node);
+    }
+    return graph;
+}
+// ─── HTTP call extraction from body ──────────────────────────────────────────
+/**
+ * Find simple direct HTTP calls in a function body.
+ * Returns method+path pairs for string-literal calls only.
+ */
+function extractDirectHttpCallsFromBody(body) {
+    const calls = [];
+    // client.get('/path'), api.post('/path'), etc.
+    const httpPattern = /\.(get|post|put|patch|delete|head|options)\s*\(\s*['"`]([^'"`]+)['"`]\s*[),]/gi;
+    let m;
+    while ((m = httpPattern.exec(body)) !== null) {
+        calls.push({ method: m[1].toUpperCase(), path: m[2] });
+    }
+    // return client.get('/path')
+    const returnHttpPattern = /return\s+\w+\.(get|post|put|patch|delete|head|options)\s*\(\s*['"`]([^'"`]+)['"`]/gi;
+    while ((m = returnHttpPattern.exec(body)) !== null) {
+        calls.push({ method: m[1].toUpperCase(), path: m[2] });
+    }
+    return calls;
+}
+/**
+ * Find calls to other local functions in a body.
+ */
+function extractLocalCallsFromBody(body, localFunctionNames) {
+    const called = [];
+    for (const name of localFunctionNames) {
+        // name(...) appears in the body
+        const pattern = new RegExp(`\\b${escapeRegex(name)}\\s*\\(`, 'g');
+        if (pattern.test(body)) {
+            called.push(name);
+        }
+    }
+    return called;
+}
+// ─── Return value extraction ──────────────────────────────────────────────────
+/** Extract the string literal returned by a JS/TS function body, if any. */
+function extractReturnStringLiteral(body) {
+    const m = /\breturn\s+['"`]([^'"`\n]+)['"`]/.exec(body);
+    return m ? m[1] : undefined;
+}
+/** Extract the string literal returned by a Java/Kotlin method body. */
+function extractReturnStringLiteralJava(body) {
+    const m = /\breturn\s+"([^"\n]+)"/.exec(body);
+    return m ? m[1] : undefined;
+}
+/** Extract the string literal returned by a Python function body. */
+function extractReturnStringLiteralPython(body) {
+    const m = /\breturn\s+['"]([^'"\n]+)['"]/.exec(body);
+    return m ? m[1] : undefined;
+}
+// ─── Brace-balanced function body extraction ─────────────────────────────────
+/**
+ * Find all functions matching a pattern that starts a brace-delimited body
+ * and extract the body text (balanced braces).
+ */
+function extractBracedFunctions(content, headerPattern, results) {
+    const gPattern = new RegExp(headerPattern.source, 'g');
+    let m;
+    while ((m = gPattern.exec(content)) !== null) {
+        const name = m[1];
+        if (!name)
+            continue;
+        // Find the opening brace
+        const openBrace = content.indexOf('{', m.index + m[0].length - 1);
+        if (openBrace === -1)
+            continue;
+        // Extract balanced brace body
+        const body = extractBalancedBraces(content, openBrace);
+        if (body !== undefined) {
+            results.push({ name, body });
+        }
+    }
+}
+/**
+ * Extract the content of a brace-delimited block starting at `startIndex`
+ * (which must point at the opening `{`). Returns the inner body without
+ * the surrounding braces.
+ *
+ * Returns undefined if braces are not balanced.
+ */
+function extractBalancedBraces(content, startIndex) {
+    if (content[startIndex] !== '{')
+        return undefined;
+    let depth = 0;
+    let inString = null;
+    let i = startIndex;
+    while (i < content.length) {
+        const ch = content[i];
+        if (inString) {
+            if (ch === '\\') {
+                i += 2;
+                continue;
+            }
+            if (ch === inString)
+                inString = null;
+        }
+        else {
+            if (ch === '"' || ch === "'" || ch === '`') {
+                inString = ch;
+            }
+            else if (ch === '{') {
+                depth++;
+            }
+            else if (ch === '}') {
+                depth--;
+                if (depth === 0) {
+                    return content.slice(startIndex + 1, i);
+                }
+            }
+        }
+        i++;
+    }
+    return undefined;
+}
+// ─── Utility ──────────────────────────────────────────────────────────────────
+function escapeRegex(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}

package/dist/src/coverage/deep-analysis/deepEndpointResolver.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Deep Code Analysis — Deep Endpoint Resolver
+ *
+ * Orchestrates all deep-analysis sub-modules to extract HTTP calls from a
+ * single source file, resolving constants, enums, string templates, wrapper
+ * methods, request builders, and assertion linkage.
+ *
+ * The main entry point is `deepResolveFile()`.
+ */
+import type { DeepAnalysisConfig, ResolvedHttpCall } from './types';
+import { extractResponseVariables } from './resolveAssertions';
+/**
+ * Run deep endpoint analysis on a single source file.
+ *
+ * @param content       Raw file content
+ * @param filePath      Absolute path (used in output metadata)
+ * @param language      Detected language
+ * @param config        Deep analysis feature configuration
+ * @returns Array of resolved HTTP calls with resolution metadata
+ */
+export declare function deepResolveFile(content: string, filePath: string, language: 'typescript' | 'javascript' | 'java' | 'kotlin' | 'python' | 'ruby' | 'cucumber' | 'auto', config?: DeepAnalysisConfig): ResolvedHttpCall[];
+export { extractResponseVariables };
+//# sourceMappingURL=deepEndpointResolver.d.ts.map

package/dist/src/coverage/deep-analysis/deepEndpointResolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deepEndpointResolver.d.ts","sourceRoot":"","sources":["../../../../src/coverage/deep-analysis/deepEndpointResolver.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,kBAAkB,EAAE,gBAAgB,EAAgC,MAAM,SAAS,CAAC;AAyBlG,OAAO,EAAqB,wBAAwB,EAAE,MAAM,qBAAqB,CAAC;AAIlF;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAC7B,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,YAAY,GAAG,YAAY,GAAG,MAAM,GAAG,QAAQ,GAAG,QAAQ,GAAG,MAAM,GAAG,UAAU,GAAG,MAAM,EACnG,MAAM,GAAE,kBAAiD,GACxD,gBAAgB,EAAE,CA8MpB;AA0ND,OAAO,EAAE,wBAAwB,EAAE,CAAC"}