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

package/dist/assert.cjs

@@ -112,6 +112,9 @@ var supportedMethods = /* @__PURE__ */ new Set(["GET", "POST", "DELETE", "PUT",
 var supportedBodyMethods = /* @__PURE__ */ new Set(["POST", "PUT", "PATCH"]);
 var supportedProtocols = /* @__PURE__ */ new Set(["http:", "https:"]);
 var isSupportedMethod = (method) => {
+  if (Array.isArray(method)) {
+    return method.every((meth) => supportedMethods.has(meth));
+  }
   return supportedMethods.has(method);
 };
 var isSupportedBodyMethod = (method) => {

package/dist/assert.d.ts

@@ -3,7 +3,6 @@ import { HTTPMethod, RoutePattern, RouteHandler } from './types.js';
 import 'zod';
 import './headers.js';
 import 'cookie';
-import 'http';
 
 declare const supportedProtocols: Set<string>;
 /**
@@ -12,7 +11,7 @@ declare const supportedProtocols: Set<string>;
  * @param method - The HTTP method to check.
  * @returns True if the method is supported, false otherwise.
  */
-declare const isSupportedMethod: (method: string) => method is HTTPMethod;
+declare const isSupportedMethod: (method: string | string[]) => method is HTTPMethod | HTTPMethod[];
 /**
  * Check if the provided method can includes a body as per HTTP specification.
  * @param method - The HTTP method to check.

package/dist/assert.js

@@ -7,7 +7,7 @@ import {
   isValidHandler,
   isValidRoute,
   supportedProtocols
-} from "./chunk-3X2BFSRT.js";
+} from "./chunk-NFASFT4W.js";
 import "./chunk-FJYSN2I6.js";
 export {
   isInvalidZodSchemaError,

package/dist/chunk-3ATEFJBU.js

@@ -0,0 +1,87 @@
+import {
+  executeGlobalMiddlewares,
+  executeMiddlewares
+} from "./chunk-JAYQXZDB.js";
+import {
+  onError
+} from "./chunk-VRGPOTTV.js";
+import {
+  TrieRouter
+} from "./chunk-FS3EN7NZ.js";
+import {
+  getBody,
+  getRouteParams,
+  getSearchParams
+} from "./chunk-HHL2LY22.js";
+import {
+  isSupportedMethod
+} from "./chunk-NFASFT4W.js";
+import {
+  RouterError
+} from "./chunk-FJYSN2I6.js";
+import {
+  HeadersBuilder
+} from "./chunk-6JNMFP4L.js";
+
+// src/router.ts
+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.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 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);
+    const headers = new HeadersBuilder(globalRequestContext.request.headers);
+    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.use);
+    const response = await endpoint.handler(context);
+    return response;
+  } catch (error) {
+    return onError(error, request, config);
+  }
+};
+var createRouter = (endpoints, config = {}) => {
+  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;
+    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, router);
+  }
+  return server;
+};
+
+export {
+  createRouter
+};

package/dist/chunk-FS3EN7NZ.js

@@ -0,0 +1,114 @@
+import {
+  RouterError
+} from "./chunk-FJYSN2I6.js";
+
+// 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 };
+  }
+};
+
+export {
+  TrieNode,
+  TrieRouter
+};

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

@@ -1,6 +1,6 @@
 import {
   isSupportedBodyMethod
-} from "./chunk-3X2BFSRT.js";
+} from "./chunk-NFASFT4W.js";
 import {
   InvalidZodSchemaError,
   RouterError

package/dist/{chunk-SP2NSNB2.js → chunk-ISIML7WX.js}

@@ -1,6 +1,7 @@
 // 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(
     {},
     {
@@ -8,7 +9,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));
           }
@@ -17,11 +18,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/{chunk-6CIHAUKJ.js → chunk-JAYQXZDB.js}

@@ -3,9 +3,9 @@ import {
 } from "./chunk-FJYSN2I6.js";
 
 // 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");
     }
@@ -20,10 +20,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/{chunk-3X2BFSRT.js → chunk-NFASFT4W.js}

@@ -8,6 +8,9 @@ var supportedMethods = /* @__PURE__ */ new Set(["GET", "POST", "DELETE", "PUT",
 var supportedBodyMethods = /* @__PURE__ */ new Set(["POST", "PUT", "PATCH"]);
 var supportedProtocols = /* @__PURE__ */ new Set(["http:", "https:"]);
 var isSupportedMethod = (method) => {
+  if (Array.isArray(method)) {
+    return method.every((meth) => supportedMethods.has(meth));
+  }
   return supportedMethods.has(method);
 };
 var isSupportedBodyMethod = (method) => {

package/dist/chunk-VRGPOTTV.js

@@ -0,0 +1,42 @@
+import {
+  isInvalidZodSchemaError,
+  isRouterError
+} from "./chunk-NFASFT4W.js";
+import {
+  statusText
+} from "./chunk-FJYSN2I6.js";
+
+// 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 });
+};
+
+export {
+  onError
+};

package/dist/{chunk-5F6FUKTB.js → chunk-ZTWC6PXG.js}

@@ -2,7 +2,7 @@ import {
   isSupportedMethod,
   isValidHandler,
   isValidRoute
-} from "./chunk-3X2BFSRT.js";
+} from "./chunk-NFASFT4W.js";
 import {
   RouterError
 } from "./chunk-FJYSN2I6.js";

package/dist/client.cjs

@@ -24,7 +24,8 @@ __export(client_exports, {
 });
 module.exports = __toCommonJS(client_exports);
 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(
     {},
     {
@@ -32,7 +33,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));
           }
@@ -41,11 +42,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/client.d.ts

@@ -3,7 +3,6 @@ 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

package/dist/client.js

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

package/dist/context.d.ts

@@ -3,7 +3,6 @@ import { EndpointConfig, ContextSearchParams } from './types.js';
 import './error.js';
 import './headers.js';
 import 'cookie';
-import 'http';
 
 /**
  * @experimental

package/dist/context.js

@@ -3,8 +3,8 @@ import {
   getBody,
   getRouteParams,
   getSearchParams
-} from "./chunk-SY4MM2AG.js";
-import "./chunk-3X2BFSRT.js";
+} from "./chunk-HHL2LY22.js";
+import "./chunk-NFASFT4W.js";
 import "./chunk-FJYSN2I6.js";
 export {
   formatZodError,

package/dist/endpoint.cjs

@@ -94,6 +94,9 @@ var RouterError = class extends AuraStackRouterError {
 // src/assert.ts
 var supportedMethods = /* @__PURE__ */ new Set(["GET", "POST", "DELETE", "PUT", "PATCH", "OPTIONS", "HEAD", "TRACE", "CONNECT"]);
 var isSupportedMethod = (method) => {
+  if (Array.isArray(method)) {
+    return method.every((meth) => supportedMethods.has(meth));
+  }
   return supportedMethods.has(method);
 };
 var isValidRoute = (route) => {

package/dist/endpoint.d.ts

@@ -3,7 +3,6 @@ import 'zod';
 import './error.js';
 import './headers.js';
 import 'cookie';
-import 'http';
 
 /**
  * Defines an API endpoint for the router by specifying the HTTP method, route pattern,
@@ -21,7 +20,7 @@ import 'http';
  *   return new Response("Signed in");
  * });
  */
-declare const createEndpoint: <const Method extends Uppercase<HTTPMethod>, const Route extends RoutePattern, const Schemas extends EndpointSchemas>(method: Method, route: Route, handler: RouteHandler<Route, {
+declare const createEndpoint: <const Method extends Uppercase<HTTPMethod> | Uppercase<HTTPMethod>[], const Route extends RoutePattern, const Schemas extends EndpointSchemas>(method: Method, route: Route, handler: RouteHandler<Route, {
     schemas: Schemas;
 }>, config?: EndpointConfig<Route, Schemas>) => RouteEndpoint<Method, Route, {
     schemas?: Schemas;
@@ -38,7 +37,7 @@ declare const createEndpoint: <const Method extends Uppercase<HTTPMethod>, const
  * @example
  * // Without route pattern
  * const config = createEndpointConfig({
- *   middlewares: [myMiddleware],
+ *   use: [myMiddleware],
  *   schemas: {
  *     searchParams: z.object({
  *       q: z.string().min(3),
@@ -52,7 +51,7 @@ declare const createEndpoint: <const Method extends Uppercase<HTTPMethod>, const
  *
  * // Overload with route pattern
  * const config = createEndpointConfig("/users/:userId", {
- *   middlewares: [myMiddleware],
+ *   use: [myMiddleware],
  * })
  *
  * const getUser = createEndpoint("GET", "/users/:userId", async (request, ctx) => {

package/dist/endpoint.js

@@ -1,8 +1,8 @@
 import {
   createEndpoint,
   createEndpointConfig
-} from "./chunk-5F6FUKTB.js";
-import "./chunk-3X2BFSRT.js";
+} from "./chunk-ZTWC6PXG.js";
+import "./chunk-NFASFT4W.js";
 import "./chunk-FJYSN2I6.js";
 export {
   createEndpoint,