@stacksjs/bun-router 0.0.15 → 0.0.17

package/dist/cli.js

@@ -1,7 +1,8 @@
 // @bun
 import {
   middleware
-} from "./chunk-j0e7z7hd.js";
+} from "./chunk-cgptvjdf.js";
+import"./chunk-1ahs68ys.js";
 
 // src/cli/index.ts
 import process15 from "process";
@@ -572,11 +573,9 @@ class Command {
   isMatched(name) {
     if (this.aliasNames.includes(name))
       return true;
-    if (this.name === name)
-      return true;
-    if (this.namespace && `${this.namespace}:${this.name}` === name)
-      return true;
-    return false;
+    if (this.namespace)
+      return `${this.namespace}:${this.name}` === name;
+    return this.name === name;
   }
   get isDefaultCommand() {
     return this.name === "" || this.aliasNames.includes("!");
@@ -584,6 +583,9 @@ class Command {
   get isGlobalCommand() {
     return this instanceof GlobalCommand;
   }
+  get displayName() {
+    return this.namespace ? `${this.namespace}:${this.name}` : this.name;
+  }
   hasOption(name) {
     name = name.split(".")[0];
     return !!this.options.find((option) => {
@@ -649,7 +651,7 @@ class Command {
       });
       sections.push({
         title: `For more info, run any command with the \`--help\` flag`,
-        body: commands.map((command) => `  $ ${name}${command.name === "" ? "" : ` ${command.name}`} --help`).join(`
+        body: commands.map((command) => `  $ ${name}${command.displayName === "" ? "" : ` ${command.displayName}`} --help`).join(`
 `)
       });
     }
@@ -1004,8 +1006,8 @@ Received ${signal}, cleaning up...`);
     if (this.enableDidYouMean) {
       const allCommandNames = [];
       for (const command of this.commands) {
-        if (command.name) {
-          allCommandNames.push(command.name);
+        if (command.displayName) {
+          allCommandNames.push(command.displayName);
         }
         if (command.aliasNames) {
           allCommandNames.push(...command.aliasNames);
@@ -1961,7 +1963,7 @@ class GroupMultiSelectPrompt extends Prompt {
       this.value = [];
     }
     if (item.group === true) {
-      const group = item.value;
+      const group = String(item.value);
       const groupedItems = this.getGroupItems(group);
       if (this.isGroupSelected(group)) {
         this.value = this.value.filter((v) => groupedItems.findIndex((i) => i.value === v) === -1);
@@ -2044,7 +2046,7 @@ function getPrefix() {
 }
 var prefix = getPrefix();
 // package.json
-var version = "0.0.15";
+var version = "0.0.17";
 
 // 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/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';