utneque 1.0.0

package/packages/browser/src/core/user/__tests__/migrate.test.ts

@@ -0,0 +1,101 @@
+import jar from 'js-cookie'
+import { User } from '..'
+import { LocalStorage } from '../../storage'
+
+function clear(): void {
+  document.cookie.split(';').forEach(function (c) {
+    document.cookie = c
+      .replace(/^ +/, '')
+      .replace(/=.*/, '=;expires=' + new Date().toUTCString() + ';path=/')
+  })
+  localStorage.clear()
+}
+
+let store: LocalStorage
+beforeEach(function () {
+  store = new LocalStorage()
+  clear()
+  // Restore any cookie, localstorage disable
+  jest.restoreAllMocks()
+  jest.spyOn(console, 'warn').mockImplementation(() => {}) // silence console spam.
+})
+
+const anonymousIdKey = 'htjs_anonymous_id'
+const rudderHtAnonymousIdKey = 'htev_anonymous_id'
+const segmentAnonymousIdKey = 'ajs_anonymous_id'
+const rudderAnonymousIdKey = 'rl_anonymous_id'
+
+describe('user anonymousId migration', () => {
+  describe('()', () => {
+    it('should get the hightouch anonymousId', () => {
+      store.set(anonymousIdKey, '1234')
+      const user = new User()
+      expect(user.anonymousId()).toEqual('1234')
+    })
+
+    it('should decrypt the "legacy" hightouch anonymousId', () => {
+      store.set(
+        rudderHtAnonymousIdKey,
+        'HtEvEncrypt:U2FsdGVkX1+BxLsjF52p24D/rVEQfG9ACRjvLRoSgbnfLYlWBmBCWABZPMsDHWySVO4c26kYs2hxrT13q8amlw=='
+      )
+      const user = new User()
+      expect(user.anonymousId()).toEqual('c027ce91-f759-4f91-96d4-985eaa146346')
+
+      store.remove(rudderHtAnonymousIdKey)
+      const user2 = new User()
+      expect(user2.anonymousId()).toEqual(
+        'c027ce91-f759-4f91-96d4-985eaa146346'
+      )
+      expect(store.get(anonymousIdKey)).toEqual(
+        'c027ce91-f759-4f91-96d4-985eaa146346'
+      )
+      expect(store.get(rudderHtAnonymousIdKey)).toEqual(null)
+    })
+
+    it('should get the segment anonymousId', () => {
+      store.set(segmentAnonymousIdKey, '56789')
+      const user = new User()
+      expect(user.anonymousId()).toEqual('56789')
+    })
+
+    it('should get the unencrypted rudder anonymousId', () => {
+      jar.set(rudderAnonymousIdKey, '56789')
+      const user = new User()
+      expect(user.anonymousId()).toEqual('56789')
+    })
+
+    it('should get the v3 "encrypted" rudder anonymousId', () => {
+      jar.set(rudderAnonymousIdKey, 'RS_ENC_v3_dGVzdC1kYXRh')
+      const user = new User()
+      expect(user.anonymousId()).toEqual('test-data')
+    })
+
+    it('should get the v1 "encrypted" rudder anonymousId', () => {
+      jar.set(
+        rudderAnonymousIdKey,
+        'RudderEncrypt:U2FsdGVkX1+5q5jikppUASe8AdIH6O2iORyF41sYXgxzIGiX9whSeVxxww0OK5h/'
+      )
+      const user = new User()
+      expect(user.anonymousId()).toEqual('1wefk7M3Y1D6EDX4ZpIE00LpKAE')
+    })
+
+    it('should always choose the hightouch anonymousId when present', () => {
+      store.set(segmentAnonymousIdKey, '56789')
+      jar.set(anonymousIdKey, '1234')
+      const user = new User()
+      expect(user.anonymousId()).toEqual('1234')
+    })
+
+    it('should migrate the anonymousId', () => {
+      store.set(segmentAnonymousIdKey, '56789')
+      const user = new User()
+      expect(user.anonymousId()).toEqual('56789')
+
+      store.remove(segmentAnonymousIdKey)
+      const user2 = new User()
+      expect(user2.anonymousId()).toEqual('56789')
+      expect(store.get(anonymousIdKey)).toEqual('56789')
+      expect(store.get(segmentAnonymousIdKey)).toEqual(null)
+    })
+  })
+})

package/packages/browser/src/core/user/__tests__/session.test.ts

