@stacksjs/bun-router 0.0.16 → 0.0.18

package/dist/cli.js

@@ -1,7 +1,8 @@
 // @bun
 import {
   middleware
-} from "./chunk-0145g1me.js";
+} from "./chunk-cgptvjdf.js";
+import"./chunk-1ahs68ys.js";
 
 // src/cli/index.ts
 import process15 from "process";
@@ -2045,7 +2046,7 @@ function getPrefix() {
 }
 var prefix = getPrefix();
 // package.json
-var version = "0.0.16";
+var version = "0.0.18";
 
 // src/cli/middleware.ts
 import fs2 from "fs/promises";

package/dist/container/container.d.ts

@@ -66,6 +66,7 @@ export interface InjectMetadata {
  */
 export declare class Container {
     private bindings;
+    private tagIndex;
     private instances;
     private scopedInstances;
     private interceptors;

package/dist/container/contextual-binding.d.ts

@@ -237,4 +237,3 @@ export declare class BindingConditions {
      */
     static custom(predicate: (context: ResolutionContext) => boolean, description?: string): BindingCondition;
 }
-export { ContextualContainer as DIContainer };

package/dist/container/decorators.d.ts

@@ -2,11 +2,8 @@
  * Modern Dependency Injection Decorators
  */
 import type { ResolutionContext } from './container';
-import { Container } from './container';
-export declare const INJECTABLE_METADATA_KEY: unique symbol;
-export declare const INJECT_METADATA_KEY: unique symbol;
-export declare const OPTIONAL_METADATA_KEY: unique symbol;
-export declare const TAGGED_METADATA_KEY: unique symbol;
+import { Container, INJECT_METADATA_KEY, INJECTABLE_METADATA_KEY, OPTIONAL_METADATA_KEY, TAGGED_METADATA_KEY } from './container';
+export { INJECT_METADATA_KEY, INJECTABLE_METADATA_KEY, OPTIONAL_METADATA_KEY, TAGGED_METADATA_KEY };
 export declare const CONTROLLER_METADATA_KEY: unique symbol;
 export declare const ROUTE_METADATA_KEY: unique symbol;
 export declare const MIDDLEWARE_METADATA_KEY: unique symbol;

package/dist/container/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Dependency-injection container — public entry point.
+ *
+ * ```ts
+ * import { Container, createContainer, Inject, Injectable } from '@stacksjs/bun-router/container'
+ * ```
+ *
+ * The core `Container` (and a few companions) are also re-exported from the
+ * package root; the decorators live only here because their names (`Get`,
+ * `Post`, `Controller`, …) would collide with the router's exports.
+ */
+export * from './container';
+export { Body, Controller, CONTROLLER_METADATA_KEY, Cookie, decoratorContainer, DecoratorContainer, Delete, Get, Head, Header, Inject, Injectable, InjectParam, MetadataReader, MIDDLEWARE_METADATA_KEY, Optional, Options, Param, PARAM_METADATA_KEY, Patch, Post, Put, Query, ROUTE_METADATA_KEY, Tagged, UseMiddleware, } from './decorators';
+export type { ControllerMetadata, ParamMetadata, RouteMetadata } from './decorators';
+export * from './contextual-binding';
+export * from './service-provider';

package/dist/container/index.js

@@ -0,0 +1,322 @@
+// @bun
+import {
+  AuthGuard,
+  AuthService,
+  AuthServiceProvider,
+  BaseDeferredServiceProvider,
+  BaseServiceProvider,
+  BindingBuilder,
+  BindingConditions,
+  CacheManager,
+  CacheServiceProvider,
+  ConfigService,
+  ConfigServiceProvider,
+  ConsoleLogger,
+  Container,
+  ContextualContainer,
+  DatabaseConnection,
+  DatabaseServiceProvider,
+  DefaultContextualBindingBuilder,
+  DefaultServiceProviderManager,
+  EnvironmentManager,
+  EnvironmentPresets,
+  EventBus,
+  EventDispatcher,
+  EventServiceProvider,
+  FileLogger,
+  INJECTABLE_METADATA_KEY,
+  INJECT_METADATA_KEY,
+  JwtService,
+  Logger,
+  LoggingServiceProvider,
+  MemoryCache,
+  OPTIONAL_METADATA_KEY,
+  PostRepository,
+  RedisCache,
+  TAGGED_METADATA_KEY,
+  UserRepository,
+  ValidationPipe,
+  ValidationServiceProvider,
+  Validator,
+  createContainer,
+  getContainer,
+  setContainer
+} from "../chunk-g3ybefhg.js";
+import"../chunk-1ahs68ys.js";
+// src/container/decorators.ts
+var CONTROLLER_METADATA_KEY = Symbol("controller");
+var ROUTE_METADATA_KEY = Symbol("route");
+var MIDDLEWARE_METADATA_KEY = Symbol("middleware");
+var PARAM_METADATA_KEY = Symbol("param");
+function Injectable(metadata = {}) {
+  return (target) => {
+    target[INJECTABLE_METADATA_KEY] = metadata;
+    return target;
+  };
+}
+function Inject(token, options) {
+  return function(target, _propertyKey, parameterIndex) {
+    const classConstructor = target.constructor === Function ? target : target.constructor;
+    if (!classConstructor[INJECT_METADATA_KEY]) {
+      classConstructor[INJECT_METADATA_KEY] = [];
+    }
+    const metadata = {
+      token,
+      optional: options?.optional,
+      tags: options?.tags,
+      when: options?.when
+    };
+    classConstructor[INJECT_METADATA_KEY][parameterIndex] = metadata;
+  };
+}
+function Optional() {
+  return (target, _propertyKey, parameterIndex) => {
+    if (!target[OPTIONAL_METADATA_KEY]) {
+      target[OPTIONAL_METADATA_KEY] = [];
+    }
+    target[OPTIONAL_METADATA_KEY][parameterIndex] = true;
+  };
+}
+function Tagged(tag) {
+  return function(target, _propertyKey, parameterIndex) {
+    if (!target[TAGGED_METADATA_KEY]) {
+      target[TAGGED_METADATA_KEY] = [];
+    }
+    target[TAGGED_METADATA_KEY][parameterIndex] = tag;
+  };
+}
+function Controller(prefix, options) {
+  return function(target) {
+    const metadata = {
+      prefix: prefix || "",
+      middleware: options?.middleware || [],
+      tags: options?.tags || []
+    };
+    target[CONTROLLER_METADATA_KEY] = metadata;
+    return target;
+  };
+}
+function Get(path = "", options) {
+  return createRouteDecorator("GET", path, options);
+}
+function Post(path = "", options) {
+  return createRouteDecorator("POST", path, options);
+}
+function Put(path = "", options) {
+  return createRouteDecorator("PUT", path, options);
+}
+function Delete(path = "", options) {
+  return createRouteDecorator("DELETE", path, options);
+}
+function Patch(path = "", options) {
+  return createRouteDecorator("PATCH", path, options);
+}
+function Options(path = "", options) {
+  return createRouteDecorator("OPTIONS", path, options);
+}
+function Head(path = "", options) {
+  return createRouteDecorator("HEAD", path, options);
+}
+function createRouteDecorator(method, path, options) {
+  return function(target, propertyKey, descriptor) {
+    if (!target.constructor[ROUTE_METADATA_KEY]) {
+      target.constructor[ROUTE_METADATA_KEY] = [];
+    }
+    const metadata = {
+      method,
+      path,
+      middleware: options?.middleware || [],
+      tags: options?.tags || []
+    };
+    target.constructor[ROUTE_METADATA_KEY].push({
+      ...metadata,
+      propertyKey,
+      handler: descriptor.value
+    });
+    return descriptor;
+  };
+}
+function UseMiddleware(...middleware) {
+  return function(target, propertyKey, descriptor) {
+    if (propertyKey && descriptor) {
+      if (!target.constructor[MIDDLEWARE_METADATA_KEY]) {
+        target.constructor[MIDDLEWARE_METADATA_KEY] = new Map;
+      }
+      target.constructor[MIDDLEWARE_METADATA_KEY].set(propertyKey, middleware);
+    } else {
+      target[MIDDLEWARE_METADATA_KEY] = middleware;
+    }
+    return descriptor || target;
+  };
+}
+function Param(key) {
+  return createParamDecorator("param", key);
+}
+function Query(key) {
+  return createParamDecorator("query", key);
+}
+function Body() {
+  return createParamDecorator("body");
+}
+function Header(key) {
+  return createParamDecorator("header", key);
+}
+function Cookie(key) {
+  return createParamDecorator("cookie", key);
+}
+function InjectParam(token) {
+  return createParamDecorator("param", undefined, token);
+}
+function createParamDecorator(type, key, token) {
+  return function(target, propertyKey, parameterIndex) {
+    if (!target.constructor[PARAM_METADATA_KEY]) {
+      target.constructor[PARAM_METADATA_KEY] = new Map;
+    }
+    if (!target.constructor[PARAM_METADATA_KEY].has(propertyKey)) {
+      target.constructor[PARAM_METADATA_KEY].set(propertyKey, []);
+    }
+    const metadata = {
+      type,
+      key,
+      token
+    };
+    target.constructor[PARAM_METADATA_KEY].get(propertyKey)[parameterIndex] = metadata;
+  };
+}
+
+class MetadataReader {
+  static getInjectableMetadata(target) {
+    return target[INJECTABLE_METADATA_KEY];
+  }
+  static getInjectMetadata(target) {
+    return target[INJECT_METADATA_KEY] || [];
+  }
+  static getOptionalMetadata(target) {
+    return target[OPTIONAL_METADATA_KEY] || [];
+  }
+  static getTaggedMetadata(target) {
+    return target[TAGGED_METADATA_KEY] || [];
+  }
+  static getControllerMetadata(target) {
+    return target[CONTROLLER_METADATA_KEY];
+  }
+  static getAllRoutes(target) {
+    return target[ROUTE_METADATA_KEY] || [];
+  }
+  static getMiddlewareMetadata(target, propertyKey) {
+    if (propertyKey) {
+      const methodMiddleware = target[MIDDLEWARE_METADATA_KEY]?.get(propertyKey);
+      return methodMiddleware || [];
+    }
+    return target[MIDDLEWARE_METADATA_KEY] || [];
+  }
+  static getParamMetadata(target, propertyKey) {
+    return target[PARAM_METADATA_KEY]?.get(propertyKey) || [];
+  }
+}
+
+class DecoratorContainer extends Container {
+  registerController(controllerClass) {
+    const metadata = MetadataReader.getControllerMetadata(controllerClass);
+    if (!metadata) {
+      throw new Error(`Class ${controllerClass.name} is not decorated with @Controller`);
+    }
+    this.singleton(controllerClass, controllerClass);
+    const routes = MetadataReader.getAllRoutes(controllerClass);
+    for (const _route of routes) {}
+  }
+  resolve(token, context) {
+    if (typeof token === "function") {
+      const metadata = MetadataReader.getInjectableMetadata(token);
+      if (metadata) {
+        try {
+          return super.resolve(token, context);
+        } catch {
+          const scope = metadata.scope || "transient";
+          switch (scope) {
+            case "singleton":
+              this.singleton(token, token);
+              break;
+            case "transient":
+              this.transient(token, token);
+              break;
+            default:
+              this.transient(token, token);
+          }
+        }
+      }
+    }
+    return super.resolve(token, context);
+  }
+}
+var decoratorContainer = new DecoratorContainer;
+export {
+  setContainer,
+  getContainer,
+  decoratorContainer,
+  createContainer,
+  Validator,
+  ValidationServiceProvider,
+  ValidationPipe,
+  UserRepository,
+  UseMiddleware,
+  Tagged,
+  TAGGED_METADATA_KEY,
+  RedisCache,
+  ROUTE_METADATA_KEY,
+  Query,
+  Put,
+  PostRepository,
+  Post,
+  Patch,
+  Param,
+  PARAM_METADATA_KEY,
+  Options,
+  Optional,
+  OPTIONAL_METADATA_KEY,
+  MetadataReader,
+  MemoryCache,
+  MIDDLEWARE_METADATA_KEY,
+  LoggingServiceProvider,
+  Logger,
+  JwtService,
+  Injectable,
+  InjectParam,
+  Inject,
+  INJECT_METADATA_KEY,
+  INJECTABLE_METADATA_KEY,
+  Header,
+  Head,
+  Get,
+  FileLogger,
+  EventServiceProvider,
+  EventDispatcher,
+  EventBus,
+  EnvironmentPresets,
+  EnvironmentManager,
+  Delete,
+  DefaultServiceProviderManager,
+  DefaultContextualBindingBuilder,
+  DecoratorContainer,
+  DatabaseServiceProvider,
+  DatabaseConnection,
+  Container as DIContainer,
+  Cookie,
+  Controller,
+  ContextualContainer,
+  Container,
+  ConsoleLogger,
+  ConfigServiceProvider,
+  ConfigService,
+  CacheServiceProvider,
+  CacheManager,
+  CONTROLLER_METADATA_KEY,
+  Body,
+  BindingConditions,
+  BindingBuilder,
+  BaseServiceProvider,
+  BaseDeferredServiceProvider,
+  AuthServiceProvider,
+  AuthService,
+  AuthGuard
+};

package/dist/container/service-provider.d.ts

@@ -181,7 +181,7 @@ export declare class LoggingServiceProvider extends BaseServiceProvider {
  */
 export declare class DatabaseServiceProvider extends BaseServiceProvider {
     readonly name = "database";
-    readonly dependencies: readonly ["config", "logging"];
+    readonly dependencies: readonly ['config', 'logging'];
     register(container: Container): void;
     boot(container: Container): Promise<void>;
     shutdown(container: Container): Promise<void>;
@@ -191,7 +191,7 @@ export declare class DatabaseServiceProvider extends BaseServiceProvider {
  */
 export declare class CacheServiceProvider extends BaseServiceProvider {
     readonly name = "cache";
-    readonly dependencies: readonly ["config"];
+    readonly dependencies: readonly ['config'];
     register(container: Container): void;
 }
 /**
@@ -199,7 +199,7 @@ export declare class CacheServiceProvider extends BaseServiceProvider {
  */
 export declare class AuthServiceProvider extends BaseServiceProvider {
     readonly name = "auth";
-    readonly dependencies: readonly ["config", "database"];
+    readonly dependencies: readonly ['config', 'database'];
     register(container: Container): void;
 }
 /**

package/dist/development/performance-profiler.d.ts

@@ -201,11 +201,11 @@ export declare const PerformanceProfilingHelpers: {
     /**
      * Record timing from request context
      */
-    startTiming: (req: EnhancedRequest, phase: keyof RouteProfile["phases"], name: string) => string | null;
+    startTiming: (req: EnhancedRequest, phase: keyof RouteProfile['phases'], name: string) => string | null;
     /**
      * End timing from request context
      */
-    endTiming: (req: EnhancedRequest, phase: keyof RouteProfile["phases"], timingId: string) => void;
+    endTiming: (req: EnhancedRequest, phase: keyof RouteProfile['phases'], timingId: string) => void;
     /**
      * Record database query from request context
      */
@@ -213,5 +213,5 @@ export declare const PerformanceProfilingHelpers: {
     /**
      * Record profile point from request context
      */
-    recordPoint: (req: EnhancedRequest, phase: keyof RouteProfile["phases"], name: string, metadata?: Record<string, any>) => void;
+    recordPoint: (req: EnhancedRequest, phase: keyof RouteProfile['phases'], name: string, metadata?: Record<string, any>) => void;
 };

package/dist/development/route-debugger.d.ts

@@ -150,5 +150,5 @@ export declare const RouteDebugHelpers: {
     /**
      * Record timing from request context
      */
-    recordTiming: (req: EnhancedRequest, phase: keyof RouteDebugInfo["timings"], duration: number) => void;
+    recordTiming: (req: EnhancedRequest, phase: keyof RouteDebugInfo['timings'], duration: number) => void;
 };

package/dist/development/route-inspector.d.ts

@@ -199,7 +199,7 @@ export declare const RouteInspectionHelpers: {
     /**
      * List all routes in a formatted table
      */
-    listRoutes: (filter?: Parameters<RouteInspector["getRoutes"]>[0]) => void;
+    listRoutes: (filter?: Parameters<RouteInspector['getRoutes']>[0]) => void;
     /**
      * Analyze routes and show recommendations
      */
@@ -207,5 +207,5 @@ export declare const RouteInspectionHelpers: {
     /**
      * Export routes to file
      */
-    exportRoutes: (format?: "json" | "csv" | "markdown" | "openapi", filename?: string) => void;
+    exportRoutes: (format?: 'json' | 'csv' | 'markdown' | 'openapi', filename?: string) => void;
 };

package/dist/file-serving/static-files.d.ts

@@ -17,6 +17,12 @@ export interface StaticFileConfig {
     compressionThreshold?: number;
     cacheControl?: string;
     dotfiles?: 'allow' | 'deny' | 'ignore';
+    /**
+     * Files larger than this (bytes) are streamed straight from disk via
+     * `Bun.file()` instead of being buffered into the in-memory cache.
+     * Streamed responses support HTTP Range requests (206). Default: 5 MiB.
+     */
+    maxCacheFileSize?: number;
 }
 export interface FileCache {
     content: ArrayBuffer;
@@ -56,6 +62,11 @@ export declare class StaticFileServer {
      * Serve cached file with proper headers
      */
     private serveCachedFile;
+    /**
+     * Stream a file from disk without buffering it into memory.
+     * Supports single-range HTTP Range requests (RFC 9110 §14).
+     */
+    private serveStreamedFile;
     /**
      * Resolve file path, handling index files and extensions
      */
@@ -88,6 +99,11 @@ export declare class StaticFileServer {
      * Clear cache
      */
     clearCache(): void;
+    /**
+     * Invalidate a single cached file (e.g. from a file watcher), leaving
+     * the rest of the cache warm.
+     */
+    invalidateFile(filePath: string): void;
     /**
      * Get cache size
      */

package/dist/index.d.ts

@@ -1,14 +1,30 @@
+/**
+ * @stacksjs/bun-router — a fast, type-safe router for Bun.
+ *
+ * Main entry point. The most commonly used exports:
+ * - `Router` — the primary router class (from `./router`)
+ * - `FluentRouter` / `router` — chainable routing API
+ * - `Auth`, `JWT`, `ApiKeyManager`, `OAuth2Helper` — auth helpers
+ * - `Container`, `createContainer` — dependency-injection container
+ * - `url()` / `registerNamedRoute()` — named-route URL generation
+ * - `Errors` — namespaced error/exception types
+ */
 export { default as Auth } from './auth';
 export * from './auth';
 export * from './config';
+export { BindingBuilder, Container, createContainer, getContainer, setContainer, } from './container/container';
+export type { Binding, BindingScope, ContainerOptions, ResolutionContext, Token } from './container/container';
+export { ContextualContainer, EnvironmentManager } from './container/contextual-binding';
+export { DefaultServiceProviderManager } from './container/service-provider';
 export * as Errors from './errors';
 export * from './middleware';
-export { getCurrentRequest, request, runWithRequest, setCurrentRequest } from './request/context';
+export { enableRequestContext, getCurrentRequest, request, runWithRequest, setCurrentRequest } from './request/context';
 export * from './session';
 export * from './response/response-factory';
 export * from './router';
 export { MiddlewareGroupRegistry, middlewareGroups } from './router/middleware-groups';
 export * from './testing';
 export * from './types';
+export * from './validation/validator';
 export { clearNamedRoutes, getNamedRoutePath, getNamedRoutes, registerNamedRoute, url, type UrlOptions } from './url';
 export * from './utils';