@redmix/api-server 0.0.1

package/dist/plugins/lambdaLoader.d.ts

@@ -0,0 +1,23 @@
+import type { Handler } from 'aws-lambda';
+import type { Options as FastGlobOptions } from 'fast-glob';
+import type { FastifyReply, FastifyRequest, RequestGenericInterface } from 'fastify';
+export type Lambdas = Record<string, Handler>;
+export declare const LAMBDA_FUNCTIONS: Lambdas;
+export declare const setLambdaFunctions: (foundFunctions: string[]) => Promise<void>;
+type LoadFunctionsFromDistOptions = {
+    fastGlobOptions?: FastGlobOptions;
+};
+export declare const loadFunctionsFromDist: (options?: LoadFunctionsFromDistOptions) => Promise<void>;
+interface LambdaHandlerRequest extends RequestGenericInterface {
+    Params: {
+        routeName: string;
+    };
+}
+/**
+ This will take a fastify request
+ Then convert it to a lambdaEvent, and pass it to the the appropriate handler for the routeName
+ The LAMBDA_FUNCTIONS lookup has been populated already by this point
+ **/
+export declare const lambdaRequestHandler: (req: FastifyRequest<LambdaHandlerRequest>, reply: FastifyReply) => Promise<void>;
+export {};
+//# sourceMappingURL=lambdaLoader.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"lambdaLoader.d.ts","sourceRoot":"","sources":["../../src/plugins/lambdaLoader.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,YAAY,CAAA;AAGzC,OAAO,KAAK,EAAE,OAAO,IAAI,eAAe,EAAE,MAAM,WAAW,CAAA;AAC3D,OAAO,KAAK,EACV,YAAY,EACZ,cAAc,EACd,uBAAuB,EACxB,MAAM,SAAS,CAAA;AAOhB,MAAM,MAAM,OAAO,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;AAC7C,eAAO,MAAM,gBAAgB,EAAE,OAAY,CAAA;AAI3C,eAAO,MAAM,kBAAkB,mBAA0B,MAAM,EAAE,kBA8BhE,CAAA;AAED,KAAK,4BAA4B,GAAG;IAClC,eAAe,CAAC,EAAE,eAAe,CAAA;CAClC,CAAA;AAGD,eAAO,MAAM,qBAAqB,aACvB,4BAA4B,kBActC,CAAA;AAgBD,UAAU,oBAAqB,SAAQ,uBAAuB;IAC5D,MAAM,EAAE;QACN,SAAS,EAAE,MAAM,CAAA;KAClB,CAAA;CACF;AAED;;;;IAII;AACJ,eAAO,MAAM,oBAAoB,QAC1B,cAAc,CAAC,oBAAoB,CAAC,SAClC,YAAY,kBAsBpB,CAAA"}

package/dist/plugins/lambdaLoader.js

@@ -0,0 +1,116 @@
+"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 __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
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var lambdaLoader_exports = {};
+__export(lambdaLoader_exports, {
+  LAMBDA_FUNCTIONS: () => LAMBDA_FUNCTIONS,
+  lambdaRequestHandler: () => lambdaRequestHandler,
+  loadFunctionsFromDist: () => loadFunctionsFromDist,
+  setLambdaFunctions: () => setLambdaFunctions
+});
+module.exports = __toCommonJS(lambdaLoader_exports);
+var import_path = __toESM(require("path"));
+var import_chalk = __toESM(require("chalk"));
+var import_fast_glob = __toESM(require("fast-glob"));
+var import_lodash = require("lodash");
+var import_project_config = require("@redmix/project-config");
+var import_awsLambdaFastify = require("../requestHandlers/awsLambdaFastify");
+const LAMBDA_FUNCTIONS = {};
+const 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_path.default.basename(fnPath).replace(".js", "");
+    const { handler } = await import(`file://${fnPath}`);
+    LAMBDA_FUNCTIONS[routeName] = handler;
+    if (!handler) {
+      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")
+  );
+};
+const loadFunctionsFromDist = async (options = {}) => {
+  const serverFunctions = findApiDistFunctions(
+    (0, import_project_config.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);
+};
+function findApiDistFunctions(cwd = (0, import_project_config.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
+  });
+}
+const 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 (0, import_awsLambdaFastify.requestHandler)(req, reply, LAMBDA_FUNCTIONS[routeName]);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LAMBDA_FUNCTIONS,
+  lambdaRequestHandler,
+  loadFunctionsFromDist,
+  setLambdaFunctions
+});

