react-native-mosquito-transport 0.0.48 → 0.0.49

package/ios/{Mosquitodb.swift → MosquitoTransport.swift}

@@ -1,52 +1,34 @@
 import React
 
-@objc(Mosquitodb)
-class Mosquitodb:  RCTEventEmitter, URLSessionDataDelegate {
+@objc
+public protocol NativeMosquitoTransportImplDelegate {
+    func sendEvent(name: String, body: Any)
+}
+
+@objc(NativeMosquitoTransportImpl)
+public class NativeMosquitoTransportImpl: NSObject, URLSessionDataDelegate {
+    // Add property for the Objective-C bridge
+    @objc public weak var delegate: NativeMosquitoTransportImplDelegate? = nil
     
     public override init() {
         super.init()
     }
-    
-    override public static func requiresMainQueueSetup() -> Bool {
-        return true;
-    }
-    
-    @objc(supportedEvents)
-    override public func supportedEvents() -> [String] {
-        return [
-            "mt-uploading-progress",
-            "mt-uploading-status",
-            "mt-download-progress",
-            "mt-download-status"
-        ]
+
+    private func emitNewEvent(name: String, body: Any? = nil) {
+        delegate?.sendEvent(name: name, body: body ?? [])
     }
     
-    var uploadTask: [String: MosquitodbUploadTask] = [:]
-    var downloadTask: [String: MosquitodbDownloadTask] = [:]
-    
-    @objc(downloadFile:)
-    func downloadFile(options: [String: Any]) -> Void {
-        let processID = options["processID"] as! String
-        downloadTask[processID] = MosquitodbDownloadTask()
-        downloadTask[processID]?.downloadFile(options: options, completion: { res in
-            let status = res![0] as? String
-            
-            self.sendEvent(withName: status, body: res![1])
-            if status == "mt-download-status" {
-                self.downloadTask.removeValue(forKey: processID)
-            }
-        })
-    }
+    var uploadTask: [String: MosquitoTransportUploadTask] = [:]
     
     @objc(uploadFile:)
-    func uploadFile(options: [String: Any]) -> Void {
+    public func uploadFile(options: [String: Any]) -> Void {
         let processID = options["processID"] as! String
         
-        uploadTask[processID] = MosquitodbUploadTask()
+        uploadTask[processID] = MosquitoTransportUploadTask()
         uploadTask[processID]?.uploadFile(options: options, completion: { res in
             let status = res![0] as? String
             
-            self.sendEvent(withName: status, body: res![1])
+            self.emitNewEvent(name: status!, body: res![1])
             if status == "mt-uploading-status" {
                 self.uploadTask.removeValue(forKey: processID)
             }
@@ -54,28 +36,43 @@ class Mosquitodb:  RCTEventEmitter, URLSessionDataDelegate {
     }
     
     @objc(cancelUpload:)
-    func cancelUpload (processID: String)-> Void {
+    public func cancelUpload (processID: String)-> Void {
         uploadTask[processID]?.cancelUpload()
     }
     
+    var downloadTask: [String: MosquitoTransportDownloadTask] = [:]
+    
+    @objc(downloadFile:)
+    public func downloadFile(options: [String: Any]) -> Void {
+        let processID = options["processID"] as! String
+        downloadTask[processID] = MosquitoTransportDownloadTask()
+        downloadTask[processID]?.downloadFile(options: options, completion: { res in
+            let status = res![0] as? String
+            
+            self.emitNewEvent(name: status!, body: res![1])
+            if status == "mt-download-status" {
+                self.downloadTask.removeValue(forKey: processID)
+            }
+        })
+    }
+    
     @objc(cancelDownload:)
-    func cancelDownload (processID: String)-> Void {
+    public func cancelDownload (processID: String)-> Void {
         downloadTask[processID]?.cancelDownload()
     }
     
     @objc(pauseDownload:)
-    func pauseDownload (processID: String)-> Void {
+    public func pauseDownload (processID: String)-> Void {
         downloadTask[processID]?.pauseDownload()
     }
     
     @objc(resumeDownload:)
-    func resumeDownload (processID: String)-> Void {
+    public func resumeDownload (processID: String)-> Void {
         downloadTask[processID]?.resumeDownload()
     }
 }
 
-
-class MosquitodbUploadTask: NSObject, URLSessionDataDelegate {
+class MosquitoTransportUploadTask: NSObject, URLSessionDataDelegate {
     
     var mainProcessID: String = ""
     var mainTask : URLSessionUploadTask? = nil
@@ -177,7 +174,7 @@ class MosquitodbUploadTask: NSObject, URLSessionDataDelegate {
 }
 
 
-class MosquitodbDownloadTask: NSObject, URLSessionDownloadDelegate {
+class MosquitoTransportDownloadTask: NSObject, URLSessionDownloadDelegate {
     
     var mainProcessID: String = ""
     var mainTask : URLSessionDownloadTask? = nil
@@ -208,7 +205,7 @@ class MosquitodbDownloadTask: NSObject, URLSessionDownloadDelegate {
         mainOptions = options
         trigger = completion
         task.resume()
-        print("MosquitodbDownloadTask started:\(mainProcessID)")
+        print("MosquitoTransportDownloadTask started:\(mainProcessID)")
     }
     
     func cancelDownload ()-> Void {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-mosquito-transport",
-  "version": "0.0.48",
+  "version": "0.0.49",
   "description": "React native javascript sdk for mosquito-transport (https://github.com/brainbehindx/mosquito-transport)",
   "main": "src/index.js",
   "type": "module",
@@ -26,6 +26,14 @@
     "url": "https://github.com/brainbehindx/react-native-mosquito-transport/issues"
   },
   "homepage": "https://github.com/brainbehindx/react-native-mosquito-transport#readme",
+  "codegenConfig": {
+    "name": "MosquitoTransportSpec",
+    "type": "modules",
+    "jsSrcsDir": "src",
+    "android": {
+      "javaPackageName": "com.mosquitotransport"
+    }
+  },
   "dependencies": {
     "@turf/turf": "^7.2.0",
     "buffer": "^6.0.3",
@@ -43,4 +51,4 @@
     "react-native-get-random-values": "*",
     "react-native-sha256": "*"
   }
-}
+}

package/src/NativeMosquitoTransport.js

@@ -0,0 +1,24 @@
+// @flow
+import type { TurboModule } from 'react-native';
+import { type UnsafeObject } from 'react-native/Libraries/Types/CodegenTypes';
+import { TurboModuleRegistry } from 'react-native';
+
+export interface Spec extends TurboModule {
+  // storage
+  uploadFile(option: UnsafeObject): void;
+  cancelUpload(process_id: string): void;
+  downloadFile(option: UnsafeObject): void;
+  cancelDownload(process_id: string): void;
+  pauseDownload(process_id: string): void;
+  resumeDownload(process_id: string): void;
+
+  // utils
+  getSystemUptime(): Promise<number>;
+
+  // event listeners
+  // readonly onMessage?: EventEmitter<{ message: string }>;
+  addListener(eventName: string): void;
+  removeListeners(count: number): void;
+}
+
+export default TurboModuleRegistry.getEnforcing<Spec>('MosquitoTransport');

package/src/helpers/fs_manager.js

@@ -4,7 +4,7 @@ import { Platform } from "react-native";
 import { Dirs, FileSystem } from "react-native-file-access";
 import { Buffer } from "buffer";
 
-const PARENT_FOLDER = `${Platform.OS === 'android' ? Dirs.DocumentDir.split('/').slice(0, -1).join('/') : Dirs.MainBundleDir}/mosquito_base`;
+const PARENT_FOLDER = `${Platform.OS === 'android' ? Dirs.DocumentDir.split('/').slice(0, -1).join('/') : Dirs.LibraryDir}/mosquito_base`;
 
 /**
  * this method linearize read/write for individual access_id on the file system ensuring consistency across concurrent operations

package/src/helpers/utils.js

@@ -134,21 +134,19 @@ export const releaseCacheStore = async (builder) => {
         Scoped.AuthJWTToken[key] = value?.token;
     });
     Scoped.IsStoreReady = true;
-    StoreReadyListener.dispatchPersist('_', 'ready');
+    StoreReadyListener.dispatchPersist('_', true);
     setTimeout(() => {
         if (tobePurged.length) updateCacheStore(tobePurged);
     }, 0);
 };
 
-export const getPrefferTime = () => Date.now() + (Scoped.serverTimeOffset || 0);
-
 export const awaitStore = () => new Promise(resolve => {
     if (Scoped.IsStoreReady) {
         resolve();
         return;
     }
     const l = StoreReadyListener.listenToPersist('_', t => {
-        if (t === 'ready') {
+        if (t) {
             resolve();
             l();
         }

package/src/helpers/variables.js

@@ -10,7 +10,8 @@ export const Scoped = {
     AuthJWTToken: {},
     IsStoreReady: false,
     TokenRefreshTimer: {},
-    LastTokenRefreshRef: {},
+    TokenRefreshProcess: {},
+    TokenTimestamping: {},
     StorageProcessID: 0,
     InitiatedForcedToken: {},
     PendingFetchCollective: {},

package/src/index.d.ts

@@ -347,7 +347,7 @@ interface GetConfig {
     retrieval?: Retrieval;
     /**
      * - 0: returns data that may have been internally updated locally with updateOne, updateMany, mergeOne, deleteOne, deleteMany, putOne, replaceOne
-     * - 1: returns exact data which was cached in the last query process
+     * - 1: returns exact remote data which was cached in the last query process
      * 
      * @defaults - 0
      * 

package/src/index.js

@@ -16,6 +16,7 @@ import { Buffer } from 'buffer';
 import MTAuth, { purgePendingToken } from './products/auth';
 import { BSON } from "./vendor/bson";
 import { basicClone } from './helpers/basic_clone';
+import { AppState } from "react-native";
 
 const {
     _listenCollection,
@@ -59,11 +60,10 @@ class RNMT {
 
         if (!Scoped.InitializedProject[projectUrl]) {
             Scoped.InitializedProject[projectUrl] = basicClone(this.config);
-            Scoped.LastTokenRefreshRef[projectUrl] = 0;
             triggerAuthToken(projectUrl);
-            initTokenRefresher({ ...this.config }, true);
+            initTokenRefresher({ config: this.config, forceRefresh: true });
 
-            let isConnected, recentToken;
+            let isConnected, recentToken, isVirtualMachineFocused = true;
 
             const socket = io(`${this.config.wsPrefix}://${this.config.baseUrl}`, {
                 transports: ['websocket', 'polling', 'flashsocket'],
@@ -86,9 +86,9 @@ class RNMT {
             };
             const onDisconnect = () => {
                 ++connectionIte;
-                isConnected = false;
-                Scoped.IS_CONNECTED[projectUrl] = false;
-                ServerReachableListener.dispatchPersist(projectUrl, false);
+                isConnected = isVirtualMachineFocused ? false : null;
+                Scoped.IS_CONNECTED[projectUrl] = isConnected;
+                ServerReachableListener.dispatchPersist(projectUrl, isConnected);
             }
 
             const manualCheckConnection = () => {
@@ -112,6 +112,11 @@ class RNMT {
                 manualCheckConnection();
             });
 
+            AppState.addEventListener('change', (s) => {
+                isVirtualMachineFocused = s === 'active';
+                manualCheckConnection();
+            });
+
             const updateMountedToken = () => {
                 socket.emit('_update_mounted_user', recentToken || null);
             };
@@ -308,7 +313,7 @@ class RNMT {
             tokenListener = listenTokenReady(status => {
                 if (lastTokenStatus === (status || false)) return;
 
-                if (status === 'ready') {
+                if (status) {
                     init();
                 } else {
                     socket?.close?.();
@@ -448,7 +453,7 @@ const ConfigValidator = {
         if (v.endsWith('/')) throw '"projectUrl" must not end with a trailing slash "/"';
     },
     disableCache: (v) => {
-        if (typeof v !== 'boolean')
+        if (typeof v !== 'boolean' && v !== undefined)
             throw `Invalid value supplied to disableCache, value must be a boolean`;
     },
     maxRetries: (v) => {
@@ -456,7 +461,7 @@ const ConfigValidator = {
             throw `Invalid value supplied to maxRetries, value must be positive integer greater than zero`;
     },
     enableE2E_Encryption: (v) => {
-        if (typeof v !== 'boolean')
+        if (typeof v !== 'boolean' && v !== undefined)
             throw `Invalid value supplied to enableE2E_Encryption, value must be a boolean`;
     },
     castBSON: v => {
@@ -468,7 +473,7 @@ const ConfigValidator = {
             throw `Expected "borrowToken" to be valid https or http link but got "${v}"`;
     },
     serverE2E_PublicKey: (v) => {
-        if (typeof v !== 'string' || !v.trim())
+        if (v !== undefined && (typeof v !== 'string' || !v.trim()))
             throw `Invalid value supplied to serverETE_PublicKey, value must be a non-empty string`;
     },
     extraHeaders: v => {

package/src/products/auth/accessor.js

@@ -2,11 +2,12 @@ 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, getPrefferTime, updateCacheStore } from "../../helpers/utils";
+import { awaitStore, buildFetchInterface, buildFetchResult, updateCacheStore } from "../../helpers/utils";
 import { CacheStore, Scoped } from "../../helpers/variables";
 import { simplifyError } from "simplify-error";
 import { Validator } from "guard-object";
 import { basicClone } from "../../helpers/basic_clone";
+import NativeMosquitoTransport from "../../NativeMosquitoTransport.js";
 
 export const listenToken = (callback, projectUrl) =>
     AuthTokenListener.listenToPersist(projectUrl, (t, n) => {
@@ -17,16 +18,16 @@ export const listenToken = (callback, projectUrl) =>
 export const injectFreshToken = async (config, { token, refreshToken }) => {
     const { projectUrl } = config;
 
-    await awaitStore();
     CacheStore.AuthStore[projectUrl] = { token, refreshToken };
     Scoped.AuthJWTToken[projectUrl] = token;
     const isEmulated = projectUrl in CacheStore.EmulatedAuth;
     if (isEmulated) delete CacheStore.EmulatedAuth[projectUrl];
+    await updateTokenTimestamp(projectUrl, token);
 
     updateCacheStore(['AuthStore', isEmulated ? 'EmulatedAuth' : ''].filter(v => v));
 
     triggerAuthToken(projectUrl);
-    initTokenRefresher(config);
+    initTokenRefresher({ config });
 };
 
 export const injectEmulatedAuth = async (config, emulatedURL) => {
@@ -49,7 +50,7 @@ export const injectEmulatedAuth = async (config, emulatedURL) => {
 
     updateCacheStore(['AuthStore', 'EmulatedAuth']);
     triggerAuthToken(projectUrl);
-    initTokenRefresher(config);
+    initTokenRefresher({ config });
 };
 
 export const parseToken = (token) => JSON.parse(decodeBinary(token.split('.')[1]));
@@ -59,28 +60,35 @@ export const triggerAuthToken = async (projectUrl, isInit) => {
     AuthTokenListener.dispatchPersist(projectUrl, CacheStore.AuthStore[projectUrl]?.token || null, isInit);
 };
 
-export const awaitRefreshToken = (projectUrl) => new Promise(resolve => {
-    const l = TokenRefreshListener.listenToPersist(projectUrl, v => {
-        if (v === 'ready') {
-            l();
-            resolve();
+export const awaitRefreshToken = (projectUrl) =>
+    new Promise(async resolve => {
+        try {
+            if (await initTokenRefresher({ justCheck: true, config: Scoped.InitializedProject[projectUrl] })) {
+                resolve();
+            } else throw null;
+        } catch (_) {
+            const l = TokenRefreshListener.listenToPersist(projectUrl, v => {
+                if (v) {
+                    l();
+                    resolve();
+                }
+            });
         }
     });
-});
 
 export const listenTokenReady = (callback, projectUrl) => TokenRefreshListener.listenToPersist(projectUrl, callback);
 
-export const initTokenRefresher = async (config, forceRefresh) => {
+export const initTokenRefresher = async ({ config, forceRefresh, justCheck }) => {
     const { projectUrl, maxRetries } = config;
     if (!Scoped.IsStoreReady) await awaitStore();
     const { token } = CacheStore.AuthStore[projectUrl] || {};
     const emulatedURL = CacheStore.EmulatedAuth[projectUrl];
-    const tokenInfo = token && parseToken(token);
 
-    clearInterval(Scoped.TokenRefreshTimer[projectUrl]);
+    if (!justCheck) clearInterval(Scoped.TokenRefreshTimer[projectUrl]);
     if (emulatedURL) return;
 
     const notifyAuthReady = (value) => {
+        if (justCheck) return;
         TokenRefreshListener.dispatchPersist(projectUrl, value);
         getEmulatedLinks(projectUrl).forEach(v => {
             TokenRefreshListener.dispatchPersist(v, value);
@@ -88,104 +96,120 @@ export const initTokenRefresher = async (config, forceRefresh) => {
     }
 
     if (token) {
-        const expireOn = (tokenInfo.exp * 1000) - 60000;
-        const hasExpire = getPrefferTime() >= expireOn;
-        const rizz = () => refreshToken(config, ++Scoped.LastTokenRefreshRef[projectUrl], maxRetries, forceRefresh);
+        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];
+            });
+        }
 
-        if (hasExpire || forceRefresh) {
+        if (await hasTokenExpire(projectUrl) || forceRefresh) {
             notifyAuthReady();
             return rizz();
         } else {
-            notifyAuthReady('ready');
-            Scoped.TokenRefreshTimer[projectUrl] = setInterval(() => {
-                const countdown = expireOn - getPrefferTime();
-                if (countdown > 3000) return;
+            notifyAuthReady(true);
+            if (justCheck) {
+                return true;
+            } else {
+                let lastIte = 0;
                 clearInterval(Scoped.TokenRefreshTimer[projectUrl]);
-                notifyAuthReady();
-                rizz();
-            }, 3000);
+                Scoped.TokenRefreshTimer[projectUrl] = setInterval(async () => {
+                    const iteRef = ++lastIte;
+                    if (iteRef !== lastIte || !(await hasTokenExpire(projectUrl))) return;
+                    clearInterval(Scoped.TokenRefreshTimer[projectUrl]);
+                    notifyAuthReady();
+                    rizz();
+                }, 7000);
+            }
         }
     } else {
-        notifyAuthReady('ready');
-        if (forceRefresh) {
-            return simplifyError('no_token_yet', 'No token is available to initiate a refresh').simpleError;
-        }
+        notifyAuthReady(true);
+        if (justCheck) return true;
     }
 };
 
-export const getEmulatedLinks = (projectUrl) => Object.entries(CacheStore.EmulatedAuth)
-    .filter(([_, v]) => v === projectUrl)
-    .map(v => v[0]);
+const hasTokenExpire = async (projectUrl) => {
+    const timestamp = Scoped.TokenTimestamping[projectUrl];
+    if (!timestamp) return true;
+    const uptime = await NativeMosquitoTransport.getSystemUptime();
 
-const refreshToken = (builder, processRef, remainRetries = 1, isForceRefresh) => new Promise(async (resolve, reject) => {
-    const { projectUrl, serverE2E_PublicKey, uglify, extraHeaders } = builder;
-    const lostProcess = simplifyError('process_lost', 'The token refresh process has been lost and replaced with another one');
+    return timestamp.ttl <= (uptime - timestamp.uptime);
+}
 
-    try {
-        const { token, refreshToken: r_token } = CacheStore.AuthStore[projectUrl];
+const updateTokenTimestamp = async (projectUrl, token) => {
+    const { exp, iat } = parseToken(token);
+    Scoped.TokenTimestamping[projectUrl] = {
+        ttl: ((exp * 1000) - (iat * 1000)) - 60_000,
+        uptime: await NativeMosquitoTransport.getSystemUptime()
+    };
+}
 
-        const [reqBuilder, [privateKey]] = await buildFetchInterface({
-            body: { token, r_token },
-            uglify,
-            serverE2E_PublicKey,
-            extraHeaders
-        });
+export const getEmulatedLinks = (projectUrl) => Object.entries(CacheStore.EmulatedAuth)
+    .filter(([_, v]) => v === projectUrl)
+    .map(v => v[0]);
 
-        let data;
+const refreshToken = (builder, remainRetries = 1, isForceRefresh) =>
+    new Promise(async (resolve, reject) => {
+        const { projectUrl, serverE2E_PublicKey, uglify, extraHeaders } = builder;
+        const lostProcess = simplifyError('process_lost', 'The token refresh process has been lost and replaced with another one');
 
         try {
-            data = await buildFetchResult(await fetch(EngineApi._refreshAuthToken(projectUrl, uglify), reqBuilder), uglify);
-        } finally {
-            if (processRef !== Scoped.LastTokenRefreshRef[projectUrl]) {
-                reject(lostProcess.simpleError);
-                return;
-            }
-        }
-
-        const f = uglify ? await deserializeE2E(data, serverE2E_PublicKey, privateKey) : data;
-
-        if (CacheStore.AuthStore[projectUrl]) {
-            CacheStore.AuthStore[projectUrl].token = f.result.token;
-            Scoped.AuthJWTToken[projectUrl] = f.result.token;
-
-            resolve(f.result.token);
-            const isInit = !Scoped.InitiatedForcedToken[projectUrl] && isForceRefresh;
-
-            triggerAuthToken(projectUrl, isInit);
-            if (isForceRefresh) Scoped.InitiatedForcedToken[projectUrl] = true;
+            const { token, refreshToken: r_token } = CacheStore.AuthStore[projectUrl];
 
-            getEmulatedLinks(projectUrl).forEach(v => {
-                CacheStore.AuthStore[v] = basicClone(CacheStore.AuthStore[projectUrl]);
-                Scoped.AuthJWTToken[v] = f.result.token;
-
-                triggerAuthToken(v, isInit);
-                if (isForceRefresh) Scoped.InitiatedForcedToken[v] = true;
+            const [reqBuilder, [privateKey]] = await buildFetchInterface({
+                body: { token, r_token },
+                uglify,
+                serverE2E_PublicKey,
+                extraHeaders
             });
-            updateCacheStore(['AuthStore']);
-            initTokenRefresher(builder);
-        } else reject(lostProcess.simpleError);
-    } catch (e) {
-        if (e.simpleError) {
-            console.error(`refreshToken error: ${e.simpleError?.message}`);
-            doSignOut({ ...builder });
-            reject(e.simpleError);
-        } else if (remainRetries <= 0) {
-            reject(
-                processRef === Scoped.LastTokenRefreshRef[projectUrl] ?
-                    lostProcess.simpleError :
+
+            const data = await buildFetchResult(await fetch(EngineApi._refreshAuthToken(projectUrl, uglify), reqBuilder), uglify);
+
+            const f = uglify ? await deserializeE2E(data, serverE2E_PublicKey, privateKey) : data;
+
+            if (CacheStore.AuthStore[projectUrl]) {
+                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;
+
+                triggerAuthToken(projectUrl, isInit);
+                if (isForceRefresh) Scoped.InitiatedForcedToken[projectUrl] = true;
+
+                getEmulatedLinks(projectUrl).forEach(v => {
+                    CacheStore.AuthStore[v] = basicClone(CacheStore.AuthStore[projectUrl]);
+                    Scoped.AuthJWTToken[v] = f.result.token;
+
+                    triggerAuthToken(v, isInit);
+                    if (isForceRefresh) Scoped.InitiatedForcedToken[v] = true;
+                });
+                updateCacheStore(['AuthStore']);
+                initTokenRefresher({ config: builder });
+            } else reject(lostProcess.simpleError);
+        } catch (e) {
+            if (e.simpleError) {
+                console.error(`refreshToken error: ${e.simpleError?.message}`);
+                doSignOut({ ...builder });
+                reject(e.simpleError);
+            } else if (remainRetries <= 0) {
+                reject(
                     simplifyError('retry_limit_reached', 'The retry limit has been reach and execution prematurely stopped').simpleError
-            );
-            console.error(`refreshToken retry limit exceeded`);
-        } else {
-            const l = listenReachableServer(c => {
-                if (processRef !== Scoped.LastTokenRefreshRef[projectUrl]) {
-                    reject(lostProcess.simpleError);
-                    l();
-                } else if (c) {
-                    l();
-                    refreshToken(builder, processRef, remainRetries - 1, isForceRefresh).then(resolve, reject);
-                }
-            }, projectUrl);
+                );
+                console.error(`refreshToken retry limit exceeded`);
+            } else {
+                const l = listenReachableServer(c => {
+                    if (c) {
+                        l();
+                        refreshToken(builder, remainRetries - 1, isForceRefresh).then(resolve, reject);
+                    }
+                }, projectUrl);
+            }
         }
-    }
-});
+    });