@arcblock/ws 1.28.9 → 1.29.0

package/esm/server/index.mjs

@@ -0,0 +1,474 @@
+import { __require } from "../_virtual/rolldown_runtime.mjs";
+import logger_default from "../logger.mjs";
+import EventEmitter from "node:events";
+import WebSocket, { WebSocketServer } from "ws";
+import cluster from "node:cluster";
+import get from "lodash/get.js";
+
+//#region src/server/index.ts
+const eventHub = cluster.isMaster ? __require("@arcblock/event-hub/single").default : __require("@arcblock/event-hub").default;
+const nanoid = (length = 16) => [...Array(length)].map(() => Math.random().toString(36)[2]).join("");
+const sleep = (timeout) => new Promise((resolve) => {
+	setTimeout(resolve, timeout);
+});
+const reply = ({ socket, topic, event, data = {}, status = "ok", ref = "", joinRef = "" }) => {
+	if (socket.readyState === WebSocket.OPEN) {
+		const res = JSON.stringify([
+			joinRef,
+			ref,
+			topic,
+			event,
+			{
+				status,
+				response: data
+			}
+		]);
+		socket.send(res);
+	}
+};
+const noop = () => {};
+const defaultHooks = {
+	authenticateJoinChannel: noop,
+	preJoinChannel: noop,
+	postJoinChannel: noop,
+	preLeaveChannel: noop,
+	postLeaveChannel: noop,
+	postBroadcast: noop,
+	postSend: noop,
+	receiveMessage: noop
+};
+const refreshHeartbeat = (socket) => {
+	socket.heartbeatAt = Date.now();
+};
+const HEARTBEAT_TIMEOUT = 300 * 1e3;
+/**
+* Create a websocket server
+*
+* @param {Object} opts
+* @param {String} opts.pathname - which path to mount the socket server
+* @param {Object} opts.authenticate - authentication function to be called on connection
+* @param {Object} opts.hooks - hooks to be called on events
+* @param {Object} opts.logger - logger used to log messages
+* @param {Object} opts.broadcastEventName - used in cluster mode, default is '@arcblock/ws:broadcast'
+* @param {Object} opts.heartbeatTimeout - maximum non-response time of a connection socket
+* @class WsServer
+* @extends {EventEmitter}
+*/
+var WsServer = class extends EventEmitter {
+	constructor(opts = {}) {
+		super();
+		this.pathname = opts.pathname;
+		this.authenticate = opts.authenticate;
+		this.hooks = Object.assign({}, defaultHooks, opts.hooks || {});
+		this.logger = opts.logger || logger_default("server", opts.silent);
+		this.skipLogOnHookError = opts.skipLogOnHookError || false;
+		this.heartbeatTimeout = opts.heartbeatTimeout || HEARTBEAT_TIMEOUT;
+		this.wss = new WebSocketServer({
+			noServer: true,
+			clientTracking: false
+		});
+		this.wss.on("connection", this.onWssConnection.bind(this));
+		this.wss.on("close", this.onWssClose.bind(this));
+		this.wss.on("error", this.onWssError.bind(this));
+		this.topics = {};
+		this.broadcastEventName = opts.broadcastEventName || "@arcblock/ws:broadcast";
+		eventHub.on(this.broadcastEventName, (data) => this._doBroadCast(data));
+	}
+	attach(server) {
+		server.on("upgrade", this.onConnect.bind(this));
+		return this;
+	}
+	onConnect(request, socket, head) {
+		const { pathname } = new URL(request.url, `http://${request.headers.host || "unknown"}`);
+		this.logger.debug("connect attempt", { pathname });
+		if (this.pathname && pathname !== this.pathname) {
+			socket.write("HTTP/1.1 404 Pathname mismatch\r\n\r\n");
+			socket.destroy();
+			return;
+		}
+		if (!this.authenticate) {
+			this.wss.handleUpgrade(request, socket, head, (ws) => {
+				this.wss.emit("connection", ws, request);
+			});
+			return;
+		}
+		this.authenticate(request, (err, authInfo) => {
+			if (err) {
+				socket.write("HTTP/1.1 401 Unauthorized\r\n\r\n");
+				socket.destroy();
+				return;
+			}
+			this.wss.handleUpgrade(request, socket, head, (ws) => {
+				ws.authInfo = authInfo;
+				this.wss.emit("connection", ws, request);
+			});
+		});
+	}
+	/**
+	* Broadcast message to all subscribers of a topic, can be used as
+	* - broadcast(event, data) ==> broadcast(event, event, data)
+	* - broadcast(topic, event, data)
+	* - broadcast(topic, event, data, options)
+	*/
+	async broadcast(...args) {
+		let topic;
+		let event;
+		let data;
+		let options = {};
+		let cb = () => {};
+		if (typeof args[args.length - 1] === "function") cb = args.pop();
+		if (args.length < 2) throw new Error("Broadcasting requires at least 2 arguments");
+		if (args.length === 2) {
+			[event, data] = args;
+			topic = event;
+		} else if (args.length === 3) [topic, event, data] = args;
+		else [topic, event, data, options] = args;
+		const enableLog = !!options.enableLog;
+		const { socketFilters, noCluster } = options;
+		const replyId = nanoid();
+		let count = 0;
+		if (noCluster) {
+			const { count: c } = this._doBroadCast({
+				topic,
+				event,
+				data,
+				enableLog,
+				socketFilters
+			});
+			count = c;
+		} else {
+			eventHub.on(replyId, ({ count: c } = {}) => {
+				if (c) count += c;
+			});
+			eventHub.broadcast(this.broadcastEventName, {
+				topic,
+				event,
+				data,
+				options,
+				enableLog,
+				replyId,
+				socketFilters
+			});
+			await sleep(600);
+			eventHub.off(replyId);
+		}
+		const opts = {
+			count,
+			topic,
+			event,
+			data,
+			options
+		};
+		cb(opts);
+		try {
+			await this.hooks.postBroadcast(opts);
+		} catch (error) {
+			if (!this.skipLogOnHookError) this.logger.error("postBroadcast error", { error });
+		}
+	}
+	_doBroadCast({ topic, event, data, enableLog, replyId, socketFilters } = {}) {
+		try {
+			let count = 0;
+			if (this.topics[topic]?.size) {
+				let conditions = null;
+				if (socketFilters && Object.keys(socketFilters).length) conditions = Object.entries(socketFilters);
+				this.topics[topic].forEach((socket) => {
+					const noHeartbeatTime = Date.now() - socket.heartbeatAt;
+					if (noHeartbeatTime > this.heartbeatTimeout) {
+						this.logger.error(`Socket has no heartbeat within ${Math.floor(noHeartbeatTime / 1e3)} seconds`, {
+							topic,
+							id: socket.id
+						});
+						this.topics[topic].delete(socket);
+						return;
+					}
+					if (conditions && !conditions.every(([key, value]) => get(socket, key) === value)) return;
+					count++;
+					if (enableLog) this.logger.info("broadcast message to", {
+						topic,
+						event,
+						id: socket.id
+					});
+					reply({
+						socket,
+						topic,
+						event,
+						data
+					});
+				});
+			}
+			if (count > 0 && replyId) eventHub.broadcast(replyId, { count });
+			return { count };
+		} catch (error) {
+			this.logger.error("_doBroadcast error", { error });
+			return {
+				count: 0,
+				error
+			};
+		}
+	}
+	/**
+	* Send message to 1 subscriber of a topic, can be used as
+	* - send(socket, event, data)
+	* - send(socket, topic, event, data)
+	* - send(socket, topic, event, data, options)
+	*/
+	async send(...args) {
+		let socket;
+		let topic;
+		let event;
+		let data;
+		let options = {};
+		if (args.length < 3) throw new Error("send requires at least 3 arguments");
+		if (args.length === 3) {
+			[socket, event, data] = args;
+			topic = event;
+		} else if (args.length === 4) [socket, topic, event, data] = args;
+		else [socket, topic, event, data, options] = args;
+		const opts = {
+			enableLog: true,
+			...options
+		};
+		if (!socket) {
+			this.logger.error("socket does not exist");
+			return;
+		}
+		if (opts.enableLog) this.logger.info("send message to", {
+			topic,
+			event,
+			id: socket.id
+		});
+		reply({
+			socket,
+			topic,
+			event,
+			data
+		});
+		try {
+			await this.hooks.postSend({
+				topic,
+				event,
+				data,
+				options
+			});
+		} catch (error) {
+			if (!this.skipLogOnHookError) this.logger.error("postSend error", { error });
+		}
+	}
+	/**
+	* private
+	*/
+	async onWssConnection(socket) {
+		const wsSocket = socket;
+		wsSocket.id = nanoid();
+		wsSocket.channel = {};
+		refreshHeartbeat(wsSocket);
+		this.logger.debug("socket connected", { id: wsSocket.id });
+		wsSocket.on("message", async (msg) => {
+			this.logger.debug("socket onmessage", msg.toString());
+			let joinRef;
+			let ref;
+			let topic;
+			let event;
+			let payload;
+			try {
+				[joinRef, ref, topic, event, payload] = JSON.parse(msg.toString());
+			} catch (err) {
+				this.logger.error("parse socket message error", {
+					id: wsSocket.id,
+					error: err
+				});
+				return;
+			}
+			if (!topic || !event) {
+				this.logger.warn?.("Invalid message format, topic/event fields are required");
+				return;
+			}
+			if (topic === "phoenix" && event === "heartbeat") {
+				reply({
+					socket: wsSocket,
+					topic,
+					event,
+					ref
+				});
+				refreshHeartbeat(wsSocket);
+				return;
+			}
+			if (event === "phx_join") {
+				try {
+					const authInfo = await this.hooks.authenticateJoinChannel({
+						socket: wsSocket,
+						joinRef,
+						ref,
+						topic,
+						event,
+						payload
+					});
+					await this.hooks.preJoinChannel({
+						socket: wsSocket,
+						joinRef,
+						ref,
+						topic,
+						event,
+						payload
+					});
+					wsSocket.channel[topic] = { authInfo };
+				} catch (error) {
+					if (!this.skipLogOnHookError) this.logger.error("preJoinChannel error", { error });
+					reply({
+						socket: wsSocket,
+						topic,
+						event: `chan_reply_${ref}`,
+						data: { message: error.message },
+						status: "error",
+						ref,
+						joinRef
+					});
+					return;
+				}
+				if (!this.topics[topic]) this.topics[topic] = /* @__PURE__ */ new Set();
+				this.topics[topic].add(wsSocket);
+				reply({
+					socket: wsSocket,
+					topic,
+					event: `chan_reply_${ref}`,
+					ref,
+					joinRef
+				});
+				this.emit("channel.join", {
+					socket: wsSocket,
+					topic,
+					event,
+					payload
+				});
+				try {
+					await this.hooks.postJoinChannel({
+						socket: wsSocket,
+						joinRef,
+						ref,
+						topic,
+						event,
+						payload
+					});
+				} catch (error) {
+					if (!this.skipLogOnHookError) this.logger.error("postJoinChannel error", { error });
+				}
+				return;
+			}
+			if (event === "phx_leave") {
+				try {
+					await this.hooks.preLeaveChannel({
+						socket: wsSocket,
+						joinRef,
+						ref,
+						topic,
+						event,
+						payload
+					});
+				} catch (error) {
+					if (!this.skipLogOnHookError) this.logger.error("preLeaveChannel error", { error });
+					reply({
+						socket: wsSocket,
+						topic,
+						event: `chan_reply_${ref}`,
+						data: { message: error.message },
+						status: "error",
+						ref,
+						joinRef
+					});
+					return;
+				}
+				this._leaveChannel(wsSocket, topic);
+				reply({
+					socket: wsSocket,
+					topic,
+					event: `chan_reply_${ref}`,
+					ref,
+					joinRef
+				});
+				try {
+					await this.hooks.postLeaveChannel({
+						socket: wsSocket,
+						joinRef,
+						ref,
+						topic,
+						event,
+						payload
+					});
+				} catch (error) {
+					if (!this.skipLogOnHookError) this.logger.error("postLeaveChannel error", { error });
+				}
+				return;
+			}
+			try {
+				await this.hooks.receiveMessage({
+					socket: wsSocket,
+					joinRef,
+					ref,
+					topic,
+					event,
+					payload
+				});
+			} catch (error) {
+				if (!this.skipLogOnHookError) this.logger.error("receiveMessage error", { error });
+				reply({
+					socket: wsSocket,
+					topic,
+					event: `chan_reply_${ref}`,
+					data: { message: error.message },
+					status: "error",
+					ref,
+					joinRef
+				});
+				return;
+			}
+			reply({
+				socket: wsSocket,
+				topic,
+				event: `chan_reply_${ref}`,
+				ref,
+				joinRef
+			});
+		});
+		wsSocket.on("close", () => {
+			this.logger.debug("socket onclose", { id: wsSocket.id });
+			Object.keys(this.topics).forEach((topic) => this._leaveChannel(wsSocket, topic));
+		});
+		wsSocket.on("error", (err) => {
+			this.logger.error("socket onerror", {
+				id: wsSocket.id,
+				error: err
+			});
+			Object.keys(this.topics).forEach((topic) => this._leaveChannel(wsSocket, topic));
+		});
+	}
+	/**
+	* private
+	*/
+	onWssClose() {
+		this.logger.debug("ws server onclose");
+		this.emit("close");
+	}
+	/**
+	* private
+	*/
+	onWssError(error) {
+		this.logger.error("ws server error", { error });
+		this.emit("error", error);
+	}
+	_leaveChannel(socket, topic) {
+		if (this.topics[topic]) this.topics[topic].delete(socket);
+		this.emit("channel.leave", {
+			socket,
+			topic
+		});
+		if (!this.topics[topic] || !this.topics[topic].size) this.emit("channel.destroy", {
+			socket,
+			topic
+		});
+	}
+};
+var server_default = WsServer;
+
+//#endregion
+export { server_default as default };

