@kubesense/kubesense-browser-core 1.7.0 → 2.0.0-beta.0

package/src/domain/session/sessionState.ts

@@ -1,6 +1,8 @@
+import { dateNow } from '@kubesense/kubesense-js-core/time'
+import type { TimeStamp } from '@kubesense/kubesense-js-core/time'
 import { isEmptyObject } from '../../tools/utils/objectUtils'
 import { objectEntries } from '../../tools/utils/polyfills'
-import { dateNow } from '../../tools/utils/timeUtils'
+import { generateUUID } from '../../tools/utils/stringUtils'
 import type { Configuration } from '../configuration'
 import { SESSION_EXPIRATION_DELAY, SESSION_TIME_OUT_DELAY } from './sessionConstants'
 import { isValidSessionString, SESSION_ENTRY_REGEXP, SESSION_ENTRY_SEPARATOR } from './sessionStateValidation'
@@ -11,20 +13,39 @@ export interface SessionState {
   created?: string
   expire?: string
   isExpired?: typeof EXPIRED
+  anonymousId?: string
 
   [key: string]: string | undefined
 }
 
+export function getCreatedDate(state: SessionState): TimeStamp | undefined {
+  return state.created ? (Number(state.created) as TimeStamp) : undefined
+}
+
+export function getExpireDate(state: SessionState): TimeStamp | undefined {
+  const expireDate = state.expire && (Number(state.expire) as TimeStamp)
+  const createdDate = getCreatedDate(state)
+  if (expireDate && createdDate) {
+    return Math.min(expireDate, createdDate + SESSION_TIME_OUT_DELAY) as TimeStamp
+  }
+}
+
 export function getExpiredSessionState(
-  previousSessionState: SessionState | undefined,
+  // Kept for call-site symmetry with upstream: KubeSense regenerates the anonymous id rather than
+  // carrying the previous one forward, so the previous state is not read here.
+  _previousSessionState: { anonymousId?: string } | undefined,
   configuration: Configuration
 ): SessionState {
   const expiredSessionState: SessionState = {
     isExpired: EXPIRED,
   }
-  if (configuration.trackAnonymousUser && previousSessionState?.anonymousId) {
-    expiredSessionState.anonymousId = previousSessionState?.anonymousId
+  // KubeSense rotates the anonymous id with the session rather than carrying the previous one
+  // forward, so a device is not linkable across sessions. The id is still stable for the whole
+  // lifetime of a session, which is what anonymous-user attribution within a session needs.
+  if (configuration.trackAnonymousUser) {
+    expiredSessionState.anonymousId = generateUUID()
   }
+
   return expiredSessionState
 }
 
@@ -42,12 +63,8 @@ export function isSessionInExpiredState(session: SessionState) {
 
 // An active session is a session in either `Tracked` or `NotTracked` state
 function isActiveSession(sessionState: 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))
-  )
+  const expireDate = getExpireDate(sessionState)
+  return expireDate ? dateNow() < expireDate : false
 }
 
 export function expandSessionState(session: SessionState) {
@@ -81,3 +98,47 @@ export function toSessionState(sessionString: string | undefined | null) {
   }
   return session
 }
+
+export function initializeSession(state: SessionState, configuration: Configuration): SessionState {
+  if (isSessionInNotStartedState(state)) {
+    if (configuration.trackAnonymousUser) {
+      state.anonymousId = generateUUID()
+    }
+    return getExpiredSessionState(state, configuration)
+  }
+  return state
+}
+
+export function expandOrRenew(state: SessionState, configuration: Configuration): SessionState {
+  // prevent renewing if state is altered by a 3rd party (e.g. adblocker deleting the cookie)
+  if (isSessionInNotStartedState(state)) {
+    return state
+  }
+
+  let newState = state
+
+  if (isSessionInExpiredState(state)) {
+    newState = getExpiredSessionState(state, configuration)
+  }
+
+  if (!newState.id) {
+    newState.id = generateUUID()
+    newState.created = String(dateNow())
+  }
+  if (configuration.trackAnonymousUser && !newState.anonymousId) {
+    newState.anonymousId = generateUUID()
+  }
+
+  delete newState.isExpired
+  expandSessionState(newState)
+
+  return newState
+}
+
+export function expandOnly(state: SessionState): SessionState {
+  if (isSessionInExpiredState(state) || isSessionInNotStartedState(state) || !state.id) {
+    return state
+  }
+  expandSessionState(state)
+  return state
+}

