@cedarjs/api-server 5.0.0-canary.0 → 5.0.0-canary.13874

package/dist/bin.js

@@ -141,6 +141,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}`);
@@ -149,11 +152,12 @@ async function loadFastifyConfig() {
     );
     const config3 = await import(pathToFileURL(serverConfigPath).href);
     serverConfigFile = { ...config3.default };
+    loadedServerConfigPath = serverConfigPath;
     isServerConfigLoaded = true;
   }
   return serverConfigFile;
 }
-var DEFAULT_OPTIONS, isServerConfigLoaded, serverConfigFile, createFastifyInstance;
+var DEFAULT_OPTIONS, isServerConfigLoaded, loadedServerConfigPath, serverConfigFile, createFastifyInstance;
 var init_fastify = __esm({
   "src/fastify.ts"() {
     "use strict";
@@ -236,14 +240,18 @@ var init_awsLambdaFastify = __esm({
       );
       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`
@@ -316,24 +324,33 @@ var init_utils2 = __esm({
 });
 
 // src/plugins/lambdaLoader.ts
-import path2 from "path";
+import path2 from "node:path";
+import { pathToFileURL as pathToFileURL2 } 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 as getPaths2 } from "@cedarjs/project-config";
-var LAMBDA_FUNCTIONS, setLambdaFunctions, loadFunctionsFromDist, findApiDistFunctions, lambdaRequestHandler;
+var LAMBDA_FUNCTIONS, CEDAR_HANDLERS, cedarRouteManifest, setLambdaFunctions, loadFunctionsFromDist, findApiDistFunctions, lambdaRequestHandler;
 var init_lambdaLoader = __esm({
   "src/plugins/lambdaLoader.ts"() {
     "use strict";
     init_awsLambdaFastify();
     init_utils2();
-    LAMBDA_FUNCTIONS = {};
+    LAMBDA_FUNCTIONS = /* @__PURE__ */ new Map();
+    CEDAR_HANDLERS = /* @__PURE__ */ new Map();
+    cedarRouteManifest = [];
     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 = path2.basename(fnPath).replace(".js", "");
-        const fnImport = await import(`file://${fnPath}`);
+        const routePath = routeName === "graphql" ? "/graphql" : `/${routeName}`;
+        const fnImport = await import(pathToFileURL2(fnPath).href);
         const handler3 = (() => {
           if ("handler" in fnImport) {
             return fnImport.handler;
@@ -345,17 +362,39 @@ var init_lambdaLoader = __esm({
           }
           return void 0;
         })();
-        LAMBDA_FUNCTIONS[routeName] = handler3;
-        if (!handler3) {
+        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 (handler3) {
+          LAMBDA_FUNCTIONS.set(routeName, handler3);
+        }
+        if (cedarHandler) {
+          CEDAR_HANDLERS.set(routeName, cedarHandler);
+        } else if (handler3) {
+          CEDAR_HANDLERS.set(routeName, wrapLegacyHandler(handler3));
+        }
+        if (!handler3 && !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), pathToFileURL2(fnPath).href),
           ansis.dim.italic(Date.now() - ts + " ms")
         );
       });
@@ -394,14 +433,43 @@ var init_lambdaLoader = __esm({
     };
     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 handler3 = LAMBDA_FUNCTIONS.get(routeName);
+      if (handler3) {
+        return requestHandler(req, reply, handler3);
+      } 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 {
@@ -409,7 +477,6 @@ var init_lambdaLoader = __esm({
         }
         return;
       }
-      return requestHandler(req, reply, LAMBDA_FUNCTIONS[routeName]);
     };
   }
 });
@@ -467,9 +534,11 @@ var graphql_exports = {};
 __export(graphql_exports, {
   redwoodFastifyGraphQLServer: () => redwoodFastifyGraphQLServer
 });
+import { pathToFileURL as pathToFileURL3 } from "node:url";
 import fastifyMultiPart from "@fastify/multipart";
 import fastifyUrlData2 from "@fastify/url-data";
 import fg2 from "fast-glob";
+import { buildCedarContext as buildCedarContext2 } from "@cedarjs/api/runtime";
 import { getAsyncStoreInstance as getAsyncStoreInstance3 } from "@cedarjs/context/dist/store";
 import { coerceRootPath as coerceRootPath3 } from "@cedarjs/fastify-web/dist/helpers.js";
 import { createGraphQLYoga } from "@cedarjs/graphql-server";
@@ -490,7 +559,7 @@ async function redwoodFastifyGraphQLServer(fastify2, options) {
         cwd: getPaths3().api.base,
         absolute: true
       });
