@ht-sdks/events-sdk-js-browser 1.0.4

package/src/core/storage/cookieStorage.ts

@@ -0,0 +1,80 @@
+import { Store, StorageObject } from './types'
+import jar from 'js-cookie'
+import { tld } from '../user/tld'
+
+const ONE_YEAR = 365
+
+export interface CookieOptions {
+  maxage?: number
+  domain?: string
+  path?: string
+  secure?: boolean
+  sameSite?: string
+}
+
+/**
+ * Data storage using browser cookies
+ */
+export class CookieStorage<Data extends StorageObject = StorageObject>
+  implements Store<Data>
+{
+  static get defaults(): CookieOptions {
+    return {
+      maxage: ONE_YEAR,
+      domain: tld(window.location.href),
+      path: '/',
+      sameSite: 'Lax',
+    }
+  }
+
+  private options: Required<CookieOptions>
+
+  constructor(options: CookieOptions = CookieStorage.defaults) {
+    this.options = {
+      ...CookieStorage.defaults,
+      ...options,
+    } as Required<CookieOptions>
+  }
+
+  private opts(): jar.CookieAttributes {
+    return {
+      sameSite: this.options.sameSite as jar.CookieAttributes['sameSite'],
+      expires: this.options.maxage,
+      domain: this.options.domain,
+      path: this.options.path,
+      secure: this.options.secure,
+    }
+  }
+
+  get<K extends keyof Data>(key: K): Data[K] | null {
+    try {
+      const value = jar.get(key)
+
+      if (value === undefined || value === null) {
+        return null
+      }
+
+      try {
+        return JSON.parse(value) ?? null
+      } catch (e) {
+        return (value ?? null) as unknown as Data[K] | null
+      }
+    } catch (e) {
+      return null
+    }
+  }
+
+  set<K extends keyof Data>(key: K, value: Data[K] | null): void {
+    if (typeof value === 'string') {
+      jar.set(key, value, this.opts())
+    } else if (value === null) {
+      jar.remove(key, this.opts())
+    } else {
+      jar.set(key, JSON.stringify(value), this.opts())
+    }
+  }
+
+  remove<K extends keyof Data>(key: K): void {
+    return jar.remove(key, this.opts())
+  }
+}

package/src/core/storage/index.ts

@@ -0,0 +1,64 @@
+import { CookieOptions, CookieStorage } from './cookieStorage'
+import { LocalStorage } from './localStorage'
+import { MemoryStorage } from './memoryStorage'
+import { isStoreTypeWithSettings } from './settings'
+import { StoreType, Store, InitializeStorageArgs } from './types'
+
+export * from './types'
+export * from './localStorage'
+export * from './cookieStorage'
+export * from './memoryStorage'
+export * from './universalStorage'
+export * from './settings'
+
+/**
+ * Creates multiple storage systems from an array of StoreType and options
+ * @param args StoreType and options
+ * @returns Storage array
+ */
+export function initializeStorages(args: InitializeStorageArgs): Store[] {
+  const storages = args.map((s) => {
+    let type: StoreType
+    let settings
+
+    if (isStoreTypeWithSettings(s)) {
+      type = s.name
+      settings = s.settings
+    } else {
+      type = s
+    }
+
+    switch (type) {
+      case StoreType.Cookie:
+        return new CookieStorage(settings)
+      case StoreType.LocalStorage:
+        return new LocalStorage()
+      case StoreType.Memory:
+        return new MemoryStorage()
+      default:
+        throw new Error(`Unknown Store Type: ${s}`)
+    }
+  })
+  return storages
+}
+
+/**
+ * Injects the CookieOptions into a the arguments for initializeStorage
+ * @param storeTypes list of storeType
+ * @param cookieOptions cookie Options
+ * @returns arguments for initializeStorage
+ */
+export function applyCookieOptions(
+  storeTypes: StoreType[],
+  cookieOptions?: CookieOptions
+): InitializeStorageArgs {
+  return storeTypes.map((s) => {
+    if (cookieOptions && s === StoreType.Cookie) {
+      return {
+        name: s,
+        settings: cookieOptions,
+      }
+    }
+    return s
+  })
+}

package/src/core/storage/localStorage.ts

@@ -0,0 +1,45 @@
+import { StorageObject, Store } from './types'
+
+/**
+ * Data storage using browser's localStorage
+ */
+export class LocalStorage<Data extends StorageObject = StorageObject>
+  implements Store<Data>
+{
+  private localStorageWarning(key: keyof Data, state: 'full' | 'unavailable') {
+    console.warn(`Unable to access ${key}, localStorage may be ${state}`)
+  }
+
+  get<K extends keyof Data>(key: K): Data[K] | null {
+    try {
+      const val = localStorage.getItem(key)
+      if (val === null) {
+        return null
+      }
+      try {
+        return JSON.parse(val) ?? null
+      } catch (e) {
+        return (val ?? null) as unknown as Data[K] | null
+      }
+    } catch (err) {
+      this.localStorageWarning(key, 'unavailable')
+      return null
+    }
+  }
+
+  set<K extends keyof Data>(key: K, value: Data[K] | null): void {
+    try {
+      localStorage.setItem(key, JSON.stringify(value))
+    } catch {
+      this.localStorageWarning(key, 'full')
+    }
+  }
+
+  remove<K extends keyof Data>(key: K): void {
+    try {
+      return localStorage.removeItem(key)
+    } catch (err) {
+      this.localStorageWarning(key, 'unavailable')
+    }
+  }
+}

package/src/core/storage/memoryStorage.ts

