@classytic/arc 2.3.0 → 2.4.2

package/dist/integrations/websocket.mjs

@@ -1,12 +1,23 @@
 import fp from "fastify-plugin";
-
 //#region src/integrations/websocket.ts
+/**
+* Default adapter — no cross-instance broadcast (single-instance only).
+* All methods are no-ops. Used when no adapter is configured.
+*/
+var LocalWebSocketAdapter = class {
+	name = "local";
+	async publish() {}
+	async subscribe() {}
+	async close() {}
+};
 var RoomManager = class {
 	rooms = /* @__PURE__ */ new Map();
 	clients = /* @__PURE__ */ new Map();
 	maxPerRoom;
-	constructor(maxPerRoom = 1e4) {
+	adapter;
+	constructor(maxPerRoom = 1e4, adapter) {
 		this.maxPerRoom = maxPerRoom;
+		this.adapter = adapter;
 	}
 	addClient(client) {
 		this.clients.set(client.id, client);
@@ -30,7 +41,7 @@ var RoomManager = class {
 		const members = this.rooms.get(room);
 		if (members && members.size >= this.maxPerRoom) return false;
 		if (!this.rooms.has(room)) this.rooms.set(room, /* @__PURE__ */ new Set());
-		this.rooms.get(room).add(clientId);
+		this.rooms.get(room)?.add(clientId);
 		client.subscriptions.add(room);
 		return true;
 	}
@@ -65,6 +76,23 @@ var RoomManager = class {
 			} catch {}
 		}
 	}
+	/**
+	* Broadcast locally AND through adapter (for cross-instance delivery).
+	* Use this instead of broadcast() when multi-instance is possible.
+	*/
+	async broadcastWithAdapter(room, message, excludeClientId) {
+		this.broadcast(room, message, excludeClientId);
+		if (this.adapter) await this.adapter.publish(room, message);
+	}
+	/**
+	* Org-scoped broadcast locally AND through adapter.
+	* Uses a namespaced room key for the adapter so other instances
+	* can filter by org when delivering locally.
+	*/
+	async broadcastToOrgWithAdapter(organizationId, room, message) {
+		this.broadcastToOrg(organizationId, room, message);
+		if (this.adapter) await this.adapter.publish(`org:${organizationId}:${room}`, message);
+	}
 	getClient(clientId) {
 		return this.clients.get(clientId);
 	}
@@ -80,24 +108,34 @@ var RoomManager = class {
 };
 const websocketPluginImpl = async (fastify, options) => {
 	let clientCounter = 0;
-	const { path = "/ws", auth = true, resources = [], heartbeatInterval = 3e4, authenticate: customAuth, maxClientsPerRoom = 1e4, roomPolicy, maxMessageBytes = 16384, maxSubscriptionsPerClient = 100, exposeStats = false, onMessage, onConnect, onDisconnect } = options;
+	const { path = "/ws", auth = true, resources = [], heartbeatInterval = 3e4, authenticate: customAuth, maxClientsPerRoom = 1e4, roomPolicy, maxMessageBytes = 16384, maxSubscriptionsPerClient = 100, reauthInterval = 0, adapter, exposeStats = false, onMessage, onConnect, onDisconnect } = options;
 	if (auth && !customAuth && !fastify.hasDecorator("authenticate")) throw new Error("[arc-websocket] auth is true but fastify.authenticate is not registered. Register an auth plugin before WebSocket, provide a custom authenticate function, or set auth: false.");
-	const rooms = new RoomManager(maxClientsPerRoom);
+	const rooms = new RoomManager(maxClientsPerRoom, adapter);
+	if (adapter) await adapter.subscribe((room, message) => {
+		if (room.startsWith("org:")) {
+			const parts = room.split(":");
+			const orgId = parts[1];
+			const actualRoom = parts.slice(2).join(":");
+			rooms.broadcastToOrg(orgId, actualRoom, message);
+		} else rooms.broadcast(room, message);
+	});
 	if (!fastify.hasDecorator("ws")) fastify.decorate("ws", {
 		rooms,
 		broadcast: (room, data) => {
-			rooms.broadcast(room, JSON.stringify({
+			const msg = JSON.stringify({
 				type: "broadcast",
 				channel: room,
 				data
-			}));
+			});
+			rooms.broadcastWithAdapter(room, msg);
 		},
 		broadcastToOrg: (orgId, room, data) => {
-			rooms.broadcastToOrg(orgId, room, JSON.stringify({
+			const msg = JSON.stringify({
 				type: "broadcast",
 				channel: room,
 				data
-			}));
+			});
+			rooms.broadcastToOrgWithAdapter(orgId, room, msg);
 		},
 		getStats: () => rooms.getStats()
 	});
@@ -118,8 +156,8 @@ const websocketPluginImpl = async (fastify, options) => {
 					organizationId: event.meta?.organizationId
 				}
 			});
