@openobserve/browser-core 0.3.3 → 0.4.0-beta.1

package/src/domain/session/sessionStore.ts

@@ -1,248 +1,82 @@
-import { clearInterval, setInterval } from '../../tools/timer'
-import { Observable } from '../../tools/observable'
-import { ONE_SECOND, dateNow } from '../../tools/utils/timeUtils'
-import { throttle } from '../../tools/utils/functionUtils'
-import { generateUUID } from '../../tools/utils/stringUtils'
-import type { InitConfiguration, Configuration } from '../configuration'
+import type { Configuration } from '../configuration'
+import { isWorkerEnvironment } from '../../tools/globalObject'
 import { display } from '../../tools/display'
-import { selectCookieStrategy, initCookieStrategy } from './storeStrategies/sessionInCookie'
+import { SessionPersistence } from './sessionConstants'
 import type { SessionStoreStrategy, SessionStoreStrategyType } from './storeStrategies/sessionStoreStrategy'
-import type { SessionState } from './sessionState'
-import {
-  getExpiredSessionState,
-  isSessionInExpiredState,
-  isSessionInNotStartedState,
-  isSessionStarted,
-} from './sessionState'
-import { initLocalStorageStrategy, selectLocalStorageStrategy } from './storeStrategies/sessionInLocalStorage'
-import { processSessionStoreOperations } from './sessionStoreOperations'
-import { SESSION_NOT_TRACKED, SessionPersistence } from './sessionConstants'
-
-export interface SessionStore {
-  expandOrRenewSession: () => void
-  expandSession: () => void
-  getSession: () => SessionState
-  restartSession: () => void
-  renewObservable: Observable<void>
-  expireObservable: Observable<void>
-  sessionStateUpdateObservable: Observable<{ previousState: SessionState; newState: SessionState }>
-  expire: (hasConsent?: boolean) => void
-  stop: () => void
-  updateSessionState: (state: Partial<SessionState>) => void
-}
-
-/**
- * Every second, the storage will be polled to check for any change that can occur
- * to the session state in another browser tab, or another window.
- * This value has been determined from our previous cookie-only implementation.
- */
-export const STORAGE_POLL_DELAY = ONE_SECOND
+import { selectCookieStrategy, initCookieStrategy } from './storeStrategies/sessionInCookie'
+import { selectLocalStorageStrategy, initLocalStorageStrategy } from './storeStrategies/sessionInLocalStorage'
+import { selectMemorySessionStoreStrategy, initMemorySessionStoreStrategy } from './storeStrategies/sessionInMemory'
 
 /**
  * Selects the correct session store strategy type based on the configuration and storage
- * availability.
+ * availability. When an array is provided, tries each persistence type in order until one
+ * successfully initializes.
  */
