Socket.IO

https://socket.io/docs/v4/
Admin
Socket.IO is a library that enables low-latency, bidirectional, and event-based communication...
Tokens:216,304
Snippets:1,735
Trust Score:9.9
Update:2 weeks ago
Show doc for...
Tokens:
Raw
### Install @socket.io/redis-streams-adapter

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

Install the adapter and the redis client library.

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

```

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

### Install @socket.io/gcp-pubsub-adapter

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

Install the Google Cloud Pub/Sub adapter for Socket.IO.

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

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

### Install eiows with bun

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

Install the eiows package using bun.

```bash
bun add eiows  
```

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

### Install @socket.io/admin-ui

Source: https://socket.io/docs/v4/admin-ui

Install the @socket.io/admin-ui package for the Socket.IO server.

```bash
npm i @socket.io/admin-ui  

```

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

### Socket.IO test suite with tape (ES modules)

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

Complete test suite for Socket.IO using tape, ES module import syntax. Covers connection setup, basic emit, acknowledgements, emitWithAck(), and a waitFor() helper. Requires tape, socket.io, and socket.io-client installed.

```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 @socket.io/aws-sqs-adapter

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

Install the AWS SQS adapter package for Socket.IO.

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

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

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

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

Install the @socket.io/cluster-adapter package via npm.

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

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

### Install @socket.io/pm2 globally

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

Install the @socket.io/pm2 package globally. If pm2 is already installed, remove it first to avoid conflicts.

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

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

### Install @socket.io/redis-emitter and redis

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

Install the Redis emitter package and the Redis client library using npm.

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

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

### Install SQLite packages with bun

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

Install the sqlite and sqlite3 packages using bun.

```bash
bun add sqlite sqlite3  
```

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

### Install eiows with pnpm

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

Install the eiows package using pnpm.

```bash
pnpm add eiows  
```

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

### Install Socket.IO and Bun engine with bun add

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

Install the socket.io and @socket.io/bun-engine packages using the Bun package manager.

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

```

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

### Install eiows with yarn

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

Install the eiows package using yarn.

```bash
yarn add eiows  
```

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

### Install socket.io-client with Bun

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

Installs the Socket.IO client package via Bun. Alternative to npm for package management.

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

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

### Install eiows with npm

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

Install the eiows package using npm.

```bash
npm install eiows  
```

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

### Install tape

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

Installs the tape test runner as a dev dependency.

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

```

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

### Install @socket.io/redis-adapter via npm

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

Install the adapter package using npm. This is the required first step for using the adapter.

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

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

### Server setup with msgpack parser

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

Server-side setup for using the msgpack parser. Pass the custom parser to the Server constructor.

```javascript
import { Server } from "socket.io";
import customParser from "socket.io-msgpack-parser";

const io = new Server({
  parser: customParser
});
```

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

### Install Postgres adapter dependencies

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

Install the required packages for the Postgres adapter.

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

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

### Install @socket.io/mongo-emitter and mongodb

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

Installs the MongoDB emitter package and the MongoDB driver.

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

```

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

### Install mocha, chai, and TypeScript types

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

Install mocha, chai, and their TypeScript type definitions as dev dependencies.

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

```

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

### Install Azure Service Bus adapter

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

Install the @socket.io/azure-service-bus-adapter package via npm.

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

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

### Install socket.io-client with Yarn

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

Installs the Socket.IO client package via Yarn. Alternative to npm for package management.

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

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

### Install uWebSockets.js with bun

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

Install the uWebSockets.js package (version v20.52.0) using bun.

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

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

### Install optional Socket.IO packages with Bun

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

Installs the optional binary add-on packages bufferutil and utf-8-validate using Bun. These packages improve performance for WebSocket operations. They are optional; if not installed, the WebSocket server falls back to the JavaScript implementation.

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

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

### Install SQLite packages with npm

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

Install the sqlite and sqlite3 packages using npm.

