@stacksjs/bun-router 0.0.2 → 0.0.3

package/dist/middleware/security_suite.d.ts

@@ -1,46 +0,0 @@
-import type { EnhancedRequest, MiddlewareHandler, NextFunction } from '../types';
-/**
- * Factory function to create a security suite middleware
- */
-export declare function securitySuite(options?: SecuritySuiteOptions): MiddlewareHandler;
-/**
- * Preset configurations for different security levels
- */
-export declare const securityPresets: {
-  /**
-   * Basic security - minimal performance impact
-   */
-  basic: () => any;
-  /**
-   * Standard security - balanced security and performance
-   */
-  standard: () => any;
-  /**
-   * High security - maximum protection
-   */
-  high: () => any;
-  /**
-   * API security - optimized for API endpoints
-   */
-  api: () => any;
-  /**
-   * Development security - minimal restrictions for development
-   */
-  development: () => any
-};
-export declare interface SecuritySuiteOptions {
-  helmet?: boolean | object
-  security?: boolean | object
-  ddosProtection?: boolean | object
-  inputValidation?: boolean | object
-  contentSecurityPolicy?: boolean | object
-  order?: string[]
-}
-/**
- * Comprehensive security middleware suite that combines multiple security layers
- */
-export declare class SecuritySuite {
-  private middlewares: MiddlewareHandler[];
-  constructor(options?: SecuritySuiteOptions);
-  handle(req: EnhancedRequest, next: NextFunction): Promise<Response | null>;
-}

package/dist/middleware/session.d.ts

@@ -1,7 +0,0 @@
-import type { EnhancedRequest, NextFunction } from '../types';
-export declare class Session {
-  static private sessions: Map<string, any>;
-  handle(req: EnhancedRequest, next: NextFunction): Promise<Response>;
-  private parseCookies(req: Request): Record<string, string>;
-  private generateSessionId(): string;
-}

package/dist/model-binding/index.d.ts

@@ -1,17 +0,0 @@
-export {
-  bindModel,
-  createModelBindingMiddleware,
-  ModelBindingFactory,
-  type ModelBindingMiddlewareOptions,
-  ModelBindingUtils,
-  TypedModelBinding,
-  withModelBinding,
-} from './model-middleware';
-export {
-  type ModelBindingConfig,
-  ModelFactory,
-  ModelRegistry,
-  modelRegistry,
-  type ModelResolutionResult,
-  ModelUtils,
-} from './model-registry';

package/dist/model-binding/model-middleware.d.ts

@@ -1,80 +0,0 @@
-import type { EnhancedRequest,  } from '../types';
-/**
- * Create model binding middleware
- */
-export declare function createModelBindingMiddleware(bindings: ModelBindingRef[], options?: ModelBindingMiddlewareOptions): void;
-/**
- * Single model binding middleware
- */
-export declare function bindModel(modelName: string, parameterName: string, options?: {
-    required?: boolean
-    as?: string
-    failOnError?: boolean
-  }): (req: EnhancedRequest, next: () => Promise<Response>) => Promise<Response>;
-/**
- * Route parameter model binding decorator
- */
-export declare function withModelBinding<TPath extends string>(bindings: ModelBindingRef[]): void;
-/**
- * Model binding utilities for middleware
- */
-export declare const ModelBindingUtils: {
-  /**
-   * Create middleware that binds multiple models
-   */
-  multiple(bindings: Array<{ model: string, param: string, required?: boolean }>): (req: EnhancedRequest, next: () => Promise<Response>) => unknown
-};
-/**
- * Type-safe model binding helpers
- */
-export declare const TypedModelBinding: {
-  /**
-   * Create a typed model binding that preserves route parameter types
-   */
-  create<TPath extends string>(
-    bindings: Array<{
-      model: string
-      param: keyof ExtractRouteParams<TPath>
-      required?: boolean
-      as?: string
-    }>,
-  ): (req: EnhancedRequest, next: () => Promise<Response>) => unknown;
-  /**
-   * Create a single typed model binding
-   */
-  single<TPath extends string>(
-    modelName: string,
-    param: keyof ExtractRouteParams<TPath>,
-    options: {
-      required?: boolean
-      as?: string
-    } = {},
-  ): (req: EnhancedRequest, next: () => Promise<Response>) => unknown
-};
-/**
- * Model binding middleware options
- */
-export declare interface ModelBindingMiddlewareOptions {
-  failOnError?: boolean
-  attachToRequest?: boolean
-  paramMapping?: Record<string, string>
-}
-/**
- * Simplified model binding configuration for middleware
- */
-export declare interface ModelBindingRef {
-  model: string
-  parameter: string
-  required?: boolean
-  as?: string
-}
-/**
- * Model binding middleware factory
- */
-export declare class ModelBindingFactory {
-  static user(paramName?: string, as?: string): (req: EnhancedRequest, next: () => Promise<Response>) => Promise<Response>;
-  static post(paramName?: string, as?: string): (req: EnhancedRequest, next: () => Promise<Response>) => Promise<Response>;
-  static category(paramName?: string, as?: string): (req: EnhancedRequest, next: () => Promise<Response>) => Promise<Response>;
-  static ownedResource(modelName: string, paramName: string, userIdField?: string): Array<(req: EnhancedRequest, next: () => Promise<Response>) => Promise<Response>>;
-  static nested(parentModel: string, parentParam: string, childModel: string, childParam: string): (req: EnhancedRequest, next: () => Promise<Response>) => Promise<Response>;
-}