-export function selectSessionStoreStrategyType(
-  initConfiguration: InitConfiguration
-): SessionStoreStrategyType | undefined {
-  switch (initConfiguration.sessionPersistence) {
-    case SessionPersistence.COOKIE:
-      return selectCookieStrategy(initConfiguration)
-
-    case SessionPersistence.LOCAL_STORAGE:
-      return selectLocalStorageStrategy()
+export async function selectSessionStoreStrategyType(
+  configuration: Configuration
+): Promise<SessionStoreStrategyType | undefined> {
+  const persistenceList = normalizePersistenceList(configuration.sessionPersistence)
 
-    case undefined: {
-      let sessionStoreStrategyType = selectCookieStrategy(initConfiguration)
-      if (!sessionStoreStrategyType && initConfiguration.allowFallbackToLocalStorage) {
-        sessionStoreStrategyType = selectLocalStorageStrategy()
-      }
-      return sessionStoreStrategyType
+  for (const persistence of persistenceList) {
+    const strategyType = await selectStrategyForPersistence(persistence, configuration)
+    if (strategyType !== undefined) {
+      return strategyType
     }
-
-    default:
-      display.error(`Invalid session persistence '${String(initConfiguration.sessionPersistence)}'`)
   }
-}
 
-export function getSessionStoreStrategy(
-  sessionStoreStrategyType: SessionStoreStrategyType,
-  configuration: Configuration
-) {
-  return sessionStoreStrategyType.type === SessionPersistence.COOKIE
-    ? initCookieStrategy(configuration, sessionStoreStrategyType.cookieOptions)
-    : initLocalStorageStrategy(configuration)
+  return undefined
 }
 
-/**
- * Different session concepts:
- * - tracked, the session has an id and is updated along the user navigation
- * - not tracked, the session does not have an id but it is updated along the user navigation
- * - inactive, no session in store or session expired, waiting for a renew session
- */
-export function startSessionStore<TrackingType extends string>(
-  sessionStoreStrategyType: SessionStoreStrategyType,
-  configuration: Configuration,
-  productKey: string,
-  computeTrackingType: (rawTrackingType?: string) => TrackingType,
-  sessionStoreStrategy: SessionStoreStrategy = getSessionStoreStrategy(sessionStoreStrategyType, configuration)
-): SessionStore {
-  const renewObservable = new Observable<void>()
-  const expireObservable = new Observable<void>()
-  const sessionStateUpdateObservable = new Observable<{ previousState: SessionState; newState: SessionState }>()
-
-  const watchSessionTimeoutId = setInterval(watchSession, STORAGE_POLL_DELAY)
-  let sessionCache: SessionState
-
-  startSession()
-
-  const { throttled: throttledExpandOrRenewSession, cancel: cancelExpandOrRenewSession } = throttle(() => {
-    processSessionStoreOperations(
-      {
-        process: (sessionState) => {
-          if (isSessionInNotStartedState(sessionState)) {
-            return
-          }
-
-          const synchronizedSession = synchronizeSession(sessionState)
-          expandOrRenewSessionState(synchronizedSession)
-          return synchronizedSession
-        },
-        after: (sessionState) => {
-          if (isSessionStarted(sessionState) && !hasSessionInCache()) {
-            renewSessionInCache(sessionState)
-          }
-          sessionCache = sessionState
-        },
-      },
-      sessionStoreStrategy
-    )
-  }, STORAGE_POLL_DELAY)
-
-  function expandSession() {
-    processSessionStoreOperations(
-      {
-        process: (sessionState) => (hasSessionInCache() ? synchronizeSession(sessionState) : undefined),
-      },
-      sessionStoreStrategy
-    )
-  }
-
-  /**
-   * allows two behaviors:
-   * - if the session is active, synchronize the session cache without updating the session store
-   * - if the session is not active, clear the session store and expire the session cache
-   */
-  function watchSession() {
-    const sessionState = sessionStoreStrategy.retrieveSession()
-
-    if (isSessionInExpiredState(sessionState)) {
-      processSessionStoreOperations(
-        {
-          process: (sessionState: SessionState) =>
-            isSessionInExpiredState(sessionState) ? getExpiredSessionState(sessionState, configuration) : undefined,
-          after: synchronizeSession,
-        },
-        sessionStoreStrategy
-      )
-    } else {
-      synchronizeSession(sessionState)
-    }
-  }
-
-  function synchronizeSession(sessionState: SessionState) {
-    if (isSessionInExpiredState(sessionState)) {
-      sessionState = getExpiredSessionState(sessionState, configuration)
-    }
-    if (hasSessionInCache()) {
-      if (isSessionInCacheOutdated(sessionState)) {
-        expireSessionInCache()
-      } else {
-        sessionStateUpdateObservable.notify({ previousState: sessionCache, newState: sessionState })
-        sessionCache = sessionState
-      }
-    }
-    return sessionState
+function normalizePersistenceList(
+  sessionPersistence: SessionPersistence | SessionPersistence[] | undefined
+): SessionPersistence[] {
+  if (Array.isArray(sessionPersistence)) {
+    return sessionPersistence
   }
-
-  function startSession() {
-    processSessionStoreOperations(
-      {
-        process: (sessionState) => {
-          if (isSessionInNotStartedState(sessionState)) {
-            sessionState.anonymousId = generateUUID()
-            return getExpiredSessionState(sessionState, configuration)
-          }
-        },
-        after: (sessionState) => {
-          sessionCache = sessionState
-        },
-      },
-      sessionStoreStrategy
-    )
+  if (sessionPersistence !== undefined) {
+    return [sessionPersistence]
   }
 
-  function expandOrRenewSessionState(sessionState: SessionState) {
-    if (isSessionInNotStartedState(sessionState)) {
-      return false
-    }
-
-    const trackingType = computeTrackingType(sessionState[productKey])
-    sessionState[productKey] = trackingType
-    delete sessionState.isExpired
-    if (trackingType !== SESSION_NOT_TRACKED && !sessionState.id) {
-      sessionState.id = generateUUID()
-      sessionState.created = String(dateNow())
-    }
+  // In worker environments, default to memory since cookie and localStorage are not available
+  // TODO: make it work when we start using Cookie Store API
+  // @see https://developer.mozilla.org/en-US/docs/Web/API/CookieStore
+  if (isWorkerEnvironment) {
+    return [SessionPersistence.MEMORY]
   }
 
-  function hasSessionInCache() {
-    return sessionCache?.[productKey] !== undefined
-  }
+  return [SessionPersistence.COOKIE]
+}
 
-  function isSessionInCacheOutdated(sessionState: SessionState) {
-    return sessionCache.id !== sessionState.id || sessionCache[productKey] !== sessionState[productKey]
-  }
+function selectStrategyForPersistence(
+  persistence: SessionPersistence,
+  configuration: Configuration
+): Promise<SessionStoreStrategyType | undefined> | SessionStoreStrategyType | undefined {
+  switch (persistence) {
+    case SessionPersistence.COOKIE:
+      return selectCookieStrategy(configuration)
 
-  function expireSessionInCache() {
-    sessionCache = getExpiredSessionState(sessionCache, configuration)
-    expireObservable.notify()
-  }
+    case SessionPersistence.LOCAL_STORAGE:
+      return selectLocalStorageStrategy()
 
-  function renewSessionInCache(sessionState: SessionState) {
-    sessionCache = sessionState
-    renewObservable.notify()
-  }
+    case SessionPersistence.MEMORY:
+      return selectMemorySessionStoreStrategy()
 
-  function updateSessionState(partialSessionState: Partial<SessionState>) {
-    processSessionStoreOperations(
-      {
-        process: (sessionState) => ({ ...sessionState, ...partialSessionState }),
-        after: synchronizeSession,
-      },
-      sessionStoreStrategy
-    )
+    default:
+      display.error(`Invalid session persistence '${String(persistence)}'`)
+      return undefined
   }
+}
 
-  return {
-    expandOrRenewSession: throttledExpandOrRenewSession,
-    expandSession,
-    getSession: () => sessionCache,
-    renewObservable,
-    expireObservable,
-    sessionStateUpdateObservable,
-    restartSession: startSession,
-    expire: (hasConsent?: boolean) => {
-      cancelExpandOrRenewSession()
-      if (hasConsent === false && sessionCache) {
-        delete sessionCache.anonymousId
-      }
-      sessionStoreStrategy.expireSession(sessionCache)
-      synchronizeSession(getExpiredSessionState(sessionCache, configuration))
-    },
-    stop: () => {
-      clearInterval(watchSessionTimeoutId)
-    },
-    updateSessionState,
+export function getSessionStoreStrategy(
+  sessionStoreStrategyType: SessionStoreStrategyType,
+  configuration: Configuration
+): SessionStoreStrategy {
+  switch (sessionStoreStrategyType.type) {
+    case SessionPersistence.COOKIE:
+      return initCookieStrategy(sessionStoreStrategyType, configuration)
+    case SessionPersistence.LOCAL_STORAGE:
+      return initLocalStorageStrategy()
+    case SessionPersistence.MEMORY:
+      return initMemorySessionStoreStrategy()
   }
 }

package/src/domain/session/storeStrategies/sessionInCookie.ts

@@ -1,109 +1,149 @@
 import { isEmptyObject } from '../../../tools/utils/objectUtils'
-import { isChromium } from '../../../tools/utils/browserDetection'
 import type { CookieOptions } from '../../../browser/cookie'
-import { getCurrentSite, areCookiesAuthorized, getCookies, setCookie, getCookie } from '../../../browser/cookie'
-import type { InitConfiguration, Configuration } from '../../configuration'
-import { tryOldCookiesMigration } from '../oldCookiesMigration'
-import {
-  SESSION_COOKIE_EXPIRATION_DELAY,
-  SESSION_EXPIRATION_DELAY,
-  SESSION_TIME_OUT_DELAY,
-  SessionPersistence,
-} from '../sessionConstants'
+import { getCookies } from '../../../browser/cookie'
+import type { Configuration } from '../../configuration'
+import { SESSION_COOKIE_EXPIRATION_DELAY, SESSION_TIME_OUT_DELAY, SessionPersistence } from '../sessionConstants'
 import type { SessionState } from '../sessionState'
-import { toSessionString, toSessionState, getExpiredSessionState } from '../sessionState'
-import type { SessionStoreStrategy, SessionStoreStrategyType } from './sessionStoreStrategy'
-import { SESSION_STORE_KEY } from './sessionStoreStrategy'
+import { toSessionString, toSessionState } from '../sessionState'
+import { Observable } from '../../../tools/observable'
+import { mockable } from '../../../tools/mockable'
+import { monitorError } from '../../../tools/monitor'
+import type { CookieAccess } from '../../../browser/cookieAccess'
+import {
+  areCookiesAuthorized,
+  createCookieStoreAccess,
+  createDocumentCookieAccess,
+  isCookieStoreSupported,
+} from '../../../browser/cookieAccess'
+import { CookieApi, LEGACY_SESSION_STORE_KEY, SESSION_STORE_KEY } from './sessionStoreStrategy'
+import type {
+  SessionStoreStrategy,
+  SessionStoreStrategyType,
+  CookieSessionStoreStrategyType,
+  SessionStateOperation,
+} from './sessionStoreStrategy'
 
 const SESSION_COOKIE_VERSION = 0
 
-export function selectCookieStrategy(initConfiguration: InitConfiguration): SessionStoreStrategyType | undefined {
-  const cookieOptions = buildCookieOptions(initConfiguration)
-  return cookieOptions && areCookiesAuthorized(cookieOptions)
-    ? { type: SessionPersistence.COOKIE, cookieOptions }
-    : undefined
-}
+export async function selectCookieStrategy(
+  configuration: Configuration
+): Promise<SessionStoreStrategyType | undefined> {
+  const { cookieOptions } = configuration
+  if (!cookieOptions) {
+    return undefined
+  }
 
-export function initCookieStrategy(configuration: Configuration, cookieOptions: CookieOptions): SessionStoreStrategy {
-  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: (sessionState: SessionState) =>
-      storeSessionCookie(cookieOptions, configuration, sessionState, SESSION_EXPIRATION_DELAY),
-    retrieveSession: () => retrieveSessionCookie(cookieOptions, configuration),
-    expireSession: (sessionState: SessionState) =>
-      storeSessionCookie(
-        cookieOptions,
-        configuration,
-        getExpiredSessionState(sessionState, configuration),
-        SESSION_TIME_OUT_DELAY
-      ),
+  if (isCookieStoreSupported() && (await areCookiesAuthorized(createCookieStoreAccess, cookieOptions))) {
+    return { type: SessionPersistence.COOKIE, cookieOptions, cookieApi: CookieApi.COOKIE_STORE }
   }
 
-  tryOldCookiesMigration(cookieStore)
+  if (await areCookiesAuthorized(createDocumentCookieAccess, cookieOptions)) {
+    return { type: SessionPersistence.COOKIE, cookieOptions, cookieApi: CookieApi.DOCUMENT_COOKIE }
+  }
 
-  return cookieStore
+  return undefined
 }
 
-function storeSessionCookie(
-  options: CookieOptions,
-  configuration: Configuration,
-  sessionState: SessionState,
-  defaultTimeout: number
-) {
-  let sessionStateString = toSessionString(sessionState)
-
-  if (configuration.betaEncodeCookieOptions) {
-    sessionStateString = toSessionString({
-      ...sessionState,
-      // deleting a cookie is writing a new cookie with an empty value
-      // we don't want to store the cookie options in this case otherwise the cookie will not be deleted
-      ...(!isEmptyObject(sessionState) ? { c: encodeCookieOptions(options) } : {}),
+// Promise chain serializes calls when Web Locks are unavailable
+let pendingChain: Promise<void> | undefined
+
+export function initCookieStrategy(
+  sessionStoreStrategyType: CookieSessionStoreStrategyType,
+  configuration: Configuration
+): SessionStoreStrategy {
+  const { cookieOptions, cookieApi } = sessionStoreStrategyType
+  const sessionObservable = new Observable<SessionState>()
+  const trackAnonymousUser = !!configuration.trackAnonymousUser
+  const opts = encodeCookieOptions(cookieOptions)
+  const cookieAccess = mockable(createCookieAccess)(cookieApi, cookieOptions)
+  let isFirstCall = true
+
+  cookieAccess.observable.subscribe(() => {
+    cookieAccess
+      .getAll()
+      .then((cookieValues) => {
+        sessionObservable.notify(findMatchingSessionState(cookieValues, opts))
+      })
+      .catch((error) => monitorError(new Error(`Error while reading session cookies on change: ${error}`)))
+  })
+
+  function applyAndWrite(fn: (state: SessionState) => SessionState) {
+    return cookieAccess.getAllAndSet((cookieValues) => {
+      let currentState = findMatchingSessionState(cookieValues, opts)
+
+      if (isFirstCall && isEmptyObject(currentState)) {
+        currentState = findMatchingSessionState(getCookies(LEGACY_SESSION_STORE_KEY), opts)
+      }
+      isFirstCall = false
+
+      const newState = fn(currentState)
+      const sessionString = buildSessionString(newState, cookieOptions)
+      const expireDelay = trackAnonymousUser ? SESSION_COOKIE_EXPIRATION_DELAY : SESSION_TIME_OUT_DELAY
+
+      return { value: sessionString, expireDelay }
     })
   }
 
-  setCookie(
-    SESSION_STORE_KEY,
-    sessionStateString,
-    configuration.trackAnonymousUser ? SESSION_COOKIE_EXPIRATION_DELAY : defaultTimeout,
-    options
-  )
+  return {
+    async setSessionState(
+      fn: (sessionState: SessionState) => SessionState,
+      _operation: SessionStateOperation
+    ): Promise<void> {
+      if (typeof navigator !== 'undefined' && navigator.locks) {
+        await navigator.locks
+          .request(SESSION_STORE_KEY, () => applyAndWrite(fn))
+          .catch((error: unknown) => {
+            if (isContextGoingAwayError(error)) {
+              return
+            }
+            throw error
+          })
+      } else {
+        pendingChain = (pendingChain ?? Promise.resolve()).then(() => applyAndWrite(fn))
+        await pendingChain
+      }
+    },
+    sessionObservable,
+  }
 }
 
-/**
- * Retrieve the session state from the cookie that was set with the same cookie options
- * If there is no match, return the first cookie, because that's how `getCookie()` works
- */
-export function retrieveSessionCookie(cookieOptions: CookieOptions, configuration: Configuration): SessionState {
-  if (configuration.betaEncodeCookieOptions) {
-    return retrieveSessionCookieFromEncodedCookie(cookieOptions)
+// Thrown when the browsing context tears down mid-lock-request.
+//   - "AbortError: Promise was rejected because the browsing context is going away" (Webkit)
+//   - "Error: Failed to execute 'request' on 'LockManager': The provided callback is no longer runnable." (Chromium)
+function isContextGoingAwayError(error: unknown): boolean {
+  if (!(error instanceof Error)) {
+    return false
   }
-
-  const sessionString = getCookie(SESSION_STORE_KEY)
-  const sessionState = toSessionState(sessionString)
-  return sessionState
+  return error.name === 'AbortError' || error.message.includes('no longer runnable')
 }
 
-export function buildCookieOptions(initConfiguration: InitConfiguration): CookieOptions | undefined {
-  const cookieOptions: CookieOptions = {}
+export function createCookieAccess(cookieApi: CookieApi, cookieOptions: CookieOptions): CookieAccess {
+  return cookieApi === CookieApi.COOKIE_STORE
+    ? createCookieStoreAccess(SESSION_STORE_KEY, cookieOptions)
+    : createDocumentCookieAccess(SESSION_STORE_KEY, cookieOptions)
+}
 
-  cookieOptions.secure =
-    !!initConfiguration.useSecureSessionCookie || !!initConfiguration.usePartitionedCrossSiteSessionCookie
-  cookieOptions.crossSite = !!initConfiguration.usePartitionedCrossSiteSessionCookie
-  cookieOptions.partitioned = !!initConfiguration.usePartitionedCrossSiteSessionCookie
+function findMatchingSessionState(items: string[], opts: string): SessionState {
+  let sessionState: SessionState | undefined
 
-  if (initConfiguration.trackSessionAcrossSubdomains) {
-    const currentSite = getCurrentSite()
-    if (!currentSite) {
-      return
+  // reverse the cookies so that if there is no match, the cookie returned is the first one
+  for (const item of items.slice().reverse()) {
+    sessionState = toSessionState(item)
+    if (sessionState.c === opts) {
+      break
     }
-    cookieOptions.domain = currentSite
   }
 
-  return cookieOptions
+  // remove the cookie options from the session state as this is not part of the session state
+  delete sessionState?.c
+
+  return sessionState ?? {}
+}
+
+function buildSessionString(sessionState: SessionState, cookieOptions: CookieOptions): string {
+  return toSessionString(
+    isEmptyObject(sessionState) ? sessionState : { ...sessionState, c: encodeCookieOptions(cookieOptions) }
+  )
 }
 
 function encodeCookieOptions(cookieOptions: CookieOptions): string {
@@ -118,29 +158,3 @@ function encodeCookieOptions(cookieOptions: CookieOptions): string {
 
   return byte.toString(16) // Convert to hex string
 }
-
-/**
- * Retrieve the session state from the cookie that was set with the same cookie options.
- * If there is no match, fallback to the first cookie, (because that's how `getCookie()` works)
- * and this allows to keep the current session id when we release this feature.
- */
-function retrieveSessionCookieFromEncodedCookie(cookieOptions: CookieOptions): SessionState {
-  const cookies = getCookies(SESSION_STORE_KEY)
-  const opts = encodeCookieOptions(cookieOptions)
-
-  let sessionState: SessionState | undefined
-
-  // reverse the cookies so that if there is no match, the cookie returned is the first one
-  for (const cookie of cookies.reverse()) {
-    sessionState = toSessionState(cookie)
-
-    if (sessionState.c === opts) {
-      break
-    }
-  }
-
-  // remove the cookie options from the session state as this is not part of the session state
-  delete sessionState?.c
-
-  return sessionState ?? {}
-}

package/src/domain/session/storeStrategies/sessionInLocalStorage.ts

@@ -1,10 +1,11 @@
 import { generateUUID } from '../../../tools/utils/stringUtils'
-import type { Configuration } from '../../configuration'
+import { Observable } from '../../../tools/observable'
+import { addEventListener } from '../../../browser/addEventListener'
 import { SessionPersistence } from '../sessionConstants'
 import type { SessionState } from '../sessionState'
-import { toSessionString, toSessionState, getExpiredSessionState } from '../sessionState'
-import type { SessionStoreStrategy, SessionStoreStrategyType } from './sessionStoreStrategy'
-import { SESSION_STORE_KEY } from './sessionStoreStrategy'
+import { isSessionInNotStartedState, toSessionString, toSessionState } from '../sessionState'
+import type { SessionStateOperation, SessionStoreStrategy, SessionStoreStrategyType } from './sessionStoreStrategy'
+import { SESSION_STORE_KEY, LEGACY_SESSION_STORE_KEY } from './sessionStoreStrategy'
 
 const LOCAL_STORAGE_TEST_KEY = '_oo_test_'
 
@@ -21,24 +22,35 @@ export function selectLocalStorageStrategy(): SessionStoreStrategyType | undefin
   }
 }
 
-export function initLocalStorageStrategy(configuration: Configuration): SessionStoreStrategy {
-  return {
-    isLockEnabled: false,
-    persistSession: persistInLocalStorage,
-    retrieveSession: retrieveSessionFromLocalStorage,
-    expireSession: (sessionState: SessionState) => expireSessionFromLocalStorage(sessionState, configuration),
-  }
-}
+export function initLocalStorageStrategy(): SessionStoreStrategy {
+  const sessionObservable = new Observable<SessionState>(
+    (observable) =>
+      addEventListener(window, 'storage', (event) => {
+        if (event.key === SESSION_STORE_KEY && event.storageArea === localStorage) {
+          observable.notify(toSessionState(event.newValue))
+        }
+      }).stop
+  )
 
-function persistInLocalStorage(sessionState: SessionState) {
-  localStorage.setItem(SESSION_STORE_KEY, toSessionString(sessionState))
-}
+  let isFirstCall = true
 
-export function retrieveSessionFromLocalStorage(): SessionState {
-  const sessionString = localStorage.getItem(SESSION_STORE_KEY)
-  return toSessionState(sessionString)
-}
+  return {
+    async setSessionState(
+      fn: (sessionState: SessionState) => SessionState,
+      _operation: SessionStateOperation
+    ): Promise<void> {
+      let currentState = toSessionState(localStorage.getItem(SESSION_STORE_KEY))
 
-function expireSessionFromLocalStorage(previousSessionState: SessionState, configuration: Configuration) {
-  persistInLocalStorage(getExpiredSessionState(previousSessionState, configuration))
+      if (isFirstCall && isSessionInNotStartedState(currentState)) {
+        currentState = toSessionState(localStorage.getItem(LEGACY_SESSION_STORE_KEY))
+      }
+      isFirstCall = false
+
+      const newState = fn(currentState)
+      localStorage.setItem(SESSION_STORE_KEY, toSessionString(newState))
+      await Promise.resolve()
+      sessionObservable.notify(newState)
+    },
+    sessionObservable,
+  }
 }