react-native-mosquito-transport 0.0.51 → 0.0.53

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-mosquito-transport",
-  "version": "0.0.51",
+  "version": "0.0.53",
   "description": "React native javascript sdk for mosquito-transport (https://github.com/brainbehindx/mosquito-transport)",
   "main": "src/index.js",
   "type": "module",
@@ -41,7 +41,7 @@
     "guard-object": "^1.1.4",
     "poke-object": "^1.0.1",
     "simplify-error": "^1.0.1",
-    "socket.io-client": "^4.8.1",
+    "socket.io-client": "^4.8.3",
     "subscription-listener": "^1.1.3",
     "tweetnacl": "^1.0.3"
   },
@@ -51,4 +51,4 @@
     "react-native-get-random-values": "*",
     "react-native-sha256": "*"
   }
-}
+}

package/src/helpers/peripherals.js

@@ -1,5 +1,4 @@
 import { Buffer } from "buffer";
-import { ServerReachableListener } from "./listeners";
 import naclPkg from 'tweetnacl';
 import { deserialize, serialize } from "entity-serializer";
 import { sha256 } from 'react-native-sha256';
@@ -8,14 +7,6 @@ import { grab } from "poke-object";
 
 const { box, randomBytes } = naclPkg;
 
-export const listenReachableServer = (callback, projectUrl) => {
-    let lastValue;
-    return ServerReachableListener.listenToPersist(projectUrl, t => {
-        if (typeof t === 'boolean' && t !== lastValue) callback?.(t);
-        lastValue = t;
-    });
-};
-
 export const prefixStoragePath = (path, prefix = 'file:///') => {
     let cleanedPath = path.replace(/^[^/]+:\/{1,3}/, '');
 
@@ -30,13 +21,6 @@ export const prefixStoragePath = (path, prefix = 'file:///') => {
     return `${prefix}${cleanedPath}`;
 };
 
-export const niceTry = (promise) => new Promise(async resolve => {
-    try {
-        const r = await promise();
-        resolve(r);
-    } catch (e) { resolve(); }
-});
-
 export const normalizeRoute = (route = '') => route.split('').map((v, i, a) =>
     ((!i && v === '/') || (i === a.length - 1 && v === '/') || (i && a[i - 1] === '/' && v === '/')) ? '' : v
 ).join('');

package/src/helpers/utils.js

@@ -7,6 +7,8 @@ import { breakDbMap, purgeRedundantRecords } from "./purger";
 import { FS_PATH, getSystem } from "./fs_manager";
 import { Buffer } from "buffer";
 import { basicClone } from "./basic_clone";
+import engine_api from "./engine_api";
+import { AppState } from "react-native";
 
 const { FILE_NAME, TABLE_NAME } = FS_PATH;
 
@@ -153,31 +155,76 @@ export const awaitStore = () => new Promise(resolve => {
     });
 });
 
