github/peerjs-server
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

style: run prettier

Browse Source
This commit is contained in:
Jonas Gloning 2023-02-14 20:49:59 +01:00
parent fad2041a5e
commit d38066a391
No known key found for this signature in database
GPG Key ID: 684639B5E59E7614
45 changed files with 26336 additions and 26161 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
.github/ISSUE_TEMPLATE/peer-template.md vendored
View File

@ -1,13 +1,13 @@
---
name: peer template
about: Create a report to help us improve
title: ''
labels: ''
assignees: ''
title: ""
labels: ""
assignees: ""
---
### I'm having an issue:
- Give an expressive description of what is went wrong
- Version of `peer` you're experiencing this issue
- Nodejs version?
@ -16,13 +16,15 @@ assignees: ''
- If you're getting an error or exception, please provide its full stack-trace as plain-text or screenshot
### I have a suggestion:
- Describe your feature / request
- How you're going to use it? Give a usage example(s)
### Documentation is missing something or incorrect (have typos, etc.):
- Give an expressive description what you have changed/added and why
- Make sure you're using correct markdown markup
- Make sure all code blocks starts with triple ``` (*backtick*) and have a syntax tag, for more read [this docs](https://help.github.com/articles/creating-and-highlighting-code-blocks/#syntax-highlighting)
- Make sure all code blocks starts with triple ``` (_backtick_) and have a syntax tag, for more read [this docs](https://help.github.com/articles/creating-and-highlighting-code-blocks/#syntax-highlighting)
- Post addition/changes in issue, we will manage it
## Thank you, and do not forget to get rid of this default message

3
.github/workflows/node.js.yml vendored
View File

@ -11,7 +11,6 @@ on:
jobs:
build:
runs-on: ubuntu-latest
strategy:
@ -25,7 +24,7 @@ jobs:
uses: actions/setup-node@v3
with:
node-version: ${{ matrix.node-version }}
cache: 'npm'
cache: "npm"
- run: npm ci
- run: npm run build
- run: npm run lint

96
README.md
View File

@ -4,7 +4,8 @@
[![npm version](https://badge.fury.io/js/peer.svg)](https://www.npmjs.com/package/peer)
[![Downloads](https://img.shields.io/npm/dm/peer.svg)](https://www.npmjs.com/package/peer)
[![Docker Image Size (latest semver)](https://img.shields.io/docker/image-size/peerjs/peerjs-server)](https://hub.docker.com/r/peerjs/peerjs-server)
# PeerServer: A server for PeerJS #
# PeerServer: A server for PeerJS
PeerServer helps establishing connections between PeerJS clients. Data is not proxied through the server.
@ -27,16 +28,19 @@ If you don't want to develop anything, just enter few commands below.
$ npm install peer -g
```
2. Run the server:
```sh
$ peerjs --port 9000 --key peerjs --path /myapp
Started PeerServer on ::, port: 9000, path: /myapp (v. 0.3.2)
```
3. Check it: http://127.0.0.1:9000/myapp It should returns JSON with name, description and website fields.
#### Docker
Also, you can use Docker image to run a new container:
```sh
$ docker run -p 9000:9000 -d peerjs/peerjs-server
```
@ -48,9 +52,11 @@ $ kubectl run peerjs-server --image=peerjs/peerjs-server --port 9000 --expose --
```
### Create a custom server:
If you have your own server, you can attach PeerServer.
1. Install the package:
```bash
# $ cd your-project-path
@ -60,11 +66,13 @@ If you have your own server, you can attach PeerServer.
# with yarn
$ yarn add peer
```
2. Use PeerServer object to create a new server:
```javascript
const { PeerServer } = require('peer');
const peerServer = PeerServer({ port: 9000, path: '/myapp' });
2. Use PeerServer object to create a new server:
```javascript
const { PeerServer } = require("peer");
const peerServer = PeerServer({ port: 9000, path: "/myapp" });
```
3. Check it: http://127.0.0.1:9000/myapp It should returns JSON with name, description and website fields.
@ -73,19 +81,20 @@ If you have your own server, you can attach PeerServer.
```html
<script>
const peer = new Peer('someid', {
host: 'localhost',
const peer = new Peer("someid", {
host: "localhost",
port: 9000,
path: '/myapp'
path: "/myapp",
});
</script>
```
## Config / CLI options
You can provide config object to `PeerServer` function or specify options for `peerjs` CLI.
| CLI option | JS option | Description | Required | Default |
|--------------------------|--------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|:--------:|:----------:|
| ------------------------ | ------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :------: | :--------: |
| `--port, -p` | `port` | Port to listen (number) | **Yes** | |
| `--key, -k` | `key` | Connection key (string). Client must provide it to call API methods | No | `"peerjs"` |
| `--path` | `path` | Path (string). The server responds for requests to the root URL + path. **E.g.** Set the `path` to `/myapp` and run server on 9000 port via `peerjs --port 9000 --path /myapp` Then open http://127.0.0.1:9000/myapp - you should see a JSON reponse. | No | `"/"` |
@ -98,39 +107,40 @@ You can provide config object to `PeerServer` function or specify options for `p
| `--allow_discovery` | `allow_discovery` | Allow to use GET `/peers` http API method to get an array of ids of all connected clients (boolean) | No | |
| `--cors` | `corsOptions` | The CORS origins that can access this server |
| | `generateClientId` | A function which generate random client IDs when calling `/id` API method (`() => string`) | No | `uuid/v4` |
## Using HTTPS
Simply pass in PEM-encoded certificate and key.
```javascript
const fs = require('fs');
const { PeerServer } = require('peer');
const fs = require("fs");
const { PeerServer } = require("peer");
const peerServer = PeerServer({
port: 9000,
ssl: {
key: fs.readFileSync('/path/to/your/ssl/key/here.key'),
cert: fs.readFileSync('/path/to/your/ssl/certificate/here.crt')
}
key: fs.readFileSync("/path/to/your/ssl/key/here.key"),
cert: fs.readFileSync("/path/to/your/ssl/certificate/here.crt"),
},
});
```
You can also pass any other [SSL options accepted by https.createServer](https://nodejs.org/api/https.html#https_https_createserver_options_requestlistenerfrom), such as `SNICallback:
```javascript
const fs = require('fs');
const { PeerServer } = require('peer');
const fs = require("fs");
const { PeerServer } = require("peer");
const peerServer = PeerServer({
port: 9000,
ssl: {
SNICallback: (servername, cb) => {
// your code here ....
}
}
},
},
});
```
## Running PeerServer behind a reverse proxy
Make sure to set the `proxied` option, otherwise IP based limiting will fail.
@ -139,29 +149,31 @@ The option is passed verbatim to the
if it is truthy.
```javascript
const { PeerServer } = require('peer');
const { PeerServer } = require("peer");
const peerServer = PeerServer({
port: 9000,
path: '/myapp',
proxied: true
path: "/myapp",
proxied: true,
});
```
## Custom client ID generation
By default, PeerServer uses `uuid/v4` npm package to generate random client IDs.
You can set `generateClientId` option in config to specify a custom function to generate client IDs.
```javascript
const { PeerServer } = require('peer');
const { PeerServer } = require("peer");
const customGenerationFunction = () => (Math.random().toString(36) + '0000000000000000000').substr(2, 16);
const customGenerationFunction = () =>
(Math.random().toString(36) + "0000000000000000000").substr(2, 16);
const peerServer = PeerServer({
port: 9000,
path: '/myapp',
generateClientId: customGenerationFunction
path: "/myapp",
generateClientId: customGenerationFunction,
});
```
@ -170,34 +182,34 @@ Open http://127.0.0.1:9000/myapp/peerjs/id to see a new random id.
## Combining with existing express app
```javascript
const express = require('express');
const { ExpressPeerServer } = require('peer');
const express = require("express");
const { ExpressPeerServer } = require("peer");
const app = express();
app.get('/', (req, res, next) => res.send('Hello world!'));
app.get("/", (req, res, next) => res.send("Hello world!"));
// =======
const server = app.listen(9000);
const peerServer = ExpressPeerServer(server, {
path: '/myapp'
path: "/myapp",
});
app.use('/peerjs', peerServer);
app.use("/peerjs", peerServer);
// == OR ==
const http = require('http');
const http = require("http");
const server = http.createServer(app);
const peerServer = ExpressPeerServer(server, {
debug: true,
path: '/myapp'
path: "/myapp",
});
app.use('/peerjs', peerServer);
app.use("/peerjs", peerServer);
server.listen(9000);
@ -236,18 +248,20 @@ $ npm test
We have 'ready to use' images on docker hub:
https://hub.docker.com/r/peerjs/peerjs-server
To run the latest image:
```sh
$ docker run -p 9000:9000 -d peerjs/peerjs-server
```
You can build a new image simply by calling:
```sh
$ docker build -t myimage https://github.com/peers/peerjs-server.git
```
To run the image execute this:
```sh
$ docker run -p 9000:9000 -d myimage
```
@ -289,23 +303,23 @@ resources:
3. Create `server.js` (which node will run by default for the `start` script):
```js
const express = require('express');
const { ExpressPeerServer } = require('peer');
const express = require("express");
const { ExpressPeerServer } = require("peer");
const app = express();
app.enable('trust proxy');
app.enable("trust proxy");
const PORT = process.env.PORT || 9000;
const server = app.listen(PORT, () => {
console.log(`App listening on port ${PORT}`);
console.log('Press Ctrl+C to quit.');
console.log("Press Ctrl+C to quit.");
});
const peerServer = ExpressPeerServer(server, {
path: '/'
path: "/",
});
app.use('/', peerServer);
app.use("/", peerServer);
module.exports = app;
```

14
__test__/messageHandler/handlers/heartbeat/index.spec.ts
View File

@ -1,17 +1,17 @@
import { describe, expect, it } from "@jest/globals";
import { Client } from '../../../../src/models/client';
import { HeartbeatHandler } from '../../../../src/messageHandler/handlers';
import { Client } from "../../../../src/models/client";
import { HeartbeatHandler } from "../../../../src/messageHandler/handlers";
describe('Heartbeat handler', () => {
it('should update last ping time', () => {
const client = new Client({ id: 'id', token: '' });
describe("Heartbeat handler", () => {
it("should update last ping time", () => {
const client = new Client({ id: "id", token: "" });
client.setLastPing(0);
const nowTime = new Date().getTime();
HeartbeatHandler(client);
expect(client.getLastPing()).toBeGreaterThanOrEqual(nowTime-2)
expect(nowTime).toBeGreaterThanOrEqual(client.getLastPing())
expect(client.getLastPing()).toBeGreaterThanOrEqual(nowTime - 2);
expect(nowTime).toBeGreaterThanOrEqual(client.getLastPing());
});
});

16
__test__/messageHandler/handlersRegistry.spec.ts
View File

@ -1,11 +1,11 @@
import { describe, expect, it } from "@jest/globals";
import { HandlersRegistry } from '../../src/messageHandler/handlersRegistry';
import type { Handler } from '../../src/messageHandler/handler';
import { MessageType } from '../../src/enums';
import { HandlersRegistry } from "../../src/messageHandler/handlersRegistry";
import type { Handler } from "../../src/messageHandler/handler";
import { MessageType } from "../../src/enums";
describe('HandlersRegistry', () => {
it('should execute handler for message type', () => {
describe("HandlersRegistry", () => {
it("should execute handler for message type", () => {
const handlersRegistry = new HandlersRegistry();
let handled = false;
@ -17,7 +17,11 @@ describe('HandlersRegistry', () => {
handlersRegistry.registerHandler(MessageType.OPEN, handler);
handlersRegistry.handle(undefined, { type: MessageType.OPEN, src: 'src', dst: 'dst' });
handlersRegistry.handle(undefined, {
type: MessageType.OPEN,
src: "src",
dst: "dst",
});
expect(handled).toBe(true);
});

30
__test__/models/messageQueue.spec.ts
View File

@ -1,34 +1,34 @@
import { describe, expect, it } from "@jest/globals";
import { MessageQueue } from '../../src/models/messageQueue';
import { MessageType } from '../../src/enums';
import type { IMessage } from '../../src/models/message';
import { wait } from '../utils';
import { MessageQueue } from "../../src/models/messageQueue";
import { MessageType } from "../../src/enums";
import type { IMessage } from "../../src/models/message";
import { wait } from "../utils";
describe('MessageQueue', () => {
describe("MessageQueue", () => {
const createTestMessage = (): IMessage => {
return {
type: MessageType.OPEN,
src: 'src',
dst: 'dst'
src: "src",
dst: "dst",
};
};
describe('#addMessage', () => {
it('should add message to queue', () => {
describe("#addMessage", () => {
it("should add message to queue", () => {
const queue = new MessageQueue();
queue.addMessage(createTestMessage());
expect(queue.getMessages().length).toBe(1);
});
});
describe('#readMessage', () => {
it('should return undefined for empty queue', () => {
describe("#readMessage", () => {
it("should return undefined for empty queue", () => {
const queue = new MessageQueue();
expect(queue.readMessage()).toBeUndefined();
});
it('should return message if any exists in queue', () => {
it("should return message if any exists in queue", () => {
const queue = new MessageQueue();
const message = createTestMessage();
queue.addMessage(message);
@ -38,15 +38,15 @@ describe('MessageQueue', () => {
});
});
describe('#getLastReadAt', () => {
it('should not be changed if no messages when read', () => {
describe("#getLastReadAt", () => {
it("should not be changed if no messages when read", () => {
const queue = new MessageQueue();
const lastReadAt = queue.getLastReadAt();
queue.readMessage();
expect(queue.getLastReadAt()).toBe(lastReadAt);
});
it('should be changed when read message', async () => {
it("should be changed when read message", async () => {
const queue = new MessageQueue();
const lastReadAt = queue.getLastReadAt();
queue.addMessage(createTestMessage());

48
__test__/models/realm.spec.ts
View File

@ -1,50 +1,50 @@
import { describe, expect, it } from "@jest/globals";
import { Realm } from '../../src/models/realm';
import { Client } from '../../src/models/client';
import { Realm } from "../../src/models/realm";
import { Client } from "../../src/models/client";
describe('Realm', () => {
describe('#generateClientId', () => {
it('should generate a 36-character UUID, or return function value', () => {
describe("Realm", () => {
describe("#generateClientId", () => {
it("should generate a 36-character UUID, or return function value", () => {
const realm = new Realm();
expect(realm.generateClientId().length).toBe(36);
expect(realm.generateClientId(() => 'abcd')).toBe('abcd');
expect(realm.generateClientId(() => "abcd")).toBe("abcd");
});
});
describe('#setClient', () => {
it('should add client to realm', () => {
describe("#setClient", () => {
it("should add client to realm", () => {
const realm = new Realm();
const client = new Client({ id: 'id', token: '' });
const client = new Client({ id: "id", token: "" });
realm.setClient(client, 'id');
expect(realm.getClientsIds()).toEqual(['id']);
realm.setClient(client, "id");
expect(realm.getClientsIds()).toEqual(["id"]);
});
});
describe('#removeClientById', () => {
it('should remove client from realm', () => {
describe("#removeClientById", () => {
it("should remove client from realm", () => {
const realm = new Realm();
const client = new Client({ id: 'id', token: '' });
const client = new Client({ id: "id", token: "" });
realm.setClient(client, 'id');
realm.removeClientById('id');
realm.setClient(client, "id");
realm.removeClientById("id");
expect(realm.getClientById('id')).toBeUndefined();
expect(realm.getClientById("id")).toBeUndefined();
});
});
describe('#getClientsIds', () => {
it('should reflects on add/remove childs', () => {
describe("#getClientsIds", () => {
it("should reflects on add/remove childs", () => {
const realm = new Realm();
const client = new Client({ id: 'id', token: '' });
const client = new Client({ id: "id", token: "" });
realm.setClient(client, 'id');
expect(realm.getClientsIds()).toEqual(['id']);
realm.setClient(client, "id");
expect(realm.getClientsIds()).toEqual(["id"]);
expect(realm.getClientById('id')).toBe(client);
expect(realm.getClientById("id")).toBe(client);
realm.removeClientById('id');
realm.removeClientById("id");
expect(realm.getClientsIds()).toEqual([]);
});
});

70
__test__/peerjs.spec.ts
View File

@ -1,91 +1,91 @@
import { describe, expect, it } from "@jest/globals";
import http from 'http';
import expectedJson from '../app.json';
import http from "http";
import expectedJson from "../app.json";
import fetch from "node-fetch";
import * as crypto from "crypto";
import { startServer } from "./utils";
const PORT = '9000';
const PORT = "9000";
async function makeRequest() {
return new Promise<object>((resolve, reject) => {
http.get(`http://localhost:${PORT}/`, resp => {
let data = '';
http
.get(`http://localhost:${PORT}/`, (resp) => {
let data = "";
resp.on('data', chunk => {
resp.on("data", (chunk) => {
data += chunk;
});
resp.on('end', () => {
resp.on("end", () => {
resolve(JSON.parse(data));
});
}).on("error", err => {
})
.on("error", (err) => {
console.log("Error: " + err.message);
reject(err);
});
});
}
describe('Check bin/peerjs', () => {
it('should return content of app.json file', async () => {
describe("Check bin/peerjs", () => {
it("should return content of app.json file", async () => {
expect.assertions(1);
const ls = await startServer()
const ls = await startServer();
try {
const resp = await makeRequest();
expect(resp).toEqual(expectedJson);
} finally {
ls.kill();
}
});
it('should reflect the origin header in CORS by default', async () => {
it("should reflect the origin header in CORS by default", async () => {
expect.assertions(1);
const ls = await startServer()
const ls = await startServer();
const origin = crypto.randomUUID();
try {
const res = await fetch(`http://localhost:${PORT}/peerjs/id`, {
headers: {
Origin: origin
}
})
expect(res.headers.get("access-control-allow-origin")).toBe(origin)
Origin: origin,
},
});
expect(res.headers.get("access-control-allow-origin")).toBe(origin);
} finally {
ls.kill()
ls.kill();
}
});
it('should respect the CORS parameters', async () => {
it("should respect the CORS parameters", async () => {
expect.assertions(3);
const origin1 = crypto.randomUUID();
const origin2 = crypto.randomUUID();
const origin3 = crypto.randomUUID();
const ls = await startServer(["--cors", origin1, "--cors", origin2])
const ls = await startServer(["--cors", origin1, "--cors", origin2]);
try {
const res1 = await fetch(`http://localhost:${PORT}/peerjs/id`, {
headers: {
Origin: origin1
}
})
expect(res1.headers.get("access-control-allow-origin")).toBe(origin1)
Origin: origin1,
},
});
expect(res1.headers.get("access-control-allow-origin")).toBe(origin1);
const res2 = await fetch(`http://localhost:${PORT}/peerjs/id`, {
headers: {
Origin: origin2
}
})
expect(res2.headers.get("access-control-allow-origin")).toBe(origin2)
Origin: origin2,
},
});
expect(res2.headers.get("access-control-allow-origin")).toBe(origin2);
const res3 = await fetch(`http://localhost:${PORT}/peerjs/id`, {
headers: {
Origin: origin3
}
})
expect(res3.headers.get("access-control-allow-origin")).toBe(null)
Origin: origin3,
},
});
expect(res3.headers.get("access-control-allow-origin")).toBe(null);
} finally {
ls.kill()
ls.kill();
}
});
});

38
__test__/services/checkBrokenConnections/index.spec.ts
View File

@ -1,33 +1,41 @@
import { describe, expect, it } from "@jest/globals";
import { Client } from '../../../src/models/client';
import { Realm } from '../../../src/models/realm';
import { CheckBrokenConnections } from '../../../src/services/checkBrokenConnections';
import { wait } from '../../utils';
import { Client } from "../../../src/models/client";
import { Realm } from "../../../src/models/realm";
import { CheckBrokenConnections } from "../../../src/services/checkBrokenConnections";
import { wait } from "../../utils";
describe('CheckBrokenConnections', () => {
it('should remove client after 2 checks', async () => {
describe("CheckBrokenConnections", () => {
it("should remove client after 2 checks", async () => {
const realm = new Realm();
const doubleCheckTime = 55; //~ equals to checkBrokenConnections.checkInterval * 2
const checkBrokenConnections = new CheckBrokenConnections({ realm, config: { alive_timeout: doubleCheckTime }, checkInterval: 30 });
const client = new Client({ id: 'id', token: '' });
realm.setClient(client, 'id');
const checkBrokenConnections = new CheckBrokenConnections({
realm,
config: { alive_timeout: doubleCheckTime },
checkInterval: 30,
});
const client = new Client({ id: "id", token: "" });
realm.setClient(client, "id");
checkBrokenConnections.start();
await wait(checkBrokenConnections.checkInterval * 2 + 30);
expect(realm.getClientById('id')).toBeUndefined();
expect(realm.getClientById("id")).toBeUndefined();
checkBrokenConnections.stop();
});
it('should remove client after 1 ping', async () => {
it("should remove client after 1 ping", async () => {
const realm = new Realm();
const doubleCheckTime = 55; //~ equals to checkBrokenConnections.checkInterval * 2
const checkBrokenConnections = new CheckBrokenConnections({ realm, config: { alive_timeout: doubleCheckTime }, checkInterval: 30 });
const client = new Client({ id: 'id', token: '' });
realm.setClient(client, 'id');
const checkBrokenConnections = new CheckBrokenConnections({
realm,
config: { alive_timeout: doubleCheckTime },
checkInterval: 30,
});
const client = new Client({ id: "id", token: "" });
realm.setClient(client, "id");
checkBrokenConnections.start();
@ -38,7 +46,7 @@ describe('CheckBrokenConnections', () => {
await wait(checkBrokenConnections.checkInterval * 2 + 10);
expect(realm.getClientById('id')).toBeUndefined();
expect(realm.getClientById("id")).toBeUndefined();
checkBrokenConnections.stop();
});

62
__test__/services/messagesExpire/index.spec.ts
View File

@ -1,40 +1,49 @@
import { describe, expect, it } from "@jest/globals";
import { Client } from '../../../src/models/client';
import { Realm } from '../../../src/models/realm';
import type { IMessage } from '../../../src/models/message';
import { MessagesExpire } from '../../../src/services/messagesExpire';
import { MessageHandler } from '../../../src/messageHandler';
import { MessageType } from '../../../src/enums';
import { wait } from '../../utils';
import { Client } from "../../../src/models/client";
import { Realm } from "../../../src/models/realm";
import type { IMessage } from "../../../src/models/message";
import { MessagesExpire } from "../../../src/services/messagesExpire";
import { MessageHandler } from "../../../src/messageHandler";
import { MessageType } from "../../../src/enums";
import { wait } from "../../utils";
describe('MessagesExpire', () => {
describe("MessagesExpire", () => {
const createTestMessage = (dst: string): IMessage => {
return {
type: MessageType.OPEN,
src: 'src',
src: "src",
dst,
};
};
it('should remove client if no read from queue', async () => {
it("should remove client if no read from queue", async () => {
const realm = new Realm();
const messageHandler = new MessageHandler(realm);
const checkInterval = 10;
const expireTimeout = 50;
const config = { cleanup_out_msgs: checkInterval, expire_timeout: expireTimeout };
const config = {
cleanup_out_msgs: checkInterval,
expire_timeout: expireTimeout,
};
const messagesExpire = new MessagesExpire({ realm, config, messageHandler });
const messagesExpire = new MessagesExpire({
realm,
config,
messageHandler,
});
const client = new Client({ id: 'id', token: '' });
realm.setClient(client, 'id');
realm.addMessageToQueue(client.getId(), createTestMessage('dst'));
const client = new Client({ id: "id", token: "" });
realm.setClient(client, "id");
realm.addMessageToQueue(client.getId(), createTestMessage("dst"));
messagesExpire.startMessagesExpiration();
await wait(checkInterval * 2);
expect(realm.getMessageQueueById(client.getId())?.getMessages().length).toBe(1);
expect(
realm.getMessageQueueById(client.getId())?.getMessages().length,
).toBe(1);
await wait(expireTimeout);
@ -43,19 +52,26 @@ describe('MessagesExpire', () => {
messagesExpire.stopMessagesExpiration();
});
it('should fire EXPIRE message', async () => {
it("should fire EXPIRE message", async () => {
const realm = new Realm();
const messageHandler = new MessageHandler(realm);
const checkInterval = 10;
const expireTimeout = 50;
const config = { cleanup_out_msgs: checkInterval, expire_timeout: expireTimeout };
const config = {
cleanup_out_msgs: checkInterval,
expire_timeout: expireTimeout,
};
const messagesExpire = new MessagesExpire({ realm, config, messageHandler });
const messagesExpire = new MessagesExpire({
realm,
config,
messageHandler,
});
const client = new Client({ id: 'id', token: '' });
realm.setClient(client, 'id');
realm.addMessageToQueue(client.getId(), createTestMessage('dst1'));
realm.addMessageToQueue(client.getId(), createTestMessage('dst2'));
const client = new Client({ id: "id", token: "" });
realm.setClient(client, "id");
realm.addMessageToQueue(client.getId(), createTestMessage("dst1"));
realm.addMessageToQueue(client.getId(), createTestMessage("dst2"));
let handledCount = 0;

140
__test__/services/webSocketServer/index.spec.ts
View File

@ -1,32 +1,35 @@
import { describe, expect, it } from "@jest/globals";
import { Server, WebSocket } from 'mock-socket';
import type {Server as HttpServer} from 'node:http';
import { Realm } from '../../../src/models/realm';
import { WebSocketServer } from '../../../src/services/webSocketServer';
import { Errors, MessageType } from '../../../src/enums';
import { wait } from '../../utils';
import { Server, WebSocket } from "mock-socket";
import type { Server as HttpServer } from "node:http";
import { Realm } from "../../../src/models/realm";
import { WebSocketServer } from "../../../src/services/webSocketServer";
import { Errors, MessageType } from "../../../src/enums";
import { wait } from "../../utils";
type Destroyable<T> = T & { destroy?: () => Promise<void>; };
type Destroyable<T> = T & { destroy?: () => Promise<void> };
const checkOpen = async (c: WebSocket): Promise<boolean> => {
return new Promise(resolve => {
c.onmessage = (event: object & { data?: string; }): void => {
return new Promise((resolve) => {
c.onmessage = (event: object & { data?: string }): void => {
const message = JSON.parse(event.data as string);
resolve(message.type === MessageType.OPEN);
};
});
};
const checkSequence = async (c: WebSocket, msgs: { type: MessageType; error?: Errors; }[]): Promise<boolean> => {
return new Promise(resolve => {
const checkSequence = async (
c: WebSocket,
msgs: { type: MessageType; error?: Errors }[],
): Promise<boolean> => {
return new Promise((resolve) => {
const restMessages = [...msgs];
const finish = (success = false): void => {
resolve(success);
};
c.onmessage = (event: object & { data?: string; }): void => {
c.onmessage = (event: object & { data?: string }): void => {
const [mes] = restMessages;
if (!mes) {
@ -53,16 +56,38 @@ const checkSequence = async (c: WebSocket, msgs: { type: MessageType; error?: Er
});
};
const createTestServer = ({ realm, config, url }: { realm: Realm; config: { path: string; key: string; concurrent_limit: number; }; url: string; }): Destroyable<WebSocketServer> => {
const createTestServer = ({
realm,
config,
url,
}: {
realm: Realm;
config: { path: string; key: string; concurrent_limit: number };
url: string;
}): Destroyable<WebSocketServer> => {
const server = new Server(url) as Server & HttpServer;
const webSocketServer: Destroyable<WebSocketServer> = new WebSocketServer({ server, realm, config });
const webSocketServer: Destroyable<WebSocketServer> = new WebSocketServer({
server,
realm,
config,
});
server.on('connection', (socket: WebSocket & { on?: (eventName: string, callback: () => void) => void; }) => {
server.on(
"connection",
(
socket: WebSocket & {
on?: (eventName: string, callback: () => void) => void;
},
) => {
const s = webSocketServer.socketServer;
s.emit('connection', socket, { url: socket.url });
s.emit("connection", socket, { url: socket.url });
socket.onclose = (): void => {
const userId = socket.url.split('?')[1]?.split('&').find(p => p.startsWith('id'))?.split('=')[1];
const userId = socket.url
.split("?")[1]
?.split("&")
.find((p) => p.startsWith("id"))
?.split("=")[1];
if (!userId) return;
@ -72,11 +97,17 @@ const createTestServer = ({ realm, config, url }: { realm: Realm; config: { path
if (!clientSocket) return;
(clientSocket as unknown as WebSocket).listeners['server::close']?.forEach((s: () => void) => s());
(clientSocket as unknown as WebSocket).listeners[
"server::close"
]?.forEach((s: () => void) => s());
};
socket.onmessage = (event: object & { data?: string; }): void => {
const userId = socket.url.split('?')[1]?.split('&').find(p => p.startsWith('id'))?.split('=')[1];
socket.onmessage = (event: object & { data?: string }): void => {
const userId = socket.url
.split("?")[1]
?.split("&")
.find((p) => p.startsWith("id"))
?.split("=")[1];
if (!userId) return;
@ -86,9 +117,12 @@ const createTestServer = ({ realm, config, url }: { realm: Realm; config: { path
if (!clientSocket) return;
(clientSocket as unknown as WebSocket).listeners['server::message']?.forEach((s: (data: object) => void) => s(event));
(clientSocket as unknown as WebSocket).listeners[
"server::message"
]?.forEach((s: (data: object) => void) => s(event));
};
});
},
);
webSocketServer.destroy = async (): Promise<void> => {
server.close();
@ -97,22 +131,25 @@ const createTestServer = ({ realm, config, url }: { realm: Realm; config: { path
return webSocketServer;
};
describe('WebSocketServer', () => {
it('should return valid path', () => {
describe("WebSocketServer", () => {
it("should return valid path", () => {
const realm = new Realm();
const config = { path: '/', key: 'testKey', concurrent_limit: 1 };
const config2 = { ...config, path: 'path' };
const server = new Server('path1') as Server & HttpServer;
const server2 = new Server('path2') as Server & HttpServer;
const config = { path: "/", key: "testKey", concurrent_limit: 1 };
const config2 = { ...config, path: "path" };
const server = new Server("path1") as Server & HttpServer;
const server2 = new Server("path2") as Server & HttpServer;
const webSocketServer = new WebSocketServer({ server, realm, config });
expect(webSocketServer.path).toBe('/peerjs');
expect(webSocketServer.path).toBe("/peerjs");
const webSocketServer2 = new WebSocketServer({ server: server2, realm, config: config2 });
const webSocketServer2 = new WebSocketServer({
server: server2,
realm,
config: config2,
});
expect(webSocketServer2.path).toBe('path/peerjs');
expect(webSocketServer2.path).toBe("path/peerjs");
server.stop();
server2.stop();
@ -120,15 +157,20 @@ describe('WebSocketServer', () => {
it(`should check client's params`, async () => {
const realm = new Realm();
const config = { path: '/', key: 'testKey', concurrent_limit: 1 };
const fakeURL = 'ws://localhost:8080/peerjs';
const config = { path: "/", key: "testKey", concurrent_limit: 1 };
const fakeURL = "ws://localhost:8080/peerjs";
const getError = async (url: string, validError: Errors = Errors.INVALID_WS_PARAMETERS): Promise<boolean> => {
const getError = async (
url: string,
validError: Errors = Errors.INVALID_WS_PARAMETERS,
): Promise<boolean> => {
const webSocketServer = createTestServer({ url, realm, config });
const ws = new WebSocket(url);
const errorSent = await checkSequence(ws, [{ type: MessageType.ERROR, error: validError }]);
const errorSent = await checkSequence(ws, [
{ type: MessageType.ERROR, error: validError },
]);
ws.close();
@ -140,13 +182,18 @@ describe('WebSocketServer', () => {
expect(await getError(fakeURL)).toBe(true);
expect(await getError(`${fakeURL}?key=${config.key}`)).toBe(true);
expect(await getError(`${fakeURL}?key=${config.key}&id=1`)).toBe(true);
expect(await getError(`${fakeURL}?key=notValidKey&id=userId&token=userToken`, Errors.INVALID_KEY)).toBe(true);
expect(
await getError(
`${fakeURL}?key=notValidKey&id=userId&token=userToken`,
Errors.INVALID_KEY,
),
).toBe(true);
});
it(`should check concurrent limit`, async () => {
const realm = new Realm();
const config = { path: '/', key: 'testKey', concurrent_limit: 1 };
const fakeURL = 'ws://localhost:8080/peerjs';
const config = { path: "/", key: "testKey", concurrent_limit: 1 };
const fakeURL = "ws://localhost:8080/peerjs";
const createClient = (id: string): Destroyable<WebSocket> => {
// id in the path ensures that all mock servers listen on different urls
@ -169,16 +216,17 @@ describe('WebSocketServer', () => {
return ws;
};
const c1 = createClient('1');
const c1 = createClient("1");
expect(await checkOpen(c1)).toBe(true);
const c2 = createClient('2');
const c2 = createClient("2");
expect(await checkSequence(c2, [
{ type: MessageType.ERROR, error: Errors.CONNECTION_LIMIT_EXCEED }
])).toBe(true);
expect(
await checkSequence(c2, [
{ type: MessageType.ERROR, error: Errors.CONNECTION_LIMIT_EXCEED },
]),
).toBe(true);
await c1.destroy?.();
await c2.destroy?.();
@ -187,7 +235,7 @@ describe('WebSocketServer', () => {
expect(realm.getClientsIds().length).toBe(0);
const c3 = createClient('3');
const c3 = createClient("3");
expect(await checkOpen(c3)).toBe(true);

22
__test__/utils.ts
View File

@ -1,15 +1,21 @@
import { ChildProcessWithoutNullStreams, spawn } from "child_process";
import path from "path";
export const wait = (ms: number): Promise<void> => new Promise(resolve => setTimeout(resolve, ms));
export const wait = (ms: number): Promise<void> =>
new Promise((resolve) => setTimeout(resolve, ms));
export const startServer = (params: string[] = []) => {
return new Promise<ChildProcessWithoutNullStreams>((resolve, reject) => {
const ls = spawn('node', [path.join(__dirname, '../', 'dist/bin/peerjs.js'), '--port', "9000", ...params]);
ls.stdout.once("data", ()=> resolve(ls))
const ls = spawn("node", [
path.join(__dirname, "../", "dist/bin/peerjs.js"),
"--port",
"9000",
...params,
]);
ls.stdout.once("data", () => resolve(ls));
ls.stderr.once("data", () => {
ls.kill()
reject()
})
})
}
ls.kill();
reject();
});
});
};

15
bin/peerjs.ts
View File

@ -5,14 +5,14 @@ import {version} from "../package.json";
import fs from "node:fs";
const optimistUsageLength = 98;
import yargs from "yargs";
import { hideBin } from 'yargs/helpers'
import { hideBin } from "yargs/helpers";
import { PeerServer } from "../src";
import type { AddressInfo } from "node:net";
import type { CorsOptions } from "cors";
const y = yargs(hideBin(process.argv));
const portEnvIsSet = !!process.env["PORT"]
const portEnvIsSet = !!process.env["PORT"];
const opts = y
.usage("Usage: $0")
@ -86,14 +86,15 @@ const opts = y
describe: "Set the list of CORS origins",
},
})
.boolean("allow_discovery").parseSync();
.boolean("allow_discovery")
.parseSync();
if (!opts.port) {
opts.port= parseInt(process.env["PORT"] as string)
opts.port = parseInt(process.env["PORT"] as string);
}
if (opts.cors) {
opts["corsOptions"] = {
origin: opts.cors
origin: opts.cors,
} satisfies CorsOptions;
}
process.on("uncaughtException", function (e) {
@ -109,7 +110,7 @@ if (opts.sslkey || opts.sslcert) {
} else {
console.error(
"Warning: PeerServer will not run because either " +
"the key or the certificate has not been provided."
"the key or the certificate has not been provided.",
);
process.exit(1);
}
@ -124,7 +125,7 @@ const server = PeerServer(opts, (server) => {
host,
port,
userPath || "/",
version
version,
);
const shutdownApp = () => {

2
jest.config.js
View File

@ -7,7 +7,7 @@ const config = {
transformIgnorePatterns: [
// "node_modules"
],
collectCoverageFrom: ["./src/**"]
collectCoverageFrom: ["./src/**"],
};
export default config;

7
src/api/README.md
View File

@ -8,8 +8,9 @@ So, the base path should be like `http://127.0.0.1:9000/` or `http://127.0.0.1:9
Endpoints:
* GET `/` - return a JSON to test the server.
- GET `/` - return a JSON to test the server.
This group of methods uses `:key` option from config:
* GET `/:key/id` - return a new user id. required `:key` from config.
* GET `/:key/peers` - return an array of all connected users. required `:key` from config. **IMPORTANT:** You should set `allow_discovery` to `true` in config to enable this method. It disabled by default.
- GET `/:key/id` - return a new user id. required `:key` from config.
- GET `/:key/peers` - return an array of all connected users. required `:key` from config. **IMPORTANT:** You should set `allow_discovery` to `true` in config to enable this method. It disabled by default.

6
src/api/index.ts
View File

@ -5,7 +5,11 @@ import PublicApi from "./v1/public";
import type { IConfig } from "../config";
import type { IRealm } from "../models/realm";
export const Api = ({ config, realm, corsOptions }: {
export const Api = ({
config,
realm,
corsOptions,
}: {
config: IConfig;
realm: IRealm;
corsOptions: CorsOptions;

8
src/api/v1/public/index.ts
View File

@ -2,8 +2,12 @@ import express from "express";
import type { IConfig } from "../../../config";
import type { IRealm } from "../../../models/realm";
export default ({ config, realm }: {
config: IConfig; realm: IRealm;
export default ({
config,
realm,
}: {
config: IConfig;
realm: IRealm;
}): express.Router => {
const app = express.Router();

2
src/config/index.ts
View File

@ -1,4 +1,4 @@
import type {WebSocketServer, ServerOptions} from 'ws';
import type { WebSocketServer, ServerOptions } from "ws";
import type { CorsOptions } from "cors";
export interface IConfig {

4
src/enums.ts
View File

@ -2,7 +2,7 @@ export enum Errors {
INVALID_KEY = "Invalid key provided",
INVALID_TOKEN = "Invalid token provided",
INVALID_WS_PARAMETERS = "No id, token, or key supplied to websocket server",
CONNECTION_LIMIT_EXCEED = "Server has reached its concurrent user limit"
CONNECTION_LIMIT_EXCEED = "Server has reached its concurrent user limit",
}
export enum MessageType {
@ -14,5 +14,5 @@ export enum MessageType {
EXPIRE = "EXPIRE",
HEARTBEAT = "HEARTBEAT",
ID_TAKEN = "ID-TAKEN",
ERROR = "ERROR"
ERROR = "ERROR",
}

35
src/index.ts
View File

@ -9,39 +9,49 @@ import {createInstance} from "./instance";
import type { IClient } from "./models/client";
import type { IMessage } from "./models/message";
export type {MessageType} from "./enums"
export type {IConfig, PeerServerEvents, IClient, IMessage}
export type { MessageType } from "./enums";
export type { IConfig, PeerServerEvents, IClient, IMessage };
function ExpressPeerServer(server: https.Server | http.Server, options?: Partial<IConfig>) {
function ExpressPeerServer(
server: https.Server | http.Server,
options?: Partial<IConfig>,
) {
const app = express();
const newOptions: IConfig = {
...defaultConfig,
...options
...options,
};
if (newOptions.proxied) {
app.set("trust proxy", newOptions.proxied === "false" ? false : !!newOptions.proxied);
app.set(
"trust proxy",
newOptions.proxied === "false" ? false : !!newOptions.proxied,
);
}
app.on("mount", () => {
if (!server) {
throw new Error("Server is not passed to constructor - " +
"can't start PeerServer");
throw new Error(
"Server is not passed to constructor - " + "can't start PeerServer",
);
}
createInstance({ app, server, options: newOptions });
});
return app as Express & PeerServerEvents
return app as Express & PeerServerEvents;
}
function PeerServer(options: Partial<IConfig> = {}, callback?: (server: https.Server | http.Server) => void) {
function PeerServer(
options: Partial<IConfig> = {},
callback?: (server: https.Server | http.Server) => void,
) {
const app = express();
let newOptions: IConfig = {
...defaultConfig,
...options
...options,
};
const port = newOptions.port;
@ -66,7 +76,4 @@ function PeerServer(options: Partial<IConfig> = {}, callback?: (server: https.Se
return peerjs;
}
export {
ExpressPeerServer,
PeerServer
};
export { ExpressPeerServer, PeerServer };

30
src/instance.ts
View File

@ -16,13 +16,20 @@ import type {IMessage} from "./models/message";
import type { IConfig } from "./config";
export interface PeerServerEvents {
on(event: 'connection', listener: (client: IClient) => void): this;
on(event: "message", listener: (client: IClient, message: IMessage) => void): this;
on(event: "connection", listener: (client: IClient) => void): this;
on(
event: "message",
listener: (client: IClient, message: IMessage) => void,
): this;
on(event: "disconnect", listener: (client: IClient) => void): this;
on(event: "error", listener: (client: Error) => void): this;
}
export const createInstance = ({ app, server, options }: {
export const createInstance = ({
app,
server,
options,
}: {
app: express.Application;
server: HttpServer | HttpsServer;
options: IConfig;
@ -32,24 +39,31 @@ export const createInstance = ({ app, server, options }: {
const messageHandler = new MessageHandler(realm);
const api = Api({ config, realm, corsOptions: options.corsOptions });
const messagesExpire: IMessagesExpire = new MessagesExpire({ realm, config, messageHandler });
const messagesExpire: IMessagesExpire = new MessagesExpire({
realm,
config,
messageHandler,
});
const checkBrokenConnections = new CheckBrokenConnections({
realm,
config,
onClose: client => {
onClose: (client) => {
app.emit("disconnect", client);
}
},
});
app.use(options.path, api);
//use mountpath for WS server
const customConfig = { ...config, path: path.posix.join(app.path(), options.path, '/') };
const customConfig = {
...config,
path: path.posix.join(app.path(), options.path, "/"),
};
const wss: IWebSocketServer = new WebSocketServer({
server,
realm,
config: customConfig
config: customConfig,
});
wss.on("connection", (client: IClient) => {

5
src/messageHandler/handler.ts
View File

@ -1,4 +1,7 @@
import type { IClient } from "../models/client";
import type { IMessage } from "../models/message";
export type Handler = (client: IClient | undefined, message: IMessage) => boolean;
export type Handler = (
client: IClient | undefined,
message: IMessage,
) => boolean;

8
src/messageHandler/handlers/transmission/index.ts
View File

@ -3,7 +3,11 @@ import type {IClient} from "../../../models/client";
import type { IMessage } from "../../../models/message";
import type { IRealm } from "../../../models/realm";
export const TransmissionHandler = ({ realm }: { realm: IRealm; }): (client: IClient | undefined, message: IMessage) => boolean => {
export const TransmissionHandler = ({
realm,
}: {
realm: IRealm;
}): ((client: IClient | undefined, message: IMessage) => boolean) => {
const handle = (client: IClient | undefined, message: IMessage) => {
const type = message.type;
const srcId = message.src;
@ -36,7 +40,7 @@ export const TransmissionHandler = ({ realm }: { realm: IRealm; }): (client: ICl
handle(client, {
type: MessageType.LEAVE,
src: dstId,
dst: srcId
dst: srcId,
});
}
} else {

43
src/messageHandler/index.ts
View File

@ -12,11 +12,17 @@ export interface IMessageHandler {
}
export class MessageHandler implements IMessageHandler {
constructor(realm: IRealm, private readonly handlersRegistry: IHandlersRegistry = new HandlersRegistry()) {
constructor(
realm: IRealm,
private readonly handlersRegistry: IHandlersRegistry = new HandlersRegistry(),
) {
const transmissionHandler: Handler = TransmissionHandler({ realm });
const heartbeatHandler: Handler = HeartbeatHandler;
const handleTransmission: Handler = (client: IClient | undefined, { type, src, dst, payload }: IMessage): boolean => {
const handleTransmission: Handler = (
client: IClient | undefined,
{ type, src, dst, payload }: IMessage,
): boolean => {
return transmissionHandler(client, {
type,
src,
@ -25,14 +31,33 @@ export class MessageHandler implements IMessageHandler {
});
};
const handleHeartbeat = (client: IClient | undefined, message: IMessage) => heartbeatHandler(client, message);
const handleHeartbeat = (client: IClient | undefined, message: IMessage) =>
heartbeatHandler(client, message);
this.handlersRegistry.registerHandler(MessageType.HEARTBEAT, handleHeartbeat);
this.handlersRegistry.registerHandler(MessageType.OFFER, handleTransmission);
this.handlersRegistry.registerHandler(MessageType.ANSWER, handleTransmission);
this.handlersRegistry.registerHandler(MessageType.CANDIDATE, handleTransmission);
this.handlersRegistry.registerHandler(MessageType.LEAVE, handleTransmission);
this.handlersRegistry.registerHandler(MessageType.EXPIRE, handleTransmission);
this.handlersRegistry.registerHandler(
MessageType.HEARTBEAT,
handleHeartbeat,
);
this.handlersRegistry.registerHandler(
MessageType.OFFER,
handleTransmission,
);
this.handlersRegistry.registerHandler(
MessageType.ANSWER,
handleTransmission,
);
this.handlersRegistry.registerHandler(
MessageType.CANDIDATE,
handleTransmission,
);
this.handlersRegistry.registerHandler(
MessageType.LEAVE,
handleTransmission,
);
this.handlersRegistry.registerHandler(
MessageType.EXPIRE,
handleTransmission,
);
}
public handle(client: IClient | undefined, message: IMessage): boolean {

2
src/models/client.ts
View File

@ -22,7 +22,7 @@ export class Client implements IClient {
private socket: WebSocket | null = null;
private lastPing: number = new Date().getTime();
constructor({ id, token }: { id: string; token: string; }) {
constructor({ id, token }: { id: string; token: string }) {
this.id = id;
this.token = token;
}

10
src/services/checkBrokenConnections/index.ts
View File

@ -4,17 +4,21 @@ import type {IRealm} from "../../models/realm";
const DEFAULT_CHECK_INTERVAL = 300;
type CustomConfig = Pick<IConfig, 'alive_timeout'>;
type CustomConfig = Pick<IConfig, "alive_timeout">;
export class CheckBrokenConnections {
public readonly checkInterval: number;
private timeoutId: NodeJS.Timeout | null = null;
private readonly realm: IRealm;
private readonly config: CustomConfig;
private readonly onClose?: (client: IClient) => void;
constructor({ realm, config, checkInterval = DEFAULT_CHECK_INTERVAL, onClose }: {
constructor({
realm,
config,
checkInterval = DEFAULT_CHECK_INTERVAL,
onClose,
}: {
realm: IRealm;
config: CustomConfig;
checkInterval?: number;

8
src/services/messagesExpire/index.ts
View File

@ -8,7 +8,7 @@ export interface IMessagesExpire {
stopMessagesExpiration(): void;
}
type CustomConfig = Pick<IConfig, 'cleanup_out_msgs' | 'expire_timeout'>;
type CustomConfig = Pick<IConfig, "cleanup_out_msgs" | "expire_timeout">;
export class MessagesExpire implements IMessagesExpire {
private readonly realm: IRealm;
@ -17,7 +17,11 @@ export class MessagesExpire implements IMessagesExpire {
private timeoutId: NodeJS.Timeout | null = null;
constructor({ realm, config, messageHandler }: {
constructor({
realm,
config,
messageHandler,
}: {
realm: IRealm;
config: CustomConfig;
messageHandler: IMessageHandler;

55
src/services/webSocketServer/index.ts
View File

@ -21,18 +21,28 @@ interface IAuthParams {
key?: string;
}
type CustomConfig = Pick<IConfig, 'path' | 'key' | 'concurrent_limit' | 'createWebSocketServer'>;
type CustomConfig = Pick<
IConfig,
"path" | "key" | "concurrent_limit" | "createWebSocketServer"
>;
const WS_PATH = 'peerjs';
const WS_PATH = "peerjs";
export class WebSocketServer extends EventEmitter implements IWebSocketServer {
public readonly path: string;
private readonly realm: IRealm;
private readonly config: CustomConfig;
public readonly socketServer: Server;
constructor({ server, realm, config }: { server: HttpServer | HttpsServer; realm: IRealm; config: CustomConfig; }) {
constructor({
server,
realm,
config,
}: {
server: HttpServer | HttpsServer;
realm: IRealm;
config: CustomConfig;
}) {
super();
this.setMaxListeners(0);
@ -41,28 +51,28 @@ export class WebSocketServer extends EventEmitter implements IWebSocketServer {
this.config = config;
const path = this.config.path;
this.path = `${path}${path.endsWith('/') ? "" : "/"}${WS_PATH}`;
this.path = `${path}${path.endsWith("/") ? "" : "/"}${WS_PATH}`;
const options: WebSocket.ServerOptions = {
path: this.path,
server,
};
this.socketServer = (
config.createWebSocketServer ?
config.createWebSocketServer(options) :
new Server(options)
);
this.socketServer = config.createWebSocketServer
? config.createWebSocketServer(options)
: new Server(options);
this.socketServer.on("connection", (socket, req) => this._onSocketConnection(socket, req));
this.socketServer.on("connection", (socket, req) =>
this._onSocketConnection(socket, req),
);
this.socketServer.on("error", (error: Error) => this._onSocketError(error));
}
private _onSocketConnection(socket: WebSocket, req: IncomingMessage): void {
// An unhandled socket error might crash the server. Handle it first.
socket.on("error", error => this._onSocketError(error))
socket.on("error", (error) => this._onSocketError(error));
const { query = {} } = url.parse(req.url ?? '', true);
const { query = {} } = url.parse(req.url ?? "", true);
const { id, token, key }: IAuthParams = query;
@ -79,10 +89,12 @@ export class WebSocketServer extends EventEmitter implements IWebSocketServer {
if (client) {
if (token !== client.getToken()) {
// ID-taken, invalid token
socket.send(JSON.stringify({
socket.send(
JSON.stringify({
type: MessageType.ID_TAKEN,
payload: { msg: "ID is taken" }
}));
payload: { msg: "ID is taken" },
}),
);
return socket.close();
}
@ -98,8 +110,11 @@ export class WebSocketServer extends EventEmitter implements IWebSocketServer {
this.emit("error", error);
}
private _registerClient({ socket, id, token }:
{
private _registerClient({
socket,
id,
token,
}: {
socket: WebSocket;
id: string;
token: string;
@ -149,8 +164,8 @@ export class WebSocketServer extends EventEmitter implements IWebSocketServer {
socket.send(
JSON.stringify({
type: MessageType.ERROR,
payload: { msg }
})
payload: { msg },
}),
);
socket.close();

14
tsconfig.json
View File

@ -1,19 +1,11 @@
{
"extends": "@tsconfig/node16-strictest-esm/tsconfig.json",
"compilerOptions": {
"lib": [
"esnext"
],
"lib": ["esnext"],
"noEmit": true,
"resolveJsonModule": true,
"exactOptionalPropertyTypes": false
},
"include": [
"./src/**/*",
"__test__/**/*"
],
"exclude": [
"test",
"bin"
]
"include": ["./src/**/*", "__test__/**/*"],
"exclude": ["test", "bin"]
}