@stacksjs/bun-router 0.0.2

package/dist/middleware/auth.d.ts

@@ -0,0 +1,34 @@
+import type { EnhancedRequest, Middleware, NextFunction } from '../types';
+/**
+ * Extracts and decodes Basic Auth credentials from Authorization header
+ */
+export declare function extractBasicAuth(authHeader: string): { username: string, password: string } | null;
+/**
+ * Extracts Bearer token from Authorization header
+ */
+export declare function extractBearerToken(authHeader: string): string | null;
+/**
+ * Extracts API key from various sources
+ */
+export declare function extractApiKey(req: EnhancedRequest, source?: 'header' | 'query' | 'cookie', key?: string): string | null;
+// Convenience factory functions for common auth types
+export declare function basicAuth(validator: (credentials: { username: string, password: string }, req: EnhancedRequest) => Promise<boolean> | boolean, options?: Partial<AuthOptions>): AuthMiddleware;
+export declare function bearerAuth(validator: (token: string, req: EnhancedRequest) => Promise<boolean> | boolean, options?: Partial<AuthOptions>): AuthMiddleware;
+export declare function jwtAuth(validator: (token: string, req: EnhancedRequest) => Promise<boolean> | boolean, options?: Partial<AuthOptions>): AuthMiddleware;
+export declare function apiKeyAuth(validator: (apiKey: string, req: EnhancedRequest) => Promise<boolean> | boolean, options?: Partial<AuthOptions>): AuthMiddleware;
+export declare function oauth2Auth(validator: (token: string, req: EnhancedRequest) => Promise<boolean> | boolean, options?: Partial<AuthOptions>): AuthMiddleware;
+export declare interface AuthOptions {
+  type: 'basic' | 'bearer' | 'api-key' | 'oauth2' | 'jwt' | 'custom'
+  validator: (credentials: any, req: EnhancedRequest) => Promise<boolean> | boolean
+  userExtractor?: (credentials: any, req: EnhancedRequest) => Promise<any> | any
+  source?: 'header' | 'query' | 'cookie'
+  key?: string
+  realm?: string
+  credentialsExtractor?: (req: EnhancedRequest) => Promise<any> | any
+  attachUser?: boolean
+}
+export declare class AuthMiddleware implements Middleware {
+  private options: AuthOptions;
+  constructor(options: AuthOptions);
+  handle(req: EnhancedRequest, next: NextFunction): Promise<Response>;
+}

package/dist/middleware/content_security_policy.d.ts

@@ -0,0 +1,54 @@
+import type { EnhancedRequest, NextFunction } from '../types';
+// Factory function for easy use
+export declare function contentSecurityPolicy(options?: CSPOptions): (req: EnhancedRequest, next: NextFunction) => Promise<Response>;
+export declare interface CSPDirectives {
+  'default-src'?: string[]
+  'script-src'?: string[]
+  'script-src-elem'?: string[]
+  'script-src-attr'?: string[]
+  'style-src'?: string[]
+  'style-src-elem'?: string[]
+  'style-src-attr'?: string[]
+  'img-src'?: string[]
+  'font-src'?: string[]
+  'connect-src'?: string[]
+  'media-src'?: string[]
+  'object-src'?: string[]
+  'child-src'?: string[]
+  'frame-src'?: string[]
+  'worker-src'?: string[]
+  'frame-ancestors'?: string[]
+  'form-action'?: string[]
+  'base-uri'?: string[]
+  'manifest-src'?: string[]
+  'prefetch-src'?: string[]
+  'navigate-to'?: string[]
+  'report-uri'?: string[]
+  'report-to'?: string[]
+  'require-trusted-types-for'?: string[]
+  'trusted-types'?: string[]
+  'upgrade-insecure-requests'?: boolean
+  'block-all-mixed-content'?: boolean
+  'plugin-types'?: string[]
+  'sandbox'?: string[]
+  'disown-opener'?: boolean
+}
+export declare interface CSPOptions {
+  directives?: CSPDirectives
+  reportOnly?: boolean
+  reportUri?: string
+  reportTo?: string
+  useNonces?: boolean
+  nonceLength?: number
+  upgradeInsecureRequests?: boolean
+  blockAllMixedContent?: boolean
+}
+export declare class ContentSecurityPolicy {
+  private options: CSPOptions;
+  private nonces: Map<string, string>;
+  constructor(options?: CSPOptions);
+  private generateNonce(): string;
+  private buildCSPHeader(): string;
+  handle(req: EnhancedRequest, next: NextFunction): Promise<Response>;
+  getNonce(url: string): string | undefined;
+}

