@cedarjs/vite 5.0.7-next.338 → 5.0.7

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

@@ -1,28 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,247 +0,0 @@
-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

@@ -1,39 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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"}

package/dist/plugins/vite-plugin-cedar-otel-wrapping.js

@@ -1,200 +0,0 @@
-import { parseSync } from "oxc-parser";
-import { normalizePath } from "vite";
-import { getPaths } from "@cedarjs/project-config";
-function cedarOtelWrappingPlugin() {
-  return {
-    name: "cedar-otel-wrapping",
-    transform(code, id) {
-      let apiSrc;
-      try {
-        apiSrc = normalizePath(getPaths().api.src);
-      } catch {
-        return null;
-      }
-      if (!normalizePath(id).startsWith(apiSrc + "/")) {
-        return null;
-      }
-      const relativePath = normalizePath(id).slice(apiSrc.length + 1);
-      const apiFolder = relativePath.split("/")[0] ?? "?";
-      const result = applyOtelWrapping(code, id, apiFolder);
-      return result ? { code: result, map: null } : null;
-    }
-  };
-}
-function applyOtelWrapping(code, filename, apiFolder) {
-  const parseResult = parseSync(filename, code, { sourceType: "module" });
-  const replacements = [];
-  for (const node of parseResult.program.body) {
-    if (node.type !== "ExportNamedDeclaration") {
-      continue;
-    }
-    const decl = node.declaration;
-    if (decl?.type !== "VariableDeclaration") {
-      continue;
-    }
-    const declarator = decl.declarations[0];
-    if (!declarator) {
-      continue;
-    }
-    const fn = declarator.init;
-    if (fn?.type !== "ArrowFunctionExpression") {
-      continue;
-    }
-    if (declarator.id.type !== "Identifier") {
-      continue;
-    }
-    const fnName = declarator.id.name;
-    const innerArgs = buildInnerArgs(fn.params);
-    if (innerArgs === null) {
-      continue;
-    }
-    const fnHeader = code.slice(fn.start, fn.body.start);
-    const originalFnSrc = code.slice(fn.start, fn.end);
-    const isAsync = fn.async;
-    const awaitKw = isAsync ? "await " : "";
-    const asyncKw = isAsync ? "async " : "";
-    replacements.push({
-      start: node.start,
-      end: node.end,
-      src: buildWrappedExport(
-        fnName,
-        fnHeader,
-        originalFnSrc,
-        innerArgs,
-        awaitKw,
-        asyncKw,
-        apiFolder,
-        filename
-      )
-    });
-  }
-  if (replacements.length === 0) {
-    return null;
-  }
-  let output = code;
-  for (let i = replacements.length - 1; i >= 0; i--) {
-    const r = replacements[i];
-    output = output.slice(0, r.start) + r.src + output.slice(r.end);
-  }
-  return `import { trace as OTEL_TRACE } from '@opentelemetry/api'
-` + output;
-}
-function buildInnerArgs(params) {
-  const args = [];
-  for (const param of params) {
-    if (param.type === "RestElement" || param.type === "ArrayPattern" || param.type === "TSParameterProperty") {
-      return null;
-    }
-    if (param.type === "Identifier") {
-      args.push(param.name);
-      continue;
-    }
-    if (param.type === "ObjectPattern") {
-      for (const prop of param.properties) {
-        if (prop.type === "RestElement") {
-          return null;
-        }
-        if (prop.key.type !== "Identifier") {
-          return null;
-        }
-        const value = prop.value;
-        if (value.type !== "Identifier" && value.type !== "AssignmentPattern" && value.type !== "ObjectPattern") {
-          return null;
-        }
-        if (value.type === "AssignmentPattern") {
-          if (value.left.type !== "Identifier" && value.left.type !== "ObjectPattern") {
-            return null;
-          }
-        }
-      }
-      const obj = buildObjectCallArg(param);
-      if (obj === null) {
-        return null;
-      }
-      args.push(obj);
-      continue;
-    }
-    if (param.type === "AssignmentPattern") {
-      const ap = param;
-      if (ap.left.type === "Identifier") {
-        args.push(ap.left.name);
-      } else if (ap.left.type === "ObjectPattern") {
-        const obj = buildObjectCallArg(ap.left);
-        if (obj === null) {
-          return null;
-        }
-        args.push(obj);
-      } else {
-        return null;
-      }
-      continue;
-    }
-    return null;
-  }
-  return args.join(", ");
-}
-function buildObjectCallArg(pattern) {
-  const keys = [];
-  for (const prop of pattern.properties) {
-    if (prop.type === "RestElement") {
-      return null;
-    }
-    if (prop.key.type !== "Identifier") {
-      return null;
-    }
-    const keyName = prop.key.name;
-    let valueName = null;
-    if (prop.value.type === "Identifier") {
-      valueName = prop.value.name;
-    } else if (prop.value.type === "AssignmentPattern") {
-      if (prop.value.left.type === "Identifier") {
-        valueName = prop.value.left.name;
-      } else {
-        return null;
-      }
-    } else {
-      return null;
-    }
-    if (valueName !== keyName) {
-      keys.push(`${keyName}: ${valueName}`);
-    } else {
-      keys.push(keyName);
-    }
-  }
-  return `{ ${keys.join(", ")} }`;
-}
-function buildWrappedExport(fnName, fnHeader, originalFnSrc, innerArgs, awaitKw, asyncKw, apiFolder, filename) {
-  const privateName = `__${fnName}`;
-  const spanName = `redwoodjs:api:${apiFolder}:${fnName}`;
-  return `export const ${fnName} = ${fnHeader}{
-  const ${privateName} = ${originalFnSrc}
-  const OTEL_TRACER = OTEL_TRACE.getTracer('redwoodjs')
-  const OTEL_RESULT = ${awaitKw}OTEL_TRACER.startActiveSpan(
-    '${spanName}',
-    ${asyncKw}(span) => {
-      span.setAttribute('code.function', '${fnName}')
-      span.setAttribute('code.filepath', ${JSON.stringify(filename)})
-      try {
-        const OTEL_INNER_RESULT = ${awaitKw}${privateName}(${innerArgs})
-        span.end()
-        return OTEL_INNER_RESULT
-      } catch (error) {
-        span.recordException(error)
-        span.setStatus({
-          code: 2,
-          message:
-            error?.message?.split('\\n')[0] ??
-            error?.toString()?.split('\\n')[0],
-        })
-        span.end()
-        throw error
-      }
-    }
-  )
-  return OTEL_RESULT
-}`;
-}
-export {
-  applyOtelWrapping,
-  cedarOtelWrappingPlugin
-};

package/dist/plugins/vite-plugin-handler-als-wrapping.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"vite-plugin-handler-als-wrapping.d.ts","sourceRoot":"","sources":["../../src/plugins/vite-plugin-handler-als-wrapping.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAA;AAKlC;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,wBAAwB,CAAC,EACvC,YAAoB,GACrB,GAAE;IACD,YAAY,CAAC,EAAE,OAAO,CAAA;CAClB,GAAG,MAAM,CAuBd;AAED;;;;;;;;;GASG;AACH,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,MAAM,EACZ,EAAE,YAAoB,EAAE,GAAE;IAAE,YAAY,CAAC,EAAE,OAAO,CAAA;CAAO,GACxD,MAAM,GAAG,IAAI,CAsDf"}