@stacksjs/bun-router 0.0.13 → 0.0.14

package/dist/streaming/sse-handler.d.ts

@@ -1,138 +0,0 @@
-import type { EnhancedRequest, ExtractRouteParams, SSEConfig, SSEEvent, SSERouteHandler } from '../types';
-/**
- * Server-Sent Events handler
- */
-export declare class SSEHandler {
-    private config;
-    private controller?;
-    private encoder;
-    private isConnected;
-    private heartbeatInterval?;
-    constructor(config?: SSEConfig);
-    /**
-     * Create SSE response stream
-     */
-    createStream(): Response;
-    /**
-     * Send an SSE event
-     */
-    send(event: SSEEvent): boolean;
-    /**
-     * Send multiple events
-     */
-    sendBatch(events: SSEEvent[]): number;
-    /**
-     * Send a simple message
-     */
-    message(data: any, id?: string): boolean;
-    /**
-     * Send an event with type
-     */
-    event(type: string, data: any, id?: string): boolean;
-    /**
-     * Send a comment (for debugging)
-     */
-    comment(text: string): boolean;
-    /**
-     * Close the connection
-     */
-    close(): void;
-    /**
-     * Check if connection is active
-     */
-    get connected(): boolean;
-    /**
-     * Format SSE event according to specification
-     */
-    private formatEvent;
-    /**
-     * Setup heartbeat to keep connection alive
-     */
-    private setupHeartbeat;
-    /**
-     * Clear heartbeat interval
-     */
-    private clearHeartbeat;
-    /**
-     * Send retry delay instruction
-     */
-    private sendRetryDelay;
-    /**
-     * Disconnect and cleanup
-     */
-    private disconnect;
-}
-/**
- * SSE connection manager
- */
-export declare class SSEConnectionManager {
-    private connections;
-    private connectionCounts;
-    /**
-     * Create or get SSE connection
-     */
-    createConnection(connectionId: string, config?: SSEConfig): SSEHandler;
-    /**
-     * Get existing connection
-     */
-    getConnection(connectionId: string): SSEHandler | undefined;
-    /**
-     * Close connection
-     */
-    closeConnection(connectionId: string): boolean;
-    /**
-     * Broadcast to all connections
-     */
-    broadcast(event: SSEEvent): number;
-    /**
-     * Broadcast to specific connections
-     */
-    broadcastToConnections(connectionIds: string[], event: SSEEvent): number;
-    /**
-     * Get connection statistics
-     */
-    getStats(): {
-        totalConnections: number;
-        connectionsByUser: Record<string, number>;
-        activeConnections: string[];
-    };
-    /**
-     * Cleanup dead connections
-     */
-    cleanup(): void;
-}
-/**
- * Global SSE connection manager instance
- */
-export declare const sseManager: SSEConnectionManager;
-/**
- * SSE middleware for route handlers
- */
-export declare function createSSEMiddleware(config?: SSEConfig): (req: EnhancedRequest, next: () => Promise<Response>) => Promise<Response>;
-/**
- * SSE utility functions
- */
-export declare const SSEUtils: {
-    /**
-     * Create a simple SSE route handler
-     */
-    createHandler<TPath extends string>(handler: SSERouteHandler<TPath>): (req: EnhancedRequest & {
-        params: ExtractRouteParams<TPath>;
-    }) => Promise<Response>;
-    /**
-     * Create SSE event from object
-     */
-    createEvent(data: any, options?: Partial<SSEEvent>): SSEEvent;
-    /**
-     * Validate SSE event
-     */
-    validateEvent(event: SSEEvent): boolean;
-    /**
-     * Create periodic SSE sender
-     */
-    createPeriodicSender(sse: SSEHandler, dataFn: () => any | Promise<any>, intervalMs: number): () => void;
-    /**
-     * Create SSE from async iterable
-     */
-    fromAsyncIterable<T>(sse: SSEHandler, iterable: AsyncIterable<T>, transform?: (item: T) => SSEEvent): Promise<void>;
-};

package/dist/streaming/stream-handler.d.ts

