@redmix/api-server 0.0.1

package/dist/bothCLIConfig.d.ts

@@ -0,0 +1,6 @@
+import type { Argv } from 'yargs';
+import type { BothParsedOptions } from './types';
+export declare const description = "Start a server for serving the api and web sides";
+export declare function builder(yargs: Argv<BothParsedOptions>): void;
+export declare function handler(options: BothParsedOptions): Promise<void>;
+//# sourceMappingURL=bothCLIConfig.d.ts.map

package/dist/bothCLIConfig.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bothCLIConfig.d.ts","sourceRoot":"","sources":["../src/bothCLIConfig.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,OAAO,CAAA;AAEjC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAA;AAEhD,eAAO,MAAM,WAAW,qDAAqD,CAAA;AAE7E,wBAAgB,OAAO,CAAC,KAAK,EAAE,IAAI,CAAC,iBAAiB,CAAC,QA+BrD;AAED,wBAAsB,OAAO,CAAC,OAAO,EAAE,iBAAiB,iBAGvD"}

package/dist/bothCLIConfig.js

@@ -0,0 +1,76 @@
+"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 bothCLIConfig_exports = {};
+__export(bothCLIConfig_exports, {
+  builder: () => builder,
+  description: () => description,
+  handler: () => handler
+});
+module.exports = __toCommonJS(bothCLIConfig_exports);
+const description = "Start a server for serving the api and web sides";
+function builder(yargs) {
+  yargs.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: "/"
+    }
+  });
+}
+async function handler(options) {
+  const { handler: handler2 } = await import("./bothCLIConfigHandler.js");
+  await handler2(options);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  builder,
+  description,
+  handler
+});

package/dist/bothCLIConfigHandler.d.ts

@@ -0,0 +1,3 @@
+import type { BothParsedOptions } from './types';
+export declare function handler(options: BothParsedOptions): Promise<void>;
+//# sourceMappingURL=bothCLIConfigHandler.d.ts.map

package/dist/bothCLIConfigHandler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bothCLIConfigHandler.d.ts","sourceRoot":"","sources":["../src/bothCLIConfigHandler.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAA;AAEhD,wBAAsB,OAAO,CAAC,OAAO,EAAE,iBAAiB,iBAmEvD"}

package/dist/bothCLIConfigHandler.js