package/dist/middleware/cors.d.ts

@@ -0,0 +1,5 @@
+import type { EnhancedRequest, NextFunction } from '../types';
+export declare class Cors {
+  private getCorsHeaders(): Record<string, string>;
+  handle(req: EnhancedRequest, next: NextFunction): Promise<Response>;
+}

package/dist/middleware/csrf.d.ts

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

package/dist/middleware/ddos_protection.d.ts

@@ -0,0 +1,47 @@
+import type { EnhancedRequest, NextFunction } from '../types';
+// Factory function for easy use
+export declare function ddosProtection(options?: DDoSProtectionOptions): (req: EnhancedRequest, next: NextFunction) => Promise<Response>;
+export declare interface DDoSProtectionOptions {
+  enabled?: boolean
+  maxRequestsPerSecond?: number
+  maxRequestsPerMinute?: number
+  maxRequestsPerHour?: number
+  burstLimit?: number
+  windowSize?: number
+  blockDuration?: number
+  whitelistedIPs?: string[]
+  blacklistedIPs?: string[]
+  trustProxy?: boolean
+  skipSuccessfulRequests?: boolean
+  skipFailedRequests?: boolean
+  keyGenerator?: (req: EnhancedRequest) => string
+  onLimitReached?: (req: EnhancedRequest, rateLimitInfo: any) => Response | Promise<Response>
+  store?: 'memory' | 'redis'
+  redis?: {
+    url: string
+    prefix?: string
+  }
+}
+declare interface RequestInfo {
+  count: number
+  firstRequest: number
+  lastRequest: number
+  blocked: boolean
+  blockExpires?: number
+}
+export declare class DDoSProtection {
+  private options: DDoSProtectionOptions;
+  private requestStore: Map<string, RequestInfo>;
+  private cleanupInterval: Timer | null;
+  constructor(options?: DDoSProtectionOptions);
+  private defaultKeyGenerator(req: EnhancedRequest): string;
+  private startCleanupInterval(): void;
+  private isWhitelisted(ip: string): boolean;
+  private isBlacklisted(ip: string): boolean;
+  private getRateLimitInfo(key: string, now: number): RequestInfo;
+  private shouldBlock(info: RequestInfo, now: number): boolean;
+  private blockIP(info: RequestInfo, now: number): void;
+  private createBlockedResponse(req: EnhancedRequest, info: RequestInfo): Response;
+  handle(req: EnhancedRequest, next: NextFunction): Promise<Response>;
+  destroy(): void;
+}

package/dist/middleware/file_security.d.ts

@@ -0,0 +1,23 @@
+import type { UploadedFile } from './file_upload';
+export declare function createFileSecurity(config?: FileSecurityConfig): FileSecurity;
+export declare interface FileSecurityConfig {
+  scanForMalware?: boolean
+  checkMagicNumbers?: boolean
+  sanitizeFilenames?: boolean
+  preventExecutableUploads?: boolean
+  maxFilenameLength?: number
+}
+export declare class FileSecurity {
+  private config: Required<FileSecurityConfig>;
+  readonly private FILE_SIGNATURES: Record<string, Uint8Array[]>;
+  readonly private EXECUTABLE_EXTENSIONS: any;
+  constructor(config?: FileSecurityConfig);
+  validateFile(file: UploadedFile): { isValid: boolean, errors: string[] };
+  private validateFileSignature(file: UploadedFile): boolean;
+  private sanitizeFilename(filename: string): string;
+  private getFileExtension(filename: string): string;
+  private basicMalwareScan(file: UploadedFile): boolean;
+  getSafeFilename(originalName: string): string;
+  isAllowedFileType(mimetype: string, allowedTypes: string[]): boolean;
+  isWithinSizeLimit(fileSize: number, maxSize: number): boolean;
+}

