@kaito-http/core 4.0.0-beta.10 → 4.0.0-beta.12

package/dist/index.cjs

@@ -147,12 +147,13 @@ var isNodeLikeDev = typeof process !== "undefined" && typeof process.env !== "un
 // src/router/router.ts
 var Router = class _Router {
   state;
-  static create = (config) => new _Router({
-    through: async (context) => context,
-    routes: /* @__PURE__ */ new Set(),
-    config,
-    paramsSchema: null
-  });
+  static create = (config = {}) => {
+    return new _Router({
+      through: async (context) => context,
+      routes: /* @__PURE__ */ new Set(),
+      config
+    });
+  };
   constructor(state) {
     this.state = state;
   }
@@ -171,10 +172,7 @@ var Router = class _Router {
       routes: /* @__PURE__ */ new Set([...this.state.routes, merged])
     });
   };
-  params = (spec) => new _Router({
-    ...this.state,
-    paramsSchema: import_zod.z.object(spec)
-  });
+  params = () => this;
   merge = (pathPrefix, other) => {
     const newRoutes = [...other.state.routes].map((route) => ({
       ...route,
@@ -235,7 +233,7 @@ var Router = class _Router {
       });
     }
     const findRoute = _Router.getFindRoute(methodToRoutesMap);
-    const handle = async (req) => {
+    const handle = async (req, ...args) => {
       const url = new URL(req.url);
       const method = req.method;
       const { route, params: rawParams } = findRoute(method, url.pathname);
@@ -252,16 +250,15 @@ var Router = class _Router {
       try {
         const body = route.body ? await route.body.parseAsync(await req.json()) : void 0;
         const query = route.fastQuerySchema ? await route.fastQuerySchema.parseAsync(url.searchParams) : {};
-        const params = route.router.state.paramsSchema ? route.router.state.paramsSchema.parse(rawParams) : rawParams;
         const ctx = await route.router.state.through(
-          await this.state.config.getContext?.(request, head) ?? null,
-          params
+          await this.state.config.getContext?.(request, head, ...args) ?? null,
+          rawParams
         );
         const result = await route.run({
           ctx,
           body,
           query,
-          params
+          params: rawParams
         });
         if (result instanceof Response) {
           if (isNodeLikeDev) {
@@ -315,7 +312,7 @@ var Router = class _Router {
         }
       }
     };
-    return async (request) => {
+    return async (request, ...args) => {
       if (this.state.config.before) {
         const result = await this.state.config.before(request);
         if (result instanceof Response) {
@@ -328,7 +325,7 @@ var Router = class _Router {
           return result;
         }
       }
-      const response = await handle(request);
+      const response = await handle(request, ...args);
       if (this.state.config.transform) {
         const transformed = await this.state.config.transform(request, response);
         if (transformed instanceof Response) {
@@ -429,10 +426,8 @@ var Router = class _Router {
   };
 };
 
-// src/create.ts
-function create(config = {}) {
-  return Router.create(config);
-}
+// src/index.ts
+var create = Router.create;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   KaitoError,

package/dist/index.d.cts

@@ -1,4 +1,4 @@
-import { z, ZodTypeDef } from 'zod';
+import { z } from 'zod';
 import { KaitoSSEResponse } from './stream/stream.cjs';
 
 declare class WrappedError<T> extends Error {
@@ -72,55 +72,59 @@ declare class KaitoHead {
     get touched(): boolean;
 }
 
-/**
- * A helper to check if the environment is Node.js-like and the NODE_ENV is development
- */
-declare const isNodeLikeDev: boolean;
-type ErroredAPIResponse = {
-    success: false;
-    data: null;
-    message: string;
-};
-type SuccessfulAPIResponse<T> = {
-    success: true;
-    data: 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 MaybePromise<T> = T | Promise<T>;
-type KaitoMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'HEAD' | 'OPTIONS';
-type NotReadonly<T> = {
-    -readonly [K in keyof T]: T[K];
+type PrefixRoutesPathInner<R extends AnyRoute, Prefix extends `/${string}`> = R extends Route<infer ContextTo, infer Result, infer Path, infer AdditionalParams, infer Method, infer Query, infer BodyOutput> ? Route<ContextTo, Result, `${Prefix}${Path extends '/' ? '' : Path}`, AdditionalParams, Method, Query, BodyOutput> : never;
+type PrefixRoutesPath<Prefix extends `/${string}`, R extends AnyRoute> = R extends R ? PrefixRoutesPathInner<R, Prefix> : never;
+type RouterState<ContextFrom, ContextTo, RequiredParams extends string, Routes extends AnyRoute, Input extends readonly unknown[]> = {
+    routes: Set<Routes>;
+    through: (context: unknown, params: RequiredParams) => Promise<ContextTo>;
+    config: KaitoConfig<ContextFrom, Input>;
 };
-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;
-} : {};
-/**
- * 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.
- *
- * @param req - The kaito request object, which contains the request method, url, headers, etc
- * @param head - The kaito head object, which contains getters and setters for headers and status
- * @returns The context for your routes
- */
-type GetContext<Result> = (req: KaitoRequest, head: KaitoHead) => MaybePromise<Result>;
+declare class Router<ContextFrom, ContextTo, RequiredParams extends string, R extends AnyRoute, Input extends readonly unknown[]> {
+    private readonly state;
+    static create: <Context = null, Input_1 extends readonly unknown[] = []>(config?: KaitoConfig<Context, Input_1>) => Router<Context, Context, never, never, Input_1>;
+    protected constructor(state: RouterState<ContextFrom, ContextTo, RequiredParams, R, Input>);
+    get routes(): Set<R>;
+    private readonly add;
+    readonly params: [R] extends [never] ? <NextParams extends string>() => Router<ContextFrom, ContextTo, NextParams, R, Input> : 'router.params() can only be called before any routes are attached';
+    readonly merge: <PathPrefix extends `/${string}`, NextRequiredParams extends string, OtherRoutes extends AnyRoute>(pathPrefix: [NextRequiredParams] extends [ExtractRouteParams<PathPrefix> | RequiredParams] ? PathPrefix : `Missing ${Exclude<NextRequiredParams, ExtractRouteParams<PathPrefix> | RequiredParams>}`, other: Router<ContextFrom, unknown, NextRequiredParams, OtherRoutes, Input>) => Router<ContextFrom, ContextTo, RequiredParams, Extract<R | PrefixRoutesPath<PathPrefix, Extract<OtherRoutes, AnyRoute>>, AnyRoute>, Input>;
+    protected static getFindRoute: <R_1>(routes: Map<KaitoMethod, Map<string, R_1>>) => (method: KaitoMethod, path: string) => {
+        route?: never;
+        params?: never;
+    } | {
+        route: R_1;
+        params: Record<string, string>;
+    };
+    private static buildQuerySchema;
+    serve: () => (request: Request, ...args: Input) => Promise<Response>;
+    openapi: (highLevelSpec: {
+        info: {
+            version: string;
+            title: string;
+            description?: string;
+        };
+        servers?: Partial<Record<(`https://` | `http://`) | ({} & string), string>>;
+    }) => Router<ContextFrom, ContextTo, RequiredParams, R | Route<ContextTo, Response, "/openapi.json", RequiredParams, "GET", {}, never>, Input>;
+    private readonly method;
+    get: <Result, Path extends string, Query extends AnyQuery = {}, Body = never>(path: Path, route: ((data: RouteRunData<RequiredParams | ExtractRouteParams<Path>, ContextTo, Query, Body>) => Result | Promise<Result>) | Omit<Route<ContextTo, Result, Path, RequiredParams, "GET", Query, Body>, "body" | "path" | "method" | "router">) => Router<ContextFrom, ContextTo, RequiredParams, R | Route<ContextTo, Result, Path, RequiredParams, "GET", Query, Body>, Input>;
+    post: <Result, Path extends string, Query extends AnyQuery = {}, Body = never>(path: Path, route: ((data: RouteRunData<RequiredParams | ExtractRouteParams<Path>, ContextTo, Query, Body>) => Result | Promise<Result>) | Omit<Route<ContextTo, Result, Path, RequiredParams, "POST", Query, Body>, "path" | "method" | "router">) => Router<ContextFrom, ContextTo, RequiredParams, R | Route<ContextTo, Result, Path, RequiredParams, "POST", Query, Body>, Input>;
+    put: <Result, Path extends string, Query extends AnyQuery = {}, Body = never>(path: Path, route: ((data: RouteRunData<RequiredParams | ExtractRouteParams<Path>, ContextTo, Query, Body>) => Result | Promise<Result>) | Omit<Route<ContextTo, Result, Path, RequiredParams, "PUT", Query, Body>, "path" | "method" | "router">) => Router<ContextFrom, ContextTo, RequiredParams, R | Route<ContextTo, Result, Path, RequiredParams, "PUT", Query, Body>, Input>;
+    patch: <Result, Path extends string, Query extends AnyQuery = {}, Body = never>(path: Path, route: ((data: RouteRunData<RequiredParams | ExtractRouteParams<Path>, ContextTo, Query, Body>) => Result | Promise<Result>) | Omit<Route<ContextTo, Result, Path, RequiredParams, "PATCH", Query, Body>, "path" | "method" | "router">) => Router<ContextFrom, ContextTo, RequiredParams, R | Route<ContextTo, Result, Path, RequiredParams, "PATCH", Query, Body>, Input>;
+    delete: <Result, Path extends string, Query extends AnyQuery = {}, Body = never>(path: Path, route: ((data: RouteRunData<RequiredParams | ExtractRouteParams<Path>, ContextTo, Query, Body>) => Result | Promise<Result>) | Omit<Route<ContextTo, Result, Path, RequiredParams, "DELETE", Query, Body>, "path" | "method" | "router">) => Router<ContextFrom, ContextTo, RequiredParams, R | Route<ContextTo, Result, Path, RequiredParams, "DELETE", Query, Body>, Input>;
+    head: <Result, Path extends string, Query extends AnyQuery = {}, Body = never>(path: Path, route: ((data: RouteRunData<RequiredParams | ExtractRouteParams<Path>, ContextTo, Query, Body>) => Result | Promise<Result>) | Omit<Route<ContextTo, Result, Path, RequiredParams, "HEAD", Query, Body>, "path" | "method" | "router">) => Router<ContextFrom, ContextTo, RequiredParams, R | Route<ContextTo, Result, Path, RequiredParams, "HEAD", Query, Body>, Input>;
+    options: <Result, Path extends string, Query extends AnyQuery = {}, Body = never>(path: Path, route: ((data: RouteRunData<RequiredParams | ExtractRouteParams<Path>, ContextTo, Query, Body>) => Result | Promise<Result>) | Omit<Route<ContextTo, Result, Path, RequiredParams, "OPTIONS", Query, Body>, "path" | "method" | "router">) => Router<ContextFrom, ContextTo, RequiredParams, R | Route<ContextTo, Result, Path, RequiredParams, "OPTIONS", Query, Body>, Input>;
+    through: <NextContext>(through: (context: ContextTo, params: RequiredParams) => MaybePromise<NextContext>) => Router<ContextFrom, NextContext, RequiredParams, R, Input>;
+}
 
-type RouteRunData<Params, Context, QueryOutput, BodyOutput> = {
+type RouteRunData<Params extends string, Context, QueryOutput, BodyOutput> = {
+    params: Record<Params, string>;
     ctx: Context;
-    body: BodyOutput;
     query: QueryOutput;
-    params: Params;
+    body: BodyOutput;
 };
 type AnyQuery = {
     [key in string]: any;
 };
-type Through<From, To, RequiredParams extends Record<string, unknown>> = (context: From, params: RequiredParams) => Promise<To>;
+type Through<From, To, RequiredParams extends string> = (context: From, params: Record<RequiredParams, string>) => Promise<To>;
 type SSEOutputSpec<Result> = {
     type: 'sse';
     schema: z.Schema<Result>;
@@ -135,7 +139,7 @@ type OutputSpec<Result> = {
     description?: string;
     body: NoInfer<Result extends KaitoSSEResponse<infer R> ? SSEOutputSpec<R> : JSONOutputSpec<Result>>;
 };
-type Route<ContextTo, Result, Path extends string, AdditionalParams extends Record<string, unknown>, Method extends KaitoMethod, Query, Body> = {
+type Route<ContextTo, Result, Path extends string, AdditionalParams extends string, Method extends KaitoMethod, Query, Body> = {
     body?: z.Schema<Body>;
     query?: {
         [Key in keyof Query]: z.Schema<Query[Key]>;
@@ -143,19 +147,33 @@ type Route<ContextTo, Result, Path extends string, AdditionalParams extends Reco
     path: Path;
     method: Method;
     openapi?: OutputSpec<NoInfer<Result>>;
-    router: Router<unknown, ContextTo, AdditionalParams, AnyRoute>;
-    run(data: RouteRunData<ExtractRouteParams<Path> & AdditionalParams, ContextTo, Query, Body>): Promise<Result> | Result;
+    router: Router<unknown, ContextTo, AdditionalParams, AnyRoute, any>;
+    run(data: RouteRunData<ExtractRouteParams<Path> | AdditionalParams, ContextTo, Query, Body>): Promise<Result> | Result;
 };
 type AnyRoute = Route<any, any, any, any, any, any, any>;
 
-type PrefixRoutesPathInner<R extends AnyRoute, Prefix extends `/${string}`> = R extends Route<infer ContextTo, infer Result, infer Path, infer AdditionalParams, infer Method, infer Query, infer BodyOutput> ? Route<ContextTo, Result, `${Prefix}${Path extends '/' ? '' : Path}`, AdditionalParams, Method, Query, BodyOutput> : never;
-type PrefixRoutesPath<Prefix extends `/${string}`, R extends AnyRoute> = R extends R ? PrefixRoutesPathInner<R, Prefix> : never;
-type RouterState<ContextFrom, ContextTo, RequiredParams extends Record<string, unknown>, Routes extends AnyRoute> = {
-    routes: Set<Routes>;
-    through: (context: unknown, params: RequiredParams) => Promise<ContextTo>;
-    config: KaitoConfig<ContextFrom>;
-    paramsSchema: z.Schema<RequiredParams> | null;
+/**
+ * A helper to check if the environment is Node.js-like and the `NODE_ENV` environment variable is set to `'development'`
+ */
+declare const isNodeLikeDev: boolean;
+type ErroredAPIResponse = {
+    success: false;
+    data: null;
+    message: string;
 };
+type SuccessfulAPIResponse<T> = {
+    success: true;
+    data: 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 MaybePromise<T> = T | Promise<T>;
+type KaitoMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'HEAD' | 'OPTIONS';
+type NotReadonly<T> = {
+    -readonly [K in keyof T]: T[K];
+};
+type ExtractRouteParams<T extends string> = string extends T ? string : T extends `${string}:${infer Param}/${infer Rest}` ? Param | ExtractRouteParams<Rest> : T extends `${string}:${infer Param}` ? Param : never;
 /**
  * Accepts a router instance, and returns a union of all the routes in the router
  *
@@ -166,46 +184,21 @@ type RouterState<ContextFrom, ContextTo, RequiredParams extends Record<string, u
  * type Routes = InferRoutes<typeof app>;
  * ```
  */
-type InferRoutes<R extends Router<any, any, any, any>> = R extends Router<any, any, any, infer R extends AnyRoute> ? R : never;
-declare class Router<ContextFrom, ContextTo, RequiredParams extends Record<string, unknown>, R extends AnyRoute> {
-    private readonly state;
-    static create: <Context>(config: KaitoConfig<Context>) => Router<Context, Context, {}, never>;
-    protected constructor(state: RouterState<ContextFrom, ContextTo, RequiredParams, R>);
-    get routes(): Set<R>;
-    private add;
-    params: this extends Router<infer ContextFrom, infer ContextTo, infer Params extends Record<string, unknown>, infer R extends AnyRoute> ? [keyof Params] extends [never] ? <NextParams extends Record<string, unknown> = {}>(spec: {
-        [Key in keyof NextParams]: z.ZodType<NextParams[Key], ZodTypeDef, string>;
-    }) => Router<ContextFrom, ContextTo, NextParams, R> : 'You cannot define params() on a router that has already had params defined, as routes that already consume params can break.' : never;
-    readonly merge: <PathPrefix extends `/${string}`, NextRequiredParams extends Record<string, unknown>, OtherRoutes extends AnyRoute>(pathPrefix: keyof NextRequiredParams extends keyof ExtractRouteParams<PathPrefix> | keyof RequiredParams ? PathPrefix : `Missing ${Exclude<Extract<keyof NextRequiredParams, string>, keyof RequiredParams>}${string}`, other: Router<ContextFrom, unknown, NextRequiredParams, OtherRoutes>) => Router<ContextFrom, ContextTo, RequiredParams, Extract<R | PrefixRoutesPath<PathPrefix, Extract<OtherRoutes, AnyRoute>>, AnyRoute>>;
-    protected static getFindRoute: <R_1>(routes: Map<KaitoMethod, Map<string, R_1>>) => (method: KaitoMethod, path: string) => {
-        route?: never;
-        params?: never;
-    } | {
-        route: R_1;
-        params: Record<string, string>;
-    };
-    private static buildQuerySchema;
-    serve: () => (request: Request) => Promise<Response>;
-    openapi: (highLevelSpec: {
-        info: {
-            version: string;
-            title: string;
-            description?: string;
-        };
-        servers?: Partial<Record<(`https://` | `http://`) | ({} & string), string>>;
-    }) => Router<ContextFrom, ContextTo, RequiredParams, R | Route<ContextTo, Response, "/openapi.json", RequiredParams, "GET", {}, never>>;
-    private readonly method;
-    get: <Result, Path extends string, Query extends AnyQuery = {}, Body = never>(path: Path, route: ((data: RouteRunData<ExtractRouteParams<Path> & RequiredParams, ContextTo, Query, Body>) => Result | Promise<Result>) | Omit<Route<ContextTo, Result, Path, RequiredParams, "GET", Query, Body>, "body" | "path" | "method" | "router">) => Router<ContextFrom, ContextTo, RequiredParams, R | Route<ContextTo, Result, Path, RequiredParams, "GET", Query, Body>>;
-    post: <Result, Path extends string, Query extends AnyQuery = {}, Body = never>(path: Path, route: ((data: RouteRunData<ExtractRouteParams<Path> & RequiredParams, ContextTo, Query, Body>) => Result | Promise<Result>) | Omit<Route<ContextTo, Result, Path, RequiredParams, "POST", Query, Body>, "path" | "method" | "router">) => Router<ContextFrom, ContextTo, RequiredParams, R | Route<ContextTo, Result, Path, RequiredParams, "POST", Query, Body>>;
-    put: <Result, Path extends string, Query extends AnyQuery = {}, Body = never>(path: Path, route: ((data: RouteRunData<ExtractRouteParams<Path> & RequiredParams, ContextTo, Query, Body>) => Result | Promise<Result>) | Omit<Route<ContextTo, Result, Path, RequiredParams, "PUT", Query, Body>, "path" | "method" | "router">) => Router<ContextFrom, ContextTo, RequiredParams, R | Route<ContextTo, Result, Path, RequiredParams, "PUT", Query, Body>>;
-    patch: <Result, Path extends string, Query extends AnyQuery = {}, Body = never>(path: Path, route: ((data: RouteRunData<ExtractRouteParams<Path> & RequiredParams, ContextTo, Query, Body>) => Result | Promise<Result>) | Omit<Route<ContextTo, Result, Path, RequiredParams, "PATCH", Query, Body>, "path" | "method" | "router">) => Router<ContextFrom, ContextTo, RequiredParams, R | Route<ContextTo, Result, Path, RequiredParams, "PATCH", Query, Body>>;
-    delete: <Result, Path extends string, Query extends AnyQuery = {}, Body = never>(path: Path, route: ((data: RouteRunData<ExtractRouteParams<Path> & RequiredParams, ContextTo, Query, Body>) => Result | Promise<Result>) | Omit<Route<ContextTo, Result, Path, RequiredParams, "DELETE", Query, Body>, "path" | "method" | "router">) => Router<ContextFrom, ContextTo, RequiredParams, R | Route<ContextTo, Result, Path, RequiredParams, "DELETE", Query, Body>>;
-    head: <Result, Path extends string, Query extends AnyQuery = {}, Body = never>(path: Path, route: ((data: RouteRunData<ExtractRouteParams<Path> & RequiredParams, ContextTo, Query, Body>) => Result | Promise<Result>) | Omit<Route<ContextTo, Result, Path, RequiredParams, "HEAD", Query, Body>, "path" | "method" | "router">) => Router<ContextFrom, ContextTo, RequiredParams, R | Route<ContextTo, Result, Path, RequiredParams, "HEAD", Query, Body>>;
-    options: <Result, Path extends string, Query extends AnyQuery = {}, Body = never>(path: Path, route: ((data: RouteRunData<ExtractRouteParams<Path> & RequiredParams, ContextTo, Query, Body>) => Result | Promise<Result>) | Omit<Route<ContextTo, Result, Path, RequiredParams, "OPTIONS", Query, Body>, "path" | "method" | "router">) => Router<ContextFrom, ContextTo, RequiredParams, R | Route<ContextTo, Result, Path, RequiredParams, "OPTIONS", Query, Body>>;
-    through: <NextContext>(through: (context: ContextTo, params: RequiredParams) => MaybePromise<NextContext>) => Router<ContextFrom, NextContext, RequiredParams, R>;
-}
+type InferRoutes<R extends Router<never, never, never, never, never>> = R extends Router<any, any, any, infer R extends AnyRoute, any> ? R : never;
+/**
+ * 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.
+ *
+ * @param req - The kaito request object, which contains the request method, url, headers, etc
+ * @param head - The kaito head object, which contains getters and setters for headers and status
+ * @returns The context for your routes
+ */
+type GetContext<Result, Input extends readonly unknown[]> = (req: KaitoRequest, head: KaitoHead, ...args: Input) => MaybePromise<Result>;
 
-type KaitoConfig<ContextFrom> = {
+type KaitoConfig<ContextFrom, Input extends readonly unknown[]> = {
     /**
      * A function that is called to get the context for a request.
      *
@@ -213,7 +206,7 @@ type KaitoConfig<ContextFrom> = {
      *
      * It's fine for this function to throw; if it does, the error is passed to the `onError` function.
      */
-    getContext?: GetContext<ContextFrom>;
+    getContext?: GetContext<ContextFrom, Input>;
     /**
      * A function that is called when an error occurs inside a route handler.
      *
@@ -263,14 +256,15 @@ type KaitoConfig<ContextFrom> = {
      */
     transform?: (req: Request, res: Response) => MaybePromise<Response | void | undefined>;
 };
+
 /**
- * Create a helper function for instantiating a Kaito router
+ * Helper function for instantiating a Kaito router
  *
  * This is the starting point for any Kaito application
  *
  * @param config - The configuration for the router
  * @returns A new Kaito router
  */
-declare function create<Context = null>(config?: KaitoConfig<Context>): Router<Context, Context, {}, never>;
+declare const create: <Context = null, Input extends readonly unknown[] = []>(config?: KaitoConfig<Context, Input>) => Router<Context, Context, never, never, Input>;
 
 export { type APIResponse, type AnyQuery, type AnyResponse, type AnyRoute, type ErroredAPIResponse, type ExtractRouteParams, type GetContext, type InferRoutes, type JSONOutputSpec, type KaitoConfig, KaitoError, KaitoHead, type KaitoMethod, KaitoRequest, type MakeOptional, type MaybePromise, type NotReadonly, type OutputSpec, type Route, type RouteRunData, Router, type RouterState, type SSEOutputSpec, type SuccessfulAPIResponse, type Through, WrappedError, create, isNodeLikeDev };

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { z, ZodTypeDef } from 'zod';
+import { z } from 'zod';
 import { KaitoSSEResponse } from './stream/stream.js';
 
 declare class WrappedError<T> extends Error {
@@ -72,55 +72,59 @@ declare class KaitoHead {
     get touched(): boolean;
 }
 
-/**
- * A helper to check if the environment is Node.js-like and the NODE_ENV is development
- */
-declare const isNodeLikeDev: boolean;
-type ErroredAPIResponse = {
-    success: false;
-    data: null;
-    message: string;
-};
-type SuccessfulAPIResponse<T> = {
-    success: true;
-    data: 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 MaybePromise<T> = T | Promise<T>;
-type KaitoMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'HEAD' | 'OPTIONS';
-type NotReadonly<T> = {
-    -readonly [K in keyof T]: T[K];
+type PrefixRoutesPathInner<R extends AnyRoute, Prefix extends `/${string}`> = R extends Route<infer ContextTo, infer Result, infer Path, infer AdditionalParams, infer Method, infer Query, infer BodyOutput> ? Route<ContextTo, Result, `${Prefix}${Path extends '/' ? '' : Path}`, AdditionalParams, Method, Query, BodyOutput> : never;
+type PrefixRoutesPath<Prefix extends `/${string}`, R extends AnyRoute> = R extends R ? PrefixRoutesPathInner<R, Prefix> : never;
+type RouterState<ContextFrom, ContextTo, RequiredParams extends string, Routes extends AnyRoute, Input extends readonly unknown[]> = {
+    routes: Set<Routes>;
+    through: (context: unknown, params: RequiredParams) => Promise<ContextTo>;
+    config: KaitoConfig<ContextFrom, Input>;
 };
-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;
-} : {};
-/**
- * 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.
- *
- * @param req - The kaito request object, which contains the request method, url, headers, etc
- * @param head - The kaito head object, which contains getters and setters for headers and status
- * @returns The context for your routes
- */
-type GetContext<Result> = (req: KaitoRequest, head: KaitoHead) => MaybePromise<Result>;
+declare class Router<ContextFrom, ContextTo, RequiredParams extends string, R extends AnyRoute, Input extends readonly unknown[]> {
+    private readonly state;
+    static create: <Context = null, Input_1 extends readonly unknown[] = []>(config?: KaitoConfig<Context, Input_1>) => Router<Context, Context, never, never, Input_1>;
+    protected constructor(state: RouterState<ContextFrom, ContextTo, RequiredParams, R, Input>);
+    get routes(): Set<R>;
+    private readonly add;
+    readonly params: [R] extends [never] ? <NextParams extends string>() => Router<ContextFrom, ContextTo, NextParams, R, Input> : 'router.params() can only be called before any routes are attached';
+    readonly merge: <PathPrefix extends `/${string}`, NextRequiredParams extends string, OtherRoutes extends AnyRoute>(pathPrefix: [NextRequiredParams] extends [ExtractRouteParams<PathPrefix> | RequiredParams] ? PathPrefix : `Missing ${Exclude<NextRequiredParams, ExtractRouteParams<PathPrefix> | RequiredParams>}`, other: Router<ContextFrom, unknown, NextRequiredParams, OtherRoutes, Input>) => Router<ContextFrom, ContextTo, RequiredParams, Extract<R | PrefixRoutesPath<PathPrefix, Extract<OtherRoutes, AnyRoute>>, AnyRoute>, Input>;
+    protected static getFindRoute: <R_1>(routes: Map<KaitoMethod, Map<string, R_1>>) => (method: KaitoMethod, path: string) => {
+        route?: never;
+        params?: never;
+    } | {
+        route: R_1;
+        params: Record<string, string>;
+    };
+    private static buildQuerySchema;
+    serve: () => (request: Request, ...args: Input) => Promise<Response>;
+    openapi: (highLevelSpec: {
+        info: {
+            version: string;
+            title: string;
+            description?: string;
+        };
+        servers?: Partial<Record<(`https://` | `http://`) | ({} & string), string>>;
+    }) => Router<ContextFrom, ContextTo, RequiredParams, R | Route<ContextTo, Response, "/openapi.json", RequiredParams, "GET", {}, never>, Input>;
+    private readonly method;
+    get: <Result, Path extends string, Query extends AnyQuery = {}, Body = never>(path: Path, route: ((data: RouteRunData<RequiredParams | ExtractRouteParams<Path>, ContextTo, Query, Body>) => Result | Promise<Result>) | Omit<Route<ContextTo, Result, Path, RequiredParams, "GET", Query, Body>, "body" | "path" | "method" | "router">) => Router<ContextFrom, ContextTo, RequiredParams, R | Route<ContextTo, Result, Path, RequiredParams, "GET", Query, Body>, Input>;
+    post: <Result, Path extends string, Query extends AnyQuery = {}, Body = never>(path: Path, route: ((data: RouteRunData<RequiredParams | ExtractRouteParams<Path>, ContextTo, Query, Body>) => Result | Promise<Result>) | Omit<Route<ContextTo, Result, Path, RequiredParams, "POST", Query, Body>, "path" | "method" | "router">) => Router<ContextFrom, ContextTo, RequiredParams, R | Route<ContextTo, Result, Path, RequiredParams, "POST", Query, Body>, Input>;
+    put: <Result, Path extends string, Query extends AnyQuery = {}, Body = never>(path: Path, route: ((data: RouteRunData<RequiredParams | ExtractRouteParams<Path>, ContextTo, Query, Body>) => Result | Promise<Result>) | Omit<Route<ContextTo, Result, Path, RequiredParams, "PUT", Query, Body>, "path" | "method" | "router">) => Router<ContextFrom, ContextTo, RequiredParams, R | Route<ContextTo, Result, Path, RequiredParams, "PUT", Query, Body>, Input>;
+    patch: <Result, Path extends string, Query extends AnyQuery = {}, Body = never>(path: Path, route: ((data: RouteRunData<RequiredParams | ExtractRouteParams<Path>, ContextTo, Query, Body>) => Result | Promise<Result>) | Omit<Route<ContextTo, Result, Path, RequiredParams, "PATCH", Query, Body>, "path" | "method" | "router">) => Router<ContextFrom, ContextTo, RequiredParams, R | Route<ContextTo, Result, Path, RequiredParams, "PATCH", Query, Body>, Input>;
+    delete: <Result, Path extends string, Query extends AnyQuery = {}, Body = never>(path: Path, route: ((data: RouteRunData<RequiredParams | ExtractRouteParams<Path>, ContextTo, Query, Body>) => Result | Promise<Result>) | Omit<Route<ContextTo, Result, Path, RequiredParams, "DELETE", Query, Body>, "path" | "method" | "router">) => Router<ContextFrom, ContextTo, RequiredParams, R | Route<ContextTo, Result, Path, RequiredParams, "DELETE", Query, Body>, Input>;
+    head: <Result, Path extends string, Query extends AnyQuery = {}, Body = never>(path: Path, route: ((data: RouteRunData<RequiredParams | ExtractRouteParams<Path>, ContextTo, Query, Body>) => Result | Promise<Result>) | Omit<Route<ContextTo, Result, Path, RequiredParams, "HEAD", Query, Body>, "path" | "method" | "router">) => Router<ContextFrom, ContextTo, RequiredParams, R | Route<ContextTo, Result, Path, RequiredParams, "HEAD", Query, Body>, Input>;
+    options: <Result, Path extends string, Query extends AnyQuery = {}, Body = never>(path: Path, route: ((data: RouteRunData<RequiredParams | ExtractRouteParams<Path>, ContextTo, Query, Body>) => Result | Promise<Result>) | Omit<Route<ContextTo, Result, Path, RequiredParams, "OPTIONS", Query, Body>, "path" | "method" | "router">) => Router<ContextFrom, ContextTo, RequiredParams, R | Route<ContextTo, Result, Path, RequiredParams, "OPTIONS", Query, Body>, Input>;
+    through: <NextContext>(through: (context: ContextTo, params: RequiredParams) => MaybePromise<NextContext>) => Router<ContextFrom, NextContext, RequiredParams, R, Input>;
+}
 
-type RouteRunData<Params, Context, QueryOutput, BodyOutput> = {
+type RouteRunData<Params extends string, Context, QueryOutput, BodyOutput> = {
+    params: Record<Params, string>;
     ctx: Context;
-    body: BodyOutput;
     query: QueryOutput;
-    params: Params;
+    body: BodyOutput;
 };
 type AnyQuery = {
     [key in string]: any;
 };
-type Through<From, To, RequiredParams extends Record<string, unknown>> = (context: From, params: RequiredParams) => Promise<To>;
+type Through<From, To, RequiredParams extends string> = (context: From, params: Record<RequiredParams, string>) => Promise<To>;
 type SSEOutputSpec<Result> = {
     type: 'sse';
     schema: z.Schema<Result>;
@@ -135,7 +139,7 @@ type OutputSpec<Result> = {
     description?: string;
     body: NoInfer<Result extends KaitoSSEResponse<infer R> ? SSEOutputSpec<R> : JSONOutputSpec<Result>>;
 };
-type Route<ContextTo, Result, Path extends string, AdditionalParams extends Record<string, unknown>, Method extends KaitoMethod, Query, Body> = {
+type Route<ContextTo, Result, Path extends string, AdditionalParams extends string, Method extends KaitoMethod, Query, Body> = {
     body?: z.Schema<Body>;
     query?: {
         [Key in keyof Query]: z.Schema<Query[Key]>;
@@ -143,19 +147,33 @@ type Route<ContextTo, Result, Path extends string, AdditionalParams extends Reco
     path: Path;
     method: Method;
     openapi?: OutputSpec<NoInfer<Result>>;
-    router: Router<unknown, ContextTo, AdditionalParams, AnyRoute>;
-    run(data: RouteRunData<ExtractRouteParams<Path> & AdditionalParams, ContextTo, Query, Body>): Promise<Result> | Result;
+    router: Router<unknown, ContextTo, AdditionalParams, AnyRoute, any>;
+    run(data: RouteRunData<ExtractRouteParams<Path> | AdditionalParams, ContextTo, Query, Body>): Promise<Result> | Result;
 };
 type AnyRoute = Route<any, any, any, any, any, any, any>;
 
-type PrefixRoutesPathInner<R extends AnyRoute, Prefix extends `/${string}`> = R extends Route<infer ContextTo, infer Result, infer Path, infer AdditionalParams, infer Method, infer Query, infer BodyOutput> ? Route<ContextTo, Result, `${Prefix}${Path extends '/' ? '' : Path}`, AdditionalParams, Method, Query, BodyOutput> : never;
-type PrefixRoutesPath<Prefix extends `/${string}`, R extends AnyRoute> = R extends R ? PrefixRoutesPathInner<R, Prefix> : never;
-type RouterState<ContextFrom, ContextTo, RequiredParams extends Record<string, unknown>, Routes extends AnyRoute> = {
-    routes: Set<Routes>;
-    through: (context: unknown, params: RequiredParams) => Promise<ContextTo>;
-    config: KaitoConfig<ContextFrom>;
-    paramsSchema: z.Schema<RequiredParams> | null;
+/**
+ * A helper to check if the environment is Node.js-like and the `NODE_ENV` environment variable is set to `'development'`
+ */
+declare const isNodeLikeDev: boolean;
+type ErroredAPIResponse = {
+    success: false;
+    data: null;
+    message: string;
 };
+type SuccessfulAPIResponse<T> = {
+    success: true;
+    data: 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 MaybePromise<T> = T | Promise<T>;
+type KaitoMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'HEAD' | 'OPTIONS';
+type NotReadonly<T> = {
+    -readonly [K in keyof T]: T[K];
+};
+type ExtractRouteParams<T extends string> = string extends T ? string : T extends `${string}:${infer Param}/${infer Rest}` ? Param | ExtractRouteParams<Rest> : T extends `${string}:${infer Param}` ? Param : never;
 /**
  * Accepts a router instance, and returns a union of all the routes in the router
  *
@@ -166,46 +184,21 @@ type RouterState<ContextFrom, ContextTo, RequiredParams extends Record<string, u
  * type Routes = InferRoutes<typeof app>;
  * ```
  */
-type InferRoutes<R extends Router<any, any, any, any>> = R extends Router<any, any, any, infer R extends AnyRoute> ? R : never;
-declare class Router<ContextFrom, ContextTo, RequiredParams extends Record<string, unknown>, R extends AnyRoute> {
-    private readonly state;
-    static create: <Context>(config: KaitoConfig<Context>) => Router<Context, Context, {}, never>;
-    protected constructor(state: RouterState<ContextFrom, ContextTo, RequiredParams, R>);
-    get routes(): Set<R>;
-    private add;
-    params: this extends Router<infer ContextFrom, infer ContextTo, infer Params extends Record<string, unknown>, infer R extends AnyRoute> ? [keyof Params] extends [never] ? <NextParams extends Record<string, unknown> = {}>(spec: {
-        [Key in keyof NextParams]: z.ZodType<NextParams[Key], ZodTypeDef, string>;
-    }) => Router<ContextFrom, ContextTo, NextParams, R> : 'You cannot define params() on a router that has already had params defined, as routes that already consume params can break.' : never;
-    readonly merge: <PathPrefix extends `/${string}`, NextRequiredParams extends Record<string, unknown>, OtherRoutes extends AnyRoute>(pathPrefix: keyof NextRequiredParams extends keyof ExtractRouteParams<PathPrefix> | keyof RequiredParams ? PathPrefix : `Missing ${Exclude<Extract<keyof NextRequiredParams, string>, keyof RequiredParams>}${string}`, other: Router<ContextFrom, unknown, NextRequiredParams, OtherRoutes>) => Router<ContextFrom, ContextTo, RequiredParams, Extract<R | PrefixRoutesPath<PathPrefix, Extract<OtherRoutes, AnyRoute>>, AnyRoute>>;
-    protected static getFindRoute: <R_1>(routes: Map<KaitoMethod, Map<string, R_1>>) => (method: KaitoMethod, path: string) => {
-        route?: never;
-        params?: never;
-    } | {
-        route: R_1;
-        params: Record<string, string>;
-    };
-    private static buildQuerySchema;
-    serve: () => (request: Request) => Promise<Response>;
-    openapi: (highLevelSpec: {
-        info: {
-            version: string;
-            title: string;
-            description?: string;
-        };
-        servers?: Partial<Record<(`https://` | `http://`) | ({} & string), string>>;
-    }) => Router<ContextFrom, ContextTo, RequiredParams, R | Route<ContextTo, Response, "/openapi.json", RequiredParams, "GET", {}, never>>;
-    private readonly method;
-    get: <Result, Path extends string, Query extends AnyQuery = {}, Body = never>(path: Path, route: ((data: RouteRunData<ExtractRouteParams<Path> & RequiredParams, ContextTo, Query, Body>) => Result | Promise<Result>) | Omit<Route<ContextTo, Result, Path, RequiredParams, "GET", Query, Body>, "body" | "path" | "method" | "router">) => Router<ContextFrom, ContextTo, RequiredParams, R | Route<ContextTo, Result, Path, RequiredParams, "GET", Query, Body>>;
-    post: <Result, Path extends string, Query extends AnyQuery = {}, Body = never>(path: Path, route: ((data: RouteRunData<ExtractRouteParams<Path> & RequiredParams, ContextTo, Query, Body>) => Result | Promise<Result>) | Omit<Route<ContextTo, Result, Path, RequiredParams, "POST", Query, Body>, "path" | "method" | "router">) => Router<ContextFrom, ContextTo, RequiredParams, R | Route<ContextTo, Result, Path, RequiredParams, "POST", Query, Body>>;
-    put: <Result, Path extends string, Query extends AnyQuery = {}, Body = never>(path: Path, route: ((data: RouteRunData<ExtractRouteParams<Path> & RequiredParams, ContextTo, Query, Body>) => Result | Promise<Result>) | Omit<Route<ContextTo, Result, Path, RequiredParams, "PUT", Query, Body>, "path" | "method" | "router">) => Router<ContextFrom, ContextTo, RequiredParams, R | Route<ContextTo, Result, Path, RequiredParams, "PUT", Query, Body>>;
-    patch: <Result, Path extends string, Query extends AnyQuery = {}, Body = never>(path: Path, route: ((data: RouteRunData<ExtractRouteParams<Path> & RequiredParams, ContextTo, Query, Body>) => Result | Promise<Result>) | Omit<Route<ContextTo, Result, Path, RequiredParams, "PATCH", Query, Body>, "path" | "method" | "router">) => Router<ContextFrom, ContextTo, RequiredParams, R | Route<ContextTo, Result, Path, RequiredParams, "PATCH", Query, Body>>;
-    delete: <Result, Path extends string, Query extends AnyQuery = {}, Body = never>(path: Path, route: ((data: RouteRunData<ExtractRouteParams<Path> & RequiredParams, ContextTo, Query, Body>) => Result | Promise<Result>) | Omit<Route<ContextTo, Result, Path, RequiredParams, "DELETE", Query, Body>, "path" | "method" | "router">) => Router<ContextFrom, ContextTo, RequiredParams, R | Route<ContextTo, Result, Path, RequiredParams, "DELETE", Query, Body>>;
-    head: <Result, Path extends string, Query extends AnyQuery = {}, Body = never>(path: Path, route: ((data: RouteRunData<ExtractRouteParams<Path> & RequiredParams, ContextTo, Query, Body>) => Result | Promise<Result>) | Omit<Route<ContextTo, Result, Path, RequiredParams, "HEAD", Query, Body>, "path" | "method" | "router">) => Router<ContextFrom, ContextTo, RequiredParams, R | Route<ContextTo, Result, Path, RequiredParams, "HEAD", Query, Body>>;
-    options: <Result, Path extends string, Query extends AnyQuery = {}, Body = never>(path: Path, route: ((data: RouteRunData<ExtractRouteParams<Path> & RequiredParams, ContextTo, Query, Body>) => Result | Promise<Result>) | Omit<Route<ContextTo, Result, Path, RequiredParams, "OPTIONS", Query, Body>, "path" | "method" | "router">) => Router<ContextFrom, ContextTo, RequiredParams, R | Route<ContextTo, Result, Path, RequiredParams, "OPTIONS", Query, Body>>;
-    through: <NextContext>(through: (context: ContextTo, params: RequiredParams) => MaybePromise<NextContext>) => Router<ContextFrom, NextContext, RequiredParams, R>;
-}
+type InferRoutes<R extends Router<never, never, never, never, never>> = R extends Router<any, any, any, infer R extends AnyRoute, any> ? R : never;
+/**
+ * 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.
+ *
+ * @param req - The kaito request object, which contains the request method, url, headers, etc
+ * @param head - The kaito head object, which contains getters and setters for headers and status
+ * @returns The context for your routes
+ */
+type GetContext<Result, Input extends readonly unknown[]> = (req: KaitoRequest, head: KaitoHead, ...args: Input) => MaybePromise<Result>;
 
-type KaitoConfig<ContextFrom> = {
+type KaitoConfig<ContextFrom, Input extends readonly unknown[]> = {
     /**
      * A function that is called to get the context for a request.
      *
@@ -213,7 +206,7 @@ type KaitoConfig<ContextFrom> = {
      *
      * It's fine for this function to throw; if it does, the error is passed to the `onError` function.
      */
-    getContext?: GetContext<ContextFrom>;
+    getContext?: GetContext<ContextFrom, Input>;
     /**
      * A function that is called when an error occurs inside a route handler.
      *
@@ -263,14 +256,15 @@ type KaitoConfig<ContextFrom> = {
      */
     transform?: (req: Request, res: Response) => MaybePromise<Response | void | undefined>;
 };
+
 /**
- * Create a helper function for instantiating a Kaito router
+ * Helper function for instantiating a Kaito router
  *
  * This is the starting point for any Kaito application
  *
  * @param config - The configuration for the router
  * @returns A new Kaito router
  */
-declare function create<Context = null>(config?: KaitoConfig<Context>): Router<Context, Context, {}, never>;
+declare const create: <Context = null, Input extends readonly unknown[] = []>(config?: KaitoConfig<Context, Input>) => Router<Context, Context, never, never, Input>;
 
 export { type APIResponse, type AnyQuery, type AnyResponse, type AnyRoute, type ErroredAPIResponse, type ExtractRouteParams, type GetContext, type InferRoutes, type JSONOutputSpec, type KaitoConfig, KaitoError, KaitoHead, type KaitoMethod, KaitoRequest, type MakeOptional, type MaybePromise, type NotReadonly, type OutputSpec, type Route, type RouteRunData, Router, type RouterState, type SSEOutputSpec, type SuccessfulAPIResponse, type Through, WrappedError, create, isNodeLikeDev };

package/dist/index.js

@@ -117,12 +117,13 @@ var isNodeLikeDev = typeof process !== "undefined" && typeof process.env !== "un
 // src/router/router.ts
 var Router = class _Router {
   state;
-  static create = (config) => new _Router({
-    through: async (context) => context,
-    routes: /* @__PURE__ */ new Set(),
-    config,
-    paramsSchema: null
-  });
+  static create = (config = {}) => {
+    return new _Router({
+      through: async (context) => context,
+      routes: /* @__PURE__ */ new Set(),
+      config
+    });
+  };
   constructor(state) {
     this.state = state;
   }
@@ -141,10 +142,7 @@ var Router = class _Router {
       routes: /* @__PURE__ */ new Set([...this.state.routes, merged])
     });
   };
-  params = (spec) => new _Router({
-    ...this.state,
-    paramsSchema: z.object(spec)
-  });
+  params = () => this;
   merge = (pathPrefix, other) => {
     const newRoutes = [...other.state.routes].map((route) => ({
       ...route,
@@ -205,7 +203,7 @@ var Router = class _Router {
       });
     }
     const findRoute = _Router.getFindRoute(methodToRoutesMap);
-    const handle = async (req) => {
+    const handle = async (req, ...args) => {
       const url = new URL(req.url);
       const method = req.method;
       const { route, params: rawParams } = findRoute(method, url.pathname);
@@ -222,16 +220,15 @@ var Router = class _Router {
       try {
         const body = route.body ? await route.body.parseAsync(await req.json()) : void 0;
         const query = route.fastQuerySchema ? await route.fastQuerySchema.parseAsync(url.searchParams) : {};
-        const params = route.router.state.paramsSchema ? route.router.state.paramsSchema.parse(rawParams) : rawParams;
         const ctx = await route.router.state.through(
-          await this.state.config.getContext?.(request, head) ?? null,
-          params
+          await this.state.config.getContext?.(request, head, ...args) ?? null,
+          rawParams
         );
         const result = await route.run({
           ctx,
           body,
           query,
-          params
+          params: rawParams
         });
         if (result instanceof Response) {
           if (isNodeLikeDev) {
@@ -285,7 +282,7 @@ var Router = class _Router {
         }
       }
     };
-    return async (request) => {
+    return async (request, ...args) => {
       if (this.state.config.before) {
         const result = await this.state.config.before(request);
         if (result instanceof Response) {
@@ -298,7 +295,7 @@ var Router = class _Router {
           return result;
         }
       }
-      const response = await handle(request);
+      const response = await handle(request, ...args);
       if (this.state.config.transform) {
         const transformed = await this.state.config.transform(request, response);
         if (transformed instanceof Response) {
@@ -399,10 +396,8 @@ var Router = class _Router {
   };
 };
 
-// src/create.ts
-function create(config = {}) {
-  return Router.create(config);
-}
+// src/index.ts
+var create = Router.create;
 export {
   KaitoError,
   KaitoHead,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kaito-http/core",
-  "version": "4.0.0-beta.10",
+  "version": "4.0.0-beta.12",
   "author": "Alistair Smith <hi@alistair.sh>",
   "repository": "https://github.com/kaito-http/kaito",
   "devDependencies": {