@stacksjs/bun-router 0.0.2

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

@@ -0,0 +1,221 @@
+import type { BindingBuilder, Container, ResolutionContext } from './container';
+// Service provider interfaces
+export declare interface ServiceProvider {
+  register: (container: Container) => void | Promise<void>
+  boot?: (container: Container) => void | Promise<void>
+  shutdown?: (container: Container) => void | Promise<void>
+  name: string
+  version?: string
+  dependencies?: readonly string[]
+  environment?: string[]
+  priority?: number
+}
+export declare interface DeferredServiceProvider extends ServiceProvider {
+  provides: () => (string | symbol | Function)[]
+  isDeferred: () => boolean
+}
+export declare interface ConditionalServiceProvider extends ServiceProvider {
+  shouldLoad: (container: Container) => boolean | Promise<boolean>
+}
+// Service provider manager
+export declare 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>;
+  protected singleton<T>(container: Container, token: string | symbol | Function, implementation: new (...args: any[]) => T): void;
+  protected transient<T>(container: Container, token: string | symbol | Function, implementation: new (...args: any[]) => T): void;
+  protected value<T>(container: Container, token: string | symbol | Function, value: T): void;
+  protected factory<T>(container: Container, token: string | symbol | Function, factory: (...args: any[]) => T): void;
+  protected when(container: Container, condition: (context: ResolutionContext) => boolean): { bind: <T>(token: string | symbol | Function) => BindingBuilder<T> };
+  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: any;
+  private deferredProviders: any;
+  private loadedProviders: any;
+  private bootedProviders: any;
+  private container: Container;
+  constructor(container: Container);
+  register(provider: ServiceProvider): this;
+  boot(): Promise<void>;
+  shutdown(): Promise<void>;
+  getProvider(name: string): ServiceProvider | undefined;
+  getProviders(): ServiceProvider[];
+  loadDeferredProvider(token: string | symbol | Function): Promise<void>;
+  private doRegister(provider: ServiceProvider): void;
+  private loadProvider(provider: ServiceProvider): Promise<void>;
+  private bootProvider(provider: ServiceProvider): Promise<void>;
+  private validateDependencies(providers: ServiceProvider[]): void;
+  private isDeferredProvider(provider: ServiceProvider): provider is DeferredServiceProvider;
+  private isConditionalProvider(provider: ServiceProvider): provider is ConditionalServiceProvider;
+}
+/**
+ * Common service providers
+ */
+/**
+ * Configuration service provider
+ */
+export declare class ConfigServiceProvider extends BaseServiceProvider {
+  readonly name: any;
+  readonly priority: any;
+  register(container: Container): void;
+}
+/**
+ * Logging service provider
+ */
+export declare class LoggingServiceProvider extends BaseServiceProvider {
+  readonly name: any;
+  readonly priority: any;
+  register(container: Container): void;
+}
+/**
+ * Database service provider
+ */
+export declare class DatabaseServiceProvider extends BaseServiceProvider {
+  readonly name: any;
+  readonly dependencies: any;
+  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: any;
+  readonly dependencies: any;
+  register(container: Container): void;
+}
+/**
+ * Authentication service provider
+ */
+export declare class AuthServiceProvider extends BaseServiceProvider {
+  readonly name: any;
+  readonly dependencies: any;
+  register(container: Container): void;
+}
+/**
+ * Validation service provider
+ */
+export declare class ValidationServiceProvider extends BaseServiceProvider {
+  readonly name: any;
+  register(container: Container): void;
+}
+/**
+ * Event service provider (deferred)
+ */
+export declare class EventServiceProvider extends BaseDeferredServiceProvider {
+  readonly name: any;
+  provides(): (string | symbol | Function)[];
+  register(container: Container): void;
+}
+// Mock service classes for demonstration
+declare class ConfigService {
+  get(key: string, defaultValue?: any): any;
+}
+declare class Logger {
+  private config: any;
+  constructor(config: any);
+  log(message: string): void;
+}
+declare class ConsoleLogger extends Logger {
+  constructor();
+}
+declare class FileLogger extends Logger {
+  private filePath: string;
+  constructor(filePath: string);
+}
+declare class DatabaseConnection {
+  connect(): Promise<void>;
+  disconnect(): Promise<void>;
+}
+declare class UserRepository {
+  private db: DatabaseConnection;
+  constructor(db: DatabaseConnection);
+}
+declare class PostRepository {
+  private db: DatabaseConnection;
+  constructor(db: DatabaseConnection);
+}
+declare class CacheManager {
+  private store: any;
+  constructor(store: any);
+}
+declare class MemoryCache {
+  private cache: any;
+}
+declare class RedisCache {
+  private config: any;
+  constructor(config: any);
+}
+declare class AuthService {
+  private jwt: JwtService;
+  private userRepo: UserRepository;
+  constructor(jwt: JwtService, userRepo: UserRepository);
+}
+declare class JwtService {
+  private config: ConfigService;
+  constructor(config: ConfigService);
+}
+declare class AuthGuard {
+  private auth: AuthService;
+  constructor(auth: AuthService);
+}
+declare class Validator {
+  validate(_data: any, _rules: any): boolean;
+}
+declare class ValidationPipe {
+  private validator: Validator;
+  constructor(validator: Validator);
+}
+declare class EventBus {
+  emit(_event: string, _data: any): void;
+}
+declare class EventDispatcher {
+  private bus: EventBus;
+  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,129 @@
+/**
+ * Hot reload middleware for preserving server state
+ */
+export declare function createHotReloadMiddleware(hotReload: HotReloadManager): 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 utilities
+ */
+export declare const HotReloadUtils: {
+  /**
+   * Check if running in hot reload mode
+   */
+  isHotReloadEnabled: () => any;
+  /**
+   * Get current reload count
+   */
+  getReloadCount: () => any;
+  /**
+   * Create hot-reloadable module cache
+   */
+  createModuleCache: <T>() => unknown;
+  /**
+   * Create hot-reloadable configuration
+   */
+  createHotConfig: <T>(initialConfig: T, configPath?: string) => { get: ()
+};
+/**
+ * Hot reload helpers for common patterns
+ */
+export declare const HotReloadHelpers: {
+  /**
+   * Create hot-reloadable route handlers
+   */
+  createHotHandler: (handlerPath: string) => unknown;
+  /**
+   * Create hot-reloadable middleware
+   */
+  createHotMiddleware: (middlewarePath: string) => unknown;
+  /**
+   * Create development server with hot reload
+   */
+  createDevelopmentServer: (config: { port?: number hostname?: string hotReload?: HotReloadConfig onReload?: () => void } = {}) => unknown
+};
+/**
+ * Hot reload decorators for classes and methods
+ */
+export declare const HotReloadDecorators: {
+  /**
+   * Class decorator for hot-reloadable classes
+   */
+  hotReloadable: () => unknown;
+  /**
+   * Method decorator for hot-reloadable methods
+   */
+  hotMethod: (target: any, propertyKey: string, descriptor: PropertyDescriptor) => any
+};
+/**
+ * Hot reload factory functions
+ */
+export declare const HotReloadFactory: {
+  /**
+   * Create development hot reload
+   */
+  createDevelopment: () => any;
+  /**
+   * Create production hot reload (disabled)
+   */
+  createProduction: () => any;
+  /**
+   * Create testing hot reload
+   */
+  createTesting: () => any
+};
+export declare 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 declare interface HotReloadState {
+  reloadCount: number
+  lastReload: number
+  changedFiles: string[]
+  preservedState: Record<string, any>
+  watchers: Map<string, any>
+}
+/**
+ * Hot reload manager for development
+ */
+export declare class HotReloadManager {
+  private config: Required<HotReloadConfig>;
+  private state: HotReloadState;
+  private debounceTimer?: Timer;
+  private isReloading: any;
+  constructor(config?: HotReloadConfig);
+  private initializeState(): void;
+  private setupWatchers(): void;
+  private handleFileChange(eventType: string, filePath: string): void;
+  private shouldIgnoreFile(filePath: string): boolean;
+  private shouldWatchFile(filePath: string): boolean;
+  private triggerReload(): void;
+  preserveState<T>(key: string, value: T): void;
+  restoreState<T>(key: string, defaultValue?: T): T | undefined;
+  clearState(key?: string): void;
+  getStats(): {
+    reloadCount: number
+    lastReload: number
+    uptime: number
+    watchedPaths: string[]
+    preservedKeys: string[]
+  };
+  stop(): void;
+}
+declare namespace global {
+  var __HOT_RELOAD_STATE__: HotReloadState | undefined;
+  var __HOT_RELOAD_PRESERVE__: Record<string, any>;
+}

package/dist/development/index.d.ts

@@ -0,0 +1,144 @@
+import { PerformanceProfiler, PerformanceProfilingHelpers } from './performance-profiler';
+import { RouteDebugger, RouteDebugHelpers } from './route-debugger';
+import { RouteInspectionHelpers, RouteInspector } from './route-inspector';
+import { TypeScriptHelpers, TypeScriptUtilities } from './typescript-utilities';
+import type { EnhancedRequest } from '../types';
+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';
+/**
+ * Development presets for common configurations
+ */
+export declare const DevelopmentPresets: {
+  /**
+   * Full development mode with all features enabled
+   */
+  development: () => any;
+  /**
+   * Production debugging with minimal overhead
+   */
+  production: () => any;
+  /**
+   * Performance testing configuration
+   */
+  performance: () => any;
+  /**
+   * TypeScript development configuration
+   */
+  typescript: () => any
+};
+export declare 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: RouteDebugger;
+  private inspector: RouteInspector;
+  private profiler: PerformanceProfiler;
+  private tsUtils: TypeScriptUtilities;
+  private config: DevelopmentConfig;
+  constructor(config?: DevelopmentConfig);
+  createMiddleware(): Array<(req: EnhancedRequest, next: () => Promise<Response>) => Promise<Response>>;
+  registerRoute(method: string, pattern: string, handler: (...args: any[]) => any, middleware?: ((...args: any[]) => any)[], options?: any): string;
+  debug(): {
+    listRoutes: typeof RouteInspectionHelpers.listRoutes
+    analyzeRoutes: typeof RouteInspectionHelpers.analyzeRoutes
+    exportRoutes: typeof RouteInspectionHelpers.exportRoutes
+    getDebugSession: (requestId: string) => import('./route-debugger').RouteDebugInfo | undefined
+    clearSessions: () => void
+  };
+  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[]
+  };
+  profile(): {
+    getMetrics: () => import('./performance-profiler').PerformanceMetrics
+    getProfiles: (filter?: any) => import('./performance-profiler').RouteProfile[]
+    generateReport: () => string
+    clear: () => void
+  };
+  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[] }
+  };
+  generateReport(): string;
+  clear(): void;
+  private createInspectionMiddleware(): void;
+}
+/**
+ * Router extension for development tools
+ */
+export declare class DevelopmentRouter {
+  private devTools: DevelopmentTools;
+  private routes: any;
+  constructor(config?: DevelopmentConfig);
+  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
+  };
+  profile(): {
+    group: (callback: () => void) => void
+  };
+  getRoutes(): import('./route-inspector').RouteMetadata[];
+  private registerRoute(method: string, pattern: string, handler: (...args: any[]) => any, options?: any): void;
+}
+export {
+  PerformanceProfiler,
+  PerformanceProfilingHelpers,
+  RouteDebugger,
+  RouteDebugHelpers,
+  RouteInspectionHelpers,
+  RouteInspector,
+  TypeScriptHelpers,
+  TypeScriptUtilities,
+};

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

