@redmix/api-server 0.0.1

package/dist/bin.js

@@ -0,0 +1,850 @@
+#!/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("@redmix/project-config");
+  }
+});
+
+// src/createServerHelpers.ts
+function resolveOptions(options = {}, args) {
+  options.parseArgs ??= true;
+  options.logger ??= DEFAULT_CREATE_SERVER_OPTIONS.logger;
+  const resolvedOptions = {
+    apiRootPath: options.apiRootPath ?? DEFAULT_CREATE_SERVER_OPTIONS.apiRootPath,
+    fastifyServerOptions: options.fastifyServerOptions ?? {
+      requestTimeout: DEFAULT_CREATE_SERVER_OPTIONS.fastifyServerOptions.requestTimeout,
+      logger: options.logger ?? DEFAULT_CREATE_SERVER_OPTIONS.logger,
+      bodyLimit: DEFAULT_CREATE_SERVER_OPTIONS.fastifyServerOptions.bodyLimit
+    },
+    configureApiServer: options.configureApiServer ?? DEFAULT_CREATE_SERVER_OPTIONS.configureApiServer,
+    apiHost: getAPIHost(),
+    apiPort: getAPIPort()
+  };
+  resolvedOptions.fastifyServerOptions.requestTimeout ??= DEFAULT_CREATE_SERVER_OPTIONS.fastifyServerOptions.requestTimeout;
+  resolvedOptions.fastifyServerOptions.logger = options.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, DEFAULT_CREATE_SERVER_OPTIONS;
+var init_createServerHelpers = __esm({
+  "src/createServerHelpers.ts"() {
+    "use strict";
+    import_util = require("util");
+    import_helpers = require("@redmix/fastify-web/dist/helpers");
+    init_cliHelpers();
+    DEFAULT_CREATE_SERVER_OPTIONS = {
+      apiRootPath: "/",
+      logger: {
+        level: process.env.LOG_LEVEL ?? (process.env.NODE_ENV === "development" ? "debug" : "warn")
+      },
+      fastifyServerOptions: {
+        requestTimeout: 15e3,
+        bodyLimit: 1024 * 1024 * 100
+        // 100MB
+      },
+      configureApiServer: () => {
+      },
+      parseArgs: true
+    };
+  }
+});
+
+// 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_fs.default.existsSync(serverConfigPath)) {
+    return serverConfigFile;
+  }
+  if (!isServerConfigLoaded) {
+    console.log(`Loading server config from ${serverConfigPath}`);
+    const config3 = await import(`file://${serverConfigPath}`);
+    serverConfigFile = { ...config3.default };
+    isServerConfigLoaded = true;
+  }
+  return serverConfigFile;
+}
+var import_fs, import_path, import_fastify, import_store, import_project_config2, DEFAULT_OPTIONS, isServerConfigLoaded, serverConfigFile, createFastifyInstance, fastify_default;
+var init_fastify = __esm({
+  "src/fastify.ts"() {
+    "use strict";
+    import_fs = __toESM(require("fs"));
+    import_path = __toESM(require("path"));
+    import_fastify = __toESM(require("fastify"));
+    import_store = require("@redmix/context/dist/store");
+    import_project_config2 = require("@redmix/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;
+    };
+    fastify_default = createFastifyInstance;
+  }
+});
+
+// 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"));
+    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/plugins/lambdaLoader.ts
+function findApiDistFunctions(cwd = (0, import_project_config3.getPaths)().api.base, options = {}) {
+  return import_fast_glob.default.sync("dist/functions/**/*.{ts,js}", {
+    cwd,
+    deep: 2,
+    // We don't support deeply nested api functions, to maximise compatibility with deployment providers
+    absolute: true,
+    ...options
+  });
+}
+var import_path2, import_chalk, import_fast_glob, import_lodash, import_project_config3, LAMBDA_FUNCTIONS, setLambdaFunctions, loadFunctionsFromDist, lambdaRequestHandler;
+var init_lambdaLoader = __esm({
+  "src/plugins/lambdaLoader.ts"() {
+    "use strict";
+    import_path2 = __toESM(require("path"));
+    import_chalk = __toESM(require("chalk"));
+    import_fast_glob = __toESM(require("fast-glob"));
+    import_lodash = require("lodash");
+    import_project_config3 = require("@redmix/project-config");
+    init_awsLambdaFastify();
+    LAMBDA_FUNCTIONS = {};
+    setLambdaFunctions = async (foundFunctions) => {
+      const tsImport = Date.now();
+      console.log(import_chalk.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 { handler: handler3 } = await import(`file://${fnPath}`);
+        LAMBDA_FUNCTIONS[routeName] = handler3;
+        if (!handler3) {
+          console.warn(
+            routeName,
+            "at",
+            fnPath,
+            "does not have a function called handler defined."
+          );
+        }
+        console.log(
+          import_chalk.default.magenta("/" + routeName),
+          import_chalk.default.dim.italic(Date.now() - ts + " ms")
+        );
+      });
+      await Promise.all(imports);
+      console.log(
+        import_chalk.default.dim.italic("...Done importing in " + (Date.now() - tsImport) + " ms")
+      );
+    };
+    loadFunctionsFromDist = async (options = {}) => {
+      const serverFunctions = findApiDistFunctions(
+        (0, import_project_config3.getPaths)().api.base,
+        options?.fastGlobOptions
+      );
+      const i = serverFunctions.findIndex((x) => x.includes("graphql"));
+      if (i >= 0) {
+        const graphQLFn = serverFunctions.splice(i, 1)[0];
+        serverFunctions.unshift(graphQLFn);
+      }
+      await setLambdaFunctions(serverFunctions);
+    };
+    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((0, import_lodash.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
+  });
+}
+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"));
+    import_fastify_raw_body = __toESM(require("fastify-raw-body"));
+    import_store2 = require("@redmix/context/dist/store");
+    import_helpers2 = require("@redmix/fastify-web/dist/helpers");
+    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 { __rw_graphqlOptions } = await import(`file://${graphqlFunctionPath}`);
+      redwoodOptions.graphql = __rw_graphqlOptions;
+    }
+    const graphqlOptions = redwoodOptions.graphql;
+    if (graphqlOptions?.realtime) {
+      const { useRedwoodRealtime } = await import("@redmix/realtime");
+      const originalExtraPlugins = graphqlOptions.extraPlugins ?? [];
+      originalExtraPlugins.push(useRedwoodRealtime(graphqlOptions.realtime));
+      graphqlOptions.extraPlugins = originalExtraPlugins;
+      if (graphqlOptions.realtime.subscriptions) {
+        method.push("PUT");
+      }
+    }
+    const { yoga } = (0, import_graphql_server.createGraphQLYoga)(graphqlOptions);
+    const graphQLYogaHandler = async (req, reply) => {
+      const response = await yoga.handleNodeRequest(req, {
+        req,
+        reply,
+        event: lambdaEventForFastifyRequest(req),
+        requestContext: {}
+      });
+      for (const [name, value] of response.headers) {
+        reply.header(name, value);
+      }
+      reply.status(response.status);
+      reply.send(response.body);
+      return reply;
+    };
+    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) => graphQLYogaHandler(req, reply)
+      });
+    }
+    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"));
+    import_url_data2 = __toESM(require("@fastify/url-data"));
+    import_fast_glob2 = __toESM(require("fast-glob"));
+    import_store3 = require("@redmix/context/dist/store");
+    import_helpers3 = require("@redmix/fastify-web/dist/helpers");
+    import_graphql_server = require("@redmix/graphql-server");
+    import_project_config4 = require("@redmix/project-config");
+    init_awsLambdaFastify();
+  }
+});
+
+// src/createServer.ts
+async function createServer(options = {}) {
+  const {
+    apiRootPath,
+    fastifyServerOptions,
+    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_fs2.default.existsSync(serverConfigPath)) {
+    console.warn(
+      import_chalk2.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"]
+      },
+      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_chalk2.default.magenta(
+        `${server.listeningOrigin}${apiRootPath}`
+      )}`
+    );
+    done();
+  });
+  server.start = (options2 = {}) => {
+    return server.listen({
+      ...options2,
+      port: apiPort,
+      host: apiHost
+    });
+  };
+  return server;
+}
+var import_fs2, import_path3, import_chalk2, import_dotenv_defaults, import_fast_glob3, import_fastify3, import_store4, import_project_config5;
+var init_createServer = __esm({
+  "src/createServer.ts"() {
+    "use strict";
+    import_fs2 = __toESM(require("fs"));
+    import_path3 = __toESM(require("path"));
+    import_chalk2 = __toESM(require("chalk"));
+    import_dotenv_defaults = require("dotenv-defaults");
+    import_fast_glob3 = __toESM(require("fast-glob"));
+    import_fastify3 = __toESM(require("fastify"));
+    import_store4 = require("@redmix/context/dist/store");
+    import_project_config5 = require("@redmix/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_chalk3.default.dim.italic("Starting API Server..."));
+  options.apiRootPath = (0, import_fastify_web.coerceRootPath)(options.apiRootPath ?? "/");
+  const fastify2 = await createServer({
+    apiRootPath: options.apiRootPath
+  });
+  options.host ??= getAPIHost();
+  options.port ??= getAPIPort();
+  await fastify2.start();
+  fastify2.log.trace(
+    { custom: { ...fastify2.initialConfig } },
+    "Fastify server configuration"
+  );
+  fastify2.log.trace(`Registered plugins
+${fastify2.printPlugins()}`);
+  console.log(import_chalk3.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_chalk3.default.magenta(`${address}${options.apiRootPath}`);
+  const graphqlEndpoint = import_chalk3.default.magenta(`${apiServer}graphql`);
+  console.log(`API server listening at ${apiServer}`);
+  console.log(`GraphQL endpoint at ${graphqlEndpoint}`);
+  process?.send?.("ready");
+}
+var import_chalk3, import_fastify_web;
+var init_apiCLIConfigHandler = __esm({
+  "src/apiCLIConfigHandler.ts"() {
+    "use strict";
+    import_chalk3 = __toESM(require("chalk"));
+    import_fastify_web = require("@redmix/fastify-web");
+    init_cliHelpers();
+    init_createServer();
+  }
+});
+
+// src/bothCLIConfigHandler.ts
+async function handler2(options) {
+  const timeStart = Date.now();
+  console.log(import_chalk4.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 fastify_default();
+  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_chalk4.default.dim.italic("Took " + (Date.now() - timeStart) + " ms"));
+  const webServer = import_chalk4.default.green(webFastify.listeningOrigin);
+  const apiServer = import_chalk4.default.magenta(
+    `${apiFastify.listeningOrigin}${options.apiRootPath}`
+  );
+  const graphqlEndpoint = import_chalk4.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_chalk4, import_fastify_web2;
+var init_bothCLIConfigHandler = __esm({
+  "src/bothCLIConfigHandler.ts"() {
+    "use strict";
+    import_chalk4 = __toESM(require("chalk"));
+    import_fastify_web2 = require("@redmix/fastify-web");
+    init_cliHelpers();
+    init_createServer();
+    init_fastify();
+  }
+});
+
+// src/bin.ts
+var import_path4 = __toESM(require("path"));
+var import_dotenv_defaults2 = require("dotenv-defaults");
+var import_helpers4 = require("yargs/helpers");
+var import_yargs = __toESM(require("yargs/yargs"));
+var import_project_config6 = require("@redmix/project-config");
+var import_web_server = require("@redmix/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();