@@ -0,0 +1,22 @@
+import { Store, StorageObject } from './types'
+
+/**
+ * Data Storage using in memory object
+ */
+export class MemoryStorage<Data extends StorageObject = StorageObject>
+  implements Store<Data>
+{
+  private cache: Record<string, unknown> = {}
+
+  get<K extends keyof Data>(key: K): Data[K] | null {
+    return (this.cache[key] ?? null) as Data[K] | null
+  }
+
+  set<K extends keyof Data>(key: K, value: Data[K] | null): void {
+    this.cache[key] = value
+  }
+
+  remove<K extends keyof Data>(key: K): void {
+    delete this.cache[key]
+  }
+}

package/src/core/storage/settings.ts

@@ -0,0 +1,23 @@
+import { StoreType, StoreTypeWithSettings } from './types'
+
+export type UniversalStorageSettings = { stores: StoreType[] }
+
+// This is setup this way to permit eventually a different set of settings for custom storage
+export type StorageSettings = UniversalStorageSettings
+
+export function isArrayOfStoreType(
+  s: StorageSettings
+): s is UniversalStorageSettings {
+  return (
+    s &&
+    s.stores &&
+    Array.isArray(s.stores) &&
+    s.stores.every((e) => Object.values(StoreType).includes(e))
+  )
+}
+
+export function isStoreTypeWithSettings(
+  s: StoreTypeWithSettings | StoreType
+): s is StoreTypeWithSettings {
+  return typeof s === 'object' && s.name !== undefined
+}

package/src/core/storage/types.ts

@@ -0,0 +1,49 @@
+import { CookieOptions } from './cookieStorage'
+
+export const StoreType = {
+  Cookie: 'cookie',
+  LocalStorage: 'localStorage',
+  Memory: 'memory',
+} as const
+
+/**
+ * Known Storage Types
+ *
+ * Convenience settings for storage systems that AJS includes support for
+ */
+export type StoreType = typeof StoreType[keyof typeof StoreType]
+
+export type StorageObject = Record<string, unknown>
+
+/**
+ * Defines a Storage object for use in AJS Client.
+ */
+export interface Store<Data extends StorageObject = StorageObject> {
+  /**
+   * get value for the key from the stores. it will return the first value found in the stores
+   * @param key key for the value to be retrieved
+   * @returns value for the key or null if not found
+   */
+  get<K extends keyof Data>(key: K): Data[K] | null
+
+  /**
+   * it will set the value for the key in all the stores
+   * @param key key for the value to be stored
+   * @param value value to be stored
+   * @returns value that was stored
+   */
+  set<K extends keyof Data>(key: K, value: Data[K] | null): void
+  /**
+   * remove the value for the key from all the stores
+   * @param key key for the value to be removed
+   * @param storeTypes optional array of store types to be used for removing the value
+   */
+  remove<K extends keyof Data>(key: K): void
+}
+
+export interface StoreTypeWithSettings<T extends StoreType = StoreType> {
+  name: T
+  settings?: T extends 'cookie' ? CookieOptions : never
+}
+
+export type InitializeStorageArgs = (StoreTypeWithSettings | StoreType)[]

package/src/core/storage/universalStorage.ts

@@ -0,0 +1,78 @@
+import { Store, StorageObject } from './types'
+
+// not adding to private method because those method names do not get minified atm, and does not use 'this'
+const _logStoreKeyError = (
+  store: Store,
+  action: 'set' | 'get' | 'remove',
+  key: string,
+  err: unknown
+) => {
+  console.warn(
+    `${store.constructor.name}: Can't ${action} key "${key}" | Err: ${err}`
+  )
+}
+
+/**
+ * Uses multiple storages in a priority list to get/set values in the order they are specified.
+ */
+export class UniversalStorage<Data extends StorageObject = StorageObject> {
+  private stores: Store[]
+
+  constructor(stores: Store[]) {
+    this.stores = stores
+  }
+
+  get<K extends keyof Data>(key: K): Data[K] | null {
+    let val: Data[K] | null = null
+
+    for (const store of this.stores) {
+      try {
+        val = store.get(key) as Data[K] | null
+        if (val !== undefined && val !== null) {
+          return val
+        }
+      } catch (e) {
+        _logStoreKeyError(store, 'get', key, e)
+      }
+    }
+    return null
+  }
+
+  set<K extends keyof Data>(key: K, value: Data[K] | null): void {
+    this.stores.forEach((store) => {
+      try {
+        store.set(key, value)
+      } catch (e) {
+        _logStoreKeyError(store, 'set', key, e)
+      }
+    })
+  }
+
+  clear<K extends keyof Data>(key: K): void {
+    this.stores.forEach((store) => {
+      try {
+        store.remove(key)
+      } catch (e) {
+        _logStoreKeyError(store, 'remove', key, e)
+      }
+    })
+  }
+
+  /*
+    This is to support few scenarios where:
+    - value exist in one of the stores ( as a result of other stores being cleared from browser ) and we want to resync them
+    - read values in AJS 1.0 format ( for customers after 1.0 --> 2.0 migration ) and then re-write them in AJS 2.0 format
+  */
+  getAndSync<K extends keyof Data>(key: K): Data[K] | null {
+    const val = this.get(key)
+
+    // legacy behavior, getAndSync can change the type of a value from number to string (AJS 1.0 stores numerical values as a number)
+    const coercedValue = (typeof val === 'number' ? val.toString() : val) as
+      | Data[K]
+      | null
+
+    this.set(key, coercedValue)
+
+    return coercedValue
+  }
+}