@@ -1,114 +0,0 @@
-import type { BufferedStreamConfig, ContentType, DirectStreamConfig, EnhancedRequest, ResponseStatus, StreamingCompression } from '../types';
-/**
- * Base streaming configuration
- */
-export interface BaseStreamConfig {
-    contentType?: ContentType;
-    headers?: Record<string, string>;
-    status?: ResponseStatus;
-    bufferSize?: number;
-    enableCompression?: boolean;
-    compressionType?: StreamingCompression;
-}
-/**
- * Stream response wrapper
- */
-export declare class StreamResponse {
-    private stream;
-    private headers;
-    private status;
-    constructor(stream: ReadableStream, options?: {
-        headers?: Headers | Record<string, string>;
-        status?: ResponseStatus;
-        contentType?: ContentType;
-    });
-    toResponse(): Response;
-    addHeader(name: string, value: string): this;
-    setContentType(contentType: ContentType): this;
-    setStatus(status: ResponseStatus): this;
-}
-/**
- * Generic streaming handler
- */
-export declare class StreamHandler {
-    /**
-     * Create a direct stream response
-     */
-    static direct<T>(data: T[] | AsyncIterable<T>, config?: DirectStreamConfig): StreamResponse;
-    /**
-     * Create a buffered stream response
-     */
-    static buffered<T>(data: T[] | AsyncIterable<T>, config?: BufferedStreamConfig): StreamResponse;
-    /**
-     * Create a JSON stream response
-     */
-    static json<T>(data: T[] | AsyncIterable<T>, config?: BaseStreamConfig): StreamResponse;
-    /**
-     * Create a text stream response
-     */
-    static text(data: string[] | AsyncIterable<string>, config?: BaseStreamConfig): StreamResponse;
-    /**
-     * Create a CSV stream response
-     */
-    static csv<T extends Record<string, any>>(data: T[] | AsyncIterable<T>, config?: BaseStreamConfig & {
-        csvHeaders?: string[];
-    }): StreamResponse;
-    /**
-     * Format data according to the specified format
-     */
-    private static formatData;
-    /**
-     * Convert object to CSV row
-     */
-    private static objectToCsvRow;
-    /**
-     * Get appropriate content type for format
-     */
-    private static getContentTypeForFormat;
-}
-/**
- * Stream utilities
- */
-export declare const StreamUtils: {
-    /**
-     * Create a transform stream
-     */
-    transform<T, U>(transformFn: (chunk: T) => U | Promise<U>): TransformStream<T, U>;
-    /**
-     * Create a filter stream
-     */
-    filter<T>(filterFn: (chunk: T) => boolean | Promise<boolean>): TransformStream<T, T>;
-    /**
-     * Create a batch stream
-     */
-    batch<T>(batchSize: number): TransformStream<T, T[]>;
-    /**
-     * Create a delay stream
-     */
-    delay<T>(ms: number): TransformStream<T, T>;
-    /**
-     * Create a rate limit stream
-     */
-    rateLimit<T>(itemsPerSecond: number): TransformStream<T, T>;
-};
-/**
- * File streaming utilities
- */
-export declare class FileStreamHandler {
-    /**
-     * Stream a file with range support
-     */
-    static streamFile(filePath: string, request: EnhancedRequest, options?: {
-        contentType?: ContentType;
-        enableRanges?: boolean;
-        chunkSize?: number;
-    }): Promise<Response>;
-    /**
-     * Handle range requests for file streaming
-     */
-    private static handleRangeRequest;
-    /**
-     * Parse Range header
-     */
-    private static parseRangeHeader;
-}

package/dist/testing/auth-testing.d.ts