@@ -0,0 +1,107 @@
+"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 bothCLIConfigHandler_exports = {};
+__export(bothCLIConfigHandler_exports, {
+  handler: () => handler
+});
+module.exports = __toCommonJS(bothCLIConfigHandler_exports);
+var import_chalk = __toESM(require("chalk"));
+var import_fastify_web = require("@redmix/fastify-web");
+var import_cliHelpers = require("./cliHelpers");
+var import_createServer = require("./createServer");
+var import_fastify = __toESM(require("./fastify"));
+async function handler(options) {
+  const timeStart = Date.now();
+  console.log(import_chalk.default.dim.italic("Starting API and Web Servers..."));
+  options.webHost ??= (0, import_cliHelpers.getWebHost)();
+  options.webPort ??= (0, import_cliHelpers.getWebPort)();
+  options.apiHost ??= (0, import_cliHelpers.getAPIHost)();
+  options.apiPort ??= (0, import_cliHelpers.getAPIPort)();
+  options.apiRootPath = (0, import_fastify_web.coerceRootPath)(options.apiRootPath ?? "/");
+  const apiProxyTarget = [
+    "http://",
+    options.apiHost.includes(":") ? `[${options.apiHost}]` : options.apiHost,
+    ":",
+    options.apiPort,
+    options.apiRootPath
+  ].join("");
+  const webFastify = await (0, import_fastify.default)();
+  webFastify.register(import_fastify_web.redwoodFastifyWeb, {
+    redwood: {
+      apiProxyTarget
+    }
+  });
+  const apiFastify = await (0, import_createServer.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_chalk.default.dim.italic("Took " + (Date.now() - timeStart) + " ms"));
+  const webServer = import_chalk.default.green(webFastify.listeningOrigin);
+  const apiServer = import_chalk.default.magenta(
+    `${apiFastify.listeningOrigin}${options.apiRootPath}`
+  );
+  const graphqlEndpoint = import_chalk.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}`;
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  handler
+});

package/dist/buildManager.d.ts

@@ -0,0 +1,15 @@
+export type BuildAndRestartOptions = {
+    rebuild?: boolean;
+    clean?: boolean;
+};
+declare class BuildManager {
+    private shouldRebuild;
+    private shouldClean;
+    private debouncedBuild;
+    private buildFn;
+    constructor(buildFn: (options: BuildAndRestartOptions) => Promise<void>);
+    run(options: BuildAndRestartOptions): Promise<void>;
+    cancelScheduledBuild(): void;
+}
+export { BuildManager };
+//# sourceMappingURL=buildManager.d.ts.map

package/dist/buildManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buildManager.d.ts","sourceRoot":"","sources":["../src/buildManager.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,sBAAsB,GAAG;IACnC,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,KAAK,CAAC,EAAE,OAAO,CAAA;CAChB,CAAA;AAED,cAAM,YAAY;IAChB,OAAO,CAAC,aAAa,CAAS;IAC9B,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,cAAc,CAA6B;IACnD,OAAO,CAAC,OAAO,CAAoD;gBAEvD,OAAO,EAAE,CAAC,OAAO,EAAE,sBAAsB,KAAK,OAAO,CAAC,IAAI,CAAC;IAgCjE,GAAG,CAAC,OAAO,EAAE,sBAAsB;IAWzC,oBAAoB;CAGrB;AAED,OAAO,EAAE,YAAY,EAAE,CAAA"}

package/dist/buildManager.js

@@ -0,0 +1,74 @@
+"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 buildManager_exports = {};
+__export(buildManager_exports, {
+  BuildManager: () => BuildManager
+});
+module.exports = __toCommonJS(buildManager_exports);
+var import_lodash = require("lodash");
+class BuildManager {
+  shouldRebuild;
+  shouldClean;
+  debouncedBuild;
+  buildFn;
+  constructor(buildFn) {
+    this.shouldRebuild = true;
+    this.shouldClean = false;
+    this.buildFn = buildFn;
+    this.debouncedBuild = (0, import_lodash.debounce)(
+      async (options) => {
+        try {
+          await this.buildFn({
+            ...options,
+            rebuild: this.shouldRebuild,
+            clean: this.shouldClean
+          });
+        } finally {
+          this.shouldRebuild = true;
+          this.shouldClean = false;
+        }
+      },
+      // We want to delay execution when multiple files are modified on the filesystem,
+      // this usually happens when running RedwoodJS generator commands.
+      // Local writes are very fast, but writes in e2e environments are not,
+      // so allow the default to be adjusted with an env-var.
+      //
+      process.env.RWJS_DELAY_RESTART ? parseInt(process.env.RWJS_DELAY_RESTART, 10) : 500
+    );
+  }
+  // Wrapper method to handle options and set precedence flags.
+  // If we ever see a `rebuild: false` option while debouncing, we never want to rebuild.
+  // If we ever see a `clean: true` option, we always want to clean.
+  async run(options) {
+    if (options.rebuild === false) {
+      this.shouldRebuild = false;
+    }
+    if (options.clean) {
+      this.shouldClean = true;
+    }
+    await this.debouncedBuild(options);
+  }
+  cancelScheduledBuild() {
+    this.debouncedBuild.cancel();
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BuildManager
+});

package/dist/cliHelpers.d.ts

@@ -0,0 +1,5 @@
+export declare function getAPIHost(): string;
+export declare function getAPIPort(): number;
+export declare function getWebHost(): string;
+export declare function getWebPort(): number;
+//# sourceMappingURL=cliHelpers.d.ts.map

package/dist/cliHelpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cliHelpers.d.ts","sourceRoot":"","sources":["../src/cliHelpers.ts"],"names":[],"mappings":"AAEA,wBAAgB,UAAU,WAKzB;AAED,wBAAgB,UAAU,WAIzB;AAED,wBAAgB,UAAU,WAKzB;AAED,wBAAgB,UAAU,WAIzB"}

package/dist/cliHelpers.js

@@ -0,0 +1,52 @@
+"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 cliHelpers_exports = {};
+__export(cliHelpers_exports, {
+  getAPIHost: () => getAPIHost,
+  getAPIPort: () => getAPIPort,
+  getWebHost: () => getWebHost,
+  getWebPort: () => getWebPort
+});
+module.exports = __toCommonJS(cliHelpers_exports);
+var import_project_config = require("@redmix/project-config");
+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;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getAPIHost,
+  getAPIPort,
+  getWebHost,
+  getWebPort
+});

package/dist/createServer.d.ts

@@ -0,0 +1,30 @@
+import type { CreateServerOptions, Server } from './createServerHelpers';
+/**
+ * Creates a server for api functions:
+ *
+ * ```js
+ * import { createServer } from '@redmix/api-server'
+ *
+ * import { logger } from 'src/lib/logger'
+ *
+  async function main() {
+ *   const server = await createServer({
+ *     logger,
+ *     apiRootPath: 'api'
+ *     configureApiServer: (server) => {
+ *       // Configure the API server fastify instance, e.g. add content type parsers
+ *     },
+ *   })
+ *
+ *   // Configure the returned fastify instance:
+ *   server.register(myPlugin)
+ *
+ *   // When ready, start the server:
+ *   await server.start()
+ * }
+ *
+ * main()
+ * ```
+ */
+export declare function createServer(options?: CreateServerOptions): Promise<Server>;
+//# sourceMappingURL=createServer.d.ts.map

package/dist/createServer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createServer.d.ts","sourceRoot":"","sources":["../src/createServer.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EACV,mBAAmB,EACnB,MAAM,EAEP,MAAM,uBAAuB,CAAA;AAqB9B;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAsB,YAAY,CAAC,OAAO,GAAE,mBAAwB,mBAiHnE"}

package/dist/createServer.js

@@ -0,0 +1,142 @@
+"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 createServer_exports = {};
+__export(createServer_exports, {
+  createServer: () => createServer
+});
+module.exports = __toCommonJS(createServer_exports);
+var import_fs = __toESM(require("fs"));
+var import_path = __toESM(require("path"));
+var import_chalk = __toESM(require("chalk"));
+var import_dotenv_defaults = require("dotenv-defaults");
+var import_fast_glob = __toESM(require("fast-glob"));
+var import_fastify = __toESM(require("fastify"));
+var import_store = require("@redmix/context/dist/store");
+var import_project_config = require("@redmix/project-config");
+var import_createServerHelpers = require("./createServerHelpers");
+var import_api = require("./plugins/api");
+if (!process.env.REDWOOD_ENV_FILES_LOADED) {
+  (0, import_dotenv_defaults.config)({
+    path: import_path.default.join((0, import_project_config.getPaths)().base, ".env"),
+    defaults: import_path.default.join((0, import_project_config.getPaths)().base, ".env.defaults"),
+    multiline: true
+  });
+  process.env.REDWOOD_ENV_FILES_LOADED = "true";
+}
+async function createServer(options = {}) {
+  const {
+    apiRootPath,
+    fastifyServerOptions,
+    configureApiServer,
+    apiPort,
+    apiHost
+  } = (0, import_createServerHelpers.resolveOptions)(options);
+  const serverConfigPath = import_path.default.join(
+    (0, import_project_config.getPaths)().base,
+    (0, import_project_config.getConfig)().api.serverConfig
+  );
+  if (import_fs.default.existsSync(serverConfigPath)) {
+    console.warn(
+      import_chalk.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_fastify.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_store.getAsyncStoreInstance)().run(/* @__PURE__ */ new Map(), done);
+  });
+  await server.register(import_api.redwoodFastifyAPI, {
+    redwood: {
+      apiRootPath,
+      fastGlobOptions: {
+        ignore: ["**/dist/functions/graphql.js"]
+      },
+      configureServer: configureApiServer
+    }
+  });
+  const [graphqlFunctionPath] = await (0, import_fast_glob.default)("dist/functions/graphql.{ts,js}", {
+    cwd: (0, import_project_config.getPaths)().api.base,
+    absolute: true
+  });
+  if (graphqlFunctionPath) {
+    const { redwoodFastifyGraphQLServer } = await import("./plugins/graphql.js");
+    const { __rw_graphqlOptions } = await import(`file://${graphqlFunctionPath}`);
+    await server.register(redwoodFastifyGraphQLServer, {
+      redwood: {
+        apiRootPath,
+        graphql: __rw_graphqlOptions
+      }
+    });
+  }
+  server.addHook("onReady", (done) => {
+    process.send?.("ready");
+    done();
+  });
+  server.addHook("onListen", (done) => {
+    console.log(
+      `Server listening at ${import_chalk.default.magenta(
+        `${server.listeningOrigin}${apiRootPath}`
+      )}`
+    );
+    done();
+  });
+  server.start = (options2 = {}) => {
+    return server.listen({
+      ...options2,
+      port: apiPort,
+      host: apiHost
+    });
+  };
+  return server;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createServer
+});

