@cedarjs/api-server 4.0.0 → 4.0.1-next.67

package/dist/cjs/udFetchable.js

@@ -0,0 +1,36 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var udFetchable_exports = {};
+__export(udFetchable_exports, {
+  createCedarFetchable: () => createCedarFetchable
+});
+module.exports = __toCommonJS(udFetchable_exports);
+var import_runtime = require("@cedarjs/api/runtime");
+function createCedarFetchable(handler) {
+  return {
+    async fetch(request) {
+      const ctx = await (0, import_runtime.buildCedarContext)(request);
+      return handler(request, ctx);
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createCedarFetchable
+});

package/dist/createServer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"createServer.d.ts","sourceRoot":"","sources":["../src/createServer.ts"],"names":[],"mappings":"AAgBA,OAAO,KAAK,EACV,mBAAmB,EACnB,MAAM,EAEP,MAAM,0BAA0B,CAAA;AAsBjC;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAsB,YAAY,CAAC,OAAO,GAAE,mBAAwB,mBAoHnE"}
+{"version":3,"file":"createServer.d.ts","sourceRoot":"","sources":["../src/createServer.ts"],"names":[],"mappings":"AAiBA,OAAO,KAAK,EACV,mBAAmB,EACnB,MAAM,EAEP,MAAM,0BAA0B,CAAA;AAsBjC;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAsB,YAAY,CAAC,OAAO,GAAE,mBAAwB,mBAoHnE"}

package/dist/createServer.js

@@ -1,5 +1,6 @@
 import fs from "node:fs";
-import path from "path";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
 import ansis from "ansis";
 import { config } from "dotenv-defaults";
 import fg from "fast-glob";
