@aura-stack/router 0.4.0 → 0.6.0-rc.1

package/dist/middlewares.d.ts

@@ -1,6 +1,9 @@
 import { GlobalMiddlewareContext, RouterConfig, EndpointConfig, RequestContext, MiddlewareFunction } from './types.js';
 import 'zod';
 import './error.js';
+import './headers.js';
+import 'cookie';
+import 'http';
 
 /**
  * Executes the middlewares in sequence, passing the request to each middleware.
@@ -9,7 +12,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: (context: GlobalMiddlewareContext, middlewares: RouterConfig["middlewares"]) => Promise<GlobalMiddlewareContext | Response>;
+declare const executeGlobalMiddlewares: (context: GlobalMiddlewareContext, middlewares: RouterConfig["middlewares"]) => Promise<Response | GlobalMiddlewareContext>;
 /**
  * Executes middlewares in sequence, passing the request and context to each middleware.
  *

package/dist/middlewares.js

@@ -1,8 +1,8 @@
 import {
   executeGlobalMiddlewares,
   executeMiddlewares
-} from "./chunk-CFAIW6YL.js";
-import "./chunk-GJC3ODME.js";
+} from "./chunk-6CIHAUKJ.js";
+import "./chunk-FJYSN2I6.js";
 export {
   executeGlobalMiddlewares,
   executeMiddlewares

package/dist/router.cjs

@@ -61,6 +61,24 @@ var statusText = Object.keys(statusCode).reduce(
   {}
 );
 var AuraStackRouterError = class 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
+   */
+  status;
+  /**
+   * 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
+   */
+  statusText;
   constructor(type, message, name) {
     super(message);
     this.name = name ?? "RouterError";
@@ -74,6 +92,51 @@ var RouterError = class extends AuraStackRouterError {
     this.name = name ?? "RouterError";
   }
 };
+var InvalidZodSchemaError = class {
+  status;
+  statusText;
+  errors;
+  constructor(type, errors) {
+    this.status = statusCode[type];
+    this.statusText = statusText[type];
+    this.errors = errors;
+  }
+};
+
+// src/headers.ts
+var import_cookie = require("cookie");
+var HeadersBuilder = class {
+  headers;
+  constructor(initialHeaders) {
+    this.headers = new Headers(initialHeaders);
+  }
+  setHeader(name, value) {
+    this.headers.set(name, value);
+    return this;
+  }
+  setCookie(name, value, options) {
+    this.headers.append("Set-Cookie", (0, import_cookie.serialize)(name, value, options));
+    return this;
+  }
+  getHeader(name) {
+    return this.headers.get(name);
+  }
+  getCookie(name) {
+    const cookies = (0, import_cookie.parse)(this.headers.get("cookie") ?? "");
+    return cookies[name];
+  }
+  getSetCookie(name) {
+    const cookies = this.headers.getSetCookie();
+    const cookie = cookies.find((cookie2) => cookie2.startsWith(name + "="));
+    return cookie ? (0, import_cookie.parseSetCookie)(cookie).value : void 0;
+  }
+  toHeaders() {
+    return new Headers(this.headers);
+  }
+  toCookies() {
+    return (0, import_cookie.parse)(this.headers.get("cookie") ?? "");
+  }
+};
 
 // src/assert.ts
 var supportedMethods = /* @__PURE__ */ new Set(["GET", "POST", "DELETE", "PUT", "PATCH", "OPTIONS", "HEAD", "TRACE", "CONNECT"]);
