@reactoo/watchtogether-sdk-js 2.7.61 → 2.7.63

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reactoo/watchtogether-sdk-js",
-  "version": "2.7.61",
+  "version": "2.7.63",
   "description": "Javascript SDK for Reactoo",
   "main": "dist/watchtogether-sdk.min.js",
   "module": "dist/watchtogether-sdk.min.js",

package/src/models/iot.js

@@ -7,6 +7,7 @@ let iot = function () {
     let shouldBeConnected = false;
     let isReconnecting = false;
     let interruptCount = 0;
+    let subscriptionFailureCount = 0;
 
     return {
         
@@ -15,6 +16,7 @@ let iot = function () {
         __updateCredentials: () => {
             this.__privates.iot.log('Updating Credentials...');
             interruptCount = 0;
+            subscriptionFailureCount = 0;
             isReconnecting = true;
             this.iot.$emit('isReconnecting', isReconnecting, true);
             return this.iot.getCredentials()
@@ -86,6 +88,7 @@ let iot = function () {
         iotLogin: (subscribeToSuggestedTopics = true) => {
 
             interruptCount = 0;
+            subscriptionFailureCount = 0;
             shouldBeConnected = true;
 
             this.iot.__promise = new Promise((resolve, reject) => {
@@ -149,6 +152,7 @@ let iot = function () {
             }
 
             interruptCount = 0;
+            subscriptionFailureCount = 0;
             shouldBeConnected = false;
 
             this.iot.disableVisibilityChangeListener();
@@ -181,9 +185,21 @@ let iot = function () {
                 // if subscription fails, remove the topic from the current topics
                 return this.iot.__promise
                     .then(() => this.__privates.iot.subscribe(topic))
-                    .catch(() => {
-                        __currentTopics.delete(topic);
-                        return Promise.reject('subscription_failed');
+                    .catch((error) => {
+
+                        if(error?.cause === -1) {
+                            __currentTopics.delete(topic);
+                            return Promise.reject('invalid_topic');
+                        }
+
+                        if(shouldBeConnected && !isReconnecting && subscriptionFailureCount > 5) {
+                            this.__privates.iot.log('Subscription failure exceeded, reconnecting...');
+                            this.iot.__updateCredentials();
+                            return Promise.reject('subscription_failed');
+                        }
+                        subscriptionFailureCount++;
+
+                        return this.subscribe(topic)
                     });
             }
         },

package/src/modules/wt-iot-worker.worker.js

@@ -5,15 +5,15 @@ let connection = null;
 let currentConnectionId = 1;
 
 self.onmessage = function(event) {
-    const { type, params, topic, message } = event.data;
+    const { type, params, topic, message, stamp } = event.data;
     console.log(`Worker: Received message of type: ${type}`);
 
     switch (type) {
         case 'connect':
-            connect(params);
+            connect(params, stamp);
             break;
         case 'disconnect':
-            disconnect();
+            disconnect(stamp);
             break;
         case 'is_connected':
             isConnected();
@@ -22,10 +22,10 @@ self.onmessage = function(event) {
             // No action needed in the worker
             break;
         case 'subscribe':
-            subscribe(topic);
+            subscribe(topic, stamp);
             break;
         case 'unsubscribe':
-            unsubscribe(topic);
+            unsubscribe(topic, stamp);
             break;
         case 'send':
             send(topic, message);
@@ -33,7 +33,7 @@ self.onmessage = function(event) {
     }
 };
 
-function connect(params) {
+function connect(params, stamp) {
     console.log('Worker: Attempting to connect');
     const { apiMqttUrl, apiMqttClientId, region, accessKeyId, secretAccessKey, sessionToken } = params;
 
@@ -60,15 +60,15 @@ function connect(params) {
     connection.connect()
         .then(() => {
             console.log('Worker: Connection successful');
-            self.postMessage({ type: 'connect_result', data: {success: true, connectionId: currentConnectionId} });
+            self.postMessage({ type: 'connect_result', data: {success: true, connectionId: currentConnectionId, stamp} });
         })
         .catch((error) => {
             console.error('Worker: Connection failed', error);
-            self.postMessage({ type: 'connect_result', data: {success: false, error: error.message} });
+            self.postMessage({ type: 'connect_result', data: {success: false, error: error.message, stamp} });
         });
 }
 
-function disconnect() {
+function disconnect(stamp) {
     if (connection) {
         const connectionId = currentConnectionId;
         connection.disconnect()
@@ -77,18 +77,18 @@ function disconnect() {
                     console.log('Worker: Connection Id mismatch, ignoring disconnect result', connectionId, currentConnectionId);
                     return;
                 }
-                self.postMessage({ type: 'disconnect_result', data: {success: true} });
+                self.postMessage({ type: 'disconnect_result', data: {success: true, stamp} });
             })
             .catch((error) => {
                 if(connectionId !== currentConnectionId) {
                     console.log('Worker: Connection Id mismatch, ignoring disconnect result', connectionId, currentConnectionId);
                     return;
                 }
-                self.postMessage({ type: 'disconnect_result', data: { success: false, error: error.message} });
+                self.postMessage({ type: 'disconnect_result', data: { success: false, error: error.message, stamp} });
             });
         connection = null;
     } else {
-        self.postMessage({ type: 'disconnect_result', data: {success: true} });
+        self.postMessage({ type: 'disconnect_result', data: {success: true, stamp} });
     }
 }
 
@@ -97,31 +97,31 @@ function isConnected() {
     self.postMessage({ type: 'is_connected_result', data:{connected} });
 }
 
-function subscribe(topic) {
+function subscribe(topic, stamp) {
     if (connection && connection.currentState === 0 && connection.desiredState === 0) {
         connection.subscribe(topic, mqtt.QoS.AtLeastOnce)
             .then(() => {
-                self.postMessage({ type: 'subscribe_result', data: {success: true} });
+                self.postMessage({ type: 'subscribe_result', data: {success: true, stamp} });
             })
             .catch((error) => {
-                self.postMessage({ type: 'subscribe_result', data: {success: false, error: error.message} });
+                self.postMessage({ type: 'subscribe_result', data: {success: false, error: error.message, stamp} });
             });
     } else {
-        self.postMessage({ type: 'subscribe_result', data: {success: false, error: 'Not connected'} });
+        self.postMessage({ type: 'subscribe_result', data: {success: false, error: 'Not connected', stamp} });
     }
 }
 
-function unsubscribe(topic) {
+function unsubscribe(topic, stamp) {
     if (connection && connection.currentState === 0 && connection.desiredState === 0) {
         connection.unsubscribe(topic)
             .then(() => {
-                self.postMessage({ type: 'unsubscribe_result', data: {success: true} });
+                self.postMessage({ type: 'unsubscribe_result', data: {success: true, stamp} });
             })
             .catch((error) => {
-                self.postMessage({ type: 'unsubscribe_result', data: {success: false, error: error.message} });
+                self.postMessage({ type: 'unsubscribe_result', data: {success: false, error: error.message, stamp} });
             });
     } else {
-        self.postMessage({ type: 'unsubscribe_result', data: {success: false, error: 'Not connected'} });
+        self.postMessage({ type: 'unsubscribe_result', data: {success: false, error: 'Not connected', stamp} });
     }
 }
 

package/src/modules/wt-iot2.js

@@ -44,7 +44,15 @@ class Iot {
 
                 return new Promise((resolve, reject) => {
 
+                    const stamp = new Date().getTime();
+
                     const handleConnectResult = (event) => {
+
+                        if(event.stamp !== stamp) {
+                            this.log('connect event stamp mismatch', event.stamp, stamp);
+                            return;
+                        }
+
                         clearTimeout(timeoutId);
                         this.off('worker:connect_result', handleConnectResult);
                         if (event.success) {
@@ -64,7 +72,8 @@ class Iot {
 
                     this.worker.postMessage({
                         type: 'connect',
-                        params: this.lastConnectParams
+                        params: this.lastConnectParams,
+                        stamp: stamp
                     });
                 });
             });
@@ -75,7 +84,15 @@ class Iot {
         this.stopCredentialsExpirationCheck();
         return new Promise((resolve, reject) => {
 
+            const stamp = new Date().getTime();
+
             const handleDisconnectResult = (event) => {
+
+                if(event.stamp !== stamp) {
+                    this.log('disconnect event stamp mismatch', event.stamp, stamp);
+                    return;
+                }
+
                 clearTimeout(timeoutId);
                 this.off('worker:disconnect_result', handleDisconnectResult);
                 if (event.success) {
@@ -91,7 +108,7 @@ class Iot {
             }, 5000);
 
             this.on('worker:disconnect_result', handleDisconnectResult);
-            this.worker.postMessage({ type: 'disconnect' });
+            this.worker.postMessage({ type: 'disconnect', stamp: stamp });
         });
     }
 
@@ -116,7 +133,15 @@ class Iot {
         this.log('iot subscribe', topic);
         if (typeof topic === 'string' && topic.trim() !== '') {
             return new Promise((resolve, reject) => {
+
+                const stamp = new Date().getTime();
                 const handleSubscribeResult = (event) => {
+
+                    if(event.stamp !== stamp) {
+                        this.log('subscribe event stamp mismatch', event.stamp, stamp);
+                        return;
+                    }
+
                     this.off('worker:subscribe_result', handleSubscribeResult);
                     if (event.success) {
                         this.subscribedTopics.add(topic);
@@ -127,11 +152,11 @@ class Iot {
                 };
 
                 this.on('worker:subscribe_result', handleSubscribeResult);
-                this.worker.postMessage({ type: 'subscribe', topic });
+                this.worker.postMessage({ type: 'subscribe', topic, stamp });
             });
         } else {
             this.log('Invalid topic:', topic);
-            return Promise.reject(new Error('Invalid topic'));
+            return Promise.reject(new Error('Invalid topic', {cause: -1}));
         }
     }
 
@@ -139,7 +164,16 @@ class Iot {
         this.log('iot unsubscribe', topic);
         if (typeof topic === 'string' && topic.trim() !== '') {
             return new Promise((resolve, reject) => {
+
+                const stamp = new Date().getTime();
+
                 const handleUnsubscribeResult = (event) => {
+
+                    if(event.stamp !== stamp) {
+                        this.log('unsubscribe event stamp mismatch', event.stamp, stamp);
+                        return;
+                    }
+
                     this.off('worker:unsubscribe_result', handleUnsubscribeResult);
                     if (event.success) {
                         this.subscribedTopics.delete(topic);
@@ -150,7 +184,7 @@ class Iot {
                 };
 
                 this.on('worker:unsubscribe_result', handleUnsubscribeResult);
-                this.worker.postMessage({ type: 'unsubscribe', topic });
+                this.worker.postMessage({ type: 'unsubscribe', topic, stamp });
             });
         } else {
             this.log('Invalid topic:', topic);