mosquito-transport-js 0.3.5 → 0.3.7

package/.jshintrc

@@ -10,6 +10,7 @@
         "clearInterval": true,
         "setInterval": true,
         "AbortController": true,
-        "URLSearchParams": true
+        "URLSearchParams": true,
+        "URL": true
     }
 }

package/README.md

@@ -1 +1 @@
-# mosquito-transport-js
+# mosquito-transport-js

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mosquito-transport-js",
-  "version": "0.3.5",
-  "description": "Javascript web sdk for mosquito-transport (https://github.com/deflexable/mosquito-transport)",
+  "version": "0.3.7",
+  "description": "Javascript web sdk for mosquito-transport (https://github.com/brainbehindx/mosquito-transport)",
   "main": "src/index.js",
   "type": "module",
   "scripts": {

package/src/helpers/utils.js

@@ -17,11 +17,13 @@ export const updateCacheStore = (timer = 300) => {
 
     clearTimeout(Scoped.cacheStorageReducer);
     Scoped.cacheStorageReducer = setTimeout(() => {
-        const { AuthStore, DatabaseStore, PendingWrites, ...restStore } = CacheStore;
+        const { AuthStore, EmulatedAuth, PendingAuthPurge, DatabaseStore, PendingWrites, ...restStore } = CacheStore;
 
         const txt = encryptString(
             JSON.stringify({
                 AuthStore,
+                EmulatedAuth,
+                PendingAuthPurge,
                 ...promoteCache ? {
                     DatabaseStore: serializeToBase64(DatabaseStore),
                     PendingWrites: serializeToBase64(PendingWrites)

package/src/helpers/values.js

@@ -27,10 +27,10 @@ export const DELIVERY = {
 };
 
 export const AUTH_PROVIDER_ID = {
-    GOOGLE: 'google.com',
-    FACEBOOK: 'facebook.com',
+    GOOGLE: 'google',
+    FACEBOOK: 'facebook',
     PASSWORD: 'password',
-    TWITTER: 'x.com',
-    GITHUB: 'github.com',
-    APPLE: 'apple.com'
+    TWITTER: 'x',
+    GITHUB: 'github',
+    APPLE: 'apple'
 };

package/src/helpers/variables.js

@@ -36,6 +36,8 @@ export const CacheStore = {
     DatabaseCountResult: {},
     DatabaseStats: {},
     AuthStore: {},
+    PendingAuthPurge: {},
+    EmulatedAuth: {},
     PendingWrites: {},
     FetchedStore: {}
 };

package/src/index.d.ts

@@ -68,12 +68,12 @@ export class DoNotEncrypt {
 }
 
 interface auth_provider_id {
-    GOOGLE: 'google.com';
-    FACEBOOK: 'facebook.com';
+    GOOGLE: 'google';
+    FACEBOOK: 'facebook';
     PASSWORD: 'password';
-    TWITTER: 'x.com';
-    GITHUB: 'github.com';
-    APPLE: 'apple.com';
+    TWITTER: 'x';
+    GITHUB: 'github';
+    APPLE: 'apple';
 }
 
 type auth_provider_id_values = auth_provider_id['GOOGLE'] |
@@ -147,7 +147,7 @@ interface BatchWriteConfig extends WriteConfig {
 
 export class MosquitoTransport {
     constructor(config: MTConfig);
-    static releaseCache(option?: ReleaseCacheOption | ReleaseCacheOption_IO): void;
+    static initializeCache(option?: ReleaseCacheOption | ReleaseCacheOption_IO): void;
     getDatabase(dbName?: string, dbUrl?: string): GetDatabase;
     collection(path: string): MTCollection;
     auth(): MTAuth;
@@ -398,6 +398,7 @@ interface MTAuth {
     getAuth: () => Promise<TokenEventData>;
     signOut: () => Promise<void>;
     forceRefreshToken: () => Promise<string>;
+    emulate: (projectUrl?: string) => Promise<void>;
 }
 
 interface SigninResult {

package/src/index.js

@@ -1,7 +1,6 @@
 import { deserializeE2E, listenReachableServer, serializeE2E } from "./helpers/peripherals";
-import { releaseCacheStore, awaitStore } from "./helpers/utils";
+import { awaitStore, releaseCacheStore } from "./helpers/utils";
 import { CacheStore, Scoped } from "./helpers/variables";
-import { MTAuth } from "./products/auth";
 import { MTCollection, batchWrite, trySendPendingWrite } from "./products/database";
 import { MTStorage } from "./products/storage";
 import { ServerReachableListener, TokenRefreshListener } from "./helpers/listeners";
@@ -13,8 +12,9 @@ import { AUTH_PROVIDER_ID, CACHE_PROTOCOL } from "./helpers/values";
 import EngineApi from './helpers/engine_api';
 import { Validator } from 'guard-object';
 import sendMessage from "./helpers/broadcaster";
-import cloneDeep from "lodash.clonedeep";
-import { Buffer } from "buffer";
+import cloneDeep from 'lodash.clonedeep';
+import { Buffer } from 'buffer';
+import MTAuth, { purgePendingToken } from './products/auth';
 
 const {
     _listenCollection,
@@ -51,7 +51,7 @@ export class MosquitoTransport {
         this.config.wsPrefix = this.config.secureUrl ? 'wss' : 'ws';
 
         if (!Scoped.ReleaseCacheData)
-            throw `releaseCache must be called before creating any ${this.constructor.name} instance`;
+            throw `initializeCache must be called before creating any ${this.constructor.name} instance`;
 
         if (!Scoped.InitializedProject[projectUrl]) {
             Scoped.InitializedProject[projectUrl] = cloneDeep(this.config);
@@ -128,11 +128,17 @@ export class MosquitoTransport {
         }
     }
 
-    static releaseCache(prop) {
+    static initializeCache(prop) {
         if (Scoped.ReleaseCacheData) throw `calling ${this.name}() multiple times is prohibited`;
         validateReleaseCacheProp({ ...prop });
         Scoped.ReleaseCacheData = { ...prop };
         releaseCacheStore({ ...prop });
+        // purge residue tokens
+        awaitStore().then(() => {
+            Object.keys(CacheStore.PendingAuthPurge).forEach(k => {
+                purgePendingToken(k);
+            });
+        });
     }
 
     getDatabase = (dbName, dbUrl) => ({

package/src/products/auth/accessor.js

@@ -1,10 +1,12 @@
-import { doSignOut } from ".";
+import cloneDeep from "lodash.clonedeep";
+import { doSignOut, revokeAuthIntance } from ".";
 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 { CacheStore, Scoped } from "../../helpers/variables";
 import { simplifyError } from "simplify-error";
+import { Validator } from "guard-object";
 
 export const listenToken = (callback, projectUrl) =>
     AuthTokenListener.listenTo(projectUrl, (t, n) => {
@@ -18,12 +20,39 @@ export const injectFreshToken = async (config, { token, refreshToken }) => {
     await awaitStore();
     CacheStore.AuthStore[projectUrl] = { token, refreshToken };
     Scoped.AuthJWTToken[projectUrl] = token;
+    if (projectUrl in CacheStore.EmulatedAuth)
+        delete CacheStore.EmulatedAuth[projectUrl];
+
     updateCacheStore(0);
 
     triggerAuthToken(projectUrl);
     initTokenRefresher(config);
 };
 
+export const injectEmulatedAuth = async (config, emulatedURL) => {
+    await awaitStore();
+    if (typeof emulatedURL !== 'string' || (!Validator.HTTPS(emulatedURL) && !Validator.HTTP(emulatedURL)))
+        throw `Expected "projectUrl" to be valid https or http link but got "${emulatedURL}"`;
+
+    const { projectUrl } = config;
+    const { token } = CacheStore.AuthStore[emulatedURL] || {};
+    const depended = Object.entries(CacheStore.EmulatedAuth).find(([_, v]) => projectUrl === v);
+
+    if (emulatedURL === projectUrl) throw `auth instance for ${emulatedURL} cannot emulate itself`;
+    if (depended) throw `Chain Emulation Error: this auth instance (${projectUrl}) cannot be emulated as other auth instance (${depended[0]}) is already emulating it`;
+
+    const thisAuthStore = cloneDeep(CacheStore.AuthStore[projectUrl]);
+
+    CacheStore.AuthStore[projectUrl] = cloneDeep(CacheStore.AuthStore[emulatedURL]);
+    Scoped.AuthJWTToken[projectUrl] = token;
+    CacheStore.EmulatedAuth[projectUrl] = emulatedURL;
+
+    revokeAuthIntance(config, thisAuthStore);
+    updateCacheStore(0);
+    triggerAuthToken(projectUrl);
+    initTokenRefresher(config);
+};
+
 export const parseToken = (token) => JSON.parse(decodeBinary(token.split('.')[1]));
 
 export const triggerAuthToken = async (projectUrl, isInit) => {
@@ -46,9 +75,18 @@ export const initTokenRefresher = async (config, forceRefresh) => {
     const { projectUrl, maxRetries } = config;
     await awaitStore();
     const { token } = CacheStore.AuthStore[projectUrl] || {};
+    const emulatedURL = CacheStore.EmulatedAuth[projectUrl];
     const tokenInfo = token && parseToken(token);
 
     clearInterval(Scoped.TokenRefreshTimer[projectUrl]);
+    if (emulatedURL) return;
+
+    const notifyAuthReady = (value) => {
+        TokenRefreshListener.dispatch(projectUrl, value);
+        getEmulatedLinks(projectUrl).forEach(v => {
+            TokenRefreshListener.dispatch(v, value);
+        });
+    }
 
     if (token) {
         const expireOn = (tokenInfo.exp * 1000) - 60000;
@@ -56,24 +94,28 @@ export const initTokenRefresher = async (config, forceRefresh) => {
         const rizz = () => refreshToken(config, ++Scoped.LastTokenRefreshRef[projectUrl], maxRetries, maxRetries, forceRefresh);
 
         if (hasExpire || forceRefresh) {
-            TokenRefreshListener.dispatch(projectUrl);
+            notifyAuthReady();
             return rizz();
         } else {
-            TokenRefreshListener.dispatch(projectUrl, 'ready');
+            notifyAuthReady('ready');
             Scoped.TokenRefreshTimer[projectUrl] = setInterval(() => {
                 const countdown = expireOn - getPrefferTime();
                 if (countdown > 3000) return;
                 clearInterval(Scoped.TokenRefreshTimer[projectUrl]);
-                TokenRefreshListener.dispatch(projectUrl);
+                notifyAuthReady();
                 rizz();
             }, 3000);
         }
     } else if (forceRefresh) {
-        TokenRefreshListener.dispatch(projectUrl, 'ready');
-        return simplifyError('no_token_yet', 'No token is available to initiate a refresh').simpleError
+        notifyAuthReady('ready');
+        return simplifyError('no_token_yet', 'No token is available to initiate a refresh').simpleError;
     }
 };
 
+export const getEmulatedLinks = (projectUrl) => Object.entries(CacheStore.EmulatedAuth)
+    .filter(([_, v]) => v === projectUrl)
+    .map(v => v[0]);
+
 const refreshToken = (builder, processRef, remainRetries = 7, initialRetries = 7, isForceRefresh) => new Promise(async (resolve, reject) => {
     const { projectUrl, serverE2E_PublicKey, accessKey, uglify, extraHeaders } = builder;
     const lostProcess = simplifyError('process_lost', 'The token refresh process has been lost and replaced with another one');
@@ -107,8 +149,18 @@ const refreshToken = (builder, processRef, remainRetries = 7, initialRetries = 7
             Scoped.AuthJWTToken[projectUrl] = f.result.token;
 
             resolve(f.result.token);
-            triggerAuthToken(projectUrl, !Scoped.InitiatedForcedToken[projectUrl] && isForceRefresh);
+            const isInit = !Scoped.InitiatedForcedToken[projectUrl] && isForceRefresh;
+
+            triggerAuthToken(projectUrl, isInit);
             if (isForceRefresh) Scoped.InitiatedForcedToken[projectUrl] = true;
+
+            getEmulatedLinks(projectUrl).forEach(v => {
+                CacheStore.AuthStore[v] = cloneDeep(CacheStore.AuthStore[projectUrl]);
+                Scoped.AuthJWTToken[v] = f.result.token;
+
+                triggerAuthToken(v, isInit);
+                if (isForceRefresh) Scoped.InitiatedForcedToken[v] = true;
+            });
             updateCacheStore();
             initTokenRefresher(builder);
         } else reject(lostProcess.simpleError);

package/src/products/auth/index.js

@@ -3,19 +3,21 @@ import EngineApi from "../../helpers/engine_api";
 import { TokenRefreshListener } from "../../helpers/listeners";
 import { awaitReachableServer, awaitStore, buildFetchInterface, buildFetchResult, updateCacheStore } from "../../helpers/utils";
 import { CacheStore, Scoped } from "../../helpers/variables";
-import { awaitRefreshToken, initTokenRefresher, injectFreshToken, listenToken, parseToken, triggerAuthToken } from "./accessor";
+import { awaitRefreshToken, getEmulatedLinks, initTokenRefresher, injectEmulatedAuth, injectFreshToken, listenToken, parseToken, triggerAuthToken } from "./accessor";
 import { deserializeE2E, encodeBinary, serializeE2E } from "../../helpers/peripherals";
 import { simplifyCaughtError, simplifyError } from "simplify-error";
+import cloneDeep from "lodash.clonedeep";
 
 const {
     _listenUserVerification,
     _signOut,
     _customSignin,
     _customSignup,
-    _googleSignin
+    _googleSignin,
+    _areYouOk
 } = EngineApi;
 
-export class MTAuth {
+export default class MTAuth {
     constructor(config) {
         this.builder = { ...config };
     }
@@ -164,6 +166,10 @@ export class MTAuth {
     signOut = () => doSignOut(this.builder);
 
     forceRefreshToken = () => initTokenRefresher(this.builder, true);
+
+    emulate = async (projectUrl) => {
+        await injectEmulatedAuth(this.builder, projectUrl);
+    }
 };
 
 const doCustomSignin = (builder, email, password) => new Promise(async (resolve, reject) => {
@@ -171,6 +177,8 @@ const doCustomSignin = (builder, email, password) => new Promise(async (resolve,
 
     try {
         await awaitStore();
+        const thisAuthStore = cloneDeep(CacheStore.AuthStore[projectUrl]);
+
         const [reqBuilder, [privateKey]] = await buildFetchInterface({
             body: { data: `${encodeBinary(email)}.${encodeBinary(password)}` },
             accessKey,
@@ -189,6 +197,7 @@ const doCustomSignin = (builder, email, password) => new Promise(async (resolve,
             refreshToken: r.result.refreshToken
         });
         await injectFreshToken(builder, r.result);
+        revokeAuthIntance(builder, thisAuthStore);
     } catch (e) {
         reject(simplifyCaughtError(e).simpleError);
     }
@@ -199,6 +208,8 @@ const doCustomSignup = (builder, email, password, name, metadata) => new Promise
 
     try {
         await awaitStore();
+        const thisAuthStore = cloneDeep(CacheStore.AuthStore[projectUrl]);
+
         const [reqBuilder, [privateKey]] = await buildFetchInterface({
             body: {
                 data: `${encodeBinary(email)}.${encodeBinary(password)}.${(encodeBinary((name || '').trim()))}`,
@@ -220,47 +231,88 @@ const doCustomSignup = (builder, email, password, name, metadata) => new Promise
             refreshToken: r.result.refreshToken
         });
         await injectFreshToken(builder, r.result);
+        revokeAuthIntance(builder, thisAuthStore);
     } catch (e) {
         reject(simplifyCaughtError(e).simpleError);
     }
 });
 
-export const clearCacheForSignout = (builder) => {
-    const { projectUrl } = builder;
-    if (Scoped.AuthJWTToken[projectUrl]) delete Scoped.AuthJWTToken[projectUrl];
+const purgeCache = (url, isMain) => {
+    if (url in Scoped.AuthJWTToken) delete Scoped.AuthJWTToken[url];
     Object.keys(CacheStore).forEach(e => {
-        if (CacheStore[e][projectUrl]) delete CacheStore[e][projectUrl];
+        if (
+            e !== 'PendingAuthPurge' &&
+            (!['EmulatedAuth'].includes(e) || isMain)
+        ) {
+            if (CacheStore[e][url]) delete CacheStore[e][url];
+        }
     });
-    TokenRefreshListener.dispatch(projectUrl);
-    triggerAuthToken(projectUrl);
+    TokenRefreshListener.dispatch(url);
+    triggerAuthToken(url);
+};
+
+const clearCacheForSignout = (builder, disposeEmulated) => {
+    const { projectUrl } = builder;
+
+    purgeCache(projectUrl, true);
+    if (disposeEmulated) getEmulatedLinks(projectUrl).forEach(e => purgeCache(e));
     initTokenRefresher(builder);
 };
 
 export const doSignOut = async (builder) => {
     await awaitStore();
+    const emulatedURL = CacheStore.EmulatedAuth[builder.projectUrl];
 
-    const { projectUrl, serverE2E_PublicKey, accessKey, uglify, extraHeaders } = builder,
-        { token, refreshToken: r_token } = CacheStore.AuthStore[projectUrl];
-
-    clearCacheForSignout(builder);
+    clearCacheForSignout(builder, !emulatedURL);
     updateCacheStore(0);
+    if (emulatedURL) return;
+    await revokeAuthIntance(builder);
+};
+
+export const revokeAuthIntance = async (builder, authStore) => {
+    const { projectUrl, serverE2E_PublicKey, accessKey, uglify, extraHeaders } = builder;
+    const { token, refreshToken: r_token } = { ...authStore };
+
+    if (!r_token || CacheStore.EmulatedAuth[projectUrl]) return;
+    const nodeId = `${Math.random()}`;
 
-    if (token) {
+    CacheStore.PendingAuthPurge[nodeId] = {
+        auth: { token, refreshToken: r_token },
+        data: { projectUrl, serverE2E_PublicKey, accessKey, uglify, extraHeaders }
+    };
+    await purgePendingToken(nodeId);
+};
+
+export const purgePendingToken = async (nodeId) => {
+    const {
+        auth: { token, refreshToken: r_token },
+        data: { projectUrl, serverE2E_PublicKey, accessKey, uglify, extraHeaders }
+    } = CacheStore.PendingAuthPurge[nodeId];
+
+    if (!token) return;
+    try {
+        let isConnected;
         try {
+            isConnected = (await (await fetch(_areYouOk(projectUrl))).json(), { cache: 'no-cache' }).status === 'yes';
+        } catch (_) { }
+
+        if (!isConnected)
             await awaitReachableServer(projectUrl);
 
-            const [reqBuilder] = await buildFetchInterface({
-                body: { token, r_token },
-                accessKey,
-                uglify,
-                serverE2E_PublicKey,
-                extraHeaders
-            });
+        const [reqBuilder] = await buildFetchInterface({
+            body: { token, r_token },
+            accessKey,
+            uglify,
+            serverE2E_PublicKey,
+            extraHeaders
+        });
 
-            await buildFetchResult(await fetch(_signOut(projectUrl, uglify), reqBuilder), uglify);
-        } catch (e) {
-            throw simplifyCaughtError(e).simpleError;
-        }
+        await buildFetchResult(await fetch(_signOut(projectUrl, uglify), reqBuilder), uglify);
+    } catch (e) {
+        throw simplifyCaughtError(e).simpleError;
+    } finally {
+        delete CacheStore.PendingAuthPurge[nodeId];
+        updateCacheStore(0);
     }
 };
 
@@ -269,6 +321,8 @@ const doGoogleSignin = (builder, token) => new Promise(async (resolve, reject) =
 
     try {
         await awaitStore();
+        const thisAuthStore = cloneDeep(CacheStore.AuthStore[projectUrl]);
+
         const [reqBuilder, [privateKey]] = await buildFetchInterface({
             body: { token },
             accessKey,
@@ -288,6 +342,7 @@ const doGoogleSignin = (builder, token) => new Promise(async (resolve, reject) =
             isNewUser: f.result.isNewUser
         });
         await injectFreshToken(builder, f.result);
+        revokeAuthIntance(builder, thisAuthStore);
     } catch (e) {
         reject(simplifyCaughtError(e).simpleError);
     }