@aura-stack/router 0.2.0 → 0.4.0

package/dist/router.cjs

@@ -20,16 +20,13 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/router.ts
 var router_exports = {};
 __export(router_exports, {
-  createRouter: () => createRouter
+  createNode: () => createNode,
+  createRouter: () => createRouter,
+  insert: () => insert,
+  search: () => search
 });
 module.exports = __toCommonJS(router_exports);
 
-// src/assert.ts
-var supportedBodyMethods = /* @__PURE__ */ new Set(["POST", "PUT", "PATCH"]);
-var isSupportedBodyMethod = (method) => {
-  return supportedBodyMethods.has(method);
-};
-
 // src/error.ts
 var statusCode = {
   OK: 200,
@@ -57,50 +54,90 @@ var statusCode = {
   SERVICE_UNAVAILABLE: 503,
   HTTP_VERSION_NOT_SUPPORTED: 505
 };
-var statusText = Object.entries(statusCode).reduce(
-  (previous, [status, code]) => {
-    return { ...previous, [code]: status };
+var statusText = Object.keys(statusCode).reduce(
+  (previous, status) => {
+    return { ...previous, [status]: status };
   },
   {}
 );
 var AuraStackRouterError = class extends Error {
   constructor(type, message, name) {
     super(message);
-    this.name = name ?? "AuraStackRouterError";
+    this.name = name ?? "RouterError";
     this.status = statusCode[type];
-    this.statusText = statusText[this.status];
+    this.statusText = statusText[type];
+  }
+};
+var RouterError = class extends AuraStackRouterError {
+  constructor(type, message, name) {
+    super(type, message, name);
+    this.name = name ?? "RouterError";
   }
 };
 
-// src/endpoint.ts
-var createRoutePattern = (route) => {
-  const pattern = route.replace(/:[^/]+/g, "([^/]+)").replace(/\//g, "\\/");
-  return new RegExp(`^${pattern}$`);
+// src/assert.ts
+var supportedMethods = /* @__PURE__ */ new Set(["GET", "POST", "DELETE", "PUT", "PATCH", "OPTIONS", "HEAD", "TRACE", "CONNECT"]);
+var supportedBodyMethods = /* @__PURE__ */ new Set(["POST", "PUT", "PATCH"]);
+var isSupportedMethod = (method) => {
+  return supportedMethods.has(method);
+};
+var isSupportedBodyMethod = (method) => {
+  return supportedBodyMethods.has(method);
+};
+var isRouterError = (error) => {
+  return error instanceof RouterError;
+};
+
+// src/middlewares.ts
+var executeGlobalMiddlewares = async (context, middlewares) => {
+  if (!middlewares) return context;
+  for (const middleware of middlewares) {
+    if (typeof middleware !== "function") {
+      throw new RouterError("BAD_REQUEST", "Global middlewares must be functions");
+    }
+    const executed = await middleware(context);
+    if (executed instanceof Response) {
+      return executed;
+    }
+    context = executed;
+  }
+  if (!context || !(context.request instanceof Request)) {
+    throw new RouterError("BAD_REQUEST", "Global middleware must return a Request or Response object");
+  }
+  return context;
+};
+var executeMiddlewares = async (context, middlewares = []) => {
+  try {
+    let ctx = context;
+    for (const middleware of middlewares) {
+      if (typeof middleware !== "function") {
+        throw new RouterError("BAD_REQUEST", "Middleware must be a function");
+      }
+      ctx = await middleware(ctx);
+    }
+    return ctx;
+  } catch {
+    throw new RouterError("BAD_REQUEST", "Handler threw an error");
+  }
 };
 
 // src/context.ts
-var getRouteParams = (route, path) => {
-  const routeRegex = createRoutePattern(route);
-  if (!routeRegex.test(path)) {
-    throw new AuraStackRouterError("BAD_REQUEST", `Missing required route params for route: ${route}`);
-  }
-  const params = routeRegex.exec(route)?.slice(1).map((seg) => seg.replace(":", ""));
-  if (!params) return {};
-  const values = routeRegex.exec(path)?.slice(1);
-  return params.reduce(
-    (previous, now, idx) => ({
-      ...previous,
-      [now]: decodeURIComponent(values?.[idx] ?? "")
-    }),
-    {}
-  );
+var getRouteParams = (params, config) => {
+  if (config.schemas?.params) {
+    const parsed = config.schemas.params.safeParse(params);
+    if (!parsed.success) {
+      throw new RouterError("UNPROCESSABLE_ENTITY", "Invalid route parameters");
+    }
+    return parsed.data;
+  }
+  return params;
 };
 var getSearchParams = (url, config) => {
   const route = new URL(url);
   if (config.schemas?.searchParams) {
     const parsed = config.schemas.searchParams.safeParse(Object.fromEntries(route.searchParams.entries()));
     if (!parsed.success) {
-      throw new AuraStackRouterError("UNPROCESSABLE_ENTITY", "Invalid search parameters");
+      throw new RouterError("UNPROCESSABLE_ENTITY", "Invalid search parameters");
     }
     return parsed.data;
   }
@@ -111,120 +148,171 @@ var getHeaders = (request) => {
 };
 var getBody = async (request, config) => {
   if (!isSupportedBodyMethod(request.method)) {
-    return void 0;
+    return null;
   }
-  const contentType = request.headers.get("Content-Type") ?? "";
-  if (contentType.includes("application/json")) {
-    const json = await request.json();
+  const clone = request.clone();
+  const contentType = clone.headers.get("Content-Type") ?? "";
+  if (contentType.includes("application/json") || config.schemas?.body) {
+    const json = await clone.json();
     if (config.schemas?.body) {
       const parsed = config.schemas.body.safeParse(json);
       if (!parsed.success) {
-        throw new AuraStackRouterError("UNPROCESSABLE_ENTITY", "Invalid request body");
+        throw new RouterError("UNPROCESSABLE_ENTITY", "Invalid request body");
       }
       return parsed.data;
     }
     return json;
   }
-  if (contentType.includes("application/x-www-form-urlencoded") || contentType.includes("multipart/form-data")) {
-    return await request.formData();
-  }
-  if (contentType.includes("text/")) {
-    return await request.text();
+  try {
+    if (createContentTypeRegex(["application/x-www-form-urlencoded", "multipart/form-data"], contentType)) {
+      return await clone.formData();
+    }
+    if (createContentTypeRegex(["text/", "application/xml"], contentType)) {
+      return await clone.text();
+    }
+    if (createContentTypeRegex(["application/octet-stream"], contentType)) {
+      return await clone.arrayBuffer();
+    }
+    if (createContentTypeRegex(["image/", "video/", "audio/", "application/pdf"], contentType)) {
+      return await clone.blob();
+    }
+    return null;
+  } catch {
+    throw new RouterError("UNPROCESSABLE_ENTITY", "Invalid request body, the content-type does not match the body format");
   }
-  if (contentType.includes("application/octet-stream")) {
-    return await request.arrayBuffer();
+};
+var createContentTypeRegex = (contentTypes, contenType) => {
+  const regex = new RegExp(`${contentTypes.join("|")}`);
+  return regex.test(contenType);
+};
+
+// src/router.ts
+var createNode = () => ({
+  statics: /* @__PURE__ */ new Map(),
+  endpoints: /* @__PURE__ */ new Map()
+});
+var insert = (root, endpoint) => {
+  if (!root || !endpoint) return;
+  let node = root;
+  const segments = endpoint.route === "/" ? [] : endpoint.route.split("/").filter(Boolean);
+  for (const segment of segments) {
+    if (segment.startsWith(":")) {
+      const name = segment.slice(1);
+      if (!node.param) {
+        node.param = { name, node: createNode() };
+      } else if (node.param.name !== name) {
+        throw new RouterError(
+          "BAD_REQUEST",
+          `Conflicting in the route by the dynamic segment "${node.param.name}" and "${name}"`
+        );
+      }
+      node = node.param.node;
+    } else {
+      if (!node.statics.has(segment)) {
+        node.statics.set(segment, createNode());
+      }
+      node = node.statics.get(segment);
+    }
   }
-  if (contentType.includes("image/") || contentType.includes("video/") || contentType.includes("audio/")) {
-    return await request.blob();
+  if (node.endpoints.has(endpoint.method)) {
+    throw new RouterError("BAD_REQUEST", `Duplicate endpoint for ${endpoint?.method} ${endpoint?.route}`);
   }
-  return null;
+  node.endpoints.set(endpoint.method, endpoint);
 };
-
-// src/middlewares.ts
-var executeGlobalMiddlewares = async (request, middlewares) => {
-  if (!middlewares) return request;
-  for (const middleware of middlewares) {
-    if (typeof middleware !== "function") {
-      throw new AuraStackRouterError("BAD_REQUEST", "Global middlewares must be functions");
+var search = (method, root, pathname) => {
+  let node = root;
+  const params = {};
+  const segments = pathname === "/" ? [] : pathname.split("/").filter(Boolean);
+  for (const segment of segments) {
+    if (node?.statics.has(segment)) {
+      node = node.statics.get(segment);
+    } else if (node?.param) {
+      params[node.param.name] = decodeURIComponent(segment);
+      node = node.param.node;
+    } else {
+      throw new RouterError("NOT_FOUND", `No route found for path: ${pathname}`);
     }
-    const executed = await middleware(request);
-    if (executed instanceof Response) {
-      return executed;
+  }
+  if (!node.endpoints.has(method)) {
+    throw new RouterError("NOT_FOUND", `No route found for path: ${pathname}`);
+  }
+  return { endpoint: node.endpoints.get(method), params };
+};
+var handleError = async (error, request, config) => {
+  if (config.onError) {
+    try {
+      const response = await config.onError(error, request);
+      return response;
+    } catch {
+      return Response.json(
+        { message: "A critical failure occurred during error handling" },
+        { status: 500, statusText: statusText.INTERNAL_SERVER_ERROR }
+      );
     }
-    request = executed;
   }
-  if (!request || !(request instanceof Request)) {
-    throw new AuraStackRouterError("BAD_REQUEST", "Global middleware must return a Request or Response object");
+  if (isRouterError(error)) {
+    const { message, status, statusText: statusText2 } = error;
+    return Response.json({ message }, { status, statusText: statusText2 });
   }
-  return request;
+  return Response.json({ message: "Internal Server Error" }, { status: 500, statusText: statusText.INTERNAL_SERVER_ERROR });
 };
-var executeMiddlewares = async (request, context, middlewares = []) => {
+var handleRequest = async (method, request, config, root) => {
   try {
-    let ctx = context;
-    for (const middleware of middlewares) {
-      if (typeof middleware !== "function") {
-        throw new AuraStackRouterError("BAD_REQUEST", "Middleware must be a function");
-      }
-      ctx = await middleware(request, ctx);
+    if (!isSupportedMethod(request.method)) {
+      throw new RouterError("METHOD_NOT_ALLOWED", `The HTTP method '${request.method}' is not supported`);
     }
-    return ctx;
-  } catch {
-    throw new AuraStackRouterError("BAD_REQUEST", "Handler threw an error");
+    const globalContext = { request, context: config.context ?? {} };
+    const globalRequestContext = await executeGlobalMiddlewares(globalContext, config.middlewares);
+    if (globalRequestContext instanceof Response) return globalRequestContext;
+    const url = new URL(globalRequestContext.request.url);
+    const pathnameWithBase = url.pathname;
+    if (globalRequestContext.request.method !== method) {
+      throw new RouterError("METHOD_NOT_ALLOWED", `The HTTP method '${globalRequestContext.request.method}' is not allowed`);
+    }
+    const { endpoint, params } = search(method, root, pathnameWithBase);
+    if (endpoint.method !== globalRequestContext.request.method) {
+      throw new RouterError("METHOD_NOT_ALLOWED", `The HTTP method '${globalRequestContext.request.method}' is not allowed`);
+    }
+    const dynamicParams = getRouteParams(params, endpoint.config);
+    const body = await getBody(globalRequestContext.request, endpoint.config);
+    const searchParams = getSearchParams(globalRequestContext.request.url, endpoint.config);
+    const headers = getHeaders(globalRequestContext.request);
+    let context = {
+      params: dynamicParams,
+      searchParams,
+      headers,
+      body,
+      request: globalRequestContext.request,
+      url,
+      method: globalRequestContext.request.method,
+      route: endpoint.route,
+      context: config.context ?? {}
+    };
+    context = await executeMiddlewares(context, endpoint.config.middlewares);
+    const response = await endpoint.handler(context);
+    return response;
+  } catch (error) {
+    return handleError(error, request, config);
   }
 };
-
-// src/router.ts
 var createRouter = (endpoints, config = {}) => {
+  const root = createNode();
   const server = {};
-  const groups = /* @__PURE__ */ new Map();
+  const methods = /* @__PURE__ */ new Set();
   for (const endpoint of endpoints) {
-    if (!groups.has(endpoint.method)) {
-      groups.set(endpoint.method, []);
-    }
-    groups.get(endpoint.method)?.push(endpoint);
-  }
-  for (const method of groups.keys()) {
-    server[method] = async (request) => {
-      try {
-        const globalRequest = await executeGlobalMiddlewares(request, config.middlewares);
-        if (globalRequest instanceof Response) {
-          return globalRequest;
-        }
-        const url = new URL(globalRequest.url);
-        const pathname = url.pathname;
-        const endpoint = groups.get(method)?.find((endpoint2) => {
-          const withBasePath = config.basePath ? `${config.basePath}${endpoint2.route}` : endpoint2.route;
-          const regex = createRoutePattern(withBasePath);
-          return regex.test(pathname);
-        });
-        if (endpoint) {
-          const withBasePath = config.basePath ? `${config.basePath}${endpoint.route}` : endpoint.route;
-          const body = await getBody(globalRequest, endpoint.config);
-          const params = getRouteParams(withBasePath, pathname);
-          const searchParams = getSearchParams(globalRequest.url, endpoint.config);
-          const headers = getHeaders(globalRequest);
-          const context = {
-            params,
-            searchParams,
-            headers,
-            body
-          };
-          await executeMiddlewares(globalRequest, context, endpoint.config.middlewares);
-          return endpoint.handler(globalRequest, context);
-        }
-        return Response.json({ message: "Not Found" }, { status: 404 });
-      } catch (error) {
-        if (error instanceof AuraStackRouterError) {
-          const { message, status, statusText: statusText2 } = error;
-          return Response.json({ message }, { status, statusText: statusText2 });
-        }
-        return Response.json({ message: "Internal Server Error" }, { status: 500 });
-      }
-    };
+    const withBasePath = config.basePath ? `${config.basePath}${endpoint.route}` : endpoint.route;
+    insert(root, { ...endpoint, route: withBasePath });
+    methods.add(endpoint.method);
+  }
+  for (const method of methods) {
+    server[method] = (request) => handleRequest(method, request, config, root);
   }
   return server;
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  createRouter
+  createNode,
+  createRouter,
+  insert,
+  search
 });

package/dist/router.d.ts

@@ -1,6 +1,28 @@
-import { RouteEndpoint, RouterConfig, GetHttpHandlers } from './types.js';
+import { RouteEndpoint, RouterConfig, GetHttpHandlers, HTTPMethod, RoutePattern, EndpointSchemas, MiddlewareFunction } from './types.js';
 import 'zod';
+import './error.js';
 
+interface TrieNode {
+    statics: Map<string, TrieNode>;
+    param?: {
+        name: string;
+        node: TrieNode;
+    };
+    endpoints: Map<HTTPMethod, RouteEndpoint>;
+}
+declare const createNode: () => TrieNode;
+declare const insert: (root: TrieNode, endpoint: RouteEndpoint) => void;
+declare const search: (method: HTTPMethod, root: TrieNode, pathname: string) => {
+    endpoint: RouteEndpoint<HTTPMethod, RoutePattern, {
+        schemas?: EndpointSchemas | undefined;
+        middlewares?: MiddlewareFunction<{} | {
+            [x: string]: string;
+        }, {
+            schemas: EndpointSchemas;
+        }>[] | undefined;
+    }>;
+    params: Record<string, string>;
+};
 /**
  * Creates the entry point for the server, handling the endpoints defined in the router.
  * It groups endpoints by HTTP method and matches incoming requests to the appropriate endpoint.
@@ -12,4 +34,4 @@ import 'zod';
  */
 declare const createRouter: <const Endpoints extends RouteEndpoint[]>(endpoints: Endpoints, config?: RouterConfig) => GetHttpHandlers<Endpoints>;
 
-export { createRouter };
+export { createNode, createRouter, insert, search };

package/dist/router.js

@@ -1,11 +1,16 @@
 import {
-  createRouter
-} from "./chunk-DR4C6QTF.js";
-import "./chunk-OXDCFAMF.js";
-import "./chunk-YUX3YHXF.js";
-import "./chunk-JRJKKBSH.js";
-import "./chunk-O6SY753N.js";
-import "./chunk-RFYOPPMW.js";
+  createNode,
+  createRouter,
+  insert,
+  search
+} from "./chunk-CL5D7UJU.js";
+import "./chunk-PT4GU6PH.js";
+import "./chunk-JNMXLKDG.js";
+import "./chunk-CFAIW6YL.js";
+import "./chunk-GJC3ODME.js";
 export {
-  createRouter
+  createNode,
+  createRouter,
+  insert,
+  search
 };

package/dist/types.d.ts

@@ -1,4 +1,5 @@
 import { ZodObject, z } from 'zod';
+import { RouterError } from './error.js';
 
 /**
  * Route pattern must start with a slash and can contain parameters prefixed with a colon.
@@ -8,13 +9,14 @@ import { ZodObject, z } from 'zod';
  */
 type RoutePattern = `/${string}` | `/${string}/:${string}`;
 /**
- * HTTP methods supported by the router.
+ * HTTP methods defined in HTTP/1.1 specification.
+ * @see https://datatracker.ietf.org/doc/html/rfc7231#section-4.3
  */
-type HTTPMethod = "GET" | "POST" | "DELETE" | "PUT" | "PATCH";
+type HTTPMethod = "GET" | "POST" | "DELETE" | "PUT" | "PATCH" | "OPTIONS" | "HEAD" | "TRACE" | "CONNECT";
 /**
  * Content types supported by the router.
  */
-type ContentType = "application/json" | "application/x-www-form-urlencoded" | "text/plain";
+type ContentType = "application/json" | "application/x-www-form-urlencoded" | "text/plain" | "multipart/form-data" | "application/xml" | "application/octet-stream" | `text/${string}` | `image/${string}` | `video/${string}` | `audio/${string}` | "application/pdf";
 type Prettify<Obj extends object> = {
     [Key in keyof Obj]: Obj[Key];
 } & {};
@@ -33,20 +35,27 @@ type Prettify<Obj extends object> = {
  * // Expected: {}
  * type NoParams = Params<"/about">;
  */
-type Params<Route extends RoutePattern> = Route extends `/${string}/:${infer Param}/${infer Str}` ? Prettify<{
+type GetRouteParams<Route extends RoutePattern> = Route extends `/${string}/:${infer Param}/${infer Str}` ? Prettify<{
     [K in Param]: string;
-} & Params<`/${Str}`>> : Route extends `/${string}/:${infer Param}` ? Prettify<{
+} & GetRouteParams<`/${Str}`>> : Route extends `/${string}/:${infer Param}` ? Prettify<{
     [K in Param]: string;
 }> : Route extends `/:${infer Param}` ? Prettify<{
     [K in Param]: string;
 }> : {};
-type GetRouteParams<T extends RoutePattern> = Params<T>;
 /**
  * Available schemas validation for an endpoint. It can include body and searchParams schemas.
  */
 interface EndpointSchemas {
     body?: ZodObject<any>;
     searchParams?: ZodObject<any>;
+    params?: ZodObject<any>;
+}
+/**
+ * Global context type that can be extended when creating the router. It allows passing
+ * additional data to all route handlers and middlewares. For a type-inference use module
+ * augmentation to extend the GlobalContext interface.
+ */
+interface GlobalContext {
 }
 /**
  * Configuration for an endpoint, including optional schemas for request validation and middlewares.
@@ -77,31 +86,50 @@ type ContextBody<Schemas extends EndpointConfig["schemas"]> = Schemas extends {
 } : {
     body: undefined;
 };
+/**
+ * Infer the type of route parameters from the provided value in the `EndpointConfig`.
+ */
+type ContextParams<Schemas extends EndpointConfig["schemas"], Default = Record<string, string>> = Schemas extends {
+    params: ZodObject;
+} ? {
+    params: z.infer<Schemas["params"]>;
+} : {
+    params: Default;
+};
 /**
  * Context object passed to route handlers and middlewares defined in the
  * `createEndpoint/createEndpointConfig` function or globally in the `createRouter` function.
  */
 interface RequestContext<RouteParams = Record<string, string>, Config extends EndpointConfig = EndpointConfig> {
-    params: RouteParams;
+    params: ContextParams<Config["schemas"], RouteParams>["params"];
     headers: Headers;
     body: ContextBody<Config["schemas"]>["body"];
     searchParams: ContextSearchParams<Config["schemas"]>["searchParams"];
+    request: Request;
+    url: URL;
+    method: HTTPMethod;
+    route: RoutePattern;
+    context: GlobalContext;
+}
+interface GlobalMiddlewareContext {
+    request: Request;
+    context: GlobalContext;
 }
 /**
  * Global middleware function type that represent a function that runs before the route matching.
  */
-type GlobalMiddleware = (request: Request) => Promise<Request | Response>;
+type GlobalMiddleware = (ctx: GlobalMiddlewareContext) => Response | GlobalMiddlewareContext | Promise<Response | GlobalMiddlewareContext>;
 /**
  * Middleware function type that represent a function that runs before the route handler
  * defined in the `createEndpoint/createEndpointConfig` function or globally in the `createRouter` function.
  */
-type MiddlewareFunction<RouteParams = Record<string, string>, Config extends EndpointConfig = EndpointConfig> = (request: Request, ctx: Prettify<RequestContext<RouteParams, Config>>) => Promise<RequestContext<RouteParams, Config>>;
+type MiddlewareFunction<RouteParams = Record<string, string>, Config extends EndpointConfig = EndpointConfig> = (ctx: Prettify<RequestContext<RouteParams, Config>>) => Response | RequestContext<RouteParams, Config> | Promise<Response | RequestContext<RouteParams, Config>>;
 /**
  * Defines a route handler function that processes an incoming request and returns a response.
  * The handler receives the request object and a context containing route parameters, headers,
  * and optionally validated body and search parameters based on the endpoint configuration.
  */
-type RouteHandler<Route extends RoutePattern, Config extends EndpointConfig> = (request: Request, ctx: Prettify<RequestContext<GetRouteParams<Route>, Config>>) => Promise<Response>;
+type RouteHandler<Route extends RoutePattern, Config extends EndpointConfig> = (ctx: Prettify<RequestContext<GetRouteParams<Route>, Config>>) => Response | Promise<Response>;
 /**
  * Represents a route endpoint definition, specifying the HTTP method, route pattern,
  * handler function with inferred context types, and associated configuration.
@@ -121,14 +149,64 @@ type InferMethod<Endpoints extends RouteEndpoint[]> = Endpoints extends unknown[
  * Each method is a function that takes a request and context, returning a promise of a response.
  */
 type GetHttpHandlers<Endpoints extends RouteEndpoint[]> = {
-    [Method in InferMethod<Endpoints>]: (req: Request) => Promise<Response>;
+    [Method in InferMethod<Endpoints>]: (req: Request) => Response | Promise<Response>;
+};
+type GlobalCtx = keyof GlobalContext extends never ? {
+    context?: GlobalContext;
+} : {
+    context: GlobalContext;
 };
 /**
  * Configuration options for `createRouter` function.
  */
-interface RouterConfig {
+interface RouterConfig extends GlobalCtx {
+    /**
+     * Prefix path for all routes/endpoints defined in the router.
+     *
+     * @example
+     * basePath: "/api/v1"
+     *
+     * // will match the "/users" endpoint.
+     * new Request("https://example.com/api/v1/users")
+     *
+     * // will NOT match the "/users" endpoint.
+     * new Request("https://example.com/users")
+     */
     basePath?: RoutePattern;
+    /**
+     * Global middlewares that run before route matching for all endpoints in the router.
+     * You can use this to modify the request or return a response early.
+     *
+     * @example
+     * middlewares: [
+     *   async (request) => {
+     *     if(request.headers.get("Authorization")?.startsWith("Bearer ")) {
+     *       return Response.json({ message: "Unauthorized" }, { status: 401 })
+     *     }
+     *     return request
+     *   }
+     * ]
+     */
     middlewares?: GlobalMiddleware[];
+    /**
+     * Error handler function that runs when an error is thrown in a router handler or middleware.
+     * It can be used to customize the default error response provided by the router. If is an internal
+     * error the error is from the `RouterError` class, otherwise the error is a generic
+     * `Error` instance which was caused by a handler or middleware, for how to distinguish them you can use
+     * the `isRouterError` function from the `assert` module.
+     *
+     * @param error - The error thrown in the router
+     * @param request - The original request that caused the error
+     * @returns A response to be sent back to the client
+     * @example
+     * onError: (error, request) => {
+     *   if(isRouterError(error)) {
+     *     return Response.json({ message: error.message }, { status: error.statusCode })
+     *   }
+     *   return Response.json({ message: "Internal Server Error" }, { status: 500 })
+     * }
+     */
+    onError?: (error: Error | RouterError, request: Request) => Response | Promise<Response>;
 }
 
-export type { ContentType, ContextBody, ContextSearchParams, EndpointConfig, EndpointSchemas, GetHttpHandlers, GetRouteParams, GlobalMiddleware, HTTPMethod, InferMethod, MiddlewareFunction, Params, Prettify, RequestContext, RouteEndpoint, RouteHandler, RoutePattern, RouterConfig };
+export type { ContentType, ContextBody, ContextParams, ContextSearchParams, EndpointConfig, EndpointSchemas, GetHttpHandlers, GetRouteParams, GlobalContext, GlobalCtx, GlobalMiddleware, GlobalMiddlewareContext, HTTPMethod, InferMethod, MiddlewareFunction, Prettify, RequestContext, RouteEndpoint, RouteHandler, RoutePattern, RouterConfig };