react-native-mosquito-transport 0.0.55 → 0.0.57

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-mosquito-transport",
-  "version": "0.0.55",
+  "version": "0.0.57",
   "description": "React native javascript sdk for mosquito-transport (https://github.com/brainbehindx/mosquito-transport)",
   "main": "src/index.js",
   "type": "module",

package/src/helpers/utils.js

@@ -155,17 +155,27 @@ export const awaitStore = () => new Promise(resolve => {
     });
 });
 
-export const checkAreYouOk = (projectUrl) => {
-    if (!Scoped.AreYouOkPromise[projectUrl]) {
+export const checkAreYouOk = (projectUrl, refresh) => {
+    if (!Scoped.AreYouOkPromise[projectUrl] || refresh) {
         Scoped.IS_CONNECTED[projectUrl] = undefined;
         ServerReachableListener.dispatchPersist(projectUrl, undefined);
 
+        const thatState = AppState.currentState;
+
         const promise = fetch(engine_api._areYouOk(projectUrl), { credentials: 'omit' })
             .then(async r => (await r.json()).status === 'yes')
             .catch(() => false)
             .then(async connected => {
-                Scoped.IS_CONNECTED[projectUrl] = connected;
-                ServerReachableListener.dispatchPersist(projectUrl, connected);
+                const thatPromise = Scoped.AreYouOkPromise[projectUrl];
+                if (thatPromise !== promise) {
+                    if (thatPromise) return thatPromise;
+                    return Scoped.IS_CONNECTED[projectUrl];
+                }
+
+                if (thatState === AppState.currentState) {
+                    Scoped.IS_CONNECTED[projectUrl] = connected;
+                    ServerReachableListener.dispatchPersist(projectUrl, connected);
+                }
 
                 delete Scoped.AreYouOkPromise[projectUrl];
                 return connected;
@@ -180,8 +190,10 @@ export const checkAreYouOk = (projectUrl) => {
 export const listenReachableServer = (callback, projectUrl) => {
     let lastValue;
     return ServerReachableListener.listenToPersist(projectUrl, t => {
-        if (typeof t === 'boolean' && t !== lastValue) callback?.(t);
-        lastValue = t;
+        if (typeof t === 'boolean' && t !== lastValue) {
+            callback?.(t);
+            lastValue = t;
+        }
     });
 };
 
@@ -208,7 +220,7 @@ export const awaitReachableServer = (projectUrl, pauseForRetry) =>
         }
 
         if (pauseForRetry) {
-            setTimeout(check, Number.isInteger(pauseForRetry) ? pauseForRetry : 300);
+            setTimeout(check, Number.isInteger(pauseForRetry) ? pauseForRetry : 500);
         } else check();
     });
 

package/src/index.js

@@ -89,10 +89,10 @@ class RNMT {
                 });
             };
 
-            const manualCheckConnection = () => {
+            const manualCheckConnection = (refresh) => {
                 const ref = ++connectionIte;
 
-                checkAreYouOk(projectUrl).then(ok => {
+                checkAreYouOk(projectUrl, refresh).then(ok => {
                     if (ref !== connectionIte) return;
                     if (ok) {
                         onConnect();
@@ -111,11 +111,11 @@ class RNMT {
 
             socket.on('connect', onConnect);
             socket.on('disconnect', () => {
-                manualCheckConnection();
+                manualCheckConnection(true);
             });
 
             AppState.addEventListener('change', s => {
-                manualCheckConnection();
+                if (s === 'active') manualCheckConnection();
             });
 
             const updateMountedToken = () => {

package/src/products/auth/accessor.js

@@ -89,7 +89,43 @@ export const ensureActiveToken = async (projectUrl) => {
     }
 }
 
-export const listenTokenReady = (callback, projectUrl) => TokenRefreshListener.listenToPersist(projectUrl, callback);
+export const listenTokenReady = (callback, projectUrl) => {
+    let lastToken;
+    let resetDelayTimer;
+    let postCaller;
+
+    const listener = TokenRefreshListener.listenToPersist(projectUrl, (...args) => {
+        const newTruthy = !!Scoped.AuthJWTToken[projectUrl];
+
+        if (resetDelayTimer !== undefined) {
+            if (newTruthy) {
+                clearTimeout(resetDelayTimer);
+                resetDelayTimer = undefined;
+                postCaller = undefined;
+                callback?.(...args);
+            } else {
+                postCaller = () => callback?.(...args);
+            }
+        } else if (typeof lastToken === 'boolean' && !newTruthy && lastToken) {
+            callback?.(false);
+            resetDelayTimer = setTimeout(() => {
+                resetDelayTimer = undefined;
+                if (postCaller) {
+                    postCaller();
+                    postCaller = undefined;
+                } else callback?.(...args);
+            }, 3000);
+        } else callback?.(...args);
+
+        lastToken = newTruthy;
+    });
+
+    return () => {
+        postCaller = undefined;
+        listener?.();
+        clearTimeout(resetDelayTimer);
+    }
+}
 
 export const initTokenRefresher = async ({ config, forceRefresh, justCheck }) => {
     const { projectUrl, maxRetries } = config;
@@ -168,7 +204,7 @@ export const getEmulatedLinks = (projectUrl) =>
         .filter(([_, v]) => v === projectUrl)
         .map(v => v[0]);
 
-const refreshToken = (builder, remainRetries = 1, isForceRefresh) =>
+const refreshToken = (builder, remainRetries = 3) =>
     new Promise(async (resolve, reject) => {
         const { projectUrl, serverE2E_PublicKey, uglify, extraHeaders } = builder;
 
@@ -206,7 +242,7 @@ const refreshToken = (builder, remainRetries = 1, isForceRefresh) =>
                 Scoped.AuthJWTToken[v] = f.result.token;
 
                 triggerAuthToken(v, isInit);
-                if (isForceRefresh) Scoped.InitiatedForcedToken[v] = true;
+                if (isInit) Scoped.InitiatedForcedToken[v] = true;
             });
             updateCacheStore(['AuthStore']);
             initTokenRefresher({ config: builder });
@@ -222,7 +258,7 @@ const refreshToken = (builder, remainRetries = 1, isForceRefresh) =>
                 console.error(`refreshToken retry limit exceeded err:`, e);
             } else {
                 awaitReachableServer(projectUrl, true).then(() => {
-                    refreshToken(builder, remainRetries - 1, isForceRefresh).then(resolve, reject);
+                    refreshToken(builder, remainRetries - 1).then(resolve, reject);
                 });
             }
         }

package/src/products/auth/index.js

@@ -1,6 +1,5 @@
 import { io } from "socket.io-client";
 import EngineApi from "../../helpers/engine_api";
-import { TokenRefreshListener } from "../../helpers/listeners";
 import { awaitReachableServer, awaitStore, buildFetchInterface, buildFetchResult, updateCacheStore } from "../../helpers/utils";
 import { CacheStore, Scoped } from "../../helpers/variables";
 import { awaitRefreshToken, getEmulatedLinks, initTokenRefresher, injectEmulatedAuth, injectFreshToken, listenToken, parseToken, triggerAuthToken } from "./accessor";
@@ -243,7 +242,6 @@ const purgeCache = (url, isMain) => {
     ].forEach(e => {
         if (e && CacheStore[e]?.[url]) delete CacheStore[e][url];
     });
-    TokenRefreshListener.dispatchPersist(url);
     triggerAuthToken(url);
 };
 
@@ -254,9 +252,7 @@ const clearCacheForSignout = (builder, disposeEmulated) => {
     if (disposeEmulated) getEmulatedLinks(projectUrl).forEach(e => purgeCache(e));
 
     clearInterval(Scoped.TokenRefreshTimer[projectUrl]);
-    setTimeout(() => {
-        initTokenRefresher({ config: builder });
-    }, 600);
+    initTokenRefresher({ config: builder });
 };
 
 export const doSignOut = async (builder) => {