780 lines
21 KiB
TypeScript
780 lines
21 KiB
TypeScript
import { Socket } from "./socket";
|
||
import type { Server } from "./index";
|
||
import {
|
||
EventParams,
|
||
EventNames,
|
||
EventsMap,
|
||
StrictEventEmitter,
|
||
DefaultEventsMap,
|
||
DecorateAcknowledgementsWithTimeoutAndMultipleResponses,
|
||
AllButLast,
|
||
Last,
|
||
FirstArg,
|
||
SecondArg,
|
||
} from "./typed-events";
|
||
import type { Client } from "./client";
|
||
// import debugModule from "debug"
|
||
import type { Adapter, Room, SocketId } from "../socket.io-adapter";
|
||
import { BroadcastOperator } from "./broadcast-operator";
|
||
|
||
const debug = require("../debug")("socket.io:namespace");
|
||
|
||
export interface ExtendedError extends Error {
|
||
data?: any;
|
||
}
|
||
|
||
export interface NamespaceReservedEventsMap<
|
||
ListenEvents extends EventsMap,
|
||
EmitEvents extends EventsMap,
|
||
ServerSideEvents extends EventsMap,
|
||
SocketData
|
||
> {
|
||
connect: (
|
||
socket: Socket<ListenEvents, EmitEvents, ServerSideEvents, SocketData>
|
||
) => void;
|
||
connection: (
|
||
socket: Socket<ListenEvents, EmitEvents, ServerSideEvents, SocketData>
|
||
) => void;
|
||
}
|
||
|
||
export interface ServerReservedEventsMap<
|
||
ListenEvents extends EventsMap,
|
||
EmitEvents extends EventsMap,
|
||
ServerSideEvents extends EventsMap,
|
||
SocketData
|
||
> extends NamespaceReservedEventsMap<
|
||
ListenEvents,
|
||
EmitEvents,
|
||
ServerSideEvents,
|
||
SocketData
|
||
> {
|
||
new_namespace: (
|
||
namespace: Namespace<ListenEvents, EmitEvents, ServerSideEvents, SocketData>
|
||
) => void;
|
||
}
|
||
|
||
export const RESERVED_EVENTS: ReadonlySet<string | Symbol> = new Set<
|
||
keyof ServerReservedEventsMap<never, never, never, never>
|
||
>(<const>["connect", "connection", "new_namespace"]);
|
||
|
||
/**
|
||
* A Namespace is a communication channel that allows you to split the logic of your application over a single shared
|
||
* connection.
|
||
*
|
||
* Each namespace has its own:
|
||
*
|
||
* - event handlers
|
||
*
|
||
* ```
|
||
* io.of("/orders").on("connection", (socket) => {
|
||
* socket.on("order:list", () => {});
|
||
* socket.on("order:create", () => {});
|
||
* });
|
||
*
|
||
* io.of("/users").on("connection", (socket) => {
|
||
* socket.on("user:list", () => {});
|
||
* });
|
||
* ```
|
||
*
|
||
* - rooms
|
||
*
|
||
* ```
|
||
* const orderNamespace = io.of("/orders");
|
||
*
|
||
* orderNamespace.on("connection", (socket) => {
|
||
* socket.join("room1");
|
||
* orderNamespace.to("room1").emit("hello");
|
||
* });
|
||
*
|
||
* const userNamespace = io.of("/users");
|
||
*
|
||
* userNamespace.on("connection", (socket) => {
|
||
* socket.join("room1"); // distinct from the room in the "orders" namespace
|
||
* userNamespace.to("room1").emit("holà");
|
||
* });
|
||
* ```
|
||
*
|
||
* - middlewares
|
||
*
|
||
* ```
|
||
* const orderNamespace = io.of("/orders");
|
||
*
|
||
* orderNamespace.use((socket, next) => {
|
||
* // ensure the socket has access to the "orders" namespace
|
||
* });
|
||
*
|
||
* const userNamespace = io.of("/users");
|
||
*
|
||
* userNamespace.use((socket, next) => {
|
||
* // ensure the socket has access to the "users" namespace
|
||
* });
|
||
* ```
|
||
*/
|
||
export class Namespace<
|
||
ListenEvents extends EventsMap = DefaultEventsMap,
|
||
EmitEvents extends EventsMap = ListenEvents,
|
||
ServerSideEvents extends EventsMap = DefaultEventsMap,
|
||
SocketData = any
|
||
> extends StrictEventEmitter<
|
||
ServerSideEvents,
|
||
EmitEvents,
|
||
NamespaceReservedEventsMap<
|
||
ListenEvents,
|
||
EmitEvents,
|
||
ServerSideEvents,
|
||
SocketData
|
||
>
|
||
> {
|
||
public readonly name: string;
|
||
public readonly sockets: Map<
|
||
SocketId,
|
||
Socket<ListenEvents, EmitEvents, ServerSideEvents, SocketData>
|
||
> = new Map();
|
||
|
||
public adapter: Adapter;
|
||
|
||
/** @private */
|
||
readonly server: Server<
|
||
ListenEvents,
|
||
EmitEvents,
|
||
ServerSideEvents,
|
||
SocketData
|
||
>;
|
||
|
||
/** @private */
|
||
_fns: Array<
|
||
(
|
||
socket: Socket<ListenEvents, EmitEvents, ServerSideEvents, SocketData>,
|
||
next: (err?: ExtendedError) => void
|
||
) => void
|
||
> = [];
|
||
|
||
/** @private */
|
||
_ids: number = 0;
|
||
|
||
/**
|
||
* Namespace constructor.
|
||
*
|
||
* @param server instance
|
||
* @param name
|
||
*/
|
||
constructor(
|
||
server: Server<ListenEvents, EmitEvents, ServerSideEvents, SocketData>,
|
||
name: string
|
||
) {
|
||
super();
|
||
this.server = server;
|
||
this.name = name;
|
||
this._initAdapter();
|
||
}
|
||
|
||
/**
|
||
* Initializes the `Adapter` for this nsp.
|
||
* Run upon changing adapter by `Server#adapter`
|
||
* in addition to the constructor.
|
||
*
|
||
* @private
|
||
*/
|
||
_initAdapter(): void {
|
||
// @ts-ignore
|
||
this.adapter = new (this.server.adapter()!)(this);
|
||
}
|
||
|
||
/**
|
||
* Registers a middleware, which is a function that gets executed for every incoming {@link Socket}.
|
||
*
|
||
* @example
|
||
* const myNamespace = io.of("/my-namespace");
|
||
*
|
||
* myNamespace.use((socket, next) => {
|
||
* // ...
|
||
* next();
|
||
* });
|
||
*
|
||
* @param fn - the middleware function
|
||
*/
|
||
public use(
|
||
fn: (
|
||
socket: Socket<ListenEvents, EmitEvents, ServerSideEvents, SocketData>,
|
||
next: (err?: ExtendedError) => void
|
||
) => void
|
||
): this {
|
||
this._fns.push(fn);
|
||
return this;
|
||
}
|
||
|
||
/**
|
||
* Executes the middleware for an incoming client.
|
||
*
|
||
* @param socket - the socket that will get added
|
||
* @param fn - last fn call in the middleware
|
||
* @private
|
||
*/
|
||
private run(
|
||
socket: Socket<ListenEvents, EmitEvents, ServerSideEvents, SocketData>,
|
||
fn: (err: ExtendedError | null) => void
|
||
) {
|
||
const fns = this._fns.slice(0);
|
||
if (!fns.length) return fn(null);
|
||
|
||
function run(i: number) {
|
||
fns[i](socket, function (err) {
|
||
// upon error, short-circuit
|
||
if (err) return fn(err);
|
||
|
||
// if no middleware left, summon callback
|
||
if (!fns[i + 1]) return fn(null);
|
||
|
||
// go on to next
|
||
run(i + 1);
|
||
});
|
||
}
|
||
|
||
run(0);
|
||
}
|
||
|
||
/**
|
||
* Targets a room when emitting.
|
||
*
|
||
* @example
|
||
* const myNamespace = io.of("/my-namespace");
|
||
*
|
||
* // the “foo” event will be broadcast to all connected clients in the “room-101” room
|
||
* myNamespace.to("room-101").emit("foo", "bar");
|
||
*
|
||
* // with an array of rooms (a client will be notified at most once)
|
||
* myNamespace.to(["room-101", "room-102"]).emit("foo", "bar");
|
||
*
|
||
* // with multiple chained calls
|
||
* myNamespace.to("room-101").to("room-102").emit("foo", "bar");
|
||
*
|
||
* @param room - a room, or an array of rooms
|
||
* @return a new {@link BroadcastOperator} instance for chaining
|
||
*/
|
||
public to(room: Room | Room[]) {
|
||
return new BroadcastOperator<EmitEvents, SocketData>(this.adapter).to(room);
|
||
}
|
||
|
||
/**
|
||
* Targets a room when emitting. Similar to `to()`, but might feel clearer in some cases:
|
||
*
|
||
* @example
|
||
* const myNamespace = io.of("/my-namespace");
|
||
*
|
||
* // disconnect all clients in the "room-101" room
|
||
* myNamespace.in("room-101").disconnectSockets();
|
||
*
|
||
* @param room - a room, or an array of rooms
|
||
* @return a new {@link BroadcastOperator} instance for chaining
|
||
*/
|
||
public in(room: Room | Room[]) {
|
||
return new BroadcastOperator<EmitEvents, SocketData>(this.adapter).in(room);
|
||
}
|
||
|
||
/**
|
||
* Excludes a room when emitting.
|
||
*
|
||
* @example
|
||
* const myNamespace = io.of("/my-namespace");
|
||
*
|
||
* // the "foo" event will be broadcast to all connected clients, except the ones that are in the "room-101" room
|
||
* myNamespace.except("room-101").emit("foo", "bar");
|
||
*
|
||
* // with an array of rooms
|
||
* myNamespace.except(["room-101", "room-102"]).emit("foo", "bar");
|
||
*
|
||
* // with multiple chained calls
|
||
* myNamespace.except("room-101").except("room-102").emit("foo", "bar");
|
||
*
|
||
* @param room - a room, or an array of rooms
|
||
* @return a new {@link BroadcastOperator} instance for chaining
|
||
*/
|
||
public except(room: Room | Room[]) {
|
||
return new BroadcastOperator<EmitEvents, SocketData>(this.adapter).except(
|
||
room
|
||
);
|
||
}
|
||
|
||
/**
|
||
* Adds a new client.
|
||
*
|
||
* @return {Socket}
|
||
* @private
|
||
*/
|
||
// @java-patch sync
|
||
_add(
|
||
client: Client<ListenEvents, EmitEvents, ServerSideEvents>,
|
||
auth: Record<string, unknown>,
|
||
fn: (
|
||
socket: Socket<ListenEvents, EmitEvents, ServerSideEvents, SocketData>
|
||
) => void
|
||
) {
|
||
debug("adding socket to nsp %s", this.name);
|
||
const socket = this._createSocket(client, auth);
|
||
|
||
if (
|
||
// @ts-ignore
|
||
this.server.opts.connectionStateRecovery?.skipMiddlewares &&
|
||
socket.recovered &&
|
||
client.conn.readyState === "open"
|
||
) {
|
||
return this._doConnect(socket, fn);
|
||
}
|
||
|
||
this.run(socket, (err) => {
|
||
process.nextTick(() => {
|
||
if ("open" !== client.conn.readyState) {
|
||
debug("next called after client was closed - ignoring socket");
|
||
socket._cleanup();
|
||
return;
|
||
}
|
||
|
||
if (err) {
|
||
debug("middleware error, sending CONNECT_ERROR packet to the client");
|
||
socket._cleanup();
|
||
if (client.conn.protocol === 3) {
|
||
return socket._error(err.data || err.message);
|
||
} else {
|
||
return socket._error({
|
||
message: err.message,
|
||
data: err.data,
|
||
});
|
||
}
|
||
}
|
||
|
||
this._doConnect(socket, fn);
|
||
});
|
||
});
|
||
}
|
||
|
||
// @java-patch sync
|
||
private _createSocket(
|
||
client: Client<ListenEvents, EmitEvents, ServerSideEvents>,
|
||
auth: Record<string, unknown>
|
||
) {
|
||
const sessionId = auth.pid;
|
||
const offset = auth.offset;
|
||
if (
|
||
// @ts-ignore
|
||
this.server.opts.connectionStateRecovery &&
|
||
typeof sessionId === "string" &&
|
||
typeof offset === "string"
|
||
) {
|
||
const session = this.adapter.restoreSession(sessionId, offset);
|
||
if (session) {
|
||
debug("connection state recovered for sid %s", session.sid);
|
||
return new Socket(this, client, auth, session);
|
||
} else {
|
||
debug("unable to restore session state");
|
||
}
|
||
}
|
||
return new Socket(this, client, auth);
|
||
}
|
||
|
||
private _doConnect(
|
||
socket: Socket<ListenEvents, EmitEvents, ServerSideEvents, SocketData>,
|
||
fn: (
|
||
socket: Socket<ListenEvents, EmitEvents, ServerSideEvents, SocketData>
|
||
) => void
|
||
) {
|
||
// track socket
|
||
this.sockets.set(socket.id, socket);
|
||
|
||
// it's paramount that the internal `onconnect` logic
|
||
// fires before user-set events to prevent state order
|
||
// violations (such as a disconnection before the connection
|
||
// logic is complete)
|
||
socket._onconnect();
|
||
if (fn) fn(socket);
|
||
|
||
// fire user-set events
|
||
this.emitReserved("connect", socket);
|
||
this.emitReserved("connection", socket);
|
||
}
|
||
|
||
/**
|
||
* Removes a client. Called by each `Socket`.
|
||
*
|
||
* @private
|
||
*/
|
||
_remove(
|
||
socket: Socket<ListenEvents, EmitEvents, ServerSideEvents, SocketData>
|
||
): void {
|
||
if (this.sockets.has(socket.id)) {
|
||
this.sockets.delete(socket.id);
|
||
} else {
|
||
debug("ignoring remove for %s", socket.id);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Emits to all connected clients.
|
||
*
|
||
* @example
|
||
* const myNamespace = io.of("/my-namespace");
|
||
*
|
||
* myNamespace.emit("hello", "world");
|
||
*
|
||
* // all serializable datastructures are supported (no need to call JSON.stringify)
|
||
* myNamespace.emit("hello", 1, "2", { 3: ["4"], 5: Uint8Array.from([6]) });
|
||
*
|
||
* // with an acknowledgement from the clients
|
||
* myNamespace.timeout(1000).emit("some-event", (err, responses) => {
|
||
* if (err) {
|
||
* // some clients did not acknowledge the event in the given delay
|
||
* } else {
|
||
* console.log(responses); // one response per client
|
||
* }
|
||
* });
|
||
*
|
||
* @return Always true
|
||
*/
|
||
public emit<Ev extends EventNames<EmitEvents>>(
|
||
ev: Ev,
|
||
...args: EventParams<EmitEvents, Ev>
|
||
): boolean {
|
||
return new BroadcastOperator<EmitEvents, SocketData>(this.adapter).emit(
|
||
ev,
|
||
...args
|
||
);
|
||
}
|
||
|
||
/**
|
||
* Emits an event and waits for an acknowledgement from all clients.
|
||
*
|
||
* @example
|
||
* const myNamespace = io.of("/my-namespace");
|
||
*
|
||
* try {
|
||
* const responses = await myNamespace.timeout(1000).emitWithAck("some-event");
|
||
* console.log(responses); // one response per client
|
||
* } catch (e) {
|
||
* // some clients did not acknowledge the event in the given delay
|
||
* }
|
||
*
|
||
* @return a Promise that will be fulfilled when all clients have acknowledged the event
|
||
*/
|
||
public emitWithAck<Ev extends EventNames<EmitEvents>>(
|
||
ev: Ev,
|
||
...args: AllButLast<EventParams<EmitEvents, Ev>>
|
||
): Promise<SecondArg<Last<EventParams<EmitEvents, Ev>>>> {
|
||
return new BroadcastOperator<EmitEvents, SocketData>(
|
||
this.adapter
|
||
).emitWithAck(ev, ...args);
|
||
}
|
||
|
||
/**
|
||
* Sends a `message` event to all clients.
|
||
*
|
||
* This method mimics the WebSocket.send() method.
|
||
*
|
||
* @see https://developer.mozilla.org/en-US/docs/Web/API/WebSocket/send
|
||
*
|
||
* @example
|
||
* const myNamespace = io.of("/my-namespace");
|
||
*
|
||
* myNamespace.send("hello");
|
||
*
|
||
* // this is equivalent to
|
||
* myNamespace.emit("message", "hello");
|
||
*
|
||
* @return self
|
||
*/
|
||
public send(...args: EventParams<EmitEvents, "message">): this {
|
||
this.emit("message", ...args);
|
||
return this;
|
||
}
|
||
|
||
/**
|
||
* Sends a `message` event to all clients. Sends a `message` event. Alias of {@link send}.
|
||
*
|
||
* @return self
|
||
*/
|
||
public write(...args: EventParams<EmitEvents, "message">): this {
|
||
this.emit("message", ...args);
|
||
return this;
|
||
}
|
||
|
||
/**
|
||
* Sends a message to the other Socket.IO servers of the cluster.
|
||
*
|
||
* @example
|
||
* const myNamespace = io.of("/my-namespace");
|
||
*
|
||
* myNamespace.serverSideEmit("hello", "world");
|
||
*
|
||
* myNamespace.on("hello", (arg1) => {
|
||
* console.log(arg1); // prints "world"
|
||
* });
|
||
*
|
||
* // acknowledgements (without binary content) are supported too:
|
||
* myNamespace.serverSideEmit("ping", (err, responses) => {
|
||
* if (err) {
|
||
* // some servers did not acknowledge the event in the given delay
|
||
* } else {
|
||
* console.log(responses); // one response per server (except the current one)
|
||
* }
|
||
* });
|
||
*
|
||
* myNamespace.on("ping", (cb) => {
|
||
* cb("pong");
|
||
* });
|
||
*
|
||
* @param ev - the event name
|
||
* @param args - an array of arguments, which may include an acknowledgement callback at the end
|
||
*/
|
||
public serverSideEmit<Ev extends EventNames<ServerSideEvents>>(
|
||
ev: Ev,
|
||
...args: EventParams<
|
||
DecorateAcknowledgementsWithTimeoutAndMultipleResponses<ServerSideEvents>,
|
||
Ev
|
||
>
|
||
): boolean {
|
||
if (RESERVED_EVENTS.has(ev)) {
|
||
throw new Error(`"${String(ev)}" is a reserved event name`);
|
||
}
|
||
args.unshift(ev);
|
||
this.adapter.serverSideEmit(args);
|
||
return true;
|
||
}
|
||
|
||
/**
|
||
* Sends a message and expect an acknowledgement from the other Socket.IO servers of the cluster.
|
||
*
|
||
* @example
|
||
* const myNamespace = io.of("/my-namespace");
|
||
*
|
||
* try {
|
||
* const responses = await myNamespace.serverSideEmitWithAck("ping");
|
||
* console.log(responses); // one response per server (except the current one)
|
||
* } catch (e) {
|
||
* // some servers did not acknowledge the event in the given delay
|
||
* }
|
||
*
|
||
* @param ev - the event name
|
||
* @param args - an array of arguments
|
||
*
|
||
* @return a Promise that will be fulfilled when all servers have acknowledged the event
|
||
*/
|
||
public serverSideEmitWithAck<Ev extends EventNames<ServerSideEvents>>(
|
||
ev: Ev,
|
||
...args: AllButLast<EventParams<ServerSideEvents, Ev>>
|
||
): Promise<FirstArg<Last<EventParams<ServerSideEvents, Ev>>>[]> {
|
||
return new Promise((resolve, reject) => {
|
||
args.push((err, responses) => {
|
||
if (err) {
|
||
err.responses = responses;
|
||
return reject(err);
|
||
} else {
|
||
return resolve(responses);
|
||
}
|
||
});
|
||
this.serverSideEmit(
|
||
ev,
|
||
...(args as any[] as EventParams<ServerSideEvents, Ev>)
|
||
);
|
||
});
|
||
}
|
||
|
||
/**
|
||
* Called when a packet is received from another Socket.IO server
|
||
*
|
||
* @param args - an array of arguments, which may include an acknowledgement callback at the end
|
||
*
|
||
* @private
|
||
*/
|
||
_onServerSideEmit(args: [string, ...any[]]) {
|
||
super.emitUntyped.apply(this, args);
|
||
}
|
||
|
||
/**
|
||
* Gets a list of clients.
|
||
*
|
||
* @deprecated this method will be removed in the next major release, please use {@link Namespace#serverSideEmit} or
|
||
* {@link Namespace#fetchSockets} instead.
|
||
*/
|
||
public allSockets(): Promise<Set<SocketId>> {
|
||
return new BroadcastOperator<EmitEvents, SocketData>(
|
||
this.adapter
|
||
).allSockets();
|
||
}
|
||
|
||
/**
|
||
* Sets the compress flag.
|
||
*
|
||
* @example
|
||
* const myNamespace = io.of("/my-namespace");
|
||
*
|
||
* myNamespace.compress(false).emit("hello");
|
||
*
|
||
* @param compress - if `true`, compresses the sending data
|
||
* @return self
|
||
*/
|
||
public compress(compress: boolean) {
|
||
return new BroadcastOperator<EmitEvents, SocketData>(this.adapter).compress(
|
||
compress
|
||
);
|
||
}
|
||
|
||
/**
|
||
* Sets a modifier for a subsequent event emission that the event data may be lost if the client is not ready to
|
||
* receive messages (because of network slowness or other issues, or because they’re connected through long polling
|
||
* and is in the middle of a request-response cycle).
|
||
*
|
||
* @example
|
||
* const myNamespace = io.of("/my-namespace");
|
||
*
|
||
* myNamespace.volatile.emit("hello"); // the clients may or may not receive it
|
||
*
|
||
* @return self
|
||
*/
|
||
public get volatile() {
|
||
return new BroadcastOperator<EmitEvents, SocketData>(this.adapter).volatile;
|
||
}
|
||
|
||
/**
|
||
* Sets a modifier for a subsequent event emission that the event data will only be broadcast to the current node.
|
||
*
|
||
* @example
|
||
* const myNamespace = io.of("/my-namespace");
|
||
*
|
||
* // the “foo” event will be broadcast to all connected clients on this node
|
||
* myNamespace.local.emit("foo", "bar");
|
||
*
|
||
* @return a new {@link BroadcastOperator} instance for chaining
|
||
*/
|
||
public get local() {
|
||
return new BroadcastOperator<EmitEvents, SocketData>(this.adapter).local;
|
||
}
|
||
|
||
/**
|
||
* Adds a timeout in milliseconds for the next operation.
|
||
*
|
||
* @example
|
||
* const myNamespace = io.of("/my-namespace");
|
||
*
|
||
* myNamespace.timeout(1000).emit("some-event", (err, responses) => {
|
||
* if (err) {
|
||
* // some clients did not acknowledge the event in the given delay
|
||
* } else {
|
||
* console.log(responses); // one response per client
|
||
* }
|
||
* });
|
||
*
|
||
* @param timeout
|
||
*/
|
||
public timeout(timeout: number) {
|
||
return new BroadcastOperator<EmitEvents, SocketData>(this.adapter).timeout(
|
||
timeout
|
||
);
|
||
}
|
||
|
||
/**
|
||
* Returns the matching socket instances.
|
||
*
|
||
* Note: this method also works within a cluster of multiple Socket.IO servers, with a compatible {@link Adapter}.
|
||
*
|
||
* @example
|
||
* const myNamespace = io.of("/my-namespace");
|
||
*
|
||
* // return all Socket instances
|
||
* const sockets = await myNamespace.fetchSockets();
|
||
*
|
||
* // return all Socket instances in the "room1" room
|
||
* const sockets = await myNamespace.in("room1").fetchSockets();
|
||
*
|
||
* for (const socket of sockets) {
|
||
* console.log(socket.id);
|
||
* console.log(socket.handshake);
|
||
* console.log(socket.rooms);
|
||
* console.log(socket.data);
|
||
*
|
||
* socket.emit("hello");
|
||
* socket.join("room1");
|
||
* socket.leave("room2");
|
||
* socket.disconnect();
|
||
* }
|
||
*/
|
||
public fetchSockets() {
|
||
return new BroadcastOperator<EmitEvents, SocketData>(
|
||
this.adapter
|
||
).fetchSockets();
|
||
}
|
||
|
||
/**
|
||
* Makes the matching socket instances join the specified rooms.
|
||
*
|
||
* Note: this method also works within a cluster of multiple Socket.IO servers, with a compatible {@link Adapter}.
|
||
*
|
||
* @example
|
||
* const myNamespace = io.of("/my-namespace");
|
||
*
|
||
* // make all socket instances join the "room1" room
|
||
* myNamespace.socketsJoin("room1");
|
||
*
|
||
* // make all socket instances in the "room1" room join the "room2" and "room3" rooms
|
||
* myNamespace.in("room1").socketsJoin(["room2", "room3"]);
|
||
*
|
||
* @param room - a room, or an array of rooms
|
||
*/
|
||
public socketsJoin(room: Room | Room[]) {
|
||
return new BroadcastOperator<EmitEvents, SocketData>(
|
||
this.adapter
|
||
).socketsJoin(room);
|
||
}
|
||
|
||
/**
|
||
* Makes the matching socket instances leave the specified rooms.
|
||
*
|
||
* Note: this method also works within a cluster of multiple Socket.IO servers, with a compatible {@link Adapter}.
|
||
*
|
||
* @example
|
||
* const myNamespace = io.of("/my-namespace");
|
||
*
|
||
* // make all socket instances leave the "room1" room
|
||
* myNamespace.socketsLeave("room1");
|
||
*
|
||
* // make all socket instances in the "room1" room leave the "room2" and "room3" rooms
|
||
* myNamespace.in("room1").socketsLeave(["room2", "room3"]);
|
||
*
|
||
* @param room - a room, or an array of rooms
|
||
*/
|
||
public socketsLeave(room: Room | Room[]) {
|
||
return new BroadcastOperator<EmitEvents, SocketData>(
|
||
this.adapter
|
||
).socketsLeave(room);
|
||
}
|
||
|
||
/**
|
||
* Makes the matching socket instances disconnect.
|
||
*
|
||
* Note: this method also works within a cluster of multiple Socket.IO servers, with a compatible {@link Adapter}.
|
||
*
|
||
* @example
|
||
* const myNamespace = io.of("/my-namespace");
|
||
*
|
||
* // make all socket instances disconnect (the connections might be kept alive for other namespaces)
|
||
* myNamespace.disconnectSockets();
|
||
*
|
||
* // make all socket instances in the "room1" room disconnect and close the underlying connections
|
||
* myNamespace.in("room1").disconnectSockets(true);
|
||
*
|
||
* @param close - whether to close the underlying connection
|
||
*/
|
||
public disconnectSockets(close: boolean = false) {
|
||
return new BroadcastOperator<EmitEvents, SocketData>(
|
||
this.adapter
|
||
).disconnectSockets(close);
|
||
}
|
||
|
||
// @java-patch
|
||
public close() {
|
||
RESERVED_EVENTS.forEach((event) => this.removeAllListeners(event as any));
|
||
this.server._nsps.delete(this.name);
|
||
// @java-patch close all socket when namespace close
|
||
this.sockets.forEach((socket) =>
|
||
socket._onclose(`namepsace ${this.name} close` as any)
|
||
);
|
||
}
|
||
}
|