@kaito-http/core 3.0.0-beta.1 → 3.0.0-beta.4

package/dist/index.d.ts

@@ -0,0 +1,235 @@
+import * as find_my_way from 'find-my-way';
+import find_my_way__default, { HTTPMethod } from 'find-my-way';
+export { HTTPMethod } from 'find-my-way';
+import * as http from 'http';
+import * as http$1 from 'node:http';
+import { IncomingMessage, ServerResponse } from 'node:http';
+import { CookieSerializeOptions } from 'cookie';
+
+declare class WrappedError<T> extends Error {
+    readonly data: T;
+    static maybe<T>(maybeError: T): (T & Error) | WrappedError<T>;
+    static from<T>(data: T): WrappedError<T>;
+    private constructor();
+}
+declare class KaitoError extends Error {
+    readonly status: number;
+    constructor(status: number, message: string);
+}
+
+declare class KaitoRequest {
+    readonly raw: IncomingMessage;
+    private _url;
+    constructor(raw: IncomingMessage);
+    /**
+     * The full URL of the request, including the protocol, hostname, and path.
+     * Note: does not include the query string or hash
+     */
+    get fullURL(): string;
+    /**
+     * A new URL instance for the full URL of the request.
+     */
+    get url(): URL;
+    /**
+     * The HTTP method of the request.
+     */
+    get method(): HTTPMethod;
+    /**
+     * The protocol of the request, either `http` or `https`.
+     */
+    get protocol(): 'http' | 'https';
+    /**
+     * The request headers
+     */
+    get headers(): http.IncomingHttpHeaders;
+    /**
+     * The hostname of the request.
+     */
+    get hostname(): string;
+}
+
+type ErroredAPIResponse = {
+    success: false;
+    data: null;
+    message: string;
+};
+type SuccessfulAPIResponse<T> = {
+    success: true;
+    data: T;
+    message: 'OK';
+};
+type APIResponse<T> = ErroredAPIResponse | SuccessfulAPIResponse<T>;
+type AnyResponse = APIResponse<unknown>;
+declare class KaitoResponse<T = unknown> {
+    readonly raw: ServerResponse;
+    constructor(raw: ServerResponse);
+    /**
+     * Send a response
+     * @param key The key of the header
+     * @param value The value of the header
+     * @returns The response object
+     */
+    header(key: string, value: string | readonly string[]): this;
+    /**
+     * Set the status code of the response
+     * @param code The status code
+     * @returns The response object
+     */
+    status(code: number): this;
+    /**
+     * Set a cookie
+     * @param name The name of the cookie
+     * @param value The value of the cookie
+     * @param options The options for the cookie
+     * @returns The response object
+     */
+    cookie(name: string, value: string, options: CookieSerializeOptions): this;
+    /**
+     * Send a JSON APIResponse body
+     * @param data The data to send
+     * @returns The response object
+     */
+    json(data: APIResponse<T>): this;
+}
+
+type Before<BeforeAfterContext> = (req: http$1.IncomingMessage, res: http$1.ServerResponse) => Promise<BeforeAfterContext>;
+type HandlerResult = {
+    success: true;
+    data: unknown;
+} | {
+    success: false;
+    data: {
+        status: number;
+        message: string;
+    };
+};
+type After<BeforeAfterContext> = (ctx: BeforeAfterContext, result: HandlerResult) => Promise<void>;
+type ServerConfigWithBefore<BeforeAfterContext> = {
+    before: Before<BeforeAfterContext>;
+    after?: After<BeforeAfterContext>;
+} | {
+    before?: undefined;
+};
+type ServerConfig<ContextFrom, BeforeAfterContext> = ServerConfigWithBefore<BeforeAfterContext> & {
+    router: Router<ContextFrom, unknown, any>;
+    getContext: GetContext<ContextFrom>;
+    rawRoutes?: Partial<Record<KaitoMethod, Array<{
+        path: string;
+        handler: (request: http$1.IncomingMessage, response: http$1.ServerResponse) => unknown;
+    }>>>;
+    onError(arg: {
+        error: Error;
+        req: KaitoRequest;
+        res: KaitoResponse;
+    }): Promise<KaitoError | {
+        status: number;
+        message: string;
+    }>;
+};
+declare function createFMWServer<Context, BeforeAfterContext = null>(config: ServerConfig<Context, BeforeAfterContext>): {
+    readonly server: http$1.Server<typeof http$1.IncomingMessage, typeof http$1.ServerResponse>;
+    readonly fmw: find_my_way.Instance<find_my_way.HTTPVersion.V1>;
+};
+declare function createServer<Context, BeforeAfterContext = null>(config: ServerConfig<Context, BeforeAfterContext>): http$1.Server<typeof http$1.IncomingMessage, typeof http$1.ServerResponse>;
+
+type PrefixRoutesPathInner<R extends AnyRoute, Prefix extends `/${string}`> = R extends Route<infer ContextFrom, infer ContextTo, infer Result, infer Path, infer Method, infer Query, infer BodyOutput> ? Route<ContextFrom, ContextTo, Result, `${Prefix}${Path}`, Method, Query, BodyOutput> : never;
+type PrefixRoutesPath<Prefix extends `/${string}`, R extends AnyRoute> = R extends R ? PrefixRoutesPathInner<R, Prefix> : never;
+type RouterOptions<ContextFrom, ContextTo> = {
+    through: (context: ContextFrom) => Promise<ContextTo>;
+};
+declare class Router<ContextFrom, ContextTo, R extends AnyRoute> {
+    private readonly routerOptions;
+    readonly routes: Set<R>;
+    static create: <Context>() => Router<Context, Context, never>;
+    private static parseQuery;
+    private static handle;
+    constructor(routes: Iterable<R>, options: RouterOptions<ContextFrom, ContextTo>);
+    /**
+     * Adds a new route to the router
+     * @deprecated Use the method-specific methods instead
+     */
+    add: <Result, Path extends string, Method extends KaitoMethod, Query extends AnyQueryDefinition = {}, Body extends Parsable = never>(method: Method, path: Path, route: (Method extends "GET" ? Omit<Route<ContextFrom, ContextTo, Result, Path, Method, Query, Body>, "body" | "path" | "method" | "through"> : Omit<Route<ContextFrom, ContextTo, Result, Path, Method, Query, Body>, "path" | "method" | "through">) | Route<ContextFrom, ContextTo, Result, Path, Method, Query, Body>["run"]) => Router<ContextFrom, ContextTo, R | Route<ContextFrom, ContextTo, Result, Path, Method, Query, Body>>;
+    readonly merge: <PathPrefix extends `/${string}`, OtherRoutes extends AnyRoute>(pathPrefix: PathPrefix, other: Router<ContextFrom, unknown, OtherRoutes>) => Router<ContextFrom, ContextTo, Extract<R | PrefixRoutesPath<PathPrefix, OtherRoutes>, AnyRoute>>;
+    freeze: (server: ServerConfig<ContextFrom, any>) => find_my_way__default.Instance<find_my_way__default.HTTPVersion.V1>;
+    private readonly method;
+    get: <Result, Path extends string, Query extends AnyQueryDefinition = {}, Body extends Parsable = never>(path: Path, route: ((arg: RouteArgument<Path, ContextTo, { [Key in keyof Query]: InferParsable<Query[Key]>["output"]; }, InferParsable<Body>["output"]>) => Promise<Result>) | Omit<Route<ContextFrom, ContextTo, Result, Path, "GET", Query, Body>, "body" | "path" | "method" | "through">) => Router<ContextFrom, ContextTo, R | Route<ContextFrom, ContextTo, Result, Path, "GET", Query, Body>>;
+    post: <Result, Path extends string, Query extends AnyQueryDefinition = {}, Body extends Parsable = never>(path: Path, route: ((arg: RouteArgument<Path, ContextTo, { [Key in keyof Query]: InferParsable<Query[Key]>["output"]; }, InferParsable<Body>["output"]>) => Promise<Result>) | Omit<Route<ContextFrom, ContextTo, Result, Path, "POST", Query, Body>, "path" | "method" | "through">) => Router<ContextFrom, ContextTo, R | Route<ContextFrom, ContextTo, Result, Path, "POST", Query, Body>>;
+    put: <Result, Path extends string, Query extends AnyQueryDefinition = {}, Body extends Parsable = never>(path: Path, route: ((arg: RouteArgument<Path, ContextTo, { [Key in keyof Query]: InferParsable<Query[Key]>["output"]; }, InferParsable<Body>["output"]>) => Promise<Result>) | Omit<Route<ContextFrom, ContextTo, Result, Path, "PUT", Query, Body>, "path" | "method" | "through">) => Router<ContextFrom, ContextTo, R | Route<ContextFrom, ContextTo, Result, Path, "PUT", Query, Body>>;
+    patch: <Result, Path extends string, Query extends AnyQueryDefinition = {}, Body extends Parsable = never>(path: Path, route: ((arg: RouteArgument<Path, ContextTo, { [Key in keyof Query]: InferParsable<Query[Key]>["output"]; }, InferParsable<Body>["output"]>) => Promise<Result>) | Omit<Route<ContextFrom, ContextTo, Result, Path, "PATCH", Query, Body>, "path" | "method" | "through">) => Router<ContextFrom, ContextTo, R | Route<ContextFrom, ContextTo, Result, Path, "PATCH", Query, Body>>;
+    delete: <Result, Path extends string, Query extends AnyQueryDefinition = {}, Body extends Parsable = never>(path: Path, route: ((arg: RouteArgument<Path, ContextTo, { [Key in keyof Query]: InferParsable<Query[Key]>["output"]; }, InferParsable<Body>["output"]>) => Promise<Result>) | Omit<Route<ContextFrom, ContextTo, Result, Path, "DELETE", Query, Body>, "path" | "method" | "through">) => Router<ContextFrom, ContextTo, R | Route<ContextFrom, ContextTo, Result, Path, "DELETE", Query, Body>>;
+    head: <Result, Path extends string, Query extends AnyQueryDefinition = {}, Body extends Parsable = never>(path: Path, route: ((arg: RouteArgument<Path, ContextTo, { [Key in keyof Query]: InferParsable<Query[Key]>["output"]; }, InferParsable<Body>["output"]>) => Promise<Result>) | Omit<Route<ContextFrom, ContextTo, Result, Path, "HEAD", Query, Body>, "path" | "method" | "through">) => Router<ContextFrom, ContextTo, R | Route<ContextFrom, ContextTo, Result, Path, "HEAD", Query, Body>>;
+    options: <Result, Path extends string, Query extends AnyQueryDefinition = {}, Body extends Parsable = never>(path: Path, route: ((arg: RouteArgument<Path, ContextTo, { [Key in keyof Query]: InferParsable<Query[Key]>["output"]; }, InferParsable<Body>["output"]>) => Promise<Result>) | Omit<Route<ContextFrom, ContextTo, Result, Path, "OPTIONS", Query, Body>, "path" | "method" | "through">) => Router<ContextFrom, ContextTo, R | Route<ContextFrom, ContextTo, Result, Path, "OPTIONS", Query, Body>>;
+    through: <NextContext>(transform: (context: ContextTo) => Promise<NextContext>) => Router<ContextFrom, NextContext, R>;
+}
+
+type ExtractRouteParams<T extends string> = string extends T ? Record<string, string> : T extends `${string}:${infer Param}/${infer Rest}` ? {
+    [k in Param | keyof ExtractRouteParams<Rest>]: string;
+} : T extends `${string}:${infer Param}` ? {
+    [k in Param]: string;
+} : {};
+type KaitoMethod = HTTPMethod | '*';
+type GetContext<Result> = (req: KaitoRequest, res: KaitoResponse) => Promise<Result>;
+/**
+ * @deprecated use `createUtilities` instead
+ */
+declare function createGetContext<Context>(callback: GetContext<Context>): GetContext<Context>;
+/**
+ * A helper function to create typed necessary functions
+ *
+ * @example
+ * ```ts
+ * const {router, getContext} = createUtilities(async (req, res) => {
+ *   // Return context here
+ * })
+ *
+ * const app = router().get('/', async () => "hello");
+ *
+ * const server = createServer({
+ *   router: app,
+ *   getContext,
+ *   // ...
+ * });
+ * ```
+ */
+declare function createUtilities<Context>(getContext: GetContext<Context>): {
+    getContext: GetContext<Context>;
+    router: () => Router<Context, Context, never>;
+};
+type InferContext<T> = T extends (req: KaitoRequest, res: KaitoResponse) => Promise<infer U> ? U : never;
+declare function getLastEntryInMultiHeaderValue(headerValue: string | string[]): string;
+interface Parsable<Output = any, Input = Output> {
+    _input?: Input;
+    parse: (value: unknown) => Output;
+}
+type InferParsable<T> = T extends Parsable<infer Output, infer Input> ? {
+    input: Input;
+    output: Output;
+} : never;
+type RemoveEndSlashes<T extends string> = T extends `${infer U}/` ? U : T;
+type AddStartSlashes<T extends string> = T extends `/${infer U}` ? `/${U}` : `/${T}`;
+type NormalizePath<T extends string> = AddStartSlashes<RemoveEndSlashes<T>>;
+type Values<T> = T[keyof T];
+type NoEmpty<T> = [keyof T] extends [never] ? never : T;
+declare function getBody(req: KaitoRequest): Promise<unknown>;
+
+type RouteArgument<Path extends string, Context, QueryOutput, BodyOutput> = {
+    ctx: Context;
+    body: BodyOutput;
+    query: QueryOutput;
+    params: ExtractRouteParams<Path>;
+};
+type AnyQueryDefinition = Record<string, Parsable>;
+type RouteRunner<Result, Path extends string, Context, QueryOutput, BodyOutput> = (args: RouteArgument<Path, Context, QueryOutput, BodyOutput>) => Promise<Result>;
+type Route<ContextFrom, ContextTo, Result, Path extends string, Method extends KaitoMethod, Query extends AnyQueryDefinition, Body extends Parsable> = {
+    through: (context: ContextFrom) => Promise<ContextTo>;
+    body?: Body;
+    query?: Query;
+    path: Path;
+    method: Method;
+    run(arg: RouteArgument<Path, ContextTo, {
+        [Key in keyof Query]: InferParsable<Query[Key]>['output'];
+    }, InferParsable<Body>['output']>): Promise<Result>;
+};
+type AnyRoute<FromContext = any, ToContext = any> = Route<FromContext, ToContext, any, any, any, AnyQueryDefinition, any>;
+
+export { type APIResponse, type AddStartSlashes, type After, type AnyQueryDefinition, type AnyResponse, type AnyRoute, type Before, type ErroredAPIResponse, type ExtractRouteParams, type GetContext, type HandlerResult, type InferContext, type InferParsable, KaitoError, type KaitoMethod, KaitoRequest, KaitoResponse, type NoEmpty, type NormalizePath, type Parsable, type RemoveEndSlashes, type Route, type RouteArgument, type RouteRunner, Router, type RouterOptions, type ServerConfig, type ServerConfigWithBefore, type SuccessfulAPIResponse, type Values, WrappedError, createFMWServer, createGetContext, createServer, createUtilities, getBody, getLastEntryInMultiHeaderValue };

