@aura-stack/router 0.6.0-rc.2 → 0.6.0

package/dist/types.d.ts

@@ -1,7 +1,6 @@
 import { ZodObject, z } from 'zod';
 import { RouterError } from './error.js';
 import { HeadersBuilder } from './headers.js';
-import { IncomingHttpHeaders } from 'http';
 import 'cookie';
 
 /**
@@ -65,7 +64,7 @@ interface GlobalContext {
  */
 type EndpointConfig<RouteParams extends RoutePattern = RoutePattern, Schemas extends EndpointSchemas = EndpointSchemas> = Prettify<{
     schemas?: Schemas;
-    middlewares?: MiddlewareFunction<GetRouteParams<RouteParams>, {
+    use?: MiddlewareFunction<GetRouteParams<RouteParams>, {
         schemas: Schemas;
     }>[];
 }>;
@@ -137,7 +136,7 @@ type RouteHandler<Route extends RoutePattern, Config extends EndpointConfig> = (
  * 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> {
+interface RouteEndpoint<Method extends HTTPMethod | HTTPMethod[] = HTTPMethod | HTTPMethod[], Route extends RoutePattern = RoutePattern, Config extends EndpointConfig = EndpointConfig> {
     method: Method;
     route: Route;
     handler: RouteHandler<Route, Config>;
@@ -146,7 +145,7 @@ interface RouteEndpoint<Method extends HTTPMethod = HTTPMethod, Route extends Ro
 /**
  * Infer the HTTP methods defined in the provided array of route endpoints.
  */
-type InferMethod<Endpoints extends RouteEndpoint[]> = Endpoints extends unknown[] ? Endpoints[number]["method"] : "unknown";
+type InferMethod<Endpoints extends RouteEndpoint[]> = Endpoints extends (infer Endpoint)[] ? Endpoint extends RouteEndpoint<infer Method, infer _, infer __> ? Method extends HTTPMethod[] ? Method[number] : Method : never : never;
 /**
  * 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.
@@ -181,7 +180,7 @@ interface RouterConfig extends GlobalCtx {
      * You can use this to modify the request or return a response early.
      *
      * @example
-     * middlewares: [
+     * use: [
      *   async (request) => {
      *     if(request.headers.get("Authorization")?.startsWith("Bearer ")) {
      *       return Response.json({ message: "Unauthorized" }, { status: 401 })
@@ -190,7 +189,7 @@ interface RouterConfig extends GlobalCtx {
      *   }
      * ]
      */
-    middlewares?: GlobalMiddleware[];
+    use?: 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
@@ -219,14 +218,15 @@ type ExtractEndpoint<T> = T extends RouteEndpoint<infer M, infer P, infer C> ? {
     path: P;
     config: C;
 } : never;
+type MethodIncludes<Method, Met extends HTTPMethod> = Method extends readonly HTTPMethod[] ? Met extends Method[number] ? true : false : Method extends HTTPMethod ? Method extends Met ? true : false : false;
 /**
  * @experimental
  */
-type RoutesByMethod<Defs extends readonly RouteEndpoint[], Met extends HTTPMethod> = ExtractEndpoint<Defs[number]> extends infer E ? (E extends {
-    method: Met;
+type RoutesByMethod<Defs extends readonly RouteEndpoint[], Met extends HTTPMethod> = ExtractEndpoint<Defs[number]> extends infer E ? E extends {
+    method: infer M;
     path: infer P;
-} ? P : never) : never;
-type ExtractRoutesByMethod<Defs extends RouteEndpoint[], Met extends HTTPMethod> = Defs extends unknown[] ? Defs extends [infer First, ...infer Rest] ? First extends RouteEndpoint<infer M, infer R> ? M extends Met ? R | ExtractRoutesByMethod<Rest extends RouteEndpoint[] ? Rest : [], Met> : ExtractRoutesByMethod<Rest extends RouteEndpoint[] ? Rest : [], Met> : ExtractRoutesByMethod<Rest extends RouteEndpoint[] ? Rest : [], Met> : never : false;
+} ? MethodIncludes<M, Met> extends true ? P : never : never : never;
+type ExtractRoutesByMethod<Defs extends RouteEndpoint[], Met extends HTTPMethod> = Defs extends unknown[] ? Defs extends [infer First, ...infer Rest] ? First extends RouteEndpoint<infer M, infer R> ? MethodIncludes<M, Met> extends true ? R | ExtractRoutesByMethod<Rest extends RouteEndpoint[] ? Rest : [], Met> : ExtractRoutesByMethod<Rest extends RouteEndpoint[] ? Rest : [], Met> : ExtractRoutesByMethod<Rest extends RouteEndpoint[] ? Rest : [], Met> : never : false;
 type InferZod<T> = T extends z.ZodTypeAny ? z.infer<T> : T;
 type ToInferZod<T> = {
     [K in keyof T]: InferZod<T[K]>;
@@ -234,7 +234,7 @@ type ToInferZod<T> = {
 type RemoveUndefined<T> = {
     [K in keyof T as undefined extends T[K] ? never : K]: T[K];
 };
-type Find<Defs extends RouteEndpoint[], Met extends HTTPMethod, Path extends string> = Defs extends unknown[] ? Defs extends [infer First, ...infer Rest] ? First extends RouteEndpoint<infer M, infer R, infer C> ? M extends Met ? R extends Path ? RemoveUndefined<ToInferZod<NonNullable<C["schemas"]>>> : Find<Rest extends RouteEndpoint[] ? Rest : [], Met, Path> : Find<Rest extends RouteEndpoint[] ? Rest : [], Met, Path> : Find<Rest extends RouteEndpoint[] ? Rest : [], Met, Path> : never : never;
+type Find<Defs extends RouteEndpoint[], Met extends HTTPMethod, Path extends string> = Defs extends unknown[] ? Defs extends [infer First, ...infer Rest] ? First extends RouteEndpoint<infer M, infer R, infer C> ? MethodIncludes<M, Met> extends true ? R extends Path ? RemoveUndefined<ToInferZod<NonNullable<C["schemas"]>>> : Find<Rest extends RouteEndpoint[] ? Rest : [], Met, Path> : Find<Rest extends RouteEndpoint[] ? Rest : [], Met, Path> : Find<Rest extends RouteEndpoint[] ? Rest : [], Met, Path> : never : never;
 type Client<Defs extends RouteEndpoint[]> = {
     [M in InferMethod<Defs> as Lowercase<M>]: <T extends ExtractRoutesByMethod<Defs, M>, Config extends Find<Defs, M, T>>(...args: Config extends EndpointSchemas ? [path: T, ctx?: RequestInit] : [path: T, ctx: Prettify<Omit<RequestInit, "body"> & Config>]) => Promise<Response>;
 };
@@ -243,7 +243,9 @@ type Router<Endpoints extends RouteEndpoint[]> = GetHttpHandlers<Endpoints> & {
     readonly [endpointsSymbol]?: Endpoints;
 };
 type InferEndpoints<T> = T extends Router<infer E> ? E : never;
-interface ClientOptions {
+/** @experimental */
+type FetchLike = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+interface ClientOptions extends Pick<RequestInit, "cache" | "credentials" | "mode"> {
     /**
      * Base URL for the router client to make requests to the server.
      * This is useful when the server is hosted on a different origin.
@@ -258,7 +260,82 @@ interface ClientOptions {
     /**
      * Default headers to include in every request made by the client.
      */
-    headers?: IncomingHttpHeaders;
+    headers?: RequestHeaders | (() => RequestHeaders | Promise<RequestHeaders>);
+    /**
+     * @experimental
+     * Custom fetch function to be used by the client instead of the global fetch.
+     */
+    fetch?: FetchLike;
+}
+interface RequestHeaders extends Record<string, number | string | string[] | undefined> {
+    accept?: string | undefined;
+    "accept-encoding"?: string | undefined;
+    "accept-language"?: string | undefined;
+    "accept-patch"?: string | undefined;
+    "accept-ranges"?: string | undefined;
+    "access-control-allow-credentials"?: string | undefined;
+    "access-control-allow-headers"?: string | undefined;
+    "access-control-allow-methods"?: string | undefined;
+    "access-control-allow-origin"?: string | undefined;
+    "access-control-expose-headers"?: string | undefined;
+    "access-control-max-age"?: string | undefined;
+    "access-control-request-headers"?: string | undefined;
+    "access-control-request-method"?: string | undefined;
+    age?: string | undefined;
+    allow?: string | undefined;
+    "alt-svc"?: string | undefined;
+    authorization?: string | undefined;
+    "cache-control"?: string | undefined;
+    connection?: string | undefined;
+    "content-disposition"?: string | undefined;
+    "content-encoding"?: string | undefined;
+    "content-language"?: string | undefined;
+    "content-length"?: string | undefined;
+    "content-location"?: string | undefined;
+    "content-range"?: string | undefined;
+    "content-type"?: string | undefined;
+    cookie?: string | undefined;
+    date?: string | undefined;
+    etag?: string | undefined;
+    expect?: string | undefined;
+    expires?: string | undefined;
+    forwarded?: string | undefined;
+    from?: string | undefined;
+    host?: string | undefined;
+    "if-match"?: string | undefined;
+    "if-modified-since"?: string | undefined;
+    "if-none-match"?: string | undefined;
+    "if-unmodified-since"?: string | undefined;
+    "last-modified"?: string | undefined;
+    location?: string | undefined;
+    origin?: string | undefined;
+    pragma?: string | undefined;
+    "proxy-authenticate"?: string | undefined;
+    "proxy-authorization"?: string | undefined;
+    "public-key-pins"?: string | undefined;
+    range?: string | undefined;
+    referer?: string | undefined;
+    "retry-after"?: string | undefined;
+    "sec-fetch-site"?: string | undefined;
+    "sec-fetch-mode"?: string | undefined;
+    "sec-fetch-user"?: string | undefined;
+    "sec-fetch-dest"?: string | undefined;
+    "sec-websocket-accept"?: string | undefined;
+    "sec-websocket-extensions"?: string | undefined;
+    "sec-websocket-key"?: string | undefined;
+    "sec-websocket-protocol"?: string | undefined;
+    "sec-websocket-version"?: string | undefined;
+    "set-cookie"?: string[] | undefined;
+    "strict-transport-security"?: string | undefined;
+    tk?: string | undefined;
+    trailer?: string | undefined;
+    "transfer-encoding"?: string | undefined;
+    upgrade?: string | undefined;
+    "user-agent"?: string | undefined;
+    vary?: string | undefined;
+    via?: string | undefined;
+    warning?: string | undefined;
+    "www-authenticate"?: string | undefined;
 }
 
-export type { Client, ClientOptions, ContentType, ContextBody, ContextParams, ContextSearchParams, EndpointConfig, EndpointSchemas, ExtractEndpoint, ExtractRoutesByMethod, Find, GetHttpHandlers, GetRouteParams, GlobalContext, GlobalCtx, GlobalMiddleware, GlobalMiddlewareContext, HTTPMethod, InferEndpoints, InferMethod, InferZod, MiddlewareFunction, Prettify, RemoveUndefined, RequestContext, RouteEndpoint, RouteHandler, RoutePattern, Router, RouterConfig, RoutesByMethod, ToInferZod };
+export type { Client, ClientOptions, ContentType, ContextBody, ContextParams, ContextSearchParams, EndpointConfig, EndpointSchemas, ExtractEndpoint, ExtractRoutesByMethod, FetchLike, Find, GetHttpHandlers, GetRouteParams, GlobalContext, GlobalCtx, GlobalMiddleware, GlobalMiddlewareContext, HTTPMethod, InferEndpoints, InferMethod, InferZod, MiddlewareFunction, Prettify, RemoveUndefined, RequestContext, RequestHeaders, RouteEndpoint, RouteHandler, RoutePattern, Router, RouterConfig, RoutesByMethod, ToInferZod };

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "@aura-stack/router",
-  "version": "0.6.0-rc.2",
+  "version": "0.6.0",
+  "private": false,
   "type": "module",
   "description": "A lightweight TypeScript library for building, managing, and validating API routes and endpoints in Node.js applications.",
   "repository": {
@@ -68,7 +69,9 @@
     "./types": "./dist/types.d.ts"
   },
   "devDependencies": {
+    "@types/bun": "^1.3.9",
     "@types/node": "24.6.2",
+    "mitata": "^1.0.34",
     "prettier": "^3.6.2",
     "tsup": "^8.5.1",
     "typescript": "^5.9.3",

package/dist/chunk-WJXMLTGP.js

@@ -1,163 +0,0 @@
-import {
-  executeGlobalMiddlewares,
-  executeMiddlewares
-} from "./chunk-6CIHAUKJ.js";
-import {
-  getBody,
-  getRouteParams,
-  getSearchParams
-} from "./chunk-SY4MM2AG.js";
-import {
-  isInvalidZodSchemaError,
-  isRouterError,
-  isSupportedMethod
-} from "./chunk-3X2BFSRT.js";
-import {
-  RouterError,
-  statusText
-} from "./chunk-FJYSN2I6.js";
-import {
-  HeadersBuilder
-} from "./chunk-6JNMFP4L.js";
-
-// 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 (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 (isInvalidZodSchemaError(error)) {
-    const { errors, status, statusText: statusText2 } = error;
-    return Response.json(
-      {
-        message: "Invalid request data",
-        error: "validation_error",
-        details: errors
-      },
-      { status, statusText: statusText2 }
-    );
-  }
-  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 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 = new HeadersBuilder(globalRequestContext.request.headers);
-    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);
-  }
-};
-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;
-};
-
-export {
-  createNode,
-  insert,
-  search,
-  createRouter
-};