cgraphx 2.0.2 → 2.0.3

package/dist/core/code/engine/core/ingestion/languages/typescript/nuxt-auto-imports.js

@@ -0,0 +1,325 @@
+"use strict";
+/**
+ * Nuxt v4 auto-import resolution for the TypeScript scope-resolver.
+ *
+ * Nuxt and Nitro both make symbols available project-wide without explicit
+ * import statements. Two sources cover the common cases:
+ *
+ *   1. `.nuxt/imports.d.ts` - client/shared composables generated by Nuxt at
+ *      build time. Only entries whose source is a project-local relative path
+ *      (i.e. NOT a package in node_modules or a Nuxt runtime alias) are
+ *      indexed. These are project utils and composables the developer wrote.
+ *
+ *   2. `server/utils/**` - Nitro auto-imports all exports from this directory
+ *      tree into every `server/api/`, `server/routes/`, and
+ *      `server/middleware/` file. These are not included in `imports.d.ts`
+ *      because they are server-only.
+ *
+ * The two sources are kept in separate maps because their visibility scopes
+ * differ: app/client files do not see `server/utils`, while Nitro server
+ * handlers prefer same-named server utilities over client composables.
+ *
+ * Detection: if `.nuxt/imports.d.ts` is absent the repo is not a Nuxt project
+ * and this module returns null immediately, adding zero overhead to non-Nuxt
+ * analysis runs. The `server/utils` scan is only attempted when the Nuxt
+ * detection succeeds, so it also costs nothing for non-Nuxt repos.
+ *
+ * Limitations:
+ *   - Auto-import edges are still heuristic rather than type-checked. The
+ *     emitter tags them with confidence 0.75.
+ *   - Re-exports with non-matching aliases (e.g. `flatUnwrap as unwrapSlot`
+ *     where `flatUnwrap` is the graph node name) try both the original export
+ *     name and the local alias when looking up the graph node.
+ *   - Only direct exports are indexed; barrel re-exports that chain through
+ *     multiple files are not followed.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadNuxtAutoImports = loadNuxtAutoImports;
+exports.hasNuxtAutoImports = hasNuxtAutoImports;
+exports.getNuxtAutoImportEntry = getNuxtAutoImportEntry;
+exports.isNitroServerRuntimeFile = isNitroServerRuntimeFile;
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+const FILE_EXTENSIONS = ['.ts', '.tsx', '.js', '.jsx'];
+const GENERATED_DIR_NAMES = new Set([
+    '.git',
+    '.nuxt',
+    '.output',
+    '.next',
+    'build',
+    'coverage',
+    'dist',
+    'node_modules',
+]);
+const IMPORTS_DTS_EXPORT_RE = /^export\s*\{([^}]+)\}\s*from\s*['"]([^'"]+)['"]/gm;
+const NITRO_DECLARATION_EXPORT_RE = /^export\s+(?:default\s+)?(?:async\s+)?function\s+([A-Za-z_$][A-Za-z0-9_$]*)|^export\s+(?:default\s+)?class\s+([A-Za-z_$][A-Za-z0-9_$]*)/gm;
+const NITRO_VARIABLE_EXPORT_RE = /^export\s+(?:const|let|var)\s+([^;\n]+)/gm;
+// Matches the binding name at the head of a single declarator (`name`, `name:`, `name =`).
+// A leading `{`/`[` (destructuring) does not match, so destructured exports are skipped.
+const DECLARATOR_NAME_RE = /^\s*([A-Za-z_$][A-Za-z0-9_$]*)/;
+// ---- loader -----------------------------------------------------------------
+/**
+ * Load the Nuxt auto-import map for `repoRoot`.
+ *
+ * Returns null when:
+ *   - `.nuxt/imports.d.ts` does not exist (non-Nuxt project or pre-build), or
+ *   - the file exists but yields zero project-local entries and `server/utils`
+ *     is absent or empty.
+ *
+ * The `server/utils` scan is only attempted when `.nuxt/imports.d.ts` was
+ * successfully read, confirming this is an initialized Nuxt project. This
+ * avoids partial results from repos that have a `server/utils` directory but
+ * are not Nuxt projects.
+ */
+async function loadNuxtAutoImports(repoRoot) {
+    const clientByLocalName = new Map();
+    const serverByLocalName = new Map();
+    const nuxtInitialized = await collectImportsDts(repoRoot, clientByLocalName);
+    // Only scan server/utils when imports.d.ts was present, confirming this is
+    // an initialized Nuxt project. Without this gate, a non-Nuxt repo with a
+    // server/utils directory would get spurious Nitro auto-import edges.
+    if (nuxtInitialized) {
+        await collectNitroServerUtils(repoRoot, serverByLocalName);
+    }
+    const config = { clientByLocalName, serverByLocalName };
+    return hasNuxtAutoImports(config) ? config : null;
+}
+function hasNuxtAutoImports(config) {
+    return config.clientByLocalName.size > 0 || config.serverByLocalName.size > 0;
+}
+function getNuxtAutoImportEntry(config, localName, callerFile) {
+    if (isNitroServerRuntimeFile(callerFile)) {
+        // Nitro auto-imports only `server/utils/**` into the server context; app
+        // `composables/` are Vue-app-only. Server callers therefore resolve the
+        // server map only — no client fallback, which would emit cross-context
+        // CALLS edges Nitro never actually creates.
+        return config.serverByLocalName.get(localName);
+    }
+    return config.clientByLocalName.get(localName);
+}
+/**
+ * Directories whose files run in the Nitro server context and so receive
+ * `server/utils` auto-imports without an explicit import: API routes, server
+ * routes, middleware, plugins, and (Nitro 2.6+) tasks.
+ */
+const NITRO_RUNTIME_DIR_PREFIXES = [
+    'server/api/',
+    'server/routes/',
+    'server/middleware/',
+    'server/plugins/',
+    'server/tasks/',
+];
+function isNitroServerRuntimeFile(filePath) {
+    const normalized = filePath.replace(/\\/g, '/');
+    return NITRO_RUNTIME_DIR_PREFIXES.some((prefix) => normalized.startsWith(prefix));
+}
+// ---- .nuxt/imports.d.ts -----------------------------------------------------
+/**
+ * Parse `.nuxt/imports.d.ts` and add project-local entries to `byLocalName`.
+ *
+ * The file contains lines of the form:
+ *   export { name1, name2, origName as alias } from 'source'
+ *
+ * Only entries with a source that is a project-local relative path
+ * (starts with `./` or `../` AND does not contain `node_modules`) are
+ * included. Nuxt runtime paths (`#app/...`) and third-party packages are
+ * intentionally skipped because they have no graph nodes in the repo.
+ *
+ * @returns true when `.nuxt/imports.d.ts` was successfully read.
+ */
+async function collectImportsDts(repoRoot, byLocalName) {
+    const importsPath = path_1.default.join(repoRoot, '.nuxt', 'imports.d.ts');
+    let content;
+    try {
+        content = await promises_1.default.readFile(importsPath, 'utf-8');
+    }
+    catch {
+        return false;
+    }
+    const nuxtDir = path_1.default.join(repoRoot, '.nuxt');
+    IMPORTS_DTS_EXPORT_RE.lastIndex = 0;
+    let m;
+    while ((m = IMPORTS_DTS_EXPORT_RE.exec(content)) !== null) {
+        const symbolsRaw = m[1];
+        const source = m[2];
+        if (!isProjectLocalPath(source))
+            continue;
+        // Containment guard: a crafted source (`from '../../../../etc/passwd'`)
+        // passes the relative-path check but escapes the repo. Skip anything that
+        // resolves outside repoRoot before touching the filesystem.
+        const resolvedBase = path_1.default.resolve(nuxtDir, source);
+        if (!isWithinRepo(repoRoot, resolvedBase))
+            continue;
+        const resolvedFile = await resolveExtension(resolvedBase);
+        if (resolvedFile === null)
+            continue;
+        const sourceFile = toRepoPosix(repoRoot, resolvedFile);
+        for (const raw of symbolsRaw.split(',')) {
+            const trimmed = raw.trim();
+            if (!trimmed)
+                continue;
+            const asIdx = trimmed.indexOf(' as ');
+            const exportName = asIdx >= 0 ? trimmed.slice(0, asIdx).trim() : trimmed;
+            const localName = asIdx >= 0 ? trimmed.slice(asIdx + 4).trim() : trimmed;
+            if (!localName || !exportName)
+                continue;
+            if (!byLocalName.has(localName)) {
+                byLocalName.set(localName, { localName, exportName, sourceFile, scope: 'client' });
+            }
+        }
+    }
+    return true;
+}
+// ---- server/utils (Nitro auto-imports) --------------------------------------
+/**
+ * Scan `server/utils/**` and register every exported symbol as a Nitro
+ * auto-import. Nitro makes all exports from this directory tree available
+ * without an import statement in server routes and middleware.
+ */
+async function collectNitroServerUtils(repoRoot, byLocalName) {
+    const serverUtilsDir = path_1.default.join(repoRoot, 'server', 'utils');
+    if (!(await dirExists(serverUtilsDir)))
+        return;
+    const tsFiles = await collectTsFiles(serverUtilsDir);
+    for (const absPath of tsFiles) {
+        let content;
+        try {
+            content = await promises_1.default.readFile(absPath, 'utf-8');
+        }
+        catch {
+            continue;
+        }
+        const sourceFile = toRepoPosix(repoRoot, absPath);
+        for (const name of extractNitroExportNames(content)) {
+            if (!byLocalName.has(name)) {
+                byLocalName.set(name, { localName: name, exportName: name, sourceFile, scope: 'server' });
+            }
+        }
+    }
+}
+// ---- helpers ----------------------------------------------------------------
+function isProjectLocalPath(source) {
+    if (!source.startsWith('./') && !source.startsWith('../'))
+        return false;
+    if (source.includes('node_modules'))
+        return false;
+    return true;
+}
+/** True when `absPath` is `repoRoot` itself or lives beneath it. */
+function isWithinRepo(repoRoot, absPath) {
+    const root = path_1.default.resolve(repoRoot);
+    const safeRoot = root.endsWith(path_1.default.sep) ? root : root + path_1.default.sep;
+    return absPath === root || absPath.startsWith(safeRoot);
+}
+async function resolveExtension(base) {
+    const directFile = await firstExistingFile([...FILE_EXTENSIONS.map((ext) => base + ext), base]);
+    if (directFile !== null)
+        return directFile;
+    return firstExistingFile(FILE_EXTENSIONS.map((ext) => path_1.default.join(base, `index${ext}`)));
+}
+async function firstExistingFile(candidates) {
+    const matches = await Promise.all(candidates.map(async (candidate) => ((await isFile(candidate)) ? candidate : null)));
+    return matches.find((candidate) => candidate !== null) ?? null;
+}
+async function isFile(filePath) {
+    try {
+        const stat = await promises_1.default.stat(filePath);
+        return stat.isFile();
+    }
+    catch {
+        return false;
+    }
+}
+function toRepoPosix(repoRoot, absPath) {
+    return path_1.default.relative(repoRoot, absPath).replace(/\\/g, '/');
+}
+async function dirExists(dirPath) {
+    try {
+        const stat = await promises_1.default.stat(dirPath);
+        return stat.isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+/** Recursively collect supported TypeScript/JavaScript files under a directory. */
+async function collectTsFiles(dir) {
+    const results = [];
+    let entries;
+    try {
+        entries = await promises_1.default.readdir(dir, { withFileTypes: true });
+    }
+    catch {
+        return results;
+    }
+    for (const entry of entries) {
+        if (entry.isDirectory() && GENERATED_DIR_NAMES.has(entry.name))
+            continue;
+        const full = path_1.default.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            results.push(...(await collectTsFiles(full)));
+        }
+        else if (entry.isFile() && hasSupportedSourceExtension(entry.name)) {
+            results.push(full);
+        }
+    }
+    return results;
+}
+function hasSupportedSourceExtension(fileName) {
+    return FILE_EXTENSIONS.some((ext) => fileName.endsWith(ext));
+}
+function extractNitroExportNames(content) {
+    const names = new Set();
+    NITRO_DECLARATION_EXPORT_RE.lastIndex = 0;
+    let declaration;
+    while ((declaration = NITRO_DECLARATION_EXPORT_RE.exec(content)) !== null) {
+        const name = declaration[1] ?? declaration[2];
+        if (name)
+            names.add(name);
+    }
+    NITRO_VARIABLE_EXPORT_RE.lastIndex = 0;
+    let variableDeclaration;
+    while ((variableDeclaration = NITRO_VARIABLE_EXPORT_RE.exec(content)) !== null) {
+        // Only the LHS binding name of each top-level declarator is a Nitro export.
+        // Splitting on top-level commas and reading the leading identifier avoids
+        // capturing RHS tokens (arrow params, object keys, operands) as export names,
+        // and tolerates commas inside generic type annotations (`x: Map<a, b> = …`).
+        for (const declarator of splitTopLevelDeclarators(variableDeclaration[1])) {
+            const name = DECLARATOR_NAME_RE.exec(declarator);
+            if (name)
+                names.add(name[1]);
+        }
+    }
+    return [...names];
+}
+/**
+ * Split a `const`/`let`/`var` declarator list on top-level commas, tracking
+ * `()`, `[]`, `{}`, and `<>` nesting so commas inside call args, object/array
+ * literals, and generic type arguments do not split a declarator. Errs toward
+ * under-splitting on pathological RHS (a missed binding name, never a spurious
+ * one) — Nitro only auto-imports real top-level binding names.
+ */
+function splitTopLevelDeclarators(text) {
+    const parts = [];
+    let depth = 0;
+    let start = 0;
+    for (let i = 0; i < text.length; i++) {
+        const ch = text[i];
+        if (ch === '(' || ch === '[' || ch === '{' || ch === '<') {
+            depth++;
+        }
+        else if (ch === ')' || ch === ']' || ch === '}' || ch === '>') {
+            if (depth > 0)
+                depth--;
+        }
+        else if (ch === ',' && depth === 0) {
+            parts.push(text.slice(start, i));
+            start = i + 1;
+        }
+    }
+    parts.push(text.slice(start));
+    return parts;
+}