@stacksjs/bun-router 0.0.13 → 0.0.14

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

@@ -1,285 +0,0 @@
-/**
- * Service Providers for Bootstrapping
- *
- * Service provider system for registering services, managing lifecycle,
- * and bootstrapping application components with dependency injection
- */
-import type { BindingBuilder, Container, ResolutionContext } from './container';
-export interface ServiceProvider {
-    /**
-     * Register services in the container
-     */
-    register: (container: Container) => void | Promise<void>;
-    /**
-     * Boot services after all providers are registered
-     */
-    boot?: (container: Container) => void | Promise<void>;
-    /**
-     * Shutdown services gracefully
-     */
-    shutdown?: (container: Container) => void | Promise<void>;
-    /**
-     * Provider metadata
-     */
-    readonly name: string;
-    readonly version?: string;
-    readonly dependencies?: readonly string[];
-    readonly environment?: string[];
-    readonly priority?: number;
-}
-export interface DeferredServiceProvider extends ServiceProvider {
-    /**
-     * Services that should trigger loading of this provider
-     */
-    provides: () => (string | symbol | Function)[];
-    /**
-     * Check if provider should be loaded
-     */
-    isDeferred: () => boolean;
-}
-export interface ConditionalServiceProvider extends ServiceProvider {
-    /**
-     * Check if provider should be loaded based on environment
-     */
-    shouldLoad: (container: Container) => boolean | Promise<boolean>;
-}
-export interface ServiceProviderManager {
-    register: (provider: ServiceProvider) => this;
-    boot: () => Promise<void>;
-    shutdown: () => Promise<void>;
-    getProvider: (name: string) => ServiceProvider | undefined;
-    getProviders: () => ServiceProvider[];
-}
-/**
- * Base service provider implementation
- */
-export declare abstract class BaseServiceProvider implements ServiceProvider {
-    abstract readonly name: string;
-    readonly version?: string;
-    readonly dependencies?: readonly string[];
-    readonly environment?: string[];
-    readonly priority: number;
-    abstract register(container: Container): void | Promise<void>;
-    boot?(_container: Container): void | Promise<void>;
-    shutdown?(_container: Container): void | Promise<void>;
-    /**
-     * Helper method to bind singleton
-     */
-    protected singleton<T>(container: Container, token: string | symbol | Function, implementation: new (...args: any[]) => T): void;
-    /**
-     * Helper method to bind transient
-     */
-    protected transient<T>(container: Container, token: string | symbol | Function, implementation: new (...args: any[]) => T): void;
-    /**
-     * Helper method to bind value
-     */
-    protected value<T>(container: Container, token: string | symbol | Function, value: T): void;
-    /**
-     * Helper method to bind factory
-     */
-    protected factory<T>(container: Container, token: string | symbol | Function, factory: (...args: any[]) => T): void;
-    /**
-     * Helper method for conditional binding
-     */
-    protected when(container: Container, condition: (context: ResolutionContext) => boolean): {
-        bind: <T>(token: string | symbol | Function) => BindingBuilder<T>;
-    };
-    /**
-     * Helper method for environment-specific binding
-     */
-    protected forEnvironment(container: Container, ...environments: string[]): {
-        bind: <T>(token: string | symbol | Function) => BindingBuilder<T>;
-    };
-}
-/**
- * Deferred service provider base class
- */
-export declare abstract class BaseDeferredServiceProvider extends BaseServiceProvider implements DeferredServiceProvider {
-    abstract provides(): (string | symbol | Function)[];
-    isDeferred(): boolean;
-}
-/**
- * Service provider manager implementation
- */
-export declare class DefaultServiceProviderManager implements ServiceProviderManager {
-    private providers;
-    private deferredProviders;
-    private loadedProviders;
-    private bootedProviders;
-    private container;
-    constructor(container: Container);
-    /**
-     * Register a service provider
-     */
-    register(provider: ServiceProvider): this;
-    /**
-     * Boot all registered providers
-     */
-    boot(): Promise<void>;
-    /**
-     * Shutdown all providers
-     */
-    shutdown(): Promise<void>;
-    /**
-     * Get provider by name
-     */
-    getProvider(name: string): ServiceProvider | undefined;
-    /**
-     * Get all providers
-     */
-    getProviders(): ServiceProvider[];
-    /**
-     * Load deferred provider when needed
-     */
-    loadDeferredProvider(token: string | symbol | Function): Promise<void>;
-    /**
-     * Internal registration logic
-     */
-    private doRegister;
-    /**
-     * Load a provider
-     */
-    private loadProvider;
-    /**
-     * Boot a provider
-     */
-    private bootProvider;
-    /**
-     * Validate provider dependencies
-     */
-    private validateDependencies;
-    /**
-     * Check if provider is deferred
-     */
-    private isDeferredProvider;
-    /**
-     * Check if provider is conditional
-     */
-    private isConditionalProvider;
-}
-/**
- * Common service providers
- */
-/**
- * Configuration service provider
- */
-export declare class ConfigServiceProvider extends BaseServiceProvider {
-    readonly name = "config";
-    readonly priority = 100;
-    register(container: Container): void;
-}
-/**
- * Logging service provider
- */
-export declare class LoggingServiceProvider extends BaseServiceProvider {
-    readonly name = "logging";
-    readonly priority = 90;
-    register(container: Container): void;
-}
-/**
- * Database service provider
- */
-export declare class DatabaseServiceProvider extends BaseServiceProvider {
-    readonly name = "database";
-    readonly dependencies: readonly ["config", "logging"];
-    register(container: Container): void;
-    boot(container: Container): Promise<void>;
-    shutdown(container: Container): Promise<void>;
-}
-/**
- * Cache service provider
- */
-export declare class CacheServiceProvider extends BaseServiceProvider {
-    readonly name = "cache";
-    readonly dependencies: readonly ["config"];
-    register(container: Container): void;
-}
-/**
- * Authentication service provider
- */
-export declare class AuthServiceProvider extends BaseServiceProvider {
-    readonly name = "auth";
-    readonly dependencies: readonly ["config", "database"];
-    register(container: Container): void;
-}
-/**
- * Validation service provider
- */
-export declare class ValidationServiceProvider extends BaseServiceProvider {
-    readonly name = "validation";
-    register(container: Container): void;
-}
-/**
- * Event service provider (deferred)
- */
-export declare class EventServiceProvider extends BaseDeferredServiceProvider {
-    readonly name = "events";
-    provides(): (string | symbol | Function)[];
-    register(container: Container): void;
-}
-declare class ConfigService {
-    get(key: string, defaultValue?: any): any;
-}
-declare class Logger {
-    private config;
-    constructor(config: any);
-    log(message: string): void;
-}
-declare class ConsoleLogger extends Logger {
-    constructor();
-}
-declare class FileLogger extends Logger {
-    private filePath;
-    constructor(filePath: string);
-}
-declare class DatabaseConnection {
-    connect(): Promise<void>;
-    disconnect(): Promise<void>;
-}
-declare class UserRepository {
-    private db;
-    constructor(db: DatabaseConnection);
-}
-declare class PostRepository {
-    private db;
-    constructor(db: DatabaseConnection);
-}
-declare class CacheManager {
-    private store;
-    constructor(store: any);
-}
-declare class MemoryCache {
-    private cache;
-}
-declare class RedisCache {
-    private config;
-    constructor(config: any);
-}
-declare class AuthService {
-    private jwt;
-    private userRepo;
-    constructor(jwt: JwtService, userRepo: UserRepository);
-}
-declare class JwtService {
-    private config;
-    constructor(config: ConfigService);
-}
-declare class AuthGuard {
-    private auth;
-    constructor(auth: AuthService);
-}
-declare class Validator {
-    validate(_data: any, _rules: any): boolean;
-}
-declare class ValidationPipe {
-    private validator;
-    constructor(validator: Validator);
-}
-declare class EventBus {
-    emit(_event: string, _data: any): void;
-}
-declare class EventDispatcher {
-    private bus;
-    constructor(bus: EventBus);
-}
-export { AuthGuard, AuthService, CacheManager, ConfigService, ConsoleLogger, DatabaseConnection, EventBus, EventDispatcher, FileLogger, JwtService, Logger, MemoryCache, PostRepository, RedisCache, UserRepository, ValidationPipe, Validator, };

