@aura-stack/router 0.4.0 → 0.5.0

package/dist/assert.cjs

@@ -20,6 +20,8 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/assert.ts
 var assert_exports = {};
 __export(assert_exports, {
+  isInvalidZodSchemaError: () => isInvalidZodSchemaError,
+  isObject: () => isObject,
   isRouterError: () => isRouterError,
   isSupportedBodyMethod: () => isSupportedBodyMethod,
   isSupportedMethod: () => isSupportedMethod,
@@ -76,6 +78,13 @@ var RouterError = class extends AuraStackRouterError {
     this.name = name ?? "RouterError";
   }
 };
+var InvalidZodSchemaError = class {
+  constructor(type, errors) {
+    this.status = statusCode[type];
+    this.statusText = statusText[type];
+    this.errors = errors;
+  }
+};
 
 // src/assert.ts
 var supportedMethods = /* @__PURE__ */ new Set(["GET", "POST", "DELETE", "PUT", "PATCH", "OPTIONS", "HEAD", "TRACE", "CONNECT"]);
@@ -97,8 +106,16 @@ var isValidHandler = (handler) => {
 var isRouterError = (error) => {
   return error instanceof RouterError;
 };
+var isObject = (value) => {
+  return typeof value === "object" && value !== null && value !== void 0 && !Array.isArray(value);
+};
+var isInvalidZodSchemaError = (error) => {
+  return error instanceof InvalidZodSchemaError;
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  isInvalidZodSchemaError,
+  isObject,
   isRouterError,
   isSupportedBodyMethod,
   isSupportedMethod,

package/dist/assert.d.ts

@@ -1,6 +1,8 @@
-import { RouterError } from './error.js';
+import { RouterError, InvalidZodSchemaError } from './error.js';
 import { HTTPMethod, RoutePattern, RouteHandler } from './types.js';
 import 'zod';
+import './headers.js';
+import 'cookie';
 
 declare const supportedProtocols: Set<string>;
 /**
@@ -48,5 +50,13 @@ declare const isValidHandler: (handler: unknown) => handler is RouteHandler<any,
  * }
  */
 declare const isRouterError: (error: unknown) => error is RouterError;
+declare const isObject: (value: unknown) => value is Record<string, unknown>;
+/**
+ * Checks if the provided error is an instance of InvalidZodSchemaError.
+ *
+ * @param error the error to check
+ * @returns true if the error is an instance of InvalidZodSchemaError, false otherwise.
+ */
+declare const isInvalidZodSchemaError: (error: unknown) => error is InvalidZodSchemaError;
 
-export { isRouterError, isSupportedBodyMethod, isSupportedMethod, isValidHandler, isValidRoute, supportedProtocols };
+export { isInvalidZodSchemaError, isObject, isRouterError, isSupportedBodyMethod, isSupportedMethod, isValidHandler, isValidRoute, supportedProtocols };

package/dist/assert.js

@@ -1,13 +1,17 @@
 import {
+  isInvalidZodSchemaError,
+  isObject,
   isRouterError,
   isSupportedBodyMethod,
   isSupportedMethod,
   isValidHandler,
   isValidRoute,
   supportedProtocols
-} from "./chunk-JNMXLKDG.js";
-import "./chunk-GJC3ODME.js";
+} from "./chunk-FU35BPU7.js";
+import "./chunk-B6PMGVSL.js";
 export {
+  isInvalidZodSchemaError,
+  isObject,
   isRouterError,
   isSupportedBodyMethod,
   isSupportedMethod,

package/dist/{chunk-6PZEXNTS.js → chunk-4UYDR5IO.js}

@@ -2,10 +2,10 @@ import {
   isSupportedMethod,
   isValidHandler,
   isValidRoute
-} from "./chunk-JNMXLKDG.js";
+} from "./chunk-FU35BPU7.js";
 import {
   RouterError
-} from "./chunk-GJC3ODME.js";
+} from "./chunk-B6PMGVSL.js";
 
 // src/endpoint.ts
 var createEndpoint = (method, route, handler, config = {}) => {

package/dist/{chunk-GJC3ODME.js → chunk-B6PMGVSL.js}

@@ -45,10 +45,18 @@ var RouterError = class extends AuraStackRouterError {
     this.name = name ?? "RouterError";
   }
 };
+var InvalidZodSchemaError = class {
+  constructor(type, errors) {
+    this.status = statusCode[type];
+    this.statusText = statusText[type];
+    this.errors = errors;
+  }
+};
 
 export {
   statusCode,
   statusText,
   AuraStackRouterError,
-  RouterError
+  RouterError,
+  InvalidZodSchemaError
 };

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

@@ -1,6 +1,6 @@
 import {
   RouterError
-} from "./chunk-GJC3ODME.js";
+} from "./chunk-B6PMGVSL.js";
 
 // src/middlewares.ts
 var executeGlobalMiddlewares = async (context, middlewares) => {

package/dist/{chunk-JNMXLKDG.js → chunk-FU35BPU7.js}

@@ -1,6 +1,7 @@
 import {
+  InvalidZodSchemaError,
   RouterError
-} from "./chunk-GJC3ODME.js";
+} from "./chunk-B6PMGVSL.js";
 
 // src/assert.ts
 var supportedMethods = /* @__PURE__ */ new Set(["GET", "POST", "DELETE", "PUT", "PATCH", "OPTIONS", "HEAD", "TRACE", "CONNECT"]);
