@aura-stack/router 0.2.0 → 0.4.0

package/package.json

@@ -1,8 +1,31 @@
 {
   "name": "@aura-stack/router",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "type": "module",
   "description": "A lightweight TypeScript library for building, managing, and validating API routes and endpoints in Node.js applications.",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/aura-stack-ts/router"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/@aura-stack/router"
+  },
+  "keywords": [
+    "router",
+    "endpoints",
+    "api",
+    "aura",
+    "aura stack",
+    "typescript",
+    "nodejs"
+  ],
+  "author": "Aura Stack <auraauthoss@gmail.com> | Hernan Alvarado <hernanvid123@gmail.com>",
+  "homepage": "https://github.com/aura-stack-ts/router",
+  "bugs": {
+    "url": "https://github.com/aura-stack-ts/router/issues"
+  },
+  "license": "MIT",
   "files": [
     "dist"
   ],
@@ -22,19 +45,13 @@
       "import": "./dist/endpoint.js",
       "require": "./dist/endpoint.cjs"
     },
+    "./error": {
+      "types": "./dist/error.d.ts",
+      "import": "./dist/error.js",
+      "require": "./dist/error.cjs"
+    },
     "./types": "./dist/types.d.ts"
   },
-  "keywords": [
-    "router",
-    "endpoints",
-    "api",
-    "aura",
-    "aura stack",
-    "typescript",
-    "nodejs"
-  ],
-  "author": "Aura Stack <auraauthoss@gmail.com> | Hernan Alvarado <hernanvid123@gmail.com>",
-  "license": "MIT",
   "devDependencies": {
     "prettier": "^3.6.2",
     "tsup": "^8.5.0",
@@ -50,8 +67,10 @@
     "format:check": "prettier --check .",
     "test": "vitest --run",
     "test:watch": "vitest",
+    "test:bench": "vitest --run bench",
     "type-check": "tsc --noEmit",
     "clean": "rm -rf dist",
-    "clean:cts": "rm -rf dist/*.cts"
+    "clean:cts": "rm -rf dist/*.cts",
+    "prepublish": "pnpm clean:cts"
   }
 }

package/dist/assert.d.cts

@@ -1,32 +0,0 @@
-import { HTTPMethod, RoutePattern, RouteHandler } from './types.cjs';
-import 'zod';
-
-/**
- * Checks if the provided method is a supported HTTP method.
- *
- * @param method - The HTTP method to check.
- * @returns True if the method is supported, false otherwise.
- */
-declare const isSupportedMethod: (method: string) => method is HTTPMethod;
-/**
- * Check if the provided method can includes a body as per HTTP specification.
- * @param method - The HTTP method to check.
- * @returns True if the method can include a body, false otherwise.
- */
-declare const isSupportedBodyMethod: (method: string) => method is HTTPMethod;
-/**
- * Checks if the provided route is a valid route pattern.
- *
- * @param route - The route pattern to check.
- * @returns True if the route is valid, false otherwise.
- */
-declare const isValidRoute: (route: string) => route is RoutePattern;
-/**
- * Checks if the provided handler is a valid route handler function.
- *
- * @param handler - The handler to check.
- * @returns True if the handler is valid, false otherwise.
- */
-declare const isValidHandler: (handler: unknown) => handler is RouteHandler<any, any>;
-
-export { isSupportedBodyMethod, isSupportedMethod, isValidHandler, isValidRoute };

package/dist/chunk-DR4C6QTF.js

@@ -1,72 +0,0 @@
-import {
-  getBody,
-  getHeaders,
-  getRouteParams,
-  getSearchParams
-} from "./chunk-OXDCFAMF.js";
-import {
-  createRoutePattern
-} from "./chunk-YUX3YHXF.js";
-import {
-  executeGlobalMiddlewares,
-  executeMiddlewares
-} from "./chunk-O6SY753N.js";
-import {
-  AuraStackRouterError
-} from "./chunk-RFYOPPMW.js";
-
-// src/router.ts
-var createRouter = (endpoints, config = {}) => {
-  const server = {};
-  const groups = /* @__PURE__ */ new Map();
-  for (const endpoint of endpoints) {
-    if (!groups.has(endpoint.method)) {
-      groups.set(endpoint.method, []);
-    }
-    groups.get(endpoint.method)?.push(endpoint);
-  }
-  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 } = error;
-          return Response.json({ message }, { status, statusText });
-        }
-        return Response.json({ message: "Internal Server Error" }, { status: 500 });
-      }
-    };
-  }
-  return server;
-};
-
-export {
-  createRouter
-};