package/dist/development/hot-reload.d.ts

@@ -1,187 +0,0 @@
-/**
- * Hot Reload Development
- *
- * Hot reload for development using Bun's --hot mode with state preservation
- */
-export interface HotReloadConfig {
-    enabled?: boolean;
-    watchPaths?: string[];
-    ignorePaths?: string[];
-    extensions?: string[];
-    debounceMs?: number;
-    preserveState?: boolean;
-    onReload?: (changedFiles: string[]) => void;
-    onError?: (error: Error) => void;
-    verbose?: boolean;
-}
-export interface HotReloadState {
-    reloadCount: number;
-    lastReload: number;
-    changedFiles: string[];
-    preservedState: Record<string, any>;
-    watchers: Map<string, any>;
-}
-declare global {
-    var __HOT_RELOAD_STATE__: HotReloadState | undefined;
-    var __HOT_RELOAD_PRESERVE__: Record<string, any>;
-}
-/**
- * Hot reload manager for development
- */
-export declare class HotReloadManager {
-    private config;
-    private state;
-    private debounceTimer?;
-    private isReloading;
-    constructor(config?: HotReloadConfig);
-    /**
-     * Initialize or restore hot reload state
-     */
-    private initializeState;
-    /**
-     * Setup file watchers
-     */
-    private setupWatchers;
-    /**
-     * Handle file change event
-     */
-    private handleFileChange;
-    /**
-     * Check if file should be ignored
-     */
-    private shouldIgnoreFile;
-    /**
-     * Check if file should be watched
-     */
-    private shouldWatchFile;
-    /**
-     * Trigger hot reload
-     */
-    private triggerReload;
-    /**
-     * Preserve state across reloads
-     */
-    preserveState<T>(key: string, value: T): void;
-    /**
-     * Restore preserved state
-     */
-    restoreState<T>(key: string, defaultValue?: T): T | undefined;
-    /**
-     * Clear preserved state
-     */
-    clearState(key?: string): void;
-    /**
-     * Get hot reload statistics
-     */
-    getStats(): {
-        reloadCount: number;
-        lastReload: number;
-        uptime: number;
-        watchedPaths: string[];
-        preservedKeys: string[];
-    };
-    /**
-     * Stop hot reload
-     */
-    stop(): void;
-}
-/**
- * Hot reload middleware for preserving server state
- */
-export declare function createHotReloadMiddleware(hotReload: HotReloadManager): (request: Request, next: () => Promise<Response>) => Promise<Response>;
-/**
- * Hot reload utilities
- */
-export declare const HotReloadUtils: {
-    /**
-     * Check if running in hot reload mode
-     */
-    isHotReloadEnabled: () => boolean;
-    /**
-     * Get current reload count
-     */
-    getReloadCount: () => number;
-    /**
-     * Create hot-reloadable module cache
-     */
-    createModuleCache: <T>() => {
-        get: (key: string) => T | undefined;
-        set: (key: string, value: T) => void;
-        clear: () => void;
-        delete: (key: string) => boolean;
-        has: (key: string) => boolean;
-        size: () => number;
-    };
-    /**
-     * Create hot-reloadable configuration
-     */
-    createHotConfig: <T>(initialConfig: T, configPath?: string) => {
-        get: () => T;
-        reload: () => Promise<T>;
-        onChange: (callback: (config: T) => void) => void;
-    };
-};
-/**
- * Hot reload helpers for common patterns
- */
-export declare const HotReloadHelpers: {
-    /**
-     * Create hot-reloadable route handlers
-     */
-    createHotHandler: (handlerPath: string) => (request: Request) => Promise<Response>;
-    /**
-     * Create hot-reloadable middleware
-     */
-    createHotMiddleware: (middlewarePath: string) => (request: Request, next: () => Promise<Response>) => Promise<Response>;
-    /**
-     * Create development server with hot reload
-     */
-    createDevelopmentServer: (config?: {
-        port?: number;
-        hostname?: string;
-        hotReload?: HotReloadConfig;
-        onReload?: () => void;
-    }) => {
-        server: ReturnType<typeof Bun.serve>;
-        hotReload: HotReloadManager;
-        stop: () => void;
-    };
-};
-/**
- * Hot reload decorators for classes and methods
- */
-export declare const HotReloadDecorators: {
-    /**
-     * Class decorator for hot-reloadable classes
-     */
-    hotReloadable: <T extends new (...args: any[]) => any>(constructor: T) => T;
-    /**
-     * Method decorator for hot-reloadable methods
-     */
-    hotMethod: (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
-};
-/**
- * Initialize global hot reload
- */
-export declare function initializeHotReload(config?: HotReloadConfig): HotReloadManager;
-/**
- * Get global hot reload instance
- */
-export declare function getHotReload(): HotReloadManager | null;
-/**
- * Hot reload factory functions
- */
-export declare const HotReloadFactory: {
-    /**
-     * Create development hot reload
-     */
-    createDevelopment: () => HotReloadManager;
-    /**
-     * Create production hot reload (disabled)
-     */
-    createProduction: () => HotReloadManager;
-    /**
-     * Create testing hot reload
-     */
-    createTesting: () => HotReloadManager;
-};

package/dist/development/index.d.ts

@@ -1,167 +0,0 @@
-/**
- * Development Tools - Main Integration
- *
- * Unified development tools with router integration and middleware
- */
-import type { EnhancedRequest } from '../types';
-import { PerformanceProfiler, PerformanceProfilingHelpers } from './performance-profiler';
-import { RouteDebugger, RouteDebugHelpers } from './route-debugger';
-import { RouteInspectionHelpers, RouteInspector } from './route-inspector';
-import { TypeScriptHelpers, TypeScriptUtilities } from './typescript-utilities';
-export interface DevelopmentConfig {
-    debug?: {
-        enabled?: boolean;
-        logLevel?: 'debug' | 'info' | 'warn' | 'error';
-        includeHeaders?: boolean;
-        includeBody?: boolean;
-        colorOutput?: boolean;
-    };
-    profiling?: {
-        enabled?: boolean;
-        sampleRate?: number;
-        includeMemory?: boolean;
-        includeCpu?: boolean;
-    };
-    inspection?: {
-        enabled?: boolean;
-        trackStats?: boolean;
-        generateReports?: boolean;
-    };
-    typescript?: {
-        generateTypes?: boolean;
-        validateTypes?: boolean;
-        generateSchemas?: boolean;
-    };
-}
-/**
- * Development tools manager
- */
-export declare class DevelopmentTools {
-    private debugger;
-    private inspector;
-    private profiler;
-    private tsUtils;
-    private config;
-    constructor(config?: DevelopmentConfig);
-    /**
-     * Create development middleware stack
-     */
-    createMiddleware(): Array<(req: EnhancedRequest, next: () => Promise<Response>) => Promise<Response>>;
-    /**
-     * Register route with all development tools
-     */
-    registerRoute(method: string, pattern: string, handler: (...args: any[]) => any, middleware?: ((..._args: any[]) => any)[], options?: any): string;
-    /**
-     * Get route debugging information
-     */
-    debug(): {
-        listRoutes: typeof RouteInspectionHelpers.listRoutes;
-        analyzeRoutes: typeof RouteInspectionHelpers.analyzeRoutes;
-        exportRoutes: typeof RouteInspectionHelpers.exportRoutes;
-        getDebugSession: (requestId: string) => import('./route-debugger').RouteDebugInfo | undefined;
-        clearSessions: () => void;
-    };
-    /**
-     * Get route listing and analysis
-     */
-    routes(): {
-        list: (filter?: any) => import('./route-inspector').RouteMetadata[];
-        analyze: () => import('./route-inspector').RouteAnalysis;
-        export: (format?: 'json' | 'csv' | 'markdown' | 'openapi') => string;
-        groups: () => import('./route-inspector').RouteGroup[];
-        find: (method: string, path: string) => import('./route-inspector').RouteMetadata[];
-    };
-    /**
-     * Get performance profiling information
-     */
-    profile(): {
-        getMetrics: () => import('./performance-profiler').PerformanceMetrics;
-        getProfiles: (filter?: any) => import('./performance-profiler').RouteProfile[];
-        generateReport: () => string;
-        clear: () => void;
-    };
-    /**
-     * Get TypeScript utilities
-     */
-    typescript(): {
-        generateTypes: () => string;
-        generateSchemas: () => Record<string, import('./typescript-utilities').ValidationSchema>;
-        generateOpenAPI: () => any;
-        generateRouteBuilder: () => string;
-        validateRequest: (req: EnhancedRequest, routeKey: string) => {
-            valid: boolean;
-            errors: string[];
-            warnings: string[];
-        };
-    };
-    /**
-     * Generate comprehensive development report
-     */
-    generateReport(): string;
-    /**
-     * Clear all development data
-     */
-    clear(): void;
-    /**
-     * Create inspection middleware
-     */
-    private createInspectionMiddleware;
-}
-/**
- * Router extension for development tools
- */
-export declare class DevelopmentRouter {
-    private devTools;
-    private routes;
-    constructor(config?: DevelopmentConfig);
-    /**
-     * Enable debugging for next route
-     */
-    debug(): {
-        get: (pattern: string, handler: (...args: any[]) => any) => any;
-        post: (pattern: string, handler: (...args: any[]) => any) => any;
-        put: (pattern: string, handler: (...args: any[]) => any) => any;
-        patch: (pattern: string, handler: (...args: any[]) => any) => any;
-        delete: (pattern: string, handler: (...args: any[]) => any) => any;
-    };
-    /**
-     * Enable profiling for route group
-     */
-    profile(): {
-        group: (callback: () => void) => void;
-    };
-    /**
-     * Get all registered routes
-     */
-    getRoutes(): import('./route-inspector').RouteMetadata[];
-    /**
-     * Register route with development tools
-     */
-    private registerRoute;
-}
-/**
- * Development presets for common configurations
- */
-export declare const DevelopmentPresets: {
-    /**
-     * Full development mode with all features enabled
-     */
-    development: () => DevelopmentConfig;
-    /**
-     * Production debugging with minimal overhead
-     */
-    production: () => DevelopmentConfig;
-    /**
-     * Performance testing configuration
-     */
-    performance: () => DevelopmentConfig;
-    /**
-     * TypeScript development configuration
-     */
-    typescript: () => DevelopmentConfig;
-};
-export { PerformanceProfiler, PerformanceProfilingHelpers, RouteDebugger, RouteDebugHelpers, RouteInspectionHelpers, RouteInspector, TypeScriptHelpers, TypeScriptUtilities, };
-export type { ProfileConfig as ProfilerConfig, PerformanceMetrics as ProfilerMetrics, RouteProfile as ProfilerRouteProfile, } from './performance-profiler';
-export type { RouteDebugConfig, RouteDebugInfo, } from './route-debugger';
-export type { RouteAnalysis as InspectorRouteAnalysis, RouteMetadata as InspectorRouteMetadata, RouteGroup, } from './route-inspector';
-export type { TypeScriptConfig as TSConfig, RouteTypeInfo as TSRouteTypeInfo, TypeDefinition as TSTypeDefinition, ValidationSchema as TSValidationSchema, } from './typescript-utilities';