insite-ws 1.0.350

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Eugene Nesvetaev
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,13 @@
+# inSite WebSockets
+
+## Installation
+
+```sh
+$ npm install insite-ws
+```
+
+Or
+
+```sh
+$ yarn add insite-ws
+```

package/lib/client/WebSocket.js

@@ -0,0 +1,223 @@
+import { debounce, noop } from "@nesvet/n";
+import EventEmitter from "eventemitter3";
+import { heartbeatGap, heartbeatInterval } from "../common";
+import { extendEventEmitter } from "../extendEventEmitter";
+
+
+const reconnectTimeout = 2000;
+
+let i = 0;
+
+
+export class InSiteWebSocket extends EventEmitter {
+	constructor(url, options = {}) {
+		super();
+		
+		extendEventEmitter(this);
+		
+		this.url = url;
+		
+		const {
+			name = i++,
+			protocols,
+			immediately = true,
+			autoReconnect = true,
+			on
+		} = options;
+		
+		this.name = name;
+		
+		this.protocols = protocols;
+		
+		this.autoReconnect = autoReconnect;
+		
+		if (on)
+			for (const eventName in on)
+				if (on[eventName])
+					this.on(eventName, on[eventName]);
+		
+		if (this.url && immediately)
+			this.open().catch(noop);
+		
+	}
+	
+	webSocket = null;
+	
+	#defib = debounce(function () {
+		
+		if (this.isOpen) {
+			if (process.env.NODE_ENV === "development")
+				console.info(`WebSocket ${this.name} has no heartbeat - going offline`);
+			
+			this.webSocket.close();
+		}
+		
+	}, heartbeatInterval + heartbeatGap);
+	
+	#openResolve;
+	#openReject;
+	
+	get isConnecting() {
+		return this.webSocket ? this.webSocket.readyState === this.webSocket.CONNECTING : null;
+	}
+	
+	get isOpen() {
+		return this.webSocket ? this.webSocket.readyState === this.webSocket.OPEN : null;
+	}
+	
+	get isClosing() {
+		return this.webSocket ? this.webSocket.readyState === this.webSocket.CLOSING : null;
+	}
+	
+	get isClosed() {
+		return this.webSocket ? this.webSocket.readyState === this.webSocket.CLOSED : null;
+	}
+	
+	isChanged = false;
+	
+	#handleWebSocketOpen = () => {
+		
+		this.#openResolve();
+		this.#openResolve = undefined;
+		this.#openReject = undefined;
+		
+		this.emit("open");
+		
+		this.#defib();
+		
+	};
+	
+	#handleWebSocketMessage = ({ data: message }) => {
+		
+		this.#defib();
+		
+		if (message)
+			try {
+				const [ kind, ...rest ] = JSON.parse(message);
+				
+				this.emit("message", kind, ...rest);
+				this.emit(`message:${kind}`, ...rest);
+			} catch (error) {
+				this.#handleWebSocketError(error);
+			}
+		 else
+			this.webSocket.send("");
+		
+	};
+	
+	#handleWebSocketError = error => {
+		if (error instanceof Event)
+			error = undefined;
+		
+		if (this.#openReject) {
+			this.#openReject(error);
+			this.#openResolve = undefined;
+			this.#openReject = undefined;
+		}
+		
+		this.emit("error", error);
+		
+	};
+	
+	#reconnectTimeout;
+	
+	#handleWebSocketClose = event => {
+		
+		if (process.env.NODE_ENV === "development")
+			console.info(`WebSocket ${this.name} is closed with code ${event.code} and reason "${event.reason}"`);
+		
+		this.#defib.clear();
+		
+		this.emit("close", event);
+		
+		if (this.autoReconnect && ![ 1002, 3500, 4000 ].includes(event.code)) {
+			if (process.env.NODE_ENV === "development")
+				console.info(`WebSocket ${this.name} will try to reconnect in 2 sec…`);
+			
+			this.#reconnectTimeout = setTimeout(() => this.open().catch(noop), reconnectTimeout);
+		}
+		
+	};
+	
+	open(options = {}) {
+		
+		clearTimeout(this.#reconnectTimeout);
+		
+		return this.close(4000, "reopen").then(() => {
+			
+			if (options.url)
+				this.url = options.url;
+			
+			if (options.protocols)
+				this.protocols = options.protocols;
+			
+			return new Promise((resolve, reject) => {
+				this.#openResolve = resolve;
+				this.#openReject = reject;
+				
+				if (this.webSocket) {
+					this.isChanged = this.webSocket._url !== this.url;
+					if (this.isChanged)
+						this.emit("server-change");
+				}
+				
+				this.webSocket = new WebSocket(this.url, this.protocols);
+				this.webSocket._url = this.url;
+				
+				this.emit("connecting");
+				
+				this.send = this.webSocket.send.bind(this.webSocket);
+				
+				this.webSocket.addEventListener("open", this.#handleWebSocketOpen);
+				this.webSocket.addEventListener("message", this.#handleWebSocketMessage);
+				this.webSocket.addEventListener("error", this.#handleWebSocketError);
+				this.webSocket.addEventListener("close", this.#handleWebSocketClose);
+				
+			});
+		});
+	}
+	
+	connect = this.open;
+	
+	close(code = 3500, reason = "manual") {
+		
+		clearTimeout(this.#reconnectTimeout);
+		
+		return new Promise(resolve => {
+			if (this.isConnecting || this.isOpen) {
+				this.webSocket.addEventListener("close", resolve);
+				this.webSocket.close(code, reason);
+			} else
+				resolve();
+			
+		});
+	}
+	
+	disconnect = this.close;
+	
+	#queue = [];
+	
+	#releaseQueue = () => {
+		
+		for (const message of this.#queue)
+			this.webSocket.send(message);
+		
+		this.#queue.length = 0;
+		
+	};
+	
+	sendMessage(...args) {
+		const message = JSON.stringify(args);
+		
+		if (this.isOpen)
+			this.webSocket.send(message);
+		else {
+			if (!this.#queue.length)
+				this.once("open", this.#releaseQueue);
+			
+			this.#queue.push(message);
+		}
+		
+	}
+	
+}

package/lib/client/index.js

@@ -0,0 +1 @@
+export * from "./WebSocket";

package/lib/common.js

@@ -0,0 +1,2 @@
+export const heartbeatInterval = 5_000;
+export const heartbeatGap = 60_000;

package/lib/extendEventEmitter.js

@@ -0,0 +1,46 @@
+/** @this EventEmitter */
+function extendedOn(...args) {
+	
+	for (const listenerHandler of this.listenerHandlers)
+		if (listenerHandler.call(this, true, ...args) !== undefined)
+			return;
+	
+	this.directOn(...args);
+	
+}
+
+/** @this EventEmitter */
+function extendedOnce(...args) {
+	
+	for (const listenerHandler of this.listenerHandlers)
+		if (listenerHandler.call(this, true, ...args) !== undefined)
+			return;
+	
+	this.directOnce(...args);
+	
+}
+
+/** @this EventEmitter */
+function extendedOff(...args) {
+	
+	for (const listenerHandler of this.listenerHandlers)
+		if (listenerHandler.call(this, false, ...args) !== undefined)
+			return;
+	
+	this.directOff(...args);
+	
+}
+
+export function extendEventEmitter(eventEmitter) {
+	
+	eventEmitter.directOn = eventEmitter.on;
+	eventEmitter.directOnce = eventEmitter.once;
+	eventEmitter.directOff = eventEmitter.off;
+	
+	eventEmitter.listenerHandlers = new Set();
+	
+	eventEmitter.on = extendedOn;
+	eventEmitter.once = extendedOnce;
+	eventEmitter.off = extendedOff;
+	
+}

package/lib/server/WebSocketServer.js

@@ -0,0 +1,117 @@
+import http from "node:http";
+import https from "node:https";
+import { debounce } from "@nesvet/n";
+import { WebSocketServer } from "ws";
+import { heartbeatGap, heartbeatInterval } from "../common";
+import { extendEventEmitter } from "../extendEventEmitter";
+import { defibSymbol, heartbeatIntervalSymbol, pingTsSymbol } from "./symbols";
+import { WebSocketServerClient } from "./WebSocketServerClient";
+
+
+export class InSiteWebSocketServer extends WebSocketServer {
+	constructor(options = {}, props) {
+		const {
+			upgrade,
+			ssl,
+			port,
+			server = ssl ? https.createServer({ ...ssl }) : http.createServer(),
+			...wssOptions
+		} = options;
+		
+		super({
+			...wssOptions,
+			WebSocket: WebSocketServerClient,
+			server
+		});
+		
+		extendEventEmitter(this);
+		
+		if ("upgrade" in this)
+			throw new Error("WebSocketServer now contains an \"upgrade\" property");
+		
+		if (props)
+			Object.assign(this, props);
+		
+		this.upgrade = upgrade;
+		
+		this.on("connection", this.#handleConnection);
+		
+		server.listen(port);
+		
+	}
+	
+	isWebSocketServer = true;
+	
+	#handleConnection(ws, request) {
+		ws.wss = this;
+		
+		ws.userAgent = request.headers["user-agent"];
+		ws.remoteAddress = request.headers["x-real-ip"] ?? request.headers["x-forwarded-for"];
+		
+		ws.on("message", InSiteWebSocketServer.handleClientMessage);
+		ws.on("error", InSiteWebSocketServer.handleClientError);
+		ws.on("close", InSiteWebSocketServer.handleClientClose);
+		
+		ws[defibSymbol] = debounce(() => ws.terminate(), heartbeatInterval + heartbeatGap);
+		ws[defibSymbol]();
+		
+		ws.latency = 0;
+		
+		ws[heartbeatIntervalSymbol] = setInterval(() => {
+			
+			ws[pingTsSymbol] = Date.now();
+			ws.send("");
+			
+		}, heartbeatInterval);
+		
+		this.emit("client-connect", ws, request);
+		
+	}
+	
+	static handleClientMessage(data) {
+		const message = data.toString();
+		
+		this[defibSymbol]();
+		
+		if (message)
+			try {
+				const [ kind, ...rest ] = JSON.parse(message);
+				
+				this.emit(`message:${kind}`, ...rest);
+				this.wss.emit("client-message", this, kind, ...rest);
+				this.wss.emit(`client-message:${kind}`, this, ...rest);
+			} catch (error) {
+				InSiteWebSocketServer.handleClientError.call(this, error);
+			}
+		 else if (this[pingTsSymbol]) {
+			this.latency = Date.now() - this[pingTsSymbol];
+			delete this[pingTsSymbol];
+		}
+		
+	}
+	
+	static handleClientError(error) {
+		if (error instanceof Event)
+			error = undefined;
+		
+		if (process.env.NODE_ENV === "development")
+			console.error("WebSocketServer Client error", error);
+		
+		this.wss.emit("client-error", this, error);
+		
+	}
+	
+	static handleClientClose(...args) {
+		
+		if (process.env.NODE_ENV === "development")
+			console.info("WebSocketServer Client closed", ...args);
+		
+		this[defibSymbol].clear();
+		clearInterval(this[heartbeatIntervalSymbol]);
+		
+		this.wss.emit("client-close", this);
+		this.wss.emit("client-closed", this);
+		
+	}
+	
+}

package/lib/server/WebSocketServerClient.js

@@ -0,0 +1,29 @@
+import WebSocket from "ws";
+
+
+export class InSiteWebSocketServerClient extends WebSocket {
+	
+	isWebSocketServerClient = true;
+	
+	get isConnecting() {
+		return this.readyState === this.CONNECTING;
+	}
+	
+	get isOpen() {
+		return this.readyState === this.OPEN;
+	}
+	
+	get isClosing() {
+		return this.readyState === this.CLOSING;
+	}
+	
+	get isClosed() {
+		return this.readyState === this.CLOSED;
+	}
+	
+	sendMessage(...args) {
+		this.send(JSON.stringify(args));
+		
+	}
+	
+}

package/lib/server/index.js

@@ -0,0 +1 @@
+export * from "./WebSocketServer";

package/lib/server/symbols.js

@@ -0,0 +1,3 @@
+export const heartbeatIntervalSymbol = Symbol("heartbeatInterval");
+export const defibSymbol = Symbol("defib");
+export const pingTsSymbol = Symbol("pingTs");

package/package.json

@@ -0,0 +1,33 @@
+{
+	"name": "insite-ws",
+	"version": "1.0.350",
+	"description": "inSite WebSockets",
+	"type": "module",
+	"exports": {
+		"./server": "./lib/server/index.js",
+		"./client": "./lib/client/index.js"
+	},
+	"packageManager": "yarn@1.22.22",
+	"scripts": {
+		"test": "echo \"Error: no test specified\" && exit 1"
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/nesvet/insite-ws.git"
+	},
+	"keywords": [
+		"insite",
+		"ws",
+		"websockets"
+	],
+	"author": "Eugene Nesvetaev <dev@nesvet.dev> (https://nesvet.dev/)",
+	"license": "MIT",
+	"dependencies": {
+		"@nesvet/n": "^1",
+		"eventemitter3": "^5",
+		"ws": "^8"
+	},
+	"devDependencies": {
+		"@nesvet/eslint-config": "^1"
+	}
+}