@aura-stack/router 0.2.0 → 0.4.0

package/dist/index.cjs

@@ -20,29 +20,16 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  RouterError: () => RouterError,
   createEndpoint: () => createEndpoint,
   createEndpointConfig: () => createEndpointConfig,
-  createRouter: () => createRouter
+  createRouter: () => createRouter,
+  isRouterError: () => isRouterError,
+  statusCode: () => statusCode,
+  statusText: () => statusText
 });
 module.exports = __toCommonJS(index_exports);
 
-// src/assert.ts
-var supportedMethods = /* @__PURE__ */ new Set(["GET", "POST", "DELETE", "PUT", "PATCH"]);
-var supportedBodyMethods = /* @__PURE__ */ new Set(["POST", "PUT", "PATCH"]);
-var isSupportedMethod = (method) => {
-  return supportedMethods.has(method);
-};
-var isSupportedBodyMethod = (method) => {
-  return supportedBodyMethods.has(method);
-};
-var isValidRoute = (route) => {
-  const routePattern = /^\/[a-zA-Z0-9/_:-]*$/;
-  return routePattern.test(route);
-};
-var isValidHandler = (handler) => {
-  return typeof handler === "function";
-};
-
 // src/error.ts
 var statusCode = {
   OK: 200,
@@ -70,35 +57,57 @@ var statusCode = {
   SERVICE_UNAVAILABLE: 503,
   HTTP_VERSION_NOT_SUPPORTED: 505
 };
-var statusText = Object.entries(statusCode).reduce(
-  (previous, [status, code]) => {
-    return { ...previous, [code]: status };
+var statusText = Object.keys(statusCode).reduce(
+  (previous, status) => {
+    return { ...previous, [status]: status };
   },
   {}
 );
 var AuraStackRouterError = class extends Error {
   constructor(type, message, name) {
     super(message);
-    this.name = name ?? "AuraStackRouterError";
+    this.name = name ?? "RouterError";
     this.status = statusCode[type];
-    this.statusText = statusText[this.status];
+    this.statusText = statusText[type];
+  }
+};
+var RouterError = class extends AuraStackRouterError {
+  constructor(type, message, name) {
+    super(type, message, name);
+    this.name = name ?? "RouterError";
   }
 };
 
-// src/endpoint.ts
-var createRoutePattern = (route) => {
-  const pattern = route.replace(/:[^/]+/g, "([^/]+)").replace(/\//g, "\\/");
-  return new RegExp(`^${pattern}$`);
+// 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 isValidRoute = (route) => {
+  const routePattern = /^\/[a-zA-Z0-9/_:-]*$/;
+  return routePattern.test(route);
+};
+var isValidHandler = (handler) => {
+  return typeof handler === "function";
+};
+var isRouterError = (error) => {
+  return error instanceof RouterError;
+};
+
+// src/endpoint.ts
 var createEndpoint = (method, route, handler, config = {}) => {
   if (!isSupportedMethod(method)) {
-    throw new AuraStackRouterError("METHOD_NOT_ALLOWED", `Unsupported HTTP method: ${method}`);
+    throw new RouterError("METHOD_NOT_ALLOWED", `Unsupported HTTP method: ${method}`);
   }
   if (!isValidRoute(route)) {
-    throw new AuraStackRouterError("BAD_REQUEST", `Invalid route format: ${route}`);
+    throw new RouterError("BAD_REQUEST", `Invalid route format: ${route}`);
   }
   if (!isValidHandler(handler)) {
-    throw new AuraStackRouterError("BAD_REQUEST", "Handler must be a function");
+    throw new RouterError("BAD_REQUEST", "Handler must be a function");
   }
   return { method, route, handler, config };
 };
@@ -107,29 +116,56 @@ function createEndpointConfig(...args) {
   return args[0];
 }
 
+// src/middlewares.ts
+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(context);
+    if (executed instanceof Response) {
+      return executed;
+    }
+    context = executed;
+  }
+  if (!context || !(context.request instanceof Request)) {
+    throw new RouterError("BAD_REQUEST", "Global middleware must return a Request or Response object");
+  }
+  return context;
+};
+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(ctx);
+    }
+    return ctx;
+  } catch {
+    throw new RouterError("BAD_REQUEST", "Handler threw an error");
+  }
+};
+
 // src/context.ts