@@ -0,0 +1,136 @@
+import { User } from '..'
+import { LocalStorage } from '../../storage'
+import { SessionInfo } from '../../session'
+
+function clear(): void {
+  document.cookie.split(';').forEach(function (c) {
+    document.cookie = c
+      .replace(/^ +/, '')
+      .replace(/=.*/, '=;expires=' + new Date().toUTCString() + ';path=/')
+  })
+  localStorage.clear()
+}
+
+let store: LocalStorage
+beforeEach(function () {
+  store = new LocalStorage()
+  clear()
+  // Restore any cookie, localstorage disable
+  jest.restoreAllMocks()
+  jest.spyOn(console, 'warn').mockImplementation(() => {}) // silence console spam.
+})
+
+const seshKey = 'htjs_sesh'
+
+describe('user anonymousId migration', () => {
+  describe('()', () => {
+    it('should create a session', () => {
+      const user = new User()
+      const session = user.getAndUpdateSession()
+      expect(session?.sessionStart).toEqual(true)
+      expect(session?.sessionId).toBeTruthy()
+
+      const sesh = store.get(seshKey) as unknown as SessionInfo
+      expect(sesh.expiresAt).toBeTruthy()
+      expect(sesh.autoTrack).toBeTruthy()
+    })
+
+    it('should update an existing session', () => {
+      const user = new User()
+      const session = user.getAndUpdateSession()
+      const sesh = store.get(seshKey) as unknown as SessionInfo
+      expect(session?.sessionStart).toEqual(true)
+      expect(session?.sessionId).toBeTruthy()
+
+      const updated = user.getAndUpdateSession()
+      const updatedSesh = store.get(seshKey) as unknown as SessionInfo
+      expect(updated?.sessionStart).toEqual(undefined)
+      expect(updated?.sessionId).toEqual(session?.sessionId)
+      expect(updatedSesh.expiresAt).toEqual(sesh.expiresAt! + sesh.timeout!)
+    })
+
+    it('should not create a session if autoTrack is disabled', () => {
+      const user = new User({ sessions: { autoTrack: false } })
+      const session = user.getAndUpdateSession()
+      expect(session).toEqual({})
+    })
+
+    it('should be able to start and end manual sessions', () => {
+      const user = new User({ sessions: { autoTrack: false } })
+      const session = user.getAndUpdateSession()
+      expect(session).toEqual({})
+
+      user.startManualSession()
+      const sessionId = user.sessionId()
+      const sesh = store.get(seshKey) as unknown as SessionInfo
+
+      expect(sesh).toEqual({
+        id: sessionId,
+        manualTrack: true,
+        sessionStart: true,
+      })
+
+      // first call sets it as no longer being the start of the session
+      const firstCall = user.getAndUpdateSession()
+      expect(firstCall).toEqual({ sessionId })
+      // subsequent calls do not change the session
+      const secondCall = user.getAndUpdateSession()
+      expect(secondCall).toEqual({ sessionId })
+      const thirdCall = user.getAndUpdateSession()
+      expect(thirdCall).toEqual({ sessionId })
+
+      // ending the session should clear the session
+      user.endManualSession()
+      // this should NOT auto create another session
+      // autoTrack was disabled during User init
+      const ended = user.getAndUpdateSession()
+      expect(ended).toEqual({})
+    })
+
+    it('should end an autoTrack session when manualSession is called', () => {
+      const user = new User()
+      const session = user.getAndUpdateSession()
+      const sesh = store.get(seshKey) as unknown as SessionInfo
+      expect(session?.sessionStart).toEqual(true)
+      expect(session?.sessionId).toBeTruthy()
+      expect(sesh?.sessionStart).toEqual(true)
+      expect(sesh?.expiresAt).toBeTruthy()
+      expect(sesh?.autoTrack).toBeTruthy()
+
+      user.startManualSession(23114123412)
+      const newSesh = store.get(seshKey) as unknown as SessionInfo
+      const newSession = user.getAndUpdateSession()
+      expect(newSession?.sessionId === session?.sessionId).toBe(false)
+      expect(newSesh).toEqual({
+        id: newSession?.sessionId,
+        manualTrack: true,
+        sessionStart: true,
+      })
+
+      // ending the manual session should return to auto track
+      user.endManualSession()
+      const autoSession = user.getAndUpdateSession()
+      const autoSesh = store.get(seshKey) as unknown as SessionInfo
+      expect(autoSession?.sessionStart).toEqual(true)
+      expect(autoSession?.sessionId).toBeTruthy()
+      expect(autoSesh?.sessionStart).toEqual(true)
+      expect(autoSesh?.expiresAt).toBeTruthy()
+      expect(autoSesh?.autoTrack).toBeTruthy()
+    })
+
+    it('should get a sessionId without affecting the session', () => {
+      const user = new User()
+      const session = user.getAndUpdateSession()
+      const sesh = store.get(seshKey) as unknown as SessionInfo
+      expect(session?.sessionId).toBeTruthy()
+
+      user.sessionId()
+      user.sessionId()
+      user.sessionId()
+      const notUpdated = store.get(seshKey) as unknown as SessionInfo
+      expect(user.sessionId()).toEqual(session?.sessionId)
+      expect(notUpdated.expiresAt).toEqual(sesh.expiresAt)
+      expect(notUpdated.id).toEqual(sesh.id)
+    })
+  })
+})