package/lib/_virtual/rolldown_runtime.cjs

@@ -0,0 +1,29 @@
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+
+exports.__toESM = __toESM;

package/lib/browser.cjs

@@ -0,0 +1,3 @@
+const require_client_browser = require('./client/browser.cjs');
+
+exports.WsClient = require_client_browser.default;

package/lib/browser.d.cts

@@ -0,0 +1,2 @@
+import _default from "./client/browser.cjs";
+export { _default as WsClient };

package/lib/client/base.cjs

@@ -0,0 +1,119 @@
+Object.defineProperty(exports, '__esModule', { value: true });
+const require_logger = require('../logger.cjs');
+
+//#region src/client/base.ts
+var base_default = (Socket, EventEmitter, transport) => {
+	return class WsClient extends Socket {
+		constructor(endpoint, opts = {}) {
+			super(endpoint, {
+				transport,
+				...opts
+			});
+			this._logger = require_logger.default("client", opts.silent);
+			this.emitter = new EventEmitter();
+			this.onOpen(() => {
+				this._logger.debug("socket open", endpoint);
+			});
+			this.onClose(() => {
+				this._logger.debug("socket close", endpoint);
+			});
+			this.onError((err) => {
+				this._logger.error("socket error", err.error);
+			});
+			this.onMessage((message) => {
+				this._logger.debug("socket message", message);
+			});
+		}
+		on(event, handler, params = {}) {
+			this.ensureJoinChannel(event, params);
+			this.emitter.on(event, handler);
+		}
+		off(event, handler) {
+			if (handler) this.emitter.off(event, handler);
+			else this.emitter.removeAllListeners(event);
+			this.ensureLeaveChannel(event);
+		}
+		disconnect(callback, code, reason) {
+			this.emitter.eventNames().forEach((event) => {
+				this.emitter.removeAllListeners(event);
+			});
+			super.disconnect(callback, code, reason);
+		}
+		/**
+		* private
+		*/
+		ensureJoinChannel(topic, params = {}) {
+			if (this.emitter.listenerCount(topic) > 0) return;
+			const channel = this.channel(topic, params);
+			channel.join().receive("ok", (message) => {
+				this._logger.debug("join success", {
+					topic,
+					message
+				});
+			}).receive("error", (error) => {
+				this._logger.error("join error", {
+					topic,
+					error
+				});
+			}).receive("timeout", () => {
+				this._logger.debug("join timeout", { topic });
+			});
+			channel.on(topic, ({ status, response: data }) => {
+				if (status === "ok") this.emitter.emit(topic, data);
+				else this._logger.debug("response error", {
+					topic,
+					status,
+					data
+				});
+			});
+		}
+		/**
+		* private
+		*/
+		ensureLeaveChannel(topic) {
+			if (this.emitter.listenerCount(topic) > 0) return;
+			const channel = this.channels.find((c) => c.topic === topic);
+			if (!channel) return;
+			this.remove(channel);
+			channel.leave().receive("ok", (message) => {
+				this._logger.debug("leave success", {
+					topic,
+					message
+				});
+			}).receive("error", (err) => {
+				this._logger.error("leave error", {
+					topic,
+					err
+				});
+			}).receive("timeout", () => {
+				this._logger.debug("leave timeout", { topic });
+			});
+			channel.off(topic);
+		}
+		subscribe(topic, params = {}) {
+			let channel = this.channels.find((c) => c.topic === topic);
+			if (channel) return channel;
+			channel = this.channel(topic, params);
+			channel.join().receive("ok", (message) => {
+				this._logger.debug("join success", {
+					topic,
+					message
+				});
+			}).receive("error", (error) => {
+				this._logger.error("join error", {
+					topic,
+					error
+				});
+			}).receive("timeout", () => {
+				this._logger.debug("join timeout", { topic });
+			});
+			return channel;
+		}
+		unsubscribe(topic) {
+			this.ensureLeaveChannel(topic);
+		}
+	};
+};
+
+//#endregion
+exports.default = base_default;

