@nahkies/typescript-express-runtime/dist/cjs/server-C8qi1rrd.d.cts

Runtime package for code generated by @nahkies/openapi-code-generator using the typescript-express template

import { Server } from "node:http";
import { AddressInfo, ListenOptions } from "node:net";
import { OptionsJson, OptionsText, OptionsUrlencoded } from "body-parser";
import { CorsOptions, CorsOptionsDelegate } from "cors";
import { ErrorRequestHandler, Express, Request, RequestHandler, Response, Router } from "express";

//#region ../typescript-common-runtime/dist/esm/types.d.mts
//#region src/types.d.ts
type Enumerate<N extends number, Acc extends number[] = []> = Acc["length"] extends N ? Acc[number] : Enumerate<N, [...Acc, Acc["length"]]>;
type IntRange<F extends number, T extends number> = F extends T ? F : Exclude<Enumerate<T>, Enumerate<F>> extends never ? never : Exclude<Enumerate<T>, Enumerate<F>> | T;
type StatusCode1xx = IntRange<100, 199>;
type StatusCode2xx = IntRange<200, 299>;
type StatusCode3xx = IntRange<300, 399>;
type StatusCode4xx = IntRange<400, 499>;
type StatusCode5xx = IntRange<500, 599>;
type StatusCode = StatusCode1xx | StatusCode2xx | StatusCode3xx | StatusCode4xx | StatusCode5xx;
type Res<Status extends StatusCode, Type> = {
  status: Status;
  body: Type;
};
type Params<Params, Query, Body, Header> = {
  params: Params;
  query: Query;
  body: Body;
  headers: Header;
};
declare const SkipResponse: unique symbol;
//#endregion
//#region ../typescript-common-runtime/dist/esm/query-parser.d.mts
//#region src/query-parser.d.ts
/**
 * Simplified flattened schema structure, where compositions, nullability, etc, don't matter.
 *
 * We just need to know what is **possible**, as after initial parsing we'll validate against
 * the actual schema.
 */
type PrimitiveType = {
  type: "string" | "number" | "boolean" | "null";
};
type ObjectSchema = {
  type: "object";
  properties: Record<string, SchemaStructure>;
};
type ArraySchema = {
  type: "array";
  items: SchemaStructure;
};
type SchemaStructure = PrimitiveType | ObjectSchema | ArraySchema;
type Style = "deepObject" | "form" | "pipeDelimited" | "spaceDelimited";
interface QueryParameter {
  name: string;
  schema: SchemaStructure;
  style?: Style;
  explode?: boolean;
}
declare function parseQueryParameters(rawQuery: string, parameters: QueryParameter[]): Record<string, unknown>; //#endregion
//#endregion
//#region ../typescript-common-runtime/dist/esm/request-bodies/octet-stream.d.mts
//#region src/request-bodies/octet-stream.d.ts
type SizeLimit = number | `${number}${"b" | "kb" | "mb" | "gb"}`;
//#endregion
//#region src/server.d.ts
type ResponseValidator = (status: number, value: unknown) => any;
declare class ExpressRuntimeResponse<Type> {
  private readonly status;
  private _body?;
  constructor(status: StatusCode);
  body(body: Type): this;
  unpack(): Res<StatusCode, Type | undefined>;
}
declare function handleResponse(res: Response, validator: (status: number, value: unknown) => unknown): (response: ExpressRuntimeResponse<unknown> | typeof SkipResponse | Res<StatusCode, unknown>) => Promise<void>;
declare function handleImplementationError(err: unknown): never;
type ExpressRuntimeResponder<Status extends StatusCode = StatusCode, Type = any> = {
  withStatus: (status: Status) => ExpressRuntimeResponse<Type>;
};
type ServerConfig = {
  /**
   * set to "disabled" to disable cors middleware, omit or pass undefined for defaults
   *
   * by default, all origins are allowed. you probably don't want this in production,
   * so it's strongly recommended to explicitly configure this.
   **/
  cors?: "disabled" | CorsOptions | CorsOptionsDelegate | undefined;
  /**
   * set to "disabled" to disable body parsing middleware, omit or pass undefined for defaults.
   *
   * if disabling, ensure you pass a body parsing middleware that places the parsed
   * body on `req.body` for request body processing to work.
   **/
  body?: "disabled" | Partial<{
    json: OptionsJson;
    text: OptionsText;
    urlencoded: OptionsUrlencoded;
  }> | undefined;
  /**
   * provide arbitrary express middleware to be mounted before all request handlers
   * useful for mounting logging, alternative body parsers, etc
   */
  middleware?: RequestHandler[];
  /**
   * Provide a custom 404 handler
   */
  notFoundHandler?: RequestHandler;
  /**
   * Provide a custom error handler
   */
  errorHandler?: ErrorRequestHandler;
  /**
   * the router to use, normally obtained by calling the generated `createRouter`
   * function
   */
  router: Router;
  /**
   * the port to listen on, a randomly allocated port will be used if none passed
   * alternatively ListenOptions can be passed to control the network interface
   * bound to.
   */
  port?: number | ListenOptions;
};
/**
 * Starts an Express server and listens on `port` or a randomly allocated port if none provided.
 * Enables CORS and body parsing by default. It's recommended to customize the CORS options
 * for production usage.
 *
 * If you need more control over your Express server you should avoid calling this function,
 * and instead mount the router from your generated codes `createRouter` call directly
 * onto a server you have constructed.
 */
declare function startServer({
  middleware,
  cors,
  body,
  port,
  router,
  notFoundHandler,
  errorHandler
}: ServerConfig): Promise<{
  app: Express;
  server: Server;
  address: AddressInfo;
}>;
declare function parseOctetStream(req: Request, sizeLimit: SizeLimit): Promise<Blob | undefined>;
declare function sendBlob(res: Response, body: Blob): Promise<void>;
//#endregion
export { StatusCode3xx as _, handleImplementationError as a, sendBlob as c, Params as d, Res as f, StatusCode2xx as g, StatusCode1xx as h, ServerConfig as i, startServer as l, StatusCode as m, ExpressRuntimeResponse as n, handleResponse as o, SkipResponse as p, ResponseValidator as r, parseOctetStream as s, ExpressRuntimeResponder as t, parseQueryParameters as u, StatusCode4xx as v, StatusCode5xx as y };
//# sourceMappingURL=server-C8qi1rrd.d.cts.map