@@ -1,156 +0,0 @@
-import type { EnhancedRequest } from '../types';
-import type { JWTTestOptions, SessionTestOptions, TestUser } from './types';
-/**
- * Authentication testing utilities
- */
-export declare class AuthTester {
-    private request;
-    constructor(request?: EnhancedRequest);
-    /**
-     * Set authenticated user
-     */
-    as(user: TestUser): AuthTester;
-    /**
-     * Set JWT token
-     */
-    withJWT(token: string, type?: 'Bearer' | 'Basic'): AuthTester;
-    /**
-     * Set session data
-     */
-    withSession(sessionData: any): AuthTester;
-    /**
-     * Set API key
-     */
-    withApiKey(apiKey: string, headerName?: string): AuthTester;
-    /**
-     * Set basic auth credentials
-     */
-    withBasicAuth(username: string, password: string): AuthTester;
-    /**
-     * Set cookies for authentication
-     */
-    withAuthCookies(cookies: Record<string, string>): AuthTester;
-    /**
-     * Remove authentication
-     */
-    unauthenticated(): AuthTester;
-    /**
-     * Get the configured request
-     */
-    getRequest(): EnhancedRequest;
-}
-/**
- * JWT testing utilities
- */
-export declare class JWTTester {
-    private options;
-    constructor(options?: JWTTestOptions);
-    /**
-     * Generate a test JWT token
-     */
-    generateToken(payload?: Record<string, any>): string;
-    /**
-     * Generate an expired token
-     */
-    generateExpiredToken(payload?: Record<string, any>): string;
-    /**
-     * Generate an invalid token
-     */
-    generateInvalidToken(): string;
-    /**
-     * Decode a JWT token (for testing purposes)
-     */
-    decodeToken(token: string): {
-        header: any;
-        payload: any;
-        signature: string;
-    };
-    private parseExpiresIn;
-}
-/**
- * Session testing utilities
- */
-export declare class SessionTester {
-    private options;
-    constructor(options?: SessionTestOptions);
-    /**
-     * Create a test session
-     */
-    createSession(data?: Record<string, any>): {
-        sessionId: string;
-        data: Record<string, any>;
-        cookie: string;
-    };
-    /**
-     * Generate session cookie string
-     */
-    generateSessionCookie(name?: string): string;
-    /**
-     * Create an expired session
-     */
-    createExpiredSession(): {
-        sessionId: string;
-        data: Record<string, any>;
-        cookie: string;
-    };
-}
-/**
- * Authentication mock factories
- */
-export declare const authMocks: {
-    /**
-     * Create a mock user
-     */
-    user: (overrides?: Partial<TestUser>) => TestUser;
-    /**
-     * Create an admin user
-     */
-    adminUser: (overrides?: Partial<TestUser>) => TestUser;
-    /**
-     * Create a guest user
-     */
-    guestUser: () => TestUser;
-    /**
-     * Mock authentication middleware
-     */
-    authMiddleware: (user?: TestUser) => any;
-    /**
-     * Mock role-based middleware
-     */
-    roleMiddleware: (requiredRoles: string[]) => any;
-    /**
-     * Mock permission-based middleware
-     */
-    permissionMiddleware: (requiredPermissions: string[]) => any;
-};
-/**
- * Helper functions
- */
-export declare const authHelpers: {
-    /**
-     * Create an authenticated request
-     */
-    authenticatedRequest: (user: TestUser, request?: EnhancedRequest) => EnhancedRequest;
-    /**
-     * Create a request with JWT
-     */
-    jwtRequest: (payload?: Record<string, any>, request?: EnhancedRequest) => EnhancedRequest;
-    /**
-     * Create a request with session
-     */
-    sessionRequest: (sessionData?: Record<string, any>, request?: EnhancedRequest) => EnhancedRequest;
-    /**
-     * Verify JWT token structure
-     */
-    verifyJWTStructure: (token: string) => boolean;
-    /**
-     * Extract payload from JWT (for testing)
-     */
-    extractJWTPayload: (token: string) => any;
-};
-/**
- * Factory functions
- */
-export declare function createAuthTester(request?: EnhancedRequest): AuthTester;
-export declare function createJWTTester(options?: JWTTestOptions): JWTTester;
-export declare function createSessionTester(options?: SessionTestOptions): SessionTester;

package/dist/testing/file-upload-testing.d.ts

