react-native-mosquito-transport 0.0.56 → 0.0.58

package/package.json

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

package/src/index.d.ts

@@ -182,6 +182,8 @@ interface CustomSocketOption extends OveridenProjectUrl {
 export default class RNMT {
     constructor(config: RNMTConfig);
     static initializeCache(option?: ReleaseCacheOption): void;
+    get isOnline(): boolean | undefined;
+    areYouOnline(): Promise<boolean>;
     getDatabase(dbName?: string, dbUrl?: string): GetDatabase;
     collection(path: string): RNMTCollection;
     auth(): RNMTAuth;

package/src/index.js

@@ -142,6 +142,14 @@ class RNMT {
         });
     }
 
+    get isOnline() {
+        return Scoped.IS_CONNECTED[this.config.projectUrl];
+    }
+
+    areYouOnline() {
+        return checkAreYouOk(this.config.projectUrl);
+    }
+
     getDatabase = (dbName, dbUrl) => {
         if (dbName) ConfigValidator.dbName(dbName);
         if (dbUrl) ConfigValidator.dbUrl(dbUrl);
@@ -467,11 +475,10 @@ class RNMT {
                 clearForegroundListener();
                 clearSocket();
                 socketListenerList = [];
-                if (!socketReadyCallback) {
-                    makeSocketCallback();
+                if (socketReadyCallback) {
+                    socketReadyCallback[1]('socket already disconnected');
+                    socketReadyCallback = undefined;
                 }
-                socketReadyCallback[1]('socket already disconnected');
-                socketReadyCallback = undefined;
             }
         };
 

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;

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) => {

package/src/products/database/index.js

@@ -728,10 +728,15 @@ const findObject = async (builder, initConfig) => {
             } else if (retries > maxRetries) {
                 finalize(undefined, { error: 'retry_limit_exceeded', message: `retry exceed limit(${maxRetries})` });
             } else {
-                awaitReachableServer(projectUrl, true).then(() => {
+                awaitReachableServer(projectUrl, true).then(async () => {
                     if (intruder) {
                         intruder.resolve = undefined;
                         intruder.reject = undefined;
+
+                        if (Scoped.dispatchingWritesPromise[projectUrl]) {
+                            await Scoped.dispatchingWritesPromise[projectUrl];
+                        }
+
                         readValue().then(
                             e => { finalize(e); },
                             e => { finalize(undefined, e); }
@@ -880,8 +885,9 @@ const commitData = async (builder, value, type, config) => {
                             e => { finalize(undefined, e.b, e.c); }
                         );
                     });
-                } else if (shouldCache) finalize({ status: 'queued' });
-                else finalize(undefined, simplifyCaughtError(e).simpleError);
+                } else if (shouldCache) {
+                    finalize({ status: 'queued' });
+                } else finalize(undefined, simplifyCaughtError(e).simpleError);
             }
         }
     });