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

package/dist/cjs/bin.js

@@ -1,896 +0,0 @@
-#!/usr/bin/env node
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
-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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-
-// src/cliHelpers.ts
-function getAPIHost() {
-  let host = process.env.REDWOOD_API_HOST;
-  host ??= (0, import_project_config.getConfig)().api.host;
-  host ??= process.env.NODE_ENV === "production" ? "0.0.0.0" : "::";
-  return host;
-}
-function getAPIPort() {
-  return process.env.REDWOOD_API_PORT ? parseInt(process.env.REDWOOD_API_PORT) : (0, import_project_config.getConfig)().api.port;
-}
-function getWebHost() {
-  let host = process.env.REDWOOD_WEB_HOST;
-  host ??= (0, import_project_config.getConfig)().web.host;
-  host ??= process.env.NODE_ENV === "production" ? "0.0.0.0" : "::";
-  return host;
-}
-function getWebPort() {
-  return process.env.REDWOOD_WEB_PORT ? parseInt(process.env.REDWOOD_WEB_PORT) : (0, import_project_config.getConfig)().web.port;
-}
-var import_project_config;
-var init_cliHelpers = __esm({
-  "src/cliHelpers.ts"() {
-    "use strict";
-    import_project_config = require("@cedarjs/project-config");
-  }
-});
-
-// src/createServerHelpers.ts
-function isCustomLoggerInstance(logger) {
-  return !!logger && typeof logger === "object" && "info" in logger;
-}
-function resolveOptions(options = {}, args) {
-  options.parseArgs ??= true;
-  const defaults = getDefaultCreateServerOptions();
-  const logger = options.logger ?? defaults.logger;
-  const resolvedOptions = {
-    apiRootPath: options.apiRootPath ?? defaults.apiRootPath,
-    fastifyServerOptions: options.fastifyServerOptions ?? {
-      requestTimeout: defaults.fastifyServerOptions.requestTimeout,
-      bodyLimit: defaults.fastifyServerOptions.bodyLimit
-    },
-    discoverFunctionsGlob: options.discoverFunctionsGlob ?? defaults.discoverFunctionsGlob,
-    configureApiServer: options.configureApiServer ?? defaults.configureApiServer,
-    apiHost: options.apiHost ?? defaults.apiHost,
-    apiPort: options.apiPort ?? defaults.apiPort
-  };
-  resolvedOptions.fastifyServerOptions.requestTimeout ??= defaults.fastifyServerOptions.requestTimeout;
-  if (isCustomLoggerInstance(logger)) {
-    resolvedOptions.fastifyServerOptions.loggerInstance = logger;
-  } else {
-    resolvedOptions.fastifyServerOptions.logger = logger;
-  }
-  if (options.parseArgs) {
-    const { values } = (0, import_util.parseArgs)({
-      options: {
-        apiHost: {
-          type: "string"
-        },
-        apiPort: {
-          type: "string",
-          short: "p"
-        },
-        apiRootPath: {
-          type: "string"
-        }
-      },
-      strict: false,
-      ...args && { args }
-    });
-    if (values.apiHost && typeof values.apiHost !== "string") {
-      throw new Error("`apiHost` must be a string");
-    }
-    if (values.apiHost) {
-      resolvedOptions.apiHost = values.apiHost;
-    }
-    if (values.apiPort) {
-      resolvedOptions.apiPort = +values.apiPort;
-      if (isNaN(resolvedOptions.apiPort)) {
-        throw new Error("`apiPort` must be an integer");
-      }
-    }
-    if (values.apiRootPath && typeof values.apiRootPath !== "string") {
-      throw new Error("`apiRootPath` must be a string");
-    }
-    if (values.apiRootPath) {
-      resolvedOptions.apiRootPath = values.apiRootPath;
-    }
-  }
-  resolvedOptions.apiRootPath = (0, import_helpers.coerceRootPath)(resolvedOptions.apiRootPath);
-  return resolvedOptions;
-}
-var import_util, import_helpers, getDefaultCreateServerOptions;
-var init_createServerHelpers = __esm({
-  "src/createServerHelpers.ts"() {
-    "use strict";
-    import_util = require("util");
-    import_helpers = require("@cedarjs/fastify-web/dist/helpers.js");
-    init_cliHelpers();
-    getDefaultCreateServerOptions = () => ({
-      apiRootPath: "/",
-      logger: {
-        level: process.env.LOG_LEVEL ?? (process.env.NODE_ENV === "development" ? "debug" : "warn")
-      },
-      fastifyServerOptions: {
-        requestTimeout: 15e3,
-        bodyLimit: 1024 * 1024 * 100
-        // 100MB
-      },
-      discoverFunctionsGlob: "dist/functions/**/*.{ts,js}",
-      configureApiServer: () => {
-      },
-      parseArgs: true,
-      apiHost: getAPIHost(),
-      apiPort: getAPIPort()
-    });
-  }
-});
-
-// src/fastify.ts
-async function loadFastifyConfig() {
-  const serverConfigPath = import_path.default.join(
-    (0, import_project_config2.getPaths)().base,
-    (0, import_project_config2.getConfig)().api.serverConfig
-  );
-  if (!import_node_fs.default.existsSync(serverConfigPath)) {
-    return serverConfigFile;
-  }
-  if (!isServerConfigLoaded) {
-    console.log(`Loading server config from ${serverConfigPath}`);
-    console.log(`Loading server config from URL file://${serverConfigPath}`);
-    console.log(
-      `Loading server config from URL ${(0, import_url.pathToFileURL)(serverConfigPath).href}`
-    );
-    const config3 = await import((0, import_url.pathToFileURL)(serverConfigPath).href);
-    serverConfigFile = { ...config3.default };
-    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 init_fastify = __esm({
-  "src/fastify.ts"() {
-    "use strict";
-    import_node_fs = __toESM(require("node:fs"), 1);
-    import_path = __toESM(require("path"), 1);
-    import_url = require("url");
-    import_fastify = __toESM(require("fastify"), 1);
-    import_store = require("@cedarjs/context/dist/store");
-    import_project_config2 = require("@cedarjs/project-config");
-    DEFAULT_OPTIONS = {
-      logger: {
-        level: process.env.NODE_ENV === "development" ? "debug" : "info"
-      }
-    };
-    isServerConfigLoaded = false;
-    serverConfigFile = {
-      config: DEFAULT_OPTIONS,
-      configureFastify: async (fastify2, options) => {
-        fastify2.log.trace(
-          options,
-          `In configureFastify hook for side: ${options?.side}`
-        );
-        return fastify2;
-      }
-    };
-    createFastifyInstance = async (options) => {
-      const { config: config3 } = await loadFastifyConfig();
-      const fastify2 = (0, import_fastify.default)(options || config3 || DEFAULT_OPTIONS);
-      fastify2.addHook("onRequest", (_req, _reply, done) => {
-        (0, import_store.getAsyncStoreInstance)().run(/* @__PURE__ */ new Map(), done);
-      });
-      return fastify2;
-    };
-  }
-});
-
-// src/requestHandlers/utils.ts
-var parseBody, mergeMultiValueHeaders;
-var init_utils = __esm({
-  "src/requestHandlers/utils.ts"() {
-    "use strict";
-    parseBody = (rawBody) => {
-      if (typeof rawBody === "string") {
-        return { body: rawBody, isBase64Encoded: false };
-      }
-      if (rawBody instanceof Buffer) {
-        return { body: rawBody.toString("base64"), isBase64Encoded: true };
-      }
-      return { body: "", isBase64Encoded: false };
-    };
-    mergeMultiValueHeaders = (headers, multiValueHeaders) => {
-      const mergedHeaders = Object.entries(
-        headers || {}
-      ).reduce((acc, [name, value]) => {
-        acc[name.toLowerCase()] = [value];
-        return acc;
-      }, {});
-      Object.entries(multiValueHeaders || {}).forEach(([headerName, values]) => {
-        const name = headerName.toLowerCase();
-        if (name.toLowerCase() === "set-cookie") {
-          mergedHeaders["set-cookie"] = values;
-        } else {
-          mergedHeaders[name] = [values.join("; ")];
-        }
-      });
-      return mergedHeaders;
-    };
-  }
-});
-
-// src/requestHandlers/awsLambdaFastify.ts
-var import_qs, lambdaEventForFastifyRequest, fastifyResponseForLambdaResult, fastifyResponseForLambdaError, requestHandler;
-var init_awsLambdaFastify = __esm({
-  "src/requestHandlers/awsLambdaFastify.ts"() {
-    "use strict";
-    import_qs = __toESM(require("qs"), 1);
-    init_utils();
-    lambdaEventForFastifyRequest = (request) => {
-      return {
-        httpMethod: request.method,
-        headers: request.headers,
-        path: request.urlData("path"),
-        queryStringParameters: import_qs.default.parse(request.url.split(/\?(.+)/)[1]),
-        requestContext: {
-          requestId: request.id,
-          identity: {
-            sourceIp: request.ip
-          }
-        },
-        ...parseBody(request.rawBody || "")
-        // adds `body` and `isBase64Encoded`
-      };
-    };
-    fastifyResponseForLambdaResult = (reply, lambdaResult) => {
-      const {
-        statusCode = 200,
-        headers,
-        body = "",
-        multiValueHeaders
-      } = lambdaResult;
-      const mergedHeaders = mergeMultiValueHeaders(headers, multiValueHeaders);
-      Object.entries(mergedHeaders).forEach(
-        ([name, values]) => values.forEach((value) => reply.header(name, value))
-      );
-      reply.status(statusCode);
-      if (lambdaResult.isBase64Encoded) {
-        return reply.send(Buffer.from(body, "base64"));
-      } else {
-        return reply.send(body);
-      }
-    };
-    fastifyResponseForLambdaError = (req, reply, error) => {
-      req.log.error(error);
-      reply.status(500).send();
-    };
-    requestHandler = async (req, reply, handler3) => {
-      const event = lambdaEventForFastifyRequest(req);
-      const handlerCallback = (reply2) => (error, lambdaResult) => {
-        if (error) {
-          fastifyResponseForLambdaError(req, reply2, error);
-          return;
-        }
-        fastifyResponseForLambdaResult(reply2, lambdaResult);
-      };
-      const handlerPromise = handler3(
-        event,
-        // @ts-expect-error - Add support for context: https://github.com/DefinitelyTyped/DefinitelyTyped/blob/0bb210867d16170c4a08d9ce5d132817651a0f80/types/aws-lambda/index.d.ts#L443-L467
-        {},
-        handlerCallback(reply)
-      );
-      if (handlerPromise && typeof handlerPromise.then === "function") {
-        try {
-          const lambdaResponse = await handlerPromise;
-          return fastifyResponseForLambdaResult(reply, lambdaResponse);
-        } catch (error) {
-          return fastifyResponseForLambdaError(req, reply, error);
-        }
-      }
-    };
-  }
-});
-
-// src/utils.ts
-function escape(string) {
-  const htmlEscapes = {
-    "&": "&",
-    "<": "&lt;",
-    ">": "&gt;",
-    '"': "&quot;",
-    "'": "&#39;"
-  };
-  return string.replace(/[&<>"']/g, (char) => htmlEscapes[char]);
-}
-var init_utils2 = __esm({
-  "src/utils.ts"() {
-    "use strict";
-  }
-});
-
-// src/plugins/lambdaLoader.ts
-var import_path2, import_ansis, import_fast_glob, import_project_config3, LAMBDA_FUNCTIONS, setLambdaFunctions, loadFunctionsFromDist, findApiDistFunctions, lambdaRequestHandler;
-var init_lambdaLoader = __esm({
-  "src/plugins/lambdaLoader.ts"() {
-    "use strict";
-    import_path2 = __toESM(require("path"), 1);
-    import_ansis = __toESM(require("ansis"), 1);
-    import_fast_glob = __toESM(require("fast-glob"), 1);
-    import_project_config3 = require("@cedarjs/project-config");
-    init_awsLambdaFastify();
-    init_utils2();
-    LAMBDA_FUNCTIONS = {};
-    setLambdaFunctions = async (foundFunctions) => {
-      const tsImport = Date.now();
-      console.log(import_ansis.default.dim.italic("Importing Server Functions... "));
-      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 handler3 = (() => {
-          if ("handler" in fnImport) {
-            return fnImport.handler;
-          }
-          if ("default" in fnImport) {
-            if ("handler" in fnImport.default) {
-              return fnImport.default.handler;
-            }
-          }
-          return void 0;
-        })();
-        LAMBDA_FUNCTIONS[routeName] = handler3;
-        if (!handler3) {
-          console.warn(
-            routeName,
-            "at",
-            fnPath,
-            "does not have a function called handler defined."
-          );
-        }
-        console.log(
-          import_ansis.default.magenta("/" + routeName),
-          import_ansis.default.dim.italic(Date.now() - ts + " ms")
-        );
-      });
-      await Promise.all(imports);
-      console.log(
-        import_ansis.default.dim.italic("...Done importing in " + (Date.now() - tsImport) + " ms")
-      );
-    };
-    loadFunctionsFromDist = async (options = {}) => {
-      const serverFunctions = findApiDistFunctions({
-        cwd: (0, import_project_config3.getPaths)().api.base,
-        options: options?.fastGlobOptions,
-        discoverFunctionsGlob: options?.discoverFunctionsGlob
-      });
-      const i = serverFunctions.findIndex((x) => import_path2.default.basename(x) === "graphql.js");
-      if (i >= 0) {
-        const graphQLFn = serverFunctions.splice(i, 1)[0];
-        serverFunctions.unshift(graphQLFn);
-      }
-      await setLambdaFunctions(serverFunctions);
-    };
-    findApiDistFunctions = (params) => {
-      const {
-        cwd = (0, import_project_config3.getPaths)().api.base,
-        options = {},
-        discoverFunctionsGlob = "dist/functions/**/*.{ts,js}"
-      } = params;
-      return import_fast_glob.default.sync(discoverFunctionsGlob, {
-        cwd,
-        // We don't support deeply nested api functions, to maximise compatibility
-        // with deployment providers
-        deep: 2,
-        absolute: true,
-        ...options
-      });
-    };
-    lambdaRequestHandler = async (req, reply) => {
-      const { routeName } = req.params;
-      if (!LAMBDA_FUNCTIONS[routeName]) {
-        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)
-          };
-          reply.send(devError);
-        } else {
-          reply.send(escape(errorMessage));
-        }
-        return;
-      }
-      return requestHandler(req, reply, LAMBDA_FUNCTIONS[routeName]);
-    };
-  }
-});
-
-// src/plugins/api.ts
-async function redwoodFastifyAPI(fastify2, opts) {
-  const redwoodOptions = opts.redwood ?? {};
-  redwoodOptions.apiRootPath ??= "/";
-  redwoodOptions.apiRootPath = (0, import_helpers2.coerceRootPath)(redwoodOptions.apiRootPath);
-  redwoodOptions.fastGlobOptions ??= {};
-  redwoodOptions.loadUserConfig ??= false;
-  fastify2.register(import_url_data.default);
-  await fastify2.register(import_fastify_raw_body.default);
-  fastify2.addHook("onRequest", (_req, _reply, done) => {
-    (0, import_store2.getAsyncStoreInstance)().run(/* @__PURE__ */ new Map(), done);
-  });
-  fastify2.addContentTypeParser(
-    ["application/x-www-form-urlencoded", "multipart/form-data"],
-    { parseAs: "string" },
-    fastify2.defaultTextParser
-  );
-  if (redwoodOptions.loadUserConfig) {
-    const { configureFastify } = await loadFastifyConfig();
-    if (configureFastify) {
-      await configureFastify(fastify2, {
-        side: "api",
-        apiRootPath: redwoodOptions.apiRootPath
-      });
-    }
-  }
-  if (redwoodOptions.configureServer) {
-    await redwoodOptions.configureServer(fastify2);
-  }
-  fastify2.all(`${redwoodOptions.apiRootPath}:routeName`, lambdaRequestHandler);
-  fastify2.all(`${redwoodOptions.apiRootPath}:routeName/*`, lambdaRequestHandler);
-  await loadFunctionsFromDist({
-    fastGlobOptions: redwoodOptions.fastGlobOptions,
-    discoverFunctionsGlob: redwoodOptions.discoverFunctionsGlob
-  });
-}
-var import_url_data, import_fastify_raw_body, import_store2, import_helpers2;
-var init_api = __esm({
-  "src/plugins/api.ts"() {
-    "use strict";
-    import_url_data = __toESM(require("@fastify/url-data"), 1);
-    import_fastify_raw_body = __toESM(require("fastify-raw-body"), 1);
-    import_store2 = require("@cedarjs/context/dist/store");
-    import_helpers2 = require("@cedarjs/fastify-web/dist/helpers.js");
-    init_fastify();
-    init_lambdaLoader();
-  }
-});
-
-// src/plugins/graphql.ts
-var graphql_exports = {};
-__export(graphql_exports, {
-  redwoodFastifyGraphQLServer: () => redwoodFastifyGraphQLServer
-});
-async function redwoodFastifyGraphQLServer(fastify2, options) {
-  const redwoodOptions = options.redwood ?? {};
-  redwoodOptions.apiRootPath ??= "/";
-  redwoodOptions.apiRootPath = (0, import_helpers3.coerceRootPath)(redwoodOptions.apiRootPath);
-  fastify2.register(import_url_data2.default);
-  fastify2.register(import_multipart.default);
-  const method = ["GET", "POST", "OPTIONS"];
-  fastify2.addHook("onRequest", (_req, _reply, done) => {
-    (0, import_store3.getAsyncStoreInstance)().run(/* @__PURE__ */ new Map(), done);
-  });
-  try {
-    if (!redwoodOptions.graphql) {
-      const [graphqlFunctionPath] = await (0, import_fast_glob2.default)("dist/functions/graphql.{ts,js}", {
-        cwd: (0, import_project_config4.getPaths)().api.base,
-        absolute: true
-      });
-      const filePath = `file://${graphqlFunctionPath}`;
-      const { __rw_graphqlOptions } = await import(filePath);
-      if (!__rw_graphqlOptions) {
-        return;
-      }
-      redwoodOptions.graphql = __rw_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 { yoga } = (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)
-        })
-      });
-    }
-    fastify2.addHook("onReady", (done) => {
-      console.info(`GraphQL Yoga Server endpoint at ${graphqlEndpoint}`);
-      console.info(
-        `GraphQL Yoga Server Health Check endpoint at ${graphqlEndpoint}/health`
-      );
-      console.info(
-        `GraphQL Yoga Server Readiness endpoint at ${graphqlEndpoint}/readiness`
-      );
-      done();
-    });
-  } catch (e) {
-    console.log(e);
-  }
-}
-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;
-var init_graphql = __esm({
-  "src/plugins/graphql.ts"() {
-    "use strict";
-    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_store3 = require("@cedarjs/context/dist/store");
-    import_helpers3 = require("@cedarjs/fastify-web/dist/helpers.js");
-    import_graphql_server = require("@cedarjs/graphql-server");
-    import_project_config4 = require("@cedarjs/project-config");
-    init_awsLambdaFastify();
-  }
-});
-
-// src/createServer.ts
-async function createServer(options = {}) {
-  const {
-    apiRootPath,
-    fastifyServerOptions,
-    discoverFunctionsGlob,
-    configureApiServer,
-    apiPort,
-    apiHost
-  } = resolveOptions(options);
-  const serverConfigPath = import_path3.default.join(
-    (0, import_project_config5.getPaths)().base,
-    (0, import_project_config5.getConfig)().api.serverConfig
-  );
-  if (import_node_fs2.default.existsSync(serverConfigPath)) {
-    console.warn(
-      import_ansis2.default.yellow(
-        [
-          "",
-          `Ignoring \`config\` and \`configureServer\` in api/server.config.js.`,
-          `Migrate them to api/src/server.{ts,js}:`,
-          "",
-          `\`\`\`js title="api/src/server.{ts,js}"`,
-          "// Pass your config to `createServer`",
-          "const server = createServer({",
-          "  fastifyServerOptions: myFastifyConfig",
-          "})",
-          "",
-          "// Then inline your `configureFastify` logic:",
-          "server.register(myFastifyPlugin)",
-          "```",
-          ""
-        ].join("\n")
-      )
-    );
-  }
-  const server = Object.assign((0, import_fastify3.default)(fastifyServerOptions), {
-    // `start` will get replaced further down in this file
-    start: async () => {
-      throw new Error("Not implemented yet");
-    }
-  });
-  server.addHook("onRequest", (_req, _reply, done) => {
-    (0, import_store4.getAsyncStoreInstance)().run(/* @__PURE__ */ new Map(), done);
-  });
-  await server.register(redwoodFastifyAPI, {
-    redwood: {
-      apiRootPath,
-      fastGlobOptions: {
-        ignore: ["**/dist/functions/graphql.js"]
-      },
-      discoverFunctionsGlob,
-      configureServer: configureApiServer
-    }
-  });
-  const [graphqlFunctionPath] = await (0, import_fast_glob3.default)("dist/functions/graphql.{ts,js}", {
-    cwd: (0, import_project_config5.getPaths)().api.base,
-    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: {
-        apiRootPath,
-        graphql: __rw_graphqlOptions
-      }
-    });
-  }
-  server.addHook("onReady", (done) => {
-    process.send?.("ready");
-    done();
-  });
-  server.addHook("onListen", (done) => {
-    console.log(
-      `Server listening at ${import_ansis2.default.magenta(
-        `${server.listeningOrigin}${apiRootPath}`
-      )}`
-    );
-    done();
-  });
-  server.start = (options2 = {}) => {
-    return server.listen({
-      ...options2,
-      port: apiPort,
-      host: apiHost
-    });
-  };
-  return server;
-}
-var import_node_fs2, import_path3, 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_ansis2 = __toESM(require("ansis"), 1);
-    import_dotenv_defaults = require("dotenv-defaults");
-    import_fast_glob3 = __toESM(require("fast-glob"), 1);
-    import_fastify3 = __toESM(require("fastify"), 1);
-    import_store4 = require("@cedarjs/context/dist/store");
-    import_project_config5 = require("@cedarjs/project-config");
-    init_createServerHelpers();
-    init_api();
-    if (!process.env.REDWOOD_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"),
-        multiline: true
-      });
-      process.env.REDWOOD_ENV_FILES_LOADED = "true";
-    }
-  }
-});
-
-// src/apiCLIConfigHandler.ts
-async function handler(options = {}) {
-  const timeStart = Date.now();
-  console.log(import_ansis3.default.dim.italic("Starting API Server..."));
-  options.apiRootPath = (0, import_fastify_web.coerceRootPath)(options.apiRootPath ?? "/");
-  const fastify2 = await createServer({
-    apiRootPath: options.apiRootPath,
-    apiHost: options.host,
-    apiPort: options.port
-  });
-  await fastify2.start();
-  fastify2.log.trace(
-    { custom: { ...fastify2.initialConfig } },
-    "Fastify server configuration"
-  );
-  fastify2.log.trace(`Registered plugins
-${fastify2.printPlugins()}`);
-  console.log(import_ansis3.default.dim.italic("Took " + (Date.now() - timeStart) + " ms"));
-  let address = fastify2.listeningOrigin;
-  if (process.env.NODE_ENV !== "production") {
-    address = address.replace(/http:\/\/\[::\]/, "http://localhost");
-  }
-  const apiServer = import_ansis3.default.magenta(`${address}${options.apiRootPath}`);
-  const graphqlEndpoint = import_ansis3.default.magenta(`${apiServer}graphql`);
-  console.log(`API server listening at ${apiServer}`);
-  console.log(`GraphQL endpoint at ${graphqlEndpoint}`);
-  process?.send?.("ready");
-}
-var import_ansis3, import_fastify_web;
-var init_apiCLIConfigHandler = __esm({
-  "src/apiCLIConfigHandler.ts"() {
-    "use strict";
-    import_ansis3 = __toESM(require("ansis"), 1);
-    import_fastify_web = require("@cedarjs/fastify-web");
-    init_createServer();
-  }
-});
-
-// src/bothCLIConfigHandler.ts
-async function handler2(options) {
-  const timeStart = Date.now();
-  console.log(import_ansis4.default.dim.italic("Starting API and Web Servers..."));
-  options.webHost ??= getWebHost();
-  options.webPort ??= getWebPort();
-  options.apiHost ??= getAPIHost();
-  options.apiPort ??= getAPIPort();
-  options.apiRootPath = (0, import_fastify_web2.coerceRootPath)(options.apiRootPath ?? "/");
-  const apiProxyTarget = [
-    "http://",
-    options.apiHost.includes(":") ? `[${options.apiHost}]` : options.apiHost,
-    ":",
-    options.apiPort,
-    options.apiRootPath
-  ].join("");
-  const webFastify = await createFastifyInstance();
-  webFastify.register(import_fastify_web2.redwoodFastifyWeb, {
-    redwood: {
-      apiProxyTarget
-    }
-  });
-  const apiFastify = await createServer({
-    apiRootPath: options.apiRootPath
-  });
-  await webFastify.listen({
-    port: options.webPort,
-    host: options.webHost,
-    listenTextResolver: getListenTextResolver("Web")
-  });
-  webFastify.log.trace(
-    { custom: { ...webFastify.initialConfig } },
-    "Fastify server configuration"
-  );
-  webFastify.log.trace(`Registered plugins
-${webFastify.printPlugins()}`);
-  await apiFastify.listen({
-    port: options.apiPort,
-    host: options.apiHost,
-    listenTextResolver: getListenTextResolver("API")
-  });
-  apiFastify.log.trace(
-    { custom: { ...apiFastify.initialConfig } },
-    "Fastify server configuration"
-  );
-  apiFastify.log.trace(`Registered plugins
-${apiFastify.printPlugins()}`);
-  console.log(import_ansis4.default.dim.italic("Took " + (Date.now() - timeStart) + " ms"));
-  const webServer = import_ansis4.default.green(webFastify.listeningOrigin);
-  const apiServer = import_ansis4.default.magenta(
-    `${apiFastify.listeningOrigin}${options.apiRootPath}`
-  );
-  const graphqlEndpoint = import_ansis4.default.magenta(`${apiServer}graphql`);
-  console.log(`Web server listening at ${webServer}`);
-  console.log(`API server listening at ${apiServer}`);
-  console.log(`GraphQL endpoint at ${graphqlEndpoint}`);
-  process?.send?.("ready");
-}
-function getListenTextResolver(side) {
-  return (address) => {
-    if (process.env.NODE_ENV !== "production") {
-      address = address.replace(/http:\/\/\[::\]/, "http://localhost");
-    }
-    return `${side} server listening at ${address}`;
-  };
-}
-var import_ansis4, import_fastify_web2;
-var init_bothCLIConfigHandler = __esm({
-  "src/bothCLIConfigHandler.ts"() {
-    "use strict";
-    import_ansis4 = __toESM(require("ansis"), 1);
-    import_fastify_web2 = require("@cedarjs/fastify-web");
-    init_cliHelpers();
-    init_createServer();
-    init_fastify();
-  }
-});
-
-// src/bin.ts
-var import_path4 = __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);
-var import_project_config6 = require("@cedarjs/project-config");
-var import_web_server = require("@cedarjs/web-server");
-
-// src/apiCLIConfig.ts
-var description = "Start a server for serving the api side";
-function builder(yargs2) {
-  yargs2.options({
-    port: {
-      description: "The port to listen at",
-      type: "number",
-      alias: "p"
-    },
-    host: {
-      description: "The host to listen at. Note that you most likely want this to be '0.0.0.0' in production",
-      type: "string"
-    },
-    apiRootPath: {
-      description: "Root path where your api functions are served",
-      type: "string",
-      alias: ["api-root-path", "rootPath", "root-path"],
-      default: "/"
-    },
-    // This became a no-op in v7 because env files weren't loaded by default
-    // but removing it would break yargs parsing for older projects,
-    // so leaving it here so that yargs doesn't throw an error
-    loadEnvFiles: {
-      hidden: true
-    }
-  });
-}
-
-// src/bin.ts
-init_apiCLIConfigHandler();
-
-// src/bothCLIConfig.ts
-var description2 = "Start a server for serving the api and web sides";
-function builder2(yargs2) {
-  yargs2.options({
-    webPort: {
-      description: "The port for the web server to listen on",
-      type: "number",
-      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",
-      type: "string",
-      alias: ["web-host"]
-    },
-    apiPort: {
-      description: "The port for the api server to listen on",
-      type: "number",
-      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",
-      type: "string",
-      alias: ["api-host"]
-    },
-    apiRootPath: {
-      description: "Root path where your api functions are served",
-      type: "string",
-      alias: ["api-root-path", "rootPath", "root-path"],
-      default: "/"
-    }
-  });
-}
-
-// src/bin.ts
-init_bothCLIConfigHandler();
-if (!process.env.REDWOOD_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"),
-    multiline: true
-  });
-  process.env.REDWOOD_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",
-  description2,
-  // @ts-expect-error The yargs types seem wrong; it's ok for builder to be a function
-  builder2,
-  handler2
-).command(
-  "api",
-  description,
-  // @ts-expect-error The yargs types seem wrong; it's ok for builder to be a function
-  builder,
-  handler
-).command(
-  "web",
-  import_web_server.description,
-  // @ts-expect-error The yargs types seem wrong; it's ok for builder to be a function
-  import_web_server.builder,
-  import_web_server.handler
-).parse();