iureiure 1.0.0

package/packages/analytics-js/src/services/StoreManager/StoreManager.ts

@@ -0,0 +1,231 @@
+import type {
+  IStoreConfig,
+  IStoreManager,
+  StoreId,
+} from '@rudderstack/analytics-js-common/types/Store';
+import type { IErrorHandler } from '@rudderstack/analytics-js-common/types/ErrorHandler';
+import type { ILogger } from '@rudderstack/analytics-js-common/types/Logger';
+import type { IPluginsManager } from '@rudderstack/analytics-js-common/types/PluginsManager';
+import { STORE_MANAGER } from '@rudderstack/analytics-js-common/constants/loggerContexts';
+import {
+  COOKIE_STORAGE,
+  LOCAL_STORAGE,
+  MEMORY_STORAGE,
+  NO_STORAGE,
+  SESSION_STORAGE,
+} from '@rudderstack/analytics-js-common/constants/storages';
+import {
+  mergeDeepRight,
+  removeUndefinedValues,
+} from '@rudderstack/analytics-js-common/utilities/object';
+import {
+  DEFAULT_STORAGE_TYPE,
+  type StorageType,
+} from '@rudderstack/analytics-js-common/types/Storage';
+import type { UserSessionKey } from '@rudderstack/analytics-js-common/types/UserSessionStorage';
+import { batch } from '@preact/signals-core';
+import { isDefined } from '@rudderstack/analytics-js-common/utilities/checks';
+import { USER_SESSION_KEYS } from '@rudderstack/analytics-js/constants/storage';
+import { USER_SESSION_STORAGE_KEYS } from '../../components/userSessionManager/constants';
+import { STORAGE_UNAVAILABLE_WARNING } from '../../constants/logMessages';
+import { type StoreManagerOptions, storageClientDataStoreNameMap } from './types';
+import { state } from '../../state';
+import { configureStorageEngines, getStorageEngine } from './storages/storageEngine';
+import { Store } from './Store';
+import { getStorageTypeFromPreConsentIfApplicable } from './utils';
+
+/**
+ * A service to manage stores & available storage client configurations
+ */
+class StoreManager implements IStoreManager {
+  stores: Record<StoreId, Store> = {};
+  isInitialized = false;
+  errorHandler?: IErrorHandler;
+  logger?: ILogger;
+  pluginsManager?: IPluginsManager;
+  hasErrorHandler = false;
+
+  constructor(pluginsManager?: IPluginsManager, errorHandler?: IErrorHandler, logger?: ILogger) {
+    this.errorHandler = errorHandler;
+    this.logger = logger;
+    this.hasErrorHandler = Boolean(this.errorHandler);
+    this.pluginsManager = pluginsManager;
+    this.onError = this.onError.bind(this);
+  }
+
+  /**
+   * Configure available storage client instances
+   */
+  init() {
+    if (this.isInitialized) {
+      return;
+    }
+
+    const loadOptions = state.loadOptions.value;
+    const config: StoreManagerOptions = {
+      cookieStorageOptions: {
+        samesite: loadOptions.sameSiteCookie,
+        secure: loadOptions.secureCookie,
+        domain: loadOptions.setCookieDomain,
+        sameDomainCookiesOnly: loadOptions.sameDomainCookiesOnly,
+        enabled: true,
+      },
+      localStorageOptions: { enabled: true },
+      inMemoryStorageOptions: { enabled: true },
+      sessionStorageOptions: { enabled: true },
+    };
+
+    configureStorageEngines(
+      removeUndefinedValues(
+        mergeDeepRight(config.cookieStorageOptions ?? {}, state.storage.cookie?.value ?? {}),
+      ),
+      removeUndefinedValues(config.localStorageOptions),
+      removeUndefinedValues(config.inMemoryStorageOptions),
+      removeUndefinedValues(config.sessionStorageOptions),
+    );
+
+    this.initClientDataStores();
+    this.isInitialized = true;
+  }
+
+  /**
+   * Create store to persist data used by the SDK like session, used details etc
+   */
+  initClientDataStores() {
+    this.initializeStorageState();
+
+    // TODO: fill in extra config values and bring them in from StoreManagerOptions if needed
+    // TODO: should we pass the keys for all in order to validate or leave free as v1.1?
+
+    // Initializing all the enabled store because previous user data might be in different storage
+    // that needs auto migration
+    const storageTypes = [MEMORY_STORAGE, LOCAL_STORAGE, COOKIE_STORAGE, SESSION_STORAGE];
+
+    storageTypes.forEach(storageType => {
+      if (getStorageEngine(storageType)?.isEnabled) {
+        this.setStore({
+          id: storageClientDataStoreNameMap[storageType] as string,
+          name: storageClientDataStoreNameMap[storageType] as string,
+          isEncrypted: true,
+          noCompoundKey: true,
+          type: storageType,
+        });
+      }
+    });
+  }
+
+  initializeStorageState() {
+    let globalStorageType = state.storage.type.value;
+    let entriesOptions = state.loadOptions.value.storage?.entries;
+
+    // Use the storage options from post consent if anything is defined
+    const postConsentStorageOpts = state.consents.postConsent.value.storage;
+    if (isDefined(postConsentStorageOpts?.type) || isDefined(postConsentStorageOpts?.entries)) {
+      globalStorageType = postConsentStorageOpts?.type;
+      entriesOptions = postConsentStorageOpts?.entries;
+    }
+
+    let trulyAnonymousTracking = true;
+    let storageEntries = {};
+    USER_SESSION_KEYS.forEach(sessionKey => {
+      const key = sessionKey;
+      const storageKey = sessionKey;
+      const configuredStorageType = entriesOptions?.[key]?.type;
+
+      const preConsentStorageType = getStorageTypeFromPreConsentIfApplicable(state, sessionKey);
+
+      // Storage type precedence order: pre-consent strategy > entry type > global type > default
+      const storageType =
+        preConsentStorageType ?? configuredStorageType ?? globalStorageType ?? DEFAULT_STORAGE_TYPE;
+
+      const finalStorageType = this.getResolvedStorageTypeForEntry(storageType, sessionKey);
+
+      if (finalStorageType !== NO_STORAGE) {
+        trulyAnonymousTracking = false;
+      }
+
+      storageEntries = {
+        ...storageEntries,
+        [sessionKey]: {
+          type: finalStorageType,
+          key: USER_SESSION_STORAGE_KEYS[storageKey],
+        },
+      };
+    });
+
+    batch(() => {
+      state.storage.type.value = globalStorageType;
+      state.storage.entries.value = storageEntries;
+      state.storage.trulyAnonymousTracking.value = trulyAnonymousTracking;
+    });
+  }
+
+  private getResolvedStorageTypeForEntry(storageType: StorageType, sessionKey: UserSessionKey) {
+    let finalStorageType = storageType;
+    switch (storageType) {
+      case LOCAL_STORAGE:
+        if (!getStorageEngine(LOCAL_STORAGE)?.isEnabled) {
+          finalStorageType = MEMORY_STORAGE;
+        }
+        break;
+      case SESSION_STORAGE:
+        if (!getStorageEngine(SESSION_STORAGE)?.isEnabled) {
+          finalStorageType = MEMORY_STORAGE;
+        }
+        break;
+      case MEMORY_STORAGE:
+      case NO_STORAGE:
+        break;
+      case COOKIE_STORAGE:
+      default:
+        // First try setting the storage to cookie else to local storage
+        if (getStorageEngine(COOKIE_STORAGE)?.isEnabled) {
+          finalStorageType = COOKIE_STORAGE;
+        } else if (getStorageEngine(LOCAL_STORAGE)?.isEnabled) {
+          finalStorageType = LOCAL_STORAGE;
+        } else if (getStorageEngine(SESSION_STORAGE)?.isEnabled) {
+          finalStorageType = SESSION_STORAGE;
+        } else {
+          finalStorageType = MEMORY_STORAGE;
+        }
+        break;
+    }
+
+    if (finalStorageType !== storageType) {
+      this.logger?.warn(
+        STORAGE_UNAVAILABLE_WARNING(STORE_MANAGER, sessionKey, storageType, finalStorageType),
+      );
+    }
+
+    return finalStorageType;
+  }
+
+  /**
+   * Create a new store
+   */
+  setStore(storeConfig: IStoreConfig): Store {
+    const storageEngine = getStorageEngine(storeConfig.type);
+    this.stores[storeConfig.id] = new Store(storeConfig, storageEngine, this.pluginsManager);
+    return this.stores[storeConfig.id] as Store;
+  }
+
+  /**
+   * Retrieve a store
+   */
+  getStore(id: StoreId): Store | undefined {
+    return this.stores[id];
+  }
+
+  /**
+   * Handle errors
+   */
+  onError(error: unknown) {
+    if (this.hasErrorHandler) {
+      this.errorHandler?.onError(error, STORE_MANAGER);
+    } else {
+      throw error;
+    }
+  }
+}
+
+export { StoreManager };