```bash
npm install sqlite sqlite3  
```

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

### Install SQLite packages with yarn

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

Install the sqlite and sqlite3 packages using yarn.

```bash
yarn add sqlite sqlite3  
```

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

### Install socket.io-client with pnpm

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

Installs the Socket.IO client package via pnpm. Alternative to npm for package management.

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

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

### Install mocha and chai (CommonJS)

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

Install mocha and chai as dev dependencies for testing with CommonJS.

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

```

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

### Install socket.io-client with npm

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

Installs the Socket.IO client package via npm. Use this when using a bundler like webpack or browserify.

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

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

### Install optional Socket.IO packages with NPM

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

Installs the optional binary add-on packages bufferutil and utf-8-validate using NPM. These packages improve performance for WebSocket operations. They are optional; if not installed, the WebSocket server falls back to the JavaScript implementation.

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

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

### Install optional Socket.IO packages with pnpm

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

Installs the optional binary add-on packages bufferutil and utf-8-validate using pnpm. These packages improve performance for WebSocket operations. They are optional; if not installed, the WebSocket server falls back to the JavaScript implementation.

```bash
pnpm add -O bufferutil utf-8-validate  
```

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

### Clone the Socket.IO chat example repository

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

Clones the Socket.IO chat example repository from GitHub. Use this to get the full source code for the tutorial application.

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

```

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

### Server with self-signed certificate

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

Server-side example for a self-signed certificate setup. Creates an HTTPS server with the certificate and key, then attaches Socket.IO. This is the counterpart to the client example with ca option.

```javascript
import { readFileSync } from "fs";
import { createServer } from "https";
import { Server } from "socket.io";

const httpServer = createServer({
  cert: readFileSync("./cert.pem"),
  key: readFileSync("./key.pem")
});
const io = new Server(httpServer);
```

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

### server.listen(httpServer[, options])

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

Synonym of `server.attach(httpServer[, options])`. Starts the server by attaching to an existing HTTP server.

```APIDOC
## [GET] /listen(httpServer[, options])

### Description
Synonym of `server.attach(httpServer[, options])`. Starts the server by attaching to an existing HTTP server.

### Method
GET

### Endpoint
`server.listen(httpServer[, options])`

### Parameters
#### Path Parameters
- **httpServer** (object) - Required - The HTTP server to attach to.
- **options** (object) - Optional - Additional options for the server.

### Request Example
```js
const server = require('http').createServer();
const io = require('socket.io')(server);
io.listen(server);
```

### Response
#### Success Response (200)
- **server** (object) - The Socket.IO server instance.
```

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

### Increase maxHttpBufferSize to 1e8

Source: https://socket.io/docs/v4/troubleshooting-connection-issues

Increase the maxHttpBufferSize option to allow larger payloads. The default is 1 MB; this example sets it to 1e8 (100 MB). Use this if you get disconnected while sending a huge payload.

```javascript
const io = require("socket.io")(httpServer, {  
  maxHttpBufferSize: 1e8  
});  
```

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

### Usage example for Azure Service Bus adapter

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

Shows how to set up the adapter with Service Bus clients, create a Socket.IO server with the adapter, initialize the subscription, and listen on port 3000.

```typescript
import { ServiceBusClient, ServiceBusAdministrationClient } from "@azure/service-bus";  
import { Server } from "socket.io";  
import { createAdapter } from "@socket.io/azure-service-bus-adapter";  
  
const connectionString = "Endpoint=...";  
  
const serviceBusClient = new ServiceBusClient(connectionString);  
const serviceBusAdminClient = new ServiceBusAdministrationClient(connectionString);  
  
const io = new Server({  
  adapter: createAdapter(serviceBusClient, serviceBusAdminClient)  
});  
  
// wait for the creation of the subscription  
await io.of("/").adapter.init();  
  
io.listen(3000);  
```

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

### Node.js http-proxy reverse proxy setup