package/dist/middleware/file_upload.d.ts

@@ -0,0 +1,41 @@
+import FileSecurity from './file_security';
+import type { EnhancedRequest, NextFunction } from '../types';
+import type { FileSecurityConfig } from './file_security';
+// Factory function for easier usage
+export declare function fileUpload(config?: FileUploadConfig): FileUpload;
+// Specialized factory functions
+export declare function singleFileUpload(fieldName: string, config?: FileUploadConfig): FileUpload;
+export declare function multipleFileUpload(maxFiles?: number, config?: FileUploadConfig): FileUpload;
+export declare function imageUpload(config?: FileUploadConfig): FileUpload;
+export declare function documentUpload(config?: FileUploadConfig): FileUpload;
+export declare interface UploadedFile {
+  fieldName: string
+  originalName: string
+  filename: string
+  path: string
+  size: number
+  mimetype: string
+  buffer: ArrayBuffer
+}
+export declare interface FileUploadConfig extends FileSecurityConfig {
+  destination?: string
+  maxFileSize?: number
+  maxFiles?: number
+  allowedMimeTypes?: string[]
+  allowedExtensions?: string[]
+  preserveOriginalName?: boolean
+  generateUniqueFilename?: boolean
+  createDestination?: boolean
+}
+export declare interface FileUploadOptions extends FileUploadConfig {
+  fieldName?: string | string[]
+}
+export declare class FileUpload {
+  private config: Required<FileUploadConfig>;
+  private fileSecurity: FileSecurity;
+  constructor(config?: FileUploadConfig);
+  handle(req: EnhancedRequest, next: NextFunction): Promise<Response>;
+  private generateFilename(originalName: string): string;
+  private formatBytes(bytes: number): string;
+  private createErrorResponse(message: string, status: number): Response;
+}

package/dist/middleware/helmet.d.ts

@@ -0,0 +1,54 @@
+import type { EnhancedRequest, NextFunction } from '../types';
+export declare interface HelmetOptions {
+  contentSecurityPolicy?: boolean | {
+    directives?: Record<string, string[]>
+    reportOnly?: boolean
+    reportUri?: string
+    upgradeInsecureRequests?: boolean
+    blockAllMixedContent?: boolean
+  }
+  crossOriginEmbedderPolicy?: boolean | {
+    policy?: 'require-corp' | 'credentialless'
+  }
+  crossOriginOpenerPolicy?: boolean | {
+    policy?: 'same-origin' | 'same-origin-allow-popups' | 'unsafe-none'
+  }
+  crossOriginResourcePolicy?: boolean | {
+    policy?: 'same-site' | 'same-origin' | 'cross-origin'
+  }
+  dnsPrefetchControl?: boolean | {
+    allow?: boolean
+  }
+  expectCt?: boolean | {
+    enforce?: boolean
+    maxAge?: number
+    reportUri?: string
+  }
+  frameguard?: boolean | {
+    action?: 'deny' | 'sameorigin'
+    domain?: string
+  }
+  hidePoweredBy?: boolean
+  hsts?: boolean | {
+    maxAge?: number
+    includeSubDomains?: boolean
+    preload?: boolean
+  }
+  ieNoOpen?: boolean
+  noSniff?: boolean
+  originAgentCluster?: boolean
+  permittedCrossDomainPolicies?: boolean | {
+    permittedPolicies?: 'none' | 'master-only' | 'by-content-type' | 'all'
+  }
+  referrerPolicy?: boolean | {
+    policy?: string | string[]
+  }
+  xssFilter?: boolean | {
+    setOnOldIE?: boolean
+  }
+}
+export declare class Helmet {
+  private options: HelmetOptions;
+  constructor(options?: HelmetOptions);
+  handle(req: EnhancedRequest, next: NextFunction): Promise<Response>;
+}