@@ -22,6 +23,12 @@ var isValidHandler = (handler) => {
 var isRouterError = (error) => {
   return error instanceof RouterError;
 };
+var isObject = (value) => {
+  return typeof value === "object" && value !== null && value !== void 0 && !Array.isArray(value);
+};
+var isInvalidZodSchemaError = (error) => {
+  return error instanceof InvalidZodSchemaError;
+};
 
 export {
   supportedProtocols,
@@ -29,5 +36,7 @@ export {
   isSupportedBodyMethod,
   isValidRoute,
   isValidHandler,
-  isRouterError
+  isRouterError,
+  isObject,
+  isInvalidZodSchemaError
 };

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

@@ -1,21 +1,24 @@
 import {
   getBody,
-  getHeaders,
   getRouteParams,
   getSearchParams
-} from "./chunk-PT4GU6PH.js";
+} from "./chunk-XB5P5CQZ.js";
 import {
+  isInvalidZodSchemaError,
   isRouterError,
   isSupportedMethod
-} from "./chunk-JNMXLKDG.js";
+} from "./chunk-FU35BPU7.js";
+import {
+  HeadersBuilder
+} from "./chunk-Z6JJAIWN.js";
 import {
   executeGlobalMiddlewares,
   executeMiddlewares
-} from "./chunk-CFAIW6YL.js";
+} from "./chunk-BWIKAYZV.js";
 import {
   RouterError,
   statusText
-} from "./chunk-GJC3ODME.js";
+} from "./chunk-B6PMGVSL.js";
 
 // src/router.ts
 var createNode = () => ({
@@ -81,6 +84,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 });
@@ -107,7 +121,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/{chunk-PT4GU6PH.js → chunk-XB5P5CQZ.js}

@@ -1,16 +1,32 @@
 import {
   isSupportedBodyMethod
-} from "./chunk-JNMXLKDG.js";
+} from "./chunk-FU35BPU7.js";
 import {
+  InvalidZodSchemaError,
   RouterError
-} from "./chunk-GJC3ODME.js";
+} from "./chunk-B6PMGVSL.js";
 
 // src/context.ts
+var formatZodError = (error) => {
+  if (!error.issues || error.issues.length === 0) {
+    return {};
+  }
+  return error.issues.reduce((previous, issue) => {
+    const key = issue.path.join(".");
+    return {
+      ...previous,
+      [key]: {
+        code: issue.code,
+        message: issue.message
+      }
+    };
+  }, {});
+};
 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;
   }
