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

package/dist/router.cjs

@@ -20,10 +20,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/router.ts
 var router_exports = {};
 __export(router_exports, {
-  createNode: () => createNode,
-  createRouter: () => createRouter,
-  insert: () => insert,
-  search: () => search
+  createRouter: () => createRouter
 });
 module.exports = __toCommonJS(router_exports);
 
@@ -103,6 +100,162 @@ var InvalidZodSchemaError = class {
   }
 };
 
+// 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/assert.ts
+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) => {
+  return supportedBodyMethods.has(method);
+};
+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 });
+};
+
 // src/headers.ts
 var import_cookie = require("cookie");
 var HeadersBuilder = class {
@@ -138,22 +291,6 @@ var HeadersBuilder = class {
   }
 };
 
-// src/assert.ts
-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) => {
-  return supportedMethods.has(method);
-};
-var isSupportedBodyMethod = (method) => {
-  return supportedBodyMethods.has(method);
-};
-var isRouterError = (error) => {
-  return error instanceof RouterError;
-};
-var isInvalidZodSchemaError = (error) => {
-  return error instanceof InvalidZodSchemaError;
-};
-
 // src/context.ts
 var formatZodError = (error) => {
   if (!error.issues || error.issues.length === 0) {
@@ -232,9 +369,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");
     }
@@ -249,10 +386,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");
       }
@@ -265,103 +402,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);
@@ -377,31 +435,31 @@ 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;
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  createNode,
-  createRouter,
-  insert,
-  search
+  createRouter
 });

package/dist/router.d.ts

@@ -1,31 +1,9 @@
-import { RouteEndpoint, RouterConfig, Router, HTTPMethod, RoutePattern, EndpointSchemas, MiddlewareFunction } from './types.js';
+import { RouteEndpoint, RouterConfig, Router } from './types.js';
 import 'zod';
 import './error.js';
 import './headers.js';
 import 'cookie';
-import 'http';
 
-interface TrieNode {
-    statics: Map<string, TrieNode>;
-    param?: {
-        name: string;
-        node: TrieNode;
-    };
-    endpoints: Map<HTTPMethod, RouteEndpoint>;
-}
-declare const createNode: () => TrieNode;
-declare const insert: (root: TrieNode, endpoint: RouteEndpoint) => void;
-declare const search: (method: HTTPMethod, root: TrieNode, pathname: string) => {
-    endpoint: RouteEndpoint<HTTPMethod, RoutePattern, {
-        schemas?: EndpointSchemas | undefined;
-        middlewares?: MiddlewareFunction<{} | {
-            [x: string]: string;
-        }, {
-            schemas: EndpointSchemas;
-        }>[] | undefined;
-    }>;
-    params: Record<string, string>;
-};
 /**
  * Creates the entry point for the server, handling the endpoints defined in the router.
  * It groups endpoints by HTTP method and matches incoming requests to the appropriate endpoint.
@@ -37,4 +15,4 @@ declare const search: (method: HTTPMethod, root: TrieNode, pathname: string) =>
  */
 declare const createRouter: <const Endpoints extends RouteEndpoint[]>(endpoints: Endpoints, config?: RouterConfig) => Router<Endpoints>;
 
-export { createNode, createRouter, insert, search };
+export { createRouter };

package/dist/router.js

@@ -1,17 +1,13 @@
 import {
-  createNode,
-  createRouter,
-  insert,
-  search
-} from "./chunk-WJXMLTGP.js";
-import "./chunk-6CIHAUKJ.js";
-import "./chunk-SY4MM2AG.js";
-import "./chunk-3X2BFSRT.js";
+  createRouter
+} from "./chunk-3ATEFJBU.js";
+import "./chunk-JAYQXZDB.js";
+import "./chunk-VRGPOTTV.js";
+import "./chunk-FS3EN7NZ.js";
+import "./chunk-HHL2LY22.js";
+import "./chunk-NFASFT4W.js";
 import "./chunk-FJYSN2I6.js";
 import "./chunk-6JNMFP4L.js";
 export {
-  createNode,
-  createRouter,
-  insert,
-  search
+  createRouter
 };

package/dist/trie.cjs

@@ -0,0 +1,203 @@
+"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/trie.ts
+var trie_exports = {};
+__export(trie_exports, {
+  TrieNode: () => TrieNode,
+  TrieRouter: () => TrieRouter
+});
+module.exports = __toCommonJS(trie_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";
+  }
+};
+
+// 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 };
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TrieNode,
+  TrieRouter
+});

package/dist/trie.d.ts

@@ -0,0 +1,34 @@
+import { HTTPMethod, RouteEndpoint, RoutePattern, EndpointSchemas, MiddlewareFunction } from './types.js';
+import 'zod';
+import './error.js';
+import './headers.js';
+import 'cookie';
+
+declare class TrieNode {
+    param?: {
+        name: string;
+        node: TrieNode;
+    } | undefined;
+    statics: Map<string, TrieNode>;
+    endpoints: Map<HTTPMethod, RouteEndpoint>;
+}
+declare class TrieRouter {
+    private root;
+    private statics;
+    private methods;
+    constructor();
+    add(endpoint: RouteEndpoint): void;
+    match(method: HTTPMethod, pathname: string): {
+        endpoint: RouteEndpoint<HTTPMethod | HTTPMethod[], RoutePattern, {
+            schemas?: EndpointSchemas | undefined;
+            use?: MiddlewareFunction<{} | {
+                [x: string]: string;
+            }, {
+                schemas: EndpointSchemas;
+            }>[] | undefined;
+        }>;
+        params: Record<string, string>;
+    } | null;
+}
+
+export { TrieNode, TrieRouter };

package/dist/trie.js

@@ -0,0 +1,9 @@
+import {
+  TrieNode,
+  TrieRouter
+} from "./chunk-FS3EN7NZ.js";
+import "./chunk-FJYSN2I6.js";
+export {
+  TrieNode,
+  TrieRouter
+};