Source: https://socket.io/docs/v4/reverse-proxy

Install the http-proxy package and create a proxy server that forwards requests to http://localhost:3000, with WebSocket support enabled (ws: true). The server listens on port 80.

```bash
npm i http-proxy
```

```javascript
const httpProxy = require("http-proxy");  
  
httpProxy  
  .createProxyServer({  
    target: "http://localhost:3000",  
    ws: true,  
  })  
  .listen(80);  

```

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

### Socket.IO test suite with tape (CommonJS)

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

Complete test suite for Socket.IO using tape, CommonJS require syntax. Covers connection setup, basic emit, acknowledgements, emitWithAck(), and a waitFor() helper. Requires tape, socket.io, and socket.io-client installed.

```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();  
});  

```

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

### new Server(options) with io.listen()

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

Creates a Socket.IO server with only an options object, then starts listening on port 3000 with io.listen(). The options object is optional; the complete list of available options is linked in the documentation.

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

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

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

io.listen(3000);
```

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

### Reusing an existing namespace creates a new Manager

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

Even when reusing an existing namespace, calling io() again creates a new Manager instance. This example shows that socket1 and socket2 each get their own manager, while socket3 reuses the first manager, and socket4 creates a third.

```javascript
const socket1 = io(); // 1st manager  
const socket2 = io(); // 2nd manager  
const socket3 = io("/admin"); // reuse the 1st manager  
const socket4 = io("/admin"); // 3rd manager  

```

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

### Test Socket.IO with tape (test/basic.ts)

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

Complete tape-based test suite for Socket.IO server-client communication. Covers basic emit, acknowledgements, emitWithAck(), and a waitFor() helper. Requires tape, socket.io, and socket.io-client. The setup test starts an HTTP server and connects a client; test.onFinish closes the server and disconnects the client.

```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) => {  
  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", 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 ws native add-ons (bufferutil, utf-8-validate)

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

Install optional binary add-ons for the ws WebSocket server to improve performance. These packages are optional; if not available, the server falls back to the JavaScript implementation.

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

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

### server.listen(port[, options])

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

Synonym of `server.attach(port[, options])`. Starts the server by listening on a specified port.

```APIDOC
## [GET] /listen(port[, options])

### Description
Synonym of `server.attach(port[, options])`. Starts the server by listening on a specified port.

### Method
GET

### Endpoint
`server.listen(port[, options])`

### Parameters
#### Path Parameters
- **port** (number) - Required - The port number to listen on.
- **options** (object) - Optional - Additional options for the server.

### Request Example
```js
const io = require('socket.io')();
io.listen(3000);
```

### Response
#### Success Response (200)
- **server** (object) - The Socket.IO server instance.
```

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

### Install Express 4 with npm install

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

Installs Express version 4 to populate the dependencies property in package.json. Run this after creating the manifest file.

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

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

### Set up Socket.IO server with ES modules

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

ES modules version of the server setup. Uses import statements and computes __dirname from import.meta.url. Otherwise identical to the CommonJS version.

```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');  
});  

```

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

### new Server(options)

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

Constructor that creates a Socket.IO server with options, to be attached later.

```APIDOC
## [CONSTRUCTOR] new Server(options)

### Description
Creates a new Socket.IO server instance with the given options. The server must be attached to a port or HTTP server later using `listen()` or `attach()`.

### Constructor
`new Server(options)`

### Parameters
- **options** (`<Object>`) - Required - Configuration options for the server.

### Request Example
```js
import { Server } from "socket.io";

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

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

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

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

### Configure Postgres adapter standalone

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

Initialize the Socket.IO server with the Postgres adapter, including the required database pool and attachment table setup.

```javascript
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);
```

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

### Manager-based equivalent of io() with options

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

Shows the equivalent long version of the previous example using `Manager` and `manager.socket()`. The `Manager` is created with the base URL and query options, then a socket is created for the namespace with auth options.

```javascript
import { Manager } from "socket.io-client";  
  
const manager = new Manager("ws://example.com", {  
  reconnectionDelayMax: 10000,  
  query: {  
    "my-key": "my-value"  
  }  
});  
  
const socket = manager.socket("/my-namespace", {  
  auth: {  
    token: "123"  
  }  
});  
```

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

### WebSocket packet example

Source: https://socket.io/docs/v4/engine-io-protocol

Example of a WebSocket packet with a plaintext payload.

```text
4hello  
  
with:  
  
4      => message packet type  
hello  => message payload (UTF-8 encoded)  
```

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

### Set up cluster adapter with ES modules (index.js)

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

ES modules version of the cluster adapter setup. The primary process forks one worker per core and calls setupPrimary(); each worker creates a Socket.IO server with the cluster adapter and listens on its own PORT.

```javascript
import express from 'express';  
import { createServer } from 'node:http';  
import { Server } from 'socket.io';  
import sqlite3 from 'sqlite3';  
import { open } from 'sqlite';  
import { availableParallelism } from 'node:os';  
import cluster from 'node:cluster';  
import { createAdapter, setupPrimary } from '@socket.io/cluster-adapter';  
  
if (cluster.isPrimary) {  
  const numCPUs = availableParallelism();  
  // create one worker per available core  
  for (let i = 0; i < numCPUs; i++) {  
    cluster.fork({  
      PORT: 3000 + i  
    });  
  }  
    
  // set up the adapter on the primary thread  
  setupPrimary();  
} else {  
  const app = express();  
  const server = createServer(app);  
  const io = new Server(server, {  
    connectionStateRecovery: {},  
    // set up the adapter on each worker thread  
    adapter: createAdapter()  
  });  
  
  // [...]  
  
  // each worker will listen on a distinct port  
  const port = process.env.PORT;  
  
  server.listen(port, () => {  
    console.log(`server running at http://localhost:${port}`);  
  });  
}  
```

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

### Install vitest

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

Install vitest as a dev dependency for the Socket.IO test suite.

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

```

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

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

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

