mosquito-transport-js 0.6.2 → 0.6.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mosquito-transport-js",
-  "version": "0.6.2",
+  "version": "0.6.4",
   "description": "Javascript web sdk for mosquito-transport (https://github.com/brainbehindx/mosquito-transport)",
   "main": "src/index.js",
   "type": "module",

package/src/helpers/utils.js

@@ -179,18 +179,16 @@ export const awaitStore = () => new Promise(resolve => {
 
 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 })
+        Scoped.IS_CONNECTED[projectUrl] = undefined;
+        ServerReachableListener.dispatchPersist(projectUrl, undefined);
+
+        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);
 
-                clearTimeout(timer);
                 delete Scoped.AreYouOkPromise[projectUrl];
                 return connected;
             });
@@ -209,25 +207,31 @@ export const listenReachableServer = (callback, projectUrl) => {
     });
 };
 
-export const awaitReachableServer = (projectUrl) =>
-    new Promise(async resolve => {
-        if (!isScreenFocused()) {
-            if (await checkAreYouOk(projectUrl)) {
+export const awaitReachableServer = (projectUrl, pauseForRetry) =>
+    new Promise(resolve => {
+        const check = async () => {
+            if (!isScreenFocused()) {
+                if (await checkAreYouOk(projectUrl)) {
+                    resolve();
+                    return;
+                }
+            }
+
+            if (Scoped.IS_CONNECTED[projectUrl]) {
                 resolve();
                 return;
             }
-        }
 
-        if (Scoped.IS_CONNECTED[projectUrl]) {
-            resolve();
-            return;
+            const l = listenReachableServer(t => {
+                if (!t) return;
+                resolve();
+                l();
+            }, projectUrl);
         }
 
-        const l = listenReachableServer(t => {
-            if (!t) return;
-            resolve();
-            l();
-        }, projectUrl);
+        if (pauseForRetry) {
+            setTimeout(check, Number.isInteger(pauseForRetry) ? pauseForRetry : 300);
+        } else check();
     });
 
 export const getReachableServer = (projectUrl) =>

package/src/index.d.ts

@@ -302,6 +302,14 @@ export interface FetchHttpConfig {
     disableAuth?: boolean;
     enableMinimizer?: boolean;
     rawApproach?: boolean;
+    /**
+     * Wait for the server to come online if the response does not include a header with status 200.
+     * 
+     * This ensures that the fetchHttp method only resolves when a response with status 200 is received; otherwise, it rejects if the server is online but continues returning a non-200 status
+     * 
+     * @default false
+     */
+    enforce200?: boolean;
 }
 
 type Delievery = 'default' | 'cache-no-await' | 'no-cache-no-await' | 'no-cache-await';

package/src/index.js

@@ -73,7 +73,6 @@ export class MosquitoTransport {
             });
 
             let connectionIte = 0;
-            let chainedPromise;
             const setConnected = c => {
                 isConnected = c;
                 Scoped.IS_CONNECTED[projectUrl] = isConnected;
@@ -90,11 +89,9 @@ export class MosquitoTransport {
             };
 
             const manualCheckConnection = () => {
-                if (chainedPromise) return;
                 const ref = ++connectionIte;
 
                 checkAreYouOk(projectUrl).then(ok => {
-                    chainedPromise = undefined;
                     if (ref !== connectionIte) return;
                     if (ok) {
                         onConnect();
@@ -363,9 +360,7 @@ export class MosquitoTransport {
                 }
 
                 if (isScreenFocused()) {
-                    setTimeout(() => {
-                        awaitReachableServer(projectUrl).then(reloadIntance);
-                    }, timeout);
+                    awaitReachableServer(projectUrl, timeout).then(reloadIntance);
                 } else {
                     foregroundListener = listenScreenVisible(visible => {
                         if (visible) {
@@ -396,7 +391,7 @@ export class MosquitoTransport {
                 clearSocket();
                 if (r === 'io client disconnect' || r === 'io server disconnect') {
                     resultant.destroy();
-                } else reconnect(0);
+                } else reconnect(true);
             });
 
             clientPrivateKey = privateKey;

package/src/products/auth/accessor.js

@@ -2,7 +2,7 @@ import { doSignOut, revokeAuthIntance } from "./index.js";
 import EngineApi from "../../helpers/engine_api";
 import { AuthTokenListener, TokenRefreshListener } from "../../helpers/listeners";
 import { decodeBinary, deserializeE2E } from "../../helpers/peripherals";
-import { awaitReachableServer, awaitStore, buildFetchInterface, buildFetchResult, updateCacheStore } from "../../helpers/utils";
+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";
@@ -75,6 +75,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 }) => {
@@ -217,7 +230,7 @@ const refreshToken = (builder, remainRetries = 1, isForceRefresh) =>
                 );
                 console.error(`refreshToken retry limit exceeded err:`, e);
             } else {
-                awaitReachableServer(projectUrl).then(() => {
+                awaitReachableServer(projectUrl, true).then(() => {
                     refreshToken(builder, remainRetries - 1, isForceRefresh).then(resolve, reject);
                 });
             }

package/src/products/auth/index.js

@@ -54,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, []];
 
@@ -251,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);

package/src/products/database/index.js

@@ -6,7 +6,7 @@ import { awaitReachableServer, awaitStore, buildFetchInterface, buildFetchResult
 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 "bson";
 import { guardObject, Validator } from "guard-object";
@@ -261,9 +261,7 @@ const listenDocument = (callback, onError, builder, config) => {
             }
 
             if (isScreenFocused()) {
-                setTimeout(() => {
-                    awaitReachableServer(projectUrl).then(reloadIntance);
-                }, timeout);
+                awaitReachableServer(projectUrl, timeout).then(reloadIntance);
             } else {
                 foregroundListener = listenScreenVisible(visible => {
                     if (visible) {
@@ -288,7 +286,7 @@ const listenDocument = (callback, onError, builder, config) => {
             clearSocket();
             if (r === 'io client disconnect' || r === 'io server disconnect') {
                 canceller();
-            } else reconnect(0);
+            } else reconnect(true);
         });
     };
 
@@ -419,9 +417,7 @@ const initOnDisconnectionTask = ({ builder, connectData, disconnectData }) => {
             }
 
             if (isScreenFocused()) {
-                setTimeout(() => {
-                    awaitReachableServer(projectUrl).then(reloadIntance);
-                }, timeout);
+                awaitReachableServer(projectUrl, timeout).then(reloadIntance);
             } else {
                 foregroundListener = listenScreenVisible(visible => {
                     if (visible) {
@@ -446,7 +442,7 @@ const initOnDisconnectionTask = ({ builder, connectData, disconnectData }) => {
             clearSocket();
             if (r === 'io client disconnect' || r === 'io server disconnect') {
                 canceller();
-            } else reconnect(0);
+            } else reconnect(true);
         });
     };
 
@@ -525,8 +521,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: {
@@ -558,7 +553,7 @@ const countCollection = async (builder, config) => {
             } else if (retries > maxRetries) {
                 finalize(undefined, { error: 'retry_limit_exceeded', message: `retry exceed limit(${maxRetries})` });
             } else {
-                awaitReachableServer(projectUrl).then(() => {
+                awaitReachableServer(projectUrl, true).then(() => {
                     readValue().then(
                         e => { finalize(e); },
                         e => { finalize(undefined, e); }
@@ -675,8 +670,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: {
@@ -733,7 +727,7 @@ const findObject = async (builder, initConfig) => {
             } else if (retries > maxRetries) {
                 finalize(undefined, { error: 'retry_limit_exceeded', message: `retry exceed limit(${maxRetries})` });
             } else {
-                awaitReachableServer(projectUrl).then(() => {
+                awaitReachableServer(projectUrl, true).then(() => {
                     if (intruder) {
                         intruder.resolve = undefined;
                         intruder.reject = undefined;
@@ -838,8 +832,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: {
@@ -880,7 +873,7 @@ const commitData = async (builder, value, type, config) => {
                 );
             } else {
                 if (delivery === DELIVERY.NO_CACHE_AWAIT) {
-                    awaitReachableServer(projectUrl).then(() => {
+                    awaitReachableServer(projectUrl, true).then(() => {
                         sendValue().then(
                             e => { finalize(e.a, undefined, e.c); },
                             e => { finalize(undefined, e.b, e.c); }

package/src/products/http_callable/index.js

@@ -1,9 +1,9 @@
 import { Buffer } from "buffer";
 import { deserializeE2E, niceHash, normalizeRoute, serializeE2E } from "../../helpers/peripherals";
-import { awaitReachableServer, awaitStore, getReachableServer } from "../../helpers/utils";
+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";
@@ -42,10 +42,11 @@ export const mfetch = async (input = '', init, config) => {
             enableMinimizer: t => t === undefined || Validator.BOOLEAN(t),
             rawApproach: t => t === undefined || Validator.BOOLEAN(t),
             disableAuth: t => t === undefined || Validator.BOOLEAN(t),
-            retrieval: t => t === undefined || Object.values(RETRIEVAL).includes(t)
+            retrieval: t => t === undefined || Object.values(RETRIEVAL).includes(t),
+            enforce200: t => t === undefined || Validator.BOOLEAN(t)
         }).validate(method);
 
-    const { retrieval = RETRIEVAL.DEFAULT, enableMinimizer, rawApproach } = method || {};
+    const { retrieval = RETRIEVAL.DEFAULT, enableMinimizer, rawApproach, enforce200 } = method || {};
     const isLink = Validator.LINK(input);
     const isBaseUrl = isLink || rawApproach;
     const disableAuth = method?.disableAuth === undefined ? isBaseUrl : method?.disableAuth;
@@ -138,8 +139,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'];
@@ -168,6 +168,8 @@ export const mfetch = async (input = '', init, config) => {
             const { ok, type, status, statusText, redirected, url, headers, size } = f;
             const simple = headers.get('simple_error');
 
+            if (enforce200 && status !== 200)
+                throw `expected response status to be 200 but got ${status}`;
             if (!isLink && simple) throw { simpleError: JSON.parse(simple) };
 
             const buffer = uglified ?
@@ -220,7 +222,7 @@ export const mfetch = async (input = '', init, config) => {
             } else if (retries > maxRetries) {
                 finalize(undefined, simplifyCaughtError(e).simpleError);
             } else {
-                awaitReachableServer(projectUrl).then(() => {
+                awaitReachableServer(projectUrl, true).then(() => {
                     callFetch().then(
                         e => finalize(e),
                         e => finalize(undefined, e)