Socket.IO

https://socket.io/docs
Admin
Socket.IO is a library that enables low-latency, bidirectional, and event-based communication...
Tokens:148,126
Snippets:1,561
Trust Score:9.9
Update:3 months ago
Show doc for...
Tokens:
Raw
### Server-side Volatile Event Example Setup

Source: https://socket.io/docs/v4/emitting-events

Server setup to log connection events and listen for 'ping' events. This is part of a volatile event demonstration.

```javascript
io.on("connection", (socket) => {
  console.log("connect");

  socket.on("ping", (count) => {
    console.log(count);
  });
});
```

--------------------------------

### Socket.IO Installation with Tape

Source: https://socket.io/docs/v4/testing

Installs the Tape testing framework as a development dependency using npm.

```bash
npm install --save-dev tape

```

--------------------------------

### Install Redis Emitter and Redis

Source: https://socket.io/docs/v4/redis-adapter

Install the necessary packages for the Redis emitter and the Redis client.

```bash
npm install @socket.io/redis-emitter redis  

```

--------------------------------

### Install Socket.IO Client with Bun

Source: https://socket.io/docs/v4/client-installation

Install the Socket.IO client package using Bun. This command is equivalent to the NPM installation for Bun users.

```bash
bun add socket.io-client
```

--------------------------------

### Install @socket.io/pm2

Source: https://socket.io/docs/v4/pm2

Install the @socket.io/pm2 package globally. If pm2 is already installed, it needs to be removed first.

```bash
npm install -g @socket.io/pm2

```

```bash
npm remove -g pm2

```

--------------------------------

### Install Redis Adapter

Source: https://socket.io/docs/v4/redis-adapter

Install the Redis adapter package using npm.

```bash
npm install @socket.io/redis-adapter  

```

--------------------------------

### Install Socket.IO with Bun

Source: https://socket.io/docs/v4/server-installation

Use this command to install the latest release of Socket.IO using Bun.

```bash
bun add socket.io  
```

--------------------------------

### Socket.IO Server Initialization Examples

Source: https://socket.io/docs/v4/tutorial/introduction

Examples demonstrating how to import the Server class for Socket.IO, supporting both CommonJS and ES modules syntax.

```javascript
const { Server } = require("socket.io");  
```

```javascript
import { Server } from "socket.io";  
```

--------------------------------

### Install Socket.IO and Bun Engine

Source: https://socket.io/docs/v4/server-installation

Install the Socket.IO core package along with the `@socket.io/bun-engine` for Bun-specific optimizations.

```bash
bun add socket.io @socket.io/bun-engine  
```

--------------------------------

### Create Socket.IO Client from Engine.IO Socket

Source: https://socket.io/docs/v4/server-api

This advanced example shows how to manually create a Socket.IO client instance from an incoming Engine.IO socket, typically used in custom server setups.

```javascript
import { Server } from "socket.io";
import { Server as Engine } from "engine.io";

const engine = new Engine();
const io = new Server();

engine.on("connection", (socket) => {
  io.onconnection(socket);
});

engine.listen(3000);

```

--------------------------------

### Configure Redis Adapter with ES Modules

Source: https://socket.io/docs/v4/server-options

Example of setting up the Socket.IO server to use the Redis adapter with ES module syntax. Requires Redis client setup.

```javascript
import { Server } from "socket.io";
import { createAdapter } from "@socket.io/redis-adapter";
import { createClient } from "redis";

const pubClient = createClient({ host: "localhost", port: 6379 });
const subClient = pubClient.duplicate();

const io = new Server({
  adapter: createAdapter(pubClient, subClient)
});

io.listen(3000);

```

--------------------------------

### Setup Socket.IO Server and Client for Testing

Source: https://socket.io/docs/v4/testing

This setup function initializes a Socket.IO server and client, establishing a connection before running tests. It ensures that the server and client are ready for communication.

```javascript
const { beforeAll, afterAll, describe, it, expect } = require("vitest");
const { createServer } = require("node:http");
const { Server } = require("socket.io");
const ioc = require("socket.io-client");

function waitFor(socket, event) {
  return new Promise((resolve) => {
    socket.once(event, resolve);
  });
}

describe("my awesome project", () => {
  let io, serverSocket, clientSocket;

  beforeAll(() => {
    return new Promise((resolve) => {
      const httpServer = createServer();
      io = new Server(httpServer);
      httpServer.listen(() => {
        const port = httpServer.address().port;
        clientSocket = ioc(`http://localhost:${port}`);
        io.on("connection", (socket) => {
          serverSocket = socket;
        });
        clientSocket.on("connect", resolve);
      });
    });
  });

  afterAll(() => {
    io.close();
    clientSocket.disconnect();
  });

  it("should work", () => {
    return new Promise((resolve) => {
      clientSocket.on("hello", (arg) => {
        expect(arg).toEqual("world");
        resolve();
      });
      serverSocket.emit("hello", "world");
    });
  });

  it("should work with an acknowledgement", () => {
    return new Promise((resolve) => {
      serverSocket.on("hi", (cb) => {
        cb("hola");
      });
      clientSocket.emit("hi", (arg) => {
        expect(arg).toEqual("hola");
        resolve();
      });
    });
  });

  it("should work with emitWithAck()", async () => {
    serverSocket.on("foo", (cb) => {
      cb("bar");
    });
    const result = await clientSocket.emitWithAck("foo");
    expect(result).toEqual("bar");
  });

  it("should work with waitFor()", () => {
    clientSocket.emit("baz");

    return waitFor(serverSocket, "baz");
  });
});

```

```javascript
import { beforeAll, afterAll, describe, it, expect } from "vitest";
import { createServer } from "node:http";
import { io as ioc } from "socket.io-client";
import { Server } from "socket.io";

function waitFor(socket, event) {
  return new Promise((resolve) => {
    socket.once(event, resolve);
  });
}

