@cedarjs/vite 5.0.3 → 5.0.4-next.167

package/dist/plugins/vite-plugin-cedar-graphql-options-extract.d.ts

@@ -0,0 +1,42 @@
+import type { SourceMap } from 'magic-string';
+import type { Plugin } from 'vite';
+/**
+ * Vite plugin that extracts options passed to createGraphQLHandler into an
+ * exported variable.
+ *
+ * Transforms:
+ *   export const handler = createGraphQLHandler({ options })
+ * into:
+ *   export const __cedar_graphqlOptions = { options }
+ *   export const handler = createGraphQLHandler(__cedar_graphqlOptions)
+ *
+ * This allows options to be imported elsewhere and enables the gqlorm-inject
+ * plugin to mutate the sdls object in-place before the call.
+ *
+ * The extraction uses an oxc-parser AST walk (see `applyGraphqlOptionsExtract`
+ * below) so the transform is robust against aliased imports, nested calls, and
+ * string escapes. The same logic is duplicated in
+ * `@cedarjs/internal` (`applyGraphqlOptionsExtract`) for the standalone esbuild
+ * API build
+ */
+export declare function cedarGraphqlOptionsExtractPlugin(): Plugin;
+/**
+ * Extracts the options argument from createGraphQLHandler calls and stores
+ * them in an exported variable. Returns the transformed code with a sourcemap,
+ * or null if no transformation was needed.
+ *
+ * Transforms:
+ *   export const handler = createGraphQLHandler({ options })
+ * into:
+ *   export const __cedar_graphqlOptions = { options }
+ *   export const handler = createGraphQLHandler(__cedar_graphqlOptions)
+ *
+ * Duplicate of `@cedarjs/internal`'s `applyGraphqlOptionsExtract` so this
+ * logic can run inside the Vite plugin pipeline without depending on internal's
+ * build output.
+ */
+export declare function applyGraphqlOptionsExtract(code: string): {
+    code: string;
+    map: SourceMap;
+} | null;
+//# sourceMappingURL=vite-plugin-cedar-graphql-options-extract.d.ts.map

package/dist/plugins/vite-plugin-cedar-graphql-options-extract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vite-plugin-cedar-graphql-options-extract.d.ts","sourceRoot":"","sources":["../../src/plugins/vite-plugin-cedar-graphql-options-extract.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA;AAG7C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAA;AAElC;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,gCAAgC,IAAI,MAAM,CA2BzD;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,0BAA0B,CACxC,IAAI,EAAE,MAAM,GACX;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,SAAS,CAAA;CAAE,GAAG,IAAI,CAgGzC"}

package/dist/plugins/vite-plugin-cedar-graphql-options-extract.js