package/dist/requestHandlers/awsLambdaFastify.d.ts

@@ -0,0 +1,5 @@
+import type { APIGatewayProxyEvent, Handler } from 'aws-lambda';
+import type { FastifyRequest, FastifyReply } from 'fastify';
+export declare const lambdaEventForFastifyRequest: (request: FastifyRequest) => APIGatewayProxyEvent;
+export declare const requestHandler: (req: FastifyRequest, reply: FastifyReply, handler: Handler) => Promise<void>;
+//# sourceMappingURL=awsLambdaFastify.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"awsLambdaFastify.d.ts","sourceRoot":"","sources":["../../src/requestHandlers/awsLambdaFastify.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,oBAAoB,EACpB,OAAO,EACR,MAAM,YAAY,CAAA;AACnB,OAAO,KAAK,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,SAAS,CAAA;AAK3D,eAAO,MAAM,4BAA4B,YAC9B,cAAc,KACtB,oBAcF,CAAA;AAoCD,eAAO,MAAM,cAAc,QACpB,cAAc,SACZ,YAAY,WACV,OAAO,kBAmCjB,CAAA"}

package/dist/requestHandlers/awsLambdaFastify.js

@@ -0,0 +1,103 @@
+"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 __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
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var awsLambdaFastify_exports = {};
+__export(awsLambdaFastify_exports, {
+  lambdaEventForFastifyRequest: () => lambdaEventForFastifyRequest,
+  requestHandler: () => requestHandler
+});
+module.exports = __toCommonJS(awsLambdaFastify_exports);
+var import_qs = __toESM(require("qs"));
+var import_utils = require("./utils");
+const 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
+      }
+    },
+    ...(0, import_utils.parseBody)(request.rawBody || "")
+    // adds `body` and `isBase64Encoded`
+  };
+};
+const fastifyResponseForLambdaResult = (reply, lambdaResult) => {
+  const {
+    statusCode = 200,
+    headers,
+    body = "",
+    multiValueHeaders
+  } = lambdaResult;
+  const mergedHeaders = (0, import_utils.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);
+  }
+};
+const fastifyResponseForLambdaError = (req, reply, error) => {
+  req.log.error(error);
+  reply.status(500).send();
+};
+const requestHandler = async (req, reply, handler) => {
+  const event = lambdaEventForFastifyRequest(req);
+  const handlerCallback = (reply2) => (error, lambdaResult) => {
+    if (error) {
+      fastifyResponseForLambdaError(req, reply2, error);
+      return;
+    }
+    fastifyResponseForLambdaResult(reply2, lambdaResult);
+  };
+  const handlerPromise = handler(
+    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);
+    }
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  lambdaEventForFastifyRequest,
+  requestHandler
+});

package/dist/requestHandlers/utils.d.ts

@@ -0,0 +1,26 @@
+type ParseBodyResult = {
+    body: string;
+    isBase64Encoded: boolean;
+};
+type FastifyHeaderValue = string | number | boolean;
+type FastifyMergedHeaders = {
+    [name: string]: FastifyHeaderValue[];
+};
+type FastifyRequestHeader = {
+    [header: string]: FastifyHeaderValue;
+};
+type FastifyLambdaHeaders = FastifyRequestHeader | undefined;
+type FastifyLambdaMultiValueHeaders = FastifyMergedHeaders | undefined;
+export declare const parseBody: (rawBody: string | Buffer) => ParseBodyResult;
+/**
+ * `headers` and `multiValueHeaders` are merged into a single object where the
+ * key is the header name in lower-case and the value is a list of values for
+ * that header. Most multi-values are merged into a single value separated by a
+ * semi-colon. The only exception is set-cookie. set-cookie headers should not
+ * be merged, they should be set individually by multiple calls to
+ * reply.header(). See
+ * https://www.fastify.io/docs/latest/Reference/Reply/#set-cookie
+ */
+export declare const mergeMultiValueHeaders: (headers: FastifyLambdaHeaders, multiValueHeaders: FastifyLambdaMultiValueHeaders) => FastifyMergedHeaders;
+export {};
+//# sourceMappingURL=utils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/requestHandlers/utils.ts"],"names":[],"mappings":"AAAA,KAAK,eAAe,GAAG;IACrB,IAAI,EAAE,MAAM,CAAA;IACZ,eAAe,EAAE,OAAO,CAAA;CACzB,CAAA;AAED,KAAK,kBAAkB,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,CAAA;AAEnD,KAAK,oBAAoB,GAAG;IAAE,CAAC,IAAI,EAAE,MAAM,GAAG,kBAAkB,EAAE,CAAA;CAAE,CAAA;AAEpE,KAAK,oBAAoB,GAAG;IAAE,CAAC,MAAM,EAAE,MAAM,GAAG,kBAAkB,CAAA;CAAE,CAAA;AAEpE,KAAK,oBAAoB,GAAG,oBAAoB,GAAG,SAAS,CAAA;AAE5D,KAAK,8BAA8B,GAAG,oBAAoB,GAAG,SAAS,CAAA;AAEtE,eAAO,MAAM,SAAS,YAAa,MAAM,GAAG,MAAM,KAAG,eAQpD,CAAA;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,sBAAsB,YACxB,oBAAoB,qBACV,8BAA8B,yBAqBlD,CAAA"}

