@stacksjs/bun-router 0.1.17 → 0.1.20

package/dist/response/markers.d.ts

@@ -0,0 +1,2 @@
+export declare const ENRICHED_NOT_FOUND_RESPONSE: unique symbol;
+export declare function markEnrichedNotFoundResponse(response: Response): Response;

package/dist/response/response-factory.d.ts

@@ -70,9 +70,6 @@ export interface ResponseFactory {
     serverError: (message?: string) => Response;
     tooManyRequests: (message?: string, retryAfter?: number) => Response;
 }
-/**
- * Response factory with common response helpers
- */
 export declare const response: ResponseFactory;
 /**
  * Fluent response builder

package/dist/router/index.d.ts

@@ -1,112 +1,8 @@
-import type { ActionHandler, Route } from '../types';
 import { Dependencies, globalMiddlewarePipeline, MiddlewareFactory, MiddlewarePipeline, SkipConditions } from '../middleware/pipeline';
 import { FluentRouteBuilder, FluentRouter, RouteFactory, router, RouterUtils } from './fluent-routing';
-import { Router } from './router';
-import '../types';
+import { Router } from './runtime';
 export { Router };
 export { applyRequestEnhancements } from './router';
-declare module './router' {
-    interface Router {
-        stream: (callback: () => Generator<string | Uint8Array, void, unknown> | AsyncGenerator<string | Uint8Array, void, unknown>, status?: number, headers?: Record<string, string>) => Response;
-        streamJson: <T>(data: Record<string, Iterable<T> | AsyncIterable<T>>, status?: number, headers?: Record<string, string>) => Response;
-        eventStream: <_T = any>(callback: () => Generator<{
-            data: any;
-            event?: string;
-            id?: string;
-            retry?: number;
-        }, void, unknown> | AsyncGenerator<{
-            data: any;
-            event?: string;
-            id?: string;
-            retry?: number;
-        }, void, unknown>, headers?: Record<string, string>) => Response;
-        streamDownload: (callback: () => Generator<string | Uint8Array, void, unknown> | AsyncGenerator<string | Uint8Array, void, unknown>, filename: string, headers?: Record<string, string>) => Response;
-        streamFile: (filePath: string, request: any, options?: {
-            contentType?: string;
-            enableRanges?: boolean;
-            chunkSize?: number;
-        }) => Promise<Response>;
-        streamFileWithRanges: (filePath: string, req: any) => Promise<Response>;
-        streamResponse: (generator: () => AsyncGenerator<string | Uint8Array, void, unknown>, options?: {
-            headers?: Record<string, string>;
-            status?: number;
-        }) => Response;
-        transformStream: (transformer: (chunk: string | Uint8Array) => string | Uint8Array | Promise<string | Uint8Array>, options?: {
-            headers?: Record<string, string>;
-            status?: number;
-        }) => (req: Request) => Response;
-        model: <T>(key: string, modelClass: string | ((_value: string) => Promise<T | null>), callback?: (model: T | null) => Response | null) => Router;
-        implicitBinding: () => any;
-        missing: (callback: (req: any) => Response) => any;
-        scopedBindings: (bindings: Record<string, string>) => any;
-        clearModelCache: (modelName?: string) => Router;
-        getModelStats: () => {
-            totalEntries: number;
-            validEntries: number;
-            expiredEntries: number;
-            models: number;
-        };
-        readonly modelRegistry: {
-            has: (name: string) => boolean;
-            register: <_T>(name: string, config: any) => void;
-            resolve: <_T>(modelName: string, params: Record<string, string>, req?: any) => Promise<any>;
-            createErrorResponse: (modelName: string, result: any, params: Record<string, string>) => Response;
-            clearCache: (modelName: string, params?: Record<string, string>) => void;
-            clearAllCache: () => void;
-            getCacheStats: () => any;
-        };
-        matchRoute(path: string, method: string, domain?: string): {
-            route: Route;
-            params: Record<string, string>;
-        } | undefined;
-        getAllowedMethods(path: string, domain?: string): string[];
-        clearRouteCache: () => void;
-        getCacheStats: () => any;
-        getRouteStats: () => any;
-        warmRouteCache: (commonPaths: Array<{
-            path: string;
-            method: string;
-        }>) => void;
-        getRoutesByMethod: () => any;
-        getRouteConflicts: () => any;
-        rebuildRouteCompiler: () => void;
-        optimizeRoutes: (usageStats?: Record<string, number>) => void;
-        addRouteToCompiler: (route: Route) => void;
-        initializeRouteCompiler: () => void;
-        health: () => Router;
-        renderView: (view: string, data?: Record<string, any>, options?: {
-            layout?: string;
-        }) => Promise<string>;
-        view: (path: string, view: string, data?: Record<string, any>, options?: {
-            layout?: string;
-            status?: number;
-            headers?: Record<string, string>;
-        }) => Router;
-        withoutNativeDispatch: () => Router;
-        where: ((_param: string, _pattern: string | RegExp) => Router) & ((constraints: Record<string, string | RegExp>) => Router);
-        whereNumber: (param: string) => Router;
-        whereAlpha: (param: string) => Router;
-        whereAlphaNumeric: (param: string) => Router;
-        whereUuid: (param: string) => Router;
-        whereIn: (param: string, values: string[]) => Router;
-        domain: (domain: string, callback: () => void) => Router;
-        resource: (name: string, handlers: {
-            index?: ActionHandler;
-            show?: ActionHandler;
-            store?: ActionHandler;
-            update?: ActionHandler;
-            destroy?: ActionHandler;
-            create?: ActionHandler;
-            edit?: ActionHandler;
-        }) => Router;
-        head: (path: string, handler: ActionHandler, type?: 'api' | 'web', name?: string, middleware?: any[]) => Router;
-        onError(handler: (error: Error) => Response | Promise<Response>): Router;
-        redirect(url: string, status?: 301 | 302 | 303 | 307 | 308): Response;
-        permanentRedirect(url: string): Response;
-        fallback(handler: ActionHandler): Router;
-        route(name: string, params?: Record<string, string>): string;
-    }
-}
 export { Dependencies, FluentRouteBuilder, FluentRouter, globalMiddlewarePipeline, MiddlewareFactory, MiddlewarePipeline, RouteFactory, router, RouterUtils, SkipConditions };
 export * from '../routing/route-caching';
 export * from '../routing/route-throttling';

package/dist/router/middleware-chain.d.ts

@@ -0,0 +1,10 @@
+import type { EnhancedRequest, MiddlewareHandler } from '../types';
+export type CompiledMiddlewareChain = (request: EnhancedRequest) => Response | null | Promise<Response | null>;
+export type PublicMiddlewareChain = (request: EnhancedRequest) => Promise<Response | null>;
+interface MiddlewareChainHost {
+    buildMiddlewareChain: (middlewares: MiddlewareHandler[]) => PublicMiddlewareChain;
+}
+export declare function compileMiddlewareChain(middlewares: MiddlewareHandler[]): CompiledMiddlewareChain;
+export declare function buildMiddlewareChain(middlewares: MiddlewareHandler[]): PublicMiddlewareChain;
+export declare function resolveMiddlewareChain(host: MiddlewareChainHost, middlewares: MiddlewareHandler[]): CompiledMiddlewareChain;
+export {};

package/dist/router/router.d.ts

@@ -39,7 +39,7 @@ export declare class Router {
         params: Record<string, string>;
     }>;
     staticRoutes: Map<string, Map<string, Route>>;
-    staticResponses: Map<string, Response>;
+    staticResponses: Map<string, Map<string, Response>>;
     precompiledPatterns: Map<string, RegExp>;
     domainPatternCache: Map<string, RegExp>;
     routeCompiler: RouteCompiler | null;

package/dist/router/runtime.d.ts

@@ -0,0 +1,107 @@
+import type { ActionHandler, Route } from '../types';
+import { Router } from './router';
+import '../types';
+export { Router };
+export { applyRequestEnhancements } from './router';
+declare module './router' {
+    interface Router {
+        stream: (callback: () => Generator<string | Uint8Array, void, unknown> | AsyncGenerator<string | Uint8Array, void, unknown>, status?: number, headers?: Record<string, string>) => Response;
+        streamJson: <T>(data: Record<string, Iterable<T> | AsyncIterable<T>>, status?: number, headers?: Record<string, string>) => Response;
+        eventStream: <_T = any>(callback: () => Generator<{
+            data: any;
+            event?: string;
+            id?: string;
+            retry?: number;
+        }, void, unknown> | AsyncGenerator<{
+            data: any;
+            event?: string;
+            id?: string;
+            retry?: number;
+        }, void, unknown>, headers?: Record<string, string>) => Response;
+        streamDownload: (callback: () => Generator<string | Uint8Array, void, unknown> | AsyncGenerator<string | Uint8Array, void, unknown>, filename: string, headers?: Record<string, string>) => Response;
+        streamFile: (filePath: string, request: any, options?: {
+            contentType?: string;
+            enableRanges?: boolean;
+            chunkSize?: number;
+        }) => Promise<Response>;
+        streamFileWithRanges: (filePath: string, req: any) => Promise<Response>;
+        streamResponse: (generator: () => AsyncGenerator<string | Uint8Array, void, unknown>, options?: {
+            headers?: Record<string, string>;
+            status?: number;
+        }) => Response;
+        transformStream: (transformer: (chunk: string | Uint8Array) => string | Uint8Array | Promise<string | Uint8Array>, options?: {
+            headers?: Record<string, string>;
+            status?: number;
+        }) => (req: Request) => Response;
+        model: <T>(key: string, modelClass: string | ((_value: string) => Promise<T | null>), callback?: (model: T | null) => Response | null) => Router;
+        implicitBinding: () => any;
+        missing: (callback: (req: any) => Response) => any;
+        scopedBindings: (bindings: Record<string, string>) => any;
+        clearModelCache: (modelName?: string) => Router;
+        getModelStats: () => {
+            totalEntries: number;
+            validEntries: number;
+            expiredEntries: number;
+            models: number;
+        };
+        readonly modelRegistry: {
+            has: (name: string) => boolean;
+            register: <_T>(name: string, config: any) => void;
+            resolve: <_T>(modelName: string, params: Record<string, string>, req?: any) => Promise<any>;
+            createErrorResponse: (modelName: string, result: any, params: Record<string, string>) => Response;
+            clearCache: (modelName: string, params?: Record<string, string>) => void;
+            clearAllCache: () => void;
+            getCacheStats: () => any;
+        };
+        matchRoute(path: string, method: string, domain?: string): {
+            route: Route;
+            params: Record<string, string>;
+        } | undefined;
+        getAllowedMethods(path: string, domain?: string): string[];
+        clearRouteCache: () => void;
+        getCacheStats: () => any;
+        getRouteStats: () => any;
+        warmRouteCache: (commonPaths: Array<{
+            path: string;
+            method: string;
+        }>) => void;
+        getRoutesByMethod: () => any;
+        getRouteConflicts: () => any;
+        rebuildRouteCompiler: () => void;
+        optimizeRoutes: (usageStats?: Record<string, number>) => void;
+        addRouteToCompiler: (route: Route) => void;
+        initializeRouteCompiler: () => void;
+        health: () => Router;
+        renderView: (view: string, data?: Record<string, any>, options?: {
+            layout?: string;
+        }) => Promise<string>;
+        view: (path: string, view: string, data?: Record<string, any>, options?: {
+            layout?: string;
+            status?: number;
+            headers?: Record<string, string>;
+        }) => Router;
+        withoutNativeDispatch: () => Router;
+        where: ((_param: string, _pattern: string | RegExp) => Router) & ((constraints: Record<string, string | RegExp>) => Router);
+        whereNumber: (param: string) => Router;
+        whereAlpha: (param: string) => Router;
+        whereAlphaNumeric: (param: string) => Router;
+        whereUuid: (param: string) => Router;
+        whereIn: (param: string, values: string[]) => Router;
+        domain: (domain: string, callback: () => void) => Router;
+        resource: (name: string, handlers: {
+            index?: ActionHandler;
+            show?: ActionHandler;
+            store?: ActionHandler;
+            update?: ActionHandler;
+            destroy?: ActionHandler;
+            create?: ActionHandler;
+            edit?: ActionHandler;
+        }) => Router;
+        head: (path: string, handler: ActionHandler, type?: 'api' | 'web', name?: string, middleware?: any[]) => Router;
+        onError(handler: (error: Error) => Response | Promise<Response>): Router;
+        redirect(url: string, status?: 301 | 302 | 303 | 307 | 308): Response;
+        permanentRedirect(url: string): Response;
+        fallback(handler: ActionHandler): Router;
+        route(name: string, params?: Record<string, string>): string;
+    }
+}

package/dist/runtime.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Runtime-only router surface for frameworks and API servers.
+ *
+ * The root entry intentionally exposes every bun-router subsystem. Consumers
+ * that only need to register and serve routes can import this entry without
+ * loading auth, containers, sessions, or testing utilities.
+ */
+export { applyRequestEnhancements, Router } from './router/runtime';
+export { enableRequestContext, getCurrentRequest, request, runWithRequest, runWithRequestArguments, setCurrentRequest, } from './request/context';
+export { applyResponseCompression, DEFAULT_COMPRESSION, } from './response/compression';
+export { response, ResponseBuilder, responseBuilder, } from './response/response-factory';
+export { ENRICHED_NOT_FOUND_RESPONSE } from './response/markers';
+export { createTypedRouter } from './typed/router';
+export type { ActionHandler, ActionPath, EnhancedRequest, ExtractRouteParams, KnownRouteName, MiddlewareHandler, MiddlewareReference, PathForRouteName, RequestFor, Route, ServerOptions, } from './types';
+export type { CompressionOptions } from './response/compression';
+export type { TypedRouter } from './typed/router';