describe("my awesome project", () => {
  let io, serverSocket, clientSocket;

  beforeAll(() => {
    return new Promise((resolve) => {
      const httpServer = createServer();
      io = new Server(httpServer);
      httpServer.listen(() => {
        const port = httpServer.address().port;
        clientSocket = ioc(`http://localhost:${port}`);
        io.on("connection", (socket) => {
          serverSocket = socket;
        });
        clientSocket.on("connect", resolve);
      });
    });
  });

  afterAll(() => {
    io.close();
    clientSocket.disconnect();
  });

  it("should work", () => {
    return new Promise((resolve) => {
      clientSocket.on("hello", (arg) => {
        expect(arg).toEqual("world");
        resolve();
      });
      serverSocket.emit("hello", "world");
    });
  });

  it("should work with an acknowledgement", () => {
    return new Promise((resolve) => {
      serverSocket.on("hi", (cb) => {
        cb("hola");
      });
      clientSocket.emit("hi", (arg) => {
        expect(arg).toEqual("hola");
        resolve();
      });
    });
  });

  it("should work with emitWithAck()", async () => {
    serverSocket.on("foo", (cb) => {
      cb("bar");
    });
    const result = await clientSocket.emitWithAck("foo");
    expect(result).toEqual("bar");
  });

  it("should work with waitFor()", () => {
    clientSocket.emit("baz");

    return waitFor(serverSocket, "baz");
  });
});

```

--------------------------------

### Configure Redis Adapter with CommonJS

Source: https://socket.io/docs/v4/server-options

Example of setting up the Socket.IO server to use the Redis adapter for inter-server communication. Requires Redis client setup.

```javascript
const { Server } = require("socket.io");
const { createAdapter } = require("@socket.io/redis-adapter");
const { createClient } = require("redis");

const pubClient = createClient({ host: "localhost", port: 6379 });
const subClient = pubClient.duplicate();

const io = new Server({
  adapter: createAdapter(pubClient, subClient)
});

io.listen(3000);

```

--------------------------------

### Install Redis Streams Adapter

Source: https://socket.io/docs/v4/redis-streams-adapter

Install the necessary packages for the Redis Streams adapter and the redis client.

```bash
npm install @socket.io/redis-streams-adapter redis  

```

--------------------------------

### Install Socket.IO with Yarn

Source: https://socket.io/docs/v4/server-installation

Use this command to install the latest release of Socket.IO using Yarn.

```bash
yarn add socket.io  
```

--------------------------------

### Install eiows with Bun

Source: https://socket.io/docs/v4/server-installation

Install the eiows package, an alternative WebSocket server implementation, using Bun.

```bash
bun add eiows  
```

--------------------------------

### Basic Socket.IO Test Setup (ES Modules)

Source: https://socket.io/docs/v4/testing

Sets up a Socket.IO server and client for testing using Node.js http server and socket.io-client with ES module syntax. Includes setup and teardown for the test environment.

```javascript
import { createServer } from "node:http";  
import { io as ioc } from "socket.io-client";  
import { Server } from "socket.io";  
  
function waitFor(socket, event) {  
  return new Promise((resolve) => {  
    socket.once(event, resolve);  
  });  
}  
  
describe("my awesome project", () => {  
  let io, serverSocket, clientSocket;  
  
  beforeAll((done) => {  
    const httpServer = createServer();  
    io = new Server(httpServer);  
    httpServer.listen(() => {  
      const port = httpServer.address().port;  
      clientSocket = ioc(`http://localhost:${port}`);  
      io.on("connection", (socket) => {  
        serverSocket = socket;  
      });  
      clientSocket.on("connect", done);  
    });  
  });  
  
  afterAll(() => {  
    io.close();  
    clientSocket.disconnect();  
  });  

  test("should work", (done) => {  
    clientSocket.on("hello", (arg) => {  
      expect(arg).toBe("world");  
      done();  
    });  
    serverSocket.emit("hello", "world");  
  });  

  test("should work with an acknowledgement", (done) => {  
    serverSocket.on("hi", (cb) => {  
      cb("hola");  
    });  
    clientSocket.emit("hi", (arg) => {  
      expect(arg).toBe("hola");  
      done();  
    });  
  });  

  test("should work with emitWithAck()", async () => {  
    serverSocket.on("foo", (cb) => {  
      cb("bar");  
    });  
    const result = await clientSocket.emitWithAck("foo");  
    expect(result).toBe("bar");  
  });  

  test("should work with waitFor()", () => {  
    clientSocket.emit("baz");  

    return waitFor(serverSocket, "baz");  
  });  
});  

```

--------------------------------

### Install Socket.IO Client with Yarn

Source: https://socket.io/docs/v4/client-installation

Install the Socket.IO client package using Yarn. This command is equivalent to the NPM installation for Yarn users.

```bash
yarn add socket.io-client
```

--------------------------------

### Basic Socket.IO Test Setup (CommonJS)

Source: https://socket.io/docs/v4/testing

Sets up a Socket.IO server and client for testing using Node.js http server and socket.io-client. Includes setup and teardown for the test environment.

```javascript
const { createServer } = require("node:http");  
const { Server } = require("socket.io");  
const ioc = require("socket.io-client");  

function waitFor(socket, event) {  
  return new Promise((resolve) => {  
    socket.once(event, resolve);  
  });  
}  

