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

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,
@@ -63,6 +65,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";
@@ -76,6 +96,16 @@ 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/assert.ts
 var supportedMethods = /* @__PURE__ */ new Set(["GET", "POST", "DELETE", "PUT", "PATCH", "OPTIONS", "HEAD", "TRACE", "CONNECT"]);
@@ -97,8 +127,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,9 @@
-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';
+import 'http';
 
 declare const supportedProtocols: Set<string>;
 /**
@@ -48,5 +51,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-3X2BFSRT.js";
+import "./chunk-FJYSN2I6.js";
 export {
+  isInvalidZodSchemaError,
+  isObject,
   isRouterError,
   isSupportedBodyMethod,
   isSupportedMethod,

package/dist/{chunk-JNMXLKDG.js → chunk-3X2BFSRT.js}

@@ -1,6 +1,7 @@
 import {
+  InvalidZodSchemaError,
   RouterError
-} from "./chunk-GJC3ODME.js";
+} from "./chunk-FJYSN2I6.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-6PZEXNTS.js → chunk-5F6FUKTB.js}

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

package/dist/{chunk-CFAIW6YL.js → chunk-6CIHAUKJ.js}

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

package/dist/chunk-6JNMFP4L.js

@@ -0,0 +1,38 @@
+// src/headers.ts
+import { serialize, parse, parseSetCookie } from "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", 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/{chunk-GJC3ODME.js → chunk-FJYSN2I6.js}

@@ -32,6 +32,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";
@@ -45,10 +63,21 @@ 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;
+  }
+};
 
 export {
   statusCode,
   statusText,
   AuraStackRouterError,
-  RouterError
+  RouterError,
+  InvalidZodSchemaError
 };

package/dist/chunk-MP4L2ICK.js

@@ -0,0 +1,38 @@
+// src/client.ts
+function createClient(options) {
+  const { baseURL, headers: defaultHeaders } = options;
+  return new Proxy(
+    {},
+    {
+      get(_, prop) {
+        const method = prop.toString().toUpperCase();
+        return async (path, ctx) => {
+          const searchParams = new URLSearchParams(ctx?.searchParams);
+          let interpolatedPath = path;
+          for (const [key, value] of Object.entries(ctx?.params ?? {})) {
+            interpolatedPath = interpolatedPath.replace(`:${key}`, String(value));
+          }
+          const url = new URL(interpolatedPath, baseURL);
+          if (searchParams.size > 0) {
+            url.search = searchParams.toString();
+          }
+          const { params: _p, searchParams: _s, ...requestInit } = ctx ?? {};
+          const response = await fetch(url.toString(), {
+            ...requestInit,
+            method,
+            headers: {
+              ...defaultHeaders,
+              ...ctx?.headers
+            },
+            body: ctx?.body ? ctx.body instanceof FormData ? ctx.body : JSON.stringify(ctx.body) : void 0
+          });
+          return response;
+        };
+      }
+    }
+  );
+}
+
+export {
+  createClient
+};

package/dist/{chunk-PT4GU6PH.js → chunk-SY4MM2AG.js}

@@ -1,16 +1,32 @@
 import {
   isSupportedBodyMethod
-} from "./chunk-JNMXLKDG.js";
+} from "./chunk-3X2BFSRT.js";
 import {
+  InvalidZodSchemaError,
   RouterError
-} from "./chunk-GJC3ODME.js";
+} from "./chunk-FJYSN2I6.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-CL5D7UJU.js → chunk-WJXMLTGP.js}

@@ -1,21 +1,24 @@
+import {
+  executeGlobalMiddlewares,
+  executeMiddlewares
+} from "./chunk-6CIHAUKJ.js";
 import {
   getBody,
-  getHeaders,
   getRouteParams,
   getSearchParams
-} from "./chunk-PT4GU6PH.js";
+} from "./chunk-SY4MM2AG.js";
 import {
+  isInvalidZodSchemaError,
   isRouterError,
   isSupportedMethod
-} from "./chunk-JNMXLKDG.js";
-import {
-  executeGlobalMiddlewares,
-  executeMiddlewares
-} from "./chunk-CFAIW6YL.js";
+} from "./chunk-3X2BFSRT.js";
 import {
   RouterError,
   statusText
-} from "./chunk-GJC3ODME.js";
+} from "./chunk-FJYSN2I6.js";
+import {
+  HeadersBuilder
+} from "./chunk-6JNMFP4L.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/client.cjs

@@ -0,0 +1,62 @@
+"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/client.ts
+var client_exports = {};
+__export(client_exports, {
+  createClient: () => createClient
+});
+module.exports = __toCommonJS(client_exports);
+function createClient(options) {
+  const { baseURL, headers: defaultHeaders } = options;
+  return new Proxy(
+    {},
+    {
+      get(_, prop) {
+        const method = prop.toString().toUpperCase();
+        return async (path, ctx) => {
+          const searchParams = new URLSearchParams(ctx?.searchParams);
+          let interpolatedPath = path;
+          for (const [key, value] of Object.entries(ctx?.params ?? {})) {
+            interpolatedPath = interpolatedPath.replace(`:${key}`, String(value));
+          }
+          const url = new URL(interpolatedPath, baseURL);
+          if (searchParams.size > 0) {
+            url.search = searchParams.toString();
+          }
+          const { params: _p, searchParams: _s, ...requestInit } = ctx ?? {};
+          const response = await fetch(url.toString(), {
+            ...requestInit,
+            method,
+            headers: {
+              ...defaultHeaders,
+              ...ctx?.headers
+            },
+            body: ctx?.body ? ctx.body instanceof FormData ? ctx.body : JSON.stringify(ctx.body) : void 0
+          });
+          return response;
+        };
+      }
+    }
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createClient
+});

package/dist/client.d.ts

@@ -0,0 +1,26 @@
+import { Router, ClientOptions, Client, InferEndpoints } from './types.js';
+import 'zod';
+import './error.js';
+import './headers.js';
+import 'cookie';
+import 'http';
+
+/**
+ * Creates a client API for making requests to the specified router. It provides type-safe methods
+ * based on the router's endpoints.
+ *
+ * @param options - Configuration options for the client, including baseURL and default headers.
+ * @returns A client object with methods corresponding to HTTP methods (GET, POST, etc.).
+ * @example
+ * import { createClient } from "aura-stack/router/client";
+ * import { appRouter } from "./server";
+ *
+ * const client = createClient<typeof appRouter>({
+ *   baseURL: "http://localhost:3000/api",
+ * })
+ *
+ * client.get("/users")
+ */
+declare function createClient<InferRouter extends Router<any>>(options: ClientOptions): Client<InferEndpoints<InferRouter>>;
+
+export { createClient };

package/dist/client.js

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

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
 });
@@ -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,16 @@ 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/assert.ts
 var supportedBodyMethods = /* @__PURE__ */ new Set(["POST", "PUT", "PATCH"]);
@@ -82,11 +110,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 +140,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 +157,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 +187,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,15 @@
+import { ZodError } from 'zod';
 import { EndpointConfig, ContextSearchParams } from './types.js';
-import 'zod';
 import './error.js';
+import './headers.js';
+import 'cookie';
+import 'http';
 
+/**
+ * @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 +61,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 +75,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 };