@@ -76,7 +77,7 @@ async function createServer(options = {}) {
   });
   if (graphqlFunctionPath) {
     const { redwoodFastifyGraphQLServer } = await import("./plugins/graphql.js");
-    const { __rw_graphqlOptions } = await import(`file://${graphqlFunctionPath}`);
+    const { __rw_graphqlOptions } = await import(pathToFileURL(graphqlFunctionPath).href);
     await server.register(redwoodFastifyGraphQLServer, {
       redwood: {
         apiRootPath,

package/dist/fastify.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fastify.d.ts","sourceRoot":"","sources":["../src/fastify.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,eAAe,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAA;AAOpE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAA;AAGrD,eAAO,MAAM,eAAe;;;;CAI3B,CAAA;AAiBD,wBAAsB,iBAAiB;YAb7B,oBAAoB;sBACV,mBAAmB;GAsCtC;AAED,eAAO,MAAM,qBAAqB,GAChC,UAAU,oBAAoB,KAC7B,OAAO,CAAC,eAAe,CAWzB,CAAA"}
+{"version":3,"file":"fastify.d.ts","sourceRoot":"","sources":["../src/fastify.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,eAAe,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAA;AAOpE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAA;AAGrD,eAAO,MAAM,eAAe;;;;CAI3B,CAAA;AAkBD,wBAAsB,iBAAiB;YAb7B,oBAAoB;sBACV,mBAAmB;GA2CtC;AAED,eAAO,MAAM,qBAAqB,GAChC,UAAU,oBAAoB,KAC7B,OAAO,CAAC,eAAe,CAWzB,CAAA"}

package/dist/fastify.js

@@ -10,6 +10,7 @@ const DEFAULT_OPTIONS = {
   }
 };
 let isServerConfigLoaded = false;
+let loadedServerConfigPath;
 let serverConfigFile = {
   config: DEFAULT_OPTIONS,
   configureFastify: async (fastify, options) => {
@@ -28,6 +29,9 @@ async function loadFastifyConfig() {
   if (!fs.existsSync(serverConfigPath)) {
     return serverConfigFile;
   }
+  if (loadedServerConfigPath !== serverConfigPath) {
+    isServerConfigLoaded = false;
+  }
   if (!isServerConfigLoaded) {
     console.log(`Loading server config from ${serverConfigPath}`);
     console.log(`Loading server config from URL file://${serverConfigPath}`);
@@ -36,6 +40,7 @@ async function loadFastifyConfig() {
     );
     const config = await import(pathToFileURL(serverConfigPath).href);
     serverConfigFile = { ...config.default };
+    loadedServerConfigPath = serverConfigPath;
     isServerConfigLoaded = true;
   }
   return serverConfigFile;

package/dist/plugins/api.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"api.d.ts","sourceRoot":"","sources":["../../src/plugins/api.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,IAAI,eAAe,EAAE,MAAM,WAAW,CAAA;AAC3D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AAO9C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,2BAA2B,CAAA;AAKvD,MAAM,WAAW,sBAAsB;IAErC,OAAO,EAAE;QACP,WAAW,CAAC,EAAE,MAAM,CAAA;QACpB,eAAe,CAAC,EAAE,eAAe,CAAA;QACjC,qBAAqB,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAA;QACzC,cAAc,CAAC,EAAE,OAAO,CAAA;QACxB,eAAe,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;KAC3D,CAAA;CACF;AAED,wBAAsB,eAAe,CACnC,OAAO,EAAE,eAAe,EACxB,IAAI,EAAE,sBAAsB,iBA4C7B"}
+{"version":3,"file":"api.d.ts","sourceRoot":"","sources":["../../src/plugins/api.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,IAAI,eAAe,EAAE,MAAM,WAAW,CAAA;AAC3D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AAO9C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,2BAA2B,CAAA;AAKvD,MAAM,WAAW,sBAAsB;IAErC,OAAO,EAAE;QACP,WAAW,CAAC,EAAE,MAAM,CAAA;QACpB,eAAe,CAAC,EAAE,eAAe,CAAA;QACjC,qBAAqB,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAA;QACzC,cAAc,CAAC,EAAE,OAAO,CAAA;QACxB,eAAe,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;KAI3D,CAAA;CACF;AAED,wBAAsB,eAAe,CACnC,OAAO,EAAE,eAAe,EACxB,IAAI,EAAE,sBAAsB,iBA4C7B"}

package/dist/plugins/graphql.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graphql.d.ts","sourceRoot":"","sources":["../../src/plugins/graphql.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,eAAe,EAAe,MAAM,SAAS,CAAA;AAO3D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAKjE,MAAM,WAAW,4BAA4B;IAC3C,OAAO,EAAE;QACP,WAAW,CAAC,EAAE,MAAM,CAAA;QACpB,OAAO,CAAC,EAAE,kBAAkB,CAAA;KAC7B,CAAA;CACF;AAED,wBAAsB,2BAA2B,CAC/C,OAAO,EAAE,eAAe,EACxB,OAAO,EAAE,4BAA4B,iBAmGtC"}
+{"version":3,"file":"graphql.d.ts","sourceRoot":"","sources":["../../src/plugins/graphql.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,eAAe,EAA+B,MAAM,SAAS,CAAA;AAO3E,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAKjE,MAAM,WAAW,4BAA4B;IAC3C,OAAO,EAAE;QACP,WAAW,CAAC,EAAE,MAAM,CAAA;QACpB,OAAO,CAAC,EAAE,kBAAkB,CAAA;KAC7B,CAAA;CACF;AAED,wBAAsB,2BAA2B,CAC/C,OAAO,EAAE,eAAe,EACxB,OAAO,EAAE,4BAA4B,iBAuGtC"}

package/dist/plugins/graphql.js

@@ -1,6 +1,8 @@
+import { pathToFileURL } from "node:url";
 import fastifyMultiPart from "@fastify/multipart";
 import fastifyUrlData from "@fastify/url-data";
 import fg from "fast-glob";
+import { buildCedarContext } from "@cedarjs/api/runtime";
 import { getAsyncStoreInstance } from "@cedarjs/context/dist/store";
 import { coerceRootPath } from "@cedarjs/fastify-web/dist/helpers.js";
 import { createGraphQLYoga } from "@cedarjs/graphql-server";
@@ -22,7 +24,7 @@ async function redwoodFastifyGraphQLServer(fastify, options) {
         cwd: getPaths().api.base,
         absolute: true
       });
-      const filePath = `file://${graphqlFunctionPath}`;
+      const filePath = pathToFileURL(graphqlFunctionPath).href;
       const { __rw_graphqlOptions } = await import(filePath);
       if (!__rw_graphqlOptions) {
         return;
@@ -30,33 +32,28 @@ async function redwoodFastifyGraphQLServer(fastify, options) {
       redwoodOptions.graphql = __rw_graphqlOptions;
     }
     const graphqlOptions = redwoodOptions.graphql;
-    if (graphqlOptions?.realtime) {
-      const { useCedarRealtime } = await import("@cedarjs/realtime");
-      const originalExtraPlugins = graphqlOptions.extraPlugins ?? [];
-      originalExtraPlugins.push(
-        // This type cast is needed because useCedarRealtime returns an
-        // EnvelopPlugin and here we need a YogaPlugin. I can't change the
-        // return type of `useCedarRealtime` yet, because it'd be a breaking
-        // change.
-        useCedarRealtime(graphqlOptions.realtime)
-      );
-      graphqlOptions.extraPlugins = originalExtraPlugins;
-      if (graphqlOptions.realtime.subscriptions) {
-        method.push("PUT");
-      }
+    if (graphqlOptions?.realtime?.subscriptions) {
+      method.push("PUT");
     }
-    const { yoga } = createGraphQLYoga(graphqlOptions);
+    const { yoga } = await createGraphQLYoga(graphqlOptions);
     const graphqlEndpoint = trimSlashes(yoga.graphqlEndpoint);
     const routePaths = ["", "/health", "/readiness", "/stream"];
     for (const routePath of routePaths) {
       fastify.route({
         url: `${redwoodOptions.apiRootPath}${graphqlEndpoint}${routePath}`,
         method,
-        handler: (req, reply) => yoga.handleNodeRequestAndResponse(req, reply, {
-          req,
-          reply,
-          event: lambdaEventForFastifyRequest(req)
-        })
+        handler: async (req, _reply) => {
+          const request = createFetchRequest(req);
+          const cedarContext = await buildCedarContext(request, {
+            authDecoder: graphqlOptions.authDecoder
+          });
+          return yoga.handle(request, {
+            request,
+            cedarContext,
+            event: lambdaEventForFastifyRequest(req),
+            requestContext: void 0
+          });
+        }
       });
     }
     fastify.addHook("onReady", (done) => {
@@ -76,6 +73,15 @@ async function redwoodFastifyGraphQLServer(fastify, options) {
 function trimSlashes(path) {
   return path.replace(/^\/|\/$/g, "");
 }
+function createFetchRequest(req) {
+  const requestBody = req.method === "GET" || req.method === "HEAD" ? void 0 : typeof req.body === "string" ? req.body : req.body ? JSON.stringify(req.body) : void 0;
+  const href = `${req.protocol}://${req.hostname}${req.raw.url ?? "/"}`;
+  return new Request(href, {
+    method: req.method,
+    headers: req.headers,
+    body: requestBody
+  });
+}
 export {
   redwoodFastifyGraphQLServer
 };

package/dist/plugins/lambdaLoader.d.ts

@@ -1,8 +1,16 @@
 import type { Handler } from 'aws-lambda';
 import type { Options as FastGlobOptions } from 'fast-glob';
 import type { FastifyReply, FastifyRequest, RequestGenericInterface } from 'fastify';
-export type Lambdas = Record<string, Handler>;
-export declare const LAMBDA_FUNCTIONS: Lambdas;
+import type { CedarHandler, CedarRouteRecord } from '@cedarjs/api/runtime';
+export declare const LAMBDA_FUNCTIONS: Map<string, Handler>;
+export declare const CEDAR_HANDLERS: Map<string, CedarHandler>;
+/**
+ * Exports a copy of the Cedar route manifest.
+ *
+ * This is intended to be used to later build WinterTC compatible `fetch`
+ * exports
+ */
+export declare const getCedarRouteManifest: () => CedarRouteRecord[];
 export declare const setLambdaFunctions: (foundFunctions: string[]) => Promise<void>;
 type LoadFunctionsFromDistOptions = {
     fastGlobOptions?: FastGlobOptions;
@@ -15,10 +23,12 @@ interface LambdaHandlerRequest extends RequestGenericInterface {
     };
 }
 /**
- This will take a fastify request
- Then convert it to a lambdaEvent, and pass it to the the appropriate handler for the routeName
- The LAMBDA_FUNCTIONS lookup has been populated already by this point
- **/
+ * This will take a fastify request
+ * Then convert it to a lambdaEvent, and pass it to the the appropriate handler
+ * for the routeName
+ * The CEDAR_HANDLERS and LAMBDA_FUNCTIONS maps have been populated already by
+ * this point
+ */
 export declare const lambdaRequestHandler: (req: FastifyRequest<LambdaHandlerRequest>, reply: FastifyReply) => Promise<void>;
 export {};
 //# sourceMappingURL=lambdaLoader.d.ts.map

package/dist/plugins/lambdaLoader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lambdaLoader.d.ts","sourceRoot":"","sources":["../../src/plugins/lambdaLoader.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,YAAY,CAAA;AAEzC,OAAO,KAAK,EAAE,OAAO,IAAI,eAAe,EAAE,MAAM,WAAW,CAAA;AAC3D,OAAO,KAAK,EACV,YAAY,EACZ,cAAc,EACd,uBAAuB,EACxB,MAAM,SAAS,CAAA;AAOhB,MAAM,MAAM,OAAO,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;AAC7C,eAAO,MAAM,gBAAgB,EAAE,OAAY,CAAA;AAI3C,eAAO,MAAM,kBAAkB,GAAU,gBAAgB,MAAM,EAAE,kBAsDhE,CAAA;AAED,KAAK,4BAA4B,GAAG;IAClC,eAAe,CAAC,EAAE,eAAe,CAAA;IACjC,qBAAqB,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAA;CAC1C,CAAA;AAGD,eAAO,MAAM,qBAAqB,GAChC,UAAS,4BAAiC,kBAe3C,CAAA;AA0BD,UAAU,oBAAqB,SAAQ,uBAAuB;IAC5D,MAAM,EAAE;QACN,SAAS,EAAE,MAAM,CAAA;KAClB,CAAA;CACF;AAED;;;;IAII;AACJ,eAAO,MAAM,oBAAoB,GAC/B,KAAK,cAAc,CAAC,oBAAoB,CAAC,EACzC,OAAO,YAAY,kBAsBpB,CAAA"}
+{"version":3,"file":"lambdaLoader.d.ts","sourceRoot":"","sources":["../../src/plugins/lambdaLoader.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,YAAY,CAAA;AAEzC,OAAO,KAAK,EAAE,OAAO,IAAI,eAAe,EAAE,MAAM,WAAW,CAAA;AAC3D,OAAO,KAAK,EACV,YAAY,EACZ,cAAc,EACd,uBAAuB,EACxB,MAAM,SAAS,CAAA;AAGhB,OAAO,KAAK,EACV,YAAY,EACZ,gBAAgB,EAEjB,MAAM,sBAAsB,CAAA;AAO7B,eAAO,MAAM,gBAAgB,sBAA6B,CAAA;AAC1D,eAAO,MAAM,cAAc,2BAAkC,CAAA;AAG7D;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB,0BAAgC,CAAA;AAIlE,eAAO,MAAM,kBAAkB,GAAU,gBAAgB,MAAM,EAAE,kBAuGhE,CAAA;AAED,KAAK,4BAA4B,GAAG;IAClC,eAAe,CAAC,EAAE,eAAe,CAAA;IACjC,qBAAqB,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAA;CAC1C,CAAA;AAGD,eAAO,MAAM,qBAAqB,GAChC,UAAS,4BAAiC,kBAe3C,CAAA;AA0BD,UAAU,oBAAqB,SAAQ,uBAAuB;IAC5D,MAAM,EAAE;QACN,SAAS,EAAE,MAAM,CAAA;KAClB,CAAA;CACF;AAED;;;;;;GAMG;AACH,eAAO,MAAM,oBAAoB,GAC/B,KAAK,cAAc,CAAC,oBAAoB,CAAC,EACzC,OAAO,YAAY,kBAqEpB,CAAA"}

package/dist/plugins/lambdaLoader.js

@@ -1,17 +1,27 @@
-import path from "path";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
 import ansis from "ansis";
 import fg from "fast-glob";
+import { terminalLink } from "termi-link";
+import { buildCedarContext, wrapLegacyHandler } from "@cedarjs/api/runtime";
 import { getPaths } from "@cedarjs/project-config";
 import { requestHandler } from "../requestHandlers/awsLambdaFastify.js";
 import { escape } from "../utils.js";
-const LAMBDA_FUNCTIONS = {};
+const LAMBDA_FUNCTIONS = /* @__PURE__ */ new Map();
+const CEDAR_HANDLERS = /* @__PURE__ */ new Map();
+const cedarRouteManifest = [];
+const getCedarRouteManifest = () => [...cedarRouteManifest];
 const setLambdaFunctions = async (foundFunctions) => {
   const tsImport = Date.now();
   console.log(ansis.dim.italic("Importing Server Functions... "));
+  cedarRouteManifest.length = 0;
+  LAMBDA_FUNCTIONS.clear();
+  CEDAR_HANDLERS.clear();
   const imports = foundFunctions.map(async (fnPath) => {
     const ts = Date.now();
     const routeName = path.basename(fnPath).replace(".js", "");
-    const fnImport = await import(`file://${fnPath}`);
+    const routePath = routeName === "graphql" ? "/graphql" : `/${routeName}`;
+    const fnImport = await import(pathToFileURL(fnPath).href);
     const handler = (() => {
       if ("handler" in fnImport) {
         return fnImport.handler;
@@ -23,17 +33,39 @@ const setLambdaFunctions = async (foundFunctions) => {
       }
       return void 0;
     })();
-    LAMBDA_FUNCTIONS[routeName] = handler;
-    if (!handler) {
+    const cedarHandler = (() => {
+      if ("handleRequest" in fnImport && typeof fnImport.handleRequest === "function") {
+        return fnImport.handleRequest;
+      }
+      if ("default" in fnImport && fnImport.default && "handleRequest" in fnImport.default && typeof fnImport.default.handleRequest === "function") {
+        return fnImport.default.handleRequest;
+      }
+      return void 0;
+    })();
+    if (handler) {
+      LAMBDA_FUNCTIONS.set(routeName, handler);
+    }
+    if (cedarHandler) {
+      CEDAR_HANDLERS.set(routeName, cedarHandler);
+    } else if (handler) {
+      CEDAR_HANDLERS.set(routeName, wrapLegacyHandler(handler));
+    }
+    if (!handler && !cedarHandler) {
       console.warn(
         routeName,
         "at",
         fnPath,
-        "does not have a function called handler defined."
+        "does not have a function called handler or handleRequest defined."
       );
     }
+    cedarRouteManifest.push({
+      path: routePath,
+      methods: routeName === "graphql" ? ["GET", "POST", "OPTIONS"] : ["GET", "POST"],
+      type: routeName === "graphql" ? "graphql" : routeName === "health" ? "health" : routeName.toLowerCase().includes("auth") ? "auth" : "function",
+      entry: fnPath
+    });
     console.log(
-      ansis.magenta("/" + routeName),
+      terminalLink(ansis.magenta("/" + routeName), pathToFileURL(fnPath).href),
       ansis.dim.italic(Date.now() - ts + " ms")
     );
   });
@@ -72,14 +104,43 @@ const findApiDistFunctions = (params) => {
 };
 const lambdaRequestHandler = async (req, reply) => {
   const { routeName } = req.params;
-  if (!LAMBDA_FUNCTIONS[routeName]) {
+  const cedarHandlerCandidate = CEDAR_HANDLERS.get(routeName);
+  const cedarHandler = typeof cedarHandlerCandidate === "function" ? cedarHandlerCandidate : void 0;
+  if (cedarHandler) {
+    const requestBody = req.method === "GET" || req.method === "HEAD" ? void 0 : typeof req.rawBody === "string" ? req.rawBody : req.rawBody ? Buffer.from(req.rawBody).toString() : void 0;
+    const href = `${req.protocol}://${req.hostname}${req.raw.url ?? "/"}`;
+    const request = new Request(href, {
+      method: req.method,
+      headers: req.headers,
+      body: requestBody
+    });
+    const ctx = await buildCedarContext(request, {
+      params: {
+        routeName
+      }
+    });
+    const response = await cedarHandler(request, ctx);
+    reply.status(response.status);
+    response.headers.forEach((value, name) => {
+      reply.header(name, value);
+    });
+    const body = await response.arrayBuffer();
+    reply.send(Buffer.from(body));
+    return;
+  }
+  const handler = LAMBDA_FUNCTIONS.get(routeName);
+  if (handler) {
+    return requestHandler(req, reply, handler);
+  } else {
     const errorMessage = `Function "${routeName}" was not found.`;
     req.log.error(errorMessage);
     reply.status(404);
     if (process.env.NODE_ENV === "development") {
       const devError = {
         error: errorMessage,
-        availableFunctions: Object.keys(LAMBDA_FUNCTIONS)
+        availableFunctions: [
+          .../* @__PURE__ */ new Set([...LAMBDA_FUNCTIONS.keys(), ...CEDAR_HANDLERS.keys()])
+        ]
       };
       reply.send(devError);
     } else {
@@ -87,10 +148,11 @@ const lambdaRequestHandler = async (req, reply) => {
     }
     return;
   }
-  return requestHandler(req, reply, LAMBDA_FUNCTIONS[routeName]);
 };
 export {
+  CEDAR_HANDLERS,
   LAMBDA_FUNCTIONS,
+  getCedarRouteManifest,
   lambdaRequestHandler,
   loadFunctionsFromDist,
   setLambdaFunctions

package/dist/requestHandlers/awsLambdaFastify.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"awsLambdaFastify.d.ts","sourceRoot":"","sources":["../../src/requestHandlers/awsLambdaFastify.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,oBAAoB,EACpB,OAAO,EAER,MAAM,YAAY,CAAA;AACnB,OAAO,KAAK,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,SAAS,CAAA;AAK3D,eAAO,MAAM,4BAA4B,GACvC,SAAS,cAAc,KACtB,oBAyBF,CAAA;AAoCD,eAAO,MAAM,cAAc,GACzB,KAAK,cAAc,EACnB,OAAO,YAAY,EACnB,SAAS,OAAO,kBAmCjB,CAAA"}
+{"version":3,"file":"awsLambdaFastify.d.ts","sourceRoot":"","sources":["../../src/requestHandlers/awsLambdaFastify.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,oBAAoB,EACpB,OAAO,EAGR,MAAM,YAAY,CAAA;AACnB,OAAO,KAAK,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,SAAS,CAAA;AAK3D,eAAO,MAAM,4BAA4B,GACvC,SAAS,cAAc,KACtB,oBA6BF,CAAA;AAoCD,eAAO,MAAM,cAAc,GACzB,KAAK,cAAc,EACnB,OAAO,YAAY,EACnB,SAAS,OAAO,kBAmCjB,CAAA"}

package/dist/requestHandlers/awsLambdaFastify.js

@@ -11,14 +11,18 @@ const lambdaEventForFastifyRequest = (request) => {
   );
   return {
     httpMethod: request.method,
-    headers: request.headers,
+    headers: {
+      "x-forwarded-proto": request.protocol,
+      ...request.headers
+    },
     path: request.urlData("path"),
     queryStringParameters: qsParams,
     requestContext: {
       requestId: request.id,
       identity: {
         sourceIp: request.ip
-      }
+      },
+      domainName: request.hostname
     },
     ...parseBody(request.rawBody || "")
     // adds `body` and `isBase64Encoded`

package/dist/udDispatcher.d.ts

@@ -0,0 +1,28 @@
+import type { EntryMeta } from '@universal-deploy/store';
+import type { Fetchable } from './udFetchable.js';
+export interface CedarDispatcherOptions {
+    apiRootPath?: string;
+    discoverFunctionsGlob?: string | string[];
+    /**
+     * Cache-bust token appended to dynamic ESM imports. Use this in dev to
+     * bypass Node.js's ESM module cache after a rebuild. Production builds
+     * should omit this.
+     */
+    cacheBust?: string | number;
+}
+export interface CedarDispatcherResult {
+    fetchable: Fetchable;
+    registrations: EntryMeta[];
+}
+/**
+ * Shared aggregate Cedar API dispatcher used by
+ * `cedarUniversalDeployPlugin` (via `virtual:cedar-api`).
+ *
+ * Discovers Cedar API functions in `api/dist/functions/`, builds a rou3 router
+ * and a map of route names to Fetchables, then returns a single Fetchable that
+ * routes incoming Fetch-API requests to the correct per-function handler.
+ * Also returns the list of `EntryMeta` registrations so callers can forward
+ * them to `@universal-deploy/store` via `addEntry()`.
+ */
+export declare function buildCedarDispatcher(options?: CedarDispatcherOptions): Promise<CedarDispatcherResult>;
+//# sourceMappingURL=udDispatcher.d.ts.map

package/dist/udDispatcher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"udDispatcher.d.ts","sourceRoot":"","sources":["../src/udDispatcher.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAA;AAUxD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAA;AAgBjD,MAAM,WAAW,sBAAsB;IACrC,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,qBAAqB,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAA;IACzC;;;;OAIG;IACH,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;CAC5B;AAED,MAAM,WAAW,qBAAqB;IACpC,SAAS,EAAE,SAAS,CAAA;IACpB,aAAa,EAAE,SAAS,EAAE,CAAA;CAC3B;AA6BD;;;;;;;;;GASG;AACH,wBAAsB,oBAAoB,CACxC,OAAO,CAAC,EAAE,sBAAsB,GAC/B,OAAO,CAAC,qBAAqB,CAAC,CAmNhC"}

package/dist/udDispatcher.js

@@ -0,0 +1,158 @@
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import fg from "fast-glob";
+import { addRoute, createRouter, findRoute } from "rou3";
+import { buildCedarContext, requestToLegacyEvent } from "@cedarjs/api/runtime";
+import { getAsyncStoreInstance } from "@cedarjs/context/dist/store";
+import { getPaths } from "@cedarjs/project-config";
+import { createCedarFetchable } from "./udFetchable.js";
+const ALL_HTTP_METHODS = [
+  "GET",
+  "HEAD",
+  "POST",
+  "PUT",
+  "DELETE",
+  "PATCH",
+  "OPTIONS",
+  "CONNECT",
+  "TRACE"
+];
+const GRAPHQL_METHODS = ["GET", "POST", "OPTIONS"];
+function normalizeApiRootPath(rootPath) {
+  let normalized = rootPath;
+  if (!normalized.startsWith("/")) {
+    normalized = "/" + normalized;
+  }
+  if (!normalized.endsWith("/")) {
+    normalized = normalized + "/";
+  }
+  return normalized;
+}
+async function buildCedarDispatcher(options) {
+  const normalizedApiRootPath = normalizeApiRootPath(
+    options?.apiRootPath ?? "/"
+  );
+  const discoverFunctionsGlob = options?.discoverFunctionsGlob ?? "dist/functions/**/*.{ts,js}";
+  const serverFunctions = fg.sync(discoverFunctionsGlob, {
+    cwd: getPaths().api.base,
+    deep: 2,
+    absolute: true
+  });
+  const graphqlIdx = serverFunctions.findIndex(
+    (x) => path.basename(x, path.extname(x)) === "graphql"
+  );
+  if (graphqlIdx >= 0) {
+    const [graphqlFn] = serverFunctions.splice(graphqlIdx, 1);
+    serverFunctions.unshift(graphqlFn);
+  }
+  const fetchableMap = /* @__PURE__ */ new Map();
+  const router = createRouter();
+  const registrations = [];
+  for (const fnPath of serverFunctions) {
+    const routeName = path.basename(fnPath, path.extname(fnPath));
+    const routePath = routeName === "graphql" ? "/graphql" : `/${routeName}`;
+    const importUrl = options?.cacheBust ? `${pathToFileURL(fnPath).href}?t=${options.cacheBust}` : pathToFileURL(fnPath).href;
+    const fnImport = await import(importUrl);
+    if ("__rw_graphqlOptions" in fnImport && fnImport.__rw_graphqlOptions != null) {
+      const { createGraphQLYoga } = await import("@cedarjs/graphql-server");
+      const graphqlOptions = fnImport.__rw_graphqlOptions;
+      const { yoga } = await createGraphQLYoga(graphqlOptions);
+      const graphqlFetchable = {
+        async fetch(request) {
+          const cedarContext = await buildCedarContext(request, {
+            authDecoder: graphqlOptions.authDecoder
+          });
+          const event = await requestToLegacyEvent(request, cedarContext);
+          return yoga.handle(request, {
+            request,
+            cedarContext,
+            event,
+            requestContext: void 0
+          });
+        }
+      };
+      fetchableMap.set(routeName, graphqlFetchable);
+      registrations.push({
+        id: routePath,
+        route: routePath,
+        method: [...GRAPHQL_METHODS]
+      });
+      for (const method of GRAPHQL_METHODS) {
+        addRoute(router, method, routePath, routeName);
+        addRoute(router, method, `${routePath}/**`, routeName);
+      }
+      continue;
+    }
+    const cedarHandler = (() => {
+      if ("handle" in fnImport && typeof fnImport.handle === "function") {
+        return fnImport.handle;
+      }
+      if ("default" in fnImport && fnImport.default != null && "handle" in fnImport.default && typeof fnImport.default.handle === "function") {
+        return fnImport.default.handle;
+      }
+      return void 0;
+    })();
+    if (!cedarHandler) {
+      console.warn(
+        routeName,
+        "at",
+        fnPath,
+        "does not export a Fetch-native `handle` function and will not be served by the Universal Deploy server. Migrate to `export async function handle(request, ctx)` or use `yarn cedar serve` for legacy Lambda-shaped handler support."
+      );
+      continue;
+    }
+    const handler = cedarHandler;
+    fetchableMap.set(routeName, createCedarFetchable(handler));
+    registrations.push({
+      id: routePath,
+      route: routePath
+      // method omitted → matches all HTTP methods per @universal-deploy/store docs
+    });
+    for (const method of ALL_HTTP_METHODS) {
+      addRoute(router, method, routePath, routeName);
+      addRoute(router, method, `${routePath}/**`, routeName);
+    }
+  }
+  const fetchable = {
+    fetch(request) {
+      return getAsyncStoreInstance().run(
+        /* @__PURE__ */ new Map(),
+        async () => {
+          const url = new URL(request.url);
+          let routePathname = url.pathname;
+          if (normalizedApiRootPath !== "/" && routePathname.startsWith(normalizedApiRootPath)) {
+            routePathname = routePathname.slice(
+              normalizedApiRootPath.length - 1
+            );
+          }
+          if (!routePathname.startsWith("/")) {
+            routePathname = "/" + routePathname;
+          }
+          const match = findRoute(router, request.method, routePathname);
+          if (!match) {
+            return new Response("Not Found", { status: 404 });
+          }
+          const matchedRouteName = match.data;
+          const fnFetchable = fetchableMap.get(matchedRouteName);
+          if (!fnFetchable) {
+            return new Response("Not Found", { status: 404 });
+          }
+          try {
+            return await fnFetchable.fetch(request);
+          } catch (err) {
+            console.error(
+              "Unhandled error in fetch handler for route",
+              matchedRouteName,
+              err
+            );
+            return new Response("Internal Server Error", { status: 500 });
+          }
+        }
+      );
+    }
+  };
+  return { fetchable, registrations };
+}
+export {
+  buildCedarDispatcher
+};

package/dist/udFetchable.d.ts

@@ -0,0 +1,12 @@
+import type { CedarHandler } from '@cedarjs/api/runtime';
+export interface Fetchable {
+    fetch(request: Request): Response | Promise<Response>;
+}
+/**
+ * Wraps a CedarHandler in a WinterTC-compatible Fetchable.
+ *
+ * The Fetchable calls buildCedarContext to produce a CedarRequestContext,
+ * then delegates to the handler.
+ */
+export declare function createCedarFetchable(handler: CedarHandler): Fetchable;
+//# sourceMappingURL=udFetchable.d.ts.map

package/dist/udFetchable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"udFetchable.d.ts","sourceRoot":"","sources":["../src/udFetchable.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAA;AAGxD,MAAM,WAAW,SAAS;IACxB,KAAK,CAAC,OAAO,EAAE,OAAO,GAAG,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAA;CACtD;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,YAAY,GAAG,SAAS,CAOrE"}

package/dist/udFetchable.js

@@ -0,0 +1,12 @@
+import { buildCedarContext } from "@cedarjs/api/runtime";
+function createCedarFetchable(handler) {
+  return {
+    async fetch(request) {
+      const ctx = await buildCedarContext(request);
+      return handler(request, ctx);
+    }
+  };
+}
+export {
+  createCedarFetchable
+};