describe("my awesome project", () => {  
  let io, serverSocket, clientSocket;  
  
  beforeAll((done) => {  
    const httpServer = createServer();  
    io = new Server(httpServer);  
    httpServer.listen(() => {  
      const port = httpServer.address().port;  
      clientSocket = ioc(`http://localhost:${port}`);  
      io.on("connection", (socket) => {  
        serverSocket = socket;  
      });  
      clientSocket.on("connect", done);  
    });  
  });  
  
  afterAll(() => {  
    io.close();  
    clientSocket.disconnect();  
  });  

  test("should work", (done) => {  
    clientSocket.on("hello", (arg) => {  
      expect(arg).toBe("world");  
      done();  
    });  
    serverSocket.emit("hello", "world");  
  });  

  test("should work with an acknowledgement", (done) => {  
    serverSocket.on("hi", (cb) => {  
      cb("hola");  
    });  
    clientSocket.emit("hi", (arg) => {  
      expect(arg).toBe("hola");  
      done();  
    });  
  });  

  test("should work with emitWithAck()", async () => {  
    serverSocket.on("foo", (cb) => {  
      cb("bar");  
    });  
    const result = await clientSocket.emitWithAck("foo");  
    expect(result).toBe("bar");  
  });  

  test("should work with waitFor()", () => {  
    clientSocket.emit("baz");  

    return waitFor(serverSocket, "baz");  
  });  
});  

```

--------------------------------

### Install MongoDB Adapter

Source: https://socket.io/docs/v4/mongo-adapter

Install the necessary packages for the MongoDB adapter and MongoDB driver.

```bash
npm install @socket.io/mongo-adapter mongodb  

```

--------------------------------

### Usage with Node.js Cluster

Source: https://socket.io/docs/v4/cluster-adapter

Set up Socket.IO with the cluster adapter in a Node.js cluster environment. This example demonstrates master and worker process configurations, including sticky session setup and inter-worker communication.

```javascript
const cluster = require("cluster");  
const http = require("http");  
const { Server } = require("socket.io");  
const numCPUs = require("os").cpus().length;  
const { setupMaster, setupWorker } = require("@socket.io/sticky");  
const { createAdapter, setupPrimary } = require("@socket.io/cluster-adapter");  
  
if (cluster.isMaster) {  
  console.log(`Master ${process.pid} is running`);  
  
  const httpServer = http.createServer();  
  
  // setup sticky sessions  
  setupMaster(httpServer, {  
    loadBalancingMethod: "least-connection",  
  });  
  
  // setup connections between the workers  
  setupPrimary();  
  
  // needed for packets containing buffers (you can ignore it if you only send plaintext objects)  
  // Node.js < 16.0.0  
  cluster.setupMaster({  
    serialization: "advanced",  
  });  
  // Node.js > 16.0.0  
  // cluster.setupPrimary({  
  //   serialization: "advanced",  
  // });  
  
  httpServer.listen(3000);  
  
  for (let i = 0; i < numCPUs; i++) {  
    cluster.fork();  
  }  
  
  cluster.on("exit", (worker) => {  
    console.log(`Worker ${worker.process.pid} died`);  
    cluster.fork();  
  });  
} else {  
  console.log(`Worker ${process.pid} started`);  
  
  const httpServer = http.createServer();  
  const io = new Server(httpServer);  
  
  // use the cluster adapter  
  io.adapter(createAdapter());  
  
  // setup connection with the primary process  
  setupWorker(io);  
  
  io.on("connection", (socket) => {  
    /* ... */  
  });  
}  

```

--------------------------------

### Install Socket.IO Postgres Adapter

Source: https://socket.io/docs/v4/postgres-adapter

Install the necessary packages for the Socket.IO Postgres adapter and PostgreSQL driver.

```bash
npm install @socket.io/postgres-adapter pg  

```

--------------------------------

### Install Socket.IO with NPM

Source: https://socket.io/docs/v4/server-installation

Use this command to install the latest release of Socket.IO using NPM.

```bash
npm install socket.io  
```

--------------------------------

### Install Socket.IO Client with pnpm

Source: https://socket.io/docs/v4/client-installation

Install the Socket.IO client package using pnpm. This command is equivalent to the NPM installation for pnpm users.

```bash
pnpm add socket.io-client
```

--------------------------------

### Install GCP Pub/Sub Adapter

Source: https://socket.io/docs/v4/gcp-pubsub-adapter

Install the adapter using npm. This is the first step to integrate Google Cloud Pub/Sub with Socket.IO.

```bash
npm install @socket.io/gcp-pubsub-adapter  

```

--------------------------------

### Install SQLite Packages with Bun

Source: https://socket.io/docs/v4/tutorial/step-7

Installs the necessary Bun packages for SQLite integration.

```bash
bun add sqlite sqlite3  
```

--------------------------------

### Install Socket.IO with pnpm

Source: https://socket.io/docs/v4/server-installation

Use this command to install the latest release of Socket.IO using pnpm.

```bash
pnpm add socket.io  
```

--------------------------------

### Install @socket.io/cluster-adapter with Bun

Source: https://socket.io/docs/v4/tutorial/step-9

Install the cluster adapter for Socket.IO using Bun. This package is required for horizontal scaling.

```bash
bun add @socket.io/cluster-adapter  
```

--------------------------------

### Install Mocha and Chai for Testing

Source: https://socket.io/docs/v4/testing

Install Mocha and Chai as development dependencies for your testing environment.

```bash
npm install --save-dev mocha chai  

```

--------------------------------

### Install Express

Source: https://socket.io/docs/v4/tutorial/step-1

Installs the Express framework version 4.x. This command should be run after creating the package.json file.

```bash
npm install express@4
```

--------------------------------

### Install ws Native Add-ons

Source: https://socket.io/docs/v4/performance-tuning

Install optional bufferutil and utf-8-validate packages to improve WebSocket frame operations and UTF-8 validation. These are optional and the server will fallback to JavaScript implementations if not available.

```bash
$ npm install --save-optional bufferutil utf-8-validate  

```

--------------------------------

### Install eiows with NPM

Source: https://socket.io/docs/v4/server-installation

Install the eiows package, an alternative WebSocket server implementation, using NPM.

```bash
npm install eiows  
```

--------------------------------

### Install Socket.IO Postgres Emitter

Source: https://socket.io/docs/v4/postgres-adapter

Install the necessary packages for the Socket.IO Postgres emitter and PostgreSQL driver.

```bash
npm install @socket.io/postgres-emitter pg  