package/dist/chunk-O6SY753N.js

@@ -1,41 +0,0 @@
-import {
-  AuraStackRouterError
-} from "./chunk-RFYOPPMW.js";
-
-// 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");
-    }
-    const executed = await middleware(request);
-    if (executed instanceof Response) {
-      return executed;
-    }
-    request = executed;
-  }
-  if (!request || !(request instanceof Request)) {
-    throw new AuraStackRouterError("BAD_REQUEST", "Global middleware must return a Request or Response object");
-  }
-  return request;
-};
-var executeMiddlewares = async (request, 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");
-      }
-      ctx = await middleware(request, ctx);
-    }
-    return ctx;
-  } catch {
-    throw new AuraStackRouterError("BAD_REQUEST", "Handler threw an error");
-  }
-};
-
-export {
-  executeGlobalMiddlewares,
-  executeMiddlewares
-};

package/dist/chunk-OXDCFAMF.js

@@ -1,78 +0,0 @@
-import {
-  createRoutePattern
-} from "./chunk-YUX3YHXF.js";
-import {
-  isSupportedBodyMethod
-} from "./chunk-JRJKKBSH.js";
-import {
-  AuraStackRouterError
-} from "./chunk-RFYOPPMW.js";
-
-// 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}`);
-  }
-  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] ?? "")
-    }),
-    {}
-  );
-};
-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");
-    }
-    return parsed.data;
-  }
-  return new URLSearchParams(route.searchParams.toString());
-};
-var getHeaders = (request) => {
-  return new Headers(request.headers);
-};
-var getBody = async (request, config) => {
-  if (!isSupportedBodyMethod(request.method)) {
-    return void 0;
-  }
-  const contentType = request.headers.get("Content-Type") ?? "";
-  if (contentType.includes("application/json")) {
-    const json = await request.json();
-    if (config.schemas?.body) {
-      const parsed = config.schemas.body.safeParse(json);
-      if (!parsed.success) {
-        throw new AuraStackRouterError("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();
-  }
-  if (contentType.includes("application/octet-stream")) {
-    return await request.arrayBuffer();
-  }
-  if (contentType.includes("image/") || contentType.includes("video/") || contentType.includes("audio/")) {
-    return await request.blob();
-  }
-  return null;
-};
-
-export {
-  getRouteParams,
-  getSearchParams,
-  getHeaders,
-  getBody
-};

package/dist/chunk-YUX3YHXF.js

@@ -1,36 +0,0 @@
-import {
-  isSupportedMethod,
-  isValidHandler,
-  isValidRoute
-} from "./chunk-JRJKKBSH.js";
-import {
-  AuraStackRouterError
-} from "./chunk-RFYOPPMW.js";
-
-// src/endpoint.ts
-var createRoutePattern = (route) => {
-  const pattern = route.replace(/:[^/]+/g, "([^/]+)").replace(/\//g, "\\/");
-  return new RegExp(`^${pattern}$`);
-};
-var createEndpoint = (method, route, handler, config = {}) => {
-  if (!isSupportedMethod(method)) {
-    throw new AuraStackRouterError("METHOD_NOT_ALLOWED", `Unsupported HTTP method: ${method}`);
-  }
-  if (!isValidRoute(route)) {
-    throw new AuraStackRouterError("BAD_REQUEST", `Invalid route format: ${route}`);
-  }
-  if (!isValidHandler(handler)) {
-    throw new AuraStackRouterError("BAD_REQUEST", "Handler must be a function");
-  }
-  return { method, route, handler, config };
-};
-function createEndpointConfig(...args) {
-  if (typeof args[0] === "string") return args[1];
-  return args[0];
-}
-
-export {
-  createRoutePattern,
-  createEndpoint,
-  createEndpointConfig
-};

package/dist/context.d.cts

@@ -1,84 +0,0 @@
-import { RoutePattern, Params, EndpointConfig, ContextSearchParams } from './types.cjs';
-import 'zod';
-
-/**
- * Extracts route parameters from a given path using the specified route pattern.
- *
- * This function matches the provided path against the route pattern
- * (e.g., "/users/:userId/posts/:postId") and returns an object mapping parameter
- * names to their decoded values.
- *
- * @param route - The route pattern, typically defined in the endpoint configuration.
- * @param path - The actual request path to extract parameters from.
- * @returns An object containing the extracted route parameters as key-value pairs.
- *
- * @example
- * const route = "/users/:userId/posts/:postId";
- * const path = "/users/123/posts/456";
- *
- * // Expected: { userId: "123", postId: "456" }
- * const params = getRouteParams(route, path);
- */
-declare const getRouteParams: <Route extends RoutePattern>(route: Route, path: string) => Params<Route>;
-/**
- * Extracts and validates search parameters from a given URL from the request.
- *
- * If a schema is provided in the endpoint configuration, the search parameters
- * are validated against it using Zod and returned the parsed data. If validation
- * fails, an error is thrown. Otherwise, a URLSearchParams object is returned.
- *
- * @param url - The actual request URL to extract search parameters from.
- * @param config - Configuration object that may include a schema for validation.
- * @returns Either a URLSearchParams object or a parsed object based on the provided schema.
- * @example
- * // With schema
- * const url = "https://example.com/api?search=test&page=2";
- * const config: EndpointConfig = {
- *   schemas: {
- *     searchParams: z.object({
- *       search: z.string(),
- *       page: z.number().optional(),
- *     }),
- *   },
- * }
- *
- * // Expected: { search: "test", page: 2 }
- * const searchParams = getSearchParams(url, config);
- *
- * // Without schema
- * const url2 = "https://example.com/api?query=example";
- *
- * // Expected: URLSearchParams { 'query' => 'example' }
- * const searchParams2 = getSearchParams(url2, {} as EndpointConfig);
- */
-declare const getSearchParams: <Config extends EndpointConfig>(url: string, config: Config) => ContextSearchParams<Config["schemas"]>["searchParams"];
-/**
- * Extracts headers from the given Request object and returns them as a Headers instance.
- *
- * @param request - The Request object from which to extract headers.
- * @returns A Headers instance containing all headers from the request.
- * @example
- * const request = new Request("https://example.com/api", {
- *   headers: {
- *     "Content-Type": "application/json",
- *     "Authorization": "Bearer token",
- *   },
- * });
- * const headers = getHeaders(request);
- */
-declare const getHeaders: (request: Request) => Headers;
-/**
- * Extracts and parses the body of a Request object based on its Content-Type header.
- *
- * If a schema is provided in the endpoint configuration, the body is validated against
- * it using Zod and returned the parsed data. If validation fails, an error is thrown.
- *
- * In some cases, the browser includes text/plain;charset=UTF-8 as the default Content-Type
- *
- * @param request - The Request object from which to extract the body.
- * @param config - Configuration object that may include a schema for validation.
- * @returns The parsed body of the request or an error if validation fails.
- */
-declare const getBody: <Config extends EndpointConfig>(request: Request, config: Config) => Promise<any>;
-
-export { getBody, getHeaders, getRouteParams, getSearchParams };

package/dist/endpoint.d.cts

@@ -1,59 +0,0 @@
-import { RoutePattern, HTTPMethod, EndpointSchemas, RouteHandler, EndpointConfig, RouteEndpoint } from './types.cjs';
-import 'zod';
-
-/**
- * Create a RegExp pattern from a route string. This function allows segment the
- * dynamic params in the route. For example, the route `/users/:id` will be
- * converted to a regex pattern that captures the `id` parameter.
- *
- * @param route - The route pattern string
- * @returns A RegExp object that matches the route pattern
- * @example
- * // Expected: /^\/users\/([^/]+)$/
- * const pattern = createRoutePattern("/users/:id");
- */
-declare const createRoutePattern: (route: RoutePattern) => RegExp;
-/**
- * Defines an API endpoint for the router by specifying the HTTP method, route pattern,
- * handler function, and optional configuration such as validation schemas or middlewares.
- * Validates all parameters for correctness. The resulting endpoint should be passed
- * to the `createRouter` function.
- *
- * @param method - The HTTP method (e.g., GET, POST, PUT, DELETE, PATCH)
- * @param route - The route pattern to associate with the endpoint (supports dynamic params)
- * @param handler - The function to handle requests matching the method and route
- * @param config - Optional configuration including validation schemas, middlewares, etc.
- * @returns An object representing the configured endpoint
- * @example
- * const signIn = createEndpoint("POST", "/auth/signin", async (req, ctx) => {
- *   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, {
-    schemas: Schemas;
-}>, config?: EndpointConfig<Route, Schemas>) => RouteEndpoint<Method, Route, {}>;
-/**
- * Create an endpoint configuration to be passed to the `createEndpoint` function.
- * This function is primarily for type inference and does not perform any runtime checks.
- *
- * @experimental
- * @param config - The endpoint configuration object
- * @returns The same configuration object, typed as EndpointConfig
- * @example
- * const config = createEndpointConfig({
- *   middlewares: [myMiddleware],
- *   schemas: {
- *     searchParams: z.object({
- *       q: z.string().min(3),
- *     })
- *   }
- * })
- *
- * const search = createEndpoint("GET", "/search", async (request, ctx) => {
- *   return new Response("Search results");
- * }, config);
- */
-declare function createEndpointConfig<Schemas extends EndpointSchemas>(config: EndpointConfig<RoutePattern, Schemas>): EndpointConfig<RoutePattern, Schemas>;
-declare function createEndpointConfig<Route extends RoutePattern, S extends EndpointSchemas>(route: Route, config: EndpointConfig<Route, S>): EndpointConfig<Route, S>;
-
-export { createEndpoint, createEndpointConfig, createRoutePattern };

package/dist/error.d.cts

@@ -1,40 +0,0 @@
-/**
- * The HTTP status codes used in AuraStack Router.
- */
-declare const statusCode: {
-    OK: number;
-    CREATED: number;
-    ACCEPTED: number;
-    NO_CONTENT: number;
-    MULTIPLE_CHOICES: number;
-    MOVED_PERMANENTLY: number;
-    FOUND: number;
-    SEE_OTHER: number;
-    NOT_MODIFIED: number;
-    TEMPORARY_REDIRECT: number;
-    BAD_REQUEST: number;
-    UNAUTHORIZED: number;
-    PAYMENT_REQUIRED: number;
-    FORBIDDEN: number;
-    NOT_FOUND: number;
-    METHOD_NOT_ALLOWED: number;
-    NOT_ACCEPTABLE: number;
-    PROXY_AUTHENTICATION_REQUIRED: number;
-    UNPROCESSABLE_ENTITY: number;
-    INTERNAL_SERVER_ERROR: number;
-    NOT_IMPLEMENTED: number;
-    BAD_GATEWAY: number;
-    SERVICE_UNAVAILABLE: number;
-    HTTP_VERSION_NOT_SUPPORTED: number;
-};
-/**
- * Defines the errors used in AuraStack Router. Includes HTTP status code and
- * status text.
- */
-declare class AuraStackRouterError extends Error {
-    readonly status: number;
-    readonly statusText: keyof typeof statusCode;
-    constructor(type: keyof typeof statusCode, message: string, name?: string);
-}
-
-export { AuraStackRouterError };

package/dist/index.d.cts

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

package/dist/middlewares.d.cts

@@ -1,22 +0,0 @@
-import { RouterConfig, EndpointConfig, RequestContext, MiddlewareFunction } from './types.cjs';
-import 'zod';
-
-/**
- * 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,15 +0,0 @@
-import { RouteEndpoint, RouterConfig, GetHttpHandlers } from './types.cjs';
-import 'zod';
-
-/**
- * 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 { createRouter };