package/packages/analytics-js/src/services/StoreManager/component-cookie/README.md

@@ -0,0 +1,23 @@
+# cookie
+
+Cookie component.
+
+## Example
+
+```js
+// set
+cookie('name', 'tobi');
+cookie('name', 'tobi', { path: '/' });
+cookie('name', 'tobi', { maxage: 60000 }); // in milliseconds
+cookie('species', 'ferret');
+
+// get
+var name = cookie('name');
+// => "tobi"
+
+var cookies = cookie();
+// => { name: "tobi", species: "ferret" }
+
+// clear
+cookie('name', null);
+```

package/packages/analytics-js/src/services/StoreManager/component-cookie/index.ts

@@ -0,0 +1,138 @@
+import { isNull } from '@rudderstack/analytics-js-common/utilities/checks';
+import type { Nullable } from '@rudderstack/analytics-js-common/types/Nullable';
+import type { CookieOptions } from '@rudderstack/analytics-js-common/types/Storage';
+import type { ILogger } from '@rudderstack/analytics-js-common/types/Logger';
+import { COOKIE_DATA_ENCODING_ERROR } from '../../../constants/logMessages';
+
+/**
+ * Encode.
+ */
+const encode = (value: any, logger?: ILogger): string | undefined => {
+  try {
+    return encodeURIComponent(value);
+  } catch (err) {
+    logger?.error(COOKIE_DATA_ENCODING_ERROR, err);
+    return undefined;
+  }
+};
+
+/**
+ * Decode
+ */
+const decode = (value: string): string | undefined => {
+  try {
+    return decodeURIComponent(value);
+  } catch (err) {
+    // Do nothing as non-RS SDK cookies may not be URI encoded
+    return undefined;
+  }
+};
+
+/**
+ * Parse cookie `str`
+ */
+const parse = (str: string): Record<string, string | undefined> => {
+  const obj: Record<string, any> = {};
+  const pairs = str.split(/\s*;\s*/);
+  let pair;
+
+  if (!pairs[0]) {
+    return obj;
+  }
+
+  // TODO: Decode only the cookies that are needed by the SDK
+  pairs.forEach(pairItem => {
+    pair = pairItem.split('=');
+    const keyName = pair[0] ? decode(pair[0]) : undefined;
+
+    if (keyName) {
+      obj[keyName] = pair[1] ? decode(pair[1]) : undefined;
+    }
+  });
+
+  return obj;
+};
+
+/**
+ * Set cookie `name` to `value`
+ */
+const set = (
+  name?: string,
+  value?: Nullable<string | number>,
+  optionsConfig?: CookieOptions,
+  logger?: ILogger,
+) => {
+  const options: CookieOptions = { ...optionsConfig } || {};
+  let cookieString = `${encode(name, logger)}=${encode(value, logger)}`;
+
+  if (isNull(value)) {
+    options.maxage = -1;
+  }
+
+  if (options.maxage) {
+    options.expires = new Date(+new Date() + options.maxage);
+  }
+
+  if (options.path) {
+    cookieString += `; path=${options.path}`;
+  }
+
+  if (options.domain) {
+    cookieString += `; domain=${options.domain}`;
+  }
+
+  if (options.expires) {
+    cookieString += `; expires=${options.expires.toUTCString()}`;
+  }
+
+  if (options.samesite) {
+    cookieString += `; samesite=${options.samesite}`;
+  }
+
+  if (options.secure) {
+    cookieString += `; secure`;
+  }
+
+  globalThis.document.cookie = cookieString;
+};
+
+/**
+ * Return all cookies
+ */
+const all = (): Record<string, string | undefined> => {
+  const cookieStringValue = globalThis.document.cookie;
+  return parse(cookieStringValue);
+};
+
+/**
+ * Get cookie `name`
+ */
+
+const get = (name: string): string => (all() as any)[name];
+
+/**
+ * Set or get cookie `name` with `value` and `options` object
+ */
+// eslint-disable-next-line func-names
+const cookie = function (
+  name?: string,
+  value?: Nullable<string | number>,
+  options?: CookieOptions,
+  logger?: ILogger,
+): void | any {
+  switch (arguments.length) {
+    case 4:
+    case 3:
+    case 2:
+      return set(name, value, options, logger);
+    case 1:
+      if (name) {
+        return get(name);
+      }
+      return all();
+    default:
+      return all();
+  }
+};
+
+export { cookie };

