@nestjs/websockets

constructor

constructor(appOrHttpServer?: any);

property forceCloseConnections

forceCloseConnections: boolean;

property httpServer

protected readonly httpServer: any;

method bindClientConnect

bindClientConnect: (server: TServer, callback: Function) => void;

method bindClientDisconnect

bindClientDisconnect: (client: TClient, callback: Function) => void;

method bindMessageHandlers

abstract bindMessageHandlers: (
    client: TClient,
    handlers: WsMessageHandler[],
    transform: (data: any) => Observable<any>
) => any;

method close

close: (server: TServer) => Promise<void>;

method create

abstract create: (port: number, options?: TOptions) => TServer;

method dispose

dispose: () => Promise<void>;

constructor

constructor(options?: BaseWsExceptionFilterOptions);

property logger

protected static readonly logger: Logger;

property options

protected readonly options: BaseWsExceptionFilterOptions;

method catch

catch: (exception: TError, host: ArgumentsHost) => void;

method emitMessage

protected emitMessage: <TClient extends { emit?: Function; send?: Function }>(
    client: TClient,
    event: string,
    payload: unknown
) => void;

• Sends an error message to the client. Supports both Socket.IO clients (which use emit) and native WebSocket clients (which use send).

  Native WebSocket clients (e.g. from the ws package) inherit from EventEmitter and therefore also have an emit method, but that method only dispatches events locally. To distinguish native WebSocket clients from Socket.IO clients, we check for a numeric readyState property (part of the WebSocket specification) before falling back to emit.

method handleError

handleError: <TClient extends { emit?: Function; send?: Function }>(
    client: TClient,
    exception: TError,
    cause: ErrorPayload['cause']
) => void;

method handleUnknownError

handleUnknownError: <TClient extends { emit?: Function; send?: Function }>(
    exception: TError,
    client: TClient,
    data: ErrorPayload['cause']
) => void;

method isExceptionObject

isExceptionObject: (err: any) => err is Error;

constructor

constructor(error: string | object);

method getError

getError: () => string | object;

method initMessage

initMessage: () => void;

property close

close: Function;

property on

on: (event: string, callback: Function) => void;

property cause

cause?: Cause;

• Message that caused the exception.

property message

message: string;

• Error message.

property status

status: 'error';

• Error message identifier.

property adapter

adapter?: any;

• The adapter to use the in-memory adapter (https://github.com/socketio/socket.io-adapter)

property allowEIO3

allowEIO3?: boolean;

• Whether to enable compatibility with Socket.IO v2 clients false

property allowRequest

allowRequest?: (
    req: any,
    fn: (err: string | null | undefined, success: boolean) => void
) => void;

• A function that receives a given handshake or upgrade request as its first parameter, and can decide whether to continue or not. The second argument is a function that needs to be called with the decided information: fn(err, success), where success is a boolean value where false means that the request is rejected, and err is an error code.

property allowUpgrades

allowUpgrades?: boolean;

• Whether to allow transport upgrades true

property connectTimeout

connectTimeout?: number;

• How many ms before a client without namespace is closed 45_000

property cookie

cookie?: any;

• Configuration of the cookie that contains the client sid to send as part of handshake response headers. This cookie might be used for sticky-session. Defaults to not sending any cookie. false

property cors

cors?: CorsOptions;

• The options that will be forwarded to the cors module

property destroyUpgrade

destroyUpgrade?: boolean;

• Destroy unhandled upgrade requests true

property destroyUpgradeTimeout

destroyUpgradeTimeout?: number;

• Milliseconds after which unhandled requests are ended 1_000

property httpCompression

httpCompression?: boolean | object;

• Parameters of the http compression for the polling transports (see zlib api docs). Set to false to disable. true

property initialPacket

initialPacket?: any;

• An optional packet which will be concatenated to the handshake packet emitted by Engine.IO.

property maxHttpBufferSize

maxHttpBufferSize?: number;

• How many bytes or characters a message can be, before closing the session (to avoid DoS). 1e6 (1 MB)

property namespace

namespace?: string | RegExp;

• The name of a namespace

property parser

parser?: any;

• The parser to use the default parser (https://github.com/socketio/socket.io-parser)

property path

path?: string;

• Name of the path to capture "/socket.io"

property perMessageDeflate

perMessageDeflate?: boolean | object;

• Parameters of the WebSocket permessage-deflate extension (see ws module api docs). Set to false to disable. false

property pingInterval

pingInterval?: number;

• How many ms before sending a new ping packet 25_000

property pingTimeout

pingTimeout?: number;

• How many ms without a pong packet to consider the connection closed 20_000

property serveClient

serveClient?: boolean;

• Whether to serve the client files true

property transports

transports?: Array<'polling' | 'websocket'>;

• The low-level transports that are enabled ["polling", "websocket"]

property upgradeTimeout

upgradeTimeout?: number;

• How many ms before an uncompleted transport upgrade is cancelled 10_000

property wsEngine

wsEngine?: string;

• What WebSocket server implementation to use. Specified module must conform to the ws interface (see ws module api docs). Default value is ws. An alternative c++ addon is also available by installing uws module.

property callback

callback: (...args: any[]) => Observable<any> | Promise<any>;

property isAckHandledManually

isAckHandledManually: boolean;

property message

message: any;

property methodName

methodName: string;

method handleConnection

handleConnection: (client: T, ...args: any[]) => any;

method handleDisconnect

handleDisconnect: (client: T, reason?: string) => any;

method afterInit

afterInit: (server: T) => any;

property connection

connection: Subject<any>;

property disconnect

disconnect: Subject<any>;

property init

init: ReplaySubject<T>;

property server

server: T;

property namespace

namespace: string;

property port

port: number;

property data

data: T;

property event

event: string;