@@ -0,0 +1,93 @@
+import MagicString from "magic-string";
+import { parseSync, Visitor } from "oxc-parser";
+function cedarGraphqlOptionsExtractPlugin() {
+  return {
+    name: "cedar-graphql-options-extract",
+    transform(code, id) {
+      if (!id.endsWith("/graphql.ts") && !id.endsWith("/graphql.js")) {
+        return null;
+      }
+      if (!code.includes("createGraphQLHandler")) {
+        return null;
+      }
+      const result = applyGraphqlOptionsExtract(code);
+      if (!result) {
+        return null;
+      }
+      return {
+        code: result.code,
+        map: result.map
+      };
+    }
+  };
+}
+function applyGraphqlOptionsExtract(code) {
+  if (code.includes("__cedar_graphqlOptions")) {
+    return null;
+  }
+  const { program } = parseSync("graphql.ts", code, {
+    // lang is only a parse hint; 'ts' also parses JS (the graphql handler can
+    // be graphql.js in JS projects), so this is safe for both file types.
+    lang: "ts",
+    sourceType: "module"
+  });
+  const importNames = /* @__PURE__ */ new Set();
+  for (const node of program.body) {
+    if (node.type === "ImportDeclaration") {
+      if (node.source.value !== "@cedarjs/graphql-server") {
+        continue;
+      }
+      for (const specifier of node.specifiers) {
+        if (specifier.type === "ImportSpecifier" && specifier.imported.type === "Identifier" && specifier.imported.name === "createGraphQLHandler") {
+          importNames.add(specifier.local.name);
+        }
+      }
+    }
+  }
+  if (importNames.size === 0) {
+    return null;
+  }
+  const callExpressionPaths = [];
+  new Visitor({
+    CallExpression(node) {
+      if (node.callee.type === "Identifier" && importNames.has(node.callee.name)) {
+        callExpressionPaths.push(node);
+      }
+    }
+  }).visit(program);
+  if (callExpressionPaths.length > 1) {
+    return null;
+  }
+  const callExpression = callExpressionPaths[0];
+  if (!callExpression) {
+    return null;
+  }
+  const options = callExpression.arguments[0];
+  if (!options) {
+    return null;
+  }
+  if (options.type !== "Identifier" && options.type !== "ObjectExpression" && options.type !== "CallExpression" && options.type !== "ConditionalExpression") {
+    return null;
+  }
+  const optionsStart = options.start;
+  const optionsEnd = options.end;
+  const lineStart = code.lastIndexOf("\n", callExpression.start) + 1;
+  const indentMatch = /^[ \t]*/.exec(code.slice(lineStart));
+  const indent = indentMatch ? indentMatch[0] : "";
+  const optionsConst = `${indent}export const __cedar_graphqlOptions = ${code.slice(
+    optionsStart,
+    optionsEnd
+  )}
+`;
+  const s = new MagicString(code);
+  s.prependLeft(lineStart, optionsConst);
+  s.overwrite(optionsStart, optionsEnd, "__cedar_graphqlOptions");
+  return {
+    code: s.toString(),
+    map: s.generateMap({ hires: true })
+  };
+}
+export {
+  applyGraphqlOptionsExtract,
+  cedarGraphqlOptionsExtractPlugin
+};