@@ -87,46 +150,31 @@ var isSupportedBodyMethod = (method) => {
 var isRouterError = (error) => {
   return error instanceof RouterError;
 };
+var isInvalidZodSchemaError = (error) => {
+  return error instanceof InvalidZodSchemaError;
+};
 
-// 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");
+// src/context.ts
+var formatZodError = (error) => {
+  if (!error.issues || error.issues.length === 0) {
+    return {};
   }
-  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");
+  return error.issues.reduce((previous, issue) => {
+    const key = issue.path.join(".");
+    return {
+      ...previous,
+      [key]: {
+        code: issue.code,
+        message: issue.message
       }
-      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) {
     const parsed = config.schemas.params.safeParse(params);
     if (!parsed.success) {
-      throw new RouterError("UNPROCESSABLE_ENTITY", "Invalid route parameters");
+      throw new InvalidZodSchemaError("UNPROCESSABLE_ENTITY", formatZodError(parsed.error));
     }
     return parsed.data;
   }
@@ -137,15 +185,12 @@ var getSearchParams = (url, config) => {
   if (config.schemas?.searchParams) {
     const parsed = config.schemas.searchParams.safeParse(Object.fromEntries(route.searchParams.entries()));
     if (!parsed.success) {
-      throw new RouterError("UNPROCESSABLE_ENTITY", "Invalid search parameters");
+      throw new InvalidZodSchemaError("UNPROCESSABLE_ENTITY", formatZodError(parsed.error));
     }
     return parsed.data;
   }
   return new URLSearchParams(route.searchParams.toString());
 };
-var getHeaders = (request) => {
-  return new Headers(request.headers);
-};
 var getBody = async (request, config) => {
   if (!isSupportedBodyMethod(request.method)) {
     return null;
@@ -157,7 +202,7 @@ var getBody = async (request, config) => {
     if (config.schemas?.body) {
       const parsed = config.schemas.body.safeParse(json);
       if (!parsed.success) {
-        throw new RouterError("UNPROCESSABLE_ENTITY", "Invalid request body");
+        throw new InvalidZodSchemaError("UNPROCESSABLE_ENTITY", formatZodError(parsed.error));
       }
       return parsed.data;
     }
@@ -186,6 +231,39 @@ var createContentTypeRegex = (contentTypes, contenType) => {
   return regex.test(contenType);
 };
 
+// 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/router.ts
 var createNode = () => ({
   statics: /* @__PURE__ */ new Map(),
@@ -250,6 +328,17 @@ var handleError = async (error, request, config) => {
       );
     }
   }
+  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 });
@@ -276,7 +365,7 @@ var handleRequest = async (method, request, config, root) => {
     const dynamicParams = getRouteParams(params, endpoint.config);
     const body = await getBody(globalRequestContext.request, endpoint.config);
     const searchParams = getSearchParams(globalRequestContext.request.url, endpoint.config);
-    const headers = getHeaders(globalRequestContext.request);
+    const headers = new HeadersBuilder(globalRequestContext.request.headers);
     let context = {
       params: dynamicParams,
       searchParams,

package/dist/router.d.ts

@@ -1,6 +1,9 @@
-import { RouteEndpoint, RouterConfig, GetHttpHandlers, HTTPMethod, RoutePattern, EndpointSchemas, MiddlewareFunction } from './types.js';
+import { RouteEndpoint, RouterConfig, Router, HTTPMethod, RoutePattern, EndpointSchemas, MiddlewareFunction } from './types.js';
 import 'zod';
 import './error.js';
+import './headers.js';
+import 'cookie';
+import 'http';
 
 interface TrieNode {
     statics: Map<string, TrieNode>;
@@ -32,6 +35,6 @@ declare const search: (method: HTTPMethod, root: TrieNode, pathname: string) =>
  * @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>;
+declare const createRouter: <const Endpoints extends RouteEndpoint[]>(endpoints: Endpoints, config?: RouterConfig) => Router<Endpoints>;
 
 export { createNode, createRouter, insert, search };

package/dist/router.js

@@ -3,11 +3,12 @@ import {
   createRouter,
   insert,
   search
-} from "./chunk-CL5D7UJU.js";
-import "./chunk-PT4GU6PH.js";
-import "./chunk-JNMXLKDG.js";
-import "./chunk-CFAIW6YL.js";
-import "./chunk-GJC3ODME.js";
+} from "./chunk-WJXMLTGP.js";
+import "./chunk-6CIHAUKJ.js";
+import "./chunk-SY4MM2AG.js";
+import "./chunk-3X2BFSRT.js";
+import "./chunk-FJYSN2I6.js";
+import "./chunk-6JNMFP4L.js";
 export {
   createNode,
   createRouter,

package/dist/types.d.ts

@@ -1,5 +1,8 @@
 import { ZodObject, z } from 'zod';
 import { RouterError } from './error.js';
+import { HeadersBuilder } from './headers.js';
+import { IncomingHttpHeaders } from 'http';
+import 'cookie';
 
 /**
  * Route pattern must start with a slash and can contain parameters prefixed with a colon.
@@ -102,7 +105,7 @@ type ContextParams<Schemas extends EndpointConfig["schemas"], Default = Record<s
  */
 interface RequestContext<RouteParams = Record<string, string>, Config extends EndpointConfig = EndpointConfig> {
     params: ContextParams<Config["schemas"], RouteParams>["params"];
-    headers: Headers;
+    headers: HeadersBuilder;
     body: ContextBody<Config["schemas"]>["body"];
     searchParams: ContextSearchParams<Config["schemas"]>["searchParams"];
     request: Request;
@@ -208,5 +211,50 @@ interface RouterConfig extends GlobalCtx {
      */
     onError?: (error: Error | RouterError, request: Request) => Response | Promise<Response>;
 }
+/**
+ * @experimental
+ */
+type ExtractEndpoint<T> = T extends RouteEndpoint<infer M, infer P, infer C> ? {
+    method: M;
+    path: P;
+    config: C;
+} : never;
+/**
+ * @experimental
+ */
+type RoutesByMethod<Defs extends readonly RouteEndpoint[], Met extends HTTPMethod> = ExtractEndpoint<Defs[number]> extends infer E ? (E extends {
+    method: Met;
+    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;
+type InferZod<T> = T extends z.ZodTypeAny ? z.infer<T> : T;
+type ToInferZod<T> = {
+    [K in keyof T]: InferZod<T[K]>;
+};
+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 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>;
+};
+declare const endpointsSymbol: unique symbol;
+type Router<Endpoints extends RouteEndpoint[]> = GetHttpHandlers<Endpoints> & {
+    readonly [endpointsSymbol]?: Endpoints;
+};
+type InferEndpoints<T> = T extends Router<infer E> ? E : never;
+interface ClientOptions {
+    /**
+     * Base URL for the router client to make requests to the server.
+     * This is useful when the server is hosted on a different origin.
+     *
+     * baseURL: "https://api.example.com"
+     */
+    baseURL: string;
+    /**
+     * Default headers to include in every request made by the client.
+     */
+    headers?: IncomingHttpHeaders;
+}
 
-export type { ContentType, ContextBody, ContextParams, ContextSearchParams, EndpointConfig, EndpointSchemas, GetHttpHandlers, GetRouteParams, GlobalContext, GlobalCtx, GlobalMiddleware, GlobalMiddlewareContext, HTTPMethod, InferMethod, MiddlewareFunction, Prettify, RequestContext, RouteEndpoint, RouteHandler, RoutePattern, RouterConfig };
+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 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aura-stack/router",
-  "version": "0.4.0",
+  "version": "0.6.0-rc.1",
   "type": "module",
   "description": "A lightweight TypeScript library for building, managing, and validating API routes and endpoints in Node.js applications.",
   "repository": {
@@ -50,15 +50,34 @@
       "import": "./dist/error.js",
       "require": "./dist/error.cjs"
     },
+    "./headers": {
+      "types": "./dist/headers.d.ts",
+      "import": "./dist/headers.js",
+      "require": "./dist/headers.cjs"
+    },
+    "./cookie": {
+      "types": "./dist/cookie.d.ts",
+      "import": "./dist/cookie.js",
+      "require": "./dist/cookie.cjs"
+    },
+    "./client": {
+      "types": "./dist/client.d.ts",
+      "import": "./dist/client.js",
+      "require": "./dist/client.cjs"
+    },
     "./types": "./dist/types.d.ts"
   },
   "devDependencies": {
+    "@types/node": "24.6.2",
     "prettier": "^3.6.2",
-    "tsup": "^8.5.0",
+    "tsup": "^8.5.1",
     "typescript": "^5.9.3",
-    "vitest": "^3.2.4",
+    "vitest": "^4.0.18",
     "zod": "^4.1.11"
   },
+  "dependencies": {
+    "cookie": "^1.1.1"
+  },
   "scripts": {
     "dev": "tsup --watch",
     "dev:docs": "pnpm --filter docs dev",