@aura-stack/router 0.6.0-rc.2 → 0.6.0

package/dist/index.cjs

@@ -113,6 +113,9 @@ var InvalidZodSchemaError = class {
 var supportedMethods = /* @__PURE__ */ new Set(["GET", "POST", "DELETE", "PUT", "PATCH", "OPTIONS", "HEAD", "TRACE", "CONNECT"]);
 var supportedBodyMethods = /* @__PURE__ */ new Set(["POST", "PUT", "PATCH"]);
 var isSupportedMethod = (method) => {
+  if (Array.isArray(method)) {
+    return method.every((meth) => supportedMethods.has(meth));
+  }
   return supportedMethods.has(method);
 };
 var isSupportedBodyMethod = (method) => {
@@ -150,6 +153,143 @@ function createEndpointConfig(...args) {
   return args[0];
 }
 
+// src/trie.ts
+var TrieNode = class {
+  param;
+  statics = /* @__PURE__ */ new Map();
+  endpoints = /* @__PURE__ */ new Map();
+};
+var TrieRouter = class {
+  root;
+  statics;
+  methods;
+  constructor() {
+    this.statics = /* @__PURE__ */ new Map();
+    this.methods = /* @__PURE__ */ new Set();
+    this.root = new TrieNode();
+  }
+  add(endpoint) {
+    const isDynamic = endpoint.route.includes(":");
+    const methods = Array.isArray(endpoint.method) ? endpoint.method : [endpoint.method];
+    if (!isDynamic) {
+      for (const method of methods) {
+        this.statics.set(`${method} ${endpoint.route}`, endpoint);
+      }
+    } else {
+      let node = this.root;
+      const route = endpoint.route;
+      const routeLength = route.length;
+      let prev = 0;
+      while (prev < routeLength) {
+        const curr = route.indexOf("/", prev);
+        const end = curr === -1 ? routeLength : curr;
+        if (end > prev) {
+          const segment = route.slice(prev, end);
+          if (segment[0] === ":") {
+            const name = segment.slice(1);
+            let param = node.param;
+            if (!param) {
+              param = { name, node: new TrieNode() };
+              node.param = param;
+            } else if (param.name !== name) {
+              throw new RouterError(
+                "BAD_REQUEST",
+                `Conflicting in the route by the dynamic segment "${param.name}" and "${name}"`
+              );
+            }
+            node = param.node;
+          } else {
+            let child = node.statics.get(segment);
+            if (!child) {
+              child = new TrieNode();
+              node.statics.set(segment, child);
+            }
+            node = child;
+          }
+        }
+        if (curr === -1) {
+          break;
+        }
+        prev = curr + 1;
+      }
+      for (const method of methods) {
+        node.endpoints.set(method, endpoint);
+      }
+    }
+    for (const method of methods) {
+      this.methods.add(method);
+    }
+  }
+  match(method, pathname) {
+    const staticEndpoint = this.statics.get(`${method} ${pathname}`);
+    if (staticEndpoint) {
+      return { endpoint: staticEndpoint, params: {} };
+    }
+    let node = this.root;
+    const params = {};
+    const pathLength = pathname.length;
+    let prev = 0;
+    while (prev < pathLength) {
+      const curr = pathname.indexOf("/", prev);
+      const end = curr === -1 ? pathLength : curr;
+      if (end > prev) {
+        const segment = pathname.slice(prev, end);
+        const staticNode = node.statics.get(segment);
+        if (staticNode) {
+          node = staticNode;
+        } else {
+          const param = node.param;
+          if (!param) {
+            return null;
+          }
+          params[param.name] = decodeURIComponent(segment);
+          node = param.node;
+        }
+      }
+      if (curr === -1) {
+        break;
+      }
+      prev = curr + 1;
+    }
+    const endpoint = node.endpoints.get(method);
+    if (!endpoint) {
+      return null;
+    }
+    return { endpoint, params };
+  }
+};
+
+// src/on-error.ts
+var onError = async (error, request, config) => {
+  if (config.onError) {
+    try {
+      const response = await config.onError(error, request);
+      return response;
+    } catch {
+      return Response.json(
+        { message: "A critical failure occurred during error handling" },
+        { status: 500, statusText: statusText.INTERNAL_SERVER_ERROR }
+      );
+    }
+  }
+  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 });
+  }
+  return Response.json({ message: "Internal Server Error" }, { status: 500, statusText: statusText.INTERNAL_SERVER_ERROR });
+};
+
 // src/headers.ts
 var import_cookie = require("cookie");
 var HeadersBuilder = class {
@@ -263,9 +403,9 @@ var createContentTypeRegex = (contentTypes, contenType) => {
 };
 
 // src/middlewares.ts
-var executeGlobalMiddlewares = async (context, middlewares) => {
-  if (!middlewares) return context;
-  for (const middleware of middlewares) {
+var executeGlobalMiddlewares = async (context, use) => {
+  if (!use) return context;
+  for (const middleware of use) {
     if (typeof middleware !== "function") {
       throw new RouterError("BAD_REQUEST", "Global middlewares must be functions");
     }
@@ -280,10 +420,10 @@ var executeGlobalMiddlewares = async (context, middlewares) => {
   }
   return context;
 };
-var executeMiddlewares = async (context, middlewares = []) => {
+var executeMiddlewares = async (context, use = []) => {
   try {
     let ctx = context;
-    for (const middleware of middlewares) {
+    for (const middleware of use) {
       if (typeof middleware !== "function") {
         throw new RouterError("BAD_REQUEST", "Middleware must be a function");
       }
@@ -296,103 +436,24 @@ var executeMiddlewares = async (context, middlewares = []) => {
 };
 
 // src/router.ts
-var createNode = () => ({
-  statics: /* @__PURE__ */ new Map(),
-  endpoints: /* @__PURE__ */ new Map()
-});
-var insert = (root, endpoint) => {
-  if (!root || !endpoint) return;
-  let node = root;
-  const segments = endpoint.route === "/" ? [] : endpoint.route.split("/").filter(Boolean);
-  for (const segment of segments) {
-    if (segment.startsWith(":")) {
-      const name = segment.slice(1);
-      if (!node.param) {
-        node.param = { name, node: createNode() };
-      } else if (node.param.name !== name) {
-        throw new RouterError(
-          "BAD_REQUEST",
-          `Conflicting in the route by the dynamic segment "${node.param.name}" and "${name}"`
-        );
-      }
-      node = node.param.node;
-    } else {
-      if (!node.statics.has(segment)) {
-        node.statics.set(segment, createNode());
-      }
-      node = node.statics.get(segment);
-    }
-  }
-  if (node.endpoints.has(endpoint.method)) {
-    throw new RouterError("BAD_REQUEST", `Duplicate endpoint for ${endpoint?.method} ${endpoint?.route}`);
-  }
-  node.endpoints.set(endpoint.method, endpoint);
-};
-var search = (method, root, pathname) => {
-  let node = root;
-  const params = {};
-  const segments = pathname === "/" ? [] : pathname.split("/").filter(Boolean);
-  for (const segment of segments) {
-    if (node?.statics.has(segment)) {
-      node = node.statics.get(segment);
-    } else if (node?.param) {
-      params[node.param.name] = decodeURIComponent(segment);
-      node = node.param.node;
-    } else {
-      throw new RouterError("NOT_FOUND", `No route found for path: ${pathname}`);
-    }
-  }
-  if (!node.endpoints.has(method)) {
-    throw new RouterError("NOT_FOUND", `No route found for path: ${pathname}`);
-  }
-  return { endpoint: node.endpoints.get(method), params };
-};
-var handleError = async (error, request, config) => {
-  if (config.onError) {
-    try {
-      const response = await config.onError(error, request);
-      return response;
-    } catch {
-      return Response.json(
-        { message: "A critical failure occurred during error handling" },
-        { status: 500, statusText: statusText.INTERNAL_SERVER_ERROR }
-      );
-    }
-  }
-  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 });
-  }
-  return Response.json({ message: "Internal Server Error" }, { status: 500, statusText: statusText.INTERNAL_SERVER_ERROR });
-};
-var handleRequest = async (method, request, config, root) => {
+var handleRequest = async (method, request, config, router) => {
   try {
     if (!isSupportedMethod(request.method)) {
       throw new RouterError("METHOD_NOT_ALLOWED", `The HTTP method '${request.method}' is not supported`);
     }
     const globalContext = { request, context: config.context ?? {} };
-    const globalRequestContext = await executeGlobalMiddlewares(globalContext, config.middlewares);
+    const globalRequestContext = await executeGlobalMiddlewares(globalContext, config.use);
     if (globalRequestContext instanceof Response) return globalRequestContext;
     const url = new URL(globalRequestContext.request.url);
     const pathnameWithBase = url.pathname;
     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 !== globalRequestContext.request.method) {
-      throw new RouterError("METHOD_NOT_ALLOWED", `The HTTP method '${globalRequestContext.request.method}' is not allowed`);
+    const node = router.match(method, pathnameWithBase);
+    if (!node) {
+      throw new RouterError("NOT_FOUND", `No route found for path: ${pathnameWithBase}`);
     }
+    const { endpoint, params } = node;
     const dynamicParams = getRouteParams(params, endpoint.config);
     const body = await getBody(globalRequestContext.request, endpoint.config);
     const searchParams = getSearchParams(globalRequestContext.request.url, endpoint.config);
@@ -408,31 +469,35 @@ var handleRequest = async (method, request, config, root) => {
       route: endpoint.route,
       context: config.context ?? {}
     };
-    context = await executeMiddlewares(context, endpoint.config.middlewares);
+    context = await executeMiddlewares(context, endpoint.config.use);
     const response = await endpoint.handler(context);
     return response;
   } catch (error) {
-    return handleError(error, request, config);
+    return onError(error, request, config);
   }
 };
 var createRouter = (endpoints, config = {}) => {
-  const root = createNode();
+  const router = new TrieRouter();
   const server = {};
   const methods = /* @__PURE__ */ new Set();
   for (const endpoint of endpoints) {
     const withBasePath = config.basePath ? `${config.basePath}${endpoint.route}` : endpoint.route;
-    insert(root, { ...endpoint, route: withBasePath });
-    methods.add(endpoint.method);
+    router.add({ ...endpoint, route: withBasePath });
+    const endpointMethods = Array.isArray(endpoint.method) ? endpoint.method : [endpoint.method];
+    for (const method of endpointMethods) {
+      methods.add(method);
+    }
   }
   for (const method of methods) {
-    server[method] = (request) => handleRequest(method, request, config, root);
+    server[method] = (request) => handleRequest(method, request, config, router);
   }
   return server;
 };
 
 // src/client.ts
 function createClient(options) {
-  const { baseURL, headers: defaultHeaders } = options;
+  const { baseURL, basePath, headers: defaultHeaders, fetch: customFetch, ...clientOptions } = options;
+  const fetchFn = customFetch ?? ((input, init) => globalThis.fetch(input, init));
   return new Proxy(
     {},
     {
@@ -440,7 +505,7 @@ function createClient(options) {
         const method = prop.toString().toUpperCase();
         return async (path, ctx) => {
           const searchParams = new URLSearchParams(ctx?.searchParams);
-          let resolvedPath = `${options.basePath ?? ""}${path}`;
+          let resolvedPath = `${basePath ?? ""}${path}`;
           for (const [key, value] of Object.entries(ctx?.params ?? {})) {
             resolvedPath = resolvedPath.replace(`:${key}`, String(value));
           }
@@ -449,11 +514,13 @@ function createClient(options) {
             url.search = searchParams.toString();
           }
           const { params: _p, searchParams: _s, ...requestInit } = ctx ?? {};
-          const response = await fetch(url.toString(), {
+          const headers = typeof defaultHeaders === "function" ? await defaultHeaders() : defaultHeaders;
+          const response = await fetchFn(url.toString(), {
+            ...clientOptions,
             ...requestInit,
             method,
             headers: {
-              ...defaultHeaders,
+              ...headers,
               ...ctx?.headers
             },
             body: ctx?.body ? ctx.body instanceof FormData ? ctx.body : JSON.stringify(ctx.body) : void 0

package/dist/index.d.ts

@@ -4,7 +4,6 @@ export { createClient } from './client.js';
 export { isInvalidZodSchemaError, isRouterError } from './assert.js';
 export { RouterError, statusCode, statusText } from './error.js';
 export { HeadersBuilder } from './headers.js';
-export { Client, ClientOptions, ContentType, ContextBody, ContextParams, ContextSearchParams, EndpointConfig, EndpointSchemas, ExtractEndpoint, ExtractRoutesByMethod, Find, GetHttpHandlers, GetRouteParams, GlobalContext, GlobalCtx, GlobalMiddleware, GlobalMiddlewareContext, HTTPMethod, InferEndpoints, InferMethod, InferZod, MiddlewareFunction, Prettify, RemoveUndefined, RequestContext, RouteEndpoint, RouteHandler, RoutePattern, Router, RouterConfig, RoutesByMethod, ToInferZod } from './types.js';
+export { Client, ClientOptions, ContentType, ContextBody, ContextParams, ContextSearchParams, EndpointConfig, EndpointSchemas, ExtractEndpoint, ExtractRoutesByMethod, FetchLike, Find, GetHttpHandlers, GetRouteParams, GlobalContext, GlobalCtx, GlobalMiddleware, GlobalMiddlewareContext, HTTPMethod, InferEndpoints, InferMethod, InferZod, MiddlewareFunction, Prettify, RemoveUndefined, RequestContext, RequestHeaders, RouteEndpoint, RouteHandler, RoutePattern, Router, RouterConfig, RoutesByMethod, ToInferZod } from './types.js';
 import 'cookie';
 import 'zod';
-import 'http';

package/dist/index.js

@@ -1,19 +1,21 @@
 import {
   createRouter
-} from "./chunk-WJXMLTGP.js";
-import "./chunk-6CIHAUKJ.js";
+} from "./chunk-3ATEFJBU.js";
+import "./chunk-JAYQXZDB.js";
+import "./chunk-VRGPOTTV.js";
+import "./chunk-FS3EN7NZ.js";
 import {
   createClient
-} from "./chunk-SP2NSNB2.js";
-import "./chunk-SY4MM2AG.js";
+} from "./chunk-ISIML7WX.js";
+import "./chunk-HHL2LY22.js";
 import {
   createEndpoint,
   createEndpointConfig
-} from "./chunk-5F6FUKTB.js";
+} from "./chunk-ZTWC6PXG.js";
 import {
   isInvalidZodSchemaError,
   isRouterError
-} from "./chunk-3X2BFSRT.js";
+} from "./chunk-NFASFT4W.js";
 import {
   RouterError,
   statusCode,

package/dist/middlewares.cjs

@@ -92,9 +92,9 @@ var RouterError = class extends AuraStackRouterError {
 };
 
 // src/middlewares.ts
-var executeGlobalMiddlewares = async (context, middlewares) => {
-  if (!middlewares) return context;
-  for (const middleware of middlewares) {
+var executeGlobalMiddlewares = async (context, use) => {
+  if (!use) return context;
+  for (const middleware of use) {
     if (typeof middleware !== "function") {
       throw new RouterError("BAD_REQUEST", "Global middlewares must be functions");
     }
@@ -109,10 +109,10 @@ var executeGlobalMiddlewares = async (context, middlewares) => {
   }
   return context;
 };
-var executeMiddlewares = async (context, middlewares = []) => {
+var executeMiddlewares = async (context, use = []) => {
   try {
     let ctx = context;
-    for (const middleware of middlewares) {
+    for (const middleware of use) {
       if (typeof middleware !== "function") {
         throw new RouterError("BAD_REQUEST", "Middleware must be a function");
       }

package/dist/middlewares.d.ts

@@ -3,16 +3,15 @@ import 'zod';
 import './error.js';
 import './headers.js';
 import 'cookie';
-import 'http';
 
 /**
  * Executes the middlewares in sequence, passing the request to each middleware.
  *
  * @param request - Original request made from the client
  * @param middlewares - Array of global middleware functions to be executed
- * @returns - The modified request after all middlewares have been executed
+ * @returns - The modified context after all middlewares have been executed
  */
-declare const executeGlobalMiddlewares: (context: GlobalMiddlewareContext, middlewares: RouterConfig["middlewares"]) => Promise<GlobalMiddlewareContext | Response>;
+declare const executeGlobalMiddlewares: (context: GlobalMiddlewareContext, use: RouterConfig["use"]) => Promise<Response | GlobalMiddlewareContext>;
 /**
  * Executes middlewares in sequence, passing the request and context to each middleware.
  *
@@ -21,6 +20,6 @@ declare const executeGlobalMiddlewares: (context: GlobalMiddlewareContext, middl
  * @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>(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>, use?: MiddlewareFunction<RouteParams, Config>[]) => Promise<RequestContext<RouteParams, Config>>;
 
 export { executeGlobalMiddlewares, executeMiddlewares };

package/dist/middlewares.js

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

package/dist/on-error.cjs

@@ -0,0 +1,144 @@
+"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/on-error.ts
+var on_error_exports = {};
+__export(on_error_exports, {
+  onError: () => onError
+});
+module.exports = __toCommonJS(on_error_exports);
+
+// src/error.ts
+var statusCode = {
+  OK: 200,
+  CREATED: 201,
+  ACCEPTED: 202,
+  NO_CONTENT: 204,
+  MULTIPLE_CHOICES: 300,
+  MOVED_PERMANENTLY: 301,
+  FOUND: 302,
+  SEE_OTHER: 303,
+  NOT_MODIFIED: 304,
+  TEMPORARY_REDIRECT: 307,
+  BAD_REQUEST: 400,
+  UNAUTHORIZED: 401,
+  PAYMENT_REQUIRED: 402,
+  FORBIDDEN: 403,
+  NOT_FOUND: 404,
+  METHOD_NOT_ALLOWED: 405,
+  NOT_ACCEPTABLE: 406,
+  PROXY_AUTHENTICATION_REQUIRED: 407,
+  UNPROCESSABLE_ENTITY: 422,
+  INTERNAL_SERVER_ERROR: 500,
+  NOT_IMPLEMENTED: 501,
+  BAD_GATEWAY: 502,
+  SERVICE_UNAVAILABLE: 503,
+  HTTP_VERSION_NOT_SUPPORTED: 505
+};
+var statusText = Object.keys(statusCode).reduce(
+  (previous, status) => {
+    return { ...previous, [status]: status };
+  },
+  {}
+);
+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";
+    this.status = statusCode[type];
+    this.statusText = statusText[type];
+  }
+};
+var RouterError = class extends AuraStackRouterError {
+  constructor(type, message, name) {
+    super(type, message, name);
+    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 isRouterError = (error) => {
+  return error instanceof RouterError;
+};
+var isInvalidZodSchemaError = (error) => {
+  return error instanceof InvalidZodSchemaError;
+};
+
+// src/on-error.ts
+var onError = async (error, request, config) => {
+  if (config.onError) {
+    try {
+      const response = await config.onError(error, request);
+      return response;
+    } catch {
+      return Response.json(
+        { message: "A critical failure occurred during error handling" },
+        { status: 500, statusText: statusText.INTERNAL_SERVER_ERROR }
+      );
+    }
+  }
+  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 });
+  }
+  return Response.json({ message: "Internal Server Error" }, { status: 500, statusText: statusText.INTERNAL_SERVER_ERROR });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  onError
+});

package/dist/on-error.d.ts

@@ -0,0 +1,9 @@
+import { RouterConfig } from './types.js';
+import 'zod';
+import './error.js';
+import './headers.js';
+import 'cookie';
+
+declare const onError: (error: unknown, request: Request, config: RouterConfig) => Promise<Response>;
+
+export { onError };

package/dist/on-error.js

@@ -0,0 +1,8 @@
+import {
+  onError
+} from "./chunk-VRGPOTTV.js";
+import "./chunk-NFASFT4W.js";
+import "./chunk-FJYSN2I6.js";
+export {
+  onError
+};