@cloudcare/browser-core 3.2.4 → 3.2.7

package/src/session/sessionConstants.js

@@ -1,3 +1,4 @@
 import { ONE_HOUR, ONE_MINUTE } from '../helper/tools'
 export var SESSION_TIME_OUT_DELAY = 4 * ONE_HOUR
 export var SESSION_EXPIRATION_DELAY = 15 * ONE_MINUTE
+export var SESSION_STORE_KEY = '_gc_s'

package/src/session/sessionInCookie.js

@@ -0,0 +1,87 @@
+import { isChromium } from '../helper/tools'
+import {
+  getCurrentSite,
+  areCookiesAuthorized,
+  getCookie,
+  setCookie
+} from '../browser/cookie'
+import {
+  SESSION_EXPIRATION_DELAY,
+  SESSION_TIME_OUT_DELAY,
+  SESSION_STORE_KEY
+} from './sessionConstants'
+import {
+  toSessionString,
+  toSessionState,
+  getExpiredSessionState
+} from './sessionState'
+
+export function selectCookieStrategy(initConfiguration) {
+  const cookieOptions = buildCookieOptions(initConfiguration)
+  return areCookiesAuthorized(cookieOptions)
+    ? { type: 'Cookie', cookieOptions }
+    : undefined
+}
+
+export function initCookieStrategy(cookieOptions) {
+  const cookieStore = {
+    /**
+     * Lock strategy allows mitigating issues due to concurrent access to cookie.
+     * This issue concerns only chromium browsers and enabling this on firefox increases cookie write failures.
+     */
+    isLockEnabled: isChromium(),
+    persistSession: persistSessionCookie(cookieOptions),
+    retrieveSession: retrieveSessionCookie(cookieOptions),
+    expireSession: function () {
+      return expireSessionCookie(cookieOptions)
+    }
+  }
+  return cookieStore
+}
+
+function persistSessionCookie(options) {
+  return function (session) {
+    setCookie(
+      SESSION_STORE_KEY,
+      toSessionString(session),
+      SESSION_EXPIRATION_DELAY,
+      options
+    )
+  }
+}
+
+function expireSessionCookie(options) {
+  setCookie(
+    SESSION_STORE_KEY,
+    toSessionString(getExpiredSessionState()),
+    SESSION_TIME_OUT_DELAY,
+    options
+  )
+}
+
+function retrieveSessionCookie(options) {
+  return function () {
+    var sessionString = getCookie(SESSION_STORE_KEY, options)
+    return toSessionState(sessionString)
+  }
+}
+
+export function buildCookieOptions(initConfiguration) {
+  const cookieOptions = {}
+
+  cookieOptions.secure =
+    !!initConfiguration.useSecureSessionCookie ||
+    !!initConfiguration.usePartitionedCrossSiteSessionCookie ||
+    !!initConfiguration.useCrossSiteSessionCookie
+  cookieOptions.crossSite =
+    !!initConfiguration.usePartitionedCrossSiteSessionCookie ||
+    !!initConfiguration.useCrossSiteSessionCookie
+  cookieOptions.partitioned =
+    !!initConfiguration.usePartitionedCrossSiteSessionCookie
+
+  if (initConfiguration.trackSessionAcrossSubdomains) {
+    cookieOptions.domain = getCurrentSite()
+  }
+
+  return cookieOptions
+}

package/src/session/sessionInLocalStorage.js

@@ -0,0 +1,45 @@
+import { UUID } from '../helper/tools'
+import {
+  toSessionString,
+  toSessionState,
+  getExpiredSessionState
+} from './sessionState'
+
+import { SESSION_STORE_KEY } from './sessionConstants'
+
+const LOCAL_STORAGE_TEST_KEY = '_gc_test_'
+
+export function selectLocalStorageStrategy() {
+  try {
+    const id = UUID()
+    const testKey = `${LOCAL_STORAGE_TEST_KEY}${id}`
+    localStorage.setItem(testKey, id)
+    const retrievedId = localStorage.getItem(testKey)
+    localStorage.removeItem(testKey)
+    return id === retrievedId ? { type: 'LocalStorage' } : undefined
+  } catch (e) {
+    return undefined
+  }
+}
+
+export function initLocalStorageStrategy() {
+  return {
+    isLockEnabled: false,
+    persistSession: persistInLocalStorage,
+    retrieveSession: retrieveSessionFromLocalStorage,
+    expireSession: expireSessionFromLocalStorage
+  }
+}
+
+function persistInLocalStorage(sessionState) {
+  localStorage.setItem(SESSION_STORE_KEY, toSessionString(sessionState))
+}
+
+function retrieveSessionFromLocalStorage() {
+  const sessionString = localStorage.getItem(SESSION_STORE_KEY)
+  return toSessionState(sessionString)
+}
+
+function expireSessionFromLocalStorage() {
+  persistInLocalStorage(getExpiredSessionState())
+}

