@pulzar/core/dist/ws/uws-gateway.d.ts

Next-generation Node.js framework for ultra-fast web applications with zero-reflection DI, GraphQL, WebSockets, events, and edge runtime support

import "reflect-metadata";
import { EventEmitter } from "events";
interface WSConnection {
    send(message: string | ArrayBuffer, isBinary?: boolean, compress?: boolean): number;
    end(code?: number, shortMessage?: string | ArrayBuffer): void;
    close(): void;
    getBufferedAmount(): number;
    subscribe(topic: string): boolean;
    unsubscribe(topic: string): boolean;
    isSubscribed(topic: string): boolean;
    getTopics(): string[];
    publish(topic: string, message: string | ArrayBuffer, isBinary?: boolean): boolean;
    getUserData(): any;
}
export interface WSMessage {
    type: string;
    data?: any;
    id?: string;
    timestamp?: number;
}
export interface WSConnectionInfo {
    id: string;
    connectedAt: Date;
    lastActivity: Date;
    subscriptions: Set<string>;
    metadata: Record<string, any>;
    authenticated: boolean;
    userId?: string;
}
export interface WSMiddleware {
    (connection: WSConnectionInfo, message: WSMessage, next: () => void): Promise<void> | void;
}
export interface WSGuard {
    canActivate(connection: WSConnectionInfo, message: WSMessage): Promise<boolean> | boolean;
}
export interface WSPipe<T = any, R = any> {
    transform(value: T, connection: WSConnectionInfo): Promise<R> | R;
}
export interface WSInterceptor {
    intercept(connection: WSConnectionInfo, message: WSMessage, next: () => Promise<any>): Promise<any>;
}
export interface UWSGatewayOptions {
    port?: number;
    host?: string;
    compression?: number;
    maxBackpressure?: number;
    idleTimeout?: number;
    maxPayloadLength?: number;
    enableMetrics?: boolean;
    enableHeartbeat?: boolean;
    heartbeatInterval?: number;
    ssl?: {
        cert: string;
        key: string;
        passphrase?: string;
    };
}
export declare class UWSGateway extends EventEmitter {
    private app;
    private uWS;
    private connections;
    private messageHandlers;
    private middlewares;
    private guards;
    private pipes;
    private interceptors;
    private options;
    private heartbeatTimer?;
    private isListening;
    constructor(options?: Partial<UWSGatewayOptions>);
    /**
     * Initialize uWebSockets.js
     */
    initialize(): Promise<void>;
    /**
     * Load uWebSockets.js dynamically
     */
    private loadUWS;
    private dynamicImportUWS;
    private createMockUWS;
    /**
     * Start listening for WebSocket connections
     */
    listen(): Promise<void>;
    /**
     * Handle WebSocket upgrade
     */
    private handleUpgrade;
    /**
     * Handle new WebSocket connection
     */
    private handleOpen;
    /**
     * Handle WebSocket message
     */
    private handleMessage;
    /**
     * Handle incoming parsed message
     */
    private handleIncomingMessage;
    /**
     * Handle WebSocket connection close
     */
    private handleClose;
    /**
     * Handle WebSocket drain event
     */
    private handleDrain;
    /**
     * Handle ping
     */
    private handlePing;
    /**
     * Handle pong
     */
    private handlePong;
    /**
     * Apply middlewares
     */
    private applyMiddlewares;
    /**
     * Apply guards
     */
    private applyGuards;
    /**
     * Apply pipes
     */
    private applyPipes;
    /**
     * Apply interceptors
     */
    private applyInterceptors;
    /**
     * Send message to WebSocket connection
     */
    sendMessage(ws: WSConnection, message: WSMessage): boolean;
    /**
     * Send error message
     */
    private sendError;
    /**
     * Broadcast message to all connections
     */
    broadcast(message: WSMessage): number;
    /**
     * Publish to topic
     */
    publishToTopic(topic: string, message: WSMessage): boolean;
    /**
     * Register message handler
     */
    registerMessageHandler(type: string, handler: WSMessageHandler): void;
    /**
     * Add middleware
     */
    use(middleware: WSMiddleware): void;
    /**
     * Add guard
     */
    addGuard(guard: WSGuard): void;
    /**
     * Add pipe
     */
    addPipe(pipe: WSPipe): void;
    /**
     * Add interceptor
     */
    addInterceptor(interceptor: WSInterceptor): void;
    /**
     * Start heartbeat timer
     */
    private startHeartbeat;
    /**
     * Handle WebSocket info endpoint
     */
    private handleWSInfo;
    /**
     * Handle WebSocket stats endpoint
     */
    private handleWSStats;
    /**
     * Generate unique connection ID
     */
    private generateConnectionId;
    /**
     * Get connection statistics
     */
    getStats(): {
        isListening: boolean;
        totalConnections: number;
        authenticatedConnections: number;
        messageHandlers: number;
        middlewares: number;
        guards: number;
        pipes: number;
        interceptors: number;
    };
    /**
     * Shutdown gateway
     */
    shutdown(): Promise<void>;
}
/**
 * WebSocket message handler interface
 */
export interface WSMessageHandler {
    handle(connection: WSConnectionInfo, message: WSMessage, ws: WSConnection): Promise<any> | any;
}
/**
 * WebSocket gateway decorator
 */
export declare function WebSocketGateway(options?: Partial<UWSGatewayOptions>): (target: any) => any;
/**
 * WebSocket message handler decorator
 */
export declare function SubscribeMessage(type: string): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
/**
 * WebSocket connection decorator for parameter injection
 */
export declare function ConnectedSocket(): (target: any, propertyKey: string, parameterIndex: number) => void;
/**
 * WebSocket message payload decorator
 */
export declare function MessageBody(): (target: any, propertyKey: string, parameterIndex: number) => void;
export default UWSGateway;
//# sourceMappingURL=uws-gateway.d.ts.map