```

--------------------------------

### Install eiows with pnpm

Source: https://socket.io/docs/v4/server-installation

Install the eiows package, an alternative WebSocket server implementation, using pnpm.

```bash
pnpm add eiows  
```

--------------------------------

### Install AWS SQS Adapter

Source: https://socket.io/docs/v4/aws-sqs-adapter

Install the AWS SQS adapter package using npm. This is the first step to enable cluster communication.

```bash
npm install @socket.io/aws-sqs-adapter  

```

--------------------------------

### Install Azure Service Bus Adapter

Source: https://socket.io/docs/v4/azure-service-bus-adapter

Install the adapter using npm. This is the first step to integrate Azure Service Bus with Socket.IO.

```bash
npm install @socket.io/azure-service-bus-adapter  

```

--------------------------------

### Install eiows with Yarn

Source: https://socket.io/docs/v4/server-installation

Install the eiows package, an alternative WebSocket server implementation, using Yarn.

```bash
yarn add eiows  
```

--------------------------------

### Install µWebSockets.js with Bun

Source: https://socket.io/docs/v4/server-installation

Install the µWebSockets.js package, a high-performance WebSocket server, using Bun with a specific version.

```bash
bun add uWebSockets.js@uNetworking/uWebSockets.js#v20.52.0  
```

--------------------------------

### Client-Side Load Balancing Example

Source: https://socket.io/docs/v4/using-multiple-nodes

This example demonstrates how a client can randomly select a Socket.IO server from a list and automatically re-establish connection to a new server if disconnected.

```javascript
const SERVERS = [
    "https://s1.example.com",
    "https://s2.example.com",
    "https://s3.example.com",
];

function pickServer() {
    return SERVERS[Math.floor(Math.random() * SERVERS.length)];
}

const socket = io(pickServer());

socket.io.on("reconnect_attempt", () => {
    socket.io.uri = pickServer();
});

```

--------------------------------

### Initialize Socket.IO with µWebSockets.js

Source: https://socket.io/docs/v4/server-initialization

Use this snippet to attach Socket.IO to a µWebSockets.js server. Ensure 'uWebSockets.js' and 'socket.io' are installed.

```javascript
import { App } from "uWebSockets.js";  
import { Server } from "socket.io";  
  
const app = App();  
const io = new Server();  
  
io.attachApp(app);  
  
io.on("connection", (socket) => {  
  // ...  
});  
  
app.listen(3000, (token) => {  
  if (!token) {  
    console.warn("port already in use");  
  }  
});  
```

--------------------------------

### Install Socket.IO Cluster Adapter

Source: https://socket.io/docs/v4/cluster-adapter

Install the cluster adapter package using npm. This is the first step to enable Socket.IO in a Node.js cluster.

```bash
npm install @socket.io/cluster-adapter  

```

--------------------------------

### Install @socket.io/cluster-adapter with pnpm

Source: https://socket.io/docs/v4/tutorial/step-9

Install the cluster adapter for Socket.IO using pnpm. This package is required for horizontal scaling.

```bash
pnpm add @socket.io/cluster-adapter  
```

--------------------------------

### Basic Namespace Setup

Source: https://socket.io/docs/v4/namespaces

Demonstrates how to set up separate namespaces for different functionalities like orders and users, and attach event handlers to them.

```javascript
io.of("/orders").on("connection", (socket) => {
  socket.on("order:list", () => {});
  socket.on("order:create", () => {});
});

io.of("/users").on("connection", (socket) => {
  socket.on("user:list", () => {});
});
```

--------------------------------

### Install µWebSockets.js with NPM

Source: https://socket.io/docs/v4/server-installation

Install the µWebSockets.js package, a high-performance WebSocket server, using NPM with a specific version.

```bash
npm install uWebSockets.js@uNetworking/uWebSockets.js#v20.52.0  
```

--------------------------------

### Integrate Socket.IO with µWebSockets.js

Source: https://socket.io/docs/v4/server-installation

Example of binding a Socket.IO server to a µWebSockets.js application. This setup leverages µWebSockets.js for potentially improved performance.

```javascript
const { App } = require("uWebSockets.js");  
const { Server } = require("socket.io");  
  
const app = App();  
const io = new Server();  
  
io.attachApp(app);  
  
io.on("connection", (socket) => {  
  // ...  
});  
  
app.listen(3000, (token) => {  
  if (!token) {  
    console.warn("port already in use");  
  }  
});  
```

--------------------------------

### Clone Socket.IO Chat Example

Source: https://socket.io/docs/v4/tutorial/ending-notes

Use this command to clone the example project from GitHub. This sets up the basic chat application for you to explore.

```bash
git clone https://github.com/socketio/chat-example.git  

```

--------------------------------

### Server-side MessagePack Parser Setup

Source: https://socket.io/docs/v4/custom-parser

Configure the Socket.IO server to use the custom MessagePack parser. Ensure the 'socket.io-msgpack-parser' package is installed.

```javascript
import { Server } from "socket.io";  
import customParser from "socket.io-msgpack-parser";  
  
const io = new Server({
  parser: customParser  
});  

```

--------------------------------

### Socket.IO Server Setup (No Client Files)

Source: https://socket.io/docs/v4/server-with-bundlers

Basic Socket.IO server setup using Webpack. The `serveClient` option is set to `false` to prevent serving client files. This configuration is suitable for backend-only bundling.

```javascript
const { Server } = require("socket.io");  
  
const io = new Server({  
  serveClient: false  
});  
  
io.on("connection", socket => {  
  console.log(`connect ${socket.id}`);  
  
  socket.on("disconnect", (reason) => {  
    console.log(`disconnect ${socket.id} due to ${reason}`);  
  });  
});  
  
io.listen(3000);  

