react-native-mosquito-transport 0.0.47 → 0.0.49

package/src/products/auth/accessor.js

@@ -1,12 +1,13 @@
-import { doSignOut, revokeAuthIntance } from ".";
+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);
+            }
         }
-    }
-});
+    });

package/src/products/auth/index.js

@@ -59,10 +59,11 @@ export default class MTAuth {
                 onError?.(simplifyError('user_login_required', 'You must be signed-in to use this method').simpleError);
                 return;
             }
-            if (processID !== lastInitRef) return;
+            if (processID !== lastInitRef || hasCancelled) return;
             const mtoken = Scoped.AuthJWTToken[projectUrl],
                 [reqBuilder, [privateKey]] = uglify ? await serializeE2E({ mtoken }, undefined, serverE2E_PublicKey) : [null, []];
 
+            if (processID !== lastInitRef || hasCancelled) return;
             socket = io(`${wsPrefix}://${baseUrl}`, {
                 transports: ['websocket', 'polling', 'flashsocket'],
                 auth: {
@@ -159,7 +160,7 @@ export default class MTAuth {
 
     signOut = () => doSignOut(this.builder);
 
-    forceRefreshToken = () => initTokenRefresher(this.builder, true);
+    forceRefreshToken = () => initTokenRefresher({ config: this.builder, forceRefresh: true });
 
     emulate = async (projectUrl) => {
         await injectEmulatedAuth(this.builder, projectUrl);
@@ -189,8 +190,8 @@ const doCustomSignin = (builder, email, password) => new Promise(async (resolve,
             token: r.result.token,
             refreshToken: r.result.refreshToken
         });
-        await injectFreshToken(builder, r.result);
         revokeAuthIntance(builder, thisAuthStore);
+        await injectFreshToken(builder, r.result);
     } catch (e) {
         reject(simplifyCaughtError(e).simpleError);
     }
@@ -223,8 +224,8 @@ const doCustomSignup = (builder, email, password, name, metadata) => new Promise
             refreshToken: r.result.refreshToken,
             isNewUser: !!r.result.isNewUser
         });
-        await injectFreshToken(builder, r.result);
         revokeAuthIntance(builder, thisAuthStore);
+        await injectFreshToken(builder, r.result);
     } catch (e) {
         reject(simplifyCaughtError(e).simpleError);
     }
@@ -248,17 +249,19 @@ const clearCacheForSignout = (builder, disposeEmulated) => {
 
     purgeCache(projectUrl, true);
     if (disposeEmulated) getEmulatedLinks(projectUrl).forEach(e => purgeCache(e));
-    initTokenRefresher(builder);
+    initTokenRefresher({ config: builder });
 };
 
 export const doSignOut = async (builder) => {
     if (!Scoped.IsStoreReady) await awaitStore();
     const emulatedURL = CacheStore.EmulatedAuth[builder.projectUrl];
+    const thisAuthStore = emulatedURL ? undefined : basicClone(CacheStore.AuthStore[builder.projectUrl]);
 
     clearCacheForSignout(builder, !emulatedURL);
     updateCacheStore(['AuthStore', 'EmulatedAuth']);
     if (emulatedURL) return;
-    await revokeAuthIntance(builder);
+
+    await revokeAuthIntance(builder, thisAuthStore);
 };
 
 export const revokeAuthIntance = async (builder, authStore) => {
@@ -288,8 +291,7 @@ export const purgePendingToken = async (nodeId) => {
             isConnected = (await (await fetch(_areYouOk(projectUrl), { credentials: 'omit' })).json()).status === 'yes';
         } catch (_) { }
 
-        if (!isConnected)
-            await awaitReachableServer(projectUrl);
+        if (!isConnected) await awaitReachableServer(projectUrl);
 
         const [reqBuilder] = await buildFetchInterface({
             body: { token, r_token },
@@ -334,8 +336,8 @@ const doProviderSignin = (builder, token, metadata, endpointer) => new Promise(a
             refreshToken: f.result.refreshToken,
             isNewUser: f.result.isNewUser
         });
-        await injectFreshToken(builder, f.result);
         revokeAuthIntance(builder, thisAuthStore);
+        await injectFreshToken(builder, f.result);
     } catch (e) {
         reject(simplifyCaughtError(e).simpleError);
     }

package/src/products/database/index.js

@@ -206,6 +206,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,

package/src/products/http_callable/index.js

@@ -3,7 +3,7 @@ import { deserializeE2E, listenReachableServer, niceHash, normalizeRoute, serial
 import { awaitStore, getReachableServer } from "../../helpers/utils";
 import { RETRIEVAL } from "../../helpers/values";
 import { Scoped } from "../../helpers/variables";
-import { awaitRefreshToken } from "../auth/accessor";
+import { awaitRefreshToken, parseToken } from "../auth/accessor";
 import { simplifyCaughtError } from "simplify-error";
 import { guardObject, Validator } from "guard-object";
 import { serialize } from "entity-serializer";
@@ -71,17 +71,18 @@ export const mfetch = async (input = '', init, config) => {
         ) throw `"body" must be any of string, buffer, object`;
     }
     await awaitStore();
+    const thisToken = disableAuth ? '' : (Scoped.AuthJWTToken[projectUrl] || '');
 
     const reqId = await niceHash(
         serialize([
             rawHeader,
             body,
-            !!disableAuth,
+            // !!disableAuth,
             input,
-            disableAuth ? '' : (Scoped.AuthJWTToken[projectUrl] || '')
+            thisToken && await parseToken(thisToken).uid
         ]).toString('base64')
     );
-    const processReqId = `${reqId}_${disableCache}_${retrieval}`;
+    const processReqId = `${reqId}_${thisToken}_${disableCache}_${retrieval}`;
 
     let retries = 0, hasFinalize;
 
@@ -143,7 +144,7 @@ export const mfetch = async (input = '', init, config) => {
             const [reqBuilder, [privateKey]] = uglified ? await serializeE2E(body, mtoken, serverE2E_PublicKey) : [null, []];
 
             const f = await fetch(isLink ? input : `${projectUrl}/${normalizeRoute(input)}`, {
-                ...(encodeBody || uglified) ? { method: 'POST' } : {},
+                ...(hasBody || uglified) ? { method: 'POST' } : {},
                 credentials: 'omit',
                 ...init,
                 ...uglified ? { body: reqBuilder } : encodeBody ? { body: serialize(body) } : {},

package/src/products/storage/index.js

@@ -1,52 +1,57 @@
 import EngineApi from "../../helpers/engine_api";
 import { deserializeE2E, prefixStoragePath } from "../../helpers/peripherals";
 import { Scoped } from "../../helpers/variables";
-import { DeviceEventEmitter, NativeEventEmitter, NativeModules, Platform } from 'react-native';
+import { NativeEventEmitter } from 'react-native';
+import NativeMosquitoTransport from '../../NativeMosquitoTransport';
 import { awaitReachableServer, buildFetchInterface, buildFetchResult } from "../../helpers/utils";
 import { awaitRefreshToken } from "../auth/accessor";
 import { simplifyError } from "simplify-error";
+import { Validator } from "guard-object";
 
-const LINKING_ERROR =
-    `The package 'react-native-mosquito-transport' doesn't seem to be linked. Make sure: \n\n` +
-    Platform.select({ ios: "- You have run 'pod install'\n", default: '' }) +
-    '- You rebuilt the app after installing the package\n' +
-    '- You are not using Expo Go\n';
-
-const RNMTModule = NativeModules.Mosquitodb || (
-    new Proxy({}, {
-        get() {
-            throw new Error(LINKING_ERROR);
-        },
-    })
-);
-const emitter = Platform.OS === 'android' ?
-    DeviceEventEmitter : new NativeEventEmitter(RNMTModule);
+const emitter = new NativeEventEmitter(NativeMosquitoTransport);
 
 export class MTStorage {
     constructor(config) {
         this.builder = { ...config };
     }
 
-    downloadFile(link = '', onComplete, destination, onProgress, options) {
-        const { awaitServer } = options || {};
+    downloadFile = (link = '', destination, options) => {
+        const { awaitServer, onProgress } = options || {};
         let hasFinished, isPaused, hasCancelled;
 
         const { projectUrl, extraHeaders } = this.builder;
+        let onComplete;
+
+        const promise = new Promise((resolve, reject) => {
+            onComplete = (err, path) => {
+                if (hasFinished) return;
+                hasFinished = true;
+                if (path) {
+                    resolve(path);
+                } else reject(err);
+            }
+        });
+
+        promise.abort = () => {
+            if (hasFinished || hasCancelled) return;
+            NativeMosquitoTransport.cancelDownload(processID);
+            hasCancelled = true;
+            onComplete?.({ error: 'download_aborted', message: 'The download process was aborted' });
+        }
 
         if (destination && (typeof destination !== 'string' || !destination.trim())) {
             onComplete?.({ error: 'destination_invalid', message: 'destination must be a non-empty string' });
-            return () => { };
+            return promise;
         }
         if (destination) destination = prefixStoragePath(destination?.trim());
 
-        if (typeof link !== 'string' || !link.trim().startsWith(`${EngineApi.staticStorage(projectUrl)}/`)) {
+        if (typeof link !== 'string' || !Validator.LINK(link = link.trim())) {
             onComplete?.({
                 error: 'invalid_link',
-                message: `link has an invalid value, expected a string that starts with "${EngineApi.staticStorage(projectUrl)}/"`
+                message: `downloadFile first argument has an invalid value, expected a valid link string but got '${link}' instead`
             });
-            return () => { };
+            return promise;
         }
-        link = link.trim();
 
         const processID = `${++Scoped.StorageProcessID}`;
         const init = async () => {
@@ -63,12 +68,12 @@ export class MTStorage {
                     isPaused: !!isPaused,
                     pause: () => {
                         if (hasFinished || isPaused || hasCancelled) return;
-                        RNMTModule.pauseDownload(processID);
+                        NativeMosquitoTransport.pauseDownload(processID);
                         isPaused = true;
                     },
                     resume: () => {
                         if (hasFinished || !isPaused || hasCancelled) return;
-                        RNMTModule.resumeDownload(processID);
+                        NativeMosquitoTransport.resumeDownload(processID);
                         isPaused = false;
                     }
                 });
@@ -86,10 +91,9 @@ export class MTStorage {
                     onComplete?.(path ? undefined : (result?.simpleError || { error, message: errorDes }), path);
                 resultListener.remove();
                 progressListener.remove();
-                hasFinished = true;
             });
 
-            RNMTModule.downloadFile({
+            NativeMosquitoTransport.downloadFile({
                 url: link,
                 authToken: Scoped.AuthJWTToken[projectUrl],
                 ...destination ? {
@@ -103,30 +107,36 @@ export class MTStorage {
         }
 
         init();
-
-        return () => {
-            if (hasFinished || hasCancelled) return;
-            RNMTModule.cancelDownload(processID);
-            hasCancelled = true;
-            setTimeout(() => {
-                onComplete?.({ error: 'download_aborted', message: 'The download process was aborted' });
-            }, 1);
-        }
+        return promise;
     }
 
-    uploadFile(file = '', destination = '', onComplete, onProgress, options) {
-        const { createHash, awaitServer } = options || {};
+    uploadFile = (file = '', destination = '', options) => {
+        const { createHash, awaitServer, onProgress } = options || {};
         let hasFinished, hasCancelled;
+        let thisComplete;
 
-        const thisComplete = (...args) => {
-            if (hasFinished) return;
-            hasFinished = true;
-            onComplete?.(...args);
-        }
+        const promise = new Promise((resolve, reject) => {
+            thisComplete = (err, url) => {
+                if (hasFinished) return;
+                hasFinished = true;
+                if (url) {
+                    resolve(url);
+                } else reject(err);
+            }
+        });
+
+        promise.abort = () => {
+            if (hasFinished || hasCancelled) return;
+            hasCancelled = true;
+            setTimeout(() => {
+                thisComplete?.({ error: 'upload_aborted', message: 'The upload process was aborted' });
+            }, 0);
+            NativeMosquitoTransport.cancelUpload(processID);
+        };
 
         if (typeof file !== 'string' || !file.trim()) {
             thisComplete?.({ error: 'file_path_invalid', message: 'file must be a non-empty string in uploadFile()' });
-            return () => { };
+            return promise;
         }
         destination = destination?.trim?.();
 
@@ -134,7 +144,7 @@ export class MTStorage {
             validateDestination(destination);
         } catch (error) {
             thisComplete?.({ error: 'destination_invalid', message: error });
-            return () => { };
+            return promise;
         }
 
         const isAsset = file.startsWith('ph://') || file.startsWith('content://');
@@ -142,6 +152,7 @@ export class MTStorage {
 
         const { projectUrl, uglify, extraHeaders } = this.builder;
         const processID = `${++Scoped.StorageProcessID}`;
+        const thisProjectUrl = options?.projectUrl || projectUrl;
 
         const init = async () => {
             if (awaitServer) await awaitReachableServer(projectUrl);
@@ -166,8 +177,8 @@ export class MTStorage {
             });
             const authToken = Scoped.AuthJWTToken[projectUrl];
 
-            RNMTModule.uploadFile({
-                url: EngineApi._uploadFile(projectUrl, uglify),
+            NativeMosquitoTransport.uploadFile({
+                url: EngineApi._uploadFile(thisProjectUrl, uglify),
                 file: isAsset ? file : file.substring('file://'.length),
                 ...authToken ? { authToken } : {},
                 createHash: createHash ? 'yes' : 'no',
@@ -178,24 +189,16 @@ export class MTStorage {
         }
 
         init();
-
-        return () => {
-            if (hasFinished || hasCancelled) return;
-            hasCancelled = true;
-            setTimeout(() => {
-                thisComplete?.({ error: 'upload_aborted', message: 'The upload process was aborted' });
-            }, 0);
-            RNMTModule.cancelUpload(processID);
-        }
+        return promise;
     }
 
-    deleteFile = (path) => deleteContent(this.builder, path);
-    deleteFolder = (path) => deleteContent(this.builder, path, true);
+    deleteFile = (path, options) => deleteContent(this.builder, path, options);
+    deleteFolder = (path, options) => deleteContent(this.builder, path, options, true);
 }
 
 const { _deleteFile, _deleteFolder } = EngineApi;
 
-const deleteContent = async (builder, path, isFolder) => {
+const deleteContent = async (builder, path, options, isFolder) => {
     const { projectUrl, uglify, extraHeaders, serverE2E_PublicKey } = builder;
 
     try {
@@ -207,8 +210,10 @@ const deleteContent = async (builder, path, isFolder) => {
             serverE2E_PublicKey,
             uglify
         });
+        const thisProjectUrl = options?.projectUrl || projectUrl;
 
-        const data = await buildFetchResult(await fetch((isFolder ? _deleteFolder : _deleteFile)(projectUrl, uglify), reqBuilder), uglify);
+        const res = await fetch((isFolder ? _deleteFolder : _deleteFile)(thisProjectUrl, uglify), reqBuilder);
+        const data = await buildFetchResult(res, uglify);
         const result = uglify ? await deserializeE2E(data, serverE2E_PublicKey, privateKey) : data;
 
         if (result.status !== 'success') throw 'operation not successful';

package/.jshintignore

@@ -1,4 +0,0 @@
-node_modules/
-android/
-example/
-ios/