@cedarjs/vite 5.0.6 → 5.0.7-next.219

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"}

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

@@ -0,0 +1,200 @@
+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-cedar-universal-deploy.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"vite-plugin-cedar-universal-deploy.d.ts","sourceRoot":"","sources":["../../src/plugins/vite-plugin-cedar-universal-deploy.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAA;AAMlC,MAAM,WAAW,iCAAiC;IAChD,WAAW,CAAC,EAAE,MAAM,CAAA;CACrB;AA6GD,wBAAgB,0BAA0B,CACxC,OAAO,GAAE,iCAAsC,GAC9C,MAAM,CA0GR"}
+{"version":3,"file":"vite-plugin-cedar-universal-deploy.d.ts","sourceRoot":"","sources":["../../src/plugins/vite-plugin-cedar-universal-deploy.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAA;AAalC,MAAM,WAAW,iCAAiC;IAChD,WAAW,CAAC,EAAE,MAAM,CAAA;CACrB;AA6GD,wBAAgB,0BAA0B,CACxC,OAAO,GAAE,iCAAsC,GAC9C,MAAM,CA0GR"}

package/dist/plugins/vite-plugin-cedar-universal-deploy.js

@@ -190,66 +190,15 @@ async function generateGraphQLModule(distPath) {
     include: ["__cedar_graphqlOptions"]
   });
   return `
-    import { buildCedarContext, noopAuthDecoder, requestToLegacyEvent } from '@cedarjs/api/runtime';
+    import { buildCedarContext, requestToLegacyEvent } from '@cedarjs/api/runtime';
     import { createGraphQLYoga } from '@cedarjs/graphql-server';
 
     // Inlined bundle of ${path.basename(distPath)} (node_modules kept external)
     ${bundledCode}
 
-    let yogaInitPromise = null;
+    ${createGraphQLFetch.toString()}
 
-    function getYoga() {
-      if (!yogaInitPromise) {
-        yogaInitPromise = createGraphQLYoga(__cedar_graphqlOptions).then(
-          ({ yoga }) => ({ yoga, graphqlOptions: __cedar_graphqlOptions })
-        );
-      }
-      return yogaInitPromise;
-    }
-
-    export default {
-      async fetch(request) {
-        const { yoga, graphqlOptions } = await getYoga();
-        const cedarContext = await buildCedarContext(request, {
-          authDecoder: graphqlOptions?.authDecoder ?? noopAuthDecoder,
-        });
-        const event = await requestToLegacyEvent(request, cedarContext);
-        // Wrap yoga.handle in an AsyncLocalStorage run so directive
-        // validators can read from the global @cedarjs/context. Without
-        // this, the auth plugin's setContext() call writes to a store
-        // that's only visible inside the plugin's own callback \u2014 not
-        // during directive validation.
-        const { getAsyncStoreInstance } = await import('@cedarjs/context/dist/store')
-        const store = getAsyncStoreInstance()
-
-        return store.run(new Map(), () => {
-          return yoga.handle(request, {
-            request,
-            cedarContext,
-            event,
-            requestContext: undefined,
-          })
-        }).then((response) => {
-          // GraphQL Yoga returns a PonyfillResponse from @whatwg-node/fetch
-          // which is not an instanceof the native Response class. Netlify's
-          // bootstrap checks instanceof Response, so we wrap it.
-          return new Response(response.body, {
-            status: response.status,
-            statusText: response.statusText,
-            headers: response.headers,
-          })
-        }).catch((e) => {
-          if (e?.code === 'ERR_STREAM_PREMATURE_CLOSE') {
-            // Client disconnected while the request was being processed (e.g.,
-            // page navigation, tab close). Return a 499 so the runtime doesn't
-            // treat this as a 500.
-            return new Response(null, { status: 499 })
-          }
-
-          throw e
-        })
-      }
-    };
+    export default { fetch: createGraphQLFetch(__cedar_graphqlOptions) };
   `;
 }
 async function generateFunctionModule(distPath) {
@@ -263,50 +212,103 @@ async function generateFunctionModule(distPath) {
     // Inlined bundle of ${path.basename(distPath)} (node_modules kept external)
     ${bundledCode}
 
-    const nativeHandler = (() => {
-      // Prefer named handleRequest export
-      if (typeof handleRequest !== 'undefined') { return handleRequest; }
-      // Handle export default { handleRequest } pattern
-      if (typeof __cedar_default !== 'undefined' && __cedar_default && typeof __cedar_default.handleRequest === 'function') {
-        return __cedar_default.handleRequest;
-      }
-      // Handle plain default-exported async function: export default async (req) => Response
-      if (typeof __cedar_default !== 'undefined' && typeof __cedar_default === 'function') {
-        return __cedar_default;
-      }
-      return undefined;
-    })();
+    ${resolveNativeHandler.toString()}
 
-    const legacyFn = (() => {
-      if (typeof handler !== 'undefined') { return handler; }
-      if (typeof __cedar_default !== 'undefined' && __cedar_default && typeof __cedar_default.handler === 'function') {
-        return __cedar_default.handler;
-      }
-      return undefined;
-    })();
+    ${resolveLegacyHandler.toString()}
 
-    if (!nativeHandler && !legacyFn) {
-      throw new Error(${notFoundMsg});
-    }
+    ${resolveCedarHandler.toString()}
 
-    const _handler = nativeHandler ?? wrapLegacyHandler(legacyFn);
+    ${createFunctionFetch.toString()}
 
     export default {
-      async fetch(request) {
-        const ctx = await buildCedarContext(request);
-        // Wrap the handler in an AsyncLocalStorage run so the global
-        // @cedarjs/context is available inside it (and isolated per request).
-        // Mirrors the GraphQL module above and the cedarContextWrappingPlugin
-        // used for non-UD builds.
-        const { getAsyncStoreInstance } = await import(
-          '@cedarjs/context/dist/store'
-        );
-        const store = getAsyncStoreInstance();
-        return store.run(new Map(), () => _handler(request, ctx));
-      }
+      fetch: createFunctionFetch(resolveCedarHandler(${notFoundMsg})),
     };
   `;
 }
+function resolveNativeHandler() {
+  if (typeof handleRequest !== "undefined") {
+    return handleRequest;
+  }
+  if (typeof __cedar_default === "undefined" || !__cedar_default) {
+    return void 0;
+  }
+  if (typeof __cedar_default === "object" && typeof __cedar_default.handleRequest === "function") {
+    return __cedar_default.handleRequest;
+  }
+  if (typeof __cedar_default === "function") {
+    return __cedar_default;
+  }
+  return void 0;
+}
+function resolveLegacyHandler() {
+  if (typeof handler !== "undefined") {
+    return handler;
+  }
+  if (typeof __cedar_default === "undefined" || !__cedar_default) {
+    return void 0;
+  }
+  if (typeof __cedar_default === "object" && typeof __cedar_default.handler === "function") {
+    return __cedar_default.handler;
+  }
+  return void 0;
+}
+function resolveCedarHandler(notFoundMessage) {
+  const nativeHandler = resolveNativeHandler();
+  if (nativeHandler) {
+    return nativeHandler;
+  }
+  const legacyFn = resolveLegacyHandler();
+  if (!legacyFn) {
+    throw new Error(notFoundMessage);
+  }
+  return wrapLegacyHandler(legacyFn);
+}
+function createFunctionFetch(cedarHandler) {
+  return async function fetch(request) {
+    const ctx = await buildCedarContext(request);
+    const { getAsyncStoreInstance } = await import("@cedarjs/context/dist/store");
+    const store = getAsyncStoreInstance();
+    return store.run(/* @__PURE__ */ new Map(), () => cedarHandler(request, ctx));
+  };
+}
+function createGraphQLFetch(graphqlOptions) {
+  let yogaInitPromise = null;
+  function getYoga() {
+    if (!yogaInitPromise) {
+      yogaInitPromise = createGraphQLYoga(graphqlOptions);
+    }
+    return yogaInitPromise;
+  }
+  return async function fetch(request) {
+    const { yoga } = await getYoga();
+    const cedarContext = await buildCedarContext(request, {
+      authDecoder: graphqlOptions?.authDecoder
+    });
+    const event = await requestToLegacyEvent(request, cedarContext);
+    const { getAsyncStoreInstance } = await import("@cedarjs/context/dist/store");
+    const store = getAsyncStoreInstance();
+    try {
+      const response = await store.run(/* @__PURE__ */ new Map(), () => {
+        return yoga.handle(request, {
+          request,
+          cedarContext,
+          event,
+          requestContext: void 0
+        });
+      });
+      return new Response(response.body, {
+        status: response.status,
+        statusText: response.statusText,
+        headers: response.headers
+      });
+    } catch (e) {
+      if (!!e && typeof e === "object" && "code" in e && e.code === "ERR_STREAM_PREMATURE_CLOSE") {
+        return new Response(null, { status: 499 });
+      }
+      throw e;
+    }
+  };
+}
 export {
   cedarUniversalDeployPlugin
 };