```

--------------------------------

### Install Socket.IO Client with NPM

Source: https://socket.io/docs/v4/client-installation

Install the Socket.IO client package using NPM. This is the recommended method for projects using module bundlers like webpack or browserify.

```bash
npm install socket.io-client
```

--------------------------------

### Client-side MessagePack Parser Setup (Node.js)

Source: https://socket.io/docs/v4/custom-parser

Integrate the MessagePack parser into a Node.js Socket.IO client. This requires installing 'socket.io-msgpack-parser' and specifying it in the client options.

```javascript
import { io } from "socket.io-client";  
import customParser from "socket.io-msgpack-parser";  
  
const socket = io("https://example.com", {  
  parser: customParser  
});  

```

--------------------------------

### Client Initialization (Same-Origin)

Source: https://socket.io/docs/v4/namespaces

Illustrates how to initialize client connections to the main and custom namespaces within the same origin.

```javascript
const socket = io(); // or io("/"", the main namespace)  
const orderSocket = io("/orders"); // the "orders" namespace  
const userSocket = io("/users"); // the "users" namespace  
```

--------------------------------

### Install Optional Packages with Bun

Source: https://socket.io/docs/v4/server-installation

Install optional performance-enhancing packages like bufferutil and utf-8-validate using Bun. These are binary add-ons that improve data payload operations and UTF-8 validation.

```bash
bun add --optional bufferutil utf-8-validate  
```

--------------------------------

### Get All Sockets in Namespace (Callback - Deprecated)

Source: https://socket.io/docs/v4/migrating-from-2-x-to-3-0

The `Namespace.clients()` method, used for retrieving socket IDs via a callback, has been renamed to `Namespace.allSockets()` and now returns a Promise. This example shows the older syntax.

```javascript
// all sockets in default namespace
io.clients((error, clients) => {
  console.log(clients); // => [6em3d4TJP8Et9EMNAAAA, G5p55dHhGgUnLUctAAAB]
});

// all sockets in the "chat" namespace
io.of("/chat").clients((error, clients) => {
  console.log(clients); // => [PZDoMHjiu8PYfRiKAAAF, Anw2LatarvGVVXEIAAAD]
});

// all sockets in the "chat" namespace and in the "general" room
io.of("/chat").in("general").clients((error, clients) => {
  console.log(clients); // => [Anw2LatarvGVVXEIAAAD]
});

```

--------------------------------

### Install Mocha, Chai, and Types for Testing (TypeScript)

Source: https://socket.io/docs/v4/testing

Install Mocha, Chai, and their corresponding TypeScript types as development dependencies for your testing environment.

```bash
npm install --save-dev mocha chai @types/mocha @types/chai  

```

--------------------------------

### Install Optional Packages with NPM

Source: https://socket.io/docs/v4/server-installation

Install optional performance-enhancing packages like bufferutil and utf-8-validate using NPM. These are binary add-ons that improve data payload operations and UTF-8 validation.

```bash
npm install --save-optional bufferutil utf-8-validate  
```

--------------------------------

### Client: Custom Path and Namespace

Source: https://socket.io/docs/v4/client-options

Example demonstrating how to set a custom path and specify a namespace in the connection URI on the client-side.

```javascript
import { io } from "socket.io-client";

const socket = io("https://example.com/order", {
  path: "/my-custom-path/"
});

```

--------------------------------

### Socket.IO Server Setup (Serving Client Files)

Source: https://socket.io/docs/v4/server-with-bundlers

Socket.IO server setup configured to serve client files using Webpack's Asset Modules. The `sendFile` function is overridden to dynamically provide the client-side code and its map file.

```javascript
const { Server } = require("socket.io");  
  
const clientFile = require("./node_modules/socket.io/client-dist/socket.io.min?raw");  
const clientMap = require("./node_modules/socket.io/client-dist/socket.io.min.js.map?raw");  
  
Server.sendFile = (filename, req, res) => {  
  res.end(filename.endsWith(".map") ? clientMap : clientFile);  
};
  
const io = new Server();  
  
io.on("connection", socket => {  
  console.log(`connect ${socket.id}`);  
  
  socket.on("disconnect", (reason) => {  
    console.log(`disconnect ${socket.id} due to ${reason}`);  
  });  
});  
  
io.listen(3000);  

```

--------------------------------

### Custom Namespace Setup

Source: https://socket.io/docs/v4/namespaces

Shows how to set up and use a custom namespace on the server-side, including handling connections and emitting messages.

```javascript
const nsp = io.of("/my-namespace");  
  
sp.on("connection", (socket) => {  
  console.log("someone connected");  
});  
  
sp.emit("hi", "everyone!");  
```

--------------------------------

### Socket.IO Test Suite Setup

Source: https://socket.io/docs/v4/testing

Sets up a Socket.IO server and client for testing. Includes beforeAll and afterAll hooks for managing the server and client lifecycle.

```typescript
import { beforeAll, afterAll, describe, it, expect } from "vitest";
import { createServer } from "node:http";
import { type AddressInfo } from "node:net";
import { io as ioc, type Socket as ClientSocket } from "socket.io-client";
import { Server, type Socket as ServerSocket } from "socket.io";

function waitFor(socket: ServerSocket | ClientSocket, event: string) {
  return new Promise((resolve) => {
    socket.once(event, resolve);
  });
}