package/src/domain/session/sessionStore.ts

@@ -1,250 +1,77 @@
-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 { isWorkerEnvironment } from '@kubesense/kubesense-js-core/util'
+import type { Configuration } from '../configuration'
 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()
-
-    case undefined: {
-      let sessionStoreStrategyType = selectCookieStrategy(initConfiguration)
-      if (!sessionStoreStrategyType && initConfiguration.allowFallbackToLocalStorage) {
-        sessionStoreStrategyType = selectLocalStorageStrategy()
-      }
-      return sessionStoreStrategyType
-    }
-
-    default:
-      display.error(`Invalid session persistence '${String(initConfiguration.sessionPersistence)}'`)
-  }
-}
-
-export function getSessionStoreStrategy(
-  sessionStoreStrategyType: SessionStoreStrategyType,
+export async function selectSessionStoreStrategyType(
   configuration: Configuration
-) {
-  return sessionStoreStrategyType.type === SessionPersistence.COOKIE
-    ? initCookieStrategy(configuration, sessionStoreStrategyType.cookieOptions)
-    : initLocalStorageStrategy(configuration)
-}
-
-/**
- * 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
-          }
+): Promise<SessionStoreStrategyType | undefined> {
+  const persistenceList = normalizePersistenceList(configuration.sessionPersistence)
 
-          const synchronizedSession = synchronizeSession(sessionState)
-          expandOrRenewSessionState(synchronizedSession)
-          return synchronizedSession
-        },
-        after: (sessionState) => {
-          if (isSessionStarted(sessionState) && !hasSessionInCache()) {
-            renewSessionInCache(sessionState)
-          }
-          sessionCache = sessionState
-        },
-      },
-      sessionStoreStrategy
-    )
-  }, STORAGE_POLL_DELAY)
-
-  function expandSession() {
-    const sessionState = sessionStoreStrategy.retrieveSession()
-
-    if (isSessionInExpiredState(sessionState)) {
-      processSessionStoreOperations(
-        {
-          process: (sessionState: SessionState) =>
-            isSessionInExpiredState(sessionState) ? getExpiredSessionState(sessionState, configuration) : undefined,
-          after: synchronizeSession,
-        },
-        sessionStoreStrategy
-      )
-    } else {
-      synchronizeSession(sessionState)
+  for (const persistence of persistenceList) {
+    const strategyType = await selectStrategyForPersistence(persistence, configuration)
+    if (strategyType !== undefined) {
+      return strategyType
     }
   }
 
-  /**
-   * 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() {
-    processSessionStoreOperations(
-      {
-        process: (sessionState) =>
-          isSessionInExpiredState(sessionState) ? getExpiredSessionState(sessionState, configuration) : undefined,
-        after: synchronizeSession,
-      },
-      sessionStoreStrategy
-    )
-  }
-
-  function synchronizeSession(sessionState: SessionState) {
-    if (isSessionInExpiredState(sessionState)) {
-      sessionState.anonymousId = generateUUID()
-      sessionState = getExpiredSessionState(sessionState, configuration)
-    }
-    if (hasSessionInCache()) {
-      if (isSessionInCacheOutdated(sessionState)) {
-        expireSessionInCache()
-      } else {
-        sessionStateUpdateObservable.notify({ previousState: sessionCache, newState: sessionState })
-        sessionCache = sessionState
-      }
-    }
-    return sessionState
-  }
+  return undefined
+}
 
-  function startSession() {
-    processSessionStoreOperations(
-      {
-        process: (sessionState) => {
-          if (isSessionInNotStartedState(sessionState)) {
-            return getExpiredSessionState(sessionState, configuration)
-          }
-        },
-        after: (sessionState) => {
-          sessionCache = sessionState
-        },
-      },
-      sessionStoreStrategy
-    )
+function normalizePersistenceList(sessionPersistence: SessionPersistence[] | undefined): SessionPersistence[] {
+  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()
   }
 }