@aura-stack/router 0.3.0 → 0.5.0

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,12 +128,61 @@ function createEndpointConfig(...args) {
   return args[0];
 }
 
+// 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/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;
   }
@@ -132,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;
@@ -152,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;
     }
@@ -182,31 +240,31 @@ var createContentTypeRegex = (contentTypes, contenType) => {
 };
 
 // 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 {
@@ -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 });
@@ -289,29 +358,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 = new HeadersBuilder(globalRequestContext.request.headers);
+    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);
@@ -333,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 { ContentType, ContextBody, ContextParams, ContextSearchParams, EndpointConfig, EndpointSchemas, GetHttpHandlers, GetRouteParams, GlobalMiddleware, HTTPMethod, InferMethod, MiddlewareFunction, Prettify, RequestContext, RouteEndpoint, RouteHandler, RoutePattern, RouterConfig } from './types.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-JIA6NLL6.js";
-import "./chunk-PT4GU6PH.js";
+} from "./chunk-4UYDR5IO.js";
 import {
+  isInvalidZodSchemaError,
   isRouterError
-} from "./chunk-JNMXLKDG.js";
-import "./chunk-FWDOXDWG.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.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,6 +1,8 @@
-import { RouterConfig, EndpointConfig, RequestContext, MiddlewareFunction } from './types.js';
+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: (request: Request, middlewares: RouterConfig["middlewares"]) => Promise<Request | Response>;
+declare const executeGlobalMiddlewares: (context: GlobalMiddlewareContext, middlewares: RouterConfig["middlewares"]) => Promise<Response | GlobalMiddlewareContext>;
 /**
  * Executes middlewares in sequence, passing the request and context to each middleware.
  *
@@ -18,6 +20,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,8 +1,8 @@
 import {
   executeGlobalMiddlewares,
   executeMiddlewares
-} from "./chunk-FWDOXDWG.js";
-import "./chunk-GJC3ODME.js";
+} from "./chunk-BWIKAYZV.js";
+import "./chunk-B6PMGVSL.js";
 export {
   executeGlobalMiddlewares,
   executeMiddlewares