react-native-mosquito-transport 0.0.52 → 0.0.54

package/package.json

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

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,71 @@ 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 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);
+
+                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,6 +4,7 @@ export const Scoped = {
     PendingIte: 0,
     AnyProcessIte: 0,
     IS_CONNECTED: {},
+    AreYouOkPromise: {},
     InitializedProject: {},
     ReleaseCacheData: undefined,
     AuthJWTToken: {},

package/src/index.js

@@ -1,6 +1,6 @@
 import 'react-native-get-random-values';
-import { deserializeE2E, listenReachableServer, serializeE2E } from "./helpers/peripherals";
-import { awaitReachableServer, 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";
@@ -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'],
@@ -75,7 +74,6 @@ class RNMT {
             });
 
             let connectionIte = 0;
-            let chainedPromise;
             const setConnected = c => {
                 isConnected = c;
                 Scoped.IS_CONNECTED[projectUrl] = isConnected;
@@ -91,28 +89,17 @@ class RNMT {
                 });
             };
 
-            const onDisconnect = () => {
-                ++connectionIte;
-                setConnected(isVirtualMachineFocused ? false : null);
-            }
-
             const manualCheckConnection = () => {
-                if (chainedPromise) return;
                 const ref = ++connectionIte;
-                const signal = new AbortController();
-                const timer = setTimeout(() => {
-                    signal.abort();
-                }, 7000);
-                chainedPromise = fetch(_areYouOk(projectUrl), { credentials: 'omit', signal }).then(async r => {
-                    clearTimeout(timer);
-                    chainedPromise = undefined;
-                    if ((await r.json()).status === 'yes') {
-                        if (ref === connectionIte) onConnect();
-                    } else throw null;
-                }).catch(() => {
-                    clearTimeout(timer);
-                    chainedPromise = undefined;
-                    if (ref === connectionIte) onDisconnect();
+
+                checkAreYouOk(projectUrl).then(ok => {
+                    if (ref !== connectionIte) return;
+                    if (ok) {
+                        onConnect();
+                    } else {
+                        ++connectionIte;
+                        isConnected = false;
+                    }
                 });
             }
 
@@ -128,7 +115,6 @@ class RNMT {
             });
 
             AppState.addEventListener('change', s => {
-                isVirtualMachineFocused = s === 'active';
                 manualCheckConnection();
             });
 
@@ -352,7 +338,7 @@ class RNMT {
                 makeSocketCallback();
                 const reloadIntance = async () => {
                     if (!disableAuth) await awaitRefreshToken(projectUrl);
-                    if (initIte === instance_id) remountInit();
+                    if (initIte === instance_id && !hasCancelled) remountInit();
                 }
 
                 if (AppState.currentState === 'active') {
@@ -387,8 +373,7 @@ class RNMT {
                 if (initIte !== instance_id || wasHandled) return;
                 wasHandled = true;
                 clearSocket();
-                if (r === 'io client disconnect') return;
-                if (r === 'io server disconnect') {
+                if (r === 'io client disconnect' || r === 'io server disconnect') {
                     resultant.destroy();
                 } else reconnect(0);
             });
@@ -478,6 +463,7 @@ class RNMT {
                 }
             },
             destroy: () => {
+                if (hasCancelled) return;
                 hasCancelled = true;
                 tokenListener?.();
                 clearForegroundListener();

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, getReachableServer, updateCacheStore } from "../../helpers/utils";
 import { CacheStore, Scoped } from "../../helpers/variables";
 import { simplifyError } from "simplify-error";
 import { Validator } from "guard-object";
@@ -76,6 +76,19 @@ export const awaitRefreshToken = (projectUrl) =>
         }
     });
 
+export const ensureActiveToken = async (projectUrl) => {
+    if (await getReachableServer(projectUrl)) {
+        await awaitRefreshToken(projectUrl);
+    } else {
+        const emulatedURL = CacheStore.EmulatedAuth[projectUrl];
+        const { token } = CacheStore.AuthStore[emulatedURL || projectUrl] || {};
+
+        if (token && await hasTokenExpire(emulatedURL || projectUrl)) {
+            throw 'unable to refreshed expired token because of unreachable internet connection';
+        }
+    }
+}
+
 export const listenTokenReady = (callback, projectUrl) => TokenRefreshListener.listenToPersist(projectUrl, callback);
 
 export const initTokenRefresher = async ({ config, forceRefresh, justCheck }) => {
@@ -208,12 +221,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 {
@@ -55,11 +54,13 @@ export default class MTAuth {
             const processID = ++lastInitRef;
             await awaitRefreshToken(projectUrl);
 
+            if (processID !== lastInitRef || hasCancelled) return;
+
             if (!Scoped.AuthJWTToken[projectUrl]) {
                 onError?.(simplifyError('user_login_required', 'You must be signed-in to use this method').simpleError);
                 return;
             }
-            if (processID !== lastInitRef || hasCancelled) return;
+
             const mtoken = Scoped.AuthJWTToken[projectUrl],
                 [reqBuilder, [privateKey]] = uglify ? await serializeE2E({ mtoken }, undefined, serverE2E_PublicKey) : [null, []];
 
@@ -252,6 +253,7 @@ const clearCacheForSignout = (builder, disposeEmulated) => {
     purgeCache(projectUrl, true);
     if (disposeEmulated) getEmulatedLinks(projectUrl).forEach(e => purgeCache(e));
 
+    clearInterval(Scoped.TokenRefreshTimer[projectUrl]);
     setTimeout(() => {
         initTokenRefresher({ config: builder });
     }, 600);
@@ -291,12 +293,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 },

package/src/products/database/index.js

@@ -1,12 +1,12 @@
 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 { 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, listenTokenReady } from "../auth/accessor";
+import { awaitRefreshToken, ensureActiveToken, listenTokenReady } from "../auth/accessor";
 import { DELIVERY, RETRIEVAL } from "../../helpers/values";
 import { ObjectId } from "../../vendor/bson";
 import { guardObject, Validator } from "guard-object";
@@ -158,7 +158,6 @@ const listenDocument = (callback, onError, builder, config) => {
         hasRespond,
         cacheListener,
         lastInitRef = 0,
-        connectedListener,
         lastSnapshot;
 
     const dispatchSnapshot = s => {
@@ -179,11 +178,10 @@ 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);
+            });
         });
     }
 
