@arcblock/ws 1.28.9 → 1.29.0

package/lib/client/browser.cjs

@@ -0,0 +1,12 @@
+Object.defineProperty(exports, '__esModule', { value: true });
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const require_client_base = require('./base.cjs');
+let eventemitter3 = require("eventemitter3");
+eventemitter3 = require_rolldown_runtime.__toESM(eventemitter3);
+let phoenix = require("phoenix");
+
+//#region src/client/browser.ts
+var browser_default = require_client_base.default(phoenix.Socket, eventemitter3.default);
+
+//#endregion
+exports.default = browser_default;

package/lib/client/browser.d.cts

@@ -0,0 +1,30 @@
+import _default$1 from "../logger.cjs";
+import { Channel, EventEmitterInstance, WsClientOptions } from "./base.cjs";
+
+//#region src/client/browser.d.ts
+declare const _default: {
+  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;
+    ensureJoinChannel(topic: string, params?: object): void;
+    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 { _default as default };

package/lib/client/index.cjs

@@ -0,0 +1,14 @@
+Object.defineProperty(exports, '__esModule', { value: true });
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const require_client_base = require('./base.cjs');
+let phoenix = require("phoenix");
+let node_events = require("node:events");
+node_events = require_rolldown_runtime.__toESM(node_events);
+let ws = require("ws");
+ws = require_rolldown_runtime.__toESM(ws);
+
+//#region src/client/index.ts
+var client_default = require_client_base.default(phoenix.Socket, node_events.default, ws.default);
+
+//#endregion
+exports.default = client_default;

package/lib/client/index.d.cts

@@ -0,0 +1,30 @@
+import _default$1 from "../logger.cjs";
+import { Channel, EventEmitterInstance, WsClientOptions } from "./base.cjs";
+
+//#region src/client/index.d.ts
+declare const _default: {
+  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;
+    ensureJoinChannel(topic: string, params?: object): void;
+    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 { _default as default };

package/lib/index.cjs

@@ -0,0 +1,5 @@
+const require_client_index = require('./client/index.cjs');
+const require_server_index = require('./server/index.cjs');
+
+exports.WsClient = require_client_index.default;
+exports.WsServer = require_server_index.default;

package/lib/index.d.cts

@@ -0,0 +1,3 @@
+import _default from "./client/index.cjs";
+import WsServer from "./server/index.cjs";
+export { _default as WsClient, WsServer };

package/lib/logger.cjs

@@ -0,0 +1,19 @@
+Object.defineProperty(exports, '__esModule', { value: true });
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
+let debug = require("debug");
+debug = require_rolldown_runtime.__toESM(debug);
+
+//#region src/logger.ts
+var logger_default = (subModule, silent = false) => {
+	const d = (0, debug.default)(["@arcblock/ws", subModule].join(":"));
+	return {
+		debug: d,
+		warn: d,
+		info: d,
+		trace: silent ? d : console.error,
+		error: silent ? d : console.error
+	};
+};
+
+//#endregion
+exports.default = logger_default;

package/lib/logger.d.cts

@@ -0,0 +1,13 @@
+import debug from "debug";
+
+//#region src/logger.d.ts
+interface Logger {
+  debug: debug.Debugger | ((...args: unknown[]) => void);
+  warn?: debug.Debugger | ((...args: unknown[]) => void);
+  info: debug.Debugger | ((...args: unknown[]) => void);
+  trace?: (...args: unknown[]) => void;
+  error: (...args: unknown[]) => void;
+}
+declare const _default: (subModule: string, silent?: boolean) => Logger;
+//#endregion
+export { Logger, _default as default };

package/lib/server/index.cjs

@@ -0,0 +1,479 @@
+Object.defineProperty(exports, '__esModule', { value: true });
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const require_logger = require('../logger.cjs');
+let node_events = require("node:events");
+node_events = require_rolldown_runtime.__toESM(node_events);
+let ws = require("ws");
+ws = require_rolldown_runtime.__toESM(ws);
+let node_cluster = require("node:cluster");
+node_cluster = require_rolldown_runtime.__toESM(node_cluster);
+let lodash_get = require("lodash/get");
+lodash_get = require_rolldown_runtime.__toESM(lodash_get);
+
+//#region src/server/index.ts
+const eventHub = node_cluster.default.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 === ws.default.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 node_events.default {
+	constructor(opts = {}) {
+		super();
+		this.pathname = opts.pathname;
+		this.authenticate = opts.authenticate;
+		this.hooks = Object.assign({}, defaultHooks, opts.hooks || {});
+		this.logger = opts.logger || require_logger.default("server", opts.silent);
+		this.skipLogOnHookError = opts.skipLogOnHookError || false;
+		this.heartbeatTimeout = opts.heartbeatTimeout || HEARTBEAT_TIMEOUT;
+		this.wss = new ws.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$1) => {
+				this.wss.emit("connection", ws$1, 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$1) => {
+				ws$1.authInfo = authInfo;
+				this.wss.emit("connection", ws$1, 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]) => (0, lodash_get.default)(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
+exports.default = server_default;