@aura-stack/router 0.3.0 → 0.5.0

package/dist/index.d.cts

@@ -1,6 +0,0 @@
-export { createEndpoint, createEndpointConfig } from './endpoint.cjs';
-export { createRouter } from './router.cjs';
-export { isRouterError } from './assert.cjs';
-export { RouterError, statusCode, statusText } from './error.cjs';
-export { ContentType, ContextBody, ContextParams, ContextSearchParams, EndpointConfig, EndpointSchemas, GetHttpHandlers, GetRouteParams, GlobalMiddleware, HTTPMethod, InferMethod, MiddlewareFunction, Prettify, RequestContext, RouteEndpoint, RouteHandler, RoutePattern, RouterConfig } from './types.cjs';
-import 'zod';

package/dist/middlewares.d.cts

@@ -1,23 +0,0 @@
-import { RouterConfig, EndpointConfig, RequestContext, MiddlewareFunction } from './types.cjs';
-import 'zod';
-import './error.cjs';
-
-/**
- * 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
- */
-declare const executeGlobalMiddlewares: (request: Request, middlewares: RouterConfig["middlewares"]) => Promise<Request | Response>;
-/**
- * Executes middlewares in sequence, passing the request and context to each middleware.
- *
- * @param request - Original request made from the client
- * @param context - Context object of the endpoint functionality
- * @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>>;
-
-export { executeGlobalMiddlewares, executeMiddlewares };

package/dist/router.d.cts

@@ -1,37 +0,0 @@
-import { RouteEndpoint, RouterConfig, GetHttpHandlers, HTTPMethod, RoutePattern, EndpointSchemas, MiddlewareFunction } from './types.cjs';
-import 'zod';
-import './error.cjs';
-
-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.
- * It accepts an optional configuration object to set a base path and middlewares for all endpoints.
- *
- * @param endpoints - Array of route endpoints to be handled by the router
- * @param config - Optional configuration object for the router
- * @returns An object with methods corresponding to HTTP methods, each handling requests for that method
- */
-declare const createRouter: <const Endpoints extends RouteEndpoint[]>(endpoints: Endpoints, config?: RouterConfig) => GetHttpHandlers<Endpoints>;
-
-export { createNode, createRouter, insert, search };

package/dist/types.d.cts