@@ -21,15 +37,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;
@@ -41,7 +54,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;
     }
@@ -71,8 +84,8 @@ var createContentTypeRegex = (contentTypes, contenType) => {
 };
 
 export {
+  formatZodError,
   getRouteParams,
   getSearchParams,
-  getHeaders,
   getBody
 };

package/dist/chunk-Z6JJAIWN.js

@@ -0,0 +1,37 @@
+// src/headers.ts
+import { serialize, parse, parseSetCookie } from "cookie";
+var HeadersBuilder = class {
+  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", serialize(name, value, options));
+    return this;
+  }
+  getHeader(name) {
+    return this.headers.get(name);
+  }
+  getCookie(name) {
+    const cookies = 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 ? parseSetCookie(cookie).value : void 0;
+  }
+  toHeaders() {
+    return new Headers(this.headers);
+  }
+  toCookies() {
+    return parse(this.headers.get("cookie") ?? "");
+  }
+};
+
+export {
+  HeadersBuilder
+};

package/dist/context.cjs

@@ -20,8 +20,8 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/context.ts
 var context_exports = {};
 __export(context_exports, {
+  formatZodError: () => formatZodError,
   getBody: () => getBody,
-  getHeaders: () => getHeaders,
   getRouteParams: () => getRouteParams,
   getSearchParams: () => getSearchParams
 });
@@ -74,6 +74,13 @@ var RouterError = class extends AuraStackRouterError {
     this.name = name ?? "RouterError";
   }
 };
+var InvalidZodSchemaError = class {
+  constructor(type, errors) {
+    this.status = statusCode[type];
+    this.statusText = statusText[type];
+    this.errors = errors;
+  }
+};
 
 // src/assert.ts
 var supportedBodyMethods = /* @__PURE__ */ new Set(["POST", "PUT", "PATCH"]);
@@ -82,11 +89,26 @@ var isSupportedBodyMethod = (method) => {
 };
 
 // src/context.ts
+var formatZodError = (error) => {
+  if (!error.issues || error.issues.length === 0) {
+    return {};
+  }
+  return error.issues.reduce((previous, issue) => {
+    const key = issue.path.join(".");
+    return {
+      ...previous,
+      [key]: {
+        code: issue.code,
+        message: issue.message
+      }
+    };
+  }, {});
+};
 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;
   }
@@ -97,15 +119,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;
@@ -117,7 +136,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;
     }
@@ -147,8 +166,8 @@ var createContentTypeRegex = (contentTypes, contenType) => {
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  formatZodError,
   getBody,
-  getHeaders,
   getRouteParams,
   getSearchParams
 });

package/dist/context.d.ts

@@ -1,7 +1,14 @@
+import { ZodError } from 'zod';
 import { EndpointConfig, ContextSearchParams } from './types.js';
-import 'zod';
 import './error.js';
+import './headers.js';
+import 'cookie';
 
+/**
+ * @experimental
+ * @param error ZodError instance
+ */
+declare const formatZodError: (error: ZodError<Record<string, unknown>>) => {};
 /**
  * Extracts route parameters from a given path using the specified route pattern.
  *
@@ -53,21 +60,6 @@ declare const getRouteParams: (params: Record<string, string>, config: EndpointC
  * 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.
  *
@@ -82,4 +74,4 @@ declare const getHeaders: (request: Request) => Headers;
  */
 declare const getBody: <Config extends EndpointConfig>(request: Request, config: Config) => Promise<any>;
 
-export { getBody, getHeaders, getRouteParams, getSearchParams };
+export { formatZodError, getBody, getRouteParams, getSearchParams };

package/dist/context.js

@@ -1,14 +1,14 @@
 import {
+  formatZodError,
   getBody,
-  getHeaders,
   getRouteParams,
   getSearchParams
-} from "./chunk-PT4GU6PH.js";
-import "./chunk-JNMXLKDG.js";
-import "./chunk-GJC3ODME.js";
+} from "./chunk-XB5P5CQZ.js";
+import "./chunk-FU35BPU7.js";
+import "./chunk-B6PMGVSL.js";
 export {
+  formatZodError,
   getBody,
-  getHeaders,
   getRouteParams,
   getSearchParams
 };

