@stacksjs/bun-router 0.0.13 → 0.0.14

package/dist/middleware/auth.d.ts

@@ -1,63 +0,0 @@
-import type { EnhancedRequest, Middleware, NextFunction } from '../types';
-export interface AuthOptions {
-    /**
-     * Authentication type to use
-     */
-    type: 'basic' | 'bearer' | 'api-key' | 'oauth2' | 'jwt' | 'custom';
-    /**
-     * Function to validate credentials
-     */
-    validator: (credentials: any, req: EnhancedRequest) => Promise<boolean> | boolean;
-    /**
-     * Extract user information after successful authentication
-     */
-    userExtractor?: (credentials: any, req: EnhancedRequest) => Promise<any> | any;
-    /**
-     * Where to look for auth information
-     */
-    source?: 'header' | 'query' | 'cookie';
-    /**
-     * Key name for the source (header name, query param, cookie name)
-     */
-    key?: string;
-    /**
-     * Realm for Basic authentication
-     */
-    realm?: string;
-    /**
-     * Custom credentials extractor
-     */
-    credentialsExtractor?: (req: EnhancedRequest) => Promise<any> | any;
-    /**
-     * Whether to attach user info to request
-     */
-    attachUser?: boolean;
-}
-/**
- * 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;
-export default class AuthMiddleware implements Middleware {
-    private options;
-    constructor(options: AuthOptions);
-    handle(req: EnhancedRequest, next: NextFunction): Promise<Response>;
-}
-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;

package/dist/middleware/content_security_policy.d.ts

@@ -1,53 +0,0 @@
-import type { EnhancedRequest, NextFunction } from '../types';
-export 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 interface CSPOptions {
-    directives?: CSPDirectives;
-    reportOnly?: boolean;
-    reportUri?: string;
-    reportTo?: string;
-    useNonces?: boolean;
-    nonceLength?: number;
-    upgradeInsecureRequests?: boolean;
-    blockAllMixedContent?: boolean;
-}
-export default class ContentSecurityPolicy {
-    private options;
-    private nonces;
-    constructor(options?: CSPOptions);
-    private generateNonce;
-    private buildCSPHeader;
-    handle(req: EnhancedRequest, next: NextFunction): Promise<Response>;
-    getNonce(url: string): string | undefined;
-}
-export declare function contentSecurityPolicy(options?: CSPOptions): (req: EnhancedRequest, next: NextFunction) => Promise<Response>;

package/dist/middleware/cors.d.ts

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

package/dist/middleware/csrf.d.ts

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

package/dist/middleware/ddos_protection.d.ts

@@ -1,39 +0,0 @@
-import type { EnhancedRequest, NextFunction } from '../types';
-export 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;
-    };
-}
-export default class DDoSProtection {
-    private options;
-    private requestStore;
-    private cleanupInterval;
-    constructor(options?: DDoSProtectionOptions);
-    private defaultKeyGenerator;
-    private startCleanupInterval;
-    private isWhitelisted;
-    private isBlacklisted;
-    private getRateLimitInfo;
-    private shouldBlock;
-    private blockIP;
-    private createBlockedResponse;
-    handle(req: EnhancedRequest, next: NextFunction): Promise<Response>;
-    destroy(): void;
-}
-export declare function ddosProtection(options?: DDoSProtectionOptions): (req: EnhancedRequest, next: NextFunction) => Promise<Response>;

package/dist/middleware/file_security.d.ts

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

package/dist/middleware/file_upload.d.ts

@@ -1,38 +0,0 @@
-import type { EnhancedRequest, NextFunction } from '../types';
-import type { FileSecurityConfig } from './file_security';
-export interface UploadedFile {
-    fieldName: string;
-    originalName: string;
-    filename: string;
-    path: string;
-    size: number;
-    mimetype: string;
-    buffer: ArrayBuffer;
-}
-export interface FileUploadConfig extends FileSecurityConfig {
-    destination?: string;
-    maxFileSize?: number;
-    maxFiles?: number;
-    allowedMimeTypes?: string[];
-    allowedExtensions?: string[];
-    preserveOriginalName?: boolean;
-    generateUniqueFilename?: boolean;
-    createDestination?: boolean;
-}
-export interface FileUploadOptions extends FileUploadConfig {
-    fieldName?: string | string[];
-}
-export default class FileUpload {
-    private config;
-    private fileSecurity;
-    constructor(config?: FileUploadConfig);
-    handle(req: EnhancedRequest, next: NextFunction): Promise<Response>;
-    private generateFilename;
-    private formatBytes;
-    private createErrorResponse;
-}
-export declare function fileUpload(config?: FileUploadConfig): FileUpload;
-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;

package/dist/middleware/helmet.d.ts

@@ -1,54 +0,0 @@
-import type { EnhancedRequest, NextFunction } from '../types';
-export 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 default class Helmet {
-    private options;
-    constructor(options?: HelmetOptions);
-    handle(req: EnhancedRequest, next: NextFunction): Promise<Response>;
-}

package/dist/middleware/index.d.ts

@@ -1,44 +0,0 @@
-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 Session from './session';
-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 type { NonceStore, RequestSigningOptions, SignatureAlgorithm, SignedPart } 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 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 function auth(): Auth;
-export declare const middleware: Record<string, any>;
-export default middleware;

package/dist/middleware/input_validation.d.ts

@@ -1,45 +0,0 @@
-import type { EnhancedRequest, NextFunction } from '../types';
-export 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 interface ValidationSchema {
-    [key: string]: ValidationRule | ValidationSchema;
-}
-export 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 interface ValidationError {
-    field: string;
-    message: string;
-    value: any;
-    rule: string;
-}
-export default class InputValidation {
-    private options;
-    constructor(options?: InputValidationOptions);
-    private validateValue;
-    private sanitizeValue;
-    private validateObject;
-    private parseRequestBody;
-    handle(req: EnhancedRequest, next: NextFunction): Promise<Response>;
-}
-export declare function inputValidation(options?: InputValidationOptions): (req: EnhancedRequest, next: NextFunction) => Promise<Response>;

package/dist/middleware/json_body.d.ts

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

package/dist/middleware/performance_alerting.d.ts

@@ -1,87 +0,0 @@
-import type { EnhancedRequest, NextFunction } from '../types';
-import type { PerformanceMetrics } from './performance_monitor';
-export 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 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 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 interface AlertingOptions {
-    enabled?: boolean;
-    rules?: AlertRule[];
-    channels?: AlertChannel[];
-    defaultCooldown?: number;
-    maxAlerts?: number;
-    autoResolve?: boolean;
-    autoResolveTimeout?: number;
-}
-export default class PerformanceAlerting {
-    private options;
-    private rules;
-    private channels;
-    private notifications;
-    private lastAlertTimes;
-    private metricsBuffer;
-    private checkInterval?;
-    constructor(options?: AlertingOptions);
-    private addDefaultRules;
-    private startAlertingEngine;
-    private evaluateRules;
-    private extractMetricValues;
-    private evaluateCondition;
-    private triggerAlert;
-    private formatAlertMessage;
-    private sendNotification;
-    private sendConsoleNotification;
-    private sendWebhookNotification;
-    private sendSlackNotification;
-    private sendEmailNotification;
-    private cleanupOldNotifications;
-    private autoResolveAlerts;
-    private generateId;
-    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;
-}
-export declare function performanceAlerting(options?: AlertingOptions): PerformanceAlerting;

package/dist/middleware/performance_dashboard.d.ts

@@ -1,87 +0,0 @@
-import type { EnhancedRequest, NextFunction } from '../types';
-import type { TraceSpan } from './request_tracer';
-export 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 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 default class PerformanceDashboard {
-    private options;
-    private metricsHistory;
-    private alerts;
-    private startTime;
-    constructor(options?: DashboardOptions);
-    private isAuthenticated;
-    private generateDashboardHTML;
-    private getDashboardData;
-    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;
-}
-export declare function performanceDashboard(options?: DashboardOptions): (req: EnhancedRequest, next: NextFunction) => Promise<Response | null>;