@shriyanss/js-recon 1.3.1-alpha.2 → 1.3.1-alpha.3

package/build/map/vue_js/vue_resolveFetch.js

@@ -12,9 +12,387 @@ import parser from "@babel/parser";
 import _traverse from "@babel/traverse";
 import fs from "fs";
 import path from "path";
-import { resolveNodeValue, substituteVariablesInString } from "../next_js/utils.js";
+import { resolveNodeValue, substituteVariablesInString, memberChainToString } from "../next_js/utils.js";
 import * as globals from "../../utility/globals.js";
 const traverse = _traverse.default;
+/**
+ * Checks whether invoking the given function body would directly execute a
+ * `fetch(...)` call (as a bare Identifier callee). Used to recognise functions
+ * that wrap the native fetch API so destructured aliases of those wrappers can
+ * be resolved as fetch calls.
+ *
+ * The walk stops at nested function boundaries so a factory function that
+ * RETURNS a fetch-wrapping arrow isn't itself classified as a wrapper — only
+ * the arrow it returns is.
+ */
+const NESTED_FN_TYPES = new Set(["ArrowFunctionExpression", "FunctionExpression", "FunctionDeclaration"]);
+/**
+ * A function is treated as a "transparent" fetch wrapper only if its first
+ * argument is forwarded as-is to fetch as the URL. Wrappers that construct the
+ * URL from a property of their input object have a different calling convention
+ * than `fetch(url, options)` — treating callsites of those as fetch calls
+ * produces garbage URLs. So we require that fetch's first arg is the function's
+ * first param (an Identifier match).
+ */
+const bodyCallsFetch = (functionNode) => {
+    var _a;
+    if (!functionNode || typeof functionNode !== "object")
+        return false;
+    const params = Array.isArray(functionNode.params) ? functionNode.params : [];
+    const firstParamName = params[0] && params[0].type === "Identifier"
+        ? params[0].name
+        : params[0] && params[0].type === "AssignmentPattern" && ((_a = params[0].left) === null || _a === void 0 ? void 0 : _a.type) === "Identifier"
+            ? params[0].left.name
+            : null;
+    if (!firstParamName)
+        return false;
+    let found = false;
+    const visit = (n, depth) => {
+        if (found || !n || typeof n !== "object")
+            return;
+        if (Array.isArray(n)) {
+            for (const child of n)
+                visit(child, depth);
+            return;
+        }
+        if (typeof n.type !== "string")
+            return;
+        // Don't descend into nested functions — they have their own invocation context.
+        if (depth > 0 && NESTED_FN_TYPES.has(n.type))
+            return;
+        if (n.type === "CallExpression" &&
+            n.callee &&
+            n.callee.type === "Identifier" &&
+            n.callee.name === "fetch" &&
+            Array.isArray(n.arguments) &&
+            n.arguments.length > 0 &&
+            n.arguments[0].type === "Identifier" &&
+            n.arguments[0].name === firstParamName) {
+            found = true;
+            return;
+        }
+        for (const key of Object.keys(n)) {
+            if (key === "loc" ||
+                key === "start" ||
+                key === "end" ||
+                key === "leadingComments" ||
+                key === "trailingComments") {
+                continue;
+            }
+            visit(n[key], depth + 1);
+        }
+    };
+    visit(functionNode, 0);
+    return found;
+};
+const isFunctionLike = (node) => !!node &&
+    (node.type === "ArrowFunctionExpression" ||
+        node.type === "FunctionExpression" ||
+        node.type === "FunctionDeclaration");
+/**
+ * Pulls out the function binding name from the surrounding declarator /
+ * assignment so we can later match callsites by identifier. Handles four
+ * common shapes seen in Vite-bundled code:
+ *   const fn = (arg) => { ... }
+ *   fn = (arg) => { ... }
+ *   function fn(arg) { ... }
+ *   { fn: (arg) => { ... } }  // object-literal property value
+ */
+const inferEnclosingFn = (callPath, file) => {
+    var _a, _b, _c, _d, _e, _f, _g, _h;
+    const fnPath = callPath.getFunctionParent();
+    if (!fnPath)
+        return null;
+    const fnNode = fnPath.node;
+    const firstParamName = fnNode.params && ((_a = fnNode.params[0]) === null || _a === void 0 ? void 0 : _a.type) === "Identifier"
+        ? fnNode.params[0].name
+        : fnNode.params &&
+            ((_b = fnNode.params[0]) === null || _b === void 0 ? void 0 : _b.type) === "AssignmentPattern" &&
+            ((_c = fnNode.params[0].left) === null || _c === void 0 ? void 0 : _c.type) === "Identifier"
+            ? fnNode.params[0].left.name
+            : null;
+    let bindingName = null;
+    if (fnNode.type === "FunctionDeclaration" && ((_d = fnNode.id) === null || _d === void 0 ? void 0 : _d.type) === "Identifier") {
+        bindingName = fnNode.id.name;
+    }
+    else {
+        const parentNode = (_e = fnPath.parentPath) === null || _e === void 0 ? void 0 : _e.node;
+        if (parentNode) {
+            if (parentNode.type === "VariableDeclarator" && ((_f = parentNode.id) === null || _f === void 0 ? void 0 : _f.type) === "Identifier") {
+                bindingName = parentNode.id.name;
+            }
+            else if (parentNode.type === "AssignmentExpression" && ((_g = parentNode.left) === null || _g === void 0 ? void 0 : _g.type) === "Identifier") {
+                bindingName = parentNode.left.name;
+            }
+            else if (parentNode.type === "ObjectProperty" &&
+                !parentNode.computed &&
+                ((_h = parentNode.key) === null || _h === void 0 ? void 0 : _h.type) === "Identifier") {
+                bindingName = parentNode.key.name;
+            }
+        }
+    }
+    return { bindingName, firstParamName, node: fnNode, file };
+};
+/**
+ * Walks an ObjectExpression and returns the property value for the given
+ * dotted property path (e.g. ["data"] -> the value node of `data: ...`).
+ * Returns null if any segment of the path isn't a literal property.
+ */
+const lookupObjectExpressionProp = (objExpr, propPath) => {
+    if (!objExpr || objExpr.type !== "ObjectExpression")
+        return null;
+    let current = objExpr;
+    for (const segment of propPath) {
+        if (!current || current.type !== "ObjectExpression")
+            return null;
+        let next = null;
+        for (const prop of current.properties) {
+            if (prop.type !== "ObjectProperty")
+                continue;
+            const key = prop.key.type === "Identifier"
+                ? prop.key.name
+                : prop.key.type === "StringLiteral"
+                    ? prop.key.value
+                    : null;
+            if (key === segment) {
+                next = prop.value;
+                break;
+            }
+        }
+        if (!next)
+            return null;
+        current = next;
+    }
+    return current;
+};
+/**
+ * Resolves the value of `paramName.propPath` by walking back through the
+ * enclosing function's callers. If a caller's argument is itself an Identifier
+ * pointing to a constant initializer, we follow that binding; if it's the
+ * caller's own first parameter, we recurse to that function's callers.
+ *
+ * Returns the resolved AST node + the scope it lives in (so further sub-property
+ * resolution can use the correct binding lookup), or null when the chain breaks.
+ */
+const resolveParamProperty = (paramName, propPath, enclosingFn, getCallers, depth = 0) => {
+    var _a, _b, _c;
+    if (!enclosingFn || !enclosingFn.bindingName || depth > 6)
+        return null;
+    // Only the function's first parameter is supported for now — every observed
+    // case has fetch wrappers shaped as `(e) => fetch(... e.X ...)`.
+    if (enclosingFn.firstParamName !== paramName)
+        return null;
+    const callers = getCallers(enclosingFn.bindingName);
+    if (!callers || callers.length === 0)
+        return null;
+    for (const caller of callers) {
+        const arg = caller.args[0];
+        if (!arg)
+            continue;
+        // Case 1: caller passes an object literal directly — fn({ a: ..., b: ... })
+        if (arg.type === "ObjectExpression") {
+            const node = lookupObjectExpressionProp(arg, propPath);
+            if (node)
+                return { node, scope: caller.scope, fileContent: caller.fileContent };
+        }
+        // Case 2: caller passes an Identifier pointing to a const-initialized
+        // object literal — `const x = { a: ... }; fn(x)`.
+        if (arg.type === "Identifier") {
+            const binding = caller.scope.getBinding(arg.name);
+            const initNode = (_b = (_a = binding === null || binding === void 0 ? void 0 : binding.path) === null || _a === void 0 ? void 0 : _a.node) === null || _b === void 0 ? void 0 : _b.init;
+            if (initNode && initNode.type === "ObjectExpression") {
+                const node = lookupObjectExpressionProp(initNode, propPath);
+                if (node)
+                    return { node, scope: caller.scope, fileContent: caller.fileContent };
+            }
+            // Case 3: caller passes its own first param straight through —
+            // `outer = (p) => fn(p)`. Recurse up to that function's callers.
+            if (((_c = caller.enclosingFn) === null || _c === void 0 ? void 0 : _c.firstParamName) === arg.name) {
+                const result = resolveParamProperty(arg.name, propPath, caller.enclosingFn, getCallers, depth + 1);
+                if (result)
+                    return result;
+            }
+        }
+    }
+    return null;
+};
+/**
+ * Renders an ObjectExpression as a `k1={k1}&k2={k2}` query-string fragment.
+ * Literal property values are URL-encoded directly; non-literal values fall
+ * back to the placeholder form so the schema reader can see what's missing.
+ */
+const renderObjectAsQuery = (objExpr, scope, fileContent) => {
+    if (!objExpr || objExpr.type !== "ObjectExpression")
+        return null;
+    const parts = [];
+    for (const prop of objExpr.properties) {
+        if (prop.type !== "ObjectProperty")
+            continue;
+        const key = prop.key.type === "Identifier" ? prop.key.name : prop.key.type === "StringLiteral" ? prop.key.value : null;
+        if (!key)
+            continue;
+        let valStr;
+        try {
+            const resolved = resolveNodeValue(prop.value, scope, "", "fetch", fileContent);
+            if (resolved !== null && resolved !== undefined && !String(resolved).startsWith("[")) {
+                valStr = encodeURIComponent(String(resolved));
+            }
+            else {
+                valStr = `{${key}}`;
+            }
+        }
+        catch (_a) {
+            valStr = `{${key}}`;
+        }
+        parts.push(`${key}=${valStr}`);
+    }
+    return parts.length > 0 ? parts.join("&") : null;
+};
+/**
+ * Returns a plain object derived from an ObjectExpression's properties.
+ * Spread elements are merged in when they themselves resolve to a literal
+ * object; otherwise the spread is preserved as a sentinel key so the schema
+ * reader knows extra fields exist at runtime.
+ */
+const renderObjectExpression = (objExpr, scope, fileContent) => {
+    if (!objExpr || objExpr.type !== "ObjectExpression")
+        return null;
+    const out = {};
+    for (const prop of objExpr.properties) {
+        if (prop.type === "ObjectProperty") {
+            const key = prop.key.type === "Identifier"
+                ? prop.key.name
+                : prop.key.type === "StringLiteral"
+                    ? prop.key.value
+                    : null;
+            if (!key)
+                continue;
+            try {
+                const resolved = resolveNodeValue(prop.value, scope, "", "fetch", fileContent);
+                out[key] = resolved === undefined || resolved === null ? "" : String(resolved);
+            }
+            catch (_a) {
+                out[key] = "";
+            }
+        }
+        else if (prop.type === "SpreadElement") {
+            try {
+                const resolved = resolveNodeValue(prop.argument, scope, "", "fetch", fileContent);
+                if (resolved && typeof resolved === "object") {
+                    for (const [k, v] of Object.entries(resolved)) {
+                        if (!(k in out))
+                            out[k] = v === undefined || v === null ? "" : String(v);
+                    }
+                }
+                else {
+                    const chain = memberChainToString(prop.argument);
+                    out[`...${chain !== null && chain !== void 0 ? chain : "spread"}`] = "<spread>";
+                }
+            }
+            catch (_b) {
+                const chain = memberChainToString(prop.argument);
+                out[`...${chain !== null && chain !== void 0 ? chain : "spread"}`] = "<spread>";
+            }
+        }
+    }
+    return out;
+};
+/**
+ * Tries to convert a value node into a printable string, transparently
+ * unwrapping template literals built from caller-side bindings. Returns null
+ * when the value is itself a Vue-style ref / member expression that we can't
+ * pin down statically.
+ */
+const renderValueNode = (node, scope, fileContent) => {
+    if (!node)
+        return null;
+    try {
+        const resolved = resolveNodeValue(node, scope, "", "fetch", fileContent);
+        if (resolved === null || resolved === undefined)
+            return null;
+        if (typeof resolved === "object") {
+            // Avoid emitting `[object Object]` — leave it to the upstream
+            // placeholder so the consumer knows it's structured.
+            return null;
+        }
+        const s = String(resolved);
+        if (s.startsWith("[unresolved"))
+            return null;
+        return s;
+    }
+    catch (_a) {
+        return null;
+    }
+};
+/**
+ * Substitutes [member:P.X], [param:P], and [urlsearchparams:P.X] markers in a
+ * string by walking back to the enclosing function's caller(s). The string is
+ * returned with as many markers resolved as we could trace.
+ */
+const substituteCallerPlaceholders = (input, enclosingFn, getCallers) => {
+    if (!input || !enclosingFn)
+        return input;
+    let output = input;
+    output = output.replace(/\[urlsearchparams:([A-Za-z_$][\w$.]*)\]/g, (match, chain) => {
+        const parts = chain.split(".");
+        if (parts.length < 1)
+            return match;
+        const paramName = parts[0];
+        const propPath = parts.slice(1);
+        const resolved = resolveParamProperty(paramName, propPath, enclosingFn, getCallers);
+        if (!resolved)
+            return match;
+        const rendered = renderObjectAsQuery(resolved.node, resolved.scope, resolved.fileContent);
+        return rendered !== null && rendered !== void 0 ? rendered : match;
+    });
+    output = output.replace(/\[member:([A-Za-z_$][\w$.]*)\]/g, (match, chain) => {
+        const parts = chain.split(".");
+        if (parts.length < 1)
+            return match;
+        const paramName = parts[0];
+        const propPath = parts.slice(1);
+        const resolved = resolveParamProperty(paramName, propPath, enclosingFn, getCallers);
+        if (!resolved)
+            return match;
+        const rendered = renderValueNode(resolved.node, resolved.scope, resolved.fileContent);
+        return rendered !== null && rendered !== void 0 ? rendered : match;
+    });
+    return output;
+};
+/**
+ * Substitutes placeholders in a header bag. `...P.X: <spread>` entries are
+ * expanded when the corresponding caller-side value is a literal object;
+ * `[member:P.X]` markers inside header values are substituted in-place.
+ */
+const substituteCallerHeaders = (headers, enclosingFn, getCallers) => {
+    if (!enclosingFn)
+        return headers;
+    const out = {};
+    for (const [k, v] of Object.entries(headers)) {
+        if (k.startsWith("...") && v === "<spread>") {
+            const chain = k.slice(3);
+            const parts = chain.split(".");
+            const paramName = parts[0];
+            const propPath = parts.slice(1);
+            const resolved = resolveParamProperty(paramName, propPath, enclosingFn, getCallers);
+            if (resolved && resolved.node.type === "ObjectExpression") {
+                const obj = renderObjectExpression(resolved.node, resolved.scope, resolved.fileContent);
+                if (obj) {
+                    for (const [hk, hv] of Object.entries(obj)) {
+                        if (!(hk in out))
+                            out[hk] = hv;
+                    }
+                    continue;
+                }
+            }
+            out[k] = v;
+        }
+        else {
+            out[k] = substituteCallerPlaceholders(v, enclosingFn, getCallers);
+        }
+    }
+    return out;
+};
 /**
  * Scans all JS files in the given directory for fetch() calls,
  * resolves their URL / method / headers / body, and registers each
@@ -36,7 +414,13 @@ const vue_resolveFetch = (directory) => __awaiter(void 0, void 0, void 0, functi
     files = files
         .filter((f) => f.endsWith(".js") && !f.includes("___subsequent_requests"))
         .filter((f) => !fs.lstatSync(path.join(directory, f)).isDirectory());
-    let totalFetchCalls = 0;
+    // Pre-pass: scan every file for object-literal properties whose value is a
+    // function that ultimately calls fetch(). Their property names are the
+    // fetch-wrapper keys downstream code destructures and invokes in place of
+    // fetch — so we need to recognise those aliases.
+    const wrapperKeyNames = new Set();
+    const fileAstCache = new Map();
+    const fileContentCache = new Map();
     for (const file of files) {
         const filePath = path.join(directory, file);
         let fileContent;
@@ -46,7 +430,6 @@ const vue_resolveFetch = (directory) => __awaiter(void 0, void 0, void 0, functi
         catch (_b) {
             continue;
         }
-        // Fast path: skip files with no fetch keyword at all
         if (!fileContent.includes("fetch"))
             continue;
         let fileAst;
@@ -60,17 +443,147 @@ const vue_resolveFetch = (directory) => __awaiter(void 0, void 0, void 0, functi
         catch (_c) {
             continue;
         }
-        // Collect fetch aliases (const x = fetch)
+        fileAstCache.set(filePath, fileAst);
+        fileContentCache.set(filePath, fileContent);
+        traverse(fileAst, {
+            ObjectProperty(p) {
+                const key = p.node.key;
+                const value = p.node.value;
+                if (!isFunctionLike(value))
+                    return;
+                if (!bodyCallsFetch(value))
+                    return;
+                const keyName = key.type === "Identifier" ? key.name : key.type === "StringLiteral" ? key.value : null;
+                if (keyName)
+                    wrapperKeyNames.add(keyName);
+            },
+        });
+    }
+    // Lazy caller lookup. Rather than building a global index of every
+    // CallExpression in every bundle (which becomes O(huge) for minified Vite
+    // chunks), we only search when phase-2 actually asks for a specific binding
+    // name, and cache the per-name result. The fast `fileContent.includes`
+    // check skips files that can't possibly contain the call. When the call
+    // count blows past a sane budget we treat the name as too ambiguous to be
+    // useful for tracing and short-circuit to an empty list.
+    const MAX_CALLERS_PER_NAME = 64;
+    const callerCache = new Map();
+    const getCallers = (bindingName) => {
+        var _a;
+        const cached = callerCache.get(bindingName);
+        if (cached)
+            return cached;
+        const needle = `${bindingName}(`;
+        const out = [];
+        let overflowed = false;
+        for (const [filePath, fileAst] of fileAstCache.entries()) {
+            if (overflowed)
+                break;
+            const fileContent = (_a = fileContentCache.get(filePath)) !== null && _a !== void 0 ? _a : "";
+            if (!fileContent.includes(needle))
+                continue;
+            traverse(fileAst, {
+                CallExpression(callPath) {
+                    if (overflowed) {
+                        callPath.stop();
+                        return;
+                    }
+                    const callee = callPath.node.callee;
+                    if (callee.type !== "Identifier" || callee.name !== bindingName)
+                        return;
+                    if (out.length >= MAX_CALLERS_PER_NAME) {
+                        overflowed = true;
+                        callPath.stop();
+                        return;
+                    }
+                    out.push({
+                        file: filePath,
+                        fileContent,
+                        callNode: callPath.node,
+                        scope: callPath.scope,
+                        args: callPath.node.arguments,
+                        enclosingFn: inferEnclosingFn(callPath, filePath),
+                    });
+                },
+            });
+        }
+        // A name with this many callsites is almost certainly a minifier
+        // single-letter local (e, t, n, …) — tracing it is noise, not signal.
+        const result = overflowed ? [] : out;
+        callerCache.set(bindingName, result);
+        return result;
+    };
+    let totalFetchCalls = 0;
+    // Counter for per-callsite uniqueness so two callsites at the same path+method
+    // are kept distinct in mapped.json and downstream specs.
+    let callsiteCounter = 0;
+    const entries = [];
+    for (const file of files) {
+        const filePath = path.join(directory, file);
+        let fileContent = fileContentCache.get(filePath);
+        let fileAst = fileAstCache.get(filePath);
+        if (!fileContent || !fileAst) {
+            try {
+                fileContent = fs.readFileSync(filePath, "utf-8");
+            }
+            catch (_d) {
+                continue;
+            }
+            if (!fileContent.includes("fetch"))
+                continue;
+            try {
+                fileAst = parser.parse(fileContent, {
+                    sourceType: "unambiguous",
+                    plugins: ["jsx", "typescript"],
+                    errorRecovery: true,
+                });
+            }
+            catch (_e) {
+                continue;
+            }
+        }
+        // Collect fetch aliases:
+        //   1. `const x = fetch` (direct identifier aliasing)
+        //   2. `const x = (i, l) => fetch(i, l)` (function-literal wrappers)
+        //   3. `const { wrapperKey: x } = factory({...})` (destructured wrapper keys)
         const fetchAliases = new Set();
         traverse(fileAst, {
             VariableDeclarator(p) {
                 const { id, init } = p.node;
-                if (id.type !== "Identifier" || !init)
+                if (!init)
                     return;
-                if (init.type === "Identifier" && init.name === "fetch") {
-                    const binding = p.scope.getBinding(id.name);
-                    if (binding)
-                        fetchAliases.add(binding);
+                if (id.type === "Identifier") {
+                    if (init.type === "Identifier" && init.name === "fetch") {
+                        const binding = p.scope.getBinding(id.name);
+                        if (binding)
+                            fetchAliases.add(binding);
+                        return;
+                    }
+                    if (isFunctionLike(init) && bodyCallsFetch(init)) {
+                        const binding = p.scope.getBinding(id.name);
+                        if (binding)
+                            fetchAliases.add(binding);
+                        return;
+                    }
+                }
+                if (id.type === "ObjectPattern") {
+                    for (const prop of id.properties) {
+                        if (prop.type !== "ObjectProperty")
+                            continue;
+                        const keyName = prop.key.type === "Identifier"
+                            ? prop.key.name
+                            : prop.key.type === "StringLiteral"
+                                ? prop.key.value
+                                : null;
+                        if (!keyName || !wrapperKeyNames.has(keyName))
+                            continue;
+                        const valueName = prop.value.type === "Identifier" ? prop.value.name : null;
+                        if (!valueName)
+                            continue;
+                        const binding = p.scope.getBinding(valueName);
+                        if (binding)
+                            fetchAliases.add(binding);
+                    }
                 }
             },
         });
@@ -108,7 +621,6 @@ const vue_resolveFetch = (directory) => __awaiter(void 0, void 0, void 0, functi
                         url = substituted;
                     }
                 }
-                console.log(chalk.green(`    URL: ${url}`));
                 let method = "GET";
                 let headers = {};
                 let body = "";
@@ -129,26 +641,81 @@ const vue_resolveFetch = (directory) => __awaiter(void 0, void 0, void 0, functi
                             body =
                                 typeof options.body === "object" ? JSON.stringify(options.body) : String(options.body);
                         }
-                        console.log(chalk.green(`    Method: ${method}`));
-                        if (Object.keys(headers).length > 0)
-                            console.log(chalk.green(`    Headers: ${JSON.stringify(headers)}`));
-                        if (body)
-                            console.log(chalk.green(`    Body: ${body}`));
                     }
                 }
-                globals.addOpenapiOutput({
-                    url: String(url),
+                const enclosingFn = inferEnclosingFn(callPath, filePath);
+                entries.push({
+                    file,
+                    filePath,
+                    fileContent,
+                    fileLine,
+                    url: typeof url === "string" ? url : "",
                     method,
-                    path: String(url),
                     headers,
                     body,
-                    chunkId: file,
-                    functionFile: filePath,
-                    functionFileLine: fileLine,
+                    enclosingFn,
                 });
             },
         });
     }
+    // Second pass: walk back to each fetch's enclosing function callers and
+    // substitute markers we couldn't resolve in the first pass. This is where
+    // `?[urlsearchparams:p.q]` turns into `?k1={k1}&k2={k2}`, and where
+    // `...p.q: <spread>` gets expanded if a literal object was passed.
+    const MARKER_RE = /\[(urlsearchparams|member|param):/;
+    const headersHaveMarkers = (h) => {
+        for (const [k, v] of Object.entries(h)) {
+            if (k.startsWith("...") && v === "<spread>")
+                return true;
+            if (MARKER_RE.test(v))
+                return true;
+        }
+        return false;
+    };
+    for (const entry of entries) {
+        if (entry.enclosingFn &&
+            entry.enclosingFn.bindingName &&
+            entry.enclosingFn.firstParamName &&
+            (MARKER_RE.test(entry.url) || MARKER_RE.test(entry.body) || headersHaveMarkers(entry.headers))) {
+            entry.url = substituteCallerPlaceholders(entry.url, entry.enclosingFn, getCallers);
+            entry.headers = substituteCallerHeaders(entry.headers, entry.enclosingFn, getCallers);
+            entry.body = substituteCallerPlaceholders(entry.body, entry.enclosingFn, getCallers);
+        }
+        console.log(chalk.green(`    URL: ${entry.url}`));
+        if (entry.method !== "GET" || Object.keys(entry.headers).length > 0 || entry.body) {
+            console.log(chalk.green(`    Method: ${entry.method}`));
+        }
+        if (Object.keys(entry.headers).length > 0)
+            console.log(chalk.green(`    Headers: ${JSON.stringify(entry.headers)}`));
+        if (entry.body)
+            console.log(chalk.green(`    Body: ${entry.body}`));
+        // Skip the openapi/postman registration for callsites where the URL
+        // never resolved to anything URL-shaped. Examples:
+        //   - inner wrapper bodies like `fetch(i, l)` where `i` is a param
+        //   - non-string AST nodes (objects, member expressions) that have
+        //     no chance of being a real path
+        const urlStr = entry.url;
+        const looksLikeUrl = urlStr.length > 0 &&
+            !urlStr.startsWith("[") &&
+            urlStr !== "[object Object]" &&
+            (urlStr.startsWith("http://") ||
+                urlStr.startsWith("https://") ||
+                urlStr.startsWith("/") ||
+                /^[A-Za-z0-9_\-.]+\//.test(urlStr));
+        if (!looksLikeUrl)
+            continue;
+        callsiteCounter++;
+        globals.addOpenapiOutput({
+            url: urlStr,
+            method: entry.method,
+            path: urlStr,
+            headers: entry.headers,
+            body: entry.body,
+            chunkId: `${entry.file}:${entry.fileLine}`,
+            functionFile: entry.filePath,
+            functionFileLine: entry.fileLine,
+        });
+    }
     console.log(chalk.green(`[✓] Found and resolved ${totalFetchCalls} fetch call(s) across Vue.JS files`));
 });
 export default vue_resolveFetch;