@socket-mesh/server 17.3.1

package/serversocket.d.ts

@@ -0,0 +1,181 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { ChannelOptions } from "@socket-mesh/channel";
+import { AuthState, AuthToken, SignedAuthToken } from "@socket-mesh/auth";
+import { AuthTokenOptions } from "@socket-mesh/server-auth";
+import { WritableConsumableStream } from "@socket-mesh/writable-consumable-stream";
+import { AsyncStreamEmitter } from "@socket-mesh/async-stream-emitter";
+import { DemuxedConsumableStream, StreamDemuxWrapper } from "@socket-mesh/stream-demux";
+import { IncomingMessage } from 'http';
+import { SocketState } from "./socket-state";
+import { AuthInfo } from "./action";
+import { AuthStateChanged, AuthTokenSigned, Authenticated, BadAuthToken, Closed, ConnectAborted, Connected, Deauthenticated, Disconnected, ErrorOccurred, RawMessage, ServerSocketEvents, Subscribed, Unsubscribed } from './events';
+import { MiddlewareStream } from './middleware-stream';
+import { ProtocolVersions } from './server-options';
+import ws from "ws";
+import { Server } from "./server";
+import { OutboundPacket, OutboundPacketOptions } from './outbound-packet';
+import { InboundRequest } from './request';
+export type WebSocket = ws.WebSocket & {
+    bytesReceived: number;
+    upgradeReq: IncomingMessage;
+};
+interface SendOptions {
+    mask?: boolean;
+    binary?: boolean;
+    compress?: boolean;
+    fin?: boolean;
+}
+interface EventObject {
+    event: string;
+    data?: any;
+    cid?: number;
+}
+export declare class ServerSocket<T> extends AsyncStreamEmitter<ServerSocketEvents> {
+    authState: AuthState;
+    authToken: AuthToken | null;
+    batchInterval: number;
+    batchOnHandshake: boolean;
+    batchOnHandshakeDuration: number;
+    cloneData: boolean;
+    channelSubscriptionsCount: number;
+    inboundReceivedMessageCount: number;
+    inboundProcessedMessageCount: number;
+    isBatching: boolean;
+    isBufferingBatch: boolean;
+    request: IncomingMessage;
+    readonly id: string;
+    readonly socket: WebSocket;
+    readonly protocolVersion: ProtocolVersions;
+    readonly channelSubscriptions: {
+        [channel: string]: boolean;
+    };
+    readonly inboundMessageStream: WritableConsumableStream<string | ArrayBuffer | Buffer[]>;
+    readonly outboundPacketStream: WritableConsumableStream<OutboundPacket<T>>;
+    readonly server: Server<T>;
+    readonly middlewareHandshakeStream: MiddlewareStream<void>;
+    readonly middlewareInboundRawStream: MiddlewareStream<string | ArrayBuffer | Buffer[]>;
+    readonly middlewareInboundStream: MiddlewareStream<ChannelOptions | T | void>;
+    readonly middlewareOutboundStream: MiddlewareStream<T>;
+    readonly remoteAddress?: string;
+    readonly remoteFamily?: string;
+    readonly remotePort?: number;
+    outboundPreparedMessageCount: number;
+    outboundSentMessageCount: number;
+    signedAuthToken: SignedAuthToken | null;
+    state: SocketState;
+    readonly receiver: StreamDemuxWrapper<string | void | T | ArrayBuffer | Buffer[] | AuthInfo | ChannelOptions>;
+    readonly procedure: StreamDemuxWrapper<InboundRequest<T>>;
+    private _cid;
+    private _handshakeTimeoutRef;
+    private _pingIntervalTicker;
+    private _pingTimeoutTicker;
+    private _batchBuffer;
+    private _batchingIntervalId;
+    private _callbackMap;
+    private readonly _receiverDemux;
+    private readonly _procedureDemux;
+    private readonly _sendPing;
+    constructor(id: string, server: Server<T>, socket: WebSocket, protocolVersion: ProtocolVersions);
+    getBackpressure(): number;
+    getInboundBackpressure(): number;
+    getOutboundBackpressure(): number;
+    private _startBatchOnHandshake;
+    private _handleInboundMessageStream;
+    private _handleHandshakeTimeout;
+    private _processHandshakeRequest;
+    private _processAuthenticateRequest;
+    private _subscribeSocket;
+    private _processSubscribeRequest;
+    private _unsubscribeFromAllChannels;
+    private _unsubscribe;
+    private _processUnsubscribePacket;
+    private _processUnsubscribeRequest;
+    private _processInboundPublishPacket;
+    private _processInboundPublishRequest;
+    private _processInboundPacket;
+    private _resetPongTimeout;
+    private _nextCallId;
+    getState(): SocketState;
+    getBytesReceived(): number;
+    emitError(error: Error): void;
+    private _abortAllPendingEventsDueToBadConnection;
+    closeAllMiddlewares(): void;
+    closeInput(): void;
+    closeOutput(): void;
+    closeIO(): void;
+    closeAllStreams(): void;
+    killAllMiddlewares(): void;
+    killInput(): void;
+    killOutput(): void;
+    killIO(): void;
+    killAllStreams(): void;
+    private _destroy;
+    disconnect(code: number, reason?: string): void;
+    terminate(): void;
+    send(data: string, options?: SendOptions): void;
+    decode(message: string): any;
+    encode(object: any): string;
+    startBatch(): void;
+    flushBatch(): void;
+    cancelBatch(): void;
+    private _startBatching;
+    startBatching(): void;
+    private _stopBatching;
+    stopBatching(): void;
+    private _cancelBatching;
+    cancelBatching(): void;
+    serializeObject(object: any): string | null;
+    sendObject(object: EventObject): void;
+    private _handleOutboundPacketStream;
+    private _transmit;
+    transmit(event: string, data: any, options?: OutboundPacketOptions): void;
+    invoke(event: string, data?: any, options?: OutboundPacketOptions): Promise<unknown>;
+    emit(eventName: 'message' | 'raw', data: RawMessage): void;
+    emit(eventName: 'error', data: ErrorOccurred): void;
+    emit(eventName: 'authStateChange', data: AuthStateChanged): void;
+    emit(eventName: 'authenticate', data: Authenticated): void;
+    emit(eventName: 'authTokenSigned', data: AuthTokenSigned): void;
+    emit(eventName: 'deauthenticate', data: Deauthenticated): void;
+    emit(eventName: 'badAuthToken', data: BadAuthToken): void;
+    emit(eventName: 'connect', data: Connected): void;
+    emit(eventName: 'subscribe', data: Subscribed): void;
+    emit(eventName: 'unsubscribe', data: Unsubscribed): void;
+    emit(eventName: 'connectAbort', data: ConnectAborted): void;
+    emit(eventName: 'disconnect', data: Disconnected): void;
+    emit(eventName: 'close', data: Closed): void;
+    emit(eventName: 'end'): void;
+    listen(eventName: 'message' | 'raw'): DemuxedConsumableStream<RawMessage>;
+    listen(eventName: 'error'): DemuxedConsumableStream<ErrorOccurred>;
+    listen(eventName: 'authStateChange'): DemuxedConsumableStream<AuthStateChanged>;
+    listen(eventName: 'authenticate'): DemuxedConsumableStream<Authenticated>;
+    listen(eventName: 'authTokenSigned'): DemuxedConsumableStream<AuthTokenSigned>;
+    listen(eventName: 'deauthenticate'): DemuxedConsumableStream<Deauthenticated>;
+    listen(eventName: 'badAuthToken'): DemuxedConsumableStream<BadAuthToken>;
+    listen(eventName: 'connect'): DemuxedConsumableStream<Connected>;
+    listen(eventName: 'subscribe'): DemuxedConsumableStream<Subscribed>;
+    listen(eventName: 'unsubscribe'): DemuxedConsumableStream<Unsubscribed>;
+    listen(eventName: 'connectAbort'): DemuxedConsumableStream<ConnectAborted>;
+    listen(eventName: 'disconnect'): DemuxedConsumableStream<Disconnected>;
+    listen(eventName: 'close'): DemuxedConsumableStream<Closed>;
+    listen(event: 'end'): DemuxedConsumableStream<void>;
+    private _processTransmit;
+    private _invoke;
+    triggerAuthenticationEvents(oldAuthState: AuthState): void;
+    setAuthToken(data: AuthToken, options: AuthTokenOptions): Promise<void>;
+    getAuthToken(): AuthToken | null;
+    deauthenticateSelf(): void;
+    deauthenticate(options?: {
+        rejectOnFailedDelivery: boolean;
+    }): Promise<void>;
+    kickOut(channel: string, message: string): Promise<void[]>;
+    subscriptions(): string[];
+    isSubscribed(channel: string): boolean;
+    private _processAuthTokenExpiry;
+    isAuthTokenExpired(token: AuthToken | null): boolean;
+    private _processTokenError;
+    private _emitBadAuthTokenError;
+    private _validateAuthToken;
+    private _processAuthentication;
+}
+export {};