@qikdev/sdk 1.0.1 → 1.0.4

package/src/api/qik.socket.js

@@ -73,6 +73,26 @@ const QikSocket = function(qik, mode) {
         }
 
         const bucket = new EventDispatcher();
+
+        function dispatchMessage(message) {
+            bucket.dispatch('message', message);
+        }
+
+        // Destroy this channel - stop receiving its events and tell the
+        // server to unsubscribe. Only touches this channel's own listeners,
+        // leaving every other channel (and connection-level listeners) intact.
+        bucket.destroy = function() {
+            service.removeEventListener(key, dispatchMessage);
+            service.unsubscribe(key);
+            bucket.removeAllListeners();
+            delete buckets[key];
+        }
+
+        // Cache the fully-formed bucket (with destroy attached) BEFORE the
+        // connect() await below. A concurrent channel(key) call can hit the
+        // early return above while we're suspended awaiting connect(); if we
+        // registered the bucket before assigning destroy, that caller would
+        // receive a bucket whose destroy() is missing and throw on teardown.
         buckets[key] = bucket;
 
         if (!service.connected) {
@@ -86,16 +106,6 @@ const QikSocket = function(qik, mode) {
         // Listen for all relevant events
         service.addEventListener(key, dispatchMessage);
 
-        function dispatchMessage(message) {
-            bucket.dispatch('message', message);
-        }
-
-        // Destroy the service
-        bucket.destroy = function() {
-            service.removeAllListeners();
-            buckets[key] = null;
-        }
-
         return buckets[key];
     }
 
@@ -340,6 +350,37 @@ const QikSocket = function(qik, mode) {
 
     ///////////////////////////////////////////////////
 
+    // Reconnect the socket whenever the authenticated organisation changes.
+    // The WebSocket authenticates with an access token at connect time, so the
+    // connection stays bound to whichever organisation was active when it
+    // opened. Switching organisations issues a new token but leaves the socket
+    // untouched, so without this it keeps streaming the previous
+    // organisation's events. Reconnecting re-authenticates with the new token.
+    let currentOrganisationID = qik.utils.id(qik.auth.getCurrentUser()?.organisation);
+
+    qik.auth.addEventListener('change', async function(user) {
+        const organisationID = qik.utils.id(user?.organisation);
+
+        // Ignore auth changes that don't change the organisation (e.g. routine
+        // access token refreshes) so we don't churn the connection needlessly.
+        if (organisationID === currentOrganisationID) {
+            return;
+        }
+
+        currentOrganisationID = organisationID;
+
+        // Nothing to reconnect if the socket was never opened.
+        if (!socket) {
+            return;
+        }
+
+        service.debug ? console.log('[socket] - organisation changed, reconnecting') : null;
+        await service.close();
+        await service.reconnect();
+    });
+
+    ///////////////////////////////////////////////////
+
     return service;
 
 }

package/src/version.js

@@ -1 +1 @@
-export const version = "1.0.1";
+export const version = "1.0.4";