@@ -1,191 +0,0 @@
-import { ZodObject, z } from 'zod';
-import { RouterError } from './error.cjs';
-
-/**
- * Route pattern must start with a slash and can contain parameters prefixed with a colon.
- * @example
- * const getUser:RoutePattern = "/users/:userId"
- * const getPostsComments:RoutePattern = "/posts/:postId/comments/:commentId"
- */
-type RoutePattern = `/${string}` | `/${string}/:${string}`;
-/**
- * HTTP methods defined in HTTP/1.1 specification.
- * @see https://datatracker.ietf.org/doc/html/rfc7231#section-4.3
- */
-type HTTPMethod = "GET" | "POST" | "DELETE" | "PUT" | "PATCH" | "OPTIONS" | "HEAD" | "TRACE" | "CONNECT";
-/**
- * Content types supported by the router.
- */
-type ContentType = "application/json" | "application/x-www-form-urlencoded" | "text/plain" | "multipart/form-data" | "application/xml" | "application/octet-stream" | `text/${string}` | `image/${string}` | `video/${string}` | `audio/${string}` | "application/pdf";
-type Prettify<Obj extends object> = {
-    [Key in keyof Obj]: Obj[Key];
-} & {};
-/**
- * Extracts route parameters from a given route pattern through colon-prefixed segments.
- * Returns an object type where keys are parameter names and values are strings.
- * If no parameters are found, returns an empty object type.
- *
- * @example
- * // Expected: { userId: string }
- * type UserParams = Params<"/users/:userId">;
- *
- * // Expected: { postId: string; commentId: string }
- * type PostCommentParams = Params<"/posts/:postId/comments/:commentId">;
- *
- * // Expected: {}
- * type NoParams = Params<"/about">;
- */
-type GetRouteParams<Route extends RoutePattern> = Route extends `/${string}/:${infer Param}/${infer Str}` ? Prettify<{
-    [K in Param]: string;
-} & GetRouteParams<`/${Str}`>> : Route extends `/${string}/:${infer Param}` ? Prettify<{
-    [K in Param]: string;
-}> : Route extends `/:${infer Param}` ? Prettify<{
-    [K in Param]: string;
-}> : {};
-/**
- * Available schemas validation for an endpoint. It can include body and searchParams schemas.
- */
-interface EndpointSchemas {
-    body?: ZodObject<any>;
-    searchParams?: ZodObject<any>;
-    params?: ZodObject<any>;
-}
-/**
- * Configuration for an endpoint, including optional schemas for request validation and middlewares.
- */
-type EndpointConfig<RouteParams extends RoutePattern = RoutePattern, Schemas extends EndpointSchemas = EndpointSchemas> = Prettify<{
-    schemas?: Schemas;
-    middlewares?: MiddlewareFunction<GetRouteParams<RouteParams>, {
-        schemas: Schemas;
-    }>[];
-}>;
-/**
- * Infer the type of search parameters from the provided value in the `EndpointConfig`.
- */
-type ContextSearchParams<Schemas extends EndpointConfig["schemas"]> = Schemas extends {
-    searchParams: ZodObject;
-} ? {
-    searchParams: z.infer<Schemas["searchParams"]>;
-} : {
-    searchParams: URLSearchParams;
-};
-/**
- * Infer the type of body from the provided value in the `EndpointConfig`.
- */
-type ContextBody<Schemas extends EndpointConfig["schemas"]> = Schemas extends {
-    body: ZodObject;
-} ? {
-    body: z.infer<Schemas["body"]>;
-} : {
-    body: undefined;
-};
-/**
- * Infer the type of route parameters from the provided value in the `EndpointConfig`.
- */
-type ContextParams<Schemas extends EndpointConfig["schemas"], Default = Record<string, string>> = Schemas extends {
-    params: ZodObject;
-} ? {
-    params: z.infer<Schemas["params"]>;
-} : {
-    params: Default;
-};
-/**
- * Context object passed to route handlers and middlewares defined in the
- * `createEndpoint/createEndpointConfig` function or globally in the `createRouter` function.
- */
-interface RequestContext<RouteParams = Record<string, string>, Config extends EndpointConfig = EndpointConfig> {
-    params: ContextParams<Config["schemas"], RouteParams>["params"];
-    headers: Headers;
-    body: ContextBody<Config["schemas"]>["body"];
-    searchParams: ContextSearchParams<Config["schemas"]>["searchParams"];
-}
-/**
- * Global middleware function type that represent a function that runs before the route matching.
- */
-type GlobalMiddleware = (request: Request) => Promise<Request | Response>;
-/**
- * Middleware function type that represent a function that runs before the route handler
- * defined in the `createEndpoint/createEndpointConfig` function or globally in the `createRouter` function.
- */
-type MiddlewareFunction<RouteParams = Record<string, string>, Config extends EndpointConfig = EndpointConfig> = (request: Request, ctx: Prettify<RequestContext<RouteParams, Config>>) => Promise<RequestContext<RouteParams, Config>>;
-/**
- * Defines a route handler function that processes an incoming request and returns a response.
- * The handler receives the request object and a context containing route parameters, headers,
- * and optionally validated body and search parameters based on the endpoint configuration.
- */
-type RouteHandler<Route extends RoutePattern, Config extends EndpointConfig> = (request: Request, ctx: Prettify<RequestContext<GetRouteParams<Route>, Config>>) => Response | Promise<Response>;
-/**
- * Represents a route endpoint definition, specifying the HTTP method, route pattern,
- * handler function with inferred context types, and associated configuration.
- */
-interface RouteEndpoint<Method extends HTTPMethod = HTTPMethod, Route extends RoutePattern = RoutePattern, Config extends EndpointConfig = EndpointConfig> {
-    method: Method;
-    route: Route;
-    handler: RouteHandler<Route, Config>;
-    config: Config;
-}
-/**
- * Infer the HTTP methods defined in the provided array of route endpoints.
- */
-type InferMethod<Endpoints extends RouteEndpoint[]> = Endpoints extends unknown[] ? Endpoints[number]["method"] : "unknown";
-/**
- * Generates an object with HTTP methods available by the router from `createRouter` function.
- * Each method is a function that takes a request and context, returning a promise of a response.
- */
-type GetHttpHandlers<Endpoints extends RouteEndpoint[]> = {
-    [Method in InferMethod<Endpoints>]: (req: Request) => Response | Promise<Response>;
-};
-/**
- * Configuration options for `createRouter` function.
- */
-interface RouterConfig {
-    /**
-     * Prefix path for all routes/endpoints defined in the router.
-     *
-     * @example
-     * basePath: "/api/v1"
-     *
-     * // will match the "/users" endpoint.
-     * new Request("https://example.com/api/v1/users")
-     *
-     * // will NOT match the "/users" endpoint.
-     * new Request("https://example.com/users")
-     */
-    basePath?: RoutePattern;
-    /**
-     * Global middlewares that run before route matching for all endpoints in the router.
-     * You can use this to modify the request or return a response early.
-     *
-     * @example
-     * middlewares: [
-     *   async (request) => {
-     *     if(request.headers.get("Authorization")?.startsWith("Bearer ")) {
-     *       return Response.json({ message: "Unauthorized" }, { status: 401 })
-     *     }
-     *     return request
-     *   }
-     * ]
-     */
-    middlewares?: GlobalMiddleware[];
-    /**
-     * Error handler function that runs when an error is thrown in a router handler or middleware.
-     * It can be used to customize the default error response provided by the router. If is an internal
-     * error the error is from the `RouterError` class, otherwise the error is a generic
-     * `Error` instance which was caused by a handler or middleware, for how to distinguish them you can use
-     * the `isRouterError` function from the `assert` module.
-     *
-     * @param error - The error thrown in the router
-     * @param request - The original request that caused the error
-     * @returns A response to be sent back to the client
-     * @example
-     * onError: (error, request) => {
-     *   if(isRouterError(error)) {
-     *     return Response.json({ message: error.message }, { status: error.statusCode })
-     *   }
-     *   return Response.json({ message: "Internal Server Error" }, { status: 500 })
-     * }
-     */
-    onError?: (error: Error | RouterError, request: Request) => Response | Promise<Response>;
-}
-
-export type { ContentType, ContextBody, ContextParams, ContextSearchParams, EndpointConfig, EndpointSchemas, GetHttpHandlers, GetRouteParams, GlobalMiddleware, HTTPMethod, InferMethod, MiddlewareFunction, Prettify, RequestContext, RouteEndpoint, RouteHandler, RoutePattern, RouterConfig };