-export const awaitReachableServer = (projectUrl) => new Promise(resolve => {
-    if (Scoped.IS_CONNECTED[projectUrl]) {
-        resolve();
-        return;
+export const checkAreYouOk = (projectUrl) => {
+    if (!Scoped.AreYouOkPromise[projectUrl]) {
+        const signal = new AbortController();
+        const timer = setTimeout(() => {
+            signal.abort();
+        }, 9000);
+        const promise = fetch(engine_api._areYouOk(projectUrl), { credentials: 'omit', signal })
+            .then(async r => (await r.json()).status === 'yes')
+            .catch(() => false)
+            .then(async connected => {
+                Scoped.IS_CONNECTED[projectUrl] = connected;
+                ServerReachableListener.dispatchPersist(projectUrl, connected);
+
+                clearTimeout(timer);
+                delete Scoped.AreYouOkPromise[projectUrl];
+                return connected;
+            });
+
+        Scoped.AreYouOkPromise[projectUrl] = promise;
     }
-    const l = ServerReachableListener.listenToPersist(projectUrl, t => {
-        if (t) {
+
+    return Scoped.AreYouOkPromise[projectUrl];
+}
+
+export const listenReachableServer = (callback, projectUrl) => {
+    let lastValue;
+    return ServerReachableListener.listenToPersist(projectUrl, t => {
+        if (typeof t === 'boolean' && t !== lastValue) callback?.(t);
+        lastValue = t;
+    });
+};
+
+export const awaitReachableServer = (projectUrl) =>
+    new Promise(async resolve => {
+        if (AppState.currentState !== 'active') {
+            if (await checkAreYouOk(projectUrl)) {
+                resolve();
+                return;
+            }
+        }
+
+        if (Scoped.IS_CONNECTED[projectUrl]) {
             resolve();
-            l();
+            return;
         }
+
+        const l = listenReachableServer(t => {
+            if (!t) return;
+            resolve();
+            l();
+        }, projectUrl);
     });
-});
 
-export const getReachableServer = (projectUrl) => new Promise(resolve => {
-    if (typeof Scoped.IS_CONNECTED[projectUrl] === 'boolean') {
-        resolve(Scoped.IS_CONNECTED[projectUrl]);
-        return;
-    }
-    const l = ServerReachableListener.listenToPersist(projectUrl, t => {
-        if (typeof t === 'boolean') {
+export const getReachableServer = (projectUrl) =>
+    new Promise(async resolve => {
+        if (AppState.currentState !== 'active') {
+            resolve(await checkAreYouOk(projectUrl));
+            return;
+        }
+
+        if (typeof Scoped.IS_CONNECTED[projectUrl] === 'boolean') {
+            resolve(Scoped.IS_CONNECTED[projectUrl]);
+            return;
+        }
+
+        const l = listenReachableServer(t => {
             resolve(t);
             l();
-        }
+        }, projectUrl);
     });
-});
 
 export const buildFetchInterface = async ({ body, authToken, method, uglify, serverE2E_PublicKey, extraHeaders }) => {
     if (!uglify) body = JSON.stringify({ ...body });

package/src/helpers/variables.js

@@ -4,7 +4,7 @@ export const Scoped = {
     PendingIte: 0,
     AnyProcessIte: 0,
     IS_CONNECTED: {},
-    IS_TOKEN_READY: {},
+    AreYouOkPromise: {},
     InitializedProject: {},
     ReleaseCacheData: undefined,
     AuthJWTToken: {},

package/src/index.js

@@ -1,11 +1,11 @@
 import 'react-native-get-random-values';
-import { deserializeE2E, listenReachableServer, serializeE2E } from "./helpers/peripherals";
-import { awaitStore, releaseCacheStore } from "./helpers/utils";
+import { deserializeE2E, serializeE2E } from "./helpers/peripherals";
+import { awaitReachableServer, awaitStore, checkAreYouOk, listenReachableServer, releaseCacheStore } from "./helpers/utils";
 import { CacheStore, Scoped } from "./helpers/variables";
 import { MTCollection, batchWrite, onCollectionConnect, trySendPendingWrite } from "./products/database";
 import { MTStorage } from "./products/storage";
-import { ServerReachableListener, TokenRefreshListener } from "./helpers/listeners";
-import { initTokenRefresher, listenToken, listenTokenReady, triggerAuthToken } from "./products/auth/accessor";
+import { ServerReachableListener } from "./helpers/listeners";
+import { awaitRefreshToken, initTokenRefresher, listenToken, listenTokenReady, triggerAuthToken } from "./products/auth/accessor";
 import { TIMESTAMP, DOCUMENT_EXTRACTION, FIND_GEO_JSON, GEO_JSON, TIMESTAMP_OFFSET } from "./products/database/types";
 import { mfetch } from "./products/http_callable";
 import { io } from "socket.io-client";
@@ -23,8 +23,7 @@ const {
     _listenDocument,
     _startDisconnectWriteTask,
     _cancelDisconnectWriteTask,
-    _listenUserVerification,
-    _areYouOk
+    _listenUserVerification
 } = EngineApi;
 
 // https://socket.io/docs/v3/emit-cheatsheet/#reserved-events
@@ -63,7 +62,7 @@ class RNMT {
             triggerAuthToken(projectUrl);
             initTokenRefresher({ config: this.config, forceRefresh: true });
 
-            let isConnected, recentToken, isVirtualMachineFocused = true;
+            let isConnected, recentToken;
 
             const socket = io(`${this.config.wsPrefix}://${this.config.baseUrl}`, {
                 transports: ['websocket', 'polling', 'flashsocket'],
@@ -73,34 +72,40 @@ class RNMT {
                     _from_base: true
                 }
             });
+
             let connectionIte = 0;
+            let chainedPromise;
+            const setConnected = c => {
+                isConnected = c;
+                Scoped.IS_CONNECTED[projectUrl] = isConnected;
+                ServerReachableListener.dispatchPersist(projectUrl, isConnected);
+            }
+
             const onConnect = () => {
                 ++connectionIte;
-                isConnected = true;
-                Scoped.IS_CONNECTED[projectUrl] = true;
+                setConnected(true);
                 if (recentToken) updateMountedToken();
-                ServerReachableListener.dispatchPersist(projectUrl, true);
                 awaitStore().then(() => {
                     if (isConnected) trySendPendingWrite(projectUrl);
                 });
             };
-            const onDisconnect = () => {
-                ++connectionIte;
-                isConnected = isVirtualMachineFocused ? false : null;
-                Scoped.IS_CONNECTED[projectUrl] = isConnected;
-                ServerReachableListener.dispatchPersist(projectUrl, isConnected);
-            }
 
             const manualCheckConnection = () => {
+                if (chainedPromise) return;
                 const ref = ++connectionIte;
-                fetch(_areYouOk(projectUrl), { credentials: 'omit' }).then(async r => {
-                    if ((await r.json()).status === 'yes') {
-                        if (ref === connectionIte) onConnect();
-                    } else throw null;
-                }).catch(() => {
-                    if (ref === connectionIte) onDisconnect();
+
+                checkAreYouOk(projectUrl).then(ok => {
+                    chainedPromise = undefined;
+                    if (ref !== connectionIte) return;
+                    if (ok) {
+                        onConnect();
+                    } else {
+                        ++connectionIte;
+                        isConnected = false;
+                    }
                 });
             }
+
             manualCheckConnection();
 
             socket.on('_signal_signout', () => {
@@ -112,8 +117,7 @@ class RNMT {
                 manualCheckConnection();
             });
 
-            AppState.addEventListener('change', (s) => {
-                isVirtualMachineFocused = s === 'active';
+            AppState.addEventListener('change', s => {
                 manualCheckConnection();
             });
 
@@ -125,10 +129,6 @@ class RNMT {
                 recentToken = token;
                 if (isConnected) updateMountedToken();
             }, projectUrl);
-
-            TokenRefreshListener.listenTo(projectUrl, v => {
-                Scoped.IS_TOKEN_READY[projectUrl] = v;
-            });
         }
     }
 
@@ -181,16 +181,31 @@ class RNMT {
             _listenUserVerification
         ].map(v => [v(), v(true)]).flat();
 
-        const makeSocketCallback = () =>
-            new Promise(resolve => {
-                socketReadyCallback = resolve;
-            });
-
         let socketReadyCallback,
-            socketReadyPromise = makeSocketCallback(),
+            socketReadyPromise,
             socketListenerList = [],
             socketListenerIte = 0;
 
+        const makeSocketCallback = () => {
+            const prevCallback = socketReadyCallback;
+
+            socketReadyPromise = new Promise((resolve, reject) => {
+
+                socketReadyCallback = [
+                    () => {
+                        prevCallback?.[0]?.();
+                        resolve();
+                    },
+                    () => {
+                        prevCallback?.[1]?.();
+                        reject();
+                    }
+                ];
+            });
+        }
+
+        makeSocketCallback();
+
         /**
          * @type {import('socket.io-client').Socket}
          */
@@ -225,67 +240,88 @@ class RNMT {
             }] : []);
         };
 
-        const emit = ({ timeout, promise, emittion: emittionx }) => new Promise(async (resolve, reject) => {
-            const [route, ...emittion] = emittionx;
+        const emit = ({ timeout, promise, emittion: emittionx }) =>
+            new Promise(async (resolve, reject) => {
+                const [route, ...emittion] = emittionx;
+
+                if (typeof route !== 'string')
+                    throw `expected ${promise ? 'emitWithAck' : 'emit'} first argument to be a string type`;
+
+                if (restrictedRoute.includes(route))
+                    throw `${route} is a restricted socket path, avoid using any of ${restrictedRoute}`;
 
-            if (typeof route !== 'string')
-                throw `expected ${promise ? 'emitWithAck' : 'emit'} first argument to be a string type`;
+                let hasResolved, stime = Date.now();
 
-            if (restrictedRoute.includes(route))
-                throw `${route} is a restricted socket path, avoid using any of ${restrictedRoute}`;
+                const timer = timeout ? setTimeout(() => {
+                    hasResolved = true;
+                    reject(new Error('emittion timeout'));
+                }, timeout) : undefined;
 
-            let hasResolved, stime = Date.now();
+                await socketReadyPromise;
+                if (hasResolved) return;
+                clearTimeout(timer);
 
-            const timer = timeout ? setTimeout(() => {
-                hasResolved = true;
-                reject(new Error('emittion timeout'));
-            }, timeout) : undefined;
+                try {
+                    const thisSocket = timeout ? socket.timeout(Math.max(timeout - (Date.now() - stime), 0)) : socket;
 
-            await socketReadyPromise;
-            if (hasResolved) return;
-            clearTimeout(timer);
+                    const lastEmit = emittion.slice(-1)[0];
+                    const hasEmitable = typeof lastEmit === 'function';
+                    const [mit, not_encrypted] = encloseSocketArguments(hasEmitable ? emittion.slice(0, -1) : emittion);
 
-            try {
-                const thisSocket = timeout ? socket.timeout(Math.max(timeout - (Date.now() - stime), 0)) : socket;
+                    const [reqBuilder, [privateKey]] = uglify ? await serializeE2E(mit, undefined, serverE2E_PublicKey) : [undefined, []];
 
-                const lastEmit = emittion.slice(-1)[0];
-                const hasEmitable = typeof lastEmit === 'function';
-                const [mit, not_encrypted] = encloseSocketArguments(hasEmitable ? emittion.slice(0, -1) : emittion);
+                    if (hasEmitable && promise)
+                        throw 'emitWithAck cannot have function in it argument';
 
-                const [reqBuilder, [privateKey]] = uglify ? await serializeE2E(mit, undefined, serverE2E_PublicKey) : [undefined, []];
+                    const result = await thisSocket[promise ? 'emitWithAck' : 'emit'](route,
+                        [uglify ? reqBuilder : mit, not_encrypted],
+                        ...hasEmitable ? [async function () {
+                            const [[args, not_encrypted]] = [...arguments];
+                            let res;
 
-                if (hasEmitable && promise)
-                    throw 'emitWithAck cannot have function in it argument';
+                            if (uglify) {
+                                res = await deserializeE2E(args, serverE2E_PublicKey, privateKey);
+                            } else res = args;
 
-                const result = await thisSocket[promise ? 'emitWithAck' : 'emit'](route,
-                    [uglify ? reqBuilder : mit, not_encrypted],
-                    ...hasEmitable ? [async function () {
-                        const [[args, not_encrypted]] = [...arguments];
-                        let res;
+                            lastEmit(...discloseSocketArguments([res, not_encrypted]));
+                        }] : []
+                    );
+                    if (promise && result) {
+                        resolve(discloseSocketArguments([uglify ? await deserializeE2E(result[0], serverE2E_PublicKey, privateKey) : result[0], result[1]])[0]);
+                    } else resolve();
+                } catch (e) {
+                    reject(e);
+                }
+            });
 
-                        if (uglify) {
-                            res = await deserializeE2E(args, serverE2E_PublicKey, privateKey);
-                        } else res = args;
+        let initIte = 0;
+        let foregroundListener;
+        const clearForegroundListener = () => {
+            if (!foregroundListener) return;
+            foregroundListener.remove();
+            foregroundListener = undefined;
+        }
 
-                        lastEmit(...discloseSocketArguments([res, not_encrypted]));
-                    }] : []
-                );
-                if (promise && result) {
-                    resolve(discloseSocketArguments([uglify ? await deserializeE2E(result[0], serverE2E_PublicKey, privateKey) : result[0], result[1]])[0]);
-                } else resolve();
-            } catch (e) {
-                reject(e);
+        const clearSocket = () => {
+            if (socket) {
+                socket.close();
+                socket = undefined;
             }
-        });
+        }
 
         const init = async () => {
+            clearForegroundListener();
             if (hasCancelled) return;
+            const instance_id = ++initIte;
+
             const mtoken = disableAuth ? undefined : Scoped.AuthJWTToken[projectUrl];
             const [reqBuilder, [privateKey]] = uglify ? await serializeE2E({ a_extras: authHandshake }, mtoken, serverE2E_PublicKey) : [null, []];
 
             const getWsPrefix = url => url.startsWith('https') ? 'wss' : 'ws';
             const wsUrl = overidenUrl ? `${getWsPrefix(overidenUrl)}://${overidenUrl.split('://')[1]}` : `${wsPrefix}://${projectUrl.split('://')[1]}`;
 
+            if (instance_id !== initIte) return;
+
             socket = io(wsUrl, {
                 transports: ['websocket', 'polling', 'flashsocket'],
                 extraHeaders,
@@ -295,32 +331,87 @@ class RNMT {
                 } : {
                     ...mtoken ? { mtoken } : {},
                     a_extras: authHandshake
+                },
+                reconnection: false
+            });
+
+            const reconnect = (timeout) => {
+                if (initIte !== instance_id || hasCancelled) return;
+
+                makeSocketCallback();
+                const reloadIntance = async () => {
+                    if (!disableAuth) await awaitRefreshToken(projectUrl);
+                    if (initIte === instance_id && !hasCancelled) remountInit();
                 }
+
+                if (AppState.currentState === 'active') {
+                    setTimeout(() => {
+                        awaitReachableServer(projectUrl).then(reloadIntance);
+                    }, timeout);
+                } else {
+                    foregroundListener = AppState.addEventListener('change', s => {
+                        if (s === 'active') {
+                            clearForegroundListener();
+                            reloadIntance();
+                        }
+                    });
+                }
+            }
+
+            let wasHandled;
+            socket.on('connect', () => {
+                if (initIte !== instance_id) return;
+                socketReadyCallback[0]();
+                socketReadyCallback = undefined;
+            });
+
+            socket.on('connect_error', () => {
+                if (initIte !== instance_id || wasHandled) return;
+                wasHandled = true;
+                clearSocket();
+                reconnect(3000);
             });
-            clientPrivateKey = privateKey;
 
-            socketReadyCallback();
+            socket.on('disconnect', r => {
+                if (initIte !== instance_id || wasHandled) return;
+                wasHandled = true;
+                clearSocket();
+                if (r === 'io client disconnect' || r === 'io server disconnect') {
+                    resultant.destroy();
+                } else reconnect(0);
+            });
+
+            clientPrivateKey = privateKey;
             socketListenerList.forEach(([_, method, route, callback]) => {
                 socket[method](route, callback);
             });
         }
 
+        const remountInit = () => {
+            makeSocketCallback();
+            if (socket) {
+                ++initIte;
+                clearSocket();
+            }
+            init();
+        }
+
         if (disableAuth) {
             init();
         } else {
             let lastTokenStatus;
 
-            tokenListener = listenTokenReady(status => {
-                if (lastTokenStatus === (status || false)) return;
-
-                if (status) {
-                    init();
+            tokenListener = listenTokenReady(ready => {
+                if (lastTokenStatus === (ready || false)) return;
+                if (ready) {
+                    remountInit();
                 } else {
-                    socket?.close?.();
-                    socket = undefined;
-                    socketReadyPromise = makeSocketCallback();
+                    makeSocketCallback();
+                    ++initIte;
+                    clearForegroundListener();
+                    clearSocket();
                 }
-                lastTokenStatus = status || false;
+                lastTokenStatus = ready || false;
             }, projectUrl);
         }
 
@@ -375,10 +466,17 @@ class RNMT {
                 }
             },
             destroy: () => {
+                if (hasCancelled) return;
                 hasCancelled = true;
                 tokenListener?.();
-                if (socket) socket.close();
+                clearForegroundListener();
+                clearSocket();
                 socketListenerList = [];
+                if (!socketReadyCallback) {
+                    makeSocketCallback();
+                }
+                socketReadyCallback[1]('socket already disconnected');
+                socketReadyCallback = undefined;
             }
         };
 

package/src/products/auth/accessor.js

@@ -1,8 +1,8 @@
 import { doSignOut, revokeAuthIntance } from "./index.js";
 import EngineApi from "../../helpers/engine_api";
 import { AuthTokenListener, TokenRefreshListener } from "../../helpers/listeners";
-import { decodeBinary, deserializeE2E, listenReachableServer } from "../../helpers/peripherals";
-import { awaitStore, buildFetchInterface, buildFetchResult, updateCacheStore } from "../../helpers/utils";
+import { decodeBinary, deserializeE2E } from "../../helpers/peripherals";
+import { awaitReachableServer, awaitStore, buildFetchInterface, buildFetchResult, updateCacheStore } from "../../helpers/utils";
 import { CacheStore, Scoped } from "../../helpers/variables";
 import { simplifyError } from "simplify-error";
 import { Validator } from "guard-object";
@@ -56,7 +56,7 @@ export const injectEmulatedAuth = async (config, emulatedURL) => {
 export const parseToken = (token) => JSON.parse(decodeBinary(token.split('.')[1]));
 
 export const triggerAuthToken = async (projectUrl, isInit) => {
-    await awaitStore();
+    if (!Scoped.IsStoreReady) await awaitStore();
     AuthTokenListener.dispatchPersist(projectUrl, CacheStore.AuthStore[projectUrl]?.token || null, isInit);
 };
 
@@ -97,15 +97,16 @@ export const initTokenRefresher = async ({ config, forceRefresh, justCheck }) =>
 
     if (token) {
         const rizz = () => {
-            const runningProcess = Scoped.TokenRefreshProcess[projectUrl];
-            if (runningProcess) return runningProcess;
-
-            Scoped.TokenRefreshProcess[projectUrl] =
-                refreshToken(config, maxRetries, forceRefresh);
-
-            Scoped.TokenRefreshProcess[projectUrl].finally(() => {
-                delete Scoped.TokenRefreshProcess[projectUrl];
-            });
+            let runningProcess = Scoped.TokenRefreshProcess[projectUrl];
+            if (!runningProcess) {
+                runningProcess = refreshToken(config, maxRetries, forceRefresh);
+                Scoped.TokenRefreshProcess[projectUrl] = runningProcess;
+
+                Scoped.TokenRefreshProcess[projectUrl].finally(() => {
+                    delete Scoped.TokenRefreshProcess[projectUrl];
+                });
+            }
+            return runningProcess;
         }
 
         if (await hasTokenExpire(projectUrl) || forceRefresh) {
@@ -120,11 +121,11 @@ export const initTokenRefresher = async ({ config, forceRefresh, justCheck }) =>
                 clearInterval(Scoped.TokenRefreshTimer[projectUrl]);
                 Scoped.TokenRefreshTimer[projectUrl] = setInterval(async () => {
                     const iteRef = ++lastIte;
-                    if (iteRef !== lastIte || !(await hasTokenExpire(projectUrl))) return;
+                    if (!(await hasTokenExpire(projectUrl)) || iteRef !== lastIte) return;
                     clearInterval(Scoped.TokenRefreshTimer[projectUrl]);
                     notifyAuthReady();
                     rizz();
-                }, 9000);
+                }, 7000);
             }
         }
     } else {
@@ -149,9 +150,10 @@ const updateTokenTimestamp = async (projectUrl, token) => {
     };
 }
 
-export const getEmulatedLinks = (projectUrl) => Object.entries(CacheStore.EmulatedAuth)
-    .filter(([_, v]) => v === projectUrl)
-    .map(v => v[0]);
+export const getEmulatedLinks = (projectUrl) =>
+    Object.entries(CacheStore.EmulatedAuth)
+        .filter(([_, v]) => v === projectUrl)
+        .map(v => v[0]);
 
 const refreshToken = (builder, remainRetries = 1, isForceRefresh) =>
     new Promise(async (resolve, reject) => {
@@ -171,15 +173,20 @@ const refreshToken = (builder, remainRetries = 1, isForceRefresh) =>
 
             const f = uglify ? await deserializeE2E(data, serverE2E_PublicKey, privateKey) : data;
 
+            if (!CacheStore.AuthStore[projectUrl]) {
+                reject(simplifyError('token_not_mounted', 'No refresh token was mounted or has been recently removed').simpleError);
+                return;
+            }
+
             CacheStore.AuthStore[projectUrl].token = f.result.token;
             Scoped.AuthJWTToken[projectUrl] = f.result.token;
             await updateTokenTimestamp(projectUrl, f.result.token);
 
             resolve(f.result.token);
-            const isInit = !Scoped.InitiatedForcedToken[projectUrl] && isForceRefresh;
+            const isInit = !Scoped.InitiatedForcedToken[projectUrl];
 
             triggerAuthToken(projectUrl, isInit);
-            if (isForceRefresh) Scoped.InitiatedForcedToken[projectUrl] = true;
+            if (isInit) Scoped.InitiatedForcedToken[projectUrl] = true;
 
             getEmulatedLinks(projectUrl).forEach(v => {
                 CacheStore.AuthStore[v] = basicClone(CacheStore.AuthStore[projectUrl]);
@@ -201,12 +208,9 @@ const refreshToken = (builder, remainRetries = 1, isForceRefresh) =>
                 );
                 console.error(`refreshToken retry limit exceeded err:`, e);
             } else {
-                const l = listenReachableServer(c => {
-                    if (c) {
-                        l();
-                        refreshToken(builder, remainRetries - 1, isForceRefresh).then(resolve, reject);
-                    }
-                }, projectUrl);
+                awaitReachableServer(projectUrl).then(() => {
+                    refreshToken(builder, remainRetries - 1, isForceRefresh).then(resolve, reject);
+                });
             }
         }
     });

package/src/products/auth/index.js

@@ -14,8 +14,7 @@ const {
     _customSignin,
     _customSignup,
     _googleSignin,
-    _appleSignin,
-    _areYouOk
+    _appleSignin
 } = EngineApi;
 
 export default class MTAuth {
@@ -185,13 +184,14 @@ const doCustomSignin = (builder, email, password) => new Promise(async (resolve,
 
         const r = uglify ? await deserializeE2E(data, serverE2E_PublicKey, privateKey) : data;
 
+        revokeAuthIntance(builder, thisAuthStore);
+        injectFreshToken(builder, r.result);
+
         resolve({
             user: parseToken(r.result.token),
             token: r.result.token,
             refreshToken: r.result.refreshToken
         });
-        revokeAuthIntance(builder, thisAuthStore);
-        await injectFreshToken(builder, r.result);
     } catch (e) {
         reject(simplifyCaughtError(e).simpleError);
     }
@@ -218,14 +218,15 @@ const doCustomSignup = (builder, email, password, name, metadata) => new Promise
 
         const r = uglify ? await deserializeE2E(data, serverE2E_PublicKey, privateKey) : data;
 
+        revokeAuthIntance(builder, thisAuthStore);
+        injectFreshToken(builder, r.result);
+
         resolve({
             user: parseToken(r.result.token),
             token: r.result.token,
             refreshToken: r.result.refreshToken,
             isNewUser: !!r.result.isNewUser
         });
-        revokeAuthIntance(builder, thisAuthStore);
-        await injectFreshToken(builder, r.result);
     } catch (e) {
         reject(simplifyCaughtError(e).simpleError);
     }
@@ -249,7 +250,10 @@ const clearCacheForSignout = (builder, disposeEmulated) => {
 
     purgeCache(projectUrl, true);
     if (disposeEmulated) getEmulatedLinks(projectUrl).forEach(e => purgeCache(e));
-    initTokenRefresher({ config: builder });
+
+    setTimeout(() => {
+        initTokenRefresher({ config: builder });
+    }, 600);
 };
 
 export const doSignOut = async (builder) => {
@@ -286,12 +290,7 @@ export const purgePendingToken = async (nodeId) => {
 
     if (!token) return;
     try {
-        let isConnected;
-        try {
-            isConnected = (await (await fetch(_areYouOk(projectUrl), { credentials: 'omit' })).json()).status === 'yes';
-        } catch (_) { }
-
-        if (!isConnected) await awaitReachableServer(projectUrl);
+        await awaitReachableServer(projectUrl);
 
         const [reqBuilder] = await buildFetchInterface({
             body: { token, r_token },
@@ -330,14 +329,15 @@ const doProviderSignin = (builder, token, metadata, endpointer) => new Promise(a
 
         const f = uglify ? await deserializeE2E(data, serverE2E_PublicKey, privateKey) : data;
 
+        revokeAuthIntance(builder, thisAuthStore);
+        injectFreshToken(builder, f.result);
+
         resolve({
             user: parseToken(f.result.token),
             token: f.result.token,
             refreshToken: f.result.refreshToken,
             isNewUser: f.result.isNewUser
         });
-        revokeAuthIntance(builder, thisAuthStore);
-        await injectFreshToken(builder, f.result);
     } catch (e) {
         reject(simplifyCaughtError(e).simpleError);
     }

package/src/products/database/index.js

@@ -1,18 +1,19 @@
 import { io } from "socket.io-client";
 import EngineApi from "../../helpers/engine_api";
 import { DatabaseRecordsListener } from "../../helpers/listeners";
-import { deserializeE2E, listenReachableServer, niceTry, serializeE2E } from "../../helpers/peripherals";
-import { awaitStore, buildFetchInterface, buildFetchResult, getReachableServer, updateCacheStore } from "../../helpers/utils";
+import { deserializeE2E, serializeE2E } from "../../helpers/peripherals";
+import { awaitReachableServer, awaitStore, buildFetchInterface, buildFetchResult, getReachableServer, updateCacheStore } from "../../helpers/utils";
 import { CacheStore, Scoped } from "../../helpers/variables";
 import { addPendingWrites, generateRecordID, getCountQuery, getRecord, insertCountQuery, insertRecord, listenQueryEntry, removePendingWrite, validateWriteValue } from "./accessor";
 import { validateCollectionName, validateFilter, validateFindConfig, validateFindObject, validateListenFindConfig } from "./validator";
-import { awaitRefreshToken, listenToken } from "../auth/accessor";
+import { awaitRefreshToken, listenTokenReady } from "../auth/accessor";
 import { DELIVERY, RETRIEVAL } from "../../helpers/values";
 import { ObjectId } from "../../vendor/bson";
 import { guardObject, Validator } from "guard-object";
 import { simplifyCaughtError } from "simplify-error";
 import { deserializeBSON, serializeToBase64 } from "./bson";
 import { basicClone } from "../../helpers/basic_clone";
+import { AppState } from "react-native";
 
 export class MTCollection {
     constructor(config) {
@@ -149,13 +150,14 @@ const listenDocument = (callback, onError, builder, config) => {
     validateFilter(findOne || find);
     validateCollectionName(path);
 
+    /**
+     * @type {import('socket.io-client').Socket}
+     */
+    let socket;
     let hasCancelled,
         hasRespond,
         cacheListener,
-        socket,
-        lastToken = Scoped.AuthJWTToken[projectUrl] || null,
         lastInitRef = 0,
-        connectedListener,
         lastSnapshot;
 
     const dispatchSnapshot = s => {
@@ -176,15 +178,30 @@ const listenDocument = (callback, onError, builder, config) => {
 
         awaitStore().then(() => {
             if (hasCancelled) return;
-            connectedListener = listenReachableServer(async connected => {
-                connectedListener();
+            getReachableServer(projectUrl).then(connected => {
                 if (!connected && !hasRespond && !hasCancelled && shouldCache)
                     DatabaseRecordsListener.dispatch('d', processId);
-            }, projectUrl);
+            });
         });
     }
 
+    let foregroundListener;
+    const clearForegroundListener = () => {
+        if (!foregroundListener) return;
+        foregroundListener.remove();
+        foregroundListener = undefined;
+    }
+
+    const clearSocket = () => {
+        if (socket) {
+            socket.close();
+            socket = undefined;
+        }
+    }
+
     const init = async () => {
+        clearForegroundListener();
+
         const processID = ++lastInitRef;
         if (!disableAuth) await awaitRefreshToken(projectUrl);
         if (hasCancelled || processID !== lastInitRef) return;
@@ -207,6 +224,7 @@ const listenDocument = (callback, onError, builder, config) => {
         const [encPlate, [privateKey]] = uglify ? await serializeE2E({ _body: authObj }, mtoken, serverE2E_PublicKey) : ['', []];
 
         if (hasCancelled || processID !== lastInitRef) return;
+
         socket = io(`${wsPrefix}://${baseUrl}`, {
             transports: ['websocket', 'polling', 'flashsocket'],
             extraHeaders,
@@ -217,7 +235,8 @@ const listenDocument = (callback, onError, builder, config) => {
                 },
                 _m_internal: true,
                 _m_route: (findOne ? _listenDocument : _listenCollection)(uglify)
-            }
+            },
+            reconnection: false
         });
 
         socket.on('mSnapshot', async ([err, snapshot]) => {
@@ -234,27 +253,83 @@ const listenDocument = (callback, onError, builder, config) => {
                 if (shouldCache) insertRecord(builder, config, await accessId, snapshot, episode);
             }
         });
-    };
 
-    init();
+        const reconnect = (timeout) => {
+            if (processID !== lastInitRef || hasCancelled) return;
 
-    const tokenListener = listenToken(t => {
-        if ((t || null) !== lastToken) {
-            socket?.close?.();
-            socket = undefined;
-            init();
+            const reloadIntance = async () => {
+                if (processID === lastInitRef && !hasCancelled) remountInit();
+            }
+
+            if (AppState.currentState === 'active') {
+                setTimeout(() => {
+                    awaitReachableServer(projectUrl).then(reloadIntance);
+                }, timeout);
+            } else {
+                foregroundListener = AppState.addEventListener('change', s => {
+                    if (s === 'active') {
+                        clearForegroundListener();
+                        reloadIntance();
+                    }
+                });
+            }
         }
-        lastToken = t || null;
-    }, projectUrl);
 
-    return () => {
+        let wasHandled;
+        socket.on('connect_error', () => {
+            if (processID !== lastInitRef || wasHandled) return;
+            wasHandled = true;
+            clearSocket();
+            reconnect(3000);
+        });
+
+        socket.on('disconnect', r => {
+            if (processID !== lastInitRef || wasHandled) return;
+            wasHandled = true;
+            clearSocket();
+            if (r === 'io client disconnect' || r === 'io server disconnect') {
+                canceller();
+            } else reconnect(0);
+        });
+    };
+
+    const remountInit = () => {
+        if (socket) {
+            ++lastInitRef;
+            clearSocket();
+        }
+        init();
+    }
+
+    let lastTokenStatus;
+    let tokenListener;
+
+    if (disableAuth) {
+        init();
+    } else {
+        tokenListener = listenTokenReady(ready => {
+            if (lastTokenStatus === (ready || false)) return;
+            if (ready) {
+                remountInit();
+            } else {
+                ++lastInitRef;
+                clearForegroundListener();
+                clearSocket();
+            }
+            lastTokenStatus = ready || false;
+        }, projectUrl);
+    }
+
+    const canceller = () => {
         if (hasCancelled) return;
         hasCancelled = true;
-        connectedListener?.();
         cacheListener?.();
         tokenListener?.();
-        if (socket) socket.close();
+        clearForegroundListener();
+        clearSocket();
     }
+
+    return canceller;
 };
 
 const initOnDisconnectionTask = ({ builder, connectData, disconnectData }) => {
@@ -279,18 +354,29 @@ const initOnDisconnectionTask = ({ builder, connectData, disconnectData }) => {
         }
     });
 
-    let hasCancelled,
-        /**
-         * @type {import('socket.io-client').Socket}
-         */
-        socket,
-        lastToken = Scoped.AuthJWTToken[projectUrl] || null,
+    /**
+     * @type {import('socket.io-client').Socket}
+     */
+    let socket,
+        hasCancelled,
         lastInitRef = 0;
 
+    let foregroundListener;
+    const clearForegroundListener = () => {
+        if (!foregroundListener) return;
+        foregroundListener.remove();
+        foregroundListener = undefined;
+    }
+
+    const clearSocket = () => {
+        if (socket) {
+            socket.close();
+            socket = undefined;
+        }
+    }
+
     const init = async () => {
         const processID = ++lastInitRef;
-        if (!disableAuth) await awaitRefreshToken(projectUrl);
-        if (hasCancelled || processID !== lastInitRef) return;
 
         const mtoken = disableAuth ? undefined : Scoped.AuthJWTToken[projectUrl];
         const makeObj = (d) => ({
@@ -307,46 +393,109 @@ const initOnDisconnectionTask = ({ builder, connectData, disconnectData }) => {
             ...dbUrl ? { dbUrl } : undefined
         };
 
+        const uglifyData = uglify && (await serializeE2E({ _body: authObj }, mtoken, serverE2E_PublicKey))[0].toString('base64');
+
+        if (hasCancelled || processID !== lastInitRef) return;
+
         socket = io(`${wsPrefix}://${baseUrl}`, {
             transports: ['websocket', 'polling', 'flashsocket'],
             extraHeaders,
             auth: {
-                ...uglify ? {
-                    e2e: (await serializeE2E({ _body: authObj }, mtoken, serverE2E_PublicKey))[0].toString('base64')
-                } : {
+                ...uglify ? { e2e: uglifyData } : {
                     ...mtoken ? { mtoken } : {},
                     _body: authObj
                 },
                 _m_internal: true,
                 _m_route: _startDisconnectWriteTask(uglify)
+            },
+            reconnection: false
+        });
+
+        const reconnect = (timeout) => {
+            if (processID !== lastInitRef || hasCancelled) return;
+
+            const reloadIntance = async () => {
+                if (!disableAuth) await awaitRefreshToken(projectUrl);
+                if (processID === lastInitRef && !hasCancelled) remountInit();
             }
+
+            if (AppState.currentState === 'active') {
+                setTimeout(() => {
+                    awaitReachableServer(projectUrl).then(reloadIntance);
+                }, timeout);
+            } else {
+                foregroundListener = AppState.addEventListener('change', s => {
+                    if (s === 'active') {
+                        clearForegroundListener();
+                        reloadIntance();
+                    }
+                });
+            }
+        }
+
+        let wasHandled;
+        socket.on('connect_error', () => {
+            if (processID !== lastInitRef || wasHandled) return;
+            wasHandled = true;
+            clearSocket();
+            reconnect(3000);
         });
-    };
 
-    init();
+        socket.on('disconnect', r => {
+            if (processID !== lastInitRef || wasHandled) return;
+            wasHandled = true;
+            clearSocket();
+            if (r === 'io client disconnect' || r === 'io server disconnect') {
+                canceller();
+            } else reconnect(0);
+        });
+    };
 
-    const tokenListener = disableAuth ? undefined : listenToken(async t => {
-        if ((t || null) !== lastToken) {
-            if (socket) {
-                socket.close();
-                socket = undefined;
-                setTimeout(init, 500);
-            } else init();
+    const remountInit = () => {
+        if (socket) {
+            ++lastInitRef;
+            clearSocket();
         }
-        lastToken = t;
-    }, projectUrl);
+        init();
+    }
+
+    let lastTokenStatus;
+    let tokenListener;
+
+    if (disableAuth) {
+        init();
+    } else {
+        tokenListener = listenTokenReady(ready => {
+            if (lastTokenStatus === (ready || false)) return;
+            if (ready) {
+                remountInit();
+            } else {
+                ++lastInitRef;
+                clearForegroundListener();
+                clearSocket();
+            }
+            lastTokenStatus = ready || false;
+        }, projectUrl);
+    }
 
-    return () => {
+    const canceller = () => {
         if (hasCancelled) return;
         hasCancelled = true;
         tokenListener?.();
+        clearForegroundListener();
         if (socket) {
             const thisSocket = socket;
-            return niceTry(() => thisSocket.timeout(5000).emitWithAck(_cancelDisconnectWriteTask(uglify))).finally(() => {
-                thisSocket.close();
-            });
+            try {
+                thisSocket.timeout(5000).emitWithAck(_cancelDisconnectWriteTask(uglify)).finally(() => {
+                    thisSocket.close();
+                });
+            } catch (error) {
+                console.warn('socket closure error:', error);
+            }
         }
     };
+
+    return canceller;
 };
 
 const countCollection = async (builder, config) => {
@@ -410,15 +559,12 @@ const countCollection = async (builder, config) => {
             } else if (retries > maxRetries) {
                 finalize(undefined, { error: 'retry_limit_exceeded', message: `retry exceed limit(${maxRetries})` });
             } else {
-                const onlineListener = listenReachableServer(connected => {
-                    if (connected) {
-                        onlineListener();
-                        readValue().then(
-                            e => { finalize(e); },
-                            e => { finalize(undefined, e); }
-                        );
-                    }
-                }, projectUrl);
+                awaitReachableServer(projectUrl).then(() => {
+                    readValue().then(
+                        e => { finalize(e); },
+                        e => { finalize(undefined, e); }
+                    );
+                });
             }
         }
     });
@@ -588,20 +734,18 @@ const findObject = async (builder, initConfig) => {
             } else if (retries > maxRetries) {
                 finalize(undefined, { error: 'retry_limit_exceeded', message: `retry exceed limit(${maxRetries})` });
             } else {
-                const onlineListener = listenReachableServer(connected => {
-                    if (connected) {
+                awaitReachableServer(projectUrl).then(() => {
+                    if (intruder) {
                         intruder.resolve = undefined;
                         intruder.reject = undefined;
-                        onlineListener();
                         readValue().then(
                             e => { finalize(e); },
                             e => { finalize(undefined, e); }
                         );
                     }
-                }, projectUrl);
+                });
 
                 const cleanseIntruder = () => {
-                    onlineListener?.();
                     intruder = undefined;
                 }
 
@@ -737,15 +881,12 @@ const commitData = async (builder, value, type, config) => {
                 );
             } else {
                 if (delivery === DELIVERY.NO_CACHE_AWAIT) {
-                    const onlineListener = listenReachableServer(connected => {
-                        if (connected) {
-                            onlineListener();
-                            sendValue().then(
-                                e => { finalize(e.a, undefined, e.c); },
-                                e => { finalize(undefined, e.b, e.c); }
-                            );
-                        }
-                    }, projectUrl);
+                    awaitReachableServer(projectUrl).then(() => {
+                        sendValue().then(
+                            e => { finalize(e.a, undefined, e.c); },
+                            e => { finalize(undefined, e.b, e.c); }
+                        );
+                    });
                 } else if (shouldCache) finalize({ status: 'queued' });
                 else finalize(undefined, simplifyCaughtError(e).simpleError);
             }

package/src/products/http_callable/index.js

@@ -1,6 +1,6 @@
 import { Buffer } from "buffer";
-import { deserializeE2E, listenReachableServer, niceHash, normalizeRoute, serializeE2E } from "../../helpers/peripherals";
-import { awaitStore, getReachableServer } from "../../helpers/utils";
+import { deserializeE2E, niceHash, normalizeRoute, serializeE2E } from "../../helpers/peripherals";
+import { awaitReachableServer, awaitStore, getReachableServer } from "../../helpers/utils";
 import { RETRIEVAL } from "../../helpers/values";
 import { Scoped } from "../../helpers/variables";
 import { awaitRefreshToken, parseToken } from "../auth/accessor";
@@ -184,7 +184,9 @@ export const mfetch = async (input = '', init, config) => {
                 )
             };
 
-            if (shouldCache) insertFetchResources(projectUrl, reqId, resObj);
+            if (shouldCache) {
+                if (status === 200) insertFetchResources(projectUrl, reqId, resObj);
+            }
 
             finalize(resObj);
         } catch (e) {
@@ -214,15 +216,12 @@ export const mfetch = async (input = '', init, config) => {
             } else if (retries > maxRetries) {
                 finalize(undefined, simplifyCaughtError(e).simpleError);
             } else {
-                const listener = listenReachableServer(async online => {
-                    if (online) {
-                        listener();
-                        callFetch().then(
-                            e => finalize(e),
-                            e => finalize(undefined, e)
-                        );
-                    }
-                }, projectUrl);
+                awaitReachableServer(projectUrl).then(() => {
+                    callFetch().then(
+                        e => finalize(e),
+                        e => finalize(undefined, e)
+                    );
+                });
             }
         }
     });