@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 handleError

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

method handleUnknownError

handleUnknownError: <TClient extends { emit: 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) => 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;