package/packages/analytics-js/src/services/StoreManager/index.ts

@@ -0,0 +1,2 @@
+export { StoreManager } from './StoreManager';
+export { Store } from './Store';

package/packages/analytics-js/src/services/StoreManager/storages/CookieStorage.ts

@@ -0,0 +1,80 @@
+import { isUndefined } from '@rudderstack/analytics-js-common/utilities/checks';
+import type { ICookieStorageOptions, IStorage } from '@rudderstack/analytics-js-common/types/Store';
+import type { Nullable } from '@rudderstack/analytics-js-common/types/Nullable';
+import type { ILogger } from '@rudderstack/analytics-js-common/types/Logger';
+import { COOKIE_STORAGE } from '@rudderstack/analytics-js-common/constants/storages';
+import { mergeDeepRight } from '@rudderstack/analytics-js-common/utilities/object';
+import { isStorageAvailable } from '../../../components/capabilitiesManager/detection';
+import { cookie } from '../component-cookie';
+import { getDefaultCookieOptions } from './defaultOptions';
+
+/**
+ * A storage utility to persist values in cookies via Storage interface
+ */
+class CookieStorage implements IStorage {
+  static globalSingleton: Nullable<CookieStorage> = null;
+  logger?: ILogger;
+  options?: ICookieStorageOptions;
+  isSupportAvailable = true;
+  isEnabled = true;
+  length = 0;
+
+  constructor(options: Partial<ICookieStorageOptions> = {}, logger?: ILogger) {
+    if (CookieStorage.globalSingleton) {
+      // eslint-disable-next-line no-constructor-return
+      return CookieStorage.globalSingleton;
+    }
+
+    this.options = getDefaultCookieOptions();
+    this.logger = logger;
+    this.configure(options);
+
+    CookieStorage.globalSingleton = this;
+  }
+
+  configure(options: Partial<ICookieStorageOptions>): ICookieStorageOptions {
+    this.options = mergeDeepRight(this.options ?? {}, options);
+    if (options.sameDomainCookiesOnly) {
+      delete this.options.domain;
+    }
+    this.isSupportAvailable = isStorageAvailable(COOKIE_STORAGE, this, this.logger);
+    this.isEnabled = Boolean(this.options.enabled && this.isSupportAvailable);
+    return this.options;
+  }
+
+  setItem(key: string, value: Nullable<string>): boolean {
+    cookie(key, value, this.options, this.logger);
+    this.length = Object.keys(cookie()).length;
+    return true;
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  getItem(key: string): Nullable<string> {
+    const value = cookie(key);
+    return isUndefined(value) ? null : value;
+  }
+
+  removeItem(key: string): boolean {
+    const result = this.setItem(key, null);
+    this.length = Object.keys(cookie()).length;
+    return result;
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  clear() {
+    // Not implemented
+    // getting a list of all cookie storage keys and remove all values
+    // sounds risky to do as it will take on all top domain cookies
+    // better to explicitly clear specific ones if needed
+  }
+
+  // This cannot be implemented for cookies
+  // eslint-disable-next-line class-methods-use-this
+  key(index: number): Nullable<string> {
+    const cookies = cookie();
+    const cookieNames = Object.keys(cookies);
+    return isUndefined(cookieNames[index]) ? null : (cookieNames[index] as string);
+  }
+}
+
+export { CookieStorage };

package/packages/analytics-js/src/services/StoreManager/storages/InMemoryStorage.ts

@@ -0,0 +1,66 @@
+import type {
+  IInMemoryStorageOptions,
+  IStorage,
+} from '@rudderstack/analytics-js-common/types/Store';
+import type { ILogger } from '@rudderstack/analytics-js-common/types/Logger';
+import { mergeDeepRight } from '@rudderstack/analytics-js-common/utilities/object';
+import type { Nullable } from '@rudderstack/analytics-js-common/types/Nullable';
+import { defaultLogger } from '../../Logger';
+import { getDefaultInMemoryStorageOptions } from './defaultOptions';
+
+/**
+ * A storage utility to retain values in memory via Storage interface
+ */
+class InMemoryStorage implements IStorage {
+  logger?: ILogger;
+  options: IInMemoryStorageOptions;
+  isEnabled = true;
+  length = 0;
+  data: Record<string, any> = {};
+
+  constructor(options?: IInMemoryStorageOptions, logger?: ILogger) {
+    this.options = getDefaultInMemoryStorageOptions();
+    this.logger = logger;
+    this.configure(options ?? {});
+  }
+
+  configure(options: Partial<IInMemoryStorageOptions>): IInMemoryStorageOptions {
+    this.options = mergeDeepRight(this.options, options);
+    this.isEnabled = Boolean(this.options.enabled);
+    return this.options;
+  }
+
+  setItem(key: string, value: any): any {
+    this.data[key] = value;
+    this.length = Object.keys(this.data).length;
+    return value;
+  }
+
+  getItem(key: string): any {
+    if (key in this.data) {
+      return this.data[key];
+    }
+    return null;
+  }
+
+  removeItem(key: string) {
+    if (key in this.data) {
+      delete this.data[key];
+    }
+    this.length = Object.keys(this.data).length;
+    return null;
+  }
+
+  clear() {
+    this.data = {};
+    this.length = 0;
+  }
+
+  key(index: number): Nullable<string> {
+    return Object.keys(this.data)[index] ? (Object.keys(this.data)[index] as string) : null;
+  }
+}
+
+const defaultInMemoryStorage = new InMemoryStorage({}, defaultLogger);
+
+export { InMemoryStorage, defaultInMemoryStorage };

package/packages/analytics-js/src/services/StoreManager/storages/LocalStorage.ts

@@ -0,0 +1,68 @@
+import store from 'storejs';
+import type { ILocalStorageOptions, IStorage } from '@rudderstack/analytics-js-common/types/Store';
+import type { ILogger } from '@rudderstack/analytics-js-common/types/Logger';
+import { mergeDeepRight } from '@rudderstack/analytics-js-common/utilities/object';
+import { isUndefined } from '@rudderstack/analytics-js-common/utilities/checks';
+import { LOCAL_STORAGE } from '@rudderstack/analytics-js-common/constants/storages';
+import type { Nullable } from '@rudderstack/analytics-js-common/types/Nullable';
+import { isStorageAvailable } from '../../../components/capabilitiesManager/detection';
+import { defaultLogger } from '../../Logger';
+import { getDefaultLocalStorageOptions } from './defaultOptions';
+
+// TODO: can we remove the storejs dependency to save bundle size?
+//  check if the get, set overloads and search methods are used at all
+//  if we do, ensure we provide types to support overloads as per storejs docs
+//  https://www.npmjs.com/package/storejs
+/**
+ * A storage utility to persist values in localstorage via Storage interface
+ */
+class LocalStorage implements IStorage {
+  logger?: ILogger;
+  options: ILocalStorageOptions;
+  isSupportAvailable = true;
+  isEnabled = true;
+  length = 0;
+
+  constructor(options: ILocalStorageOptions = {}, logger?: ILogger) {
+    this.options = getDefaultLocalStorageOptions();
+    this.logger = logger;
+    this.configure(options);
+  }
+
+  configure(options: Partial<ILocalStorageOptions>): ILocalStorageOptions {
+    this.options = mergeDeepRight(this.options, options);
+    this.isSupportAvailable = isStorageAvailable(LOCAL_STORAGE, this, this.logger);
+    this.isEnabled = Boolean(this.options.enabled && this.isSupportAvailable);
+    return this.options;
+  }
+
+  setItem(key: string, value: any) {
+    store.set(key, value);
+    this.length = store.keys().length;
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  getItem(key: string): any {
+    const value = store.get(key);
+    return isUndefined(value) ? null : value;
+  }
+
+  removeItem(key: string) {
+    store.remove(key);
+    this.length = store.keys().length;
+  }
+
+  clear() {
+    store.clear();
+    this.length = 0;
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  key(index: number): Nullable<string> {
+    return store.keys()[index] ? (store.keys()[index] as string) : null;
+  }
+}
+
+const defaultLocalStorage = new LocalStorage({}, defaultLogger);
+
+export { LocalStorage, defaultLocalStorage };

package/packages/analytics-js/src/services/StoreManager/storages/defaultOptions.ts

@@ -0,0 +1,39 @@
+import type {
+  ICookieStorageOptions,
+  IInMemoryStorageOptions,
+  ILocalStorageOptions,
+  ISessionStorageOptions,
+} from '@rudderstack/analytics-js-common/types/Store';
+import { DEFAULT_COOKIE_MAX_AGE_MS } from '../../../constants/timeouts';
+import { domain } from '../top-domain';
+
+const getDefaultCookieOptions = (): ICookieStorageOptions => {
+  const topDomain = domain(globalThis.location.href);
+
+  return {
+    maxage: DEFAULT_COOKIE_MAX_AGE_MS,
+    path: '/',
+    domain: !topDomain || topDomain === '.' ? undefined : topDomain,
+    samesite: 'Lax',
+    enabled: true,
+  };
+};
+
+const getDefaultLocalStorageOptions = (): ILocalStorageOptions => ({
+  enabled: true,
+});
+
+const getDefaultSessionStorageOptions = (): ISessionStorageOptions => ({
+  enabled: true,
+});
+
+const getDefaultInMemoryStorageOptions = (): IInMemoryStorageOptions => ({
+  enabled: true,
+});
+
+export {
+  getDefaultCookieOptions,
+  getDefaultLocalStorageOptions,
+  getDefaultInMemoryStorageOptions,
+  getDefaultSessionStorageOptions,
+};

package/packages/analytics-js/src/services/StoreManager/storages/index.ts

@@ -0,0 +1,18 @@
+export { CookieStorage } from './CookieStorage';
+export { InMemoryStorage, defaultInMemoryStorage } from './InMemoryStorage';
+export { LocalStorage, defaultLocalStorage } from './LocalStorage';
+export { SessionStorage, defaultSessionStorage } from './sessionStorage';
+export {
+  getStorageEngine,
+  configureCookieStorageEngine,
+  configureLocalStorageEngine,
+  configureInMemoryStorageEngine,
+  configureSessionStorageEngine,
+  configureStorageEngines,
+} from './storageEngine';
+export {
+  getDefaultCookieOptions,
+  getDefaultLocalStorageOptions,
+  getDefaultInMemoryStorageOptions,
+  getDefaultSessionStorageOptions,
+} from './defaultOptions';