package/packages/browser/src/core/user/__tests__/tld.test.ts

@@ -0,0 +1,36 @@
+import cookie from 'js-cookie'
+import { tld } from '../tld'
+import assert from 'assert'
+
+describe('topDomain', function () {
+  beforeEach(() => {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const cookies: Record<string, any> = {}
+
+    // @ts-ignore
+    jest.spyOn(cookie, 'set').mockImplementation((key, val, opts) => {
+      const parts = opts?.domain?.split('.') ?? []
+      if (parts[1] === 'co') return
+      cookies[key] = val
+      return val
+    })
+
+    // @ts-ignore
+    jest.spyOn(cookie, 'get').mockImplementation((key) => {
+      return cookies[key]
+    })
+  })
+
+  it('should match the following urls', function () {
+    assert.strictEqual(tld('http://www.google.com'), 'google.com')
+    assert.strictEqual(
+      tld('http://gist.github.com/calvinfo/some_file'),
+      'github.com'
+    )
+    assert.strictEqual(tld('http://localhost:3000'), undefined)
+    assert.strictEqual(tld('https://google.com:443/stuff'), 'google.com')
+    assert.strictEqual(tld('http://dev:3000'), undefined)
+    assert.strictEqual(tld('http://app.jut.io'), 'jut.io')
+    assert.strictEqual(tld('http://app.hightouch.io'), 'hightouch.io')
+  })
+})

package/packages/browser/src/core/user/index.ts