describe("my awesome project", () => {
  let io: Server, serverSocket: ServerSocket, clientSocket: ClientSocket;

  beforeAll(() => {
    return new Promise((resolve) => {
      const httpServer = createServer();
      io = new Server(httpServer);
      httpServer.listen(() => {
        const port = (httpServer.address() as AddressInfo).port;
        clientSocket = ioc(`http://localhost:${port}`);
        io.on("connection", (socket) => {
          serverSocket = socket;
        });
        clientSocket.on("connect", resolve);
      });
    });
  });

  afterAll(() => {
    io.close();
    clientSocket.disconnect();
  });

  it("should work", () => {
    return new Promise((resolve) => {
      clientSocket.on("hello", (arg) => {
        expect(arg).toEqual("world");
        resolve();
      });
      serverSocket.emit("hello", "world");
    });
  });

  it("should work with an acknowledgement", () => {
    return new Promise((resolve) => {
      serverSocket.on("hi", (cb) => {
        cb("hola");
      });
      clientSocket.emit("hi", (arg) => {
        expect(arg).toEqual("hola");
        resolve();
      });
    });
  });

  it("should work with emitWithAck()", async () => {
    serverSocket.on("foo", (cb) => {
      cb("bar");
    });
    const result = await clientSocket.emitWithAck("foo");
    expect(result).toEqual("bar");
  });

  it("should work with waitFor()", () => {
    clientSocket.emit("baz");

    return waitFor(serverSocket, "baz");
  });
});
```

--------------------------------

### Tape Test Setup and Basic Event Emission (ES Modules)

Source: https://socket.io/docs/v4/testing

Sets up a Socket.IO server and client for testing using Tape with ES module syntax. Emits a 'hello' event from the server and asserts the received argument on the client.

```javascript
import { test } from "tape";
import { createServer } from "node:http";
import { io as ioc } from "socket.io-client";
import { Server } from "socket.io";

let io, serverSocket, clientSocket;

function waitFor(socket, event) {
  return new Promise((resolve) => {
    socket.once(event, resolve);
  });
}

test("setup", (t) => {
  const httpServer = createServer();
  io = new Server(httpServer);
  httpServer.listen(() => {
    const port = httpServer.address().port;
    clientSocket = ioc(`http://localhost:${port}`);
    io.on("connection", (socket) => {
      serverSocket = socket;
    });
    clientSocket.on("connect", t.end);
  });
});

test("it works", (t) => {
  t.plan(1);
  clientSocket.on("hello", (arg) => {
    t.equal(arg, "world");
  });
  serverSocket.emit("hello", "world");
});

test("it works with an acknowledgement", (t) => {
  t.plan(1);
  serverSocket.on("hi", (cb) => {
    cb("hola");
  });
  clientSocket.emit("hi", (arg) => {
    t.equal(arg, "hola");
  });
});

test("it works with emitWithAck()", async (t) => {
  t.plan(1);
  serverSocket.on("foo", (cb) => {
    cb("bar");
  });
  const result = await clientSocket.emitWithAck("foo");
  t.equal(result, "bar");
});

test("it works with waitFor()", async (t) => {
  t.plan(1);
  clientSocket.emit("baz");

  await waitFor(serverSocket, "baz");
  t.pass();
});

test.onFinish(() => {
  io.close();
  clientSocket.disconnect();
});

```

--------------------------------

### Install Vitest

Source: https://socket.io/docs/v4/testing

Install Vitest as a development dependency using npm.

```bash
npm install --save-dev vitest
```

--------------------------------

### Tape Test Setup and Basic Event Emission (CommonJS)

Source: https://socket.io/docs/v4/testing

Sets up a Socket.IO server and client for testing using Tape. Emits a 'hello' event from the server and asserts the received argument on the client.

```javascript
const test = require("tape");
const { createServer } = require("node:http");
const { Server } = require("socket.io");
const ioc = require("socket.io-client");

let io, serverSocket, clientSocket;

function waitFor(socket, event) {
  return new Promise((resolve) => {
    socket.once(event, resolve);
  });
}

test("setup", (t) => {
  const httpServer = createServer();
  io = new Server(httpServer);
  httpServer.listen(() => {
    const port = httpServer.address().port;
    clientSocket = ioc(`http://localhost:${port}`);
    io.on("connection", (socket) => {
      serverSocket = socket;
    });
    clientSocket.on("connect", t.end);
  });
});

test("it works", (t) => {
  t.plan(1);
  clientSocket.on("hello", (arg) => {
    t.equal(arg, "world");
  });
  serverSocket.emit("hello", "world");
});

test("it works with an acknowledgement", (t) => {
  t.plan(1);
  serverSocket.on("hi", (cb) => {
    cb("hola");
  });
  clientSocket.emit("hi", (arg) => {
    t.equal(arg, "hola");
  });
});

test("it works with emitWithAck()", async (t) => {
  t.plan(1);
  serverSocket.on("foo", (cb) => {
    cb("bar");
  });
  const result = await clientSocket.emitWithAck("foo");
  t.equal(result, "bar");
});

test("it works with waitFor()", async (t) => {
  t.plan(1);
  clientSocket.emit("baz");

  await waitFor(serverSocket, "baz");
  t.pass();
});

test.onFinish(() => {
  io.close();
  clientSocket.disconnect();
});

```

--------------------------------

### Install Jest for Testing

Source: https://socket.io/docs/v4/testing

Install Jest as a development dependency for your project.

```bash
npm install --save-dev jest  
```

```bash
npm install --save-dev jest @types/jest  
```

--------------------------------

### Manager and Socket initialization with query options (Before v3)

Source: https://socket.io/docs/v4/migrating-from-2-x-to-3-0

This example illustrates how the 'query' option was handled by both Manager and Socket instances before v3, showing potential conflicts.

```javascript
const { Manager } = require("socket.io-client");  

// a new Manager is created (which will manage the low-level connection)  
const manager = new Manager({  
  query: { // sent in the query parameters  
    token: "abc"  
  }  
});  

// and then a Socket instance is created for the namespace (here, the main namespace, "/")  
const socket = manager.socket("/", {  
  query: { // sent in the CONNECT packet  
    token: "abc"  
  }  
});  
```

--------------------------------

### Install SQLite Packages with PNPM

Source: https://socket.io/docs/v4/tutorial/step-7

Installs the necessary pnpm packages for SQLite integration.

```bash
pnpm add sqlite sqlite3  
```

--------------------------------

### Configuring wsEngine option in Socket.IO (After)

Source: https://socket.io/docs/v4/migrating-from-3-x-to-4-0

Demonstrates the updated format for the wsEngine option in Socket.IO, resolving webpack bundling errors by requiring the engine directly.

```javascript
const io = require("socket.io")(httpServer, {
  wsEngine: require("eiows").Server
}); 
```

--------------------------------

### Dynamic Namespace Creation with RegExp

Source: https://socket.io/docs/v4/server-api

This example shows how to create namespaces dynamically using a regular expression. It attaches a connection handler and demonstrates broadcasting within sub-namespaces.

```javascript
const dynamicNsp = io.of(/^\/dynamic-\d+$/).on("connection", (socket) => {
  const newNamespace = socket.nsp; // newNamespace.name === "/dynamic-101"

  // broadcast to all clients in the given sub-namespace
  newNamespace.emit("hello");
});

