@stacksjs/bun-router 0.0.14 → 0.0.15

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

@@ -0,0 +1,138 @@
+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

@@ -0,0 +1,114 @@
+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

@@ -0,0 +1,156 @@
+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

@@ -0,0 +1,190 @@
+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

@@ -0,0 +1,10 @@
+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';