@@ -0,0 +1,399 @@
+import { v4 as uuid } from '@lukeed/uuid'
+import autoBind from '../../lib/bind-all'
+import { Traits } from '../events'
+import {
+  CookieOptions,
+  UniversalStorage,
+  MemoryStorage,
+  StorageObject,
+  StorageSettings,
+  StoreType,
+  applyCookieOptions,
+  initializeStorages,
+  isArrayOfStoreType,
+} from '../storage'
+import { decryptRudderValue, decryptRudderHtValue } from './migrate'
+import {
+  SessionContext,
+  SessionInfo,
+  generateAutoTrackingSession,
+  generateManualTrackingSession,
+  hasSessionExpired,
+  updateSessionExpiration,
+} from '../session'
+
+export type ID = string | null | undefined
+
+export interface UserOptions {
+  /**
+   * Disables storing any data about the user.
+   */
+  disable?: boolean
+  localStorageFallbackDisabled?: boolean
+  persist?: boolean
+
+  cookie?: {
+    key?: string
+    oldKey?: string
+  }
+
+  localStorage?: {
+    key: string
+  }
+
+  sessions?: {
+    autoTrack?: boolean
+    timeout?: number // milliseconds
+  }
+
+  /**
+   * Store priority
+   * @example stores: [StoreType.Cookie, StoreType.Memory]
+   */
+  storage?: StorageSettings
+}
+
+const defaults = {
+  persist: true,
+  cookie: {
+    key: 'htjs_user_id',
+    oldKey: 'ajs_user',
+  },
+  localStorage: {
+    key: 'htjs_user_traits',
+  },
+  sessions: {
+    autoTrack: true,
+  },
+}
+
+const sessionKey = 'htjs_sesh'
+const anonymousIdKey = 'htjs_anonymous_id'
+const rudderHtAnonymousIdKey = 'htev_anonymous_id'
+const segmentAnonymousIdKey = 'ajs_anonymous_id'
+const rudderAnonymousIdKey = 'rl_anonymous_id'
+
+export class User {
+  static defaults = defaults
+
+  private idKey: string
+  private traitsKey: string
+  private anonKey: string
+  private seshKey: string
+  private cookieOptions?: CookieOptions
+
+  private legacyUserStore: UniversalStorage<{
+    [k: string]:
+      | {
+          id?: string
+          traits?: Traits
+        }
+      | string
+  }>
+  private traitsStore: UniversalStorage<{
+    [k: string]: Traits
+  }>
+
+  private identityStore: UniversalStorage<{
+    [k: string]: string
+  }>
+
+  private sessionStore: UniversalStorage<{ [k: string]: SessionInfo }>
+
+  options: UserOptions = {}
+
+  constructor(options: UserOptions = defaults, cookieOptions?: CookieOptions) {
+    this.options = { ...defaults, ...options }
+    this.cookieOptions = cookieOptions
+
+    this.idKey = options.cookie?.key ?? defaults.cookie.key
+    this.traitsKey = options.localStorage?.key ?? defaults.localStorage.key
+    this.anonKey = anonymousIdKey
+    this.seshKey = sessionKey
+
+    this.identityStore = this.createStorage(this.options, cookieOptions)
+
+    this.sessionStore = this.createStorage(this.options, cookieOptions)
+
+    // using only cookies for legacy user store
+    this.legacyUserStore = this.createStorage(
+      this.options,
+      cookieOptions,
+      (s) => s === StoreType.Cookie
+    )
+
+    // using only localStorage / memory for traits store
+    this.traitsStore = this.createStorage(
+      this.options,
+      cookieOptions,
+      (s) => s !== StoreType.Cookie
+    )
+
+    const legacyUser = this.legacyUserStore.get(defaults.cookie.oldKey)
+    if (legacyUser && typeof legacyUser === 'object') {
+      legacyUser.id && this.id(legacyUser.id)
+      legacyUser.traits && this.traits(legacyUser.traits)
+    }
+    autoBind(this)
+  }
+
+  id = (id?: ID): ID => {
+    if (this.options.disable) {
+      return null
+    }
+
+    const prevId = this.identityStore.getAndSync(this.idKey)
+
+    if (id !== undefined) {
+      this.identityStore.set(this.idKey, id)
+
+      const changingIdentity = id !== prevId && prevId !== null && id !== null
+      if (changingIdentity) {
+        this.anonymousId(null)
+      }
+    }
+
+    const retId = this.identityStore.getAndSync(this.idKey)
+    if (retId) return retId
+
+    const retLeg = this.legacyUserStore.get(defaults.cookie.oldKey)
+    return retLeg ? (typeof retLeg === 'object' ? retLeg.id : retLeg) : null
+  }
+
+  private legacySIO(): [string, string] | null {
+    const val = this.legacyUserStore.get('_sio') as string
+    if (!val) {
+      return null
+    }
+    const [anon, user] = val.split('----')
+    return [anon, user]
+  }
+
+  anonymousId = (id?: ID): ID => {
+    if (this.options.disable) {
+      return null
+    }
+
+    if (id === undefined) {
+      let val = this.identityStore.getAndSync(this.anonKey)
+
+      // support anonymousId migration from other analytics providers
+      if (!val) {
+        val = decryptRudderHtValue(
+          this.identityStore.getAndSync(rudderHtAnonymousIdKey) ?? ''
+        )
+        if (val) this.identityStore.set(this.anonKey, val)
+      }
+      if (!val) {
+        val = this.identityStore.getAndSync(segmentAnonymousIdKey)
+        if (val) this.identityStore.set(this.anonKey, val)
+      }
+      if (!val) {
+        val = decryptRudderValue(
+          this.identityStore.getAndSync(rudderAnonymousIdKey) ?? ''
+        )
+        if (val) this.identityStore.set(this.anonKey, val)
+      }
+      if (!val) {
+        val = this.legacySIO()?.[0] ?? null
+      }
+
+      if (val) {
+        return val
+      }
+    }
+
+    if (id === null) {
+      this.identityStore.set(this.anonKey, null)
+      return this.identityStore.getAndSync(this.anonKey)
+    }
+
+    this.identityStore.set(this.anonKey, id ?? uuid())
+    return this.identityStore.getAndSync(this.anonKey)
+  }
+
+  traits = (traits?: Traits | null): Traits | undefined => {
+    if (this.options.disable) {
+      return
+    }
+
+    if (traits === null) {
+      traits = {}
+    }
+
+    if (traits) {
+      this.traitsStore.set(this.traitsKey, traits ?? {})
+    }
+
+    return this.traitsStore.get(this.traitsKey) ?? {}
+  }
+
+  identify(id?: ID, traits?: Traits): void {
+    if (this.options.disable) {
+      return
+    }
+
+    traits = traits ?? {}
+    const currentId = this.id()
+
+    if (currentId === null || currentId === id) {
+      traits = {
+        ...this.traits(),
+        ...traits,
+      }
+    }
+
+    if (id) {
+      this.id(id)
+    }
+
+    this.traits(traits)
+  }
+
+  startManualSession(sessionId?: number) {
+    if (this.options.disable) {
+      return
+    }
+    this.sessionStore.clear(this.seshKey)
+    const session = generateManualTrackingSession(sessionId)
+    this.sessionStore.set(this.seshKey, session)
+  }
+
+  endManualSession() {
+    this.sessionStore.clear(this.seshKey)
+  }
+
+  private getAndUpdateSessionInfo(): SessionInfo | null {
+    if (this.options.disable) {
+      return null
+    }
+
+    let session = this.sessionStore.getAndSync(this.seshKey)
+
+    if (session == null) {
+      if (this.options?.sessions?.autoTrack) {
+        session = generateAutoTrackingSession(this.options?.sessions?.timeout)
+        this.sessionStore.set(this.seshKey, session)
+        return session
+      }
+      return null
+    }
+
+    if (session?.autoTrack && hasSessionExpired(session.expiresAt!)) {
+      session = generateAutoTrackingSession(this.options?.sessions?.timeout)
+      this.sessionStore.set(this.seshKey, session)
+      return session
+    }
+
+    session = updateSessionExpiration(session)
+    this.sessionStore.set(this.seshKey, session)
+    return session
+  }
+
+  getAndUpdateSession(): SessionContext | null {
+    const sessionInfo = this.getAndUpdateSessionInfo()
+    const session: SessionContext = {}
+    if (sessionInfo?.id) session.sessionId = sessionInfo.id
+    if (sessionInfo?.sessionStart)
+      session.sessionStart = sessionInfo.sessionStart
+    return session
+  }
+
+  sessionId(): number | null {
+    const session = this.sessionStore.getAndSync(this.seshKey)
+    return session?.id ?? null
+  }
+
+  logout(): void {
+    this.anonymousId(null)
+    this.id(null)
+    this.traits({})
+  }
+
+  reset(): void {
+    this.logout()
+    this.identityStore.clear(this.idKey)
+    this.identityStore.clear(this.anonKey)
+    this.sessionStore.clear(this.seshKey)
+    this.traitsStore.clear(this.traitsKey)
+  }
+
+  load(): User {
+    return new User(this.options, this.cookieOptions)
+  }
+
+  save(): boolean {
+    return true
+  }
+
+  /**
+   * Creates the right storage system applying all the user options, cookie options and particular filters
+   * @param options UserOptions
+   * @param cookieOpts CookieOptions
+   * @param filterStores filter function to apply to any StoreTypes (skipped if options specify using a custom storage)
+   * @returns a Storage object
+   */
+  private createStorage<T extends StorageObject = StorageObject>(
+    options: UserOptions,
+    cookieOpts?: CookieOptions,
+    filterStores?: (value: StoreType) => boolean
+  ): UniversalStorage<T> {
+    let stores: StoreType[] = [
+      StoreType.LocalStorage,
+      StoreType.Cookie,
+      StoreType.Memory,
+    ]
+
+    // If disabled we won't have any storage functionality
+    if (options.disable) {
+      return new UniversalStorage<T>([])
+    }
+
+    // If persistance is disabled we will always fallback to Memory Storage
+    if (!options.persist) {
+      return new UniversalStorage<T>([new MemoryStorage<T>()])
+    }
+
+    if (options.storage !== undefined && options.storage !== null) {
+      if (isArrayOfStoreType(options.storage)) {
+        // If the user only specified order of stores we will still apply filters and transformations e.g. not using localStorage if localStorageFallbackDisabled
+        stores = options.storage.stores
+      }
+    }
+
+    // Disable LocalStorage
+    if (options.localStorageFallbackDisabled) {
+      stores = stores.filter((s) => s !== StoreType.LocalStorage)
+    }
+
+    // Apply Additional filters
+    if (filterStores) {
+      stores = stores.filter(filterStores)
+    }
+
+    return new UniversalStorage(
+      initializeStorages(applyCookieOptions(stores, cookieOpts))
+    )
+  }
+}
+
+const groupDefaults: UserOptions = {
+  persist: true,
+  cookie: {
+    key: 'htjs_group_id',
+  },
+  localStorage: {
+    key: 'htjs_group_properties',
+  },
+}
+
+export class Group extends User {
+  constructor(options: UserOptions = groupDefaults, cookie?: CookieOptions) {
+    super({ ...groupDefaults, ...options }, cookie)
+    autoBind(this)
+  }
+
+  anonymousId = (_id?: ID): ID => {
+    return undefined
+  }
+}