@stacksjs/bun-router 0.0.12 → 0.0.14

package/dist/testing/test-request.d.ts

@@ -1,85 +0,0 @@
-import type { EnhancedRequest } from '../types';
-import type { TestFile, TestRequestOptions } from './types';
-/**
- * Creates a mock EnhancedRequest for testing
- */
-export declare class TestRequestBuilder {
-    private request;
-    private url;
-    constructor(method: string, path: string, options?: TestRequestOptions);
-    private parseQuery;
-    private convertTestFiles;
-    private handleBody;
-    /**
-     * Set route parameters
-     */
-    params(params: Record<string, string>): TestRequestBuilder;
-    /**
-     * Set request headers
-     */
-    headers(headers: Record<string, string>): TestRequestBuilder;
-    /**
-     * Set authorization header
-     */
-    auth(token: string, type?: 'Bearer' | 'Basic'): TestRequestBuilder;
-    /**
-     * Set user context
-     */
-    user(user: any): TestRequestBuilder;
-    /**
-     * Set session data
-     */
-    session(session: any): TestRequestBuilder;
-    /**
-     * Set cookies
-     */
-    cookies(cookies: Record<string, string>): TestRequestBuilder;
-    /**
-     * Set context data
-     */
-    context(context: Record<string, any>): TestRequestBuilder;
-    /**
-     * Set JSON body
-     */
-    json(data: any): TestRequestBuilder;
-    /**
-     * Set form body
-     */
-    form(data: Record<string, any>): TestRequestBuilder;
-    /**
-     * Add uploaded files
-     */
-    files(files: TestFile[]): TestRequestBuilder;
-    /**
-     * Set IP address
-     */
-    ip(ip: string): TestRequestBuilder;
-    /**
-     * Set user agent
-     */
-    userAgent(userAgent: string): TestRequestBuilder;
-    /**
-     * Set CSRF token
-     */
-    csrf(token: string): TestRequestBuilder;
-    /**
-     * Build the final request object
-     */
-    build(): EnhancedRequest;
-}
-/**
- * Helper functions for creating test requests
- */
-export declare const testRequest: {
-    get: (path: string, options?: TestRequestOptions) => TestRequestBuilder;
-    post: (path: string, options?: TestRequestOptions) => TestRequestBuilder;
-    put: (path: string, options?: TestRequestOptions) => TestRequestBuilder;
-    patch: (path: string, options?: TestRequestOptions) => TestRequestBuilder;
-    delete: (path: string, options?: TestRequestOptions) => TestRequestBuilder;
-    options: (path: string, options?: TestRequestOptions) => TestRequestBuilder;
-    head: (path: string, options?: TestRequestOptions) => TestRequestBuilder;
-};
-/**
- * Create a mock request with minimal setup
- */
-export declare function createMockRequest(method?: string, path?: string, options?: TestRequestOptions): EnhancedRequest;

package/dist/testing/test-response.d.ts

@@ -1,90 +0,0 @@
-import type { TestResponse } from './types';
-/**
- * Test response wrapper with assertion helpers
- */
-export declare class TestResponseWrapper implements TestResponse {
-    status: number;
-    statusText: string;
-    headers: Record<string, string>;
-    body: any;
-    text: string;
-    json: any;
-    cookies: Record<string, string>;
-    redirected: boolean;
-    url: string;
-    ok: boolean;
-    type: string;
-    private originalResponse;
-    constructor(response: Response, body?: any);
-    private parseHeaders;
-    private parseCookies;
-    /**
-     * Assert response status
-     */
-    expectStatus(status: number): TestResponseWrapper;
-    /**
-     * Assert response is successful (2xx)
-     */
-    expectSuccess(): TestResponseWrapper;
-    /**
-     * Assert response has specific header
-     */
-    expectHeader(name: string, value?: string): TestResponseWrapper;
-    /**
-     * Assert response body matches
-     */
-    expectBody(expectedBody: any): TestResponseWrapper;
-    /**
-     * Assert response JSON matches
-     */
-    expectJson(expectedJson: any): TestResponseWrapper;
-    /**
-     * Assert response JSON contains specific properties
-     */
-    expectJsonContains(properties: Record<string, any>): TestResponseWrapper;
-    /**
-     * Assert response has specific cookie
-     */
-    expectCookie(name: string, value?: string): TestResponseWrapper;
-    /**
-     * Assert response is a redirect
-     */
-    expectRedirect(url?: string): TestResponseWrapper;
-    /**
-     * Assert response contains validation errors
-     */
-    expectValidationError(field?: string, message?: string): TestResponseWrapper;
-    /**
-     * Assert response content type
-     */
-    expectContentType(contentType: string): TestResponseWrapper;
-    /**
-     * Assert response body contains text
-     */
-    expectBodyContains(text: string): TestResponseWrapper;
-    /**
-     * Assert response body matches regex
-     */
-    expectBodyMatches(pattern: RegExp): TestResponseWrapper;
-    /**
-     * Assert response JSON has specific structure
-     */
-    expectJsonStructure(structure: any): TestResponseWrapper;
-    private validateStructure;
-    /**
-     * Get the original Response object
-     */
-    getOriginalResponse(): Response;
-    /**
-     * Convert to JSON for easy inspection
-     */
-    toJSON(): any;
-}
-/**
- * Create a test response from a Response object
- */
-export declare function createTestResponse(response: Response): Promise<TestResponseWrapper>;
-/**
- * Create a mock response for testing
- */
-export declare function createMockResponse(status?: number, body?: any, headers?: Record<string, string>): TestResponseWrapper;