Creates a Socket.IO server that listens on the specified port. The options object is optional; the complete list of available options is linked in the documentation.

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

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

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

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

### Install Postgres emitter dependencies

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

Install the required packages for the Postgres emitter.

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

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

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

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

Constructor that creates a Socket.IO server listening on a specified port.

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

### Description
Creates a new Socket.IO server instance that listens on the specified port.

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

### Parameters
- **port** (`<number>`) - Required - The port number to listen on.
- **options** (`<Object>`) - Optional - Configuration options for the server.

### Request Example
```js
import { Server } from "socket.io";

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

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

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

### Set up Socket.IO server with CommonJS

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

CommonJS version of the server setup. Creates an HTTP server with Express, attaches a Socket.IO server, serves index.html, and logs when a user connects. Listens on port 3000.

```javascript
const express = require('express');  
const { createServer } = require('node:http');  
const { join } = require('node:path');  
const { Server } = require('socket.io');  
  
const app = express();  
const server = createServer(app);  
const io = new Server(server);  
  
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');  
});  

```

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

### Install Artillery with Socket.IO v3 engine

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

Installs Artillery and the custom engine required for Socket.IO v3/v4 compatibility. The default Artillery installation includes a v2 client that is not compatible with v3/v4 servers.

```bash
$ npm install artillery artillery-engine-socketio-v3  

```

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

### Install Jest and @types/jest

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

Installs Jest and its TypeScript type definitions as dev dependencies.

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

```

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

### Install SQLite packages with pnpm

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

Install the sqlite and sqlite3 packages using pnpm.

```bash
pnpm add sqlite sqlite3  
```

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

### Redis adapter example (ES modules)

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

Configures the Socket.IO server to use the Redis adapter with ES module import syntax. Requires the @socket.io/redis-adapter and redis packages.

```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);  
```
Tokens:
Raw