package/dist/plugins/vite-plugin-cedar-import-dir.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"vite-plugin-cedar-import-dir.d.ts","sourceRoot":"","sources":["../../src/plugins/vite-plugin-cedar-import-dir.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAA;AAIlC;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,oBAAoB,IAAI,MAAM,CAgH7C"}
+{"version":3,"file":"vite-plugin-cedar-import-dir.d.ts","sourceRoot":"","sources":["../../src/plugins/vite-plugin-cedar-import-dir.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAA;AAIlC;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,oBAAoB,IAAI,MAAM,CAqI7C"}

package/dist/plugins/vite-plugin-cedar-import-dir.js

@@ -1,6 +1,8 @@
+import fs from "node:fs";
 import path from "node:path";
 import { parse, Lang } from "@ast-grep/napi";
-import fg from "fast-glob";
+import MagicString from "magic-string";
+import { normalizePath } from "vite";
 import { importStatementPath, getPaths } from "@cedarjs/project-config";
 function cedarImportDirPlugin() {
   return {
@@ -22,7 +24,7 @@ function cedarImportDirPlugin() {
       }
       const root = ast.root();
       let hasTransformations = false;
-      const edits = [];
+      const s = new MagicString(code);
       const globImports = root.findAll({
         rule: {
           pattern: "import $DEFAULT_IMPORT from $SOURCE"
@@ -41,20 +43,37 @@ function cedarImportDirPlugin() {
         hasTransformations = true;
         const importName = defaultImportNode.text();
         const importGlob = importStatementPath(sourceValue);
-        const cwd = importGlob.startsWith("src/") ? getPaths().api.base : path.dirname(id);
+        let cwd = path.dirname(id);
+        if (importGlob.startsWith("src/")) {
+          const normalizedId = normalizePath(id);
+          const apiBase = normalizePath(getPaths().api.base);
+          const webBase = normalizePath(getPaths().web.base);
+          if (normalizedId.startsWith(apiBase)) {
+            cwd = getPaths().api.base;
+          } else if (normalizedId.startsWith(webBase)) {
+            cwd = getPaths().web.base;
+          } else {
+            throw new Error(`Unexpected file location: ${id}`);
+          }
+        }
         try {
-          const dirFiles = fg.sync(importGlob, { cwd }).filter(
-            (n) => !n.includes(".test.") && !n.includes(".scenarios.") && !n.includes(".d.ts")
-          );
+          const dirFiles = fs.globSync(importGlob, {
+            cwd,
+            exclude: (n) => n.includes(".test.") || n.includes(".scenarios.") || n.includes(".d.ts")
+          });
           const staticGlob = importGlob.split("*")[0];
           const filePathToVarName = (filePath) => {
-            return filePath.replace(staticGlob, "").replace(/\.(js|ts)$/, "").replace(/[^a-zA-Z0-9]/g, "_");
+            const normalizedPath = normalizePath(filePath);
+            return normalizedPath.replace(staticGlob, "").replace(/\.(js|ts)$/, "").replace(/[^a-zA-Z0-9]/g, "_");
           };
           let replacement = `let ${importName} = {};
 `;
           for (const filePath of dirFiles) {
-            const { dir: fileDir, name: fileName } = path.parse(filePath);
-            const fileImportPath = fileDir + "/" + fileName;
+            const normalizedPath = normalizePath(filePath);
+            const lastSlash = normalizedPath.lastIndexOf("/");
+            const fileDir = lastSlash >= 0 ? normalizedPath.slice(0, lastSlash) : "";
+            const fileName = normalizedPath.slice(lastSlash + 1).replace(/\.\w+$/, "");
+            const fileImportPath = fileDir ? fileDir + "/" + fileName : fileName;
             const filePathVarName = filePathToVarName(filePath);
             const namespaceImportName = `${importName}_${filePathVarName}`;
             replacement += `import * as ${namespaceImportName} from '${fileImportPath}';
@@ -62,17 +81,16 @@ function cedarImportDirPlugin() {
             replacement += `${importName}.${filePathVarName} = ${namespaceImportName};
 `;
           }
-          edits.push(importNode.replace(replacement.trim()));
+          const range = importNode.range();
+          s.overwrite(range.start.index, range.end.index, replacement.trim());
         } catch (error) {
           console.warn(`Failed to process glob import: ${sourceValue}`, error);
         }
       }
-      if (hasTransformations && edits.length > 0) {
-        const transformedCode = root.commitEdits(edits);
+      if (hasTransformations) {
         return {
-          code: transformedCode,
-          map: null
-          // For simplicity, not generating source maps
+          code: s.toString(),
+          map: s.generateMap({ hires: true })
         };
       }
       return null;

package/dist/plugins/vite-plugin-cedar-log-formatter-dev.d.ts

@@ -0,0 +1,28 @@
+import type { Plugin } from 'vite';
+import type * as apiLogger from '@cedarjs/api/logger';
+/**
+ * Dev-only Vite plugin that makes the api's pino logger pretty-print
+ * through the same formatter plain `yarn cedar dev` gets via its
+ * `... | cedar-log-formatter` shell pipe.
+ *
+ * `--ud` mode runs the api in-process as Vite SSR middleware, so there's no
+ * separate api process whose stdout a shell pipe could format externally,
+ * and pino's default destination writes straight to file descriptor 1
+ * (bypassing `process.stdout.write`), so patching stdout wouldn't see the
+ * log lines either. Instead, this intercepts resolution of
+ * `@cedarjs/api/logger` and swaps in a wrapped `createLogger` that injects
+ * a formatting `destination` whenever the caller (the app's own
+ * `api/src/lib/logger.ts`) doesn't already supply one.
+ *
+ * Only registered in `createApiViteServer()`'s dev-only Vite instance —
+ * never touched by any production build path — so this has no effect on
+ * (and no dependency footprint added to) a deployed api.
+ */
+export declare function cedarApiLogFormatterDevPlugin(): Plugin;
+export declare function createFormattingDestination(): {
+    write(chunk: string): void;
+};
+type CreateLoggerParams = Parameters<typeof apiLogger.createLogger>[0];
+export declare function createLogger(params?: CreateLoggerParams): apiLogger.Logger;
+export {};
+//# sourceMappingURL=vite-plugin-cedar-log-formatter-dev.d.ts.map

package/dist/plugins/vite-plugin-cedar-log-formatter-dev.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vite-plugin-cedar-log-formatter-dev.d.ts","sourceRoot":"","sources":["../../src/plugins/vite-plugin-cedar-log-formatter-dev.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAA;AAMlC,OAAO,KAAK,KAAK,SAAS,MAAM,qBAAqB,CAAA;AAOrD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,6BAA6B,IAAI,MAAM,CAoCtD;AAED,wBAAgB,2BAA2B;iBAK1B,MAAM;EAYtB;AAED,KAAK,kBAAkB,GAAG,UAAU,CAAC,OAAO,SAAS,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,CAAA;AAUtE,wBAAgB,YAAY,CAAC,MAAM,GAAE,kBAAuB,oBAS3D"}

package/dist/plugins/vite-plugin-cedar-log-formatter-dev.js

@@ -0,0 +1,67 @@
+import { LogFormatter } from "@cedarjs/api-server/logFormatter";
+const INTERCEPTED_SPECIFIER = "@cedarjs/api/logger";
+const VIRTUAL_MODULE_ID = "virtual:cedar-api-logger-dev";
+const RESOLVED_VIRTUAL_MODULE_ID = "\0" + VIRTUAL_MODULE_ID;
+function cedarApiLogFormatterDevPlugin() {
+  return {
+    name: "cedar-api-log-formatter-dev",
+    enforce: "pre",
+    resolveId(id, importer) {
+      if (id === INTERCEPTED_SPECIFIER && importer !== RESOLVED_VIRTUAL_MODULE_ID) {
+        return RESOLVED_VIRTUAL_MODULE_ID;
+      }
+      return null;
+    },
+    load(id) {
+      if (id !== RESOLVED_VIRTUAL_MODULE_ID) {
+        return null;
+      }
+      return `
+        import * as realLogger from ${JSON.stringify(INTERCEPTED_SPECIFIER)}
+        import { LogFormatter } from '@cedarjs/api-server/logFormatter'
+
+        export * from ${JSON.stringify(INTERCEPTED_SPECIFIER)}
+
+        ${createFormattingDestination.toString()}
+
+        // toString() doesn't include the 'export' keyword
+        export ${createLogger.toString()}
+        `;
+    }
+  };
+}
+function createFormattingDestination() {
+  const format = LogFormatter();
+  let buffered = "";
+  return {
+    write(chunk) {
+      buffered += chunk;
+      const lines = buffered.split("\n");
+      buffered = lines.pop() ?? "";
+      for (const line of lines) {
+        if (line.length > 0) {
+          process.stdout.write(format(line));
+        }
+      }
+    }
+  };
+}
+const realLogger = {
+  createLogger: (_params) => {
+    return {};
+  }
+};
+function createLogger(params = {}) {
+  if (params.destination) {
+    return realLogger.createLogger(params);
+  }
+  return realLogger.createLogger({
+    ...params,
+    destination: createFormattingDestination()
+  });
+}
+export {
+  cedarApiLogFormatterDevPlugin,
+  createFormattingDestination,
+  createLogger
+};

package/dist/plugins/vite-plugin-cedar-mock-cell-data.d.ts

@@ -0,0 +1,28 @@
+import type { Plugin } from 'vite';
+/**
+ * Vite plugin that automatically wraps the `standard` export in Cell mock files
+ * with `mockGraphQLQuery`.
+ *
+ * Only active in non-production environments (for Storybook and Jest).
+ *
+ * Transforms `*.Cell.mock.[js,ts]` files by:
+ * 1. Determining the query operation name from the adjacent Cell's QUERY export
+ * 2. Wrapping the `standard` function export in `mockGraphQLQuery(operationName, fn)`
+ * 3. If the Cell has an `afterQuery` export, also wraps with `afterQuery(fn())`
+ *
+ * This is a 1:1 port of `babel-plugin-redwood-mock-cell-data`.
+ */
+export declare function cedarMockCellDataPlugin(): Plugin;
+export declare const getCellMetadata: (p: string) => {
+    hasDefaultExport: boolean;
+    namedExports: NamedExports[];
+    hasQueryExport: NamedExports | undefined;
+    hasAfterQueryExport: NamedExports | undefined;
+    operationName: string;
+};
+interface NamedExports {
+    name: string;
+    type: 're-export' | 'variable' | 'function' | 'class';
+}
+export {};
+//# sourceMappingURL=vite-plugin-cedar-mock-cell-data.d.ts.map

package/dist/plugins/vite-plugin-cedar-mock-cell-data.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vite-plugin-cedar-mock-cell-data.d.ts","sourceRoot":"","sources":["../../src/plugins/vite-plugin-cedar-mock-cell-data.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAA;AAMlC;;;;;;;;;;;;GAYG;AACH,wBAAgB,uBAAuB,IAAI,MAAM,CA2KhD;AAcD,eAAO,MAAM,eAAe,GAAI,GAAG,MAAM;;;;;;CAoFxC,CAAA;AAgCD,UAAU,YAAY;IACpB,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,WAAW,GAAG,UAAU,GAAG,UAAU,GAAG,OAAO,CAAA;CACtD"}

package/dist/plugins/vite-plugin-cedar-mock-cell-data.js

@@ -0,0 +1,247 @@
+import fs from "node:fs";
+import path from "node:path";
+import babelGenerator from "@babel/generator";
+import { parse as babelParse } from "@babel/parser";
+import babelTraverse from "@babel/traverse";
+import * as t from "@babel/types";
+import fg from "fast-glob";
+import { parse as graphqlParse, Kind } from "graphql";
+const traverse = babelTraverse.default ?? babelTraverse;
+const generate = babelGenerator.default ?? babelGenerator;
+function cedarMockCellDataPlugin() {
+  return {
+    name: "cedar-mock-cell-data",
+    transform(code, id) {
+      if (!id.endsWith("Cell.mock.js") && !id.endsWith("Cell.mock.ts")) {
+        return null;
+      }
+      if (process.env.NODE_ENV === "production") {
+        return null;
+      }
+      const ast = parse(id, code);
+      if (!ast) {
+        return null;
+      }
+      let pathsToRemove = [];
+      const nodesToInsert = [];
+      const createVisitors = (addWatchFile) => ({
+        ExportNamedDeclaration(p) {
+          const d = p.node.declaration;
+          let mockFunction = null;
+          switch (d?.type) {
+            case "VariableDeclaration": {
+              const standardMockExport = d.declarations[0];
+              const exportId = standardMockExport.id;
+              const exportName = exportId?.name;
+              if (exportName !== "standard") {
+                return;
+              }
+              const mockFunctionMaybe = standardMockExport?.init;
+              if (!mockFunctionMaybe) {
+                return;
+              }
+              if (mockFunctionMaybe.type !== "ArrowFunctionExpression" && mockFunctionMaybe.type !== "FunctionExpression") {
+                throw new Error(
+                  `
+ 
+ Mock Error: You must export your standard mock as a function 
+ 
+`
+                );
+              }
+              mockFunction = mockFunctionMaybe;
+              break;
+            }
+            case "FunctionDeclaration": {
+              const exportName = d.id?.name;
+              if (exportName !== "standard") {
+                return;
+              }
+              mockFunction = t.arrowFunctionExpression(d.params, d.body);
+              break;
+            }
+            default:
+              return;
+          }
+          const dirname = path.dirname(id);
+          const cellName = path.basename(dirname);
+          const [cellPath] = fg.sync(`${cellName}.{js,jsx,ts,tsx}`, {
+            cwd: dirname,
+            absolute: true,
+            ignore: ["node_modules"]
+          });
+          if (!cellPath) {
+            return;
+          }
+          addWatchFile?.(cellPath);
+          const cellMetadata = getCellMetadata(cellPath);
+          if (cellMetadata.hasDefaultExport || !cellMetadata.hasQueryExport) {
+            return;
+          }
+          if (!cellMetadata.operationName) {
+            console.warn(
+              `[cedar-mock-cell-data] Cell ${cellPath} has an unnamed GraphQL operation. The mock for ${id} will not work. Ensure the QUERY is named, e.g., "query GetUser { ... }"`
+            );
+            return;
+          }
+          const mockGraphQLCall = t.callExpression(
+            t.identifier("mockGraphQLQuery"),
+            [
+              t.stringLiteral(cellMetadata.operationName),
+              mockFunction
+            ]
+          );
+          pathsToRemove = [...pathsToRemove, p];
+          if (cellMetadata.hasAfterQueryExport) {
+            const importAfterQuery = t.importDeclaration(
+              [
+                t.importSpecifier(
+                  t.identifier("afterQuery"),
+                  t.identifier("afterQuery")
+                )
+              ],
+              t.stringLiteral(`./${path.basename(cellPath)}`)
+            );
+            nodesToInsert.push(
+              importAfterQuery,
+              createExportStandard(
+                t,
+                t.arrowFunctionExpression(
+                  [],
+                  t.callExpression(t.identifier("afterQuery"), [
+                    t.callExpression(mockGraphQLCall, [])
+                  ])
+                )
+              )
+            );
+          } else {
+            nodesToInsert.push(createExportStandard(t, mockGraphQLCall));
+          }
+        }
+      });
+      traverse(ast, createVisitors(this.addWatchFile?.bind(this)));
+      if (nodesToInsert.length === 0) {
+        return null;
+      }
+      for (const p of pathsToRemove) {
+        p.remove();
+      }
+      ;
+      ast.program.body.unshift(...nodesToInsert);
+      const result = generate(ast, { retainLines: false }, code);
+      return {
+        code: result.code,
+        map: result.map
+      };
+    }
+  };
+}
+function createExportStandard(babelTypes, ex) {
+  return babelTypes.exportNamedDeclaration(
+    babelTypes.variableDeclaration("const", [
+      babelTypes.variableDeclarator(babelTypes.identifier("standard"), ex)
+    ])
+  );
+}
+const getCellMetadata = (p) => {
+  const ast = getCellAst(p);
+  let hasDefaultExport = false;
+  const namedExports = [];
+  let operation;
+  traverse(ast, {
+    ExportDefaultDeclaration() {
+      hasDefaultExport = true;
+    },
+    ExportNamedDeclaration(path2) {
+      const specifiers = path2.node?.specifiers;
+      if (specifiers.length) {
+        for (const s of specifiers) {
+          const id = s.exported;
+          namedExports.push({
+            name: id.name,
+            type: "re-export"
+          });
+        }
+        return;
+      }
+      const declaration = path2.node.declaration;
+      if (!declaration) {
+        return;
+      }
+      if (declaration.type === "VariableDeclaration") {
+        const id = declaration.declarations[0].id;
+        namedExports.push({
+          name: id.name,
+          type: "variable"
+        });
+      } else if (declaration.type === "FunctionDeclaration") {
+        namedExports.push({
+          name: declaration?.id?.name,
+          type: "function"
+        });
+      } else if (declaration.type === "ClassDeclaration") {
+        namedExports.push({
+          name: declaration?.id?.name,
+          type: "class"
+        });
+      }
+    },
+    TaggedTemplateExpression(path2) {
+      if (path2.parent?.id?.name !== "QUERY") {
+        return;
+      }
+      operation = path2.node.quasi.quasis[0].value.raw;
+    }
+  });
+  const hasQueryExport = namedExports.find(({ name }) => name === "QUERY");
+  const hasAfterQueryExport = namedExports.find(
+    ({ name }) => name === "afterQuery"
+  );
+  let operationName = "";
+  if (operation) {
+    const document = graphqlParse(operation);
+    for (const definition of document.definitions) {
+      if (definition.kind === Kind.OPERATION_DEFINITION && definition.name?.value) {
+        operationName = definition.name.value;
+      }
+    }
+  }
+  return {
+    hasDefaultExport,
+    namedExports,
+    hasQueryExport,
+    hasAfterQueryExport,
+    operationName
+  };
+};
+function getCellAst(filePath) {
+  const code = fs.readFileSync(filePath, "utf-8");
+  const plugins = ["typescript", "jsx"].filter(Boolean);
+  try {
+    return babelParse(code, {
+      sourceType: "module",
+      plugins
+    });
+  } catch (e) {
+    console.error(`Error parsing: ${filePath}`);
+    console.error(e);
+    throw new Error(e?.message);
+  }
+}
+function parse(filePath, code) {
+  const plugins = ["typescript", "jsx"].filter(Boolean);
+  try {
+    return babelParse(code, {
+      sourceType: "module",
+      plugins
+    });
+  } catch (e) {
+    console.error(`Error parsing: ${filePath}`);
+    console.error(e);
+    return null;
+  }
+}
+export {
+  cedarMockCellDataPlugin,
+  getCellMetadata
+};

package/dist/plugins/vite-plugin-cedar-otel-wrapping.d.ts

@@ -0,0 +1,39 @@
+import type { Plugin } from 'vite';
+/**
+ * Vite plugin that wraps exported API functions with OpenTelemetry spans to
+ * provide automatic tracing in your Cedar API.
+ *
+ * For each `export const fn = (async?) (...) => {...}` declaration in an API
+ * file this plugin:
+ *
+ * 1. Adds an import at the top of the file:
+ *      import { trace as OTEL_TRACE } from '@opentelemetry/api'
+ *
+ * 2. Wraps the original export with an OTel span:
+ *      export const fn = (async?) (...params) => {
+ *        const __fn = (async?) (...params) => { ...original body... }
+ *        const OTEL_TRACER = OTEL_TRACE.getTracer('redwoodjs')
+ *        const OTEL_RESULT = (await?) OTEL_TRACER.startActiveSpan(
+ *          'redwoodjs:api:<folder>:<fnName>',
+ *          (async?) (span) => { ... }
+ *        )
+ *        return OTEL_RESULT
+ *      }
+ *
+ * This replaces `babel-plugin-redwood-otel-wrapping` for all Vite and esbuild
+ * builds. The previous Babel plugin has been removed entirely; Jest transforms
+ * through the Vite SSR pipeline.
+ *
+ * NOTE: Known limitation. Spans will close before a Promise settles if a
+ * synchronous function returns a Promise. To trace async work correctly, mark
+ * the function as `async` if it returns or awaits Promises.
+ */
+export declare function cedarOtelWrappingPlugin(): Plugin;
+/**
+ * Applies OpenTelemetry span wrapping to API source files.
+ *
+ * Exported as a standalone function so it can be tested without a Vite context.
+ * Returns the transformed code string, or `null` if nothing was changed.
+ */
+export declare function applyOtelWrapping(code: string, filename: string, apiFolder: string): string | null;
+//# sourceMappingURL=vite-plugin-cedar-otel-wrapping.d.ts.map

package/dist/plugins/vite-plugin-cedar-otel-wrapping.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vite-plugin-cedar-otel-wrapping.d.ts","sourceRoot":"","sources":["../../src/plugins/vite-plugin-cedar-otel-wrapping.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAA;AAKlC;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,uBAAuB,IAAI,MAAM,CAwBhD;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,GAChB,MAAM,GAAG,IAAI,CA+Ef"}