package/dist/createServerHelpers.d.ts

@@ -0,0 +1,39 @@
+import type { FastifyListenOptions, FastifyServerOptions, FastifyInstance } from 'fastify';
+export type StartOptions = Omit<FastifyListenOptions, 'port' | 'host'>;
+export interface Server extends FastifyInstance {
+    start: (options?: StartOptions) => Promise<string>;
+}
+export interface CreateServerOptions {
+    /**
+     * The prefix for all routes. Defaults to `/`.
+     */
+    apiRootPath?: string;
+    /**
+     * Logger instance or options.
+     */
+    logger?: FastifyServerOptions['logger'];
+    /**
+     * Options for the fastify server instance.
+     * Omitting logger here because we move it up.
+     */
+    fastifyServerOptions?: Omit<FastifyServerOptions, 'logger'>;
+    /**
+     * Customise the API server fastify plugin before it is registered
+     */
+    configureApiServer?: (server: Server) => void | Promise<void>;
+    /**
+     * Whether to parse args or not. Defaults to `true`.
+     */
+    parseArgs?: boolean;
+}
+type DefaultCreateServerOptions = Required<Omit<CreateServerOptions, 'fastifyServerOptions'> & {
+    fastifyServerOptions: FastifyServerOptions;
+}>;
+export declare const DEFAULT_CREATE_SERVER_OPTIONS: DefaultCreateServerOptions;
+export declare function resolveOptions(options?: CreateServerOptions, args?: string[]): Required<Omit<CreateServerOptions, "logger" | "fastifyServerOptions" | "parseArgs"> & {
+    fastifyServerOptions: FastifyServerOptions;
+    apiPort: number;
+    apiHost: string;
+}>;
+export {};
+//# sourceMappingURL=createServerHelpers.d.ts.map

