@superblocksteam/vite-plugin-file-sync 2.0.151 → 2.0.152-next.1

package/dist/extract-api-integrations.js

@@ -1,3 +1,4 @@
+import { posix as posixPath } from "node:path";
 import { parse } from "@babel/parser";
 function isNode(value) {
     return !!value && typeof value === "object";
@@ -15,18 +16,19 @@ function getPropertyName(node) {
     return undefined;
 }
 function getLiteralString(node) {
-    if (!isNode(node)) {
+    const resolved = unwrapExpression(node);
+    if (!resolved) {
         return undefined;
     }
-    if (node.type === "StringLiteral" && typeof node.value === "string") {
-        return node.value;
+    if (resolved.type === "StringLiteral" && typeof resolved.value === "string") {
+        return resolved.value;
     }
-    if (node.type === "TemplateLiteral" &&
-        Array.isArray(node.expressions) &&
-        node.expressions.length === 0 &&
-        Array.isArray(node.quasis) &&
-        node.quasis.length === 1) {
-        const quasi = node.quasis[0];
+    if (resolved.type === "TemplateLiteral" &&
+        Array.isArray(resolved.expressions) &&
+        resolved.expressions.length === 0 &&
+        Array.isArray(resolved.quasis) &&
+        resolved.quasis.length === 1) {
+        const quasi = resolved.quasis[0];
         if (isNode(quasi) &&
             isNode(quasi.value) &&
             typeof quasi.value.cooked === "string") {
@@ -58,27 +60,44 @@ function unwrapExpression(node) {
     }
     return node;
 }
-function buildVariableInitializerMap(programBody) {
-    const initializers = new Map();
+/**
+ * Walks top-level variable declarations in a program body, calling `visitor`
+ * for each individual declarator. Unwraps `export const x = ...`
+ * (`ExportNamedDeclaration` whose `.declaration` is a `VariableDeclaration`)
+ * to its inner `VariableDeclaration` so exported declarations are visited
+ * the same as bare ones.
+ */
+function visitVariableDeclarations(programBody, visitor) {
     for (const statement of programBody) {
-        if (!isNode(statement) ||
-            statement.type !== "VariableDeclaration" ||
-            !Array.isArray(statement.declarations)) {
+        if (!isNode(statement)) {
             continue;
         }
-        for (const declaration of statement.declarations) {
-            if (!isNode(declaration)) {
-                continue;
-            }
-            const identifier = declaration.id;
-            if (!isNode(identifier) ||
-                identifier.type !== "Identifier" ||
-                typeof identifier.name !== "string") {
-                continue;
+        const declarationNode = statement.type === "ExportNamedDeclaration" &&
+            isNode(statement.declaration)
+            ? statement.declaration
+            : statement;
+        if (declarationNode.type !== "VariableDeclaration" ||
+            !Array.isArray(declarationNode.declarations)) {
+            continue;
+        }
+        for (const declaration of declarationNode.declarations) {
+            if (isNode(declaration)) {
+                visitor(declaration);
             }
-            initializers.set(identifier.name, declaration.init);
         }
     }
+}
+function buildVariableInitializerMap(programBody) {
+    const initializers = new Map();
+    visitVariableDeclarations(programBody, (declaration) => {
+        const identifier = declaration.id;
+        if (!isNode(identifier) ||
+            identifier.type !== "Identifier" ||
+            typeof identifier.name !== "string") {
+            return;
+        }
+        initializers.set(identifier.name, declaration.init);
+    });
     return initializers;
 }
 function resolveApiConfigObject(expression, variableInitializers) {
@@ -126,62 +145,42 @@ function findExportedApiConfigObject(programBody) {
 }
 function buildVariableReferenceMap(programBody, stringLiterals) {
     const refs = new Map();
-    for (const statement of programBody) {
-        if (!isNode(statement) ||
-            statement.type !== "VariableDeclaration" ||
-            !Array.isArray(statement.declarations)) {
-            continue;
+    visitVariableDeclarations(programBody, (declaration) => {
+        const identifier = declaration.id;
+        const init = declaration.init;
+        if (!isNode(identifier) ||
+            identifier.type !== "Identifier" ||
+            typeof identifier.name !== "string") {
+            return;
         }
-        for (const declaration of statement.declarations) {
-            if (!isNode(declaration)) {
-                continue;
-            }
-            const identifier = declaration.id;
-            const init = declaration.init;
-            if (!isNode(identifier) ||
-                identifier.type !== "Identifier" ||
-                typeof identifier.name !== "string") {
-                continue;
-            }
-            if (!isNode(init) ||
-                init.type !== "CallExpression" ||
-                !Array.isArray(init.arguments)) {
-                continue;
-            }
-            const pluginId = getCalleeName(init.callee);
-            const id = resolveStringArgument(init.arguments[0], stringLiterals);
-            if (!pluginId || !id) {
-                continue;
-            }
-            refs.set(identifier.name, { pluginId, id });
+        if (!isNode(init) ||
+            init.type !== "CallExpression" ||
+            !Array.isArray(init.arguments)) {
+            return;
         }
-    }
+        const pluginId = getCalleeName(init.callee);
+        const id = resolveStringArgument(init.arguments[0], stringLiterals);
+        if (!pluginId || !id) {
+            return;
+        }
+        refs.set(identifier.name, { pluginId, id });
+    });
     return refs;
 }
 function buildStringLiteralMap(programBody) {
     const literals = new Map();
-    for (const statement of programBody) {
-        if (!isNode(statement) ||
-            statement.type !== "VariableDeclaration" ||
-            !Array.isArray(statement.declarations)) {
-            continue;
+    visitVariableDeclarations(programBody, (declaration) => {
+        const identifier = declaration.id;
+        if (!isNode(identifier) ||
+            identifier.type !== "Identifier" ||
+            typeof identifier.name !== "string") {
+            return;
         }
-        for (const declaration of statement.declarations) {
-            if (!isNode(declaration)) {
-                continue;
-            }
-            const identifier = declaration.id;
-            if (!isNode(identifier) ||
-                identifier.type !== "Identifier" ||
-                typeof identifier.name !== "string") {
-                continue;
-            }
-            const value = getLiteralString(declaration.init);
-            if (value !== undefined) {
-                literals.set(identifier.name, value);
-            }
+        const value = getLiteralString(declaration.init);
+        if (value !== undefined) {
+            literals.set(identifier.name, value);
         }
-    }
+    });
     return literals;
 }
 function resolveStringArgument(node, stringLiterals) {
@@ -196,68 +195,82 @@ function resolveStringArgument(node, stringLiterals) {
     }
     return undefined;
 }
-/**
- * Extract integration declarations from an SDK API source file.
- *
- * Anchors on the exported `api({ ... })` config object and extracts
- * integrations from its `integrations` property.
- *
- * Supports inline declarations:
- * `integrations: { db: postgres("uuid") }`
- *
- * Top-level variable references:
- * `const DB = postgres("uuid"); integrations: { db: DB }`
- *
- * And string variable indirection:
- * `const ID = "uuid"; integrations: { db: postgres(ID) }`
- */
-export function extractIntegrationsFromSource(source) {
-    let ast;
-    try {
-        ast = parse(source, {
-            sourceType: "module",
-            plugins: ["typescript"],
-        });
-    }
-    catch {
-        return [];
+function extractFromProgram(programBody, importedRefs) {
+    const stringLiterals = buildStringLiteralMap(programBody);
+    // Seed with imported id constants (e.g. `import { SHEETS_ID } from
+    // "../lib/constants.js"`) so a same-file declaration like
+    // `const sheets = restApiIntegration(SHEETS_ID)` can resolve them. Only
+    // fill in names the same-file scan didn't already find, so a same-file
+    // literal always wins over an imported one of the same name. In practice
+    // this `!stringLiterals.has(name)` check is defensive and unreachable for
+    // valid input: a same-file `const X` and an `import { X }` of the same
+    // name is a duplicate lexical binding, which is a parse/type error in
+    // real TS/ESM and can't occur in a file that actually compiles.
+    for (const [name, ref] of importedRefs) {
+        if (ref.kind === "id" && !stringLiterals.has(name)) {
+            stringLiterals.set(name, ref.id);
+        }
     }
-    const stringLiterals = buildStringLiteralMap(ast.program.body);
-    const variableRefs = buildVariableReferenceMap(ast.program.body, stringLiterals);
-    const apiConfig = findExportedApiConfigObject(ast.program.body);
+    const variableRefs = buildVariableReferenceMap(programBody, stringLiterals);
+    const apiConfig = findExportedApiConfigObject(programBody);
     if (!apiConfig) {
-        return [];
+        return { integrations: [], unresolvedKeys: [] };
     }
-    const results = [];
+    const integrations = [];
+    const unresolvedKeys = [];
     const apiConfigProperties = Array.isArray(apiConfig.properties)
         ? apiConfig.properties
         : [];
     const integrationsProperty = apiConfigProperties.find((property) => isNode(property) &&
         property.type === "ObjectProperty" &&
         getPropertyName(property.key) === "integrations");
-    if (!isNode(integrationsProperty) ||
-        !isNode(integrationsProperty.value) ||
+    if (!isNode(integrationsProperty)) {
+        return { integrations: [], unresolvedKeys: [] };
+    }
+    if (!isNode(integrationsProperty.value) ||
         integrationsProperty.value.type !== "ObjectExpression") {
-        return [];
+        // The `integrations` property exists but its value isn't a statically
+        // analyzable object literal (e.g. `api({ integrations })` shorthand, or
+        // `api({ integrations: sharedObject })`). "*" is a sentinel meaning the
+        // whole integrations object could not be resolved, as opposed to one
+        // specific key.
+        return { integrations: [], unresolvedKeys: ["*"] };
     }
     const properties = Array.isArray(integrationsProperty.value.properties)
         ? integrationsProperty.value.properties
         : [];
     for (const property of properties) {
         if (!isNode(property) || property.type !== "ObjectProperty") {
+            // Not a key/value property at all (e.g. a spread element or a method),
+            // so there is no key to report as unresolved.
+            unresolvedKeys.push("(dynamic)");
             continue;
         }
         const key = getPropertyName(property.key);
         if (!key) {
+            unresolvedKeys.push("(unknown)");
             continue;
         }
         if (isNode(property.value) &&
             property.value.type === "CallExpression" &&
             Array.isArray(property.value.arguments)) {
             const pluginId = getCalleeName(property.value.callee);
-            const id = resolveStringArgument(property.value.arguments[0], stringLiterals);
+            const arg = property.value.arguments[0];
+            let id = resolveStringArgument(arg, stringLiterals);
+            if (!id &&
+                isNode(arg) &&
+                arg.type === "Identifier" &&
+                typeof arg.name === "string") {
+                const imported = importedRefs.get(arg.name);
+                if (imported?.kind === "id") {
+                    id = imported.id;
+                }
+            }
             if (pluginId && id) {
-                results.push({ key, pluginId, id });
+                integrations.push({ key, pluginId, id });
+            }
+            else {
+                unresolvedKeys.push(key);
             }
             continue;
         }
@@ -266,13 +279,319 @@ export function extractIntegrationsFromSource(source) {
             typeof property.value.name === "string") {
             const resolved = variableRefs.get(property.value.name);
             if (resolved) {
-                results.push({ key, ...resolved });
+                integrations.push({ key, ...resolved });
+                continue;
             }
+            const imported = importedRefs.get(property.value.name);
+            if (imported?.kind === "declaration") {
+                integrations.push({
+                    key,
+                    pluginId: imported.pluginId,
+                    id: imported.id,
+                });
+                continue;
+            }
+            unresolvedKeys.push(key);
+            continue;
         }
+        unresolvedKeys.push(key);
+    }
+    return { integrations, unresolvedKeys };
+}
+/**
+ * Extract integration declarations from an SDK API source file.
+ *
+ * Anchors on the exported `api({ ... })` config object and extracts
+ * integrations from its `integrations` property.
+ *
+ * Supports inline declarations:
+ * `integrations: { db: postgres("uuid") }`
+ *
+ * Top-level variable references:
+ * `const DB = postgres("uuid"); integrations: { db: DB }`
+ *
+ * And string variable indirection:
+ * `const ID = "uuid"; integrations: { db: postgres(ID) }`
+ *
+ * Also resolves top-level `export const` declarations and `as const`
+ * literals in the same file (e.g. `export const ID = "uuid" as const;`) —
+ * a deliberate, additive improvement over the previous bare-declaration-only
+ * behavior. This is still single-file scope: only same-file declarations
+ * (exported or not) are considered, imports are never followed.
+ *
+ * Single-file only: does not follow imports, so an integration declared via
+ * an imported constant or an imported `integrations` object cannot be
+ * resolved here — it is silently dropped (its key is simply absent from the
+ * returned array, with no signal that it was seen but unresolved). Callers
+ * that need imported declarations resolved, or that need to know about
+ * unresolved keys instead of silently losing them, must use
+ * {@link extractApiIntegrations} instead.
+ */
+export function extractIntegrationsFromSource(source) {
+    let ast;
+    try {
+        ast = parse(source, {
+            sourceType: "module",
+            plugins: ["typescript"],
+        });
+    }
+    catch {
+        return [];
     }
-    return results;
+    return extractFromProgram(ast.program.body, new Map()).integrations;
 }
+/**
+ * Single-file only: does not follow imports, so an integration declared via
+ * an imported constant or an imported `integrations` object cannot be
+ * resolved here — it is silently dropped (its `id` is simply absent from the
+ * returned array, with no signal that it was seen but unresolved). Callers
+ * that need imported declarations resolved, or that need to know about
+ * unresolved keys instead of silently losing them, must use
+ * {@link extractApiIntegrations} instead.
+ */
 export function extractIntegrationIdsFromSource(source) {
     return extractIntegrationsFromSource(source).map((integration) => integration.id);
 }
+/**
+ * Async variant of {@link extractIntegrationsFromSource} that also resolves
+ * integrations declared via imports from other files, and reports which
+ * `integrations` object keys could not be resolved to a complete
+ * `{ key, pluginId, id }` triple.
+ *
+ * Import resolution supports one-hop relative imports (e.g., `../lib/integrations.js`).
+ * For each imported name, resolves it in the imported module via:
+ * 1. Imported string-literal constants: `export const SHEETS_ID = "sheets-uuid"`
+ *    (including `as const`/type-assertion wrapping and re-exports via
+ *    `export { name }` specifiers).
+ * 2. Imported integration declarations: `export const jira = restApiIntegration("jira-uuid")`
+ *    including string-literal indirection within the imported module, and
+ *    the same `export { name }` specifier form.
+ *
+ * Non-relative imports (package imports) are not followed.
+ *
+ * `params.entryPoint` MUST be an app-root-relative posix path (e.g.
+ * `server/apis/get-rows.ts`), never an absolute path or one containing a
+ * backslash — an entry point that violates this contract skips import
+ * resolution entirely (see the guard at the top of
+ * `buildImportedIntegrationRefs`). Within that contract, resolved relative
+ * import candidates that would escape the app root (e.g. `../../../secrets.ts`)
+ * are skipped without reading them, but that `..`-prefix skip is only a
+ * best-effort guard against traversal *relative to entryPoint's own
+ * directory* — it is not a substitute for real containment enforcement.
+ * Authoritative containment against the actual filesystem root lives in the
+ * caller's `readSource` implementation (see `resolveContainedPath` in
+ * `collect-sdk-apis.mts`), which re-resolves every candidate against the app
+ * root before touching disk.
+ *
+ * `unresolvedKeys` entries are one of:
+ * - a specific `integrations` object key that could not be resolved
+ * - `"(unknown)"` for an `ObjectProperty` whose key itself couldn't be read
+ *   (e.g. a computed key)
+ * - `"(dynamic)"` for a non-`ObjectProperty` member of the integrations
+ *   object (spread elements, methods)
+ * - `"*"` as a sentinel meaning the whole `integrations` value could not be
+ *   statically resolved at all (e.g. `api({ integrations })` shorthand, or
+ *   `api({ integrations: sharedObject })` referencing a non-literal value,
+ *   or the entry file itself failing to parse) — in this case `integrations`
+ *   is always `[]`.
+ */
+export async function extractApiIntegrations(params) {
+    let ast;
+    try {
+        ast = parse(params.source, {
+            sourceType: "module",
+            plugins: ["typescript"],
+        });
+    }
+    catch {
+        // The entry file itself failed to parse (e.g. parser-config drift: a
+        // real build compiles syntax our @babel/parser config rejects, such as
+        // decorators or import attributes). Report the "*" sentinel instead of
+        // silently returning an empty result — this is maximal uncertainty
+        // about the whole integrations surface, exactly what "*" means below.
+        return { integrations: [], unresolvedKeys: ["*"] };
+    }
+    const importedRefs = await buildImportedIntegrationRefs(ast.program.body, params.entryPoint, params.readSource);
+    return extractFromProgram(ast.program.body, importedRefs);
+}
+const TS_EXTENSIONS = [".ts", ".tsx", ".mts", ".cts"];
+const JS_TO_TS_EXTENSIONS = {
+    ".js": [".ts", ".tsx"],
+    ".jsx": [".tsx"],
+    ".mjs": [".mts", ".ts"],
+    ".cjs": [".cts", ".ts"],
+};
+export function resolveRelativeImportPath(fromPath, importPath) {
+    const resolved = posixPath.join(posixPath.dirname(fromPath), importPath);
+    const currentExt = posixPath.extname(resolved);
+    if (TS_EXTENSIONS.includes(currentExt)) {
+        return [resolved];
+    }
+    const tsReplacements = JS_TO_TS_EXTENSIONS[currentExt];
+    if (tsReplacements) {
+        const stem = resolved.slice(0, -currentExt.length);
+        return tsReplacements.map((ext) => stem + ext);
+    }
+    return TS_EXTENSIONS.map((ext) => resolved + ext);
+}
+async function readAndParseFirstExisting(candidatePaths, readSource, cache) {
+    for (const candidate of candidatePaths) {
+        if (!cache.has(candidate)) {
+            let body;
+            try {
+                const source = await readSource(candidate);
+                if (source !== undefined) {
+                    body = parse(source, {
+                        sourceType: "module",
+                        plugins: ["typescript"],
+                    }).program.body;
+                }
+            }
+            catch {
+                body = undefined;
+            }
+            cache.set(candidate, body);
+        }
+        const cached = cache.get(candidate);
+        if (cached) {
+            return cached;
+        }
+    }
+    return undefined;
+}
+function buildExportedIntegrationRefMap(programBody) {
+    const refs = new Map();
+    const stringLiterals = buildStringLiteralMap(programBody);
+    // Resolves specifier-based exports (`const jira = ...; export { jira };`)
+    // against the module's bare top-level variable declarations.
+    const variableRefs = buildVariableReferenceMap(programBody, stringLiterals);
+    // Resolve `export const x = ...` declarations directly. Filtering to only
+    // `ExportNamedDeclaration` statements before delegating to the shared
+    // walker means bare (non-exported) top-level consts are correctly excluded
+    // here, even though they're visible for same-file indirection above.
+    const exportedDeclarationStatements = programBody.filter((statement) => isNode(statement) && statement.type === "ExportNamedDeclaration");
+    visitVariableDeclarations(exportedDeclarationStatements, (declaration) => {
+        const identifier = declaration.id;
+        if (!isNode(identifier) ||
+            identifier.type !== "Identifier" ||
+            typeof identifier.name !== "string") {
+            return;
+        }
+        const literal = getLiteralString(declaration.init);
+        if (literal !== undefined) {
+            refs.set(identifier.name, { kind: "id", id: literal });
+            return;
+        }
+        const init = declaration.init;
+        if (isNode(init) &&
+            init.type === "CallExpression" &&
+            Array.isArray(init.arguments)) {
+            const pluginId = getCalleeName(init.callee);
+            const id = resolveStringArgument(init.arguments[0], stringLiterals);
+            if (pluginId && id) {
+                refs.set(identifier.name, { kind: "declaration", pluginId, id });
+            }
+        }
+    });
+    for (const statement of programBody) {
+        if (!isNode(statement) || statement.type !== "ExportNamedDeclaration") {
+            continue;
+        }
+        if (!Array.isArray(statement.specifiers)) {
+            continue;
+        }
+        for (const specifier of statement.specifiers) {
+            if (!isNode(specifier) || specifier.type !== "ExportSpecifier") {
+                continue;
+            }
+            const localName = getPropertyName(specifier.local);
+            const exportedName = getPropertyName(specifier.exported);
+            if (!localName || !exportedName) {
+                continue;
+            }
+            const literal = stringLiterals.get(localName);
+            if (literal !== undefined) {
+                refs.set(exportedName, { kind: "id", id: literal });
+                continue;
+            }
+            const varRef = variableRefs.get(localName);
+            if (varRef) {
+                refs.set(exportedName, {
+                    kind: "declaration",
+                    pluginId: varRef.pluginId,
+                    id: varRef.id,
+                });
+            }
+        }
+    }
+    return refs;
+}
+async function buildImportedIntegrationRefs(programBody, entryPoint, readSource) {
+    const refs = new Map();
+    // entryPoint is contractually an app-root-relative posix path (see the
+    // JSDoc on extractApiIntegrations). An absolute path or one containing a
+    // backslash is out-of-contract input: resolveRelativeImportPath's
+    // `..`-prefix skip only guards against traversal relative to entryPoint's
+    // own directory, so a malformed entryPoint (e.g. an absolute path) could
+    // still let a resolved candidate land outside the app root even though it
+    // doesn't start with "..". Refuse to resolve any imports at all for such
+    // input rather than rely on that guard holding — callers that violate the
+    // contract get unresolved keys instead of a potential traversal.
+    if (entryPoint.startsWith("/") || entryPoint.includes("\\")) {
+        return refs;
+    }
+    // Deliberately scoped to this call (one per entry point), not shared/module
+    // -level: each call to extractApiIntegrations gets its own cache, so
+    // repeated imports of the same relative path within a single entry point's
+    // import graph are only read and parsed once, without leaking parsed
+    // bodies across unrelated entry points or app roots.
+    const parsedImportCache = new Map();
+    for (const statement of programBody) {
+        if (!isNode(statement) || statement.type !== "ImportDeclaration") {
+            continue;
+        }
+        const importSource = statement.source;
+        const importPath = isNode(importSource) ? importSource.value : undefined;
+        if (typeof importPath !== "string" ||
+            !importPath.startsWith(".") ||
+            !Array.isArray(statement.specifiers)) {
+            continue;
+        }
+        // Real ESM/TS import specifiers always use forward slashes, and no
+        // bundler resolves a backslash as a path separator either — a backslash
+        // here only ever comes from hostile or broken input (e.g.
+        // `..\\..\\..\\secret.js`). `posixPath.join` treats `\` as an ordinary
+        // filename character rather than a separator, so the `..`-prefix guard
+        // below cannot catch a traversal spelled with backslashes. Treat the
+        // specifier as unresolvable, the same as a bare package import, and
+        // never attempt to read it.
+        if (importPath.includes("\\")) {
+            continue;
+        }
+        // Skip candidates that resolve outside the app root (e.g.
+        // `../../../secrets.ts` escaping above the entry point's directory) —
+        // never read files outside the app being built.
+        const candidatePaths = resolveRelativeImportPath(entryPoint, importPath).filter((candidate) => !candidate.startsWith(".."));
+        if (candidatePaths.length === 0) {
+            continue;
+        }
+        const importedBody = await readAndParseFirstExisting(candidatePaths, readSource, parsedImportCache);
+        if (!importedBody) {
+            continue;
+        }
+        const exportedRefs = buildExportedIntegrationRefMap(importedBody);
+        for (const specifier of statement.specifiers) {
+            if (!isNode(specifier) || specifier.type !== "ImportSpecifier") {
+                continue;
+            }
+            const importedName = getPropertyName(specifier.imported);
+            const localName = getPropertyName(specifier.local);
+            const ref = importedName ? exportedRefs.get(importedName) : undefined;
+            if (localName && ref) {
+                refs.set(localName, ref);
+            }
+        }
+    }
+    return refs;
+}
 //# sourceMappingURL=extract-api-integrations.js.map