-var getRouteParams = (route, path) => {
-  const routeRegex = createRoutePattern(route);
-  if (!routeRegex.test(path)) {
-    throw new AuraStackRouterError("BAD_REQUEST", `Missing required route params for route: ${route}`);
+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");
+    }
+    return parsed.data;
   }
-  const params = routeRegex.exec(route)?.slice(1).map((seg) => seg.replace(":", ""));
-  if (!params) return {};
-  const values = routeRegex.exec(path)?.slice(1);
-  return params.reduce(
-    (previous, now, idx) => ({
-      ...previous,
-      [now]: decodeURIComponent(values?.[idx] ?? "")
-    }),
-    {}
-  );
+  return params;
 };
 var getSearchParams = (url, config) => {
   const route = new URL(url);
   if (config.schemas?.searchParams) {
     const parsed = config.schemas.searchParams.safeParse(Object.fromEntries(route.searchParams.entries()));
     if (!parsed.success) {
-      throw new AuraStackRouterError("UNPROCESSABLE_ENTITY", "Invalid search parameters");
+      throw new RouterError("UNPROCESSABLE_ENTITY", "Invalid search parameters");
     }
     return parsed.data;
   }
@@ -140,122 +176,174 @@ var getHeaders = (request) => {
 };
 var getBody = async (request, config) => {
   if (!isSupportedBodyMethod(request.method)) {
-    return void 0;
+    return null;
   }
-  const contentType = request.headers.get("Content-Type") ?? "";
-  if (contentType.includes("application/json")) {
-    const json = await request.json();
+  const clone = request.clone();
+  const contentType = clone.headers.get("Content-Type") ?? "";
+  if (contentType.includes("application/json") || config.schemas?.body) {
+    const json = await clone.json();
     if (config.schemas?.body) {
       const parsed = config.schemas.body.safeParse(json);
       if (!parsed.success) {
-        throw new AuraStackRouterError("UNPROCESSABLE_ENTITY", "Invalid request body");
+        throw new RouterError("UNPROCESSABLE_ENTITY", "Invalid request body");
       }
       return parsed.data;
     }
     return json;
   }
-  if (contentType.includes("application/x-www-form-urlencoded") || contentType.includes("multipart/form-data")) {
-    return await request.formData();
-  }
-  if (contentType.includes("text/")) {
-    return await request.text();
+  try {
+    if (createContentTypeRegex(["application/x-www-form-urlencoded", "multipart/form-data"], contentType)) {
+      return await clone.formData();
+    }
+    if (createContentTypeRegex(["text/", "application/xml"], contentType)) {
+      return await clone.text();
+    }
+    if (createContentTypeRegex(["application/octet-stream"], contentType)) {
+      return await clone.arrayBuffer();
+    }
+    if (createContentTypeRegex(["image/", "video/", "audio/", "application/pdf"], contentType)) {
+      return await clone.blob();
+    }
+    return null;
+  } catch {
+    throw new RouterError("UNPROCESSABLE_ENTITY", "Invalid request body, the content-type does not match the body format");
   }
-  if (contentType.includes("application/octet-stream")) {
-    return await request.arrayBuffer();
+};
+var createContentTypeRegex = (contentTypes, contenType) => {
+  const regex = new RegExp(`${contentTypes.join("|")}`);
+  return regex.test(contenType);
+};
+
+// 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 (contentType.includes("image/") || contentType.includes("video/") || contentType.includes("audio/")) {
-    return await request.blob();
+  if (node.endpoints.has(endpoint.method)) {
+    throw new RouterError("BAD_REQUEST", `Duplicate endpoint for ${endpoint?.method} ${endpoint?.route}`);
   }
-  return null;
+  node.endpoints.set(endpoint.method, endpoint);
 };
-
-// src/middlewares.ts
-var executeGlobalMiddlewares = async (request, middlewares) => {
-  if (!middlewares) return request;
-  for (const middleware of middlewares) {
-    if (typeof middleware !== "function") {
-      throw new AuraStackRouterError("BAD_REQUEST", "Global middlewares must be functions");
+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}`);
     }
-    const executed = await middleware(request);
-    if (executed instanceof Response) {
-      return executed;
+  }
+  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 }
+      );
     }
-    request = executed;
   }
-  if (!request || !(request instanceof Request)) {
-    throw new AuraStackRouterError("BAD_REQUEST", "Global middleware must return a Request or Response object");
+  if (isRouterError(error)) {
+    const { message, status, statusText: statusText2 } = error;
+    return Response.json({ message }, { status, statusText: statusText2 });
   }
-  return request;
+  return Response.json({ message: "Internal Server Error" }, { status: 500, statusText: statusText.INTERNAL_SERVER_ERROR });
 };
-var executeMiddlewares = async (request, context, middlewares = []) => {
+var handleRequest = async (method, request, config, root) => {
   try {
-    let ctx = context;
-    for (const middleware of middlewares) {
-      if (typeof middleware !== "function") {
-        throw new AuraStackRouterError("BAD_REQUEST", "Middleware must be a function");
-      }
-      ctx = await middleware(request, ctx);
+    if (!isSupportedMethod(request.method)) {
+      throw new RouterError("METHOD_NOT_ALLOWED", `The HTTP method '${request.method}' is not supported`);
     }
-    return ctx;
-  } catch {
-    throw new AuraStackRouterError("BAD_REQUEST", "Handler threw an error");
+    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 (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 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);
+    let context = {
+      params: dynamicParams,
+      searchParams,
+      headers,
+      body,
+      request: globalRequestContext.request,
+      url,
+      method: globalRequestContext.request.method,
+      route: endpoint.route,
+      context: config.context ?? {}
+    };
+    context = await executeMiddlewares(context, endpoint.config.middlewares);
+    const response = await endpoint.handler(context);
+    return response;
+  } catch (error) {
+    return handleError(error, request, config);
   }
 };
-
-// src/router.ts
 var createRouter = (endpoints, config = {}) => {
+  const root = createNode();
   const server = {};
-  const groups = /* @__PURE__ */ new Map();
+  const methods = /* @__PURE__ */ new Set();
   for (const endpoint of endpoints) {
-    if (!groups.has(endpoint.method)) {
-      groups.set(endpoint.method, []);
-    }
-    groups.get(endpoint.method)?.push(endpoint);
+    const withBasePath = config.basePath ? `${config.basePath}${endpoint.route}` : endpoint.route;
+    insert(root, { ...endpoint, route: withBasePath });
+    methods.add(endpoint.method);
   }
-  for (const method of groups.keys()) {
-    server[method] = async (request) => {
-      try {
-        const globalRequest = await executeGlobalMiddlewares(request, config.middlewares);
-        if (globalRequest instanceof Response) {
-          return globalRequest;
-        }
-        const url = new URL(globalRequest.url);
-        const pathname = url.pathname;
-        const endpoint = groups.get(method)?.find((endpoint2) => {
-          const withBasePath = config.basePath ? `${config.basePath}${endpoint2.route}` : endpoint2.route;
-          const regex = createRoutePattern(withBasePath);
-          return regex.test(pathname);
-        });
-        if (endpoint) {
-          const withBasePath = config.basePath ? `${config.basePath}${endpoint.route}` : endpoint.route;
-          const body = await getBody(globalRequest, endpoint.config);
-          const params = getRouteParams(withBasePath, pathname);
-          const searchParams = getSearchParams(globalRequest.url, endpoint.config);
-          const headers = getHeaders(globalRequest);
-          const context = {
-            params,
-            searchParams,
-            headers,
-            body
-          };
-          await executeMiddlewares(globalRequest, context, endpoint.config.middlewares);
-          return endpoint.handler(globalRequest, context);
-        }
-        return Response.json({ message: "Not Found" }, { status: 404 });
-      } catch (error) {
-        if (error instanceof AuraStackRouterError) {
-          const { message, status, statusText: statusText2 } = error;
-          return Response.json({ message }, { status, statusText: statusText2 });
-        }
-        return Response.json({ message: "Internal Server Error" }, { status: 500 });
-      }
-    };
+  for (const method of methods) {
+    server[method] = (request) => handleRequest(method, request, config, root);
   }
   return server;
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  RouterError,
   createEndpoint,
   createEndpointConfig,
-  createRouter
+  createRouter,
+  isRouterError,
+  statusCode,
+  statusText
 });

package/dist/index.d.ts

@@ -1,4 +1,6 @@
 export { createEndpoint, createEndpointConfig } from './endpoint.js';
 export { createRouter } from './router.js';
-export { ContentType, ContextBody, ContextSearchParams, EndpointConfig, EndpointSchemas, GetHttpHandlers, GetRouteParams, GlobalMiddleware, HTTPMethod, InferMethod, MiddlewareFunction, Params, Prettify, RequestContext, RouteEndpoint, RouteHandler, RoutePattern, RouterConfig } from './types.js';
+export { isRouterError } from './assert.js';
+export { RouterError, statusCode, statusText } from './error.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 'zod';

package/dist/index.js

@@ -1,16 +1,26 @@
-import {
-  createRouter
-} from "./chunk-DR4C6QTF.js";
-import "./chunk-OXDCFAMF.js";
 import {
   createEndpoint,
   createEndpointConfig
-} from "./chunk-YUX3YHXF.js";
-import "./chunk-JRJKKBSH.js";
-import "./chunk-O6SY753N.js";
-import "./chunk-RFYOPPMW.js";
+} from "./chunk-6PZEXNTS.js";
+import {
+  createRouter
+} from "./chunk-CL5D7UJU.js";
+import "./chunk-PT4GU6PH.js";
+import {
+  isRouterError
+} from "./chunk-JNMXLKDG.js";
+import "./chunk-CFAIW6YL.js";
+import {
+  RouterError,
+  statusCode,
+  statusText
+} from "./chunk-GJC3ODME.js";
 export {
+  RouterError,
   createEndpoint,
   createEndpointConfig,
-  createRouter
+  createRouter,
+  isRouterError,
+  statusCode,
+  statusText
 };

package/dist/middlewares.cjs

@@ -52,51 +52,57 @@ var statusCode = {
   SERVICE_UNAVAILABLE: 503,
   HTTP_VERSION_NOT_SUPPORTED: 505
 };
-var statusText = Object.entries(statusCode).reduce(
-  (previous, [status, code]) => {
-    return { ...previous, [code]: status };
+var statusText = Object.keys(statusCode).reduce(
+  (previous, status) => {
+    return { ...previous, [status]: status };
   },
   {}
 );
 var AuraStackRouterError = class extends Error {
   constructor(type, message, name) {
     super(message);
-    this.name = name ?? "AuraStackRouterError";
+    this.name = name ?? "RouterError";
     this.status = statusCode[type];
-    this.statusText = statusText[this.status];
+    this.statusText = statusText[type];
+  }
+};
+var RouterError = class extends AuraStackRouterError {
+  constructor(type, message, name) {
+    super(type, message, name);
+    this.name = name ?? "RouterError";
   }
 };
 
 // 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 AuraStackRouterError("BAD_REQUEST", "Global middlewares must be functions");
+      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)) {
-    throw new AuraStackRouterError("BAD_REQUEST", "Global middleware must return a Request or Response object");
+  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 AuraStackRouterError("BAD_REQUEST", "Middleware must be a function");
+        throw new RouterError("BAD_REQUEST", "Middleware must be a function");
       }
-      ctx = await middleware(request, ctx);
+      ctx = await middleware(ctx);
     }
     return ctx;
   } catch {
-    throw new AuraStackRouterError("BAD_REQUEST", "Handler threw an error");
+    throw new RouterError("BAD_REQUEST", "Handler threw an error");
   }
 };
 // Annotate the CommonJS export names for ESM import in node:

package/dist/middlewares.d.ts

@@ -1,5 +1,6 @@
-import { RouterConfig, EndpointConfig, RequestContext, MiddlewareFunction } from './types.js';
+import { GlobalMiddlewareContext, RouterConfig, EndpointConfig, RequestContext, MiddlewareFunction } from './types.js';
 import 'zod';
+import './error.js';
 
 /**
  * Executes the middlewares in sequence, passing the request to each middleware.
@@ -8,7 +9,7 @@ import 'zod';
  * @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<GlobalMiddlewareContext | Response>;
 /**
  * Executes middlewares in sequence, passing the request and context to each middleware.
  *
@@ -17,6 +18,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-O6SY753N.js";
-import "./chunk-RFYOPPMW.js";
+} from "./chunk-CFAIW6YL.js";
+import "./chunk-GJC3ODME.js";
 export {
   executeGlobalMiddlewares,
   executeMiddlewares