@@ -0,0 +1,152 @@
+import type { EnhancedRequest } from '../types';
+/**
+ * Initialize global performance profiler
+ */
+export declare function initializePerformanceProfiler(config?: ProfileConfig): PerformanceProfiler;
+/**
+ * Get global performance profiler
+ */
+export declare function getPerformanceProfiler(): PerformanceProfiler | null;
+/**
+ * Performance profiling middleware factory
+ */
+export declare function createPerformanceProfilingMiddleware(config?: ProfileConfig): void;
+/**
+ * Performance profiling helpers
+ */
+export declare const PerformanceProfilingHelpers: {
+  /**
+   * Record timing from request context
+   */
+  startTiming: (req: EnhancedRequest, phase: keyof RouteProfile['phases'], name: string) => any;
+  /**
+   * End timing from request context
+   */
+  endTiming: (req: EnhancedRequest, phase: keyof RouteProfile['phases'], timingId: string) => any;
+  /**
+   * Record database query from request context
+   */
+  recordQuery: (req: EnhancedRequest, query: string, duration: number) => any;
+  /**
+   * Record profile point from request context
+   */
+  recordPoint: (req: EnhancedRequest, phase: keyof RouteProfile['phases'], name: string, metadata?: Record<string, any>) => any
+};
+export declare interface ProfileConfig {
+  enabled?: boolean
+  sampleRate?: number
+  includeMemory?: boolean
+  includeCpu?: boolean
+  includeGc?: boolean
+  trackSlowQueries?: boolean
+  slowQueryThreshold?: number
+  maxProfiles?: number
+  outputFormat?: 'console' | 'json' | 'flamegraph'
+}
+export declare interface ProfilePoint {
+  name: string
+  timestamp: number
+  duration?: number
+  memory?: NodeJS.MemoryUsage
+  cpu?: NodeJS.CpuUsage
+  metadata?: Record<string, any>
+}
+export declare interface RouteProfile {
+  id: string
+  requestId: string
+  method: string
+  path: string
+  pattern: string
+  startTime: number
+  endTime?: number
+  totalDuration?: number
+  phases: {
+    routeMatching: ProfilePoint[]
+    middlewareExecution: ProfilePoint[]
+    handlerExecution: ProfilePoint[]
+    responseGeneration: ProfilePoint[]
+  }
+  memory: {
+    initial: NodeJS.MemoryUsage
+    peak: NodeJS.MemoryUsage
+    final?: NodeJS.MemoryUsage
+    allocations: number
+  }
+  cpu: {
+    initial: NodeJS.CpuUsage
+    final?: NodeJS.CpuUsage
+    userTime: number
+    systemTime: number
+  }
+  gc?: {
+    collections: number
+    duration: number
+    reclaimedMemory: number
+  }
+  queries?: Array<{
+    query: string
+    duration: number
+    timestamp: number
+  }>
+  warnings: string[]
+  recommendations: string[]
+}
+export declare interface PerformanceMetrics {
+  averageResponseTime: number
+  p50ResponseTime: number
+  p95ResponseTime: number
+  p99ResponseTime: number
+  requestsPerSecond: number
+  memoryUsageAverage: number
+  memoryUsagePeak: number
+  cpuUsageAverage: number
+  gcPressure: number
+  slowestRoutes: Array<{
+    pattern: string
+    averageTime: number
+    count: number
+  }>
+  memoryLeaks: Array<{
+    route: string
+    memoryGrowth: number
+    requests: number
+  }>
+}
+/**
+ * Performance profiler for route analysis
+ */
+export declare class PerformanceProfiler {
+  private config: ProfileConfig;
+  private profiles: any;
+  private activeProfiles: any;
+  private metrics: PerformanceMetrics;
+  private gcObserver?: PerformanceObserver;
+  private memoryBaseline: NodeJS.MemoryUsage;
+  constructor(config?: ProfileConfig);
+  startProfiling(req: EnhancedRequest, pattern: string): string | null;
+  recordPoint(profileId: string, phase: keyof RouteProfile['phases'], name: string, metadata?: Record<string, any>): void;
+  startTiming(profileId: string, phase: keyof RouteProfile['phases'], name: string): string;
+  endTiming(profileId: string, phase: keyof RouteProfile['phases'], timingId: string): void;
+  recordQuery(profileId: string, query: string, duration: number): void;
+  finishProfiling(profileId: string, _response?: Response): RouteProfile | null;
+  getProfile(profileId: string): RouteProfile | undefined;
+  getProfiles(filter?: {
+    method?: string
+    pattern?: string
+    minDuration?: number
+    maxDuration?: number
+    hasWarnings?: boolean
+  }): RouteProfile[];
+  getMetrics(): PerformanceMetrics;
+  generateReport(): string;
+  clear(): void;
+  private shouldProfile(): boolean;
+  private generateProfileId(): string;
+  private extractRequestId(req: EnhancedRequest): string;
+  private initializeMetrics(): PerformanceMetrics;
+  private setupGcObserver(): void;
+  private generateRecommendations(profile: RouteProfile): void;
+  private updateMetrics(_profile: RouteProfile): void;
+  private cleanupProfiles(): void;
+  private logProfile(profile: RouteProfile): void;
+}