package/dist/createServerHelpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createServerHelpers.d.ts","sourceRoot":"","sources":["../src/createServerHelpers.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,oBAAoB,EACpB,oBAAoB,EACpB,eAAe,EAChB,MAAM,SAAS,CAAA;AAMhB,MAAM,MAAM,YAAY,GAAG,IAAI,CAAC,oBAAoB,EAAE,MAAM,GAAG,MAAM,CAAC,CAAA;AAEtE,MAAM,WAAW,MAAO,SAAQ,eAAe;IAC7C,KAAK,EAAE,CAAC,OAAO,CAAC,EAAE,YAAY,KAAK,OAAO,CAAC,MAAM,CAAC,CAAA;CACnD;AAED,MAAM,WAAW,mBAAmB;IAClC;;OAEG;IACH,WAAW,CAAC,EAAE,MAAM,CAAA;IAEpB;;OAEG;IACH,MAAM,CAAC,EAAE,oBAAoB,CAAC,QAAQ,CAAC,CAAA;IAEvC;;;OAGG;IACH,oBAAoB,CAAC,EAAE,IAAI,CAAC,oBAAoB,EAAE,QAAQ,CAAC,CAAA;IAE3D;;OAEG;IACH,kBAAkB,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IAE7D;;OAEG;IACH,SAAS,CAAC,EAAE,OAAO,CAAA;CACpB;AAED,KAAK,0BAA0B,GAAG,QAAQ,CACxC,IAAI,CAAC,mBAAmB,EAAE,sBAAsB,CAAC,GAAG;IAClD,oBAAoB,EAAE,oBAAoB,CAAA;CAC3C,CACF,CAAA;AAED,eAAO,MAAM,6BAA6B,EAAE,0BAa3C,CAAA;AAUD,wBAAgB,cAAc,CAC5B,OAAO,GAAE,mBAAwB,EACjC,IAAI,CAAC,EAAE,MAAM,EAAE;0BARS,oBAAoB;aACjC,MAAM;aACN,MAAM;GA+ElB"}