react-native-mosquito-transport 0.0.19 → 0.0.21

package/src/products/auth/accessor.js

@@ -1,10 +1,12 @@
-import setLargeTimeout from "set-large-timeout";
-import { doSignOut } from ".";
-import EngineApi from "../../helpers/EngineApi";
+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, simplifyError, updateCacheStore } from "../../helpers/utils";
+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,18 +20,44 @@ export const injectFreshToken = async (config, { token, refreshToken }) => {
     await awaitStore();
     CacheStore.AuthStore[projectUrl] = { token, refreshToken };
     Scoped.AuthJWTToken[projectUrl] = token;
-    updateCacheStore();
+    if (projectUrl in CacheStore.EmulatedAuth)
+        delete CacheStore.EmulatedAuth[projectUrl];
 
+    updateCacheStore(0);
+
+    triggerAuthToken(projectUrl);
+    initTokenRefresher(config);
+};
+
+export const injectEmulatedAuth = async (config, emulatedURL) => {
+    if (!Scoped.IsStoreReady) 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]);
+    revokeAuthIntance(config, thisAuthStore);
+
+    CacheStore.AuthStore[projectUrl] = cloneDeep(CacheStore.AuthStore[emulatedURL]);
+    Scoped.AuthJWTToken[projectUrl] = token;
+    CacheStore.EmulatedAuth[projectUrl] = emulatedURL;
+
+    updateCacheStore(0);
     triggerAuthToken(projectUrl);
     initTokenRefresher(config);
-}
+};
 
 export const parseToken = (token) => JSON.parse(decodeBinary(token.split('.')[1]));
 
 export const triggerAuthToken = async (projectUrl, isInit) => {
     await awaitStore();
     AuthTokenListener.dispatch(projectUrl, CacheStore.AuthStore[projectUrl]?.token || null, isInit);
-}
+};
 
 export const awaitRefreshToken = (projectUrl) => new Promise(resolve => {
     const l = TokenRefreshListener.listenTo(projectUrl, v => {
@@ -44,63 +72,96 @@ export const listenTokenReady = (callback, projectUrl) => TokenRefreshListener.l
 
 export const initTokenRefresher = async (config, forceRefresh) => {
     const { projectUrl, maxRetries } = config;
-    await awaitStore();
-    const { token } = CacheStore.AuthStore[projectUrl] || {},
-        tokenInfo = token ? parseToken(token) : undefined;
-
-    Scoped.TokenRefreshTimer[projectUrl]?.();
+    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 (emulatedURL) return;
+
+    const notifyAuthReady = (value) => {
+        TokenRefreshListener.dispatch(projectUrl, value);
+        getEmulatedLinks(projectUrl).forEach(v => {
+            TokenRefreshListener.dispatch(v, value);
+        });
+    }
 
     if (token) {
-        const hasExpire = Date.now() >= (tokenInfo.exp * 1000) - 60000,
-            rizz = () => refreshToken(config, ++Scoped.LastTokenRefreshRef[projectUrl], maxRetries, maxRetries, forceRefresh);
+        const expireOn = (tokenInfo.exp * 1000) - 60000;
+        const hasExpire = getPrefferTime() >= expireOn;
+        const rizz = () => refreshToken(config, ++Scoped.LastTokenRefreshRef[projectUrl], maxRetries, maxRetries, forceRefresh);
 
         if (hasExpire || forceRefresh) {
-            TokenRefreshListener.dispatch(projectUrl);
+            notifyAuthReady();
             return rizz();
         } else {
-            TokenRefreshListener.dispatch(projectUrl, 'ready');
-            Scoped.TokenRefreshTimer[projectUrl] = setLargeTimeout(() => {
-                TokenRefreshListener.dispatch(projectUrl);
+            notifyAuthReady('ready');
+            Scoped.TokenRefreshTimer[projectUrl] = setInterval(() => {
+                const countdown = expireOn - getPrefferTime();
+                if (countdown > 3000) return;
+                clearInterval(Scoped.TokenRefreshTimer[projectUrl]);
+                notifyAuthReady();
                 rizz();
-            }, ((tokenInfo.exp * 1000) - 60000) - Date.now());
+            }, 3000);
+        }
+    } else {
+        notifyAuthReady('ready');
+        if (forceRefresh) {
+            return simplifyError('no_token_yet', 'No token is available to initiate a refresh').simpleError;
         }
-    } else if (forceRefresh) {
-        TokenRefreshListener.dispatch(projectUrl, '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 } = builder;
-    const lostProcess = simplifyError('process_lost', 'The token refresh process has been lost and replace with another one');
+    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');
 
     try {
         const { token, refreshToken: r_token } = CacheStore.AuthStore[projectUrl];
 
-        const [reqBuilder, [privateKey]] = buildFetchInterface({
+        const [reqBuilder, [privateKey]] = await buildFetchInterface({
             body: { token, r_token },
             accessKey,
             uglify,
-            serverE2E_PublicKey
+            serverE2E_PublicKey,
+            extraHeaders
         });
 
-        const r = await (await fetch(EngineApi._refreshAuthToken(projectUrl, uglify), reqBuilder)).json();
+        let data;
 
-        if (processRef !== Scoped.LastTokenRefreshRef[projectUrl]) {
-            reject(lostProcess.simpleError);
-            return;
+        try {
+            data = await buildFetchResult(await fetch(EngineApi._refreshAuthToken(projectUrl, uglify), reqBuilder), uglify);
+        } finally {
+            if (processRef !== Scoped.LastTokenRefreshRef[projectUrl]) {
+                reject(lostProcess.simpleError);
+                return;
+            }
         }
-        if (r.simpleError) throw r;
 
-        const f = uglify ? deserializeE2E(r.e2e, serverE2E_PublicKey, privateKey) : r;
+        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);
-            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);
@@ -115,7 +176,7 @@ const refreshToken = (builder, processRef, remainRetries = 7, initialRetries = 7
                     lostProcess.simpleError :
                     simplifyError('retry_limit_reached', 'The retry limit has been reach and execution prematurely stopped').simpleError
             );
-            console.error(`refreshToken retry exceeded, waiting for 2min before starting another retry`);
+            console.error(`refreshToken retry limit exceeded`);
         } else {
             const l = listenReachableServer(c => {
                 if (processRef !== Scoped.LastTokenRefreshRef[projectUrl]) {
@@ -123,7 +184,7 @@ const refreshToken = (builder, processRef, remainRetries = 7, initialRetries = 7
                     l();
                 } else if (c) {
                     l();
-                    refreshToken(builder, processRef, remainRetries - 1, initialRetries).then(resolve, reject);
+                    refreshToken(builder, processRef, remainRetries - 1, initialRetries, isForceRefresh).then(resolve, reject);
                 }
             }, projectUrl);
         }

package/src/products/auth/index.js

@@ -1,20 +1,23 @@
 import { io } from "socket.io-client";
-import EngineApi from "../../helpers/EngineApi";
+import EngineApi from "../../helpers/engine_api";
 import { TokenRefreshListener } from "../../helpers/listeners";
-import { awaitReachableServer, awaitStore, buildFetchInterface, simplifyError, updateCacheStore } from "../../helpers/utils";
-import { CacheConstant, CacheStore, Scoped } from "../../helpers/variables";
-import { awaitRefreshToken, initTokenRefresher, injectFreshToken, listenToken, parseToken, triggerAuthToken } from "./accessor";
-import { deserializeE2E, encodeBinary, serializeE2E, simplifyCaughtError } from "../../helpers/peripherals";
+import { awaitReachableServer, awaitStore, buildFetchInterface, buildFetchResult, updateCacheStore } from "../../helpers/utils";
+import { CacheStore, Scoped } from "../../helpers/variables";
+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 };
     }
@@ -26,25 +29,29 @@ export class MTAuth {
     googleSignin = (token) => doGoogleSignin(this.builder, token);
 
     appleSignin() {
-
+        throw 'unsupported method call';
     }
 
     facebookSignin() {
-
+        throw 'unsupported method call';
     }
 
     twitterSignin() {
-
+        throw 'unsupported method call';
     }
 
     githubSignin() {
-
+        throw 'unsupported method call';
     }
 
     listenVerifiedStatus(callback, onError) {
         const { projectUrl, serverE2E_PublicKey, uglify, baseUrl, wsPrefix } = this.builder;
 
-        let socket, wasDisconnected, lastToken = Scoped.AuthJWTToken[projectUrl] || null, lastInitRef = 0;
+        let socket,
+            wasDisconnected,
+            hasCancelled,
+            lastToken = Scoped.AuthJWTToken[projectUrl] || null,
+            lastInitRef = 0;
 
         const init = async () => {
             const processID = ++lastInitRef;
@@ -56,23 +63,23 @@ export class MTAuth {
             }
             if (processID !== lastInitRef) return;
             const mtoken = Scoped.AuthJWTToken[projectUrl],
-                [reqBuilder, [privateKey]] = uglify ? serializeE2E({ mtoken }, undefined, serverE2E_PublicKey) : [null, []];
+                [reqBuilder, [privateKey]] = uglify ? await serializeE2E({ mtoken }, undefined, serverE2E_PublicKey) : [null, []];
 
             socket = io(`${wsPrefix}://${baseUrl}`, {
+                transports: ['websocket', 'polling', 'flashsocket'],
                 auth: uglify ? {
-                    e2e: reqBuilder,
+                    e2e: reqBuilder.toString('base64'),
                     _m_internal: true
                 } : { mtoken, _m_internal: true }
             });
 
             socket.emit(_listenUserVerification(uglify));
 
-            socket.on("onVerificationChanged", ([err, verified]) => {
-                const fatal = err ? simplifyCaughtError(err).simpleError : undefined;
-                if (fatal) {
-                    onError?.(fatal);
+            socket.on("onVerificationChanged", async ([err, verified]) => {
+                if (err) {
+                    onError?.(simplifyCaughtError(err).simpleError);
                 } else {
-                    callback?.(uglify ? deserializeE2E(verified, serverE2E_PublicKey, privateKey) : verified);
+                    callback?.(uglify ? await deserializeE2E(verified, serverE2E_PublicKey, privateKey) : verified);
                 }
             });
 
@@ -97,6 +104,8 @@ export class MTAuth {
         }, projectUrl);
 
         return () => {
+            if (hasCancelled) return;
+            hasCancelled = true;
             socket?.close?.();
             tokenListener?.();
         }
@@ -108,7 +117,13 @@ export class MTAuth {
         await awaitStore();
         return CacheStore.AuthStore[this.builder.projectUrl]?.refreshToken;
     }
-    
+
+    getRefreshTokenData = async () => {
+        await awaitStore();
+        const { refreshToken } = CacheStore.AuthStore[this.builder.projectUrl] || {};
+        return refreshToken && parseToken(refreshToken);
+    }
+
     parseToken = (token) => parseToken(token);
 
     getAuthToken = () => new Promise(resolve => {
@@ -126,19 +141,23 @@ export class MTAuth {
 
         return listenToken((t, initToken) => {
             const { refreshToken } = CacheStore.AuthStore[this.builder.projectUrl] || {};
+            const parseData = t && parseToken(t);
+            const tokenEntity = parseData?.entityOf || null;
 
             if (
-                (!!t || null) !== lastTrig ||
+                tokenEntity !== lastTrig ||
                 initToken
-            ) callback(t ? {
-                ...parseToken(t),
-                tokenManager: {
-                    refreshToken,
-                    accessToken: t
-                }
-            } : null);
+            ) {
+                callback(t ? {
+                    ...parseData,
+                    tokenManager: {
+                        refreshToken,
+                        accessToken: t
+                    }
+                } : null);
+            }
 
-            lastTrig = !!t || null;
+            lastTrig = tokenEntity;
         }, this.builder.projectUrl);
     }
 
@@ -152,24 +171,30 @@ 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) => {
-    const { projectUrl, serverE2E_PublicKey, accessKey, uglify } = builder;
+    const { projectUrl, serverE2E_PublicKey, accessKey, uglify, extraHeaders } = builder;
 
     try {
         await awaitStore();
-        const [reqBuilder, [privateKey]] = buildFetchInterface({
-            body: { _: `${encodeBinary(email)}.${encodeBinary(password)}` },
+        const thisAuthStore = cloneDeep(CacheStore.AuthStore[projectUrl]);
+
+        const [reqBuilder, [privateKey]] = await buildFetchInterface({
+            body: { data: `${encodeBinary(email)}.${encodeBinary(password)}` },
             accessKey,
             serverE2E_PublicKey,
-            uglify
+            uglify,
+            extraHeaders
         });
 
-        const f = await (await fetch(_customSignin(projectUrl, uglify), reqBuilder)).json();
-        if (f.simpleError) throw f;
+        const data = await buildFetchResult(await fetch(_customSignin(projectUrl, uglify), reqBuilder), uglify);
 
-        const r = uglify ? deserializeE2E(f.e2e, serverE2E_PublicKey, privateKey) : f;
+        const r = uglify ? await deserializeE2E(data, serverE2E_PublicKey, privateKey) : data;
 
         resolve({
             user: parseToken(r.result.token),
@@ -177,30 +202,33 @@ 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);
     }
 });
 
 const doCustomSignup = (builder, email, password, name, metadata) => new Promise(async (resolve, reject) => {
-    const { projectUrl, serverE2E_PublicKey, accessKey, uglify } = builder;
+    const { projectUrl, serverE2E_PublicKey, accessKey, uglify, extraHeaders } = builder;
 
     try {
         await awaitStore();
-        const [reqBuilder, [privateKey]] = buildFetchInterface({
+        const thisAuthStore = cloneDeep(CacheStore.AuthStore[projectUrl]);
+
+        const [reqBuilder, [privateKey]] = await buildFetchInterface({
             body: {
-                _: `${encodeBinary(email)}.${encodeBinary(password)}.${(encodeBinary(name || '').trim())}`,
+                data: `${encodeBinary(email)}.${encodeBinary(password)}.${(encodeBinary((name || '').trim()))}`,
                 metadata,
             },
             accessKey,
             serverE2E_PublicKey,
-            uglify
+            uglify,
+            extraHeaders
         });
 
-        const f = await (await fetch(_customSignup(projectUrl, uglify), reqBuilder)).json();
-        if (f.simpleError) throw f;
+        const data = await buildFetchResult(await fetch(_customSignup(projectUrl, uglify), reqBuilder), uglify);
 
-        const r = uglify ? deserializeE2E(f.e2e, serverE2E_PublicKey, privateKey) : f;
+        const r = uglify ? await deserializeE2E(data, serverE2E_PublicKey, privateKey) : data;
 
         resolve({
             user: parseToken(r.result.token),
@@ -208,63 +236,109 @@ 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 doSignOut = async (builder) => {
-    await awaitStore();
+const purgeCache = (url, isMain) => {
+    if (url in Scoped.AuthJWTToken) delete Scoped.AuthJWTToken[url];
+    Object.keys(CacheStore).forEach(e => {
+        if (
+            e !== 'PendingAuthPurge' &&
+            (!['EmulatedAuth'].includes(e) || isMain)
+        ) {
+            if (CacheStore[e][url]) delete CacheStore[e][url];
+        }
+    });
+    TokenRefreshListener.dispatch(url);
+    triggerAuthToken(url);
+};
 
-    const { projectUrl, serverE2E_PublicKey, accessKey, uglify } = builder,
-        { token, refreshToken: r_token } = CacheStore.AuthStore[projectUrl];
+const clearCacheForSignout = (builder, disposeEmulated) => {
+    const { projectUrl } = builder;
 
-    TokenRefreshListener.dispatch(projectUrl);
-    if (CacheStore.AuthStore[projectUrl]) delete CacheStore.AuthStore[projectUrl];
-    if (token) delete Scoped.AuthJWTToken[projectUrl];
-    Object.keys(CacheConstant).forEach(e => {
-        CacheStore[e] = CacheConstant[e];
-    });
-    triggerAuthToken(projectUrl);
-    updateCacheStore();
+    purgeCache(projectUrl, true);
+    if (disposeEmulated) getEmulatedLinks(projectUrl).forEach(e => purgeCache(e));
     initTokenRefresher(builder);
+};
 
-    if (token) {
-        TokenRefreshListener.dispatch(projectUrl, 'ready');
+export const doSignOut = async (builder) => {
+    if (!Scoped.IsStoreReady) await awaitStore();
+    const emulatedURL = CacheStore.EmulatedAuth[builder.projectUrl];
+
+    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()}`;
+
+    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] = buildFetchInterface({
-                body: { token, r_token },
-                accessKey,
-                uglify,
-                serverE2E_PublicKey
-            });
+        const [reqBuilder] = await buildFetchInterface({
+            body: { token, r_token },
+            accessKey,
+            uglify,
+            serverE2E_PublicKey,
+            extraHeaders
+        });
 
-            const r = await (await fetch(_signOut(projectUrl, uglify), reqBuilder)).json();
-            if (r.simpleError) throw r;
-        } 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);
     }
-}
+};
 
 const doGoogleSignin = (builder, token) => new Promise(async (resolve, reject) => {
-    const { projectUrl, serverE2E_PublicKey, accessKey, uglify } = builder;
+    const { projectUrl, serverE2E_PublicKey, accessKey, uglify, extraHeaders } = builder;
 
     try {
         await awaitStore();
-        const [reqBuilder, [privateKey]] = buildFetchInterface({
+        const thisAuthStore = cloneDeep(CacheStore.AuthStore[projectUrl]);
+
+        const [reqBuilder, [privateKey]] = await buildFetchInterface({
             body: { token },
             accessKey,
             uglify,
-            serverE2E_PublicKey
+            serverE2E_PublicKey,
+            extraHeaders
         });
 
-        const r = await (await fetch(_googleSignin(projectUrl, uglify), reqBuilder)).json();
-        if (r.simpleError) throw r;
+        const data = await buildFetchResult(await fetch(_googleSignin(projectUrl, uglify), reqBuilder), uglify);
 
-        const f = uglify ? deserializeE2E(r.e2e, serverE2E_PublicKey, privateKey) : r;
+        const f = uglify ? await deserializeE2E(data, serverE2E_PublicKey, privateKey) : data;
 
         resolve({
             user: parseToken(f.result.token),
@@ -273,6 +347,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);
     }
@@ -280,10 +355,4 @@ const doGoogleSignin = (builder, token) => new Promise(async (resolve, reject) =
 
 const doAppleSignin = async () => {
 
-}
-
-const validateEmailAndPassword = () => { }
-
-const getAuthState = async (projectUrl) => {
-
 }