-      const filePath = `file://${graphqlFunctionPath}`;
+      const filePath = pathToFileURL3(graphqlFunctionPath).href;
       const { __rw_graphqlOptions } = await import(filePath);
       if (!__rw_graphqlOptions) {
         return;
@@ -498,33 +567,28 @@ async function redwoodFastifyGraphQLServer(fastify2, 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) {
       fastify2.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 buildCedarContext2(request, {
+            authDecoder: graphqlOptions.authDecoder
+          });
+          return yoga.handle(request, {
+            request,
+            cedarContext,
+            event: lambdaEventForFastifyRequest(req),
+            requestContext: void 0
+          });
+        }
       });
     }
     fastify2.addHook("onReady", (done) => {
@@ -544,6 +608,15 @@ async function redwoodFastifyGraphQLServer(fastify2, options) {
 function trimSlashes(path5) {
   return path5.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
+  });
+}
 var init_graphql = __esm({
   "src/plugins/graphql.ts"() {
     "use strict";
@@ -553,7 +626,8 @@ var init_graphql = __esm({
 
 // src/createServer.ts
 import fs2 from "node:fs";
-import path3 from "path";
+import path3 from "node:path";
+import { pathToFileURL as pathToFileURL4 } from "node:url";
 import ansis2 from "ansis";
 import { config } from "dotenv-defaults";
 import fg3 from "fast-glob";
@@ -620,7 +694,7 @@ async function createServer(options = {}) {
   });
   if (graphqlFunctionPath) {
     const { redwoodFastifyGraphQLServer: redwoodFastifyGraphQLServer2 } = await Promise.resolve().then(() => (init_graphql(), graphql_exports));
-    const { __rw_graphqlOptions } = await import(`file://${graphqlFunctionPath}`);
+    const { __rw_graphqlOptions } = await import(pathToFileURL4(graphqlFunctionPath).href);
     await server.register(redwoodFastifyGraphQLServer2, {
       redwood: {
         apiRootPath,
@@ -866,7 +940,7 @@ if (!process.env.CEDAR_ENV_FILES_LOADED) {
   process.env.CEDAR_ENV_FILES_LOADED = "true";
 }
 process.env.NODE_ENV ??= "production";
-yargs(hideBin(process.argv)).scriptName("rw-server").strict().alias("h", "help").alias("v", "version").command(
+yargs(hideBin(process.argv)).scriptName("cedar-server").strict().alias("h", "help").alias("v", "version").command(
   "$0",
   description2,
   // @ts-expect-error The yargs types seem wrong; it's ok for builder to be a function

package/dist/cjs/bin.js

@@ -157,6 +157,9 @@ async function loadFastifyConfig() {
   if (!import_node_fs.default.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}`);
@@ -165,11 +168,12 @@ async function loadFastifyConfig() {
     );
     const config3 = await import((0, import_url.pathToFileURL)(serverConfigPath).href);
     serverConfigFile = { ...config3.default };
+    loadedServerConfigPath = serverConfigPath;
     isServerConfigLoaded = true;
   }
   return serverConfigFile;
 }
-var import_node_fs, import_path, import_url, import_fastify, import_store, import_project_config2, DEFAULT_OPTIONS, isServerConfigLoaded, serverConfigFile, createFastifyInstance;
+var import_node_fs, import_path, import_url, import_fastify, import_store, import_project_config2, DEFAULT_OPTIONS, isServerConfigLoaded, loadedServerConfigPath, serverConfigFile, createFastifyInstance;
 var init_fastify = __esm({
   "src/fastify.ts"() {
     "use strict";
@@ -258,14 +262,18 @@ var init_awsLambdaFastify = __esm({
       );
       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`
@@ -338,24 +346,33 @@ var init_utils2 = __esm({
 });
 
 // src/plugins/lambdaLoader.ts
-var import_path2, import_ansis, import_fast_glob, import_project_config3, LAMBDA_FUNCTIONS, setLambdaFunctions, loadFunctionsFromDist, findApiDistFunctions, lambdaRequestHandler;
+var import_node_path, import_node_url, import_ansis, import_fast_glob, import_termi_link, import_runtime, import_project_config3, LAMBDA_FUNCTIONS, CEDAR_HANDLERS, cedarRouteManifest, setLambdaFunctions, loadFunctionsFromDist, findApiDistFunctions, lambdaRequestHandler;
 var init_lambdaLoader = __esm({
   "src/plugins/lambdaLoader.ts"() {
     "use strict";
-    import_path2 = __toESM(require("path"), 1);
+    import_node_path = __toESM(require("node:path"), 1);
+    import_node_url = require("node:url");
     import_ansis = __toESM(require("ansis"), 1);
     import_fast_glob = __toESM(require("fast-glob"), 1);
+    import_termi_link = require("termi-link");
+    import_runtime = require("@cedarjs/api/runtime");
     import_project_config3 = require("@cedarjs/project-config");
     init_awsLambdaFastify();
     init_utils2();
-    LAMBDA_FUNCTIONS = {};
+    LAMBDA_FUNCTIONS = /* @__PURE__ */ new Map();
+    CEDAR_HANDLERS = /* @__PURE__ */ new Map();
+    cedarRouteManifest = [];
     setLambdaFunctions = async (foundFunctions) => {
       const tsImport = Date.now();
       console.log(import_ansis.default.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 = import_path2.default.basename(fnPath).replace(".js", "");
-        const fnImport = await import(`file://${fnPath}`);
+        const routeName = import_node_path.default.basename(fnPath).replace(".js", "");
+        const routePath = routeName === "graphql" ? "/graphql" : `/${routeName}`;
+        const fnImport = await import((0, import_node_url.pathToFileURL)(fnPath).href);
         const handler3 = (() => {
           if ("handler" in fnImport) {
             return fnImport.handler;
@@ -367,17 +384,39 @@ var init_lambdaLoader = __esm({
           }
           return void 0;
         })();
-        LAMBDA_FUNCTIONS[routeName] = handler3;
-        if (!handler3) {
+        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 (handler3) {
+          LAMBDA_FUNCTIONS.set(routeName, handler3);
+        }
+        if (cedarHandler) {
+          CEDAR_HANDLERS.set(routeName, cedarHandler);
+        } else if (handler3) {
+          CEDAR_HANDLERS.set(routeName, (0, import_runtime.wrapLegacyHandler)(handler3));
+        }
+        if (!handler3 && !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(
-          import_ansis.default.magenta("/" + routeName),
+          (0, import_termi_link.terminalLink)(import_ansis.default.magenta("/" + routeName), (0, import_node_url.pathToFileURL)(fnPath).href),
           import_ansis.default.dim.italic(Date.now() - ts + " ms")
         );
       });
@@ -392,7 +431,7 @@ var init_lambdaLoader = __esm({
         options: options?.fastGlobOptions,
         discoverFunctionsGlob: options?.discoverFunctionsGlob
       });
-      const i = serverFunctions.findIndex((x) => import_path2.default.basename(x) === "graphql.js");
+      const i = serverFunctions.findIndex((x) => import_node_path.default.basename(x) === "graphql.js");
       if (i >= 0) {
         const graphQLFn = serverFunctions.splice(i, 1)[0];
         serverFunctions.unshift(graphQLFn);
@@ -416,14 +455,43 @@ var init_lambdaLoader = __esm({
     };
     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 (0, import_runtime.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 handler3 = LAMBDA_FUNCTIONS.get(routeName);
+      if (handler3) {
+        return requestHandler(req, reply, handler3);
+      } 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 {
@@ -431,7 +499,6 @@ var init_lambdaLoader = __esm({
         }
         return;
       }
-      return requestHandler(req, reply, LAMBDA_FUNCTIONS[routeName]);
     };
   }
 });
@@ -506,7 +573,7 @@ async function redwoodFastifyGraphQLServer(fastify2, options) {
         cwd: (0, import_project_config4.getPaths)().api.base,
         absolute: true
       });
-      const filePath = `file://${graphqlFunctionPath}`;
+      const filePath = (0, import_node_url2.pathToFileURL)(graphqlFunctionPath).href;
       const { __rw_graphqlOptions } = await import(filePath);
       if (!__rw_graphqlOptions) {
         return;
@@ -514,33 +581,28 @@ async function redwoodFastifyGraphQLServer(fastify2, 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 } = (0, import_graphql_server.createGraphQLYoga)(graphqlOptions);
+    const { yoga } = await (0, import_graphql_server.createGraphQLYoga)(graphqlOptions);
     const graphqlEndpoint = trimSlashes(yoga.graphqlEndpoint);
     const routePaths = ["", "/health", "/readiness", "/stream"];
     for (const routePath of routePaths) {
       fastify2.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 (0, import_runtime2.buildCedarContext)(request, {
+            authDecoder: graphqlOptions.authDecoder
+          });
+          return yoga.handle(request, {
+            request,
+            cedarContext,
+            event: lambdaEventForFastifyRequest(req),
+            requestContext: void 0
+          });
+        }
       });
     }
     fastify2.addHook("onReady", (done) => {
@@ -560,13 +622,24 @@ async function redwoodFastifyGraphQLServer(fastify2, options) {
 function trimSlashes(path5) {
   return path5.replace(/^\/|\/$/g, "");
 }
-var import_multipart, import_url_data2, import_fast_glob2, import_store3, import_helpers3, import_graphql_server, import_project_config4;
+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
+  });
+}
+var import_node_url2, import_multipart, import_url_data2, import_fast_glob2, import_runtime2, import_store3, import_helpers3, import_graphql_server, import_project_config4;
 var init_graphql = __esm({
   "src/plugins/graphql.ts"() {
     "use strict";
+    import_node_url2 = require("node:url");
     import_multipart = __toESM(require("@fastify/multipart"), 1);
     import_url_data2 = __toESM(require("@fastify/url-data"), 1);
     import_fast_glob2 = __toESM(require("fast-glob"), 1);
+    import_runtime2 = require("@cedarjs/api/runtime");
     import_store3 = require("@cedarjs/context/dist/store");
     import_helpers3 = require("@cedarjs/fastify-web/dist/helpers.js");
     import_graphql_server = require("@cedarjs/graphql-server");
@@ -585,7 +658,7 @@ async function createServer(options = {}) {
     apiPort,
     apiHost
   } = resolveOptions(options);
-  const serverConfigPath = import_path3.default.join(
+  const serverConfigPath = import_node_path2.default.join(
     (0, import_project_config5.getPaths)().base,
     (0, import_project_config5.getConfig)().api.serverConfig
   );
@@ -636,7 +709,7 @@ async function createServer(options = {}) {
   });
   if (graphqlFunctionPath) {
     const { redwoodFastifyGraphQLServer: redwoodFastifyGraphQLServer2 } = await Promise.resolve().then(() => (init_graphql(), graphql_exports));
-    const { __rw_graphqlOptions } = await import(`file://${graphqlFunctionPath}`);
+    const { __rw_graphqlOptions } = await import((0, import_node_url3.pathToFileURL)(graphqlFunctionPath).href);
     await server.register(redwoodFastifyGraphQLServer2, {
       redwood: {
         apiRootPath,
@@ -665,12 +738,13 @@ async function createServer(options = {}) {
   };
   return server;
 }
-var import_node_fs2, import_path3, import_ansis2, import_dotenv_defaults, import_fast_glob3, import_fastify3, import_store4, import_project_config5;
+var import_node_fs2, import_node_path2, import_node_url3, import_ansis2, import_dotenv_defaults, import_fast_glob3, import_fastify3, import_store4, import_project_config5;
 var init_createServer = __esm({
   "src/createServer.ts"() {
     "use strict";
     import_node_fs2 = __toESM(require("node:fs"), 1);
-    import_path3 = __toESM(require("path"), 1);
+    import_node_path2 = __toESM(require("node:path"), 1);
+    import_node_url3 = require("node:url");
     import_ansis2 = __toESM(require("ansis"), 1);
     import_dotenv_defaults = require("dotenv-defaults");
     import_fast_glob3 = __toESM(require("fast-glob"), 1);
@@ -681,8 +755,8 @@ var init_createServer = __esm({
     init_api();
     if (!process.env.CEDAR_ENV_FILES_LOADED) {
       (0, import_dotenv_defaults.config)({
-        path: import_path3.default.join((0, import_project_config5.getPaths)().base, ".env"),
-        defaults: import_path3.default.join((0, import_project_config5.getPaths)().base, ".env.defaults"),
+        path: import_node_path2.default.join((0, import_project_config5.getPaths)().base, ".env"),
+        defaults: import_node_path2.default.join((0, import_project_config5.getPaths)().base, ".env.defaults"),
         multiline: true
       });
       process.env.CEDAR_ENV_FILES_LOADED = "true";
@@ -807,7 +881,7 @@ var init_bothCLIConfigHandler = __esm({
 });
 
 // src/bin.ts
-var import_path4 = __toESM(require("path"), 1);
+var import_path2 = __toESM(require("path"), 1);
 var import_dotenv_defaults2 = require("dotenv-defaults");
 var import_helpers4 = require("yargs/helpers");
 var import_yargs = __toESM(require("yargs/yargs"), 1);
@@ -882,14 +956,14 @@ function builder2(yargs2) {
 init_bothCLIConfigHandler();
 if (!process.env.CEDAR_ENV_FILES_LOADED) {
   (0, import_dotenv_defaults2.config)({
-    path: import_path4.default.join((0, import_project_config6.getPaths)().base, ".env"),
-    defaults: import_path4.default.join((0, import_project_config6.getPaths)().base, ".env.defaults"),
+    path: import_path2.default.join((0, import_project_config6.getPaths)().base, ".env"),
+    defaults: import_path2.default.join((0, import_project_config6.getPaths)().base, ".env.defaults"),
     multiline: true
   });
   process.env.CEDAR_ENV_FILES_LOADED = "true";
 }
 process.env.NODE_ENV ??= "production";
-(0, import_yargs.default)((0, import_helpers4.hideBin)(process.argv)).scriptName("rw-server").strict().alias("h", "help").alias("v", "version").command(
+(0, import_yargs.default)((0, import_helpers4.hideBin)(process.argv)).scriptName("cedar-server").strict().alias("h", "help").alias("v", "version").command(
   "$0",
   description2,
   // @ts-expect-error The yargs types seem wrong; it's ok for builder to be a function

package/dist/cjs/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"}