@aura-stack/router 0.1.0 → 0.3.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 = ["POST", "PUT", "PATCH"];
-var isSupportedBodyMethod = (method) => {
-  return supportedBodyMethods.includes(method);
-};
-
 // src/error.ts
 var statusCode = {
   OK: 200,
@@ -57,50 +54,57 @@ 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/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,41 +115,50 @@ 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();
-  }
-  if (contentType.includes("application/octet-stream")) {
-    return await request.arrayBuffer();
-  }
-  if (contentType.includes("image/") || contentType.includes("video/") || contentType.includes("audio/")) {
-    return await request.blob();
+  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");
   }
-  return null;
+};
+var createContentTypeRegex = (contentTypes, contenType) => {
+  const regex = new RegExp(`${contentTypes.join("|")}`);
+  return regex.test(contenType);
 };
 
-// src/middleware.ts
+// 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");
+      throw new RouterError("BAD_REQUEST", "Global middlewares must be functions");
     }
     const executed = await middleware(request);
     if (executed instanceof Response) {
@@ -154,7 +167,7 @@ var executeGlobalMiddlewares = async (request, middlewares) => {
     request = executed;
   }
   if (!request || !(request instanceof Request)) {
-    throw new AuraStackRouterError("BAD_REQUEST", "Global middleware must return a Request or Response object");
+    throw new RouterError("BAD_REQUEST", "Global middleware must return a Request or Response object");
   }
   return request;
 };
@@ -163,71 +176,137 @@ var executeMiddlewares = async (request, context, middlewares = []) => {
     let ctx = context;
     for (const middleware of middlewares) {
       if (typeof middleware !== "function") {
-        throw new AuraStackRouterError("BAD_REQUEST", "Middleware must be a function");
+        throw new RouterError("BAD_REQUEST", "Middleware must be a function");
       }
       ctx = await middleware(request, ctx);
     }
     return ctx;
   } catch {
-    throw new AuraStackRouterError("BAD_REQUEST", "Handler threw an error");
+    throw new RouterError("BAD_REQUEST", "Handler threw an error");
   }
 };
 
 // src/router.ts
-var createRouter = (endpoints, config = {}) => {
-  const server = {};
-  const groups = {
-    GET: [],
-    POST: [],
-    DELETE: [],
-    PUT: [],
-    PATCH: []
-  };
-  endpoints.forEach((endpoint) => groups[endpoint.method].push(endpoint));
-  for (const method in groups) {
-    server[method] = async (request, ctx) => {
-      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[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 = {
-            ...ctx,
-            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;
-          console.log("StatusText: ", statusText2);
-          return Response.json({ message }, { status, statusText: statusText2 });
-        }
-        return Response.json({ message: "Internal Server Error" }, { status: 500 });
+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 (node.endpoints.has(endpoint.method)) {
+    throw new RouterError("BAD_REQUEST", `Duplicate endpoint for ${endpoint?.method} ${endpoint?.route}`);
+  }
+  node.endpoints.set(endpoint.method, endpoint);
+};
+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}`);
+    }
+  }
+  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 }
+      );
+    }
+  }
+  if (isRouterError(error)) {
+    const { message, status, statusText: statusText2 } = error;
+    return Response.json({ message }, { status, statusText: statusText2 });
+  }
+  return Response.json({ message: "Internal Server Error" }, { status: 500, statusText: statusText.INTERNAL_SERVER_ERROR });
+};
+var handleRequest = async (method, request, config, root) => {
+  try {
+    if (!isSupportedMethod(request.method)) {
+      throw new RouterError("METHOD_NOT_ALLOWED", `The HTTP method '${request.method}' is not supported`);
+    }
+    const globalRequest = await executeGlobalMiddlewares(request, config.middlewares);
+    if (globalRequest instanceof Response) return globalRequest;
+    const url = new URL(globalRequest.url);
+    const pathnameWithBase = url.pathname;
+    if (globalRequest.method !== method) {
+      throw new RouterError("METHOD_NOT_ALLOWED", `The HTTP method '${globalRequest.method}' is not allowed`);
+    }
+    const { endpoint, params } = search(method, root, pathnameWithBase);
+    if (endpoint.method !== globalRequest.method) {
+      throw new RouterError("METHOD_NOT_ALLOWED", `The HTTP method '${globalRequest.method}' is not allowed`);
+    }
+    const dynamicParams = getRouteParams(params, endpoint.config);
+    const body = await getBody(globalRequest, endpoint.config);
+    const searchParams = getSearchParams(globalRequest.url, endpoint.config);
+    const headers = getHeaders(globalRequest);
+    const context = {
+      params: dynamicParams,
+      searchParams,
+      headers,
+      body
     };
+    await executeMiddlewares(globalRequest, context, endpoint.config.middlewares);
+    const response = await endpoint.handler(globalRequest, context);
+    return response;
+  } catch (error) {
+    return handleError(error, request, config);
+  }
+};
+var createRouter = (endpoints, config = {}) => {
+  const root = createNode();
+  const server = {};
+  const methods = /* @__PURE__ */ new Set();
+  for (const endpoint of endpoints) {
+    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.cts

@@ -1,6 +1,28 @@
-import { RouteEndpoint, RouterConfig, GetHttpHandlers } from './types.cjs';
+import { RouteEndpoint, RouterConfig, GetHttpHandlers, HTTPMethod, RoutePattern, EndpointSchemas, MiddlewareFunction } from './types.cjs';
 import 'zod';
+import './error.cjs';
 
+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.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-VBI7H3AK.js";
-import "./chunk-NNCUFWPI.js";
-import "./chunk-6UBPSXKR.js";
-import "./chunk-ENOBC3XN.js";
-import "./chunk-RVJ2F7OL.js";
-import "./chunk-RFYOPPMW.js";
+  createNode,
+  createRouter,
+  insert,
+  search
+} from "./chunk-JIA6NLL6.js";
+import "./chunk-PT4GU6PH.js";
+import "./chunk-JNMXLKDG.js";
+import "./chunk-FWDOXDWG.js";
+import "./chunk-GJC3ODME.js";
 export {
-  createRouter
+  createNode,
+  createRouter,
+  insert,
+  search
 };

package/dist/types.d.cts

@@ -1,4 +1,5 @@
 import { ZodObject, z } from 'zod';
+import { RouterError } from './error.cjs';
 
 /**
  * Route pattern must start with a slash and can contain parameters prefixed with a colon.
@@ -6,15 +7,16 @@ import { ZodObject, z } from 'zod';
  * const getUser:RoutePattern = "/users/:userId"
  * const getPostsComments:RoutePattern = "/posts/:postId/comments/:commentId"
  */
-type RoutePattern = `/${string}`;
+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,20 @@ 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>;
 }
 /**
  * Configuration for an endpoint, including optional schemas for request validation and middlewares.
@@ -77,12 +79,22 @@ 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"];
@@ -101,7 +113,7 @@ type MiddlewareFunction<RouteParams = Record<string, string>, Config extends End
  * 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> = (request: Request, 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 +133,59 @@ 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, ctx: RequestContext) => Promise<Response>;
+    [Method in InferMethod<Endpoints>]: (req: Request) => Response | Promise<Response>;
 };
 /**
  * Configuration options for `createRouter` function.
  */
 interface RouterConfig {
+    /**
+     * 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, GlobalMiddleware, HTTPMethod, InferMethod, MiddlewareFunction, Prettify, RequestContext, RouteEndpoint, RouteHandler, RoutePattern, RouterConfig };