package/lib/client/base.d.cts

@@ -0,0 +1,80 @@
+import _default$1 from "../logger.cjs";
+
+//#region src/client/base.d.ts
+interface SocketConstructor {
+  new (endpoint: string, opts: object): SocketInstance;
+}
+interface SocketInstance {
+  channels: Channel[];
+  connect(): void;
+  disconnect(callback?: () => void, code?: number, reason?: string): void;
+  isConnected(): boolean;
+  onOpen(cb: () => void): void;
+  onClose(cb: () => void): void;
+  onError(cb: (err: {
+    error: Error;
+  }) => void): void;
+  onMessage(cb: (message: unknown) => void): void;
+  channel(topic: string, params?: object | (() => object)): Channel;
+  remove(channel: Channel): void;
+}
+interface Channel {
+  topic: string;
+  join(): ChannelPush;
+  leave(): ChannelPush;
+  on(event: string, callback: (data: {
+    status: string;
+    response: unknown;
+  }) => void): void;
+  off(event: string): void;
+}
+interface ChannelPush {
+  receive(status: string, callback: (data: unknown) => void): ChannelPush;
+}
+interface EventEmitterConstructor {
+  new (): EventEmitterInstance;
+}
+interface EventEmitterInstance {
+  on(event: string, handler: (data: unknown) => void): void;
+  off(event: string, handler?: (data: unknown) => void): void;
+  emit(event: string, data: unknown): void;
+  removeAllListeners(event: string): void;
+  listenerCount(event: string): number;
+  eventNames(): (string | symbol)[];
+}
+interface WsClientOptions {
+  silent?: boolean;
+  [key: string]: unknown;
+}
+declare const _default: (Socket: SocketConstructor, EventEmitter: EventEmitterConstructor, transport?: unknown) => {
+  new (endpoint: string, opts?: WsClientOptions): {
+    _logger: ReturnType<typeof _default$1>;
+    emitter: EventEmitterInstance;
+    on(event: string, handler: (data: unknown) => void, params?: object): void;
+    off(event: string, handler?: (data: unknown) => void): void;
+    disconnect(callback?: () => void, code?: number, reason?: string): void;
+    /**
+     * private
+     */
+    ensureJoinChannel(topic: string, params?: object): void;
+    /**
+     * private
+     */
+    ensureLeaveChannel(topic: string): void;
+    subscribe(topic: string, params?: object): Channel;
+    unsubscribe(topic: string): void;
+    channels: Channel[];
+    connect(): void;
+    isConnected(): boolean;
+    onOpen(cb: () => void): void;
+    onClose(cb: () => void): void;
+    onError(cb: (err: {
+      error: Error;
+    }) => void): void;
+    onMessage(cb: (message: unknown) => void): void;
+    channel(topic: string, params?: object | (() => object)): Channel;
+    remove(channel: Channel): void;
+  };
+};
+//#endregion
+export { Channel, ChannelPush, EventEmitterConstructor, EventEmitterInstance, SocketConstructor, SocketInstance, WsClientOptions, _default as default };