package/dist/cookie.cjs

@@ -0,0 +1,24 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/cookie.ts
+var cookie_exports = {};
+module.exports = __toCommonJS(cookie_exports);
+__reExport(cookie_exports, require("cookie"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("cookie")
+});

package/dist/cookie.d.ts

@@ -0,0 +1 @@
+export * from 'cookie';

package/dist/cookie.js

@@ -0,0 +1,2 @@
+// src/cookie.ts
+export * from "cookie";

package/dist/endpoint.d.ts

@@ -1,6 +1,8 @@
 import { HTTPMethod, RoutePattern, EndpointSchemas, RouteHandler, EndpointConfig, RouteEndpoint } from './types.js';
 import 'zod';
 import './error.js';
+import './headers.js';
+import 'cookie';
 
 /**
  * Defines an API endpoint for the router by specifying the HTTP method, route pattern,

package/dist/endpoint.js

@@ -1,9 +1,9 @@
 import {
   createEndpoint,
   createEndpointConfig
-} from "./chunk-6PZEXNTS.js";
-import "./chunk-JNMXLKDG.js";
-import "./chunk-GJC3ODME.js";
+} from "./chunk-4UYDR5IO.js";
+import "./chunk-FU35BPU7.js";
+import "./chunk-B6PMGVSL.js";
 export {
   createEndpoint,
   createEndpointConfig

package/dist/error.cjs

@@ -21,6 +21,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var error_exports = {};
 __export(error_exports, {
   AuraStackRouterError: () => AuraStackRouterError,
+  InvalidZodSchemaError: () => InvalidZodSchemaError,
   RouterError: () => RouterError,
   statusCode: () => statusCode,
   statusText: () => statusText
@@ -72,9 +73,17 @@ var RouterError = class extends AuraStackRouterError {
     this.name = name ?? "RouterError";
   }
 };
+var InvalidZodSchemaError = class {
+  constructor(type, errors) {
+    this.status = statusCode[type];
+    this.statusText = statusText[type];
+    this.errors = errors;
+  }
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AuraStackRouterError,
+  InvalidZodSchemaError,
   RouterError,
   statusCode,
   statusText

package/dist/error.d.ts

@@ -61,5 +61,11 @@ declare class AuraStackRouterError extends Error {
 declare class RouterError extends AuraStackRouterError {
     constructor(type: StatusCode, message: string, name?: string);
 }
+declare class InvalidZodSchemaError {
+    readonly status: number;
+    readonly statusText: StatusCode;
+    readonly errors: Record<string, string>;
+    constructor(type: StatusCode, errors: Record<string, string>);
+}
 
-export { AuraStackRouterError, RouterError, statusCode, statusText };
+export { AuraStackRouterError, InvalidZodSchemaError, RouterError, statusCode, statusText };

package/dist/error.js

@@ -1,11 +1,13 @@
 import {
   AuraStackRouterError,
+  InvalidZodSchemaError,
   RouterError,
   statusCode,
   statusText
-} from "./chunk-GJC3ODME.js";
+} from "./chunk-B6PMGVSL.js";
 export {
   AuraStackRouterError,
+  InvalidZodSchemaError,
   RouterError,
   statusCode,
   statusText

package/dist/headers.cjs

@@ -0,0 +1,61 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/headers.ts
+var headers_exports = {};
+__export(headers_exports, {
+  HeadersBuilder: () => HeadersBuilder
+});
+module.exports = __toCommonJS(headers_exports);
+var import_cookie = require("cookie");
+var HeadersBuilder = class {
+  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") ?? "");
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  HeadersBuilder
+});

package/dist/headers.d.ts

@@ -0,0 +1,20 @@
+import { SerializeOptions, Cookies } from 'cookie';
+
+/**
+ * A builder class for constructing and manipulating HTTP headers.
+ * It includes methods to set, delete, and retrieve headers, as well as
+ * manage cookies within the headers.
+ */
+declare class HeadersBuilder {
+    private headers;
+    constructor(initialHeaders?: HeadersInit);
+    setHeader(name: string, value: string): HeadersBuilder;
+    setCookie(name: string, value: string, options?: SerializeOptions): HeadersBuilder;
+    getHeader(name: string): string | null;
+    getCookie(name: string): string | undefined;
+    getSetCookie(name: string): string | undefined;
+    toHeaders(): Headers;
+    toCookies(): Cookies;
+}
+
+export { HeadersBuilder };