package/dist/testing/types.d.ts

@@ -1,207 +0,0 @@
-import type { EnhancedRequest, MiddlewareHandler } from '../types';
-/**
- * Test client configuration options
- */
-export interface TestClientConfig {
-    baseUrl?: string;
-    defaultHeaders?: Record<string, string>;
-    timeout?: number;
-    followRedirects?: boolean;
-    validateStatus?: (status: number) => boolean;
-}
-/**
- * Test request options
- */
-export interface TestRequestOptions {
-    headers?: Record<string, string>;
-    query?: Record<string, string | string[]>;
-    body?: any;
-    files?: TestFile[];
-    cookies?: Record<string, string>;
-    session?: any;
-    user?: any;
-    context?: Record<string, any>;
-    timeout?: number;
-    followRedirects?: boolean;
-}
-/**
- * Test file for upload testing
- */
-export interface TestFile {
-    fieldName: string;
-    filename: string;
-    content: string | ArrayBuffer | Uint8Array;
-    mimetype?: string;
-}
-/**
- * Test response interface
- */
-export interface TestResponse {
-    status: number;
-    statusText: string;
-    headers: Record<string, string>;
-    body: any;
-    text: string;
-    json: any;
-    cookies: Record<string, string>;
-    redirected: boolean;
-    url: string;
-    ok: boolean;
-    type: string;
-}
-/**
- * Middleware test context
- */
-export interface MiddlewareTestContext {
-    request: EnhancedRequest;
-    response?: Response;
-    next: ReturnType<typeof import('bun:test').mock<() => Promise<Response | null>>>;
-    error?: Error;
-}
-/**
- * Authentication test user
- */
-export interface TestUser {
-    id: string | number;
-    email?: string;
-    username?: string;
-    roles?: string[];
-    permissions?: string[];
-    [key: string]: any;
-}
-/**
- * JWT test options
- */
-export interface JWTTestOptions {
-    secret?: string;
-    expiresIn?: string;
-    algorithm?: 'HS256' | 'HS384' | 'HS512' | 'RS256';
-    payload?: Record<string, any>;
-    headers?: Record<string, any>;
-}
-/**
- * Session test options
- */
-export interface SessionTestOptions {
-    sessionId?: string;
-    data?: Record<string, any>;
-    maxAge?: number;
-    secure?: boolean;
-    httpOnly?: boolean;
-}
-/**
- * Model binding test options
- */
-export interface ModelBindingTestOptions {
-    modelClass?: any;
-    routeKey?: string;
-    constraints?: Record<string, any>;
-    customResolver?: (value: string) => Promise<any>;
-}
-/**
- * Performance test metrics
- */
-export interface PerformanceMetrics {
-    responseTime: number;
-    memoryUsage: {
-        heapUsed: number;
-        heapTotal: number;
-        external: number;
-        rss: number;
-    };
-    cpuUsage: {
-        user: number;
-        system: number;
-    };
-    requestsPerSecond?: number;
-    concurrentRequests?: number;
-}
-/**
- * Load test configuration
- */
-export interface LoadTestConfig {
-    duration: number;
-    concurrency: number;
-    rampUp?: number;
-    rampDown?: number;
-    requestsPerSecond?: number;
-    maxRequests?: number;
-}
-/**
- * WebSocket test message
- */
-export interface WSTestMessage {
-    type: 'text' | 'binary';
-    data: string | ArrayBuffer | Uint8Array;
-    timestamp?: number;
-}
-/**
- * WebSocket test client
- */
-export interface WSTestClient {
-    send: (message: string | ArrayBuffer | Uint8Array) => void;
-    close: (code?: number, reason?: string) => void;
-    ping: (data?: Uint8Array) => void;
-    pong: (data?: Uint8Array) => void;
-    messages: WSTestMessage[];
-    isConnected: boolean;
-    readyState: number;
-}
-/**
- * Test assertion helpers
- */
-export interface TestAssertions {
-    toHaveStatus: (status: number) => void;
-    toHaveHeader: (name: string, value?: string) => void;
-    toHaveBody: (body: any) => void;
-    toHaveJson: (json: any) => void;
-    toHaveCookie: (name: string, value?: string) => void;
-    toBeRedirected: (url?: string) => void;
-    toHaveValidationError: (field?: string, message?: string) => void;
-    toBeAuthenticated: (user?: any) => void;
-    toBeUnauthenticated: () => void;
-    toHaveMiddleware: (middleware: string | MiddlewareHandler) => void;
-    toHaveModel: (model: any) => void;
-    toHaveUploadedFile: (fieldName: string, filename?: string) => void;
-    toRespondWithin: (milliseconds: number) => void;
-}
-/**
- * Mock factory options
- */
-export interface MockFactoryOptions {
-    count?: number;
-    overrides?: Record<string, any>;
-    relations?: Record<string, any>;
-}
-/**
- * Database test helpers
- */
-export interface DatabaseTestHelpers {
-    seed: (data: any[]) => Promise<void>;
-    truncate: (tables?: string[]) => Promise<void>;
-    factory: <T>(model: string, options?: MockFactoryOptions) => T[];
-    create: <T>(model: string, data?: Partial<T>) => Promise<T>;
-    transaction: <T>(callback: () => Promise<T>) => Promise<T>;
-}
-/**
- * Test environment configuration
- */
-export interface TestEnvironment {
-    database?: DatabaseTestHelpers;
-    cache?: {
-        clear: () => Promise<void>;
-        get: (key: string) => Promise<any>;
-        set: (key: string, value: any, ttl?: number) => Promise<void>;
-    };
-    storage?: {
-        clear: () => Promise<void>;
-        put: (path: string, content: string | ArrayBuffer) => Promise<void>;
-        get: (path: string) => Promise<string | ArrayBuffer | null>;
-        delete: (path: string) => Promise<void>;
-    };
-    queue?: {
-        clear: () => Promise<void>;
-        push: (job: any) => Promise<void>;
-        process: () => Promise<void>;
-    };
-}

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