package/dist/requestHandlers/utils.js

@@ -0,0 +1,55 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var utils_exports = {};
+__export(utils_exports, {
+  mergeMultiValueHeaders: () => mergeMultiValueHeaders,
+  parseBody: () => parseBody
+});
+module.exports = __toCommonJS(utils_exports);
+const 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 };
+};
+const 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;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  mergeMultiValueHeaders,
+  parseBody
+});

package/dist/serverManager.d.ts

@@ -0,0 +1,8 @@
+export declare class ServerManager {
+    private httpServerProcess;
+    private startApiServer;
+    restartApiServer(): Promise<void>;
+    killApiServer(): Promise<void>;
+}
+export declare const serverManager: ServerManager;
+//# sourceMappingURL=serverManager.d.ts.map

package/dist/serverManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serverManager.d.ts","sourceRoot":"","sources":["../src/serverManager.ts"],"names":[],"mappings":"AA0BA,qBAAa,aAAa;IACxB,OAAO,CAAC,iBAAiB,CAA4B;YAEvC,cAAc;IAuDtB,gBAAgB;IAKhB,aAAa;CAmCpB;AAED,eAAO,MAAM,aAAa,eAAsB,CAAA"}

package/dist/serverManager.js

@@ -0,0 +1,138 @@
+"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 __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
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var serverManager_exports = {};
+__export(serverManager_exports, {
+  ServerManager: () => ServerManager,
+  serverManager: () => serverManager
+});
+module.exports = __toCommonJS(serverManager_exports);
+var import_child_process = require("child_process");
+var import_fs = __toESM(require("fs"));
+var import_path = __toESM(require("path"));
+var import_chalk = __toESM(require("chalk"));
+var import_yargs = __toESM(require("yargs"));
+var import_helpers = require("yargs/helpers");
+var import_project_config = require("@redmix/project-config");
+const argv = (0, import_yargs.default)((0, import_helpers.hideBin)(process.argv)).option("debugPort", {
+  description: "Port on which to expose API server debugger",
+  type: "number",
+  alias: ["debug-port", "dp"]
+}).option("port", {
+  description: "The port to listen at",
+  type: "number",
+  alias: "p"
+}).parseSync();
+const rwjsPaths = (0, import_project_config.getPaths)();
+class ServerManager {
+  httpServerProcess = null;
+  async startApiServer() {
+    const forkOpts = {
+      execArgv: process.execArgv
+    };
+    if ((0, import_project_config.getConfig)().experimental.opentelemetry.enabled) {
+      const opentelemetrySDKScriptPath = import_path.default.join(
+        rwjsPaths.api.dist,
+        "opentelemetry.js"
+      );
+      const opentelemetrySDKScriptPathRelative = import_path.default.relative(
+        rwjsPaths.base,
+        opentelemetrySDKScriptPath
+      );
+      console.log(
+        `Setting up OpenTelemetry using the setup file: ${opentelemetrySDKScriptPathRelative}`
+      );
+      if (import_fs.default.existsSync(opentelemetrySDKScriptPath)) {
+        forkOpts.execArgv = forkOpts.execArgv.concat([
+          `--require=${opentelemetrySDKScriptPath}`
+        ]);
+      } else {
+        console.error(
+          `OpenTelemetry setup file does not exist at ${opentelemetrySDKScriptPathRelative}`
+        );
+      }
+    }
+    const debugPort = argv["debug-port"];
+    if (debugPort) {
+      forkOpts.execArgv = forkOpts.execArgv.concat([`--inspect=${debugPort}`]);
+    }
+    const port = argv.port ?? (0, import_project_config.getConfig)().api.port;
+    const serverFile = (0, import_project_config.resolveFile)(`${rwjsPaths.api.dist}/server`);
+    if (serverFile) {
+      this.httpServerProcess = (0, import_child_process.fork)(
+        serverFile,
+        ["--apiPort", port.toString()],
+        forkOpts
+      );
+    } else {
+      this.httpServerProcess = (0, import_child_process.fork)(
+        import_path.default.join(__dirname, "bin.js"),
+        ["api", "--port", port.toString()],
+        forkOpts
+      );
+    }
+  }
+  async restartApiServer() {
+    await this.killApiServer();
+    await this.startApiServer();
+  }
+  async killApiServer() {
+    if (!this.httpServerProcess) {
+      return;
+    }
+    await new Promise((resolve) => {
+      console.log(import_chalk.default.yellow("Shutting down API server."));
+      const cleanup = () => {
+        this.httpServerProcess?.removeAllListeners("exit");
+        clearTimeout(forceKillTimeout);
+      };
+      this.httpServerProcess?.on("exit", () => {
+        console.log(import_chalk.default.yellow("API server exited."));
+        cleanup();
+        resolve();
+      });
+      const forceKillTimeout = setTimeout(() => {
+        console.log(
+          import_chalk.default.yellow(
+            "API server did not exit within 2 seconds, forcefully closing it."
+          )
+        );
+        cleanup();
+        this.httpServerProcess?.kill("SIGKILL");
+        resolve();
+      }, 2e3);
+      this.httpServerProcess?.kill();
+    });
+  }
+}
+const serverManager = new ServerManager();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ServerManager,
+  serverManager
+});