-			if (event.meta?.organizationId) rooms.broadcastToOrg(event.meta.organizationId, room, payload);
-			else rooms.broadcast(room, payload);
+			if (event.meta?.organizationId) rooms.broadcastToOrgWithAdapter(event.meta.organizationId, room, payload);
+			else rooms.broadcastWithAdapter(room, payload);
 		});
 		eventUnsubscribers.push(unsub);
 	}
@@ -186,6 +224,49 @@ const websocketPluginImpl = async (fastify, options) => {
 				timestamp: Date.now()
 			}));
 		}, heartbeatInterval);
+		let reauthTimer;
+		if (reauthInterval > 0 && auth) reauthTimer = setInterval(async () => {
+			if (socket.readyState !== 1) return;
+			try {
+				if (customAuth) {
+					if (!await customAuth(request)) {
+						socket.send(JSON.stringify({
+							type: "error",
+							error: "Session expired"
+						}));
+						socket.close(4003, "Session expired");
+						return;
+					}
+				} else if (fastify.authenticate) {
+					let rejected = false;
+					const fakeReply = {
+						code() {
+							rejected = true;
+							return fakeReply;
+						},
+						send() {
+							return fakeReply;
+						},
+						sent: false
+					};
+					await fastify.authenticate(request, fakeReply);
+					if (rejected) {
+						socket.send(JSON.stringify({
+							type: "error",
+							error: "Session expired"
+						}));
+						socket.close(4003, "Session expired");
+						return;
+					}
+				}
+			} catch {
+				socket.send(JSON.stringify({
+					type: "error",
+					error: "Session expired"
+				}));
+				socket.close(4003, "Session expired");
+			}
+		}, reauthInterval);
 		socket.on("message", async (raw) => {
 			if ((typeof raw === "string" ? Buffer.byteLength(raw) : raw.length) > maxMessageBytes) {
 				socket.send(JSON.stringify({
@@ -252,11 +333,13 @@ const websocketPluginImpl = async (fastify, options) => {
 		});
 		socket.on("close", async () => {
 			if (heartbeatTimer) clearInterval(heartbeatTimer);
+			if (reauthTimer) clearInterval(reauthTimer);
 			await onDisconnect?.(client);
 			rooms.removeClient(clientId);
 		});
 		socket.on("error", () => {
 			if (heartbeatTimer) clearInterval(heartbeatTimer);
+			if (reauthTimer) clearInterval(reauthTimer);
 			rooms.removeClient(clientId);
 		});
 	});
@@ -276,6 +359,7 @@ const websocketPluginImpl = async (fastify, options) => {
 	fastify.addHook("onClose", async () => {
 		for (const unsub of eventUnsubscribers) unsub();
 		eventUnsubscribers.length = 0;
+		if (adapter) await adapter.close();
 	});
 };
 /** Pluggable WebSocket integration for Arc */
@@ -283,6 +367,5 @@ const websocketPlugin = fp(websocketPluginImpl, {
 	name: "arc-websocket",
 	fastify: "5.x"
 });
-
 //#endregion
-export { RoomManager, websocketPlugin as default, websocketPlugin };
+export { LocalWebSocketAdapter, RoomManager, websocketPlugin as default, websocketPlugin };

package/dist/{interface-CSNjltAc.d.mts → interface-B4awm1RJ.d.mts}

@@ -41,7 +41,7 @@ interface IdempotencyStore {
    * Store a result for an idempotency key.
    * TTL is handled by the store implementation.
    */
-  set(key: string, result: Omit<IdempotencyResult, 'key'>): Promise<void>;
+  set(key: string, result: Omit<IdempotencyResult, "key">): Promise<void>;
   /**
    * Try to acquire a lock for processing a key.
    * Returns true if lock acquired, false if already locked.
@@ -72,6 +72,6 @@ interface IdempotencyStore {
 /**
  * Helper to create a result object
  */
-declare function createIdempotencyResult(statusCode: number, body: unknown, headers: Record<string, string>, ttlMs: number): Omit<IdempotencyResult, 'key'>;
+declare function createIdempotencyResult(statusCode: number, body: unknown, headers: Record<string, string>, ttlMs: number): Omit<IdempotencyResult, "key">;
 //#endregion
 export { createIdempotencyResult as i, IdempotencyResult as n, IdempotencyStore as r, IdempotencyLock as t };