@cedarjs/api-server 9.0.0-canary.1784 → 9.0.0-canary.3124

package/dist/bin.js

@@ -1,8 +1,13 @@
 #!/usr/bin/env node
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+var __esm = (fn, res, err) => function __init() {
+  if (err) throw err[0];
+  try {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  } catch (e) {
+    throw err = [e], e;
+  }
 };
 var __export = (target, all) => {
   for (var name in all)
@@ -10,24 +15,55 @@ var __export = (target, all) => {
 };
 
 // src/cliHelpers.ts
-import { getConfig } from "@cedarjs/project-config";
-function getAPIHost() {
-  let host = process.env.REDWOOD_API_HOST;
+import { getConfig, parsePort, readEnvVar } from "@cedarjs/project-config";
+function getAPIHost({ isPublicSide = false } = {}) {
+  let host = readEnvVar("CEDAR_API_HOST", {
+    deprecatedAlias: "REDWOOD_API_HOST"
+  });
+  if (isPublicSide) {
+    host ??= process.env.HOST;
+  }
   host ??= getConfig().api.host;
-  host ??= process.env.NODE_ENV === "production" ? "0.0.0.0" : "::";
+  host ??= "::";
   return host;
 }
-function getAPIPort() {
-  return process.env.REDWOOD_API_PORT ? parseInt(process.env.REDWOOD_API_PORT) : getConfig().api.port;
+function getAPIPort({ isPublicSide = false } = {}) {
+  const apiPort = readEnvVar("CEDAR_API_PORT", {
+    deprecatedAlias: "REDWOOD_API_PORT"
+  });
+  if (apiPort) {
+    return parsePort(apiPort, "CEDAR_API_PORT");
+  }
+  if (isPublicSide && process.env.PORT) {
+    return parsePort(process.env.PORT, "PORT");
+  }
+  return getConfig().api.port;
+}
+function getAPIRootPath() {
+  return process.env.CEDAR_API_ROOT_PATH ?? "/";
 }
-function getWebHost() {
-  let host = process.env.REDWOOD_WEB_HOST;
+function getWebHost({ isPublicSide = false } = {}) {
+  let host = readEnvVar("CEDAR_WEB_HOST", {
+    deprecatedAlias: "REDWOOD_WEB_HOST"
+  });
+  if (isPublicSide) {
+    host ??= process.env.HOST;
+  }
   host ??= getConfig().web.host;
-  host ??= process.env.NODE_ENV === "production" ? "0.0.0.0" : "::";
+  host ??= "::";
   return host;
 }
-function getWebPort() {
-  return process.env.REDWOOD_WEB_PORT ? parseInt(process.env.REDWOOD_WEB_PORT) : getConfig().web.port;
+function getWebPort({ isPublicSide = false } = {}) {
+  const webPort = readEnvVar("CEDAR_WEB_PORT", {
+    deprecatedAlias: "REDWOOD_WEB_PORT"
+  });
+  if (webPort) {
+    return parsePort(webPort, "CEDAR_WEB_PORT");
+  }
+  if (isPublicSide && process.env.PORT) {
+    return parsePort(process.env.PORT, "PORT");
+  }
+  return getConfig().web.port;
 }
 var init_cliHelpers = __esm({
   "src/cliHelpers.ts"() {
@@ -52,7 +88,9 @@ function resolveOptions(options = {}, args) {
       bodyLimit: defaults.fastifyServerOptions.bodyLimit
     },
     discoverFunctionsGlob: options.discoverFunctionsGlob ?? defaults.discoverFunctionsGlob,
+    configureServer: options.configureServer ?? defaults.configureServer,
     configureApiServer: options.configureApiServer ?? defaults.configureApiServer,
+    configureGraphQLServer: options.configureGraphQLServer ?? defaults.configureGraphQLServer,
     apiHost: options.apiHost ?? defaults.apiHost,
     apiPort: options.apiPort ?? defaults.apiPort
   };
@@ -107,7 +145,7 @@ var init_createServerHelpers = __esm({
     "use strict";
     init_cliHelpers();
     getDefaultCreateServerOptions = () => ({
-      apiRootPath: "/",
+      apiRootPath: getAPIRootPath(),
       logger: {
         level: process.env.LOG_LEVEL ?? (process.env.NODE_ENV === "development" ? "debug" : "warn")
       },
@@ -117,11 +155,19 @@ var init_createServerHelpers = __esm({
         // 100MB
       },
       discoverFunctionsGlob: "dist/functions/**/*.{ts,js}",
+      configureServer: () => {
+      },
       configureApiServer: () => {
       },
+      configureGraphQLServer: () => {
+      },
       parseArgs: true,
-      apiHost: getAPIHost(),
-      apiPort: getAPIPort()
+      // `createServer()`'s only callers are `cedarjs-server api` and custom
+      // `api/src/server.ts` files — both only ever run with the api side
+      // serving public traffic on its own, so they get to use the host's
+      // `HOST`/`PORT` env vars.
+      apiHost: getAPIHost({ isPublicSide: true }),
+      apiPort: getAPIPort({ isPublicSide: true })
     });
   }
 });
@@ -141,6 +187,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 +198,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";
@@ -219,23 +269,35 @@ var init_utils = __esm({
 });
 
 // src/requestHandlers/awsLambdaFastify.ts
-import qs from "qs";
+import { parse } from "picoquery";
 var lambdaEventForFastifyRequest, fastifyResponseForLambdaResult, fastifyResponseForLambdaError, requestHandler;
 var init_awsLambdaFastify = __esm({
   "src/requestHandlers/awsLambdaFastify.ts"() {
     "use strict";
     init_utils();
     lambdaEventForFastifyRequest = (request) => {
+      const qsParams = parse(
+        request.url.split(/\?(.+)/)[1],
+        {
+          nestingSyntax: "index",
+          arrayRepeat: true,
+          arrayRepeatSyntax: "bracket"
+        }
+      );
       return {
         httpMethod: request.method,
-        headers: request.headers,
+        headers: {
+          "x-forwarded-proto": request.protocol,
+          ...request.headers
+        },
         path: request.urlData("path"),
-        queryStringParameters: qs.parse(request.url.split(/\?(.+)/)[1]),
+        queryStringParameters: qsParams,
         requestContext: {
           requestId: request.id,
           identity: {
             sourceIp: request.ip
-          }
+          },
+          domainName: request.hostname
         },
         ...parseBody(request.rawBody || "")
         // adds `body` and `isBase64Encoded`
@@ -308,24 +370,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}`;
+        const fnImport = await import(pathToFileURL2(fnPath).href);
         const handler3 = (() => {
           if ("handler" in fnImport) {
             return fnImport.handler;
@@ -337,17 +408,40 @@ 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({
+          id: routePath,
+          path: routePath,
+          methods: routeName === "graphql" ? ["GET", "POST", "OPTIONS"] : [],
+          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")
         );
       });
@@ -386,14 +480,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 {
@@ -401,7 +524,6 @@ var init_lambdaLoader = __esm({
         }
         return;
       }
-      return requestHandler(req, reply, LAMBDA_FUNCTIONS[routeName]);
     };
   }
 });
@@ -411,12 +533,12 @@ import fastifyUrlData from "@fastify/url-data";
 import fastifyRawBody from "fastify-raw-body";
 import { getAsyncStoreInstance as getAsyncStoreInstance2 } from "@cedarjs/context/dist/store";
 import { coerceRootPath as coerceRootPath2 } from "@cedarjs/fastify-web/dist/helpers.js";
-async function redwoodFastifyAPI(fastify2, opts) {
-  const redwoodOptions = opts.redwood ?? {};
-  redwoodOptions.apiRootPath ??= "/";
-  redwoodOptions.apiRootPath = coerceRootPath2(redwoodOptions.apiRootPath);
-  redwoodOptions.fastGlobOptions ??= {};
-  redwoodOptions.loadUserConfig ??= false;
+async function cedarFastifyAPI(fastify2, opts) {
+  const cedarOptions = opts.cedar ?? {};
+  cedarOptions.apiRootPath ??= "/";
+  cedarOptions.apiRootPath = coerceRootPath2(cedarOptions.apiRootPath);
+  cedarOptions.fastGlobOptions ??= {};
+  cedarOptions.loadUserConfig ??= false;
   fastify2.register(fastifyUrlData);
   await fastify2.register(fastifyRawBody);
   fastify2.addHook("onRequest", (_req, _reply, done) => {
@@ -427,23 +549,23 @@ async function redwoodFastifyAPI(fastify2, opts) {
     { parseAs: "string" },
     fastify2.defaultTextParser
   );
-  if (redwoodOptions.loadUserConfig) {
+  if (cedarOptions.loadUserConfig) {
     const { configureFastify } = await loadFastifyConfig();
     if (configureFastify) {
       await configureFastify(fastify2, {
         side: "api",
-        apiRootPath: redwoodOptions.apiRootPath
+        apiRootPath: cedarOptions.apiRootPath
       });
     }
   }
-  if (redwoodOptions.configureServer) {
-    await redwoodOptions.configureServer(fastify2);
+  if (cedarOptions.configureServer) {
+    await cedarOptions.configureServer(fastify2);
   }
-  fastify2.all(`${redwoodOptions.apiRootPath}:routeName`, lambdaRequestHandler);
-  fastify2.all(`${redwoodOptions.apiRootPath}:routeName/*`, lambdaRequestHandler);
+  fastify2.all(`${cedarOptions.apiRootPath}:routeName`, lambdaRequestHandler);
+  fastify2.all(`${cedarOptions.apiRootPath}:routeName/*`, lambdaRequestHandler);
   await loadFunctionsFromDist({
-    fastGlobOptions: redwoodOptions.fastGlobOptions,
-    discoverFunctionsGlob: redwoodOptions.discoverFunctionsGlob
+    fastGlobOptions: cedarOptions.fastGlobOptions,
+    discoverFunctionsGlob: cedarOptions.discoverFunctionsGlob
   });
 }
 var init_api = __esm({
@@ -457,8 +579,10 @@ var init_api = __esm({
 // src/plugins/graphql.ts
 var graphql_exports = {};
 __export(graphql_exports, {
-  redwoodFastifyGraphQLServer: () => redwoodFastifyGraphQLServer
+  cedarFastifyGraphQLServer: () => cedarFastifyGraphQLServer,
+  isClientDisconnectError: () => isClientDisconnectError
 });
+import { pathToFileURL as pathToFileURL3 } from "node:url";
 import fastifyMultiPart from "@fastify/multipart";
 import fastifyUrlData2 from "@fastify/url-data";
 import fg2 from "fast-glob";
@@ -466,51 +590,60 @@ import { getAsyncStoreInstance as getAsyncStoreInstance3 } from "@cedarjs/contex
 import { coerceRootPath as coerceRootPath3 } from "@cedarjs/fastify-web/dist/helpers.js";
 import { createGraphQLYoga } from "@cedarjs/graphql-server";
 import { getPaths as getPaths3 } from "@cedarjs/project-config";
-async function redwoodFastifyGraphQLServer(fastify2, options) {
-  const redwoodOptions = options.redwood ?? {};
-  redwoodOptions.apiRootPath ??= "/";
-  redwoodOptions.apiRootPath = coerceRootPath3(redwoodOptions.apiRootPath);
+async function cedarFastifyGraphQLServer(fastify2, options) {
+  const cedarOptions = options.cedar ?? {};
+  cedarOptions.apiRootPath ??= "/";
+  cedarOptions.apiRootPath = coerceRootPath3(cedarOptions.apiRootPath);
   fastify2.register(fastifyUrlData2);
   fastify2.register(fastifyMultiPart);
   const method = ["GET", "POST", "OPTIONS"];
   fastify2.addHook("onRequest", (_req, _reply, done) => {
     getAsyncStoreInstance3().run(/* @__PURE__ */ new Map(), done);
   });
+  if (cedarOptions.configureServer) {
+    await cedarOptions.configureServer(fastify2);
+  }
   try {
-    if (!redwoodOptions.graphql) {
+    if (!cedarOptions.graphql) {
       const [graphqlFunctionPath] = await fg2("dist/functions/graphql.{ts,js}", {
         cwd: getPaths3().api.base,
         absolute: true
       });
-      const filePath = `file://${graphqlFunctionPath}`;
-      const { __rw_graphqlOptions } = await import(filePath);
-      if (!__rw_graphqlOptions) {
+      const filePath = pathToFileURL3(graphqlFunctionPath).href;
+      const { __cedar_graphqlOptions } = await import(filePath);
+      if (!__cedar_graphqlOptions) {
         return;
       }
-      redwoodOptions.graphql = __rw_graphqlOptions;
+      cedarOptions.graphql = __cedar_graphqlOptions;
     }
-    const graphqlOptions = redwoodOptions.graphql;
-    if (graphqlOptions?.realtime) {
-      const { useCedarRealtime } = await import("@cedarjs/realtime");
-      const originalExtraPlugins = graphqlOptions.extraPlugins ?? [];
-      originalExtraPlugins.push(useCedarRealtime(graphqlOptions.realtime));
-      graphqlOptions.extraPlugins = originalExtraPlugins;
-      if (graphqlOptions.realtime.subscriptions) {
-        method.push("PUT");
-      }
+    const graphqlOptions = cedarOptions.graphql;
+    if (graphqlOptions?.realtime?.subscriptions) {
+      method.push("PUT");
     }
-    const { yoga } = createGraphQLYoga(graphqlOptions);
-    const graphqlEndpoint = trimSlashes(yoga.graphqlEndpoint);
+    const graphqlServer = await createGraphQLYoga(graphqlOptions);
+    const graphqlEndpoint = trimSlashes(graphqlServer.yoga.graphqlEndpoint);
     const routePaths = ["", "/health", "/readiness", "/stream"];
     for (const routePath of routePaths) {
       fastify2.route({
-        url: `${redwoodOptions.apiRootPath}${graphqlEndpoint}${routePath}`,
+        url: `${cedarOptions.apiRootPath}${graphqlEndpoint}${routePath}`,
         method,
-        handler: (req, reply) => yoga.handleNodeRequestAndResponse(req, reply, {
-          req,
-          reply,
-          event: lambdaEventForFastifyRequest(req)
-        })
+        handler: async (req, reply) => {
+          const request = createFetchRequest(req, reply);
+          const cedarContext = await graphqlServer.buildRequestContext(request);
+          try {
+            return await graphqlServer.yoga.handle(request, {
+              request,
+              cedarContext,
+              event: lambdaEventForFastifyRequest(req),
+              requestContext: void 0
+            });
+          } catch (e) {
+            if (isClientDisconnectError(e)) {
+              return new Response(null, { status: 499 });
+            }
+            throw e;
+          }
+        }
       });
     }
     fastify2.addHook("onReady", (done) => {
@@ -524,11 +657,41 @@ async function redwoodFastifyGraphQLServer(fastify2, options) {
       done();
     });
   } catch (e) {
-    console.log(e);
+    const message = e instanceof Error ? e.message : String(e);
+    fastify2.log.error(e, `Failed to set up the GraphQL server: ${message}`);
+    throw e;
+  }
+}
+function trimSlashes(path6) {
+  return path6.replace(/^\/|\/$/g, "");
+}
+function isClientDisconnectError(e) {
+  if (!e || typeof e !== "object") {
+    return false;
+  }
+  if ("code" in e && e.code === "ERR_STREAM_PREMATURE_CLOSE") {
+    return true;
   }
+  if (e instanceof DOMException && e.name === "AbortError") {
+    return true;
+  }
+  return false;
 }
-function trimSlashes(path5) {
-  return path5.replace(/^\/|\/$/g, "");
+function createFetchRequest(req, reply) {
+  const controller = new AbortController();
+  reply.raw.on("close", () => {
+    if (!reply.raw.writableFinished) {
+      controller.abort();
+    }
+  });
+  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,
+    signal: controller.signal
+  });
 }
 var init_graphql = __esm({
   "src/plugins/graphql.ts"() {
@@ -539,7 +702,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";
@@ -551,7 +715,9 @@ async function createServer(options = {}) {
     apiRootPath,
     fastifyServerOptions,
     discoverFunctionsGlob,
+    configureServer,
     configureApiServer,
+    configureGraphQLServer,
     apiPort,
     apiHost
   } = resolveOptions(options);
@@ -590,8 +756,11 @@ async function createServer(options = {}) {
   server.addHook("onRequest", (_req, _reply, done) => {
     getAsyncStoreInstance4().run(/* @__PURE__ */ new Map(), done);
   });
-  await server.register(redwoodFastifyAPI, {
-    redwood: {
+  if (configureServer) {
+    await configureServer(server);
+  }
+  await server.register(cedarFastifyAPI, {
+    cedar: {
       apiRootPath,
       fastGlobOptions: {
         ignore: ["**/dist/functions/graphql.js"]
@@ -605,12 +774,13 @@ async function createServer(options = {}) {
     absolute: true
   });
   if (graphqlFunctionPath) {
-    const { redwoodFastifyGraphQLServer: redwoodFastifyGraphQLServer2 } = await Promise.resolve().then(() => (init_graphql(), graphql_exports));
-    const { __rw_graphqlOptions } = await import(`file://${graphqlFunctionPath}`);
-    await server.register(redwoodFastifyGraphQLServer2, {
-      redwood: {
+    const { cedarFastifyGraphQLServer: cedarFastifyGraphQLServer2 } = await Promise.resolve().then(() => (init_graphql(), graphql_exports));
+    const { __cedar_graphqlOptions } = await import(pathToFileURL4(graphqlFunctionPath).href);
+    await server.register(cedarFastifyGraphQLServer2, {
+      cedar: {
         apiRootPath,
-        graphql: __rw_graphqlOptions
+        graphql: __cedar_graphqlOptions,
+        configureServer: configureGraphQLServer
       }
     });
   }
@@ -640,21 +810,62 @@ var init_createServer = __esm({
     "use strict";
     init_createServerHelpers();
     init_api();
-    if (!process.env.REDWOOD_ENV_FILES_LOADED) {
+    if (!process.env.CEDAR_ENV_FILES_LOADED) {
       config({
         path: path3.join(getPaths4().base, ".env"),
         defaults: path3.join(getPaths4().base, ".env.defaults"),
         multiline: true
       });
-      process.env.REDWOOD_ENV_FILES_LOADED = "true";
+      process.env.CEDAR_ENV_FILES_LOADED = "true";
     }
   }
 });
 
+// src/serverFile.ts
+import { spawn } from "node:child_process";
+import fs3 from "node:fs";
+import path4 from "node:path";
+import { getPaths as getPaths5 } from "@cedarjs/project-config";
+function apiDistServerFilePath() {
+  return path4.join(getPaths5().api.dist, "server.js");
+}
+function apiDistServerFileExists() {
+  return fs3.existsSync(apiDistServerFilePath());
+}
+async function runApiDistServerFile(options = {}) {
+  const args = ["--apiRootPath", options.apiRootPath ?? "/"];
+  if (options.port !== void 0) {
+    args.push("--apiPort", String(options.port));
+  }
+  await new Promise((resolve, reject) => {
+    const child = spawn(process.execPath, [apiDistServerFilePath(), ...args], {
+      cwd: getPaths5().api.dist,
+      stdio: "inherit"
+    });
+    child.on("error", reject);
+    child.on("exit", (code, signal) => {
+      if (signal || code === 0) {
+        resolve();
+        return;
+      }
+      reject(new Error(`api/dist/server.js exited with code ${code}`));
+    });
+  });
+}
+var init_serverFile = __esm({
+  "src/serverFile.ts"() {
+    "use strict";
+  }
+});
+
 // src/apiCLIConfigHandler.ts
 import ansis3 from "ansis";
 import { coerceRootPath as coerceRootPath4 } from "@cedarjs/fastify-web";
 async function handler(options = {}) {
+  if (apiDistServerFileExists()) {
+    await runApiDistServerFile(options);
+    return;
+  }
   const timeStart = Date.now();
   console.log(ansis3.dim.italic("Starting API Server..."));
   options.apiRootPath = coerceRootPath4(options.apiRootPath ?? "/");
@@ -685,6 +896,7 @@ var init_apiCLIConfigHandler = __esm({
   "src/apiCLIConfigHandler.ts"() {
     "use strict";
     init_createServer();
+    init_serverFile();
   }
 });
 
@@ -692,10 +904,15 @@ var init_apiCLIConfigHandler = __esm({
 import ansis4 from "ansis";
 import { redwoodFastifyWeb, coerceRootPath as coerceRootPath5 } from "@cedarjs/fastify-web";
 async function handler2(options) {
+  if (apiDistServerFileExists()) {
+    throw new Error(
+      "api/dist/server.js was found, but a custom server file is not supported when serving both sides from one process (`cedarjs-server` / `cedar serve`). It is a Fastify concept. Anything registered there (Realtime, custom plugins, custom middleware) would silently be skipped if this continued.\n\nRun the api and web sides as separate processes instead, so the api side goes through `cedarjs-server api`, which does run your server file:\n\n  cedarjs-server api\n  cedarjs-server web"
+    );
+  }
   const timeStart = Date.now();
   console.log(ansis4.dim.italic("Starting API and Web Servers..."));
-  options.webHost ??= getWebHost();
-  options.webPort ??= getWebPort();
+  options.webHost ??= getWebHost({ isPublicSide: true });
+  options.webPort ??= getWebPort({ isPublicSide: true });
   options.apiHost ??= getAPIHost();
   options.apiPort ??= getAPIPort();
   options.apiRootPath = coerceRootPath5(options.apiRootPath ?? "/");
@@ -762,15 +979,16 @@ var init_bothCLIConfigHandler = __esm({
     init_cliHelpers();
     init_createServer();
     init_fastify();
+    init_serverFile();
   }
 });
 
 // src/bin.ts
-import path4 from "path";
+import path5 from "path";
 import { config as config2 } from "dotenv-defaults";
 import { hideBin } from "yargs/helpers";
 import yargs from "yargs/yargs";
-import { getPaths as getPaths5 } from "@cedarjs/project-config";
+import { getPaths as getPaths6 } from "@cedarjs/project-config";
 import {
   description as webDescription,
   builder as webBuilder,
@@ -787,7 +1005,7 @@ function builder(yargs2) {
       alias: "p"
     },
     host: {
-      description: "The host to listen at. Note that you most likely want this to be '0.0.0.0' in production",
+      description: "The host to listen at",
       type: "string"
     },
     apiRootPath: {
@@ -818,7 +1036,7 @@ function builder2(yargs2) {
       alias: ["web-port"]
     },
     webHost: {
-      description: "The host for the web server to listen on. Note that you most likely want this to be '0.0.0.0' in production",
+      description: "The host for the web server to listen on",
       type: "string",
       alias: ["web-host"]
     },
@@ -828,7 +1046,7 @@ function builder2(yargs2) {
       alias: ["api-port"]
     },
     apiHost: {
-      description: "The host for the api server to listen on. Note that you most likely want this to be '0.0.0.0' in production",
+      description: "The host for the api server to listen on",
       type: "string",
       alias: ["api-host"]
     },
@@ -843,16 +1061,16 @@ function builder2(yargs2) {
 
 // src/bin.ts
 init_bothCLIConfigHandler();
-if (!process.env.REDWOOD_ENV_FILES_LOADED) {
+if (!process.env.CEDAR_ENV_FILES_LOADED) {
   config2({
-    path: path4.join(getPaths5().base, ".env"),
-    defaults: path4.join(getPaths5().base, ".env.defaults"),
+    path: path5.join(getPaths6().base, ".env"),
+    defaults: path5.join(getPaths6().base, ".env.defaults"),
     multiline: true
   });
-  process.env.REDWOOD_ENV_FILES_LOADED = "true";
+  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