package/dist/runtime.js

@@ -0,0 +1,2 @@
+// @bun
+import{Re,B,j,T,Y,ve,Q,m,r,Z,Ke,ee,n,se,Ce}from"./chunk-sr7yt36v.js";export{Q as DEFAULT_COMPRESSION,ee as ENRICHED_NOT_FOUND_RESPONSE,Z as ResponseBuilder,n as Router,se as applyRequestEnhancements,m as applyResponseCompression,Ce as createTypedRouter,Re as enableRequestContext,Y as getCurrentRequest,ve as request,r as response,Ke as responseBuilder,B as runWithRequest,j as runWithRequestArguments,T as setCurrentRequest};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@stacksjs/bun-router",
   "type": "module",
-  "version": "0.1.17",
+  "version": "0.1.20",
   "description": "A fast, type-safe router for Bun.",
   "author": "Chris Breuer <chris@stacksjs.com>",
   "license": "MIT",
@@ -28,6 +28,11 @@
       "bun": "./dist/index.js",
       "import": "./dist/index.js"
     },
+    "./runtime": {
+      "types": "./dist/runtime.d.ts",
+      "bun": "./dist/runtime.js",
+      "import": "./dist/runtime.js"
+    },
     "./container": {
       "types": "./dist/container/index.d.ts",
       "bun": "./dist/container/index.js",
@@ -45,6 +50,11 @@
         "bun": "./dist/index.js",
         "import": "./dist/index.js"
       },
+      "./runtime": {
+        "types": "./dist/runtime.d.ts",
+        "bun": "./dist/runtime.js",
+        "import": "./dist/runtime.js"
+      },
       "./container": {
         "types": "./dist/container/index.d.ts",
         "bun": "./dist/container/index.js",