@@ -1,227 +0,0 @@
-import type { ServerWebSocket } from 'bun';
-import type { WSTestClient, WSTestMessage } from './types';
-/**
- * WebSocket testing utilities
- */
-export declare class WebSocketTester {
-    private messages;
-    private isConnected;
-    private readyState;
-    private eventHandlers;
-    constructor();
-    private setupEventHandlers;
-    /**
-     * Simulate WebSocket connection
-     */
-    connect(): WebSocketTester;
-    /**
-     * Simulate WebSocket disconnection
-     */
-    disconnect(code?: number, reason?: string): WebSocketTester;
-    /**
-     * Simulate sending a message
-     */
-    send(data: string | ArrayBuffer | Uint8Array): WebSocketTester;
-    /**
-     * Simulate receiving a message
-     */
-    receive(data: string | ArrayBuffer | Uint8Array): WebSocketTester;
-    /**
-     * Simulate ping
-     */
-    ping(data?: Uint8Array): WebSocketTester;
-    /**
-     * Simulate pong
-     */
-    pong(data?: Uint8Array): WebSocketTester;
-    /**
-     * Add event listener
-     */
-    on(event: string, handler: (...args: any[]) => any): WebSocketTester;
-    /**
-     * Remove event listener
-     */
-    off(event: string, handler: (...args: any[]) => any): WebSocketTester;
-    /**
-     * Emit event
-     */
-    private emit;
-    /**
-     * Get all sent messages
-     */
-    getSentMessages(): WSTestMessage[];
-    /**
-     * Get messages of specific type
-     */
-    getMessagesByType(type: 'text' | 'binary'): WSTestMessage[];
-    /**
-     * Clear message history
-     */
-    clearMessages(): WebSocketTester;
-    /**
-     * Get connection state
-     */
-    getState(): {
-        isConnected: boolean;
-        readyState: number;
-    };
-    /**
-     * Create a test client interface
-     */
-    getTestClient(): WSTestClient;
-}
-/**
- * Mock ServerWebSocket for testing
- */
-export declare class MockServerWebSocket {
-    private tester;
-    private _data;
-    constructor(data?: any);
-    send(message: string | ArrayBuffer | Uint8Array): void;
-    close(code?: number, reason?: string): void;
-    ping(data?: Uint8Array): void;
-    pong(data?: Uint8Array): void;
-    publish(topic: string, message: string | ArrayBuffer | Uint8Array): void;
-    subscribe(_topic: string): void;
-    unsubscribe(_topic: string): void;
-    isSubscribed(_topic: string): boolean;
-    cork(callback: () => void): void;
-    get readyState(): number;
-    get data(): any;
-    set data(value: any);
-    getTester(): WebSocketTester;
-}
-/**
- * WebSocket handler testing utilities
- */
-export declare const wsHandlerMocks: {
-    /**
-     * Mock WebSocket open handler
-     */
-    onOpen: () => any;
-    /**
-     * Mock WebSocket message handler
-     */
-    onMessage: (response?: string | ArrayBuffer | Uint8Array) => any;
-    /**
-     * Mock WebSocket close handler
-     */
-    onClose: () => any;
-    /**
-     * Mock WebSocket error handler
-     */
-    onError: () => any;
-    /**
-     * Mock echo handler
-     */
-    echo: () => any;
-    /**
-     * Mock broadcast handler
-     */
-    broadcast: (clients: ServerWebSocket<any>[]) => any;
-    /**
-     * Mock chat room handler
-     */
-    chatRoom: (room: string) => any;
-};
-/**
- * WebSocket test scenarios
- */
-export declare const wsTestScenarios: {
-    /**
-     * Test basic connection and message exchange
-     */
-    basicConnection: () => WebSocketTester;
-    /**
-     * Test connection failure
-     */
-    connectionFailure: () => WebSocketTester;
-    /**
-     * Test message broadcasting
-     */
-    messageBroadcast: (clientCount?: number) => WebSocketTester[];
-    /**
-     * Test ping/pong mechanism
-     */
-    pingPong: () => WebSocketTester;
-    /**
-     * Test connection timeout
-     */
-    connectionTimeout: () => WebSocketTester;
-};
-/**
- * WebSocket assertion helpers
- */
-export declare const wsAssertions: {
-    /**
-     * Assert WebSocket is connected
-     */
-    isConnected: (tester: WebSocketTester) => void;
-    /**
-     * Assert WebSocket is disconnected
-     */
-    isDisconnected: (tester: WebSocketTester) => void;
-    /**
-     * Assert message was sent
-     */
-    messageSent: (tester: WebSocketTester, expectedMessage: string | ArrayBuffer | Uint8Array) => void;
-    /**
-     * Assert number of messages sent
-     */
-    messageCount: (tester: WebSocketTester, expectedCount: number) => void;
-    /**
-     * Assert message type
-     */
-    messageType: (tester: WebSocketTester, index: number, expectedType: "text" | "binary") => void;
-    /**
-     * Assert ready state
-     */
-    readyState: (tester: WebSocketTester, expectedState: number) => void;
-};
-/**
- * WebSocket performance testing
- */
-export declare const wsPerformance: {
-    /**
-     * Test message throughput
-     */
-    testThroughput: (messageCount?: number, messageSize?: number) => Promise<{
-        messagesPerSecond: number;
-        totalTime: number;
-        averageLatency: number;
-    }>;
-    /**
-     * Test concurrent connections
-     */
-    testConcurrentConnections: (connectionCount?: number) => Promise<{
-        successfulConnections: number;
-        failedConnections: number;
-        averageConnectionTime: number;
-    }>;
-};
-/**
- * Factory functions
- */
-export declare function createWebSocketTester(): WebSocketTester;
-export declare function createMockServerWebSocket(data?: any): MockServerWebSocket;
-/**
- * WebSocket test utilities
- */
-export declare const wsTestUtils: {
-    /**
-     * Create multiple connected clients
-     */
-    createClients: (count: number) => WebSocketTester[];
-    /**
-     * Simulate network latency
-     */
-    withLatency: (tester: WebSocketTester, latencyMs: number) => WebSocketTester;
-    /**
-     * Simulate packet loss
-     */
-    withPacketLoss: (tester: WebSocketTester, lossRate: number) => WebSocketTester;
-    /**
-     * Create message generator
-     */
-    messageGenerator(count: number, prefix?: string): Generator<string>;
-};