@@ -260,7 +258,7 @@ const listenDocument = (callback, onError, builder, config) => {
             if (processID !== lastInitRef || hasCancelled) return;
 
             const reloadIntance = async () => {
-                if (processID !== lastInitRef && !hasCancelled) remountInit();
+                if (processID === lastInitRef && !hasCancelled) remountInit();
             }
 
             if (AppState.currentState === 'active') {
@@ -289,8 +287,9 @@ const listenDocument = (callback, onError, builder, config) => {
             if (processID !== lastInitRef || wasHandled) return;
             wasHandled = true;
             clearSocket();
-            if (r === 'io client disconnect' || r === 'io server disconnect') return;
-            reconnect(0);
+            if (r === 'io client disconnect' || r === 'io server disconnect') {
+                canceller();
+            } else reconnect(0);
         });
     };
 
@@ -321,15 +320,16 @@ const listenDocument = (callback, onError, builder, config) => {
         }, projectUrl);
     }
 
-    return () => {
+    const canceller = () => {
         if (hasCancelled) return;
         hasCancelled = true;
-        connectedListener?.();
         cacheListener?.();
         tokenListener?.();
         clearForegroundListener();
         clearSocket();
     }
+
+    return canceller;
 };
 
 const initOnDisconnectionTask = ({ builder, connectData, disconnectData }) => {
@@ -416,7 +416,7 @@ const initOnDisconnectionTask = ({ builder, connectData, disconnectData }) => {
 
             const reloadIntance = async () => {
                 if (!disableAuth) await awaitRefreshToken(projectUrl);
-                if (processID !== lastInitRef && !hasCancelled) remountInit();
+                if (processID === lastInitRef && !hasCancelled) remountInit();
             }
 
             if (AppState.currentState === 'active') {
@@ -445,8 +445,9 @@ const initOnDisconnectionTask = ({ builder, connectData, disconnectData }) => {
             if (processID !== lastInitRef || wasHandled) return;
             wasHandled = true;
             clearSocket();
-            if (r === 'io client disconnect' || r === 'io server disconnect') return;
-            reconnect(0);
+            if (r === 'io client disconnect' || r === 'io server disconnect') {
+                canceller();
+            } else reconnect(0);
         });
     };
 
@@ -477,18 +478,24 @@ const initOnDisconnectionTask = ({ builder, connectData, disconnectData }) => {
         }, 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) => {
@@ -519,8 +526,7 @@ const countCollection = async (builder, config) => {
         };
 
         try {
-            if (!disableAuth && await getReachableServer(projectUrl))
-                await awaitRefreshToken(projectUrl);
+            if (!disableAuth) await ensureActiveToken(projectUrl);
 
             const [reqBuilder, [privateKey]] = await buildFetchInterface({
                 body: {
@@ -552,15 +558,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); }
+                    );
+                });
             }
         }
     });
@@ -672,8 +675,7 @@ const findObject = async (builder, initConfig) => {
                 }
             }
 
-            if (!disableAuth && await getReachableServer(projectUrl))
-                await awaitRefreshToken(projectUrl);
+            if (!disableAuth) await ensureActiveToken(projectUrl);
 
             const [reqBuilder, [privateKey]] = await buildFetchInterface({
                 body: {
@@ -730,20 +732,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;
                 }
 
@@ -837,8 +837,7 @@ const commitData = async (builder, value, type, config) => {
         };
 
         try {
-            if (!disableAuth && await getReachableServer(projectUrl))
-                await awaitRefreshToken(projectUrl);
+            if (!disableAuth) await ensureActiveToken(projectUrl);
 
             const [reqBuilder, [privateKey]] = await buildFetchInterface({
                 body: {
@@ -879,15 +878,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,9 +1,9 @@
 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 } from "../../helpers/utils";
 import { RETRIEVAL } from "../../helpers/values";
 import { Scoped } from "../../helpers/variables";
-import { awaitRefreshToken, parseToken } from "../auth/accessor";
+import { ensureActiveToken, parseToken } from "../auth/accessor";
 import { simplifyCaughtError } from "simplify-error";
 import { guardObject, Validator } from "guard-object";
 import { serialize } from "entity-serializer";
@@ -134,8 +134,7 @@ export const mfetch = async (input = '', init, config) => {
                 }
             }
 
-            if (!disableAuth && await getReachableServer(projectUrl))
-                await awaitRefreshToken(projectUrl);
+            if (!disableAuth) await ensureActiveToken(projectUrl);
 
             const mtoken = disableAuth ? undefined : Scoped.AuthJWTToken[projectUrl];
             const initType = rawHeader['content-type'];
@@ -216,15 +215,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)
+                    );
+                });
             }
         }
     });