package/dist/middleware/index.d.ts

@@ -0,0 +1,55 @@
+import Auth, { apiKeyAuth, basicAuth, bearerAuth, extractApiKey, extractBasicAuth, extractBearerToken, jwtAuth, oauth2Auth,  } from './auth';
+import Cors from './cors';
+import Csrf from './csrf';
+import JsonBody from './json_body';
+import RequestId from './request_id';
+import RequestSigning from './request_signing';
+import Session from './session';
+export type { NonceStore, RequestSigningOptions, SignatureAlgorithm, SignedPart } from './request_signing';
+export declare function auth(): Auth;
+// Factory functions for easier middleware creation
+export declare const cors: () => Cors;
+export declare const jsonBody: () => JsonBody;
+export declare const requestId: () => RequestId;
+export declare const session: () => Session;
+export declare const csrf: () => Csrf;
+export declare const middleware: Proxy;
+export { default as Auth } from './auth';
+export { default as ContentSecurityPolicy } from './content_security_policy';
+export { contentSecurityPolicy } from './content_security_policy';
+export { default as Cors } from './cors';
+export { default as Csrf } from './csrf';
+export { default as DDoSProtection } from './ddos_protection';
+export { ddosProtection } from './ddos_protection';
+export { default as FileSecurity } from './file_security';
+export { default as FileUpload } from './file_upload';
+export { documentUpload, fileUpload, imageUpload, multipleFileUpload, singleFileUpload } from './file_upload';
+export { default as Helmet } from './helmet';
+export { default as InputValidation } from './input_validation';
+export { inputValidation } from './input_validation';
+export { default as JsonBody } from './json_body';
+export { default as PerformanceAlerting, performanceAlerting } from './performance_alerting';
+export { default as PerformanceDashboard, performanceDashboard } from './performance_dashboard';
+export { default as PerformanceMonitor, performanceMonitor } from './performance_monitor';
+export { default as RateLimit } from './rate_limit';
+export { rateLimit } from './rate_limit';
+export { default as RequestId } from './request_id';
+export { InMemoryNonceStore, default as RequestSigning, requestSigning, signRequest, verifySignature } from './request_signing';
+export { SignatureError } from './request_signing';
+export { default as RequestTracer, requestTracer } from './request_tracer';
+export { default as Security } from './security';
+export { security } from './security';
+export { default as SecuritySuite } from './security_suite';
+export { securitySuite } from './security_suite';
+export { default as Session } from './session';
+export {
+  apiKeyAuth,
+  basicAuth,
+  bearerAuth,
+  extractApiKey,
+  extractBasicAuth,
+  extractBearerToken,
+  jwtAuth,
+  oauth2Auth,
+};
+export default middleware;

package/dist/middleware/input_validation.d.ts

@@ -0,0 +1,46 @@
+import type { EnhancedRequest, NextFunction } from '../types';
+// Factory function for easy use
+export declare function inputValidation(options?: InputValidationOptions): (req: EnhancedRequest, next: NextFunction) => Promise<Response>;
+export declare interface ValidationRule {
+  type: 'string' | 'number' | 'boolean' | 'email' | 'url' | 'uuid' | 'date' | 'regex' | 'custom'
+  required?: boolean
+  min?: number
+  max?: number
+  pattern?: RegExp
+  enum?: unknown[]
+  custom?: (value: unknown) => boolean | string
+  sanitize?: boolean
+  transform?: (value: unknown) => unknown
+}
+export declare interface ValidationSchema {
+
+}
+export declare interface InputValidationOptions {
+  enabled?: boolean
+  schemas?: {
+    query?: ValidationSchema
+    body?: ValidationSchema
+    headers?: ValidationSchema
+    params?: ValidationSchema
+  }
+  sanitizeByDefault?: boolean
+  strictMode?: boolean
+  allowUnknownFields?: boolean
+  maxDepth?: number
+  onValidationError?: (errors: ValidationError[]) => Response
+}
+export declare interface ValidationError {
+  field: string
+  message: string
+  value: any
+  rule: string
+}
+export declare class InputValidation {
+  private options: InputValidationOptions;
+  constructor(options?: InputValidationOptions);
+  private validateValue(value: any, rule: ValidationRule, fieldPath: string): ValidationError[];
+  private sanitizeValue(value: any, rule: ValidationRule): any;
+  private validateObject(obj: any, schema: ValidationSchema, basePath?: any, depth?: any): ValidationError[];
+  private parseRequestBody(req: EnhancedRequest): Promise<any>;
+  handle(req: EnhancedRequest, next: NextFunction): Promise<Response>;
+}

package/dist/middleware/json_body.d.ts

@@ -0,0 +1,4 @@
+import type { EnhancedRequest, NextFunction } from '../types';
+export declare class JsonBody {
+  handle(req: EnhancedRequest, next: NextFunction): Promise<Response>;
+}

package/dist/middleware/performance_alerting.d.ts

@@ -0,0 +1,88 @@
+import type { EnhancedRequest, NextFunction } from '../types';
+import type { PerformanceMetrics } from './performance_monitor';
+// Factory function for easy use
+export declare function performanceAlerting(options?: AlertingOptions): PerformanceAlerting;
+export declare interface AlertRule {
+  id: string
+  name: string
+  description?: string
+  enabled: boolean
+  metric: 'responseTime' | 'errorRate' | 'memoryUsage' | 'cpuUsage' | 'requestRate' | 'custom'
+  condition: 'gt' | 'lt' | 'eq' | 'gte' | 'lte'
+  threshold: number
+  duration?: number
+  severity: 'info' | 'warning' | 'critical'
+  cooldown?: number
+  customEvaluator?: (metrics: PerformanceMetrics[]) => boolean
+}
+export declare interface AlertNotification {
+  id: string
+  ruleId: string
+  ruleName: string
+  severity: 'info' | 'warning' | 'critical'
+  message: string
+  timestamp: number
+  resolved: boolean
+  resolvedAt?: number
+  metadata: Record<string, any>
+}
+export declare interface AlertChannel {
+  type: 'webhook' | 'slack' | 'email' | 'console' | 'custom'
+  enabled: boolean
+  config: {
+    url?: string
+    token?: string
+    channel?: string
+    email?: string
+    customHandler?: (notification: AlertNotification) => Promise<void>
+  }
+  filters?: {
+    severities?: Array<'info' | 'warning' | 'critical'>
+    rules?: string[]
+  }
+}
+export declare interface AlertingOptions {
+  enabled?: boolean
+  rules?: AlertRule[]
+  channels?: AlertChannel[]
+  defaultCooldown?: number
+  maxAlerts?: number
+  autoResolve?: boolean
+  autoResolveTimeout?: number
+}
+export declare class PerformanceAlerting {
+  private options: AlertingOptions;
+  private rules: Map<string, AlertRule>;
+  private channels: AlertChannel[];
+  private notifications: AlertNotification[];
+  private lastAlertTimes: Map<string, number>;
+  private metricsBuffer: PerformanceMetrics[];
+  private checkInterval?: Timer;
+  constructor(options?: AlertingOptions);
+  private addDefaultRules(): void;
+  private startAlertingEngine(): void;
+  private evaluateRules(): void;
+  private extractMetricValues(metrics: PerformanceMetrics[], metricType: string): number[];
+  private evaluateCondition(value: number, condition: string, threshold: number): boolean;
+  private triggerAlert(rule: AlertRule, value: any, metrics: PerformanceMetrics[]): Promise<void>;
+  private formatAlertMessage(rule: AlertRule, value: any, metrics: PerformanceMetrics[]): string;
+  private sendNotification(channel: AlertChannel, notification: AlertNotification): Promise<void>;
+  private sendConsoleNotification(notification: AlertNotification): void;
+  private sendWebhookNotification(channel: AlertChannel, notification: AlertNotification): Promise<void>;
+  private sendSlackNotification(channel: AlertChannel, notification: AlertNotification): Promise<void>;
+  private sendEmailNotification(channel: AlertChannel, notification: AlertNotification): Promise<void>;
+  private cleanupOldNotifications(): void;
+  private autoResolveAlerts(): void;
+  private generateId(): string;
+  addMetrics(metrics: PerformanceMetrics): void;
+  addRule(rule: AlertRule): void;
+  removeRule(ruleId: string): void;
+  updateRule(ruleId: string, updates: Partial<AlertRule>): void;
+  addChannel(channel: AlertChannel): void;
+  removeChannel(index: number): void;
+  getActiveAlerts(): AlertNotification[];
+  getAllNotifications(): AlertNotification[];
+  resolveAlert(alertId: string): void;
+  handle(req: EnhancedRequest, next: NextFunction): Promise<Response>;
+  destroy(): void;
+}

package/dist/middleware/performance_dashboard.d.ts

@@ -0,0 +1,97 @@
+import type { EnhancedRequest, NextFunction } from '../types';
+import type { TraceSpan } from './request_tracer';
+// Factory function for easy use
+export declare function performanceDashboard(options?: DashboardOptions): (req: EnhancedRequest, next: NextFunction) => Promise<Response | null>;
+export declare interface DashboardOptions {
+  enabled?: boolean
+  path?: string
+  title?: string
+  refreshInterval?: number
+  maxMetrics?: number
+  authentication?: {
+    enabled?: boolean
+    username?: string
+    password?: string
+    apiKey?: string
+  }
+  features?: {
+    realTimeMetrics?: boolean
+    historicalCharts?: boolean
+    alertsPanel?: boolean
+    tracingView?: boolean
+    systemMetrics?: boolean
+  }
+}
+export declare interface DashboardData {
+  metrics: {
+    current: {
+      totalRequests: number
+      averageResponseTime: number
+      errorRate: number
+      requestsPerSecond: number
+      memoryUsage: number
+      cpuUsage: number
+    }
+    historical: Array<{
+      timestamp: number
+      responseTime: number
+      memoryUsage: number
+      requestCount: number
+      errorCount: number
+    }>
+    distribution: {
+      statusCodes: Record<number, number>
+      paths: Record<string, number>
+      methods: Record<string, number>
+      responseTimes: Array<{ range: string, count: number }>
+    }
+  }
+  alerts: Array<{
+    id: string
+    type: 'warning' | 'critical'
+    message: string
+    timestamp: number
+    resolved: boolean
+  }>
+  traces: TraceSpan[]
+  system: {
+    uptime: number
+    nodeVersion: string
+    bunVersion: string
+    platform: string
+    arch: string
+    memory: NodeJS.MemoryUsage
+    cpu: NodeJS.CpuUsage
+  }
+}
+export declare class PerformanceDashboard {
+  private options: DashboardOptions;
+  private metricsHistory: Array<{
+    timestamp: number
+    responseTime: number
+    memoryUsage: number
+    requestCount: number
+    errorCount: number
+  }>;
+  private alerts: Array<{
+    id: string
+    type: 'warning' | 'critical'
+    message: string
+    timestamp: number
+    resolved: boolean
+  }>;
+  private startTime: number;
+  constructor(options?: DashboardOptions);
+  private isAuthenticated(req: EnhancedRequest): boolean;
+  private generateDashboardHTML(data: DashboardData): string;
+  private getDashboardData(performanceMonitor?: any, requestTracer?: any): Promise<DashboardData>;
+  handle(req: EnhancedRequest, next: NextFunction): Promise<Response | null>;
+  addAlert(type: 'warning' | 'critical', message: string): void;
+  resolveAlert(id: string): void;
+  updateMetricsHistory(data: {
+    responseTime: number
+    memoryUsage: number
+    requestCount: number
+    errorCount: number
+  }): void;
+}