package/src/session/sessionManagement.js

@@ -1,31 +1,37 @@
-import { relativeNow, clocksOrigin, ONE_MINUTE, each } from '../helper/tools'
-import {
-  addEventListeners,
-  addEventListener
-} from '../browser/addEventListener'
+import { Observable } from '../helper/observable'
 import { createValueHistory } from '../helper/valueHistory'
-import { startSessionStore } from './sessionStore'
-import { SESSION_TIME_OUT_DELAY } from './sessionConstants'
+import { relativeNow, clocksOrigin, ONE_MINUTE } from '../helper/tools'
 import { DOM_EVENT } from '../helper/enums'
+import {
+  addEventListener,
+  addEventListeners
+} from '../browser/addEventListener'
 import { clearInterval, setInterval } from '../helper/timer'
-import { Observable } from '../helper/observable'
-export var VISIBILITY_CHECK_DELAY = ONE_MINUTE
-var SESSION_CONTEXT_TIMEOUT_DELAY = SESSION_TIME_OUT_DELAY
-var stopCallbacks = []
+import { SESSION_TIME_OUT_DELAY } from './sessionConstants'
+import { startSessionStore } from './sessionStore'
 
-export var startSessionManager = function (
-  options,
+export const VISIBILITY_CHECK_DELAY = ONE_MINUTE
+const SESSION_CONTEXT_TIMEOUT_DELAY = SESSION_TIME_OUT_DELAY
+let stopCallbacks = []
+
+export function startSessionManager(
+  configuration,
   productKey,
   computeSessionState
 ) {
-  var renewObservable = new Observable()
-  var expireObservable = new Observable()
-  var sessionStore = startSessionStore(options, productKey, computeSessionState)
+  const renewObservable = new Observable()
+  const expireObservable = new Observable()
+
+  const sessionStore = startSessionStore(
+    configuration.sessionStoreStrategyType,
+    productKey,
+    computeSessionState
+  )
   stopCallbacks.push(function () {
     return sessionStore.stop()
   })
 
-  var sessionContextHistory = createValueHistory({
+  const sessionContextHistory = createValueHistory({
     expireDelay: SESSION_CONTEXT_TIMEOUT_DELAY
   })
   stopCallbacks.push(function () {
@@ -41,18 +47,20 @@ export var startSessionManager = function (
     sessionContextHistory.closeActive(relativeNow())
   })
 
+  // We expand/renew session unconditionally as tracking consent is always granted when the session
+  // manager is started.
   sessionStore.expandOrRenewSession()
   sessionContextHistory.add(buildSessionContext(), clocksOrigin().relative)
 
   trackActivity(function () {
-    return sessionStore.expandOrRenewSession()
+    sessionStore.expandOrRenewSession()
   })
   trackVisibility(function () {
     return sessionStore.expandSession()
   })
-  //   trackResume(function () {
-  //     return sessionStore.expandSession()
-  //   })
+  trackResume(function () {
+    sessionStore.restartSession()
+  })
 
   function buildSessionContext() {
     return {
@@ -62,24 +70,26 @@ export var startSessionManager = function (
   }
 
   return {
-    findActiveSession: function (startTime) {
-      return sessionContextHistory.find(startTime)
+    findSession: function (startTime, options) {
+      return sessionContextHistory.find(startTime, options)
     },
-    renewObservable: renewObservable,
-    expireObservable: expireObservable,
-    expire: sessionStore.expire
+    renewObservable,
+    expireObservable,
+    sessionStateUpdateObservable: sessionStore.sessionStateUpdateObservable,
+    expire: sessionStore.expire,
+    updateSessionState: sessionStore.updateSessionState
   }
 }
 
 export function stopSessionManager() {
-  each(stopCallbacks, function (e) {
-    return e()
+  stopCallbacks.forEach(function (e) {
+    e()
   })
   stopCallbacks = []
 }
 
 function trackActivity(expandOrRenewSession) {
-  var _addEventListeners = addEventListeners(
+  const { stop } = addEventListeners(
     window,
     [
       DOM_EVENT.CLICK,
@@ -90,23 +100,24 @@ function trackActivity(expandOrRenewSession) {
     expandOrRenewSession,
     { capture: true, passive: true }
   )
-  stopCallbacks.push(_addEventListeners.stop)
+  stopCallbacks.push(stop)
 }
 
 function trackVisibility(expandSession) {
-  var expandSessionWhenVisible = function () {
+  const expandSessionWhenVisible = function () {
     if (document.visibilityState === 'visible') {
       expandSession()
     }
   }
-  var _addEventListener = addEventListener(
+
+  const { stop } = addEventListener(
     document,
     DOM_EVENT.VISIBILITY_CHANGE,
     expandSessionWhenVisible
   )
-  stopCallbacks.push(_addEventListener.stop)
+  stopCallbacks.push(stop)
 
-  var visibilityCheckInterval = setInterval(
+  const visibilityCheckInterval = setInterval(
     expandSessionWhenVisible,
     VISIBILITY_CHECK_DELAY
   )
@@ -114,9 +125,10 @@ function trackVisibility(expandSession) {
     clearInterval(visibilityCheckInterval)
   })
 }
+
 function trackResume(cb) {
-  var _addEventListener = addEventListener(window, DOM_EVENT.RESUME, cb, {
+  const { stop } = addEventListener(window, DOM_EVENT.RESUME, cb, {
     capture: true
   })
-  stopCallbacks.push(_addEventListener.stop)
+  stopCallbacks.push(stop)
 }

package/src/session/sessionState.js

@@ -0,0 +1,72 @@
+import { isEmptyObject, objectEntries, dateNow, map } from '../helper/tools'
+import {
+  SESSION_EXPIRATION_DELAY,
+  SESSION_TIME_OUT_DELAY
+} from './sessionConstants'
+
+const SESSION_ENTRY_REGEXP = /^([a-zA-Z]+)=([a-z0-9-]+)$/
+const SESSION_ENTRY_SEPARATOR = '&'
+
+export const EXPIRED = '1'
+
+export function getExpiredSessionState() {
+  return {
+    isExpired: EXPIRED
+  }
+}
+
+export function isSessionInNotStartedState(session) {
+  return isEmptyObject(session)
+}
+
+export function isSessionStarted(session) {
+  return !isSessionInNotStartedState(session)
+}
+
+export function isSessionInExpiredState(session) {
+  return session.isExpired !== undefined || !isActiveSession(session)
+}
+
+// An active session is a session in either `Tracked` or `NotTracked` state
+function isActiveSession(sessionState) {
+  // created and expire can be undefined for versions which was not storing them
+  // these checks could be removed when older versions will not be available/live anymore
+  return (
+    (sessionState.created === undefined ||
+      dateNow() - Number(sessionState.created) < SESSION_TIME_OUT_DELAY) &&
+    (sessionState.expire === undefined ||
+      dateNow() < Number(sessionState.expire))
+  )
+}
+
+export function expandSessionState(session) {
+  session.expire = String(dateNow() + SESSION_EXPIRATION_DELAY)
+}
+
+export function toSessionString(session) {
+  return map(objectEntries(session), function (item) {
+    return item[0] + '=' + item[1]
+  }).join(SESSION_ENTRY_SEPARATOR)
+}
+
+export function toSessionState(sessionString) {
+  const session = {}
+  if (isValidSessionString(sessionString)) {
+    sessionString.split(SESSION_ENTRY_SEPARATOR).forEach(function (entry) {
+      const matches = SESSION_ENTRY_REGEXP.exec(entry)
+      if (matches !== null) {
+        const [, key, value] = matches
+        session[key] = value
+      }
+    })
+  }
+  return session
+}
+
+function isValidSessionString(sessionString) {
+  return (
+    !!sessionString &&
+    (sessionString.indexOf(SESSION_ENTRY_SEPARATOR) !== -1 ||
+      SESSION_ENTRY_REGEXP.test(sessionString))
+  )
+}