@kaito-http/core 2.9.5 → 3.0.0-beta.3

package/README.md

@@ -1,12 +1,9 @@
 # `kaito-http`
 
-[![Vercel](https://github.com/kaito-http/kaito/raw/main/static/powered-by-vercel.svg)](https://vercel.com?utm_source=kaito-http&utm_campaign=oss)
-
 #### An HTTP Framework for TypeScript
 
 View the [documentation here](https://kaito.cloud)
 
 #### Credits
 
-- [Vercel](https://vercel.com?utm_source=kaito-http&utm_campaign=oss), for sponsoring the project and hosting the documentation
-- [Alistair Smith](https://twitter.com/aabbccsmith)
+- [Alistair Smith](https://twitter.com/alistaiir)

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,41 +1,42 @@
 {
   "name": "@kaito-http/core",
-  "version": "2.9.5",
+  "version": "3.0.0-beta.3",
+  "type": "module",
+  "author": "Alistair Smith <hi@alistair.sh>",
   "description": "Functional HTTP Framework for TypeScript",
+  "scripts": {
+    "build": "tsup"
+  },
+  "exports": {
+    "./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",
-  "main": "dist/kaito-http-core.cjs.js",
-  "module": "dist/kaito-http-core.esm.js",
-  "types": "dist/kaito-http-core.cjs.d.ts",
   "devDependencies": {
-    "@types/content-type": "^1.1.5",
-    "@types/cookie": "^0.5.1",
-    "@types/node": "^18.11.9",
-    "typescript": "4.9",
-    "zod": "^3.19.1"
+    "@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",
-  "peerDependencies": {
-    "zod": "*"
-  },
-  "keywords": [
-    "typescript",
-    "http",
-    "framework"
-  ],
   "dependencies": {
-    "content-type": "^1.0.4",
-    "cookie": "^0.5.0",
-    "find-my-way": "^7.3.1",
-    "raw-body": "^2.5.1"
+    "content-type": "^1.0.5",
+    "cookie": "^0.6.0",
+    "find-my-way": "^9.1.0",
+    "raw-body": "^3.0.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);
-}

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

@@ -1,8 +0,0 @@
-export type { HTTPMethod } from 'find-my-way';
-export * from './error';
-export * from './req';
-export * from './res';
-export * from './route';
-export * from './router';
-export * from './server';
-export * from './util';

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

@@ -1,33 +0,0 @@
-/// <reference types="node" />
-import type { HTTPMethod } from 'find-my-way';
-import type { IncomingMessage } from 'node:http';
-export 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(): import("http").IncomingHttpHeaders;
-    /**
-     * The hostname of the request.
-     */
-    get hostname(): string;
-}

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

@@ -1,46 +0,0 @@
-/// <reference types="node" />
-import type { ServerResponse } from 'node:http';
-import type { CookieSerializeOptions } from 'cookie';
-export type ErroredAPIResponse = {
-    success: false;
-    data: null;
-    message: string;
-};
-export type SuccessfulAPIResponse<T> = {
-    success: true;
-    data: T;
-    message: 'OK';
-};
-export type APIResponse<T> = ErroredAPIResponse | SuccessfulAPIResponse<T>;
-export type AnyResponse = APIResponse<unknown>;
-export 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;
-}

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

@@ -1,18 +0,0 @@
-import type { z } from 'zod';
-import type { ExtractRouteParams, KaitoMethod } from './util';
-export type RouteArgument<Path extends string, Context, QueryOutput, BodyOutput> = {
-    ctx: Context;
-    body: BodyOutput;
-    query: QueryOutput;
-    params: ExtractRouteParams<Path>;
-};
-export type AnyQueryDefinition = Record<string, z.ZodTypeAny>;
-export type Route<ContextFrom, ContextTo, Result, Path extends string, Method extends KaitoMethod, Query extends AnyQueryDefinition, BodyOutput, BodyDef extends z.ZodTypeDef, BodyInput> = {
-    through: (context: ContextFrom) => Promise<ContextTo>;
-    body?: z.ZodType<BodyOutput, BodyDef, BodyInput>;
-    query?: Query;
-    path: Path;
-    method: Method;
-    run(args: RouteArgument<Path, ContextTo, z.infer<z.ZodObject<Query>>, BodyOutput>): Promise<Result>;
-};
-export type AnyRoute<FromContext = any, ToContext = any> = Route<FromContext, ToContext, any, any, any, AnyQueryDefinition, any, any, any>;

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

@@ -1,41 +0,0 @@
-import fmw from 'find-my-way';
-import { z } from 'zod';
-import type { AnyQueryDefinition, AnyRoute, Route } from './route';
-import type { ServerConfig } from './server';
-import type { KaitoMethod } from './util';
-type Routes = readonly AnyRoute[];
-type RemapRoutePrefix<R extends AnyRoute, Prefix extends `/${string}`> = R extends Route<infer ContextFrom, infer ContextTo, infer Result, infer Path, infer Method, infer Query, infer BodyOutput, infer BodyDef, infer BodyInput> ? Route<ContextFrom, ContextTo, Result, `${Prefix}${Path}`, Method, Query, BodyOutput, BodyDef, BodyInput> : never;
-type PrefixRoutesPath<Prefix extends `/${string}`, R extends Routes> = R extends [infer First, ...infer Rest] ? [
-    RemapRoutePrefix<Extract<First, AnyRoute>, Prefix>,
-    ...PrefixRoutesPath<Prefix, Extract<Rest, readonly AnyRoute[]>>
-] : [];
-export type RouterOptions<ContextFrom, ContextTo> = {
-    through: (context: ContextFrom) => Promise<ContextTo>;
-};
-export declare class Router<ContextFrom, ContextTo, R extends Routes> {
-    private readonly routerOptions;
-    readonly routes: R;
-    static create: <Context>() => Router<Context, Context, []>;
-    private static handle;
-    constructor(routes: R, options: RouterOptions<ContextFrom, ContextTo>);
-    /**
-     * Adds a new route to the router
-     * @param method The HTTP method to add a route for
-     * @param path The path to add a route for
-     * @param route The route specification to add to this router
-     * @returns A new router with this route added
-     */
-    add: <Result, Path extends string, Method extends KaitoMethod, Query extends AnyQueryDefinition = {}, BodyOutput = never, BodyDef extends z.ZodTypeDef = z.ZodTypeDef, BodyInput = BodyOutput>(method: Method, path: Path, route: ((args: import("./route").RouteArgument<Path, ContextTo, z.objectUtil.addQuestionMarks<{ [k_1 in keyof Query]: Query[k_1]["_output"]; }> extends infer T extends object ? { [k in keyof T]: z.objectUtil.addQuestionMarks<{ [k_1 in keyof Query]: Query[k_1]["_output"]; }>[k]; } : never, BodyOutput>) => Promise<Result>) | (Method extends "GET" ? Omit<Route<ContextFrom, ContextTo, Result, Path, Method, Query, BodyOutput, BodyDef, BodyInput>, "path" | "body" | "method" | "through"> : Omit<Route<ContextFrom, ContextTo, Result, Path, Method, Query, BodyOutput, BodyDef, BodyInput>, "path" | "method" | "through">)) => Router<ContextFrom, ContextTo, [...R, Route<ContextFrom, ContextTo, Result, Path, Method, Query, BodyOutput, BodyDef, BodyInput>]>;
-    readonly merge: <PathPrefix extends `/${string}`, OtherRoutes extends Routes>(pathPrefix: PathPrefix, other: Router<ContextFrom, unknown, OtherRoutes>) => Router<ContextFrom, ContextTo, [...R, ...PrefixRoutesPath<PathPrefix, OtherRoutes>]>;
-    freeze: (server: ServerConfig<ContextFrom, any>) => fmw.Instance<fmw.HTTPVersion.V1>;
-    private readonly method;
-    get: <Result, Path extends string, Query extends AnyQueryDefinition = {}, BodyOutput = never, BodyDef extends z.ZodTypeDef = z.ZodTypeDef, BodyInput = BodyOutput>(path: Path, route: ((args: import("./route").RouteArgument<Path, ContextTo, z.objectUtil.addQuestionMarks<{ [k_1 in keyof Query]: Query[k_1]["_output"]; }> extends infer T extends object ? { [k in keyof T]: z.objectUtil.addQuestionMarks<{ [k_1 in keyof Query]: Query[k_1]["_output"]; }>[k]; } : never, BodyOutput>) => Promise<Result>) | Omit<Route<ContextFrom, ContextTo, Result, Path, "GET", Query, BodyOutput, BodyDef, BodyInput>, "path" | "body" | "method" | "through">) => Router<ContextFrom, ContextTo, [...R, Route<ContextFrom, ContextTo, Result, Path, "GET", Query, BodyOutput, BodyDef, BodyInput>]>;
-    post: <Result, Path extends string, Query extends AnyQueryDefinition = {}, BodyOutput = never, BodyDef extends z.ZodTypeDef = z.ZodTypeDef, BodyInput = BodyOutput>(path: Path, route: ((args: import("./route").RouteArgument<Path, ContextTo, z.objectUtil.addQuestionMarks<{ [k_1 in keyof Query]: Query[k_1]["_output"]; }> extends infer T extends object ? { [k in keyof T]: z.objectUtil.addQuestionMarks<{ [k_1 in keyof Query]: Query[k_1]["_output"]; }>[k]; } : never, BodyOutput>) => Promise<Result>) | Omit<Route<ContextFrom, ContextTo, Result, Path, "POST", Query, BodyOutput, BodyDef, BodyInput>, "path" | "method" | "through">) => Router<ContextFrom, ContextTo, [...R, Route<ContextFrom, ContextTo, Result, Path, "POST", Query, BodyOutput, BodyDef, BodyInput>]>;
-    put: <Result, Path extends string, Query extends AnyQueryDefinition = {}, BodyOutput = never, BodyDef extends z.ZodTypeDef = z.ZodTypeDef, BodyInput = BodyOutput>(path: Path, route: ((args: import("./route").RouteArgument<Path, ContextTo, z.objectUtil.addQuestionMarks<{ [k_1 in keyof Query]: Query[k_1]["_output"]; }> extends infer T extends object ? { [k in keyof T]: z.objectUtil.addQuestionMarks<{ [k_1 in keyof Query]: Query[k_1]["_output"]; }>[k]; } : never, BodyOutput>) => Promise<Result>) | Omit<Route<ContextFrom, ContextTo, Result, Path, "PUT", Query, BodyOutput, BodyDef, BodyInput>, "path" | "method" | "through">) => Router<ContextFrom, ContextTo, [...R, Route<ContextFrom, ContextTo, Result, Path, "PUT", Query, BodyOutput, BodyDef, BodyInput>]>;
-    patch: <Result, Path extends string, Query extends AnyQueryDefinition = {}, BodyOutput = never, BodyDef extends z.ZodTypeDef = z.ZodTypeDef, BodyInput = BodyOutput>(path: Path, route: ((args: import("./route").RouteArgument<Path, ContextTo, z.objectUtil.addQuestionMarks<{ [k_1 in keyof Query]: Query[k_1]["_output"]; }> extends infer T extends object ? { [k in keyof T]: z.objectUtil.addQuestionMarks<{ [k_1 in keyof Query]: Query[k_1]["_output"]; }>[k]; } : never, BodyOutput>) => Promise<Result>) | Omit<Route<ContextFrom, ContextTo, Result, Path, "PATCH", Query, BodyOutput, BodyDef, BodyInput>, "path" | "method" | "through">) => Router<ContextFrom, ContextTo, [...R, Route<ContextFrom, ContextTo, Result, Path, "PATCH", Query, BodyOutput, BodyDef, BodyInput>]>;
-    delete: <Result, Path extends string, Query extends AnyQueryDefinition = {}, BodyOutput = never, BodyDef extends z.ZodTypeDef = z.ZodTypeDef, BodyInput = BodyOutput>(path: Path, route: ((args: import("./route").RouteArgument<Path, ContextTo, z.objectUtil.addQuestionMarks<{ [k_1 in keyof Query]: Query[k_1]["_output"]; }> extends infer T extends object ? { [k in keyof T]: z.objectUtil.addQuestionMarks<{ [k_1 in keyof Query]: Query[k_1]["_output"]; }>[k]; } : never, BodyOutput>) => Promise<Result>) | Omit<Route<ContextFrom, ContextTo, Result, Path, "DELETE", Query, BodyOutput, BodyDef, BodyInput>, "path" | "method" | "through">) => Router<ContextFrom, ContextTo, [...R, Route<ContextFrom, ContextTo, Result, Path, "DELETE", Query, BodyOutput, BodyDef, BodyInput>]>;
-    head: <Result, Path extends string, Query extends AnyQueryDefinition = {}, BodyOutput = never, BodyDef extends z.ZodTypeDef = z.ZodTypeDef, BodyInput = BodyOutput>(path: Path, route: ((args: import("./route").RouteArgument<Path, ContextTo, z.objectUtil.addQuestionMarks<{ [k_1 in keyof Query]: Query[k_1]["_output"]; }> extends infer T extends object ? { [k in keyof T]: z.objectUtil.addQuestionMarks<{ [k_1 in keyof Query]: Query[k_1]["_output"]; }>[k]; } : never, BodyOutput>) => Promise<Result>) | Omit<Route<ContextFrom, ContextTo, Result, Path, "HEAD", Query, BodyOutput, BodyDef, BodyInput>, "path" | "method" | "through">) => Router<ContextFrom, ContextTo, [...R, Route<ContextFrom, ContextTo, Result, Path, "HEAD", Query, BodyOutput, BodyDef, BodyInput>]>;
-    options: <Result, Path extends string, Query extends AnyQueryDefinition = {}, BodyOutput = never, BodyDef extends z.ZodTypeDef = z.ZodTypeDef, BodyInput = BodyOutput>(path: Path, route: ((args: import("./route").RouteArgument<Path, ContextTo, z.objectUtil.addQuestionMarks<{ [k_1 in keyof Query]: Query[k_1]["_output"]; }> extends infer T extends object ? { [k in keyof T]: z.objectUtil.addQuestionMarks<{ [k_1 in keyof Query]: Query[k_1]["_output"]; }>[k]; } : never, BodyOutput>) => Promise<Result>) | Omit<Route<ContextFrom, ContextTo, Result, Path, "OPTIONS", Query, BodyOutput, BodyDef, BodyInput>, "path" | "method" | "through">) => Router<ContextFrom, ContextTo, [...R, Route<ContextFrom, ContextTo, Result, Path, "OPTIONS", Query, BodyOutput, BodyDef, BodyInput>]>;
-    through: <NextContext>(transform: (context: ContextTo) => Promise<NextContext>) => Router<ContextFrom, NextContext, R>;
-}
-export {};

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

@@ -1,46 +0,0 @@
-/// <reference types="node" />
-import * as http from 'node:http';
-import type { KaitoError } from './error';
-import type { KaitoRequest } from './req';
-import type { KaitoResponse } from './res';
-import type { Router } from './router';
-import type { GetContext, KaitoMethod } from './util';
-export type Before<BeforeAfterContext> = (req: http.IncomingMessage, res: http.ServerResponse) => Promise<BeforeAfterContext>;
-export type HandlerResult = {
-    success: true;
-    data: unknown;
-} | {
-    success: false;
-    data: {
-        status: number;
-        message: string;
-    };
-};
-export type After<BeforeAfterContext> = (ctx: BeforeAfterContext, result: HandlerResult) => Promise<void>;
-export type ServerConfigWithBefore<BeforeAfterContext> = {
-    before: Before<BeforeAfterContext>;
-    after?: After<BeforeAfterContext>;
-} | {
-    before?: undefined;
-};
-export type ServerConfig<ContextFrom, BeforeAfterContext> = ServerConfigWithBefore<BeforeAfterContext> & {
-    router: Router<ContextFrom, unknown, any>;
-    getContext: GetContext<ContextFrom>;
-    rawRoutes?: Partial<Record<KaitoMethod, Array<{
-        path: string;
-        handler: (request: http.IncomingMessage, response: http.ServerResponse) => unknown;
-    }>>>;
-    onError(arg: {
-        error: Error;
-        req: KaitoRequest;
-        res: KaitoResponse;
-    }): Promise<KaitoError | {
-        status: number;
-        message: string;
-    }>;
-};
-export declare function createFMWServer<Context, BeforeAfterContext = null>(config: ServerConfig<Context, BeforeAfterContext>): {
-    readonly server: http.Server<typeof http.IncomingMessage, typeof http.ServerResponse>;
-    readonly fmw: import("find-my-way").Instance<import("find-my-way").HTTPVersion.V1>;
-};
-export declare function createServer<Context, BeforeAfterContext = null>(config: ServerConfig<Context, BeforeAfterContext>): http.Server<typeof http.IncomingMessage, typeof http.ServerResponse>;