package/dist/headers.js

@@ -0,0 +1,6 @@
+import {
+  HeadersBuilder
+} from "./chunk-Z6JJAIWN.js";
+export {
+  HeadersBuilder
+};

package/dist/index.cjs

@@ -20,10 +20,12 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  HeadersBuilder: () => HeadersBuilder,
   RouterError: () => RouterError,
   createEndpoint: () => createEndpoint,
   createEndpointConfig: () => createEndpointConfig,
   createRouter: () => createRouter,
+  isInvalidZodSchemaError: () => isInvalidZodSchemaError,
   isRouterError: () => isRouterError,
   statusCode: () => statusCode,
   statusText: () => statusText
@@ -77,6 +79,13 @@ var RouterError = class extends AuraStackRouterError {
     this.name = name ?? "RouterError";
   }
 };
+var InvalidZodSchemaError = class {
+  constructor(type, errors) {
+    this.status = statusCode[type];
+    this.statusText = statusText[type];
+    this.errors = errors;
+  }
+};
 
 // src/assert.ts
 var supportedMethods = /* @__PURE__ */ new Set(["GET", "POST", "DELETE", "PUT", "PATCH", "OPTIONS", "HEAD", "TRACE", "CONNECT"]);
@@ -97,6 +106,9 @@ var isValidHandler = (handler) => {
 var isRouterError = (error) => {
   return error instanceof RouterError;
 };
+var isInvalidZodSchemaError = (error) => {
+  return error instanceof InvalidZodSchemaError;
+};
 
 // src/endpoint.ts
 var createEndpoint = (method, route, handler, config = {}) => {
@@ -116,45 +128,61 @@ 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;
+// src/headers.ts
+var import_cookie = require("cookie");
+var HeadersBuilder = class {
+  constructor(initialHeaders) {
+    this.headers = new Headers(initialHeaders);
   }
-  if (!context || !(context.request instanceof Request)) {
-    throw new RouterError("BAD_REQUEST", "Global middleware must return a Request or Response object");
+  setHeader(name, value) {
+    this.headers.set(name, value);
+    return this;
   }
-  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");
+  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/context.ts
+var formatZodError = (error) => {
+  if (!error.issues || error.issues.length === 0) {
+    return {};
+  }
+  return error.issues.reduce((previous, issue) => {
+    const key = issue.path.join(".");
+    return {
+      ...previous,
+      [key]: {
+        code: issue.code,
+        message: issue.message
+      }
+    };
+  }, {});
+};
 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;
   }
@@ -165,15 +193,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;
@@ -185,7 +210,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;
     }
@@ -214,6 +239,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(),
@@ -278,6 +336,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 });
@@ -304,7 +373,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,
@@ -339,10 +408,12 @@ var createRouter = (endpoints, config = {}) => {
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  HeadersBuilder,
   RouterError,
   createEndpoint,
   createEndpointConfig,
   createRouter,
+  isInvalidZodSchemaError,
   isRouterError,
   statusCode,
   statusText

package/dist/index.d.ts

@@ -1,6 +1,8 @@
 export { createEndpoint, createEndpointConfig } from './endpoint.js';
 export { createRouter } from './router.js';
-export { isRouterError } from './assert.js';
+export { isInvalidZodSchemaError, isRouterError } from './assert.js';
 export { RouterError, statusCode, statusText } from './error.js';
+export { HeadersBuilder } from './headers.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 'cookie';
 import 'zod';

package/dist/index.js

@@ -1,25 +1,31 @@
+import {
+  createRouter
+} from "./chunk-TEDN6QMU.js";
+import "./chunk-XB5P5CQZ.js";
 import {
   createEndpoint,
   createEndpointConfig
-} from "./chunk-6PZEXNTS.js";
-import {
-  createRouter
-} from "./chunk-CL5D7UJU.js";
-import "./chunk-PT4GU6PH.js";
+} from "./chunk-4UYDR5IO.js";
 import {
+  isInvalidZodSchemaError,
   isRouterError
-} from "./chunk-JNMXLKDG.js";
-import "./chunk-CFAIW6YL.js";
+} from "./chunk-FU35BPU7.js";
+import {
+  HeadersBuilder
+} from "./chunk-Z6JJAIWN.js";
+import "./chunk-BWIKAYZV.js";
 import {
   RouterError,
   statusCode,
   statusText
-} from "./chunk-GJC3ODME.js";
+} from "./chunk-B6PMGVSL.js";
 export {
+  HeadersBuilder,
   RouterError,
   createEndpoint,
   createEndpointConfig,
   createRouter,
+  isInvalidZodSchemaError,
   isRouterError,
   statusCode,
   statusText

package/dist/middlewares.d.ts

@@ -1,6 +1,8 @@
 import { GlobalMiddlewareContext, RouterConfig, EndpointConfig, RequestContext, MiddlewareFunction } from './types.js';
 import 'zod';
 import './error.js';
+import './headers.js';
+import 'cookie';
 
 /**
  * Executes the middlewares in sequence, passing the request to each middleware.
@@ -9,7 +11,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-BWIKAYZV.js";
+import "./chunk-B6PMGVSL.js";
 export {
   executeGlobalMiddlewares,
   executeMiddlewares

package/dist/router.cjs

@@ -74,6 +74,47 @@ var RouterError = class extends AuraStackRouterError {
     this.name = name ?? "RouterError";
   }
 };
+var InvalidZodSchemaError = class {
+  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 {
+  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 +128,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 +163,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 +180,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 +209,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 +306,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 +343,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,8 @@
 import { RouteEndpoint, RouterConfig, GetHttpHandlers, HTTPMethod, RoutePattern, EndpointSchemas, MiddlewareFunction } from './types.js';
 import 'zod';
 import './error.js';
+import './headers.js';
+import 'cookie';
 
 interface TrieNode {
     statics: Map<string, TrieNode>;

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-TEDN6QMU.js";
+import "./chunk-XB5P5CQZ.js";
+import "./chunk-FU35BPU7.js";
+import "./chunk-Z6JJAIWN.js";
+import "./chunk-BWIKAYZV.js";
+import "./chunk-B6PMGVSL.js";
 export {
   createNode,
   createRouter,

package/dist/types.d.ts

@@ -1,5 +1,7 @@
 import { ZodObject, z } from 'zod';
 import { RouterError } from './error.js';
+import { HeadersBuilder } from './headers.js';
+import 'cookie';
 
 /**
  * Route pattern must start with a slash and can contain parameters prefixed with a colon.
@@ -102,7 +104,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;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aura-stack/router",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "type": "module",
   "description": "A lightweight TypeScript library for building, managing, and validating API routes and endpoints in Node.js applications.",
   "repository": {
@@ -50,6 +50,16 @@
       "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"
+    },
     "./types": "./dist/types.d.ts"
   },
   "devDependencies": {
@@ -59,6 +69,9 @@
     "vitest": "^3.2.4",
     "zod": "^4.1.11"
   },
+  "dependencies": {
+    "cookie": "^1.1.1"
+  },
   "scripts": {
     "dev": "tsup --watch",
     "dev:docs": "pnpm --filter docs dev",