@stacksjs/bun-router 0.0.5 → 0.0.6

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

@@ -0,0 +1,285 @@
+/**
+ * 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

@@ -0,0 +1,187 @@
+/**
+ * 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

@@ -0,0 +1,167 @@
+/**
+ * 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';