// client-side
const socket = io("/dynamic-101");

// broadcast to all clients in each sub-namespace
dynamicNsp.emit("hello");

// use a middleware for each sub-namespace
dynamicNsp.use((socket, next) => { /* ... */ });

```

--------------------------------

### Install SQLite Packages with Yarn

Source: https://socket.io/docs/v4/tutorial/step-7

Installs the necessary yarn packages for SQLite integration.

```bash
yarn add sqlite sqlite3  
```

--------------------------------

### Install SQLite Packages with NPM

Source: https://socket.io/docs/v4/tutorial/step-7

Installs the necessary npm packages for SQLite integration.

```bash
npm install sqlite sqlite3  
```

--------------------------------

### Client Initialization (Cross-Origin/Node.js)

Source: https://socket.io/docs/v4/namespaces

Demonstrates client initialization for custom namespaces when connecting to a different domain or in a Node.js environment.

```javascript
const socket = io("https://example.com"); // or io("https://example.com/"", the main namespace)  
const orderSocket = io("https://example.com/orders"); // the "orders" namespace  
const userSocket = io("https://example.com/users"); // the "users" namespace  
```

--------------------------------

### Server Constructor

Source: https://socket.io/docs/v4/server-api

Demonstrates the different ways to instantiate the Socket.IO Server, including passing an HTTP/S server, a port number, or just options.

```APIDOC
## Server Constructor

### `new Server(httpServer[, options])`

- `httpServer` `<http.Server>` | `<https.Server>`: An existing HTTP or HTTPS server instance.
- `options` `<Object>`: Optional configuration object.

### `new Server(port[, options])`

- `port` `<number>`: The port number to listen on.
- `options` `<Object>`: Optional configuration object.

### `new Server(options)`

- `options` `<Object>`: Optional configuration object. The server will listen on the port specified in the options or default to 3000 if not provided.

### Request Example (Server with httpServer)
```javascript
import { createServer } from "http";
import { Server } from "socket.io";

const httpServer = createServer();
const io = new Server(httpServer, {
  // options
});

io.on("connection", (socket) => {
  // ...
});

httpServer.listen(3000);
```

### Request Example (Server with port)
```javascript
import { Server } from "socket.io";

const io = new Server(3000, {
  // options
});

io.on("connection", (socket) => {
  // ...
});
```

### Request Example (Server with options)
```javascript
import { Server } from "socket.io";

const io = new Server({
  // options
});

io.on("connection", (socket) => {
  // ...
});

io.listen(3000);
```
```

--------------------------------

### Basic Socket.IO Test Setup (TypeScript)

Source: https://socket.io/docs/v4/testing

Sets up a Socket.IO server and client for testing using Node.js http server and socket.io-client with TypeScript. Includes type annotations for better code safety and setup/teardown.

```typescript
import { createServer } from "node:http";  
import { type AddressInfo } from "node:net";  
import { io as ioc, type Socket as ClientSocket } from "socket.io-client";  
import { Server, type Socket as ServerSocket } from "socket.io";  
  
function waitFor(socket: ServerSocket | ClientSocket, event: string) {  
  return new Promise((resolve) => {  
    socket.once(event, resolve);  
  });  
}  
  