package/dist/types.d.ts

@@ -0,0 +1,19 @@
+import type { FastifyInstance } from 'fastify';
+import type { RedwoodFastifyAPIOptions } from './plugins/api';
+export type FastifySideConfigFnOptions = {
+    side: 'api' | 'web';
+};
+export type FastifySideConfigFn = (fastify: FastifyInstance, options?: FastifySideConfigFnOptions & Pick<RedwoodFastifyAPIOptions['redwood'], 'apiRootPath'>) => Promise<FastifyInstance> | void;
+export type APIParsedOptions = {
+    port?: number;
+    host?: string;
+    loadEnvFiles?: boolean;
+} & Omit<RedwoodFastifyAPIOptions['redwood'], 'fastGlobOptions'>;
+export type BothParsedOptions = {
+    webPort?: number;
+    webHost?: string;
+    apiPort?: number;
+    apiHost?: string;
+    apiRootPath?: string;
+} & Omit<RedwoodFastifyAPIOptions['redwood'], 'fastGlobOptions'>;
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AAE9C,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,eAAe,CAAA;AAG7D,MAAM,MAAM,0BAA0B,GAAG;IACvC,IAAI,EAAE,KAAK,GAAG,KAAK,CAAA;CACpB,CAAA;AAED,MAAM,MAAM,mBAAmB,GAAG,CAChC,OAAO,EAAE,eAAe,EACxB,OAAO,CAAC,EAAE,0BAA0B,GAClC,IAAI,CAAC,wBAAwB,CAAC,SAAS,CAAC,EAAE,aAAa,CAAC,KACvD,OAAO,CAAC,eAAe,CAAC,GAAG,IAAI,CAAA;AAEpC,MAAM,MAAM,gBAAgB,GAAG;IAC7B,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,YAAY,CAAC,EAAE,OAAO,CAAA;CACvB,GAAG,IAAI,CAAC,wBAAwB,CAAC,SAAS,CAAC,EAAE,iBAAiB,CAAC,CAAA;AAEhE,MAAM,MAAM,iBAAiB,GAAG;IAC9B,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,WAAW,CAAC,EAAE,MAAM,CAAA;CACrB,GAAG,IAAI,CAAC,wBAAwB,CAAC,SAAS,CAAC,EAAE,iBAAiB,CAAC,CAAA"}

package/dist/watch.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=watch.d.ts.map

package/dist/watch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"watch.d.ts","sourceRoot":"","sources":["../src/watch.ts"],"names":[],"mappings":""}