@aura-stack/router 0.3.0 → 0.4.0

package/README.md

@@ -1,7 +1,7 @@
-# `@aura-stack/router`
-
 <div align="center">
 
+<h1>Aura Router</h1>
+
 **A modern, TypeScript-first router and endpoint definition library**
 
 Build fully-typed APIs with declarative endpoints, automatic parameter inference, and first-class middleware support — all returning native `Response` objects.

package/dist/{chunk-FWDOXDWG.js → chunk-CFAIW6YL.js}

@@ -3,31 +3,31 @@ import {
 } from "./chunk-GJC3ODME.js";
 
 // src/middlewares.ts
-var executeGlobalMiddlewares = async (request, middlewares) => {
-  if (!middlewares) return request;
+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(request);
+    const executed = await middleware(context);
     if (executed instanceof Response) {
       return executed;
     }
-    request = executed;
+    context = executed;
   }
-  if (!request || !(request instanceof Request)) {
+  if (!context || !(context.request instanceof Request)) {
     throw new RouterError("BAD_REQUEST", "Global middleware must return a Request or Response object");
   }
-  return request;
+  return context;
 };
-var executeMiddlewares = async (request, context, middlewares = []) => {
+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(request, ctx);
+      ctx = await middleware(ctx);
     }
     return ctx;
   } catch {

package/dist/{chunk-JIA6NLL6.js → chunk-CL5D7UJU.js}

@@ -11,7 +11,7 @@ import {
 import {
   executeGlobalMiddlewares,
   executeMiddlewares
-} from "./chunk-FWDOXDWG.js";
+} from "./chunk-CFAIW6YL.js";
 import {
   RouterError,
   statusText
@@ -92,29 +92,35 @@ var handleRequest = async (method, request, config, root) => {
     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 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 (globalRequest.method !== method) {
-      throw new RouterError("METHOD_NOT_ALLOWED", `The HTTP method '${globalRequest.method}' is not allowed`);
+    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 !== globalRequest.method) {
-      throw new RouterError("METHOD_NOT_ALLOWED", `The HTTP method '${globalRequest.method}' is not allowed`);
+    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(globalRequest, endpoint.config);
-    const searchParams = getSearchParams(globalRequest.url, endpoint.config);
-    const headers = getHeaders(globalRequest);
-    const context = {
+    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
+      body,
+      request: globalRequestContext.request,
+      url,
+      method: globalRequestContext.request.method,
+      route: endpoint.route,
+      context: config.context ?? {}
     };
-    await executeMiddlewares(globalRequest, context, endpoint.config.middlewares);
-    const response = await endpoint.handler(globalRequest, context);
+    context = await executeMiddlewares(context, endpoint.config.middlewares);
+    const response = await endpoint.handler(context);
     return response;
   } catch (error) {
     return handleError(error, request, config);

package/dist/context.d.ts

@@ -9,9 +9,9 @@ import './error.js';
  * (e.g., "/users/:userId/posts/:postId") and returns an object mapping parameter
  * names to their decoded values.
  *
- * @param route - The route pattern, typically defined in the endpoint configuration.
- * @param path - The actual request path to extract parameters from.
- * @returns An object containing the extracted route parameters as key-value pairs.
+ * @param params - The extracted route parameters as key-value pairs.
+ * @param config - The endpoint configuration which may include schemas for validation.
+ * @returns An object containing the extracted and validated route parameters.
  *
  * @example
  * const route = "/users/:userId/posts/:postId";

package/dist/index.cjs

@@ -116,6 +116,39 @@ function createEndpointConfig(...args) {
   return args[0];
 }
 
+// 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 = (params, config) => {
   if (config.schemas?.params) {
@@ -181,39 +214,6 @@ var createContentTypeRegex = (contentTypes, contenType) => {
   return regex.test(contenType);
 };
 
-// src/middlewares.ts
-var executeGlobalMiddlewares = async (request, middlewares) => {
-  if (!middlewares) return request;
-  for (const middleware of middlewares) {
-    if (typeof middleware !== "function") {
-      throw new RouterError("BAD_REQUEST", "Global middlewares must be functions");
-    }
-    const executed = await middleware(request);
-    if (executed instanceof Response) {
-      return executed;
-    }
-    request = executed;
-  }
-  if (!request || !(request instanceof Request)) {
-    throw new RouterError("BAD_REQUEST", "Global middleware must return a Request or Response object");
-  }
-  return request;
-};
-var executeMiddlewares = async (request, 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(request, ctx);
-    }
-    return ctx;
-  } catch {
-    throw new RouterError("BAD_REQUEST", "Handler threw an error");
-  }
-};
-
 // src/router.ts
 var createNode = () => ({
   statics: /* @__PURE__ */ new Map(),
@@ -289,29 +289,35 @@ var handleRequest = async (method, request, config, root) => {
     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 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 (globalRequest.method !== method) {
-      throw new RouterError("METHOD_NOT_ALLOWED", `The HTTP method '${globalRequest.method}' is not allowed`);
+    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 !== globalRequest.method) {
-      throw new RouterError("METHOD_NOT_ALLOWED", `The HTTP method '${globalRequest.method}' is not allowed`);
+    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(globalRequest, endpoint.config);
-    const searchParams = getSearchParams(globalRequest.url, endpoint.config);
-    const headers = getHeaders(globalRequest);
-    const context = {
+    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
+      body,
+      request: globalRequestContext.request,
+      url,
+      method: globalRequestContext.request.method,
+      route: endpoint.route,
+      context: config.context ?? {}
     };
-    await executeMiddlewares(globalRequest, context, endpoint.config.middlewares);
-    const response = await endpoint.handler(globalRequest, context);
+    context = await executeMiddlewares(context, endpoint.config.middlewares);
+    const response = await endpoint.handler(context);
     return response;
   } catch (error) {
     return handleError(error, request, config);

package/dist/index.d.ts

@@ -2,5 +2,5 @@ export { createEndpoint, createEndpointConfig } from './endpoint.js';
 export { createRouter } from './router.js';
 export { isRouterError } from './assert.js';
 export { RouterError, statusCode, statusText } from './error.js';
-export { ContentType, ContextBody, ContextParams, ContextSearchParams, EndpointConfig, EndpointSchemas, GetHttpHandlers, GetRouteParams, GlobalMiddleware, HTTPMethod, InferMethod, MiddlewareFunction, Prettify, RequestContext, RouteEndpoint, RouteHandler, RoutePattern, RouterConfig } from './types.js';
+export { ContentType, ContextBody, ContextParams, ContextSearchParams, EndpointConfig, EndpointSchemas, GetHttpHandlers, GetRouteParams, GlobalContext, GlobalCtx, GlobalMiddleware, GlobalMiddlewareContext, HTTPMethod, InferMethod, MiddlewareFunction, Prettify, RequestContext, RouteEndpoint, RouteHandler, RoutePattern, RouterConfig } from './types.js';
 import 'zod';

package/dist/index.js

@@ -4,12 +4,12 @@ import {
 } from "./chunk-6PZEXNTS.js";
 import {
   createRouter
-} from "./chunk-JIA6NLL6.js";
+} from "./chunk-CL5D7UJU.js";
 import "./chunk-PT4GU6PH.js";
 import {
   isRouterError
 } from "./chunk-JNMXLKDG.js";
-import "./chunk-FWDOXDWG.js";
+import "./chunk-CFAIW6YL.js";
 import {
   RouterError,
   statusCode,

package/dist/middlewares.cjs

@@ -74,31 +74,31 @@ var RouterError = class extends AuraStackRouterError {
 };
 
 // src/middlewares.ts
-var executeGlobalMiddlewares = async (request, middlewares) => {
-  if (!middlewares) return request;
+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(request);
+    const executed = await middleware(context);
     if (executed instanceof Response) {
       return executed;
     }
-    request = executed;
+    context = executed;
   }
-  if (!request || !(request instanceof Request)) {
+  if (!context || !(context.request instanceof Request)) {
     throw new RouterError("BAD_REQUEST", "Global middleware must return a Request or Response object");
   }
-  return request;
+  return context;
 };
-var executeMiddlewares = async (request, context, middlewares = []) => {
+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(request, ctx);
+      ctx = await middleware(ctx);
     }
     return ctx;
   } catch {

package/dist/middlewares.d.ts

@@ -1,4 +1,4 @@
-import { RouterConfig, EndpointConfig, RequestContext, MiddlewareFunction } from './types.js';
+import { GlobalMiddlewareContext, RouterConfig, EndpointConfig, RequestContext, MiddlewareFunction } from './types.js';
 import 'zod';
 import './error.js';
 
@@ -9,7 +9,7 @@ import './error.js';
  * @param middlewares - Array of global middleware functions to be executed
  * @returns - The modified request after all middlewares have been executed
  */
-declare const executeGlobalMiddlewares: (request: Request, middlewares: RouterConfig["middlewares"]) => Promise<Request | Response>;
+declare const executeGlobalMiddlewares: (context: GlobalMiddlewareContext, middlewares: RouterConfig["middlewares"]) => Promise<GlobalMiddlewareContext | Response>;
 /**
  * Executes middlewares in sequence, passing the request and context to each middleware.
  *
@@ -18,6 +18,6 @@ declare const executeGlobalMiddlewares: (request: Request, middlewares: RouterCo
  * @param middlewares - Array of middleware functions to be executed
  * @returns The modified context after all middlewares have been executed
  */
-declare const executeMiddlewares: <const RouteParams extends Record<string, string>, const Config extends EndpointConfig>(request: Request, context: RequestContext<RouteParams, Config>, middlewares?: MiddlewareFunction<RouteParams, Config>[]) => Promise<RequestContext<RouteParams, Config>>;
+declare const executeMiddlewares: <const RouteParams extends Record<string, string>, const Config extends EndpointConfig>(context: RequestContext<RouteParams, Config>, middlewares?: MiddlewareFunction<RouteParams, Config>[]) => Promise<RequestContext<RouteParams, Config>>;
 
 export { executeGlobalMiddlewares, executeMiddlewares };

package/dist/middlewares.js

@@ -1,7 +1,7 @@
 import {
   executeGlobalMiddlewares,
   executeMiddlewares
-} from "./chunk-FWDOXDWG.js";
+} from "./chunk-CFAIW6YL.js";
 import "./chunk-GJC3ODME.js";
 export {
   executeGlobalMiddlewares,

package/dist/router.cjs

@@ -88,6 +88,39 @@ 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 = (params, config) => {
   if (config.schemas?.params) {
@@ -153,39 +186,6 @@ var createContentTypeRegex = (contentTypes, contenType) => {
   return regex.test(contenType);
 };
 
-// src/middlewares.ts
-var executeGlobalMiddlewares = async (request, middlewares) => {
-  if (!middlewares) return request;
-  for (const middleware of middlewares) {
-    if (typeof middleware !== "function") {
-      throw new RouterError("BAD_REQUEST", "Global middlewares must be functions");
-    }
-    const executed = await middleware(request);
-    if (executed instanceof Response) {
-      return executed;
-    }
-    request = executed;
-  }
-  if (!request || !(request instanceof Request)) {
-    throw new RouterError("BAD_REQUEST", "Global middleware must return a Request or Response object");
-  }
-  return request;
-};
-var executeMiddlewares = async (request, 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(request, ctx);
-    }
-    return ctx;
-  } catch {
-    throw new RouterError("BAD_REQUEST", "Handler threw an error");
-  }
-};
-
 // src/router.ts
 var createNode = () => ({
   statics: /* @__PURE__ */ new Map(),
@@ -261,29 +261,35 @@ var handleRequest = async (method, request, config, root) => {
     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 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 (globalRequest.method !== method) {
-      throw new RouterError("METHOD_NOT_ALLOWED", `The HTTP method '${globalRequest.method}' is not allowed`);
+    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 !== globalRequest.method) {
-      throw new RouterError("METHOD_NOT_ALLOWED", `The HTTP method '${globalRequest.method}' is not allowed`);
+    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(globalRequest, endpoint.config);
-    const searchParams = getSearchParams(globalRequest.url, endpoint.config);
-    const headers = getHeaders(globalRequest);
-    const context = {
+    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
+      body,
+      request: globalRequestContext.request,
+      url,
+      method: globalRequestContext.request.method,
+      route: endpoint.route,
+      context: config.context ?? {}
     };
-    await executeMiddlewares(globalRequest, context, endpoint.config.middlewares);
-    const response = await endpoint.handler(globalRequest, context);
+    context = await executeMiddlewares(context, endpoint.config.middlewares);
+    const response = await endpoint.handler(context);
     return response;
   } catch (error) {
     return handleError(error, request, config);

package/dist/router.js

@@ -3,10 +3,10 @@ import {
   createRouter,
   insert,
   search
-} from "./chunk-JIA6NLL6.js";
+} from "./chunk-CL5D7UJU.js";
 import "./chunk-PT4GU6PH.js";
 import "./chunk-JNMXLKDG.js";
-import "./chunk-FWDOXDWG.js";
+import "./chunk-CFAIW6YL.js";
 import "./chunk-GJC3ODME.js";
 export {
   createNode,

package/dist/types.d.ts

@@ -50,6 +50,13 @@ interface EndpointSchemas {
     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.
  */
@@ -98,22 +105,31 @@ interface RequestContext<RouteParams = Record<string, string>, Config extends En
     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>>) => Response | 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.
@@ -135,10 +151,15 @@ type InferMethod<Endpoints extends RouteEndpoint[]> = Endpoints extends unknown[
 type GetHttpHandlers<Endpoints extends RouteEndpoint[]> = {
     [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.
      *
@@ -188,4 +209,4 @@ interface RouterConfig {
     onError?: (error: Error | RouterError, request: Request) => Response | Promise<Response>;
 }
 
-export type { ContentType, ContextBody, ContextParams, ContextSearchParams, EndpointConfig, EndpointSchemas, GetHttpHandlers, GetRouteParams, GlobalMiddleware, HTTPMethod, InferMethod, MiddlewareFunction, 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 };

package/package.json

@@ -1,8 +1,31 @@
 {
   "name": "@aura-stack/router",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "type": "module",
   "description": "A lightweight TypeScript library for building, managing, and validating API routes and endpoints in Node.js applications.",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/aura-stack-ts/router"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/@aura-stack/router"
+  },
+  "keywords": [
+    "router",
+    "endpoints",
+    "api",
+    "aura",
+    "aura stack",
+    "typescript",
+    "nodejs"
+  ],
+  "author": "Aura Stack <auraauthoss@gmail.com> | Hernan Alvarado <hernanvid123@gmail.com>",
+  "homepage": "https://github.com/aura-stack-ts/router",
+  "bugs": {
+    "url": "https://github.com/aura-stack-ts/router/issues"
+  },
+  "license": "MIT",
   "files": [
     "dist"
   ],
@@ -29,17 +52,6 @@
     },
     "./types": "./dist/types.d.ts"
   },
-  "keywords": [
-    "router",
-    "endpoints",
-    "api",
-    "aura",
-    "aura stack",
-    "typescript",
-    "nodejs"
-  ],
-  "author": "Aura Stack <auraauthoss@gmail.com> | Hernan Alvarado <hernanvid123@gmail.com>",
-  "license": "MIT",
   "devDependencies": {
     "prettier": "^3.6.2",
     "tsup": "^8.5.0",
@@ -58,6 +70,7 @@
     "test:bench": "vitest --run bench",
     "type-check": "tsc --noEmit",
     "clean": "rm -rf dist",
-    "clean:cts": "rm -rf dist/*.cts"
+    "clean:cts": "rm -rf dist/*.cts",
+    "prepublish": "pnpm clean:cts"
   }
 }

package/dist/assert.d.cts

@@ -1,52 +0,0 @@
-import { RouterError } from './error.cjs';
-import { HTTPMethod, RoutePattern, RouteHandler } from './types.cjs';
-import 'zod';
-
-declare const supportedProtocols: Set<string>;
-/**
- * Checks if the provided method is a supported HTTP method.
- *
- * @param method - The HTTP method to check.
- * @returns True if the method is supported, false otherwise.
- */
-declare const isSupportedMethod: (method: string) => method is HTTPMethod;
-/**
- * Check if the provided method can includes a body as per HTTP specification.
- * @param method - The HTTP method to check.
- * @returns True if the method can include a body, false otherwise.
- */
-declare const isSupportedBodyMethod: (method: string) => method is HTTPMethod;
-/**
- * Checks if the provided route is a valid route pattern.
- *
- * @param route - The route pattern to check.
- * @returns True if the route is valid, false otherwise.
- */
-declare const isValidRoute: (route: string) => route is RoutePattern;
-/**
- * Checks if the provided handler is a valid route handler function.
- *
- * @param handler - The handler to check.
- * @returns True if the handler is valid, false otherwise.
- */
-declare const isValidHandler: (handler: unknown) => handler is RouteHandler<any, any>;
-/**
- * Asserts that the error is an instance of RouterError. It is useful if you want
- * to check if the error thrown by the router is an RouterError or by other sources.
- *
- * @param error - The error to check
- * @returns True if the error is an instance of RouterError, false otherwise.
- * @example
- * import { isRouterError } from "aura-stack/router";
- *
- * try {
- *   // Some router operation that may throw an error
- * } catch (error) {
- *  if (isRouterError(error)) {
- *    // Handle RouterError
- *  }
- * }
- */
-declare const isRouterError: (error: unknown) => error is RouterError;
-
-export { isRouterError, isSupportedBodyMethod, isSupportedMethod, isValidHandler, isValidRoute, supportedProtocols };

package/dist/context.d.cts

@@ -1,85 +0,0 @@
-import { EndpointConfig, ContextSearchParams } from './types.cjs';
-import 'zod';
-import './error.cjs';
-
-/**
- * Extracts route parameters from a given path using the specified route pattern.
- *
- * This function matches the provided path against the route pattern
- * (e.g., "/users/:userId/posts/:postId") and returns an object mapping parameter
- * names to their decoded values.
- *
- * @param route - The route pattern, typically defined in the endpoint configuration.
- * @param path - The actual request path to extract parameters from.
- * @returns An object containing the extracted route parameters as key-value pairs.
- *
- * @example
- * const route = "/users/:userId/posts/:postId";
- * const path = "/users/123/posts/456";
- *
- * // Expected: { userId: "123", postId: "456" }
- * const params = getRouteParams(route, path);
- */
-declare const getRouteParams: (params: Record<string, string>, config: EndpointConfig) => Record<string, unknown>;
-/**
- * Extracts and validates search parameters from a given URL from the request.
- *
- * If a schema is provided in the endpoint configuration, the search parameters
- * are validated against it using Zod and returned the parsed data. If validation
- * fails, an error is thrown. Otherwise, a URLSearchParams object is returned.
- *
- * @param url - The actual request URL to extract search parameters from.
- * @param config - Configuration object that may include a schema for validation.
- * @returns Either a URLSearchParams object or a parsed object based on the provided schema.
- * @example
- * // With schema
- * const url = "https://example.com/api?search=test&page=2";
- * const config: EndpointConfig = {
- *   schemas: {
- *     searchParams: z.object({
- *       search: z.string(),
- *       page: z.number().optional(),
- *     }),
- *   },
- * }
- *
- * // Expected: { search: "test", page: 2 }
- * const searchParams = getSearchParams(url, config);
- *
- * // Without schema
- * const url2 = "https://example.com/api?query=example";
- *
- * // Expected: URLSearchParams { 'query' => 'example' }
- * const searchParams2 = getSearchParams(url2, {} as EndpointConfig);
- */
-declare const getSearchParams: <Config extends EndpointConfig>(url: string, config: Config) => ContextSearchParams<Config["schemas"]>["searchParams"];
-/**
- * Extracts headers from the given Request object and returns them as a Headers instance.
- *
- * @param request - The Request object from which to extract headers.
- * @returns A Headers instance containing all headers from the request.
- * @example
- * const request = new Request("https://example.com/api", {
- *   headers: {
- *     "Content-Type": "application/json",
- *     "Authorization": "Bearer token",
- *   },
- * });
- * const headers = getHeaders(request);
- */
-declare const getHeaders: (request: Request) => Headers;
-/**
- * Extracts and parses the body of a Request object based on its Content-Type header.
- *
- * If a schema is provided in the endpoint configuration, the body is validated against
- * it using Zod and returned the parsed data. If validation fails, an error is thrown.
- *
- * In some cases, the browser includes text/plain;charset=UTF-8 as the default Content-Type
- *
- * @param request - The Request object from which to extract the body.
- * @param config - Configuration object that may include a schema for validation.
- * @returns The parsed body of the request or an error if validation fails.
- */
-declare const getBody: <Config extends EndpointConfig>(request: Request, config: Config) => Promise<any>;
-
-export { getBody, getHeaders, getRouteParams, getSearchParams };

package/dist/endpoint.d.cts

@@ -1,60 +0,0 @@
-import { HTTPMethod, RoutePattern, EndpointSchemas, RouteHandler, EndpointConfig, RouteEndpoint } from './types.cjs';
-import 'zod';
-import './error.cjs';
-
-/**
- * Defines an API endpoint for the router by specifying the HTTP method, route pattern,
- * handler function, and optional configuration such as validation schemas or middlewares.
- * Validates all parameters for correctness. The resulting endpoint should be passed
- * to the `createRouter` function.
- *
- * @param method - The HTTP method (e.g., GET, POST, PUT, DELETE, PATCH)
- * @param route - The route pattern to associate with the endpoint (supports dynamic params)
- * @param handler - The function to handle requests matching the method and route
- * @param config - Optional configuration including validation schemas, middlewares, etc.
- * @returns An object representing the configured endpoint
- * @example
- * const signIn = createEndpoint("POST", "/auth/signin", async (req, ctx) => {
- *   return new Response("Signed in");
- * });
- */
-declare const createEndpoint: <const Method extends Uppercase<HTTPMethod>, const Route extends RoutePattern, const Schemas extends EndpointSchemas>(method: Method, route: Route, handler: RouteHandler<Route, {
-    schemas: Schemas;
-}>, config?: EndpointConfig<Route, Schemas>) => RouteEndpoint<Method, Route, {}>;
-/**
- * Create an endpoint configuration to be passed to the `createEndpoint` function.
- * This function is primarily for type inference and does not perform any runtime checks.
- *
- * This overload is recommended when the route pattern does not need to be specified explicitly,
- * otherwise use the overload that accepts the route pattern as the first argument.
- *
- * @param config - The endpoint configuration object
- * @returns The same configuration object, typed as EndpointConfig
- * @example
- * // Without route pattern
- * const config = createEndpointConfig({
- *   middlewares: [myMiddleware],
- *   schemas: {
- *     searchParams: z.object({
- *       q: z.string().min(3),
- *     })
- *   }
- * })
- *
- * const search = createEndpoint("GET", "/search", async (request, ctx) => {
- *   return new Response("Search results");
- * }, config);
- *
- * // Overload with route pattern
- * const config = createEndpointConfig("/users/:userId", {
- *   middlewares: [myMiddleware],
- * })
- *
- * const getUser = createEndpoint("GET", "/users/:userId", async (request, ctx) => {
- *   return new Response("User details");
- * }, config);
- */
-declare function createEndpointConfig<Schemas extends EndpointSchemas>(config: EndpointConfig<RoutePattern, Schemas>): EndpointConfig<RoutePattern, Schemas>;
-declare function createEndpointConfig<Route extends RoutePattern, Schemas extends EndpointSchemas>(route: Route, config: EndpointConfig<Route, Schemas>): EndpointConfig<Route, Schemas>;
-
-export { createEndpoint, createEndpointConfig };

package/dist/error.d.cts

@@ -1,65 +0,0 @@
-/**
- * The HTTP status codes used in AuraStack Router.
- */
-declare const statusCode: {
-    OK: number;
-    CREATED: number;
-    ACCEPTED: number;
-    NO_CONTENT: number;
-    MULTIPLE_CHOICES: number;
-    MOVED_PERMANENTLY: number;
-    FOUND: number;
-    SEE_OTHER: number;
-    NOT_MODIFIED: number;
-    TEMPORARY_REDIRECT: number;
-    BAD_REQUEST: number;
-    UNAUTHORIZED: number;
-    PAYMENT_REQUIRED: number;
-    FORBIDDEN: number;
-    NOT_FOUND: number;
-    METHOD_NOT_ALLOWED: number;
-    NOT_ACCEPTABLE: number;
-    PROXY_AUTHENTICATION_REQUIRED: number;
-    UNPROCESSABLE_ENTITY: number;
-    INTERNAL_SERVER_ERROR: number;
-    NOT_IMPLEMENTED: number;
-    BAD_GATEWAY: number;
-    SERVICE_UNAVAILABLE: number;
-    HTTP_VERSION_NOT_SUPPORTED: number;
-};
-type StatusCode = keyof typeof statusCode;
-/**
- * Reverse mapping of status codes to their corresponding status text.
- */
-declare const statusText: Record<"OK" | "CREATED" | "ACCEPTED" | "NO_CONTENT" | "MULTIPLE_CHOICES" | "MOVED_PERMANENTLY" | "FOUND" | "SEE_OTHER" | "NOT_MODIFIED" | "TEMPORARY_REDIRECT" | "BAD_REQUEST" | "UNAUTHORIZED" | "PAYMENT_REQUIRED" | "FORBIDDEN" | "NOT_FOUND" | "METHOD_NOT_ALLOWED" | "NOT_ACCEPTABLE" | "PROXY_AUTHENTICATION_REQUIRED" | "UNPROCESSABLE_ENTITY" | "INTERNAL_SERVER_ERROR" | "NOT_IMPLEMENTED" | "BAD_GATEWAY" | "SERVICE_UNAVAILABLE" | "HTTP_VERSION_NOT_SUPPORTED", "OK" | "CREATED" | "ACCEPTED" | "NO_CONTENT" | "MULTIPLE_CHOICES" | "MOVED_PERMANENTLY" | "FOUND" | "SEE_OTHER" | "NOT_MODIFIED" | "TEMPORARY_REDIRECT" | "BAD_REQUEST" | "UNAUTHORIZED" | "PAYMENT_REQUIRED" | "FORBIDDEN" | "NOT_FOUND" | "METHOD_NOT_ALLOWED" | "NOT_ACCEPTABLE" | "PROXY_AUTHENTICATION_REQUIRED" | "UNPROCESSABLE_ENTITY" | "INTERNAL_SERVER_ERROR" | "NOT_IMPLEMENTED" | "BAD_GATEWAY" | "SERVICE_UNAVAILABLE" | "HTTP_VERSION_NOT_SUPPORTED">;
-/**
- * Defines the errors used in AuraStack Router. Includes HTTP status code and
- * status text.
- * @deprecated Use RouterError instead
- */
-declare class AuraStackRouterError extends Error {
-    /**
-     * The HTTP status code associated with the error.
-     * @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Status
-     * @example
-     * NOT_FOUND: 404
-     * METHOD_NOT_ALLOWED: 405
-     * INTERNAL_SERVER_ERROR: 500
-     */
-    readonly status: number;
-    /**
-     * The HTTP status text associated with the status code of the error.
-     * @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Status
-     * @example
-     * NOT_FOUND: NOT_FOUND
-     * METHOD_NOT_ALLOWED: METHOD_NOT_ALLOWED
-     * INTERNAL_SERVER_ERROR: INTERNAL_SERVER_ERROR
-     */
-    readonly statusText: StatusCode;
-    constructor(type: StatusCode, message: string, name?: string);
-}
-declare class RouterError extends AuraStackRouterError {
-    constructor(type: StatusCode, message: string, name?: string);
-}
-
-export { AuraStackRouterError, RouterError, statusCode, statusText };

package/dist/index.d.cts

@@ -1,6 +0,0 @@
-export { createEndpoint, createEndpointConfig } from './endpoint.cjs';
-export { createRouter } from './router.cjs';
-export { isRouterError } from './assert.cjs';
-export { RouterError, statusCode, statusText } from './error.cjs';
-export { ContentType, ContextBody, ContextParams, ContextSearchParams, EndpointConfig, EndpointSchemas, GetHttpHandlers, GetRouteParams, GlobalMiddleware, HTTPMethod, InferMethod, MiddlewareFunction, Prettify, RequestContext, RouteEndpoint, RouteHandler, RoutePattern, RouterConfig } from './types.cjs';
-import 'zod';

package/dist/middlewares.d.cts

@@ -1,23 +0,0 @@
-import { RouterConfig, EndpointConfig, RequestContext, MiddlewareFunction } from './types.cjs';
-import 'zod';
-import './error.cjs';
-
-/**
- * Executes the middlewares in sequence, passing the request to each middleware.
- *
- * @param request - Original request made from the client
- * @param middlewares - Array of global middleware functions to be executed
- * @returns - The modified request after all middlewares have been executed
- */
-declare const executeGlobalMiddlewares: (request: Request, middlewares: RouterConfig["middlewares"]) => Promise<Request | Response>;
-/**
- * Executes middlewares in sequence, passing the request and context to each middleware.
- *
- * @param request - Original request made from the client
- * @param context - Context object of the endpoint functionality
- * @param middlewares - Array of middleware functions to be executed
- * @returns The modified context after all middlewares have been executed
- */
-declare const executeMiddlewares: <const RouteParams extends Record<string, string>, const Config extends EndpointConfig>(request: Request, context: RequestContext<RouteParams, Config>, middlewares?: MiddlewareFunction<RouteParams, Config>[]) => Promise<RequestContext<RouteParams, Config>>;
-
-export { executeGlobalMiddlewares, executeMiddlewares };

package/dist/router.d.cts

@@ -1,37 +0,0 @@
-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.
- * It accepts an optional configuration object to set a base path and middlewares for all endpoints.
- *
- * @param endpoints - Array of route endpoints to be handled by the router
- * @param config - Optional configuration object for the router
- * @returns An object with methods corresponding to HTTP methods, each handling requests for that method
- */
-declare const createRouter: <const Endpoints extends RouteEndpoint[]>(endpoints: Endpoints, config?: RouterConfig) => GetHttpHandlers<Endpoints>;
-
-export { createNode, createRouter, insert, search };

package/dist/types.d.cts

@@ -1,191 +0,0 @@
-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.
- * @example
- * const getUser:RoutePattern = "/users/:userId"
- * const getPostsComments:RoutePattern = "/posts/:postId/comments/:commentId"
- */
-type RoutePattern = `/${string}` | `/${string}/:${string}`;
-/**
- * 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" | "OPTIONS" | "HEAD" | "TRACE" | "CONNECT";
-/**
- * Content types supported by the router.
- */
-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];
-} & {};
-/**
- * Extracts route parameters from a given route pattern through colon-prefixed segments.
- * Returns an object type where keys are parameter names and values are strings.
- * If no parameters are found, returns an empty object type.
- *
- * @example
- * // Expected: { userId: string }
- * type UserParams = Params<"/users/:userId">;
- *
- * // Expected: { postId: string; commentId: string }
- * type PostCommentParams = Params<"/posts/:postId/comments/:commentId">;
- *
- * // Expected: {}
- * type NoParams = Params<"/about">;
- */
-type GetRouteParams<Route extends RoutePattern> = Route extends `/${string}/:${infer Param}/${infer Str}` ? Prettify<{
-    [K in Param]: string;
-} & GetRouteParams<`/${Str}`>> : Route extends `/${string}/:${infer Param}` ? Prettify<{
-    [K in Param]: string;
-}> : Route extends `/:${infer Param}` ? Prettify<{
-    [K in Param]: string;
-}> : {};
-/**
- * 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.
- */
-type EndpointConfig<RouteParams extends RoutePattern = RoutePattern, Schemas extends EndpointSchemas = EndpointSchemas> = Prettify<{
-    schemas?: Schemas;
-    middlewares?: MiddlewareFunction<GetRouteParams<RouteParams>, {
-        schemas: Schemas;
-    }>[];
-}>;
-/**
- * Infer the type of search parameters from the provided value in the `EndpointConfig`.
- */
-type ContextSearchParams<Schemas extends EndpointConfig["schemas"]> = Schemas extends {
-    searchParams: ZodObject;
-} ? {
-    searchParams: z.infer<Schemas["searchParams"]>;
-} : {
-    searchParams: URLSearchParams;
-};
-/**
- * Infer the type of body from the provided value in the `EndpointConfig`.
- */
-type ContextBody<Schemas extends EndpointConfig["schemas"]> = Schemas extends {
-    body: ZodObject;
-} ? {
-    body: z.infer<Schemas["body"]>;
-} : {
-    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: ContextParams<Config["schemas"], RouteParams>["params"];
-    headers: Headers;
-    body: ContextBody<Config["schemas"]>["body"];
-    searchParams: ContextSearchParams<Config["schemas"]>["searchParams"];
-}
-/**
- * Global middleware function type that represent a function that runs before the route matching.
- */
-type GlobalMiddleware = (request: Request) => Promise<Request | Response>;
-/**
- * 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>>;
-/**
- * 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>>) => Response | Promise<Response>;
-/**
- * Represents a route endpoint definition, specifying the HTTP method, route pattern,
- * handler function with inferred context types, and associated configuration.
- */
-interface RouteEndpoint<Method extends HTTPMethod = HTTPMethod, Route extends RoutePattern = RoutePattern, Config extends EndpointConfig = EndpointConfig> {
-    method: Method;
-    route: Route;
-    handler: RouteHandler<Route, Config>;
-    config: Config;
-}
-/**
- * Infer the HTTP methods defined in the provided array of route endpoints.
- */
-type InferMethod<Endpoints extends RouteEndpoint[]> = Endpoints extends unknown[] ? Endpoints[number]["method"] : "unknown";
-/**
- * Generates an object with HTTP methods available by the router from `createRouter` function.
- * 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) => 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, ContextParams, ContextSearchParams, EndpointConfig, EndpointSchemas, GetHttpHandlers, GetRouteParams, GlobalMiddleware, HTTPMethod, InferMethod, MiddlewareFunction, Prettify, RequestContext, RouteEndpoint, RouteHandler, RoutePattern, RouterConfig };