@schibsted/account-sdk-browser 4.8.7 → 5.0.0

package/package.json

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

package/src/identity.d.ts

@@ -13,15 +13,17 @@ export class Identity extends TinyEmitter {
      * @param {function} [options.log] - A function that receives debug log information. If not set,
      * no logging will be done
      * @param {object} [options.window] - window object
+     * @param {function} [options.callbackBeforeRedirect] - callback triggered before session refresh redirect happen
      * @throws {SDKError} - If any of options are invalid
      */
-    constructor({ clientId, redirectUri, sessionDomain, env, log, window }: {
+    constructor({ clientId, redirectUri, sessionDomain, env, log, window, callbackBeforeRedirect }: {
         clientId: string;
         sessionDomain: string;
         redirectUri: string;
         env?: string;
         log?: Function;
         window?: any;
+        callbackBeforeRedirect?: Function;
     });
     _sessionInitiatedSent: boolean;
     window: any;
@@ -30,6 +32,7 @@ export class Identity extends TinyEmitter {
     redirectUri: string;
     env: string;
     log: Function;
+    callbackBeforeRedirect: Function;
     _sessionDomain: string;
     _enableSessionCaching: boolean;
     _session: {};

package/src/identity.js

@@ -145,6 +145,9 @@ import version from './version.js';
  */
 
 const HAS_SESSION_CACHE_KEY = 'hasSession-cache';
+const SESSION_CALL_BLOCKED_CACHE_KEY = 'sessionCallBlocked-cache';
+const SESSION_CALL_BLOCKED_TTL = 1000 * 60 * 5;
+
 const globalWindow = () => window;
 
 /**
@@ -160,9 +163,18 @@ export class Identity extends EventEmitter {
      * @param {function} [options.log] - A function that receives debug log information. If not set,
      * no logging will be done
      * @param {object} [options.window] - window object
+     * @param {function} [options.callbackBeforeRedirect] - callback triggered before session refresh redirect happen
      * @throws {SDKError} - If any of options are invalid
      */
-    constructor({ clientId, redirectUri, sessionDomain, env = 'PRE', log, window = globalWindow() }) {
+    constructor({
+        clientId,
+        redirectUri,
+        sessionDomain,
+        env = 'PRE',
+        log,
+        window = globalWindow(),
+        callbackBeforeRedirect = ()=>{}
+    }) {
         super();
         assert(isNonEmptyString(clientId), 'clientId parameter is required');
         assert(isObject(window), 'The reference to window is missing');
@@ -177,6 +189,7 @@ export class Identity extends EventEmitter {
         this.redirectUri = redirectUri;
         this.env = env;
         this.log = log;
+        this.callbackBeforeRedirect = callbackBeforeRedirect;
         this._sessionDomain = sessionDomain;
 
         // Internal hack: set to false to always refresh from hassession
@@ -190,6 +203,50 @@ export class Identity extends EventEmitter {
         this._setBffServerUrl(env);
         this._setOauthServerUrl(env);
         this._setGlobalSessionServiceUrl(env);
+
+        this._unblockSessionCall();
+    }
+
+    /**
+     * Checks if getting session is blocked
+     * @private
+     *
+     * @returns {boolean|void}
+     */
+    _isSessionCallBlocked(){
+        if (this._enableSessionCaching) {
+            return this.cache.get(SESSION_CALL_BLOCKED_CACHE_KEY);
+        }
+    }
+
+    /**
+     * Block calls to get session
+     * @private
+     *
+     * @returns {void}
+     */
+    _blockSessionCall(){
+        if (this._enableSessionCaching) {
+            const SESSION_CALL_BLOCKED = true;
+
+            this.cache.set(
+                SESSION_CALL_BLOCKED_CACHE_KEY,
+                SESSION_CALL_BLOCKED,
+                SESSION_CALL_BLOCKED_TTL
+            );
+        }
+    }
+
+    /**
+     * Unblocks calls to get session
+     * @private
+     *
+     * @returns {void}
+     */
+    _unblockSessionCall(){
+        if (this._enableSessionCaching) {
+            this.cache.delete(SESSION_CALL_BLOCKED_CACHE_KEY);
+        }
     }
 
     /**
@@ -480,9 +537,15 @@ export class Identity extends EventEmitter {
      * @return {Promise<HasSessionSuccessResponse|HasSessionFailureResponse>}
      */
     hasSession() {
+        const isSessionCallBlocked = this._isSessionCallBlocked()
+        if (isSessionCallBlocked) {
+            return this._session;
+        }
+
         if (this._hasSessionInProgress) {
             return this._hasSessionInProgress;
         }
+
         const _postProcess = (sessionData) => {
             if (sessionData.error) {
                 throw new SDKError('HasSession failed', sessionData.error);
@@ -492,6 +555,14 @@ export class Identity extends EventEmitter {
             this._session = sessionData;
             return 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)
@@ -502,7 +573,7 @@ export class Identity extends EventEmitter {
             }
             let sessionData = null;
             try {
-                sessionData = await this._sessionService.get('/session');
+                sessionData = await this._sessionService.get('/v2/session');
             } catch (err) {
                 if (err && err.code === 400 && this._enableSessionCaching) {
                     const expiresIn = 1000 * (err.expiresIn || 300);
@@ -511,16 +582,33 @@ export class Identity extends EventEmitter {
                 throw err;
             }
 
-            if (sessionData && this._enableSessionCaching) {
-                const expiresIn = 1000 * (sessionData.expiresIn || 300);
-                this.cache.set(HAS_SESSION_CACHE_KEY, sessionData, expiresIn);
+            if (sessionData){
+                // for expiring session and safari browser do full page redirect to gain new session
+                if(_checkRedirectionNeed(sessionData)){
+                    this._blockSessionCall();
+
+                    await this.callbackBeforeRedirect();
+
+                    return this._sessionService.makeUrl(sessionData.redirectURL);
+                }
+
+                if (this._enableSessionCaching) {
+                    const expiresIn = 1000 * (sessionData.expiresIn || 300);
+                    this.cache.set(HAS_SESSION_CACHE_KEY, sessionData, expiresIn);
+                }
             }
+
             return _postProcess(sessionData);
         };
         this._hasSessionInProgress = _getSession()
             .then(
                 sessionData => {
                     this._hasSessionInProgress = false;
+
+                    if (isUrl(sessionData)) {
+                        return this.window.location.href = sessionData;
+                    }
+
                     return sessionData;
                 },
                 err => {
@@ -632,10 +720,10 @@ export class Identity extends EventEmitter {
      * meaning the same user's ID will differ between merchants.
      * Additionally, this identifier is bound to the external party provided as argument.
      *
-     * @description This function calls {@link Identity#hasSession} internally and thus has the side
-     * effect that it might perform an auto-login on the user
      * @param {string} externalParty
      * @param {string|null} optionalSuffix
+     * @description This function calls {@link Identity#hasSession} internally and thus has the side
+     * effect that it might perform an auto-login on the user
      * @throws {SDKError} If the `pairId` is missing in user session.
      * @throws {SDKError} If the `externalParty` is not defined
      * @return {Promise<string>} The merchant- and 3rd-party-specific `externalId`

package/src/version.js

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