describe("my awesome project", () => {  
  let io, serverSocket, clientSocket;  
  
  beforeAll((done) => {  
    const httpServer = createServer();  
    io = new Server(httpServer);  
    httpServer.listen(() => {  
      const port = (httpServer.address() as AddressInfo).port;  
      clientSocket = ioc(`http://localhost:${port}`);  

```

--------------------------------

### Create Express Server (ES Modules)

Source: https://socket.io/docs/v4/tutorial/step-1

Sets up a basic Express server using ES modules. It listens on port 3000 and responds with 'Hello world' to root requests.

```javascript
import express from 'express';
import { createServer } from 'node:http';

const app = express();
const server = createServer(app);

app.get('/', (req, res) => {
  res.send('<h1>Hello world</h1>');
});

server.listen(3000, () => {
  console.log('server running at http://localhost:3000');
});
```

--------------------------------

### Tape Test Setup and Basic Event Emission (TypeScript)

Source: https://socket.io/docs/v4/testing

Sets up a Socket.IO server and client for testing using Tape with TypeScript. Emits a 'hello' event from the server and asserts the received argument on the client, including type annotations.

```typescript
import { test } from "tape";
import { createServer } from "node:http";
import { type AddressInfo } from "node:net";
import { io as ioc, type Socket as ClientSocket } from "socket.io-client";
import { Server, type Socket as ServerSocket } from "socket.io";

let io: Server, serverSocket: ServerSocket, clientSocket: ClientSocket;

function waitFor(socket: ServerSocket | ClientSocket, event: string) {
  return new Promise((resolve) => {
    socket.once(event, resolve);
  });
}

test("setup", (t) => {

```

--------------------------------

### Client Initialization with Custom Path

Source: https://socket.io/docs/v4/client-options

Demonstrates how to configure a custom path for Socket.IO client and server to communicate.

```APIDOC
## Client Initialization with Custom Path

### Description
Configure a custom path for Socket.IO client and server communication. The `path` option must match on both client and server unless a proxy is used.

### Method
N/A (Client-side configuration)

### Endpoint
N/A

### Parameters
#### Client Options
- **path** (string) - Default: `/socket.io/` - The path used for Socket.IO communication.

### Request Example (Client)
```javascript
import { io } from "socket.io-client";

const socket = io("https://example.com", {
  path: "/my-custom-path/"
});
```

### Request Example (Server)
```javascript
import { createServer } from "http";
import { Server } from "socket.io";

const httpServer = createServer();
const io = new Server(httpServer, {
  path: "/my-custom-path/"
});
```

### Notes
- The `path` is distinct from the Namespace in the URI.
- Example URI with custom path and namespace: `GET https://example.com/my-custom-path/?EIO=4&transport=polling&t=ML4jUwU`
```

--------------------------------

### Configure Socket.IO with eiows

Source: https://socket.io/docs/v4/server-installation

Example of configuring Socket.IO to use the eiows WebSocket server implementation by specifying the `wsEngine` option.

```javascript
const { Server } = require("socket.io");  
const eiows = require("eiows");  
  
const io = new Server(3000, {  
  wsEngine: eiows.Server  
});  
```

--------------------------------

### Initialize Server with Port

Source: https://socket.io/docs/v4/server-api

Create a Socket.IO server instance that listens on a specified port. This is a convenient way to start a Socket.IO server without explicitly creating an HTTP server.

```javascript
import { Server } from "socket.io";  
  
const io = new Server(3000, {  
  // options  
});  
  
io.on("connection", (socket) => {  
  // ...  
});  
```

--------------------------------

### Initialize Socket.IO Server (ES Modules)

Source: https://socket.io/docs/v4/tutorial/step-3

Set up a basic Express server and integrate Socket.IO using ES module syntax. This code snippet demonstrates how to initialize the Socket.IO server and handle incoming connections.

```javascript
import express from 'express';  
import { createServer } from 'node:http';  
import { fileURLToPath } from 'node:url';  
import { dirname, join } from 'node:path';  
import { Server } from 'socket.io';  

const app = express();  
const server = createServer(app);  
const io = new Server(server);  

const __dirname = dirname(fileURLToPath(import.meta.url));  

app.get('/', (req, res) => {  
  res.sendFile(join(__dirname, 'index.html'));  
});  

io.on('connection', (socket) => {  
  console.log('a user connected');  
});  

server.listen(3000, () => {  
  console.log('server running at http://localhost:3000');  
});  

```

--------------------------------

### Node.js Cluster with @socket.io/sticky

Source: https://socket.io/docs/v4/using-multiple-nodes

This example demonstrates setting up Node.js clustering with the `@socket.io/sticky` package for load balancing. It configures a master process to manage workers and uses the cluster adapter for inter-worker communication.

```javascript
const cluster = require("cluster");
const http = require("http");
const { Server } = require("socket.io");
const numCPUs = require("os").cpus().length;
const { setupMaster, setupWorker } = require("@socket.io/sticky");
const { createAdapter, setupPrimary } = require("@socket.io/cluster-adapter");

if (cluster.isMaster) {
  console.log(`Master ${process.pid} is running`);

  const httpServer = http.createServer();

  // setup sticky sessions
  setupMaster(httpServer, {
    loadBalancingMethod: "least-connection",
  });

  // setup connections between the workers
  setupPrimary();

  // needed for packets containing buffers (you can ignore it if you only send plaintext objects)
  // Node.js < 16.0.0
  cluster.setupMaster({
    serialization: "advanced",
  });
  // Node.js > 16.0.0
  // cluster.setupPrimary({
  //   serialization: "advanced",
  // });

  httpServer.listen(3000);

  for (let i = 0; i < numCPUs; i++) {
    cluster.fork();
  }

  cluster.on("exit", (worker) => {
    console.log(`Worker ${worker.process.pid} died`);
    cluster.fork();
  });
} else {
  console.log(`Worker ${process.pid} started`);

  const httpServer = http.createServer();
  const io = new Server(httpServer);

  // use the cluster adapter
  io.adapter(createAdapter());

  // setup connection with the primary process
  setupWorker(io);

  io.on("connection", (socket) => {
    /* ... */
  });
}

```

--------------------------------

### Install @socket.io/cluster-adapter with Yarn

Source: https://socket.io/docs/v4/tutorial/step-9

Install the cluster adapter for Socket.IO using Yarn. This package is required for horizontal scaling.

```bash
yarn add @socket.io/cluster-adapter  
```

--------------------------------

### Install @socket.io/cluster-adapter with NPM

Source: https://socket.io/docs/v4/tutorial/step-9

Install the cluster adapter for Socket.IO using npm. This package is required for horizontal scaling.

```bash
npm install @socket.io/cluster-adapter  
```

--------------------------------

### Initialize Socket.IO with Postgres Adapter

Source: https://socket.io/docs/v4/postgres-adapter

Set up a Socket.IO server and integrate the Postgres adapter using a pg.Pool. Ensure the 'socket_io_attachments' table is created if it doesn't exist.

```typescript
import { Server } from "socket.io";  
import { createAdapter } from "@socket.io/postgres-adapter";  
import pg from "pg";  
  
const io = new Server();  
  
const pool = new pg.Pool({  
  user: "postgres",  
  host: "localhost",  
  database: "postgres",  
  password: "changeit",  
  port: 5432,  
});  
  
pool.query(`  
  CREATE TABLE IF NOT EXISTS socket_io_attachments (  
      id          bigserial UNIQUE,  
      created_at  timestamptz DEFAULT NOW(),  
      payload     bytea  
  );  
`);  
  
pool.on("error", (err) => {  
  console.error("Postgres error", err);  
});  
  
io.adapter(createAdapter(pool));  
io.listen(3000);  

```

--------------------------------

### Install Socket.IO Package

Source: https://socket.io/docs/v4/tutorial/step-3

Install the socket.io package using npm. This command adds the dependency to your package.json file.

```bash
npm install socket.io  

```
Tokens:
Raw