@kaito-http/core 3.0.0-beta.16 → 3.0.0-beta.21

package/dist/index.cjs

@@ -106,6 +106,9 @@ var KaitoResponse = class {
     return this._headers;
   }
   status(status) {
+    if (status === void 0) {
+      return this._status;
+    }
     this._status = status;
     return this;
   }
@@ -125,19 +128,6 @@ var KaitoResponse = class {
   }
 };
 
-// src/util.ts
-function createUtilities(getContext) {
-  return {
-    getContext,
-    router: () => Router.create()
-  };
-}
-function parsable(parse) {
-  return {
-    parse
-  };
-}
-
 // src/router/router.ts
 var Router = class _Router {
   state;
@@ -150,9 +140,10 @@ var Router = class _Router {
       return {};
     }
     const result = {};
-    for (const [key, parsable2] of Object.entries(schema)) {
+    for (const key in schema) {
+      if (!schema.hasOwnProperty(key)) continue;
       const value = url.searchParams.get(key);
-      result[key] = parsable2.parse(value);
+      result[key] = schema[key].parse(value);
     }
     return result;
   }
@@ -232,10 +223,10 @@ var Router = class _Router {
       const request = new KaitoRequest(url, req);
       const response = new KaitoResponse();
       try {
-        const rootCtx = await server.getContext(request, response);
-        const ctx = await route.through(rootCtx);
         const body = route.body ? await route.body.parse(await req.json()) : void 0;
         const query = _Router.parseQuery(route.query, url);
+        const rootCtx = await server.getContext(request, response);
+        const ctx = await route.through(rootCtx);
         const result = await route.run({
           ctx,
           body,
@@ -289,23 +280,33 @@ var Router = class _Router {
 
 // src/server.ts
 function createKaitoHandler(config) {
-  const match = config.router.freeze(config);
+  const handle = config.router.freeze(config);
   return async (request) => {
-    let before = void 0;
     if (config.before) {
       const result = await config.before(request);
-      if (result instanceof Response) {
-        return result;
-      }
-      before = result;
+      if (result instanceof Response) return result;
     }
-    const response = await match(request);
-    if ("after" in config && config.after) {
-      await config.after(before, response);
+    const response = await handle(request);
+    if (config.transform) {
+      const result = await config.transform(request, response);
+      if (result instanceof Response) return result;
     }
     return response;
   };
 }
+
+// src/util.ts
+function createUtilities(getContext) {
+  return {
+    getContext,
+    router: () => Router.create()
+  };
+}
+function parsable(parse) {
+  return {
+    parse
+  };
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   KaitoError,

package/dist/index.d.cts

@@ -34,10 +34,10 @@ type KaitoMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'HEAD' | 'OPTIO
  * ```ts
  * const response = new KaitoResponse();
  *
- * response.status = 200;
- * response.header('Content-Type', 'application/json');
+ * response.status(200);
+ * response.headers.set('Content-Type', 'application/json');
  *
- * console.log(response.headers); // Headers { 'content-type': 'application/json' }
+ * console.log(response.headers); // Headers {'content-type': 'application/json'}
  * ```
  */
 declare class KaitoResponse {
@@ -45,6 +45,16 @@ declare class KaitoResponse {
     private _status;
     constructor();
     get headers(): Headers;
+    /**
+     * Gets the status code of this KaitoResponse instance
+     * @returns The status code
+     */
+    status(): number;
+    /**
+     * Sets the status code of this KaitoResponse instance
+     * @param status The status code to set
+     * @returns This KaitoResponse instance
+     */
     status(status: number): this;
     /**
      * Turn this KaitoResponse instance into a Response instance
@@ -54,26 +64,70 @@ declare class KaitoResponse {
     toResponse<T>(body: APIResponse<T>): Response;
 }
 
-type Before<BeforeAfterContext> = (req: Request) => Promise<BeforeAfterContext | Response>;
-type After<BeforeAfterContext> = (ctx: BeforeAfterContext, response: Response) => Promise<void>;
-type ServerConfigWithBefore<BeforeAfterContext> = {
-    before: Before<BeforeAfterContext>;
-    after?: After<BeforeAfterContext>;
-} | {
-    before?: undefined;
-};
-type ServerConfig<ContextFrom, BeforeAfterContext> = ServerConfigWithBefore<BeforeAfterContext> & {
+type Before = (req: Request) => Promise<Response | void | undefined>;
+type ServerConfig<ContextFrom> = {
+    /**
+     * The root router to mount on this server.
+     */
     router: Router<ContextFrom, unknown, any>;
+    /**
+     * A function that is called to get the context for a request.
+     *
+     * This is useful for things like authentication, to pass in a database connection, etc.
+     *
+     * It's fine for this function to throw; if it does, the error is passed to the `onError` function.
+     */
     getContext: GetContext<ContextFrom>;
-    onError(arg: {
+    /**
+     * A function that is called when an error occurs inside a route handler.
+     *
+     * The result of this function is used to determine the response status and message, and is
+     * always sent to the client. You could include logic to check for production vs development
+     * environments here, and this would also be a good place to include error tracking
+     * like Sentry or Rollbar.
+     *
+     * @param arg - The error and the request
+     * @returns A KaitoError or an object with a status and message
+     */
+    onError: (arg: {
         error: Error;
         req: KaitoRequest;
-    }): Promise<KaitoError | {
+    }) => Promise<KaitoError | {
         status: number;
         message: string;
     }>;
+    /**
+     * A function that is called before every request. Most useful for bailing out early in the case of an OPTIONS request.
+     *
+     * @example
+     * ```ts
+     * before: async req => {
+     * 	if (req.method === 'OPTIONS') {
+     * 		return new Response(null, {status: 204});
+     * 	}
+     * }
+     * ```
+     */
+    before?: Before;
+    /**
+     * Transforms the response before it is sent to the client. Very useful for settings headers like CORS.
+     *
+     * You can also return a new response in this function, or just mutate the current one.
+     *
+     * @example
+     * ```ts
+     * transform: async (req, res) => {
+     * 	res.headers.set('Access-Control-Allow-Origin', 'http://localhost:3000');
+     * 	res.headers.set('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, OPTIONS');
+     * 	res.headers.set('Access-Control-Allow-Headers', 'Content-Type, Authorization');
+     * 	res.headers.set('Access-Control-Max-Age', '86400');
+     * 	res.headers.set('Access-Control-Allow-Credentials', 'true');
+     * }
+     * ```
+     */
+    transform?: (req: Request, res: Response) => Promise<Response | void | undefined>;
 };
-declare function createKaitoHandler<Context, BeforeAfterContext = null>(config: ServerConfig<Context, BeforeAfterContext>): (request: Request) => Promise<Response>;
+declare function createKaitoHandler<Context>(config: ServerConfig<Context>): (request: Request) => Promise<Response>;
 
 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;
@@ -88,17 +142,17 @@ declare class Router<ContextFrom, ContextTo, R extends AnyRoute> {
     private static parseQuery;
     constructor(options: RouterState<R, ContextFrom, ContextTo>);
     get routes(): Set<R>;
-    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 extends Response ? unknown : Result, Path, Method, Query, Body>>;
+    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: Omit<ServerConfig<ContextFrom, any>, "router">) => (req: Request) => Promise<Response>;
+    freeze: (server: Omit<ServerConfig<ContextFrom>, "router">) => (req: Request) => Promise<Response>;
     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 extends Response ? unknown : 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 extends Response ? unknown : 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 extends Response ? unknown : 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 extends Response ? unknown : 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 extends Response ? unknown : 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 extends Response ? unknown : 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 extends Response ? unknown : Result, Path, "OPTIONS", Query, Body>>;
+    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>;
 }
 
@@ -114,6 +168,7 @@ type SuccessfulAPIResponse<T> = {
 };
 type APIResponse<T> = ErroredAPIResponse | SuccessfulAPIResponse<T>;
 type AnyResponse = APIResponse<unknown>;
+type MakeOptional<T, K extends keyof T> = T extends T ? Omit<T, K> & Partial<Pick<T, K>> : never;
 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}` ? {
@@ -172,4 +227,4 @@ type Route<ContextFrom, ContextTo, Result, Path extends string, Method extends K
 };
 type AnyRoute<ContextFrom = any, ContextTo = any> = Route<ContextFrom, ContextTo, any, any, any, AnyQueryDefinition, any>;
 
-export { type APIResponse, type After, type AnyQueryDefinition, type AnyResponse, type AnyRoute, type Before, type ErroredAPIResponse, type ExtractRouteParams, type GetContext, type InferParsable, type InferRoutes, KaitoError, type KaitoMethod, KaitoRequest, type Parsable, type Route, type RouteArgument, Router, type RouterState, type ServerConfig, type ServerConfigWithBefore, type SuccessfulAPIResponse, type Through, WrappedError, createKaitoHandler, createUtilities, parsable };
+export { type APIResponse, type AnyQueryDefinition, type AnyResponse, type AnyRoute, type Before, type ErroredAPIResponse, type ExtractRouteParams, type GetContext, type InferParsable, type InferRoutes, KaitoError, type KaitoMethod, KaitoRequest, type MakeOptional, type Parsable, type Route, type RouteArgument, Router, type RouterState, type ServerConfig, type SuccessfulAPIResponse, type Through, WrappedError, createKaitoHandler, createUtilities, parsable };

package/dist/index.d.ts

@@ -34,10 +34,10 @@ type KaitoMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'HEAD' | 'OPTIO
  * ```ts
  * const response = new KaitoResponse();
  *
- * response.status = 200;
- * response.header('Content-Type', 'application/json');
+ * response.status(200);
+ * response.headers.set('Content-Type', 'application/json');
  *
- * console.log(response.headers); // Headers { 'content-type': 'application/json' }
+ * console.log(response.headers); // Headers {'content-type': 'application/json'}
  * ```
  */
 declare class KaitoResponse {
@@ -45,6 +45,16 @@ declare class KaitoResponse {
     private _status;
     constructor();
     get headers(): Headers;
+    /**
+     * Gets the status code of this KaitoResponse instance
+     * @returns The status code
+     */
+    status(): number;
+    /**
+     * Sets the status code of this KaitoResponse instance
+     * @param status The status code to set
+     * @returns This KaitoResponse instance
+     */
     status(status: number): this;
     /**
      * Turn this KaitoResponse instance into a Response instance
@@ -54,26 +64,70 @@ declare class KaitoResponse {
     toResponse<T>(body: APIResponse<T>): Response;
 }
 
-type Before<BeforeAfterContext> = (req: Request) => Promise<BeforeAfterContext | Response>;
-type After<BeforeAfterContext> = (ctx: BeforeAfterContext, response: Response) => Promise<void>;
-type ServerConfigWithBefore<BeforeAfterContext> = {
-    before: Before<BeforeAfterContext>;
-    after?: After<BeforeAfterContext>;
-} | {
-    before?: undefined;
-};
-type ServerConfig<ContextFrom, BeforeAfterContext> = ServerConfigWithBefore<BeforeAfterContext> & {
+type Before = (req: Request) => Promise<Response | void | undefined>;
+type ServerConfig<ContextFrom> = {
+    /**
+     * The root router to mount on this server.
+     */
     router: Router<ContextFrom, unknown, any>;
+    /**
+     * A function that is called to get the context for a request.
+     *
+     * This is useful for things like authentication, to pass in a database connection, etc.
+     *
+     * It's fine for this function to throw; if it does, the error is passed to the `onError` function.
+     */
     getContext: GetContext<ContextFrom>;
-    onError(arg: {
+    /**
+     * A function that is called when an error occurs inside a route handler.
+     *
+     * The result of this function is used to determine the response status and message, and is
+     * always sent to the client. You could include logic to check for production vs development
+     * environments here, and this would also be a good place to include error tracking
+     * like Sentry or Rollbar.
+     *
+     * @param arg - The error and the request
+     * @returns A KaitoError or an object with a status and message
+     */
+    onError: (arg: {
         error: Error;
         req: KaitoRequest;
-    }): Promise<KaitoError | {
+    }) => Promise<KaitoError | {
         status: number;
         message: string;
     }>;
+    /**
+     * A function that is called before every request. Most useful for bailing out early in the case of an OPTIONS request.
+     *
+     * @example
+     * ```ts
+     * before: async req => {
+     * 	if (req.method === 'OPTIONS') {
+     * 		return new Response(null, {status: 204});
+     * 	}
+     * }
+     * ```
+     */
+    before?: Before;
+    /**
+     * Transforms the response before it is sent to the client. Very useful for settings headers like CORS.
+     *
+     * You can also return a new response in this function, or just mutate the current one.
+     *
+     * @example
+     * ```ts
+     * transform: async (req, res) => {
+     * 	res.headers.set('Access-Control-Allow-Origin', 'http://localhost:3000');
+     * 	res.headers.set('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, OPTIONS');
+     * 	res.headers.set('Access-Control-Allow-Headers', 'Content-Type, Authorization');
+     * 	res.headers.set('Access-Control-Max-Age', '86400');
+     * 	res.headers.set('Access-Control-Allow-Credentials', 'true');
+     * }
+     * ```
+     */
+    transform?: (req: Request, res: Response) => Promise<Response | void | undefined>;
 };
-declare function createKaitoHandler<Context, BeforeAfterContext = null>(config: ServerConfig<Context, BeforeAfterContext>): (request: Request) => Promise<Response>;
+declare function createKaitoHandler<Context>(config: ServerConfig<Context>): (request: Request) => Promise<Response>;
 
 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;
@@ -88,17 +142,17 @@ declare class Router<ContextFrom, ContextTo, R extends AnyRoute> {
     private static parseQuery;
     constructor(options: RouterState<R, ContextFrom, ContextTo>);
     get routes(): Set<R>;
-    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 extends Response ? unknown : Result, Path, Method, Query, Body>>;
+    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: Omit<ServerConfig<ContextFrom, any>, "router">) => (req: Request) => Promise<Response>;
+    freeze: (server: Omit<ServerConfig<ContextFrom>, "router">) => (req: Request) => Promise<Response>;
     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 extends Response ? unknown : 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 extends Response ? unknown : 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 extends Response ? unknown : 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 extends Response ? unknown : 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 extends Response ? unknown : 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 extends Response ? unknown : 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 extends Response ? unknown : Result, Path, "OPTIONS", Query, Body>>;
+    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>;
 }
 
@@ -114,6 +168,7 @@ type SuccessfulAPIResponse<T> = {
 };
 type APIResponse<T> = ErroredAPIResponse | SuccessfulAPIResponse<T>;
 type AnyResponse = APIResponse<unknown>;
+type MakeOptional<T, K extends keyof T> = T extends T ? Omit<T, K> & Partial<Pick<T, K>> : never;
 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}` ? {
@@ -172,4 +227,4 @@ type Route<ContextFrom, ContextTo, Result, Path extends string, Method extends K
 };
 type AnyRoute<ContextFrom = any, ContextTo = any> = Route<ContextFrom, ContextTo, any, any, any, AnyQueryDefinition, any>;
 
-export { type APIResponse, type After, type AnyQueryDefinition, type AnyResponse, type AnyRoute, type Before, type ErroredAPIResponse, type ExtractRouteParams, type GetContext, type InferParsable, type InferRoutes, KaitoError, type KaitoMethod, KaitoRequest, type Parsable, type Route, type RouteArgument, Router, type RouterState, type ServerConfig, type ServerConfigWithBefore, type SuccessfulAPIResponse, type Through, WrappedError, createKaitoHandler, createUtilities, parsable };
+export { type APIResponse, type AnyQueryDefinition, type AnyResponse, type AnyRoute, type Before, type ErroredAPIResponse, type ExtractRouteParams, type GetContext, type InferParsable, type InferRoutes, KaitoError, type KaitoMethod, KaitoRequest, type MakeOptional, type Parsable, type Route, type RouteArgument, Router, type RouterState, type ServerConfig, type SuccessfulAPIResponse, type Through, WrappedError, createKaitoHandler, createUtilities, parsable };

package/dist/index.js

@@ -74,6 +74,9 @@ var KaitoResponse = class {
     return this._headers;
   }
   status(status) {
+    if (status === void 0) {
+      return this._status;
+    }
     this._status = status;
     return this;
   }
@@ -93,19 +96,6 @@ var KaitoResponse = class {
   }
 };
 
-// src/util.ts
-function createUtilities(getContext) {
-  return {
-    getContext,
-    router: () => Router.create()
-  };
-}
-function parsable(parse) {
-  return {
-    parse
-  };
-}
-
 // src/router/router.ts
 var Router = class _Router {
   state;
@@ -118,9 +108,10 @@ var Router = class _Router {
       return {};
     }
     const result = {};
-    for (const [key, parsable2] of Object.entries(schema)) {
+    for (const key in schema) {
+      if (!schema.hasOwnProperty(key)) continue;
       const value = url.searchParams.get(key);
-      result[key] = parsable2.parse(value);
+      result[key] = schema[key].parse(value);
     }
     return result;
   }
@@ -200,10 +191,10 @@ var Router = class _Router {
       const request = new KaitoRequest(url, req);
       const response = new KaitoResponse();
       try {
-        const rootCtx = await server.getContext(request, response);
-        const ctx = await route.through(rootCtx);
         const body = route.body ? await route.body.parse(await req.json()) : void 0;
         const query = _Router.parseQuery(route.query, url);
+        const rootCtx = await server.getContext(request, response);
+        const ctx = await route.through(rootCtx);
         const result = await route.run({
           ctx,
           body,
@@ -257,23 +248,33 @@ var Router = class _Router {
 
 // src/server.ts
 function createKaitoHandler(config) {
-  const match = config.router.freeze(config);
+  const handle = config.router.freeze(config);
   return async (request) => {
-    let before = void 0;
     if (config.before) {
       const result = await config.before(request);
-      if (result instanceof Response) {
-        return result;
-      }
-      before = result;
+      if (result instanceof Response) return result;
     }
-    const response = await match(request);
-    if ("after" in config && config.after) {
-      await config.after(before, response);
+    const response = await handle(request);
+    if (config.transform) {
+      const result = await config.transform(request, response);
+      if (result instanceof Response) return result;
     }
     return response;
   };
 }
+
+// src/util.ts
+function createUtilities(getContext) {
+  return {
+    getContext,
+    router: () => Router.create()
+  };
+}
+function parsable(parse) {
+  return {
+    parse
+  };
+}
 export {
   KaitoError,
   KaitoRequest,