wirejs-deploy-amplify-basic 0.0.116-realtime → 0.0.118-realtime

package/amplify-hosting-assets/compute/default/package.json

@@ -3,6 +3,6 @@
 	"dependencies": {
 		"jsdom": "^25.0.1",
 		"wirejs-dom": "^1.0.41",
-		"wirejs-resources": "^0.1.84-realtime"
+		"wirejs-resources": "^0.1.86-realtime"
 	}
 }

package/dist/client/realtime.d.ts

@@ -1,5 +1,5 @@
 import type { MessageStreamSubscriber } from "wirejs-resources";
-export type ChannelEvent<T = any> = {
+export type ChannelEvent = {
     type: "subscribe_success" | "data" | "broadcast_error" | "ka";
     id: string;
     event: any;

package/dist/client/realtime.js

@@ -7,18 +7,23 @@
  */
 const connections = new Map();
 /**
+ * Channel subscription ID look-up table.
+ *
  * `${URL}#${channel}` -> subscription ID
  */
-const channelSubs = new Map();
+const channelSubIdLUT = new Map();
 /**
  * subscription ID -> subscriber
  */
-const subscribers = new Map();
+const subIdSubscribers = new Map();
 /**
  * subcription ID -> connection state
  *
- * For when new subscribers are added, we'll want to broadcast the current
+ * For when new subIdSubscribers are added, we'll want to broadcast the current
  * state of the connection.
+ *
+ * "closed"-typed states are not represented here, as they are removed from the map
+ * when the WebSocket connection is closed.
  */
 const subscriptionState = new Map();
 /**
@@ -40,23 +45,41 @@ function getAuthProtocol(authorization) {
     const header = getBase64URLEncoded(authorization);
     return `header-${header}`;
 }
-export function subscribe(url, channel, token, authHost, subscriber) {
+function urlString(url) {
+    if (!url.startsWith('ws://') && !url.startsWith('wss://')) {
+        throw new Error(`Invalid WebSocket URL: ${url}`);
+    }
+    return url;
+}
+function fullChannelNameString(url, channel) {
+    if (!channel || typeof channel !== 'string') {
+        throw new Error(`Invalid channel name: ${channel}`);
+    }
     const fullChannelName = `${url}#${channel}`;
+    return fullChannelName;
+}
+function subscriptionIdString(id) {
+    return id;
+}
+export function subscribe(url, channel, token, authHost, subscriber) {
+    const urlKey = urlString(url);
+    const fullChannelName = fullChannelNameString(urlKey, channel);
     const authorization = {
         Authorization: token,
         host: authHost,
     };
-    if (!connections.has(url)) {
+    if (!connections.has(urlKey)) {
         const ws = new WebSocket(url, [
             'aws-appsync-event-ws',
             getAuthProtocol(authorization)
         ]);
-        connections.set(url, ws);
+        connections.set(urlKey, ws);
         ws.onmessage = event => {
             const data = JSON.parse(event.data);
+            const sid = subscriptionIdString(data.id);
             if (data.type === 'data') {
                 const eventData = JSON.parse(data.event);
-                for (const subscriber of subscribers.get(data.id) || []) {
+                for (const subscriber of subIdSubscribers.get(sid) || []) {
                     try {
                         subscriber.onmessage(eventData);
                     }
@@ -66,8 +89,8 @@ export function subscribe(url, channel, token, authHost, subscriber) {
                 }
             }
             else if (data.type === 'subscribe_success') {
-                subscriptionState.set(data.id, 'open');
-                for (const subscriber of subscribers.get(data.id) || []) {
+                subscriptionState.set(sid, 'open');
+                for (const subscriber of subIdSubscribers.get(sid) || []) {
                     try {
                         subscriber.onopen?.();
                     }
@@ -77,36 +100,38 @@ export function subscribe(url, channel, token, authHost, subscriber) {
                 }
             }
         };
-        const notifyClosed = () => {
-            const subscriptionIds = Array.from(channelSubs.entries())
+        const notifyClosed = (reason) => {
+            const subscriptionIds = Array.from(channelSubIdLUT.entries())
                 .filter(([urlChannel, _subId]) => urlChannel.startsWith(`${url}#`))
-                .map(([_urlChannel, subId]) => subId);
+                .map(([_urlChannel, subId]) => subscriptionIdString(subId));
             for (const subscriptionId of subscriptionIds) {
-                subscriptionState.set(subscriptionId, 'closed');
-                const subs = subscribers.get(subscriptionId);
+                const subs = subIdSubscribers.get(subscriptionId);
                 if (subs) {
                     for (const subscriber of subs) {
                         if (subscriber.onclose) {
                             try {
-                                subscriber.onclose();
+                                subscriber.onclose(reason);
                             }
                             catch (error) {
                                 console.error('Error in subscriber onclose:', error);
                             }
                         }
                     }
-                    subscribers.delete(subscriptionId);
                 }
+                subIdSubscribers.delete(subscriptionId);
+                subscriptionState.delete(subscriptionId);
             }
-            console.log('closed', event);
+            channelSubIdLUT.delete(fullChannelName);
+            connections.delete(urlKey);
+            console.debug('closed', ws);
         };
-        ws.onclose = () => notifyClosed();
-        ws.onerror = () => notifyClosed();
+        ws.onclose = () => notifyClosed('closed');
+        ws.onerror = () => notifyClosed('error');
     }
-    if (!channelSubs.has(fullChannelName)) {
-        const subscriptionId = crypto.randomUUID();
+    if (!channelSubIdLUT.has(fullChannelName)) {
+        const subscriptionId = subscriptionIdString(crypto.randomUUID());
         subscriptionState.set(subscriptionId, 'connecting');
-        const ws = connections.get(url);
+        const ws = connections.get(urlKey);
         const subscribe = () => {
             ws.send(JSON.stringify({
                 id: subscriptionId,
@@ -114,8 +139,8 @@ export function subscribe(url, channel, token, authHost, subscriber) {
                 channel,
                 authorization
             }));
-            channelSubs.set(fullChannelName, subscriptionId);
-            subscribers.set(subscriptionId, [subscriber]);
+            channelSubIdLUT.set(fullChannelName, subscriptionId);
+            subIdSubscribers.set(subscriptionId, [subscriber]);
         };
         if (ws.readyState === WebSocket.OPEN) {
             subscribe();
@@ -125,36 +150,42 @@ export function subscribe(url, channel, token, authHost, subscriber) {
         }
     }
     else {
-        const subscriptionId = channelSubs.get(fullChannelName);
-        subscribers.get(subscriptionId).push(subscriber);
+        const subscriptionId = channelSubIdLUT.get(fullChannelName);
+        subIdSubscribers.get(subscriptionId).push(subscriber);
         if (subscriptionState.get(subscriptionId) === 'open') {
             subscriber.onopen?.();
         }
-        else if (subscriptionState.get(subscriptionId) === 'closed') {
-            subscriber.onclose?.();
-        }
     }
 }
 export function unsubscribe(url, channel, subscriber) {
-    const fullChannelName = `${url}#${channel}`;
-    if (subscribers.has(fullChannelName)) {
-        const subs = subscribers.get(fullChannelName);
-        const index = subs.indexOf(subscriber);
-        if (index !== -1) {
-            subs.splice(index, 1);
-            if (subs.length === 0) {
-                channelSubs.delete(fullChannelName);
-                const urlSubs = Array.from(channelSubs.keys())
-                    .filter(id => id.startsWith(`${url}#`));
-                if (urlSubs.length === 0) {
-                    const ws = connections.get(url);
-                    if (ws) {
-                        ws.close();
-                        connections.delete(url);
-                    }
-                }
-                subscribers.delete(url);
-            }
-        }
+    const urlKey = urlString(url);
+    const ws = connections.get(urlKey);
+    const fullChannelName = fullChannelNameString(urlKey, channel);
+    const subId = channelSubIdLUT.get(fullChannelName);
+    const subs = subId && subIdSubscribers.get(subId);
+    const sub = subs ? subs.find(s => s === subscriber) : undefined;
+    if (sub && subs) {
+        sub.onclose?.('unsubscribed');
+        const i = subs.indexOf(sub);
+        if (i > -1)
+            subs.splice(i, 1);
+    }
+    if (subs && subs.length === 0) {
+        // No subIdSubscribers left for this channel. We can unsubscribe from channel.
+        ws?.send(JSON.stringify({
+            id: subId,
+            type: 'unsubscribe',
+        }));
+        subscriptionState.delete(subId);
+        subIdSubscribers.delete(subId);
+        channelSubIdLUT.delete(fullChannelName);
+    }
+    const socketSubs = Array.from(channelSubIdLUT.keys())
+        .filter(k => k.startsWith(`${url}#`));
+    if (socketSubs.length === 0) {
+        // No channels left for this URL. We can close the WebSocket connection.
+        ws?.close();
+        connections.delete(urlKey);
+        console.debug('closed', ws);
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "wirejs-deploy-amplify-basic",
-	"version": "0.0.116-realtime",
+	"version": "0.0.118-realtime",
 	"type": "module",
 	"main": "./dist/index.js",
 	"types": "./dist/index.d.ts",
@@ -41,7 +41,7 @@
 		"recursive-copy": "^2.0.14",
 		"rimraf": "^6.0.1",
 		"wirejs-dom": "^1.0.41",
-		"wirejs-resources": "^0.1.84-realtime"
+		"wirejs-resources": "^0.1.86-realtime"
 	},
 	"devDependencies": {
 		"@aws-amplify/backend": "^1.14.0",