package/dist/model-binding/model-registry.d.ts

@@ -1,125 +0,0 @@
-import type { EnhancedRequest, ModelResolver, ModelTransformerFn, ModelValidatorFn,  } from '../types';
-/**
- * Global model registry instance
- */
-export declare const modelRegistry: ModelRegistry;
-/**
- * Model binding utilities
- */
-export declare const ModelUtils: {
-  /**
-   * Create a simple resolver for database models
-   */
-  dbResolver<T>(
-    tableName: string,
-    idField: string = 'id',
-    db?: any,
-  ): (ModelResolver<T> { return (params)) => unknown;
-  any>>(
-    fields: (keyof T)[],
-  ): (ModelValidatorFn<T> { return (model)) => unknown;
-  K extends keyof T>(
-    fields: K[],
-  ): (ModelTransformerFn<T> { return (model)) => unknown;
-  K extends keyof T>(
-    fields: K[],
-  ): (ModelTransformerFn<T> { return (model)) => unknown;
-  /**
-   * Create a UUID validator
-   */
-  uuidValidator<T extends { id: string }>(): () => unknown;
-  /**
-   * Create ownership validator (checks if user owns the model)
-   */
-  ownershipValidator<T extends { userId?: string | number }>(
-    userIdField: string = 'userId',
-  ): (ModelValidatorFn<T> { return (model, params, req)) => unknown
-};
-/**
- * Common model binding factories
- */
-export declare const ModelFactory: {
-  /**
-   * Create a simple model binding for database entities
-   */
-  entity<T>(
-    tableName: string,
-    options: {
-      idField?: string
-      cache?: boolean
-      cacheTtl?: number
-      validator?: ModelValidatorFn<T>
-      transformer?: ModelTransformerFn<T>
-      db?: any
-    } = {},
-  ): unknown;
-  /**
-   * Create a user model binding with ownership validation
-   */
-  user<T extends { id: string, userId?: string }>(
-    tableName: string = 'users',
-    options: {
-      cache?: boolean
-      cacheTtl?: number
-      db?: any
-    } = {},
-  ): unknown;
-  /**
-   * Create a resource model binding with ownership check
-   */
-  ownedResource<T extends { id: string, userId: string }>(
-    tableName: string,
-    options: {
-      idField?: string
-      userIdField?: string
-      cache?: boolean
-      cacheTtl?: number
-      db?: any
-    } = {},
-  ): (ModelBindingConfig<T> { const { idField?, userIdField?, cache?, cacheTtl?, db, } = options return { resolver: ModelUtils.dbResolver<T>(tableName, idField, db), validator: (model, params, req)) => unknown
-};
-/**
- * Model resolution result
- */
-export declare interface ModelResolutionResult<T = any> {
-  model: T | null
-  error?: string
-  status?: number
-}
-/**
- * Model binding configuration for a specific model
- */
-export declare interface ModelBindingConfig<T = any> {
-  resolver: ModelResolver<T>
-  validator?: ModelValidatorFn<T>
-  transformer?: ModelTransformerFn<T>
-  cache?: {
-    enabled: boolean
-    ttl: number
-    key?: (params: Record<string, string>) => string
-  }
-  errorHandling?: {
-    notFound?: (params: Record<string, string>) => Response
-    validation?: (model: T, error: string) => Response
-    transform?: (error: string) => Response
-  }
-}
-/**
- * Model registry for managing model bindings
- */
-export declare class ModelRegistry {
-  private models: any;
-  private cache: any;
-  register<T>(name: string, config: ModelBindingConfig<T>): void;
-  get(name: string): ModelBindingConfig | undefined;
-  has(name: string): boolean;
-  resolve<T>(modelName: string, params: Record<string, string>, req?: EnhancedRequest): Promise<ModelResolutionResult<T>>;
-  createErrorResponse(modelName: string, result: ModelResolutionResult, params: Record<string, string>): Response;
-  clearCache(modelName: string, params?: Record<string, string>): void;
-  clearAllCache(): void;
-  getCacheStats(): { totalEntries: number, validEntries: number, expiredEntries: number, models: number };
-  cleanupCache(): number;
-  private getCachedModel<T>(modelName: string, params: Record<string, string>, config: ModelBindingConfig): T | null;
-  private cacheModel<T>(modelName: string, params: Record<string, string>, model: T, config: ModelBindingConfig): void;
-  private generateCacheKey(modelName: string, params: Record<string, string>, config: ModelBindingConfig): string;
-}

package/dist/model-binding.d.ts

@@ -1,123 +0,0 @@
-import type { EnhancedRequest } from './types';
-/**
- * Parse route parameter to extract model name and custom key
- * Examples: {user} -> {name: 'user', key: undefined}
- *          {post:slug} -> {name: 'post', key: 'slug'}
- */
-/**
- * Parse multiple route parameters from path
- */
-export declare function parseRouteParameters(path: string): { name: string, key?: string }[];
-export declare function parseRouteParameter(param: string): { name: string, key?: string };
-/**
- * Extract model parameters from route path
- */
-export declare function extractModelParameters(path: string): { name: string, key?: string }[];
-/**
- * Resolve model from route parameter using bun-query-builder
- */
-export declare function resolveModel<T extends Model>(paramName: string, value: string | number, modelWrapper: BunQueryBuilderModel<T>, customKey?: string, _context?: Record<string, Model>): Promise<T | null>;
-/**
- * Route model binding middleware factory for bun-query-builder models
- */
-export declare function createModelBindingMiddleware(modelParameters: { name: string, key?: string }[], modelWrappers: Record<string, BunQueryBuilderModel>): (req: EnhancedRequest, next: () => Promise<Response>) => Promise<Response>;
-/**
- * Create a model wrapper from bun-query-builder model definition
- */
-export declare function createModelWrapper<T extends Model>(modelDefinition: any, queryBuilder: any): BunQueryBuilderModel<T>;
-/**
- * Apply model bindings to a route
- */
-export declare function applyModelBindings(path: string, modelWrappers: Record<string, BunQueryBuilderModel>, _options?: RouteBindingOptions): (req: EnhancedRequest, next: () => Promise<Response>) => Promise<Response>;
-/**
- * Global model binding registry instance
- */
-export declare const modelRegistry: ModelBindingRegistry;
-/**
- * Laravel-style model binding that integrates with bun-query-builder models
- */
-/**
- * Base model interface compatible with bun-query-builder
- */
-export declare interface Model {
-  id: string | number
-  getRouteKeyName?: () => string
-  resolveRouteBinding?: (value: string | number, field?: string) => Promise<this | null>
-}
-/**
- * Query builder model resolver interface for integration layer
- */
-export declare interface QueryBuilderModelResolver<TModel extends Model = Model> {
-  table: string
-  queryBuilder?: any
-  find: (id: string | number, keyName?: string) => Promise<TModel | null>
-  findOrFail: (id: string | number, keyName?: string) => Promise<TModel>
-  getRouteKeyName?: () => string
-  applyConstraints?: (query: any, context: Record<string, Model>) => any
-}
-/**
- * Model binding configuration interface
- */
-export declare interface ModelBindingConfig {
-  model: string
-  key?: string
-  constraints?: Record<string, any>
-}
-/**
- * Model class interface
- */
-export declare interface ModelClass<T extends Model = Model> {
-  new (...args: any[]): T
-  find: (id: string | number) => Promise<T | null>
-  findOrFail: (id: string | number) => Promise<T>
-}
-/**
- * Model resolver interface
- */
-export declare interface ModelResolver<T extends Model = Model> {
-  find: (id: string | number, keyName?: string) => Promise<T | null>
-  findOrFail: (id: string | number, keyName?: string) => Promise<T>
-  getRouteKeyName?: () => string
-}
-/**
- * Route binding options interface
- */
-export declare interface RouteBindingOptions {
-  model?: string
-  key?: string
-  constraints?: Record<string, any>
-  middleware?: string[]
-}
-/**
- * Wrapper for bun-query-builder models to add Laravel-style route binding
- */
-export declare class BunQueryBuilderModel<T extends Model = Model> {
-  public definition: any;
-  public queryBuilder: any;
-  constructor(definition: any, queryBuilder: any);
-  getTableName(): string;
-  find(id: string | number): Promise<T | null>;
-  findOrFail(id: string | number): Promise<T>;
-  where(field: string, value: any): Promise<T | null>;
-  getRouteKeyName(): string;
-  resolveRouteBinding(value: string | number, field?: string): Promise<T | null>;
-}
-/**
- * Model not found error
- */
-export declare class ModelNotFoundError extends Error {
-  public modelName: string;
-  public value: string | number;
-  public field?: string;
-  constructor(modelName: string, value: string | number, field?: string);
-}
-/**
- * Model binding registry for explicit bindings (Laravel Route::model and Route::bind)
- */
-export declare class ModelBindingRegistry {
-  private bindings: any;
-  model<T extends Model>(parameter: string, modelWrapper: BunQueryBuilderModel<T>): void;
-  bind(parameter: string, resolver: (value: string) => Promise<Model | null>): void;
-  getBinding(parameter: string): BunQueryBuilderModel | ((value: string) => Promise<Model | null>) | undefined;
-  hasBinding(parameter: string): boolean;
-}

package/dist/model-resolver-factory.d.ts

@@ -1,31 +0,0 @@
-import type { Model, QueryBuilderModelResolver } from './model-binding';
-/**
- * Factory function to create model resolvers with bun-query-builder integration
- */
-export declare function createModelResolver<TModel extends Model = Model>(tableName: string, options?: {
-    keyName?: string
-    applyConstraints?: (query: any, context: Record<string, Model>) => any
-  }): QueryBuilderModelResolver<TModel>;
-/**
- * Create a scoped model resolver that applies constraints based on parent models
- */
-export declare function createScopedModelResolver<TModel extends Model = Model>(tableName: string, constraintFn: (query: any, context: Record<string, Model>) => any, options?: {
-    keyName?: string
-  }): QueryBuilderModelResolver<TModel>;
-/**
- * Common constraint functions for scoped bindings
- */
-export declare const constraints: {
-  /**
-   * Ensure a model belongs to a specific parent model
-   */
-  belongsTo: (parentKey: string, foreignKey: string) => ((query: any, context: Record<string, Model>) => any;
-  /**
-   * Ensure a model belongs to the authenticated user
-   */
-  belongsToUser: (userKey?, foreignKey?) => ((query: any, context: Record<string, Model>) => any;
-  /**
-   * Apply multiple constraints
-   */
-  combine: (...constraintFns: Array<(query: any, context: Record<string, Model>) => any>) => ((query: any, context: Record<string, Model>) => any
-};

package/dist/observability/correlation.d.ts

@@ -1,131 +0,0 @@
-import type { EnhancedRequest } from '../types';
-/**
- * Initialize global correlation manager
- */
-export declare function initializeCorrelation(config?: CorrelationConfig): CorrelationManager;
-/**
- * Get global correlation manager
- */
-export declare function getCorrelationManager(): CorrelationManager | null;
-/**
- * Correlation middleware factory
- */
-export declare function createCorrelationMiddleware(config?: Partial<CorrelationConfig>): void;
-/**
- * Correlation helper functions
- */
-export declare const CorrelationHelpers: {
-  /**
-   * Get correlation ID from request
-   */
-  getId: (req: EnhancedRequest) => any;
-  /**
-   * Get correlation context from request
-   */
-  getContext: (req: EnhancedRequest) => any;
-  /**
-   * Get HTTP client from request
-   */
-  getHttpClient: (req: EnhancedRequest) => any;
-  /**
-   * Add metadata to current correlation
-   */
-  addMetadata: (req: EnhancedRequest, metadata: Record<string, any>) => any;
-  /**
-   * Create child context for service call
-   */
-  createChild: (req: EnhancedRequest, serviceName: string) => any;
-  /**
-   * Get trace for current request
-   */
-  getTrace: (req: EnhancedRequest) => any
-};
-/**
- * Correlation endpoint handlers
- */
-export declare const CorrelationEndpoints: {
-  /**
-   * Get correlation trace endpoint
-   */
-  trace: (req: EnhancedRequest) => Promise<Response>;
-  /**
-   * Get correlation statistics endpoint
-   */
-  stats: (_req: EnhancedRequest) => Promise<Response>
-};
-export declare interface CorrelationConfig {
-  headerName?: string
-  generateId?: () => string
-  propagateHeaders?: string[]
-  enableLogging?: boolean
-  logLevel?: 'debug' | 'info' | 'warn' | 'error'
-  maxIdLength?: number
-  validateId?: (id: string) => boolean
-}
-export declare interface CorrelationContext {
-  correlationId: string
-  parentId?: string
-  spanId?: string
-  traceId?: string
-  userId?: string
-  sessionId?: string
-  requestId?: string
-  metadata: Record<string, any>
-  startTime: number
-  headers: Record<string, string>
-}
-export declare interface ServiceCall {
-  serviceName: string
-  method: string
-  url: string
-  correlationId: string
-  parentId?: string
-  startTime: number
-  endTime?: number
-  duration?: number
-  status?: number
-  error?: string
-  metadata?: Record<string, any>
-}
-/**
- * Correlation ID manager
- */
-export declare class CorrelationManager {
-  private config: CorrelationConfig;
-  private contexts: any;
-  private serviceCalls: any;
-  private activeRequests: any;
-  constructor(config?: CorrelationConfig);
-  private generateUUID(): string;
-  private isValidId(id: string): boolean;
-  extractContext(req: EnhancedRequest): CorrelationContext;
-  getContext(correlationId: string): CorrelationContext | undefined;
-  updateContext(correlationId: string, updates: Partial<CorrelationContext>): void;
-  addMetadata(correlationId: string, metadata: Record<string, any>): void;
-  createChildContext(parentId: string, serviceName: string): CorrelationContext;
-  recordServiceCall(call: Omit<ServiceCall, 'startTime'>): void;
-  completeServiceCall(correlationId: string, serviceName: string, status: number, error?: string, metadata?: Record<string, any>): void;
-  getServiceCalls(correlationId: string): ServiceCall[];
-  finishContext(correlationId: string, status?: number, error?: string): void;
-  createHttpClient(correlationId: string): {
-    fetch: (url: string, options?: RequestInit) => Promise<Response>
-    get: (url: string, options?: RequestInit) => Promise<Response>
-    post: (url: string, options?: RequestInit) => Promise<Response>
-    put: (url: string, options?: RequestInit) => Promise<Response>
-    delete: (url: string, options?: RequestInit) => Promise<Response>
-  };
-  getTrace(correlationId: string): {
-    context: CorrelationContext
-    serviceCalls: ServiceCall[]
-    children: string[]
-  } | null;
-  getFullTrace(rootCorrelationId: string): any;
-  cleanup(maxAge?: any): void;
-  getStats(): {
-    activeContexts: number
-    totalContexts: number
-    totalServiceCalls: number
-    averageCallsPerContext: number
-  };
-  private log(level: string, message: string, data: any): void;
-}

package/dist/observability/health-checks.d.ts

@@ -1,129 +0,0 @@
-/**
- * Initialize global health check manager
- */
-export declare function initializeHealthChecks(config?: HealthCheckConfig): HealthCheckManager;
-/**
- * Get global health check manager
- */
-export declare function getHealthManager(): HealthCheckManager | null;
-/**
- * Health check endpoint handlers
- */
-export declare const HealthEndpoints: {
-  /**
-   * Basic health check endpoint
-   */
-  health: (_req: EnhancedRequest) => Promise<Response>;
-  /**
-   * Readiness probe endpoint
-   */
-  ready: (_req: EnhancedRequest) => Promise<Response>;
-  /**
-   * Liveness probe endpoint
-   */
-  live: (_req: EnhancedRequest) => Promise<Response>;
-  /**
-   * Startup probe endpoint
-   */
-  startup: (_req: EnhancedRequest) => Promise<Response>
-};
-/**
- * Built-in dependency check factories
- */
-export declare const DependencyChecks: {
-  /**
-   * HTTP service dependency
-   */
-  httpService: (name: string, url: string, options: Partial<DependencyConfig> = {}) => any;
-  /**
-   * Database dependency
-   */
-  database: (name: string, options: Partial<DependencyConfig> = {}) => any;
-  /**
-   * Redis dependency
-   */
-  redis: (name: string, options: Partial<DependencyConfig> = {}) => any;
-  /**
-   * File system dependency
-   */
-  fileSystem: (name: string, path: string, options: Partial<DependencyConfig> = {}) => any;
-  /**
-   * Custom dependency with function
-   */
-  custom: (name: string, checkFn: () => Promise<HealthCheckResult>, options: Partial<DependencyConfig> = {}) => any
-};
-export declare interface HealthCheckConfig {
-  timeout?: number
-  retries?: number
-  interval?: number
-  gracePeriod?: number
-  dependencies?: DependencyConfig[]
-  customChecks?: CustomHealthCheck[]
-}
-export declare interface DependencyConfig {
-  name: string
-  type: 'http' | 'database' | 'redis' | 'queue' | 'file' | 'custom'
-  url?: string
-  timeout?: number
-  retries?: number
-  critical?: boolean
-  metadata?: Record<string, any>
-  check?: () => Promise<HealthCheckResult>
-}
-export declare interface CustomHealthCheck {
-  name: string
-  check: () => Promise<HealthCheckResult>
-  critical?: boolean
-  timeout?: number
-}
-export declare interface HealthCheckResult {
-  status: 'healthy' | 'unhealthy' | 'degraded'
-  message?: string
-  duration?: number
-  metadata?: Record<string, any>
-  error?: string
-  timestamp: number
-}
-export declare interface HealthStatus {
-  status: 'healthy' | 'unhealthy' | 'degraded'
-  timestamp: number
-  uptime: number
-  version?: string
-  environment?: string
-  checks: Record<string, HealthCheckResult>
-  dependencies: Record<string, HealthCheckResult>
-  summary: {
-    total: number
-    healthy: number
-    unhealthy: number
-    degraded: number
-  }
-}
-/**
- * Health check manager
- */
-export declare class HealthCheckManager {
-  private config: HealthCheckConfig;
-  private dependencies: Map<string, DependencyConfig>;
-  private customChecks: Map<string, CustomHealthCheck>;
-  private lastResults: Map<string, HealthCheckResult>;
-  private startTime: number;
-  constructor(config?: HealthCheckConfig);
-  addDependency(config: DependencyConfig): void;
-  addCustomCheck(check: CustomHealthCheck): void;
-  removeDependency(name: string): boolean;
-  removeCustomCheck(name: string): boolean;
-  checkHealth(): Promise<HealthStatus>;
-  private checkDependency(config: DependencyConfig): Promise<HealthCheckResult>;
-  private checkHttpDependency(config: DependencyConfig): Promise<HealthCheckResult>;
-  private checkDatabaseDependency(config: DependencyConfig): Promise<HealthCheckResult>;
-  private checkRedisDependency(config: DependencyConfig): Promise<HealthCheckResult>;
-  private checkQueueDependency(config: DependencyConfig): Promise<HealthCheckResult>;
-  private checkFileDependency(config: DependencyConfig): Promise<HealthCheckResult>;
-  private runCustomCheck(config: CustomHealthCheck): Promise<HealthCheckResult>;
-  private executeWithTimeout<T>(promise: Promise<T>, timeout: number): Promise<T>;
-  private isCriticalCheck(result: HealthCheckResult): boolean;
-  getLastResults(): Map<string, HealthCheckResult>;
-  getUptime(): number;
-  resetStartTime(): void;
-}