@aura-stack/router 0.3.0 → 0.5.0

package/README.md

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

package/dist/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-FWDOXDWG.js → chunk-BWIKAYZV.js}

@@ -1,33 +1,33 @@
 import {
   RouterError
-} from "./chunk-GJC3ODME.js";
+} from "./chunk-B6PMGVSL.js";
 
 // src/middlewares.ts
-var executeGlobalMiddlewares = async (request, middlewares) => {
-  if (!middlewares) return request;
+var executeGlobalMiddlewares = async (context, middlewares) => {
+  if (!middlewares) return context;
   for (const middleware of middlewares) {
     if (typeof middleware !== "function") {
       throw new RouterError("BAD_REQUEST", "Global middlewares must be functions");
     }
-    const executed = await middleware(request);
+    const executed = await middleware(context);
     if (executed instanceof Response) {
       return executed;
     }
-    request = executed;
+    context = executed;
   }
-  if (!request || !(request instanceof Request)) {
+  if (!context || !(context.request instanceof Request)) {
     throw new RouterError("BAD_REQUEST", "Global middleware must return a Request or Response object");
   }
-  return request;
+  return context;
 };
-var executeMiddlewares = async (request, context, middlewares = []) => {
+var executeMiddlewares = async (context, middlewares = []) => {
   try {
     let ctx = context;
     for (const middleware of middlewares) {
       if (typeof middleware !== "function") {
         throw new RouterError("BAD_REQUEST", "Middleware must be a function");
       }
-      ctx = await middleware(request, ctx);
+      ctx = await middleware(ctx);
     }
     return ctx;
   } catch {

package/dist/{chunk-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-JIA6NLL6.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-FWDOXDWG.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 });
@@ -92,29 +106,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);

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