package/dist/index.js

@@ -0,0 +1,389 @@
+// src/error.ts
+var WrappedError = class _WrappedError extends Error {
+  constructor(data) {
+    super("Something was thrown, but it was not an instance of Error, so a WrappedError was created.");
+    this.data = data;
+  }
+  static maybe(maybeError) {
+    if (maybeError instanceof Error) {
+      return maybeError;
+    }
+    return _WrappedError.from(maybeError);
+  }
+  static from(data) {
+    return new _WrappedError(data);
+  }
+};
+var KaitoError = class extends Error {
+  constructor(status, message) {
+    super(message);
+    this.status = status;
+  }
+};
+
+// src/req.ts
+import { TLSSocket } from "node:tls";
+
+// src/util.ts
+import { parse as parseContentType } from "content-type";
+import { Readable } from "node:stream";
+import { json } from "node:stream/consumers";
+import getRawBody from "raw-body";
+
+// src/router.ts
+import fmw from "find-my-way";
+
+// src/res.ts
+import { serialize } from "cookie";
+var KaitoResponse = class {
+  constructor(raw) {
+    this.raw = raw;
+  }
+  /**
+   * Send a response
+   * @param key The key of the header
+   * @param value The value of the header
+   * @returns The response object
+   */
+  header(key, value) {
+    this.raw.setHeader(key, value);
+    return this;
+  }
+  /**
+   * Set the status code of the response
+   * @param code The status code
+   * @returns The response object
+   */
+  status(code) {
+    this.raw.statusCode = code;
+    return this;
+  }
+  /**
+   * Set a cookie
+   * @param name The name of the cookie
+   * @param value The value of the cookie
+   * @param options The options for the cookie
+   * @returns The response object
+   */
+  cookie(name, value, options) {
+    this.raw.setHeader("Set-Cookie", serialize(name, value, options));
+    return this;
+  }
+  /**
+   * Send a JSON APIResponse body
+   * @param data The data to send
+   * @returns The response object
+   */
+  json(data) {
+    const json2 = JSON.stringify(data);
+    this.raw.setHeader("Content-Type", "application/json");
+    this.raw.setHeader("Content-Length", Buffer.byteLength(json2));
+    this.raw.end(json2);
+    return this;
+  }
+};
+
+// src/router.ts
+var getSend = (res) => (status, response) => {
+  if (res.raw.headersSent) {
+    return;
+  }
+  res.status(status).json(response);
+};
+var Router = class _Router {
+  routerOptions;
+  routes;
+  static create = () => new _Router([], {
+    through: async (context) => context
+  });
+  static parseQuery(schema, url) {
+    if (!schema) {
+      return {};
+    }
+    const result = {};
+    for (const [key, value] of url.searchParams.entries()) {
+      const parsable = schema[key];
+      if (!parsable) {
+        continue;
+      }
+      const parsed = parsable.parse(value);
+      result[key] = parsed;
+    }
+    return result;
+  }
+  static async handle(server, route, options) {
+    const send = getSend(options.res);
+    try {
+      const rootCtx = await server.getContext(options.req, options.res);
+      const ctx = await route.through(rootCtx);
+      const body = await route.body?.parse(await getBody(options.req)) ?? void 0;
+      const query = _Router.parseQuery(route.query, options.req.url);
+      const result = await route.run({
+        ctx,
+        body,
+        query,
+        params: options.params
+      });
+      if (options.res.raw.headersSent) {
+        return {
+          success: true,
+          data: result
+        };
+      }
+      send(200, {
+        success: true,
+        data: result,
+        message: "OK"
+      });
+      return {
+        success: true,
+        data: result
+      };
+    } catch (e) {
+      const error = WrappedError.maybe(e);
+      if (error instanceof KaitoError) {
+        send(error.status, {
+          success: false,
+          data: null,
+          message: error.message
+        });
+        return;
+      }
+      const { status, message } = await server.onError({ error, req: options.req, res: options.res }).catch(() => ({ status: 500, message: "Internal Server Error" }));
+      send(status, {
+        success: false,
+        data: null,
+        message
+      });
+      return {
+        success: false,
+        data: { status, message }
+      };
+    }
+  }
+  constructor(routes, options) {
+    this.routerOptions = options;
+    this.routes = new Set(routes);
+  }
+  /**
+   * Adds a new route to the router
+   * @deprecated Use the method-specific methods instead
+   */
+  add = (method, path, route) => {
+    const merged = {
+      ...typeof route === "object" ? route : { run: route },
+      method,
+      path,
+      through: this.routerOptions.through
+    };
+    return new _Router([...this.routes, merged], this.routerOptions);
+  };
+  merge = (pathPrefix, other) => {
+    const newRoutes = [...other.routes].map((route) => ({
+      ...route,
+      path: `${pathPrefix}${route.path}`
+    }));
+    return new _Router(
+      [...this.routes, ...newRoutes],
+      this.routerOptions
+    );
+  };
+  // Allow for any server context to be passed
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  freeze = (server) => {
+    const instance = fmw({
+      ignoreTrailingSlash: true,
+      async defaultRoute(req, serverResponse) {
+        const res = new KaitoResponse(serverResponse);
+        const message = `Cannot ${req.method} ${req.url ?? "/"}`;
+        getSend(res)(404, {
+          success: false,
+          data: null,
+          message
+        });
+        return {
+          success: false,
+          data: { status: 404, message }
+        };
+      }
+    });
+    for (const route of this.routes) {
+      const handler = async (incomingMessage, serverResponse, params) => {
+        const req = new KaitoRequest(incomingMessage);
+        const res = new KaitoResponse(serverResponse);
+        return _Router.handle(server, route, {
+          params,
+          req,
+          res
+        });
+      };
+      if (route.method === "*") {
+        instance.all(route.path, handler);
+        continue;
+      }
+      instance.on(route.method, route.path, handler);
+    }
+    return instance;
+  };
+  method = (method) => (path, route) => {
+    return this.add(method, path, route);
+  };
+  get = this.method("GET");
+  post = this.method("POST");
+  put = this.method("PUT");
+  patch = this.method("PATCH");
+  delete = this.method("DELETE");
+  head = this.method("HEAD");
+  options = this.method("OPTIONS");
+  through = (transform) => new _Router(this.routes, {
+    through: async (context) => {
+      const fromCurrentRouter = await this.routerOptions.through(context);
+      return transform(fromCurrentRouter);
+    }
+  });
+};
+
+// src/util.ts
+function createGetContext(callback) {
+  return callback;
+}
+function createUtilities(getContext) {
+  return {
+    getContext,
+    router: () => Router.create()
+  };
+}
+function getLastEntryInMultiHeaderValue(headerValue) {
+  const normalized = Array.isArray(headerValue) ? headerValue.join(",") : headerValue;
+  const lastIndex = normalized.lastIndexOf(",");
+  return lastIndex === -1 ? normalized.trim() : normalized.slice(lastIndex + 1).trim();
+}
+async function getBody(req) {
+  if (!req.headers["content-type"]) {
+    return null;
+  }
+  const buffer = await getRawBody(req.raw);
+  const { type } = parseContentType(req.headers["content-type"]);
+  switch (type) {
+    case "application/json": {
+      return json(Readable.from(buffer));
+    }
+    default: {
+      if (process.env.NODE_ENV === "development") {
+        console.warn("[kaito] Unsupported content type:", type);
+        console.warn("[kaito] This message is only shown in development mode.");
+      }
+      return null;
+    }
+  }
+}
+
+// src/req.ts
+var KaitoRequest = class {
+  constructor(raw) {
+    this.raw = raw;
+  }
+  _url = null;
+  /**
+   * The full URL of the request, including the protocol, hostname, and path.
+   * Note: does not include the query string or hash
+   */
+  get fullURL() {
+    return `${this.protocol}://${this.hostname}${this.raw.url ?? ""}`;
+  }
+  /**
+   * A new URL instance for the full URL of the request.
+   */
+  get url() {
+    if (this._url) {
+      return this._url;
+    }
+    this._url = new URL(this.fullURL);
+    return this._url;
+  }
+  /**
+   * The HTTP method of the request.
+   */
+  get method() {
+    if (!this.raw.method) {
+      throw new Error("Request method is not defined, somehow...");
+    }
+    return this.raw.method;
+  }
+  /**
+   * The protocol of the request, either `http` or `https`.
+   */
+  get protocol() {
+    if (this.raw.socket instanceof TLSSocket) {
+      return this.raw.socket.encrypted ? "https" : "http";
+    }
+    return "http";
+  }
+  /**
+   * The request headers
+   */
+  get headers() {
+    return this.raw.headers;
+  }
+  /**
+   * The hostname of the request.
+   */
+  get hostname() {
+    return this.raw.headers.host ?? getLastEntryInMultiHeaderValue(this.raw.headers[":authority"] ?? []);
+  }
+};
+
+// src/server.ts
+import * as http from "node:http";
+function createFMWServer(config) {
+  const router = config.router.freeze(config);
+  const rawRoutes = config.rawRoutes ?? {};
+  for (const method in rawRoutes) {
+    if (!Object.prototype.hasOwnProperty.call(rawRoutes, method)) {
+      continue;
+    }
+    const routes = rawRoutes[method];
+    if (!routes || routes.length === 0) {
+      continue;
+    }
+    for (const route of routes) {
+      if (method === "*") {
+        router.all(route.path, route.handler);
+        continue;
+      }
+      router[method.toLowerCase()](route.path, route.handler);
+    }
+  }
+  const server = http.createServer(async (req, res) => {
+    let before;
+    if (config.before) {
+      before = await config.before(req, res);
+    } else {
+      before = void 0;
+    }
+    if (res.headersSent) {
+      return;
+    }
+    const result = await router.lookup(req, res);
+    if ("after" in config && config.after) {
+      await config.after(before, result);
+    }
+  });
+  return { server, fmw: router };
+}
+function createServer2(config) {
+  return createFMWServer(config).server;
+}
+export {
+  KaitoError,
+  KaitoRequest,
+  KaitoResponse,
+  Router,
+  WrappedError,
+  createFMWServer,
+  createGetContext,
+  createServer2 as createServer,
+  createUtilities,
+  getBody,
+  getLastEntryInMultiHeaderValue
+};

package/package.json

@@ -1,35 +1,38 @@
 {
   "name": "@kaito-http/core",
-  "version": "3.0.0-beta.1",
+  "version": "3.0.0-beta.4",
+  "type": "module",
+  "author": "Alistair Smith <hi@alistair.sh>",
   "description": "Functional HTTP Framework for TypeScript",
+  "scripts": {
+    "build": "tsup"
+  },
   "exports": {
-    ".": "./dist/kaito-http-core.js",
-    "./package.json": "./package.json"
+    "./package.json": "./package.json",
+    ".": "./dist/index.js"
   },
+  "homepage": "https://github.com/kaito-http/kaito",
   "repository": "https://github.com/kaito-http/kaito",
-  "author": "Alistair Smith <hi@alistair.sh>",
+  "keywords": [
+    "typescript",
+    "http",
+    "framework"
+  ],
   "license": "MIT",
-  "type": "module",
   "devDependencies": {
-    "@types/content-type": "^1.1.5",
-    "@types/cookie": "^0.5.1",
-    "@types/node": "^18.11.9",
+    "@types/content-type": "^1.1.8",
+    "@types/cookie": "^0.6.0",
+    "@types/node": "^22.7.4",
     "typescript": "^5.6.2"
   },
   "files": [
     "package.json",
-    "readme.md",
+    "README.md",
     "dist"
   ],
   "bugs": {
     "url": "https://github.com/kaito-http/kaito/issues"
   },
-  "homepage": "https://github.com/kaito-http/kaito",
-  "keywords": [
-    "typescript",
-    "http",
-    "framework"
-  ],
   "dependencies": {
     "content-type": "^1.0.5",
     "cookie": "^0.6.0",

package/dist/declarations/src/error.d.ts

@@ -1,10 +0,0 @@
-export declare class WrappedError<T> extends Error {
-    readonly data: T;
-    static maybe<T>(maybeError: T): (T & Error) | WrappedError<T>;
-    static from<T>(data: T): WrappedError<T>;
-    private constructor();
-}
-export declare class KaitoError extends Error {
-    readonly status: number;
-    constructor(status: number, message: string);
-}