@schibsted/account-sdk-browser 5.0.1-beta.2 → 5.0.1-beta.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@schibsted/account-sdk-browser",
-  "version": "5.0.1-beta.2",
+  "version": "5.0.1-beta.4",
   "description": "Schibsted account SDK for browsers",
   "main": "index.js",
   "type": "module",

package/src/identity.d.ts

@@ -45,9 +45,10 @@ export class Identity extends TinyEmitter {
      */
     private _getTabId;
     /**
-     * Checks if calling get session is blocked
+     * Checks if calling GET session is blocked by a cache storage
      * @private
-     * @returns {boolean|void}
+     * @param {Cache} cache - cache to check
+     * @returns {string|null}
      */
     private _isSessionCallBlocked;
     /**
@@ -61,7 +62,7 @@ export class Identity extends TinyEmitter {
      * @private
      * @returns {void}
      */
-    private _unblockSessionCall;
+    private _unblockSessionCallByTab;
     /**
      * Set SPiD server URL
      * @private

package/src/identity.js

@@ -151,6 +151,9 @@ const SESSION_CALL_BLOCKED_TTL = 1000 * 30; //set to 30s, the default period for
 const TAB_ID_KEY = 'tab-id-cache';
 const TAB_ID = Math.floor(Math.random() * 100000)
 const TAB_ID_TTL = 1000 * 60 * 60 * 24 * 30;
+const MAX_SESSION_CALL_RETRIES = 10;
+const MIN_SESSION_CALL_WAIT_TIME = 100;
+
 
 const globalWindow = () => window;
 
@@ -177,7 +180,7 @@ export class Identity extends EventEmitter {
         env = 'PRE',
         log,
         window = globalWindow(),
-        callbackBeforeRedirect = ()=>{}
+        callbackBeforeRedirect = () => {}
     }) {
         super();
         assert(isNonEmptyString(clientId), 'clientId parameter is required');
@@ -194,7 +197,7 @@ export class Identity extends EventEmitter {
         this.window = window;
         this.clientId = clientId;
         this.sessionStorageCache = new Cache(() => this.window && this.window.sessionStorage);
-        this.localStorageCache = new Cache(() =>this.window && this.window.localStorage);
+        this.localStorageCache = new Cache(() => this.window && this.window.localStorage);
         this.redirectUri = redirectUri;
         this.env = env;
         this.log = log;
@@ -234,12 +237,13 @@ export class Identity extends EventEmitter {
     }
 
     /**
-     * Checks if calling GET session is blocked
+     * Checks if calling GET session is blocked by a cache storage
      * @private
-     * @returns {number|null}
+     * @param {Cache} cache - cache to check
+     * @returns {string|null}
      */
-    _isSessionCallBlocked(){
-        return this.localStorageCache.get(SESSION_CALL_BLOCKED_CACHE_KEY);
+    _isSessionCallBlocked(cache) {
+        return cache.get(SESSION_CALL_BLOCKED_CACHE_KEY);
     }
 
     /**
@@ -247,7 +251,15 @@ export class Identity extends EventEmitter {
      * @private
      * @returns {void}
      */
-    _blockSessionCall(){
+    _blockSessionCall() {
+        // session storage block protects against single tab, multiple identity instance concurrency
+        this.sessionStorageCache.set(
+            SESSION_CALL_BLOCKED_CACHE_KEY,
+            this._tabId,
+            SESSION_CALL_BLOCKED_TTL
+        );
+
+        // local storage block protects against cross-tab concurrency
         this.localStorageCache.set(
             SESSION_CALL_BLOCKED_CACHE_KEY,
             this._tabId,
@@ -261,9 +273,11 @@ export class Identity extends EventEmitter {
      * @returns {void}
      */
     _unblockSessionCallByTab() {
-        if (this._isSessionCallBlocked() === this._tabId) {
+        if (this._isSessionCallBlocked(this.localStorageCache) === this._tabId) {
             this.localStorageCache.delete(SESSION_CALL_BLOCKED_CACHE_KEY);
         }
+
+        this.sessionStorageCache.delete(SESSION_CALL_BLOCKED_CACHE_KEY);
     }
 
     /**
@@ -339,7 +353,7 @@ export class Identity extends EventEmitter {
         this._globalSessionService = new RESTClient({
             serverUrl: urlMapper(url, ENDPOINTS.SESSION_SERVICE),
             log: this.log,
-            defaultParams: { client_sdrn, sdk_version: version },
+            defaultParams: {client_sdrn, sdk_version: version},
         });
     }
 
@@ -503,7 +517,7 @@ export class Identity extends EventEmitter {
      * @returns {void}
      */
     _clearVarnishCookie() {
-        const baseDomain =  this._session && typeof this._session.baseDomain === 'string'
+        const baseDomain = this._session && typeof this._session.baseDomain === 'string'
             ? this._session.baseDomain
             : document.domain;
 
@@ -565,74 +579,128 @@ export class Identity extends EventEmitter {
             this._maybeSetVarnishCookie(sessionData);
             this._emitSessionEvent(this._session, sessionData);
             this._session = sessionData;
+
             return sessionData;
         };
 
-        const _checkRedirectionNeed = (sessionData={})=>{
+        const _checkRedirectionNeed = (sessionData = {}) => {
             const sessionDataKeys = Object.keys(sessionData);
 
             return sessionDataKeys.length === 1 &&
                 sessionDataKeys[0] === 'redirectURL';
-        }
+        };
 
         const _getSession = async () => {
-            if (this._enableSessionCaching) {
-                // Try to resolve from cache (it has a TTL)
-                let cachedSession = this.sessionStorageCache.get(HAS_SESSION_CACHE_KEY);
-                if (cachedSession) {
-                    return _postProcess(cachedSession);
+            const callSessionEndpoint = async () => {
+                try {
+                    /* Blocking future calls to session-service. This lock is removed after the response is processed
+                     to account for redirection that can happen towards session-service too */
+                    this._blockSessionCall();
+
+                    return await this._sessionService.get('/v2/session', {tabId: this._tabId});
+                } catch (err) {
+                    if (err && err.code === 400 && this._enableSessionCaching) {
+                        const expiresIn = 1000 * (err.expiresIn || 300);
+                        this.sessionStorageCache.set(HAS_SESSION_CACHE_KEY, {error: err}, expiresIn);
+                    }
+
+                    throw err;
                 }
-            }
+            };
 
-            // Prevent concurrent calls to session-service
-            if (this._isSessionCallBlocked()) {
-                // Returning data directly, without _postProcess since the data returned is the local copy
-                return this._session;
-            }
+            const useSessionResponseIfValid = async (sessionData) => {
+                if (sessionData) {
+                    // For expiring session and WebKit browsers do a full page redirect to get a new session
+                    if (_checkRedirectionNeed(sessionData)) {
+                        await this.callbackBeforeRedirect();
 
-            let sessionData = null;
-            try {
-                this._blockSessionCall();
+                        // Doing a return here, to avoid caching the redirect response
+                        return this.window.location.href = this._sessionService.makeUrl(sessionData.redirectURL, {tabId: this._getTabId()});
+                    }
 
-                sessionData = await this._sessionService.get('/v2/session', {tabId: this._tabId});
-            } catch (err) {
-                if (err && err.code === 400 && this._enableSessionCaching) {
-                    const expiresIn = 1000 * (err.expiresIn || 300);
-                    this.sessionStorageCache.set(HAS_SESSION_CACHE_KEY, { error: err }, expiresIn);
-                }
-                throw err;
-            }
+                    if (this._enableSessionCaching) {
+                        const expiresIn = 1000 * (sessionData.expiresIn || 300);
+                        this.sessionStorageCache.set(HAS_SESSION_CACHE_KEY, sessionData, expiresIn);
+                    }
 
-            if (sessionData){
-                // For expiring session and Safari browser do full page redirect to get new session
-                if(_checkRedirectionNeed(sessionData)){
-                    await this.callbackBeforeRedirect();
-                    this.window.location.href = this._sessionService.makeUrl(sessionData.redirectURL, {tabId: this._getTabId()});
+                    return _postProcess(sessionData);
                 }
+            };
 
+            const checkIfSessionCallIsNeededAndSafe = async (blockedAction) => {
                 if (this._enableSessionCaching) {
-                    const expiresIn = 1000 * (sessionData.expiresIn || 300);
-                    this.sessionStorageCache.set(HAS_SESSION_CACHE_KEY, sessionData, expiresIn);
+                    // Try to resolve from cache (it has a TTL)
+                    let cachedSession = this.sessionStorageCache.get(HAS_SESSION_CACHE_KEY);
+                    if (cachedSession) {
+                        return _postProcess(cachedSession);
+                    }
                 }
-            }
 
-            return _postProcess(sessionData);
+                if (this._isSessionCallBlocked(this.sessionStorageCache) || this._isSessionCallBlocked(this.localStorageCache)) {
+                    if (this._session && this._session.userId) {
+                        return _postProcess(this._session);
+                    }
+
+                    // If blockedAction is defined, do that and return the result, otherwise return null
+                    if (blockedAction) {
+                        const blockedResult = await blockedAction();
+
+                        return _postProcess(blockedResult);
+                    }
+
+                    return null;
+                }
+
+                // If session service calls are not blocked, call it
+                const sessionData = await callSessionEndpoint();
+
+                return await useSessionResponseIfValid(sessionData);
+            };
+
+            return await checkIfSessionCallIsNeededAndSafe(async () => {
+                let retryCount = 0;
+
+                // Try to call session-service MAX_SESSION_CALL_RETRIES times, waiting up to 1 second each time
+                while (retryCount < MAX_SESSION_CALL_RETRIES) {
+                    retryCount++;
+
+                    const randomWaitingStep = Math.floor(Math.random() * 9); // ignoring waiting times that are too small to matter
+                    const randomWaitTime = MIN_SESSION_CALL_WAIT_TIME + (randomWaitingStep * 100);
+                    await new Promise(resolve => setTimeout(resolve, randomWaitTime));
+
+                    // attempt to call session service, but don't take any action if call is blocked and don't use the result
+                    const result = await checkIfSessionCallIsNeededAndSafe(null);
+                    if (result) {
+                        return result;
+                    }
+                }
+
+                // Exceeded number of attempts, returning old session info
+                if (this._session && this._session.userId) {
+                    return this._session;
+                }
+
+                throw new SDKError('HasSession exceeded maximum number of attempts');
+            });
         };
+
         this._hasSessionInProgress = _getSession()
             .then(
                 sessionData => {
                     this._hasSessionInProgress = false;
+                    this._unblockSessionCallByTab();
 
                     return sessionData;
                 },
                 err => {
                     this.emit('error', err);
                     this._hasSessionInProgress = false;
+                    this._unblockSessionCallByTab();
+
                     throw new SDKError('HasSession failed', err);
                 }
             );
 
-        this._unblockSessionCallByTab();
         return this._hasSessionInProgress;
     }
 
@@ -673,8 +741,8 @@ export class Identity extends EventEmitter {
     async isConnected() {
         try {
             const data = await this.hasSession();
-            // if data is not an object, the promise will fail.
-            // if the result is present, it's boolean. But if it's not, it should be assumed false.
+            /* If data is not an object, the promise will fail.
+            If the result is present, it's boolean. But if it's not, it should be assumed false. */
             return !!data.result;
         } catch (_) {
             return false;
@@ -749,13 +817,13 @@ export class Identity extends EventEmitter {
         if (!pairId)
             throw new SDKError('pairId missing in user session!');
 
-        if(!externalParty || externalParty.length === 0) {
+        if (!externalParty || externalParty.length === 0) {
             throw new SDKError('externalParty cannot be empty');
         }
-        const _toHexDigest = (hashBuffer) =>{
-            // convert buffer to byte array
+        const _toHexDigest = (hashBuffer) => {
+            // Convert buffer to byte array
             const hashArray = Array.from(new Uint8Array(hashBuffer));
-            // convert bytes to hex string
+            // Convert bytes to hex string
             return hashArray.map(b => b.toString(16).padStart(2, '0')).join('');
         }
 
@@ -831,6 +899,7 @@ export class Identity extends EventEmitter {
             return null;
         }
     }
+
     /**
      * If a popup is desired, this function needs to be called in response to a user event (like
      * click or tap) in order to work correctly. Otherwise the popup will be blocked by the
@@ -953,7 +1022,7 @@ export class Identity extends EventEmitter {
         prompt = 'select_account',
     }) {
         if (typeof arguments[0] !== 'object') {
-            // backward compatibility
+            // Backward compatibility
             state = arguments[0];
             acrValues = arguments[1];
             scope = arguments[2] || scope;
@@ -1081,7 +1150,10 @@ export class Identity extends EventEmitter {
                 };
 
                 const loginNotYouHandler = async () => {
-                    this.login(Object.assign(await prepareLoginParams(loginParams), {loginHint: userData.identifier, prompt: 'login'}));
+                    this.login(Object.assign(await prepareLoginParams(loginParams), {
+                        loginHint: userData.identifier,
+                        prompt: 'login'
+                    }));
                 };
 
                 const initHandler = () => {

package/src/version.js

@@ -1,5 +1,5 @@
 // Automatically generated in 'npm version' by scripts/genversion.js
 
 'use strict'
-const version = '5.0.1-beta.2';
+const version = '5.0.1-beta.4';
 export default version;