@@ -1,190 +0,0 @@
-import type { EnhancedRequest, UploadedFile } from '../types';
-import type { TestFile } from './types';
-/**
- * File upload testing utilities
- */
-export declare class FileUploadTester {
-    private request;
-    private files;
-    constructor(request?: EnhancedRequest);
-    /**
-     * Add a test file to the request
-     */
-    addFile(testFile: TestFile): FileUploadTester;
-    /**
-     * Add multiple test files
-     */
-    addFiles(testFiles: TestFile[]): FileUploadTester;
-    /**
-     * Create an image file for testing
-     */
-    addImage(fieldName: string, filename?: string, size?: number): FileUploadTester;
-    /**
-     * Create a document file for testing
-     */
-    addDocument(fieldName: string, filename?: string, content?: string): FileUploadTester;
-    /**
-     * Create a text file for testing
-     */
-    addTextFile(fieldName: string, filename?: string, content?: string): FileUploadTester;
-    /**
-     * Create a large file for testing upload limits
-     */
-    addLargeFile(fieldName: string, sizeInMB?: number): FileUploadTester;
-    /**
-     * Create a file with invalid extension
-     */
-    addInvalidFile(fieldName: string, filename?: string): FileUploadTester;
-    /**
-     * Set form data alongside files
-     */
-    withFormData(data: Record<string, any>): FileUploadTester;
-    /**
-     * Get the configured request
-     */
-    getRequest(): EnhancedRequest;
-    /**
-     * Get uploaded files
-     */
-    getFiles(): UploadedFile[];
-    /**
-     * Clear all files
-     */
-    clearFiles(): FileUploadTester;
-    private detectMimeType;
-}
-/**
- * File validation testing utilities
- */
-export declare class FileValidationTester {
-    /**
-     * Test file size validation
-     */
-    static testFileSize(file: UploadedFile, maxSize: number): boolean;
-    /**
-     * Test file type validation
-     */
-    static testFileType(file: UploadedFile, allowedTypes: string[]): boolean;
-    /**
-     * Test file extension validation
-     */
-    static testFileExtension(file: UploadedFile, allowedExtensions: string[]): boolean;
-    /**
-     * Test filename validation (security)
-     */
-    static testFilename(file: UploadedFile): boolean;
-    /**
-     * Test image file validation
-     */
-    static testImageFile(file: UploadedFile): boolean;
-    /**
-     * Test document file validation
-     */
-    static testDocumentFile(file: UploadedFile): boolean;
-}
-/** Middleware function type */
-export type MiddlewareFn = (req: EnhancedRequest, next: () => Promise<Response>) => Promise<Response>;
-/** File storage service interface */
-export interface FileStorageService {
-    store: (file: UploadedFile, path?: string) => Promise<string>;
-    delete: (path: string) => Promise<void>;
-    exists: (path: string) => Promise<boolean>;
-    getUrl: (path: string) => string;
-}
-/** Virus scanner interface */
-export interface VirusScanResult {
-    clean: boolean;
-    threat?: string;
-}
-export interface VirusScanner {
-    scan: (file: UploadedFile) => Promise<VirusScanResult>;
-}
-/** Validation middleware options */
-export interface ValidationMiddlewareOptions {
-    maxSize?: number;
-    allowedTypes?: string[];
-    maxFiles?: number;
-}
-/** Image upload middleware options */
-export interface ImageUploadMiddlewareOptions {
-    maxSize?: number;
-    maxWidth?: number;
-    maxHeight?: number;
-}
-/**
- * File upload mock factories
- */
-export declare const fileUploadMocks: {
-    validationMiddleware: (options?: ValidationMiddlewareOptions) => MiddlewareFn;
-    imageUploadMiddleware: (options?: ImageUploadMiddlewareOptions) => MiddlewareFn;
-    storageService: FileStorageService;
-    virusScanner: VirusScanner;
-};
-/**
- * File upload test scenarios
- */
-export declare const fileUploadScenarios: {
-    /**
-     * Test successful single file upload
-     */
-    singleFileUpload: () => FileUploadTester;
-    /**
-     * Test multiple file upload
-     */
-    multipleFileUpload: () => FileUploadTester;
-    /**
-     * Test file size limit exceeded
-     */
-    fileSizeExceeded: () => FileUploadTester;
-    /**
-     * Test invalid file type
-     */
-    invalidFileType: () => FileUploadTester;
-    /**
-     * Test empty file upload
-     */
-    emptyFileUpload: () => FileUploadTester;
-    /**
-     * Test file with malicious filename
-     */
-    maliciousFilename: () => FileUploadTester;
-};
-/**
- * File upload assertion helpers
- */
-export declare const fileUploadAssertions: {
-    /**
-     * Assert that request has files
-     */
-    hasFiles: (request: EnhancedRequest, count?: number) => void;
-    /**
-     * Assert that request has file with specific field name
-     */
-    hasFileWithField: (request: EnhancedRequest, fieldName: string) => void;
-    /**
-     * Assert file properties
-     */
-    fileMatches: (file: UploadedFile, expected: Partial<UploadedFile>) => void;
-    /**
-     * Assert file size is within limits
-     */
-    fileSizeWithinLimit: (file: UploadedFile, maxSize: number) => void;
-    /**
-     * Assert file type is allowed
-     */
-    fileTypeAllowed: (file: UploadedFile, allowedTypes: string[]) => void;
-};
-/**
- * Factory functions
- */
-export declare function createFileUploadTester(request?: EnhancedRequest): FileUploadTester;
-/**
- * Helper to create test files
- */
-export declare const testFiles: {
-    image: (fieldName?: string, filename?: string) => TestFile;
-    document: (fieldName?: string, filename?: string) => TestFile;
-    text: (fieldName?: string, filename?: string, content?: string) => TestFile;
-    large: (fieldName?: string, sizeInMB?: number) => TestFile;
-    malicious: (fieldName?: string) => TestFile;
-};

package/dist/testing/index.d.ts

@@ -1,10 +0,0 @@
-export * from './auth-testing';
-export * from './file-upload-testing';
-export * from './middleware-testing';
-export * from './model-binding-testing';
-export * from './performance-testing';
-export * from './test-client';
-export * from './test-request';
-export * from './test-response';
-export * from './types';
-export * from './websocket-testing';