iureiure 1.0.0

package/packages/analytics-js/__tests__/services/StoreManager/Store.test.ts

@@ -0,0 +1,152 @@
+import { QueueStatuses } from '@rudderstack/analytics-js-common/constants/QueueStatuses';
+import { Store } from '../../../src/services/StoreManager/Store';
+import { getStorageEngine } from '../../../src/services/StoreManager/storages/storageEngine';
+
+describe('Store', () => {
+  let store: Store;
+  const engine = window.localStorage;
+  const lsProxy = {
+    length: window.localStorage.length,
+    setItem(k: string, v: any) {
+      return window.localStorage.setItem(k, v);
+    },
+    getItem(k: string) {
+      return window.localStorage.getItem(k);
+    },
+    removeItem(k: string) {
+      return window.localStorage.removeItem(k);
+    },
+    clear: () => window.localStorage.clear(),
+    key(i: number) {
+      return window.localStorage.key(i);
+    },
+  };
+
+  beforeEach(() => {
+    engine.clear();
+    store = new Store(
+      {
+        name: 'name',
+        id: 'id',
+        validKeys: QueueStatuses,
+      },
+      getStorageEngine('localStorage'),
+    );
+  });
+
+  describe('.get', () => {
+    it('should default to null', () => {
+      Object.values(QueueStatuses).forEach(keyValue => {
+        expect(store.get(keyValue)).toBeNull();
+      });
+    });
+
+    it('should de-serialize json', () => {
+      Object.values(QueueStatuses).forEach(keyValue => {
+        engine.setItem(`name.id.${keyValue}`, '"[\\"a\\",\\"b\\",{}]"');
+        expect(store.get(keyValue)).toStrictEqual(['a', 'b', {}]);
+      });
+    });
+
+    // TODO: fix, caused by Difference is the storejs and retry-queue localstorage implementation
+    it('should return null if value is not valid json', () => {
+      engine.setItem('name.id.queue', '[{]}');
+      expect(store.get(QueueStatuses.QUEUE)).toBeNull();
+    });
+  });
+
+  describe('.set', () => {
+    it('should serialize json', () => {
+      Object.values(QueueStatuses).forEach(keyValue => {
+        store.set(keyValue, ['a', 'b', {}]);
+        expect(engine.getItem(`name.id.${keyValue}`)).toStrictEqual('"[\\"a\\",\\"b\\",{}]"');
+      });
+    });
+  });
+
+  describe('.remove', () => {
+    it('should remove the item', () => {
+      Object.values(QueueStatuses).forEach(keyValue => {
+        store.set(keyValue, 'a');
+        store.remove(keyValue);
+        expect(engine.getItem(`name.id.${keyValue}`)).toBeNull();
+      });
+    });
+  });
+
+  describe('.createValidKey', () => {
+    it('should return compound if no QueueStatuses specd', () => {
+      Object.values(QueueStatuses).forEach(() => {
+        store = new Store(
+          {
+            name: 'name',
+            id: 'id',
+          },
+          getStorageEngine('localStorage'),
+        );
+        expect(store.createValidKey('test')).toStrictEqual('name.id.test');
+      });
+    });
+
+    it('should return undefined if invalid key', () => {
+      Object.values(QueueStatuses).forEach(() => {
+        store = new Store(
+          {
+            name: 'name',
+            id: 'id',
+            validKeys: { nope: 'wrongKey' },
+          },
+          getStorageEngine('localStorage'),
+        );
+        expect(store.createValidKey('test')).toBeUndefined();
+      });
+    });
+
+    it('should return compound if valid key', () => {
+      store = new Store(
+        {
+          name: 'name',
+          id: 'id',
+        },
+        getStorageEngine('localStorage'),
+      );
+      expect(store.createValidKey('queue')).toStrictEqual('name.id.queue');
+    });
+  });
+
+  describe('.swapEngine', () => {
+    it('should switch the underlying storage mechanism', () => {
+      expect(store.engine).toStrictEqual(getStorageEngine('localStorage'));
+      store.swapQueueStoreToInMemoryEngine();
+      expect(store.engine).toStrictEqual(getStorageEngine('memoryStorage'));
+    });
+
+    it('should not switch the original storage mechanism', () => {
+      expect(store.getOriginalEngine()).toStrictEqual(getStorageEngine('localStorage'));
+      store.swapQueueStoreToInMemoryEngine();
+      expect(store.getOriginalEngine()).toStrictEqual(getStorageEngine('localStorage'));
+    });
+
+    it('should swap upon quotaExceeded on set', () => {
+      store = new Store(
+        {
+          name: 'name',
+          id: 'id',
+          validKeys: QueueStatuses,
+        },
+        lsProxy,
+      );
+
+      Object.keys(QueueStatuses).forEach(keyValue => {
+        store.set(keyValue, 'stuff');
+      });
+
+      store.engine.setItem = () => {
+        throw new DOMException('error', 'QuotaExceededError');
+      };
+
+      store.set(QueueStatuses.QUEUE, 'other');
+      expect(store.get(QueueStatuses.QUEUE)).toStrictEqual('other');
+    });
+  });
+});

package/packages/analytics-js/__tests__/services/StoreManager/StoreManager.test.ts

@@ -0,0 +1,272 @@
+import { IErrorHandler } from '@rudderstack/analytics-js-common/types/ErrorHandler';
+import { ILogger } from '@rudderstack/analytics-js-common/types/Logger';
+import {
+  LOCAL_STORAGE,
+  MEMORY_STORAGE,
+  NO_STORAGE,
+  SESSION_STORAGE,
+  COOKIE_STORAGE,
+} from '@rudderstack/analytics-js-common/constants/storages';
+import {
+  configureStorageEngines,
+  getStorageEngine,
+} from '../../../src/services/StoreManager/storages/storageEngine';
+import { state, resetState } from '../../../src/state';
+import { StoreManager } from '../../../src/services/StoreManager';
+import { PluginsManager } from '../../../src/components/pluginsManager';
+import { defaultPluginEngine } from '../../../src/services/PluginEngine';
+import { defaultErrorHandler } from '../../../src/services/ErrorHandler';
+import { defaultLogger } from '../../../src/services/Logger';
+import {
+  entriesWithOnlyCookieStorage,
+  entriesWithOnlyLocalStorage,
+  entriesWithOnlyNoStorage,
+  entriesWithMixStorage,
+  loadOptionWithEntry,
+  loadOptionWithInvalidEntry,
+  entriesWithStorageOnlyForSession,
+  entriesWithStorageOnlyForAnonymousId,
+  entriesWithOnlySessionStorage,
+  entriesWithInMemoryFallback,
+  postConsentStorageEntryOptions,
+  entriesWithoutCookieStorage,
+  entriesWithoutCookieAndLocalStorage,
+} from '../../../__fixtures__/fixtures';
+
+jest.mock('../../../src/services/StoreManager/storages/storageEngine', () => ({
+  __esModule: true,
+  configureStorageEngines: jest.fn(),
+  getStorageEngine: jest.fn().mockReturnValue({
+    isEnabled: true,
+    getItem: jest.fn(),
+    setItem: jest.fn(),
+    removeItem: jest.fn(),
+  }),
+}));
+
+describe('StoreManager', () => {
+  let errorHandler: IErrorHandler;
+  let logger: ILogger;
+  let storeManager: StoreManager;
+  const defaultPluginsManager = new PluginsManager(
+    defaultPluginEngine,
+    defaultErrorHandler,
+    defaultLogger,
+  );
+
+  beforeEach(() => {
+    resetState();
+    errorHandler = { onError: jest.fn() };
+    logger = { error: jest.fn(), warn: jest.fn() };
+    storeManager = new StoreManager(defaultPluginsManager, errorHandler, logger);
+  });
+
+  afterEach(() => {
+    storeManager.isInitialized = false;
+    jest.resetAllMocks();
+    jest.resetModules();
+  });
+
+  describe('init', () => {
+    it('should initialize storage engines and create stores', () => {
+      storeManager.init();
+
+      expect(configureStorageEngines).toHaveBeenCalledWith(
+        {
+          samesite: state.loadOptions.value.sameSiteCookie,
+          secure: state.loadOptions.value.secureCookie,
+          domain: state.loadOptions.value.setCookieDomain,
+          enabled: true,
+        },
+        { enabled: true },
+        { enabled: true },
+        { enabled: true },
+      );
+
+      expect(storeManager.stores).toHaveProperty('clientDataInCookie');
+    });
+
+    it('should not initialize if already initialized', () => {
+      storeManager.isInitialized = true;
+      storeManager.init();
+      expect(configureStorageEngines).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('initClientDataStores', () => {
+    beforeEach(() => {
+      getStorageEngine.mockImplementation(() => ({
+        isEnabled: true,
+        getItem: jest.fn(),
+        setItem: jest.fn(),
+        removeItem: jest.fn(),
+      }));
+    });
+
+    afterEach(() => {
+      jest.resetAllMocks();
+    });
+
+    it('should initialize client data store for cookie,LS,memory storage,session storage', () => {
+      storeManager.initClientDataStores();
+
+      expect(storeManager.stores).toHaveProperty('clientDataInCookie');
+      expect(storeManager.stores).toHaveProperty('clientDataInLocalStorage');
+      expect(storeManager.stores).toHaveProperty('clientDataInMemory');
+      expect(storeManager.stores).toHaveProperty('clientDataInSessionStorage');
+    });
+
+    it('should construct the storage entry state with default storage type if entries or global storage type not provided as load option', () => {
+      storeManager.initClientDataStores();
+      expect(state.storage.entries.value).toEqual(entriesWithOnlyCookieStorage);
+      expect(state.storage.trulyAnonymousTracking.value).toBe(false);
+    });
+
+    it('should construct the storage entry state with global storage type if only global storage type is provided as load option', () => {
+      state.storage.type.value = LOCAL_STORAGE;
+      storeManager.initClientDataStores();
+      expect(state.storage.entries.value).toEqual(entriesWithOnlyLocalStorage);
+    });
+
+    it('should enable truly anonymous tracking if all the persisted data have storage type none', () => {
+      state.storage.type.value = NO_STORAGE;
+      storeManager.initClientDataStores();
+      expect(state.storage.entries.value).toEqual(entriesWithOnlyNoStorage);
+      expect(state.storage.trulyAnonymousTracking.value).toBe(true);
+    });
+
+    it('should construct the storage entry state with global type session storage', () => {
+      state.storage.type.value = SESSION_STORAGE;
+      getStorageEngine.mockImplementation(() => ({
+        isEnabled: true,
+        getItem: jest.fn(),
+        setItem: jest.fn(),
+        removeItem: jest.fn(),
+      }));
+      storeManager.initClientDataStores();
+      expect(state.storage.entries.value).toEqual(entriesWithOnlySessionStorage);
+    });
+
+    it('should construct the storage entry state with global type and load options', () => {
+      state.storage.type.value = MEMORY_STORAGE;
+      state.loadOptions.value.storage.entries = loadOptionWithEntry;
+      storeManager.initClientDataStores();
+      expect(state.storage.entries.value).toEqual(entriesWithMixStorage);
+      expect(state.storage.trulyAnonymousTracking.value).toBe(false);
+    });
+
+    it('should construct the valid storage entry state if invalid storage entry in load option', () => {
+      state.loadOptions.value.storage.entries = loadOptionWithInvalidEntry;
+      storeManager.initClientDataStores();
+      expect(state.storage.entries.value).toEqual(entriesWithOnlyCookieStorage);
+      expect(logger.warn).toHaveBeenCalled();
+      expect(state.storage.trulyAnonymousTracking.value).toBe(false);
+    });
+
+    it('should fallback to localstorage for storage type cookie if localstorage is available', () => {
+      getStorageEngine.mockImplementation(type => ({
+        isEnabled: type !== COOKIE_STORAGE,
+        getItem: jest.fn(),
+        setItem: jest.fn(),
+        removeItem: jest.fn(),
+      }));
+
+      state.loadOptions.value.storage.entries = loadOptionWithEntry;
+
+      storeManager.initClientDataStores();
+      expect(state.storage.entries.value).toEqual(entriesWithoutCookieStorage);
+    });
+
+    it('should fallback to session storage for storage type cookie if cookie and local storage are unavailable', () => {
+      getStorageEngine.mockImplementation(type => ({
+        isEnabled: type === SESSION_STORAGE || type === MEMORY_STORAGE,
+        getItem: jest.fn(),
+        setItem: jest.fn(),
+        removeItem: jest.fn(),
+      }));
+
+      state.loadOptions.value.storage.entries = loadOptionWithEntry;
+
+      storeManager.initClientDataStores();
+      expect(state.storage.entries.value).toEqual(entriesWithoutCookieAndLocalStorage);
+    });
+
+    it('should fallback to default storage type if specified storage type is unavailable', () => {
+      getStorageEngine.mockImplementation(() => ({
+        isEnabled: false,
+        getItem: jest.fn(),
+        setItem: jest.fn(),
+        removeItem: jest.fn(),
+      }));
+
+      state.loadOptions.value.storage.entries = loadOptionWithEntry;
+      storeManager.initClientDataStores();
+      expect(state.storage.entries.value).toEqual(entriesWithInMemoryFallback);
+      expect(logger.warn).toBeCalledTimes(8);
+    });
+
+    it('should construct the appropriate storage entry state if the pre-consent storage strategy is set to none', () => {
+      state.consents.preConsent.value = {
+        enabled: true,
+        storage: {
+          strategy: 'none',
+        },
+      };
+      storeManager.initClientDataStores();
+      expect(state.storage.entries.value).toEqual(entriesWithOnlyNoStorage);
+      expect(state.storage.trulyAnonymousTracking.value).toBe(true);
+    });
+
+    it('should construct the appropriate storage entry state if the pre-consent storage strategy is set to session', () => {
+      state.consents.preConsent.value = {
+        enabled: true,
+        storage: {
+          strategy: 'session',
+        },
+      };
+      storeManager.initClientDataStores();
+      expect(state.storage.entries.value).toEqual(entriesWithStorageOnlyForSession);
+      expect(state.storage.trulyAnonymousTracking.value).toBe(false);
+    });
+
+    it('should construct the appropriate storage entry state if the pre-consent storage strategy is set to anonymousId', () => {
+      state.consents.preConsent.value = {
+        enabled: true,
+        storage: {
+          strategy: 'anonymousId',
+        },
+      };
+      storeManager.initClientDataStores();
+      expect(state.storage.entries.value).toEqual(entriesWithStorageOnlyForAnonymousId);
+      expect(state.storage.trulyAnonymousTracking.value).toBe(false);
+    });
+
+    it('should construct the appropriate storage entry state if post consent storage options are available', () => {
+      state.loadOptions.value.storage.entries = entriesWithOnlyNoStorage; // these options should be ignored
+      state.consents.postConsent.value = {
+        storage: {
+          type: MEMORY_STORAGE,
+          entries: postConsentStorageEntryOptions,
+        },
+      };
+
+      storeManager.initClientDataStores();
+
+      expect(state.storage.entries.value).toEqual(entriesWithMixStorage);
+    });
+
+    describe('Stores', () => {
+      it('should set store', () => {
+        storeManager.setStore({
+          id: 'dummyStore',
+          name: 'dummy',
+          isEncrypted: true,
+          noCompoundKey: true,
+          type: 'cookieStorage',
+        });
+
+        expect(storeManager.stores).toHaveProperty('dummyStore');
+      });
+    });
+  });
+});

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

@@ -0,0 +1,65 @@
+import { cookie } from '../../../../src/services/StoreManager/component-cookie';
+
+// TODO: clean up structure here, clean up cookie before each test
+describe('cookie(name, value)', () => {
+  it('should set a cookie', () => {
+    cookie('name', 'tobi');
+    expect('tobi').toEqual(cookie('name'));
+
+    cookie('species', 'ferret');
+    expect('ferret').toEqual(cookie('species'));
+  });
+
+  it('should escape', () => {
+    cookie('name', 'tobi ferret');
+    expect(document.cookie.includes('name=tobi%20ferret')).toBeTruthy();
+  });
+
+  it('should unescape', () => {
+    cookie('full name', 'tobi ferret');
+    expect('tobi ferret').toEqual(cookie('full name'));
+  });
+
+  it('should ignore URIError', () => {
+    cookie('bad', '%');
+    cookie('bad', null);
+    expect(undefined).toEqual(cookie('bad'));
+  });
+});
+
+describe('when undefined', () => {
+  it('should return undefined', () => {
+    expect(undefined).toEqual(cookie('whatever'));
+  });
+});
+
+describe('cookie(name, null)', () => {
+  it('should clear the cookie', () => {
+    cookie('type', 'ferret');
+    cookie('type', null);
+    expect(undefined).toEqual(cookie('type'));
+  });
+
+  it('should not be returned in the cookie() object', () => {
+    cookie('full name', null);
+    cookie('mydb', null);
+    cookie('species', null);
+    cookie('name', '0');
+    const obj = cookie();
+
+    expect(1).toEqual(Object.keys(obj).length);
+    expect('0').toEqual(obj.name);
+  });
+});
+
+describe('cookie()', () => {
+  it('should return all cookies', () => {
+    cookie('name', 'loki');
+    cookie('species', 'ferret');
+    const obj = cookie();
+
+    expect(2).toEqual(Object.keys(obj).length);
+    expect('loki').toEqual(obj.name);
+    expect('ferret').toEqual(obj.species);
+  });
+});

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

@@ -0,0 +1,42 @@
+import { IStorage } from '@rudderstack/analytics-js-common/types/Store';
+import {
+  getStorageEngine,
+  configureCookieStorageEngine,
+} from '../../../../src/services/StoreManager/storages/storageEngine';
+
+describe('CookieStorage', () => {
+  let engine: IStorage;
+
+  beforeEach(() => {
+    engine = getStorageEngine('cookieStorage');
+    engine.clear();
+  });
+
+  it('should function as expected', () => {
+    engine.setItem('test-key', 'abc');
+    expect(engine.getItem('test-key')).toStrictEqual('abc');
+    expect(engine.length).toStrictEqual(1);
+    expect(engine.key(0)).toStrictEqual('test-key');
+
+    engine.removeItem('test-key');
+    expect(engine.getItem('test-key')).toBeNull();
+    expect(engine.length).toStrictEqual(0);
+
+    // clear not implemented intentionally, see source code comments
+    // engine.setItem('test-key', 'abc');
+    // engine.clear();
+    // expect(engine.length).toStrictEqual(0);
+  });
+  it('should not set domain if sameDomainCookiesOnly is set to true', () => {
+    expect(typeof engine.options.domain).toBe('string');
+    configureCookieStorageEngine({
+      samesite: 'Lax',
+      domain: 'example.com',
+      maxage: 31536000000,
+      enabled: true,
+      sameDomainCookiesOnly: true,
+    });
+    const newEngine = getStorageEngine('cookieStorage');
+    expect(newEngine.options.domain).toBe(undefined);
+  });
+});

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

@@ -0,0 +1,26 @@
+import { IStorage } from '@rudderstack/analytics-js-common/types/Store';
+import { getStorageEngine } from '../../../../src/services/StoreManager/storages/storageEngine';
+
+describe('InMemoryStorage', () => {
+  let engine: IStorage;
+
+  beforeEach(() => {
+    engine = getStorageEngine('memoryStorage');
+    engine.clear();
+  });
+
+  it('should function as expected', () => {
+    engine.setItem('test-key', 'abc');
+    expect(engine.getItem('test-key')).toStrictEqual('abc');
+    expect(engine.length).toStrictEqual(1);
+    expect(engine.key(0)).toStrictEqual('test-key');
+
+    engine.removeItem('test-key');
+    expect(engine.getItem('test-key')).toBeNull();
+    expect(engine.length).toStrictEqual(0);
+
+    engine.setItem('test-key', 'abc');
+    engine.clear();
+    expect(engine.length).toStrictEqual(0);
+  });
+});

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

@@ -0,0 +1,26 @@
+import { IStorage } from '@rudderstack/analytics-js-common/types/Store';
+import { getStorageEngine } from '../../../../src/services/StoreManager/storages/storageEngine';
+
+describe('Localstorage', () => {
+  let engine: IStorage;
+
+  beforeEach(() => {
+    engine = getStorageEngine('localStorage');
+    engine.clear();
+  });
+
+  it('should function as expected', () => {
+    engine.setItem('test-key', 'abc');
+    expect(engine.getItem('test-key')).toStrictEqual('abc');
+    expect(engine.length).toStrictEqual(1);
+    expect(engine.key(0)).toStrictEqual('test-key');
+
+    engine.removeItem('test-key');
+    expect(engine.getItem('test-key')).toBeNull();
+    expect(engine.length).toStrictEqual(0);
+
+    engine.setItem('test-key', 'abc');
+    engine.clear();
+    expect(engine.length).toStrictEqual(0);
+  });
+});

package/packages/analytics-js/__tests__/services/StoreManager/storages/sessionStorage.test.ts

@@ -0,0 +1,26 @@
+import { IStorage } from '@rudderstack/analytics-js-common/types/Store';
+import { getStorageEngine } from '../../../../src/services/StoreManager/storages/storageEngine';
+
+describe('SessionStorage', () => {
+  let engine: IStorage;
+
+  beforeEach(() => {
+    engine = getStorageEngine('sessionStorage');
+    engine.clear();
+  });
+
+  it('should function as expected', () => {
+    engine.setItem('test-key', 'abc');
+    expect(engine.getItem('test-key')).toStrictEqual('abc');
+    expect(engine.length).toStrictEqual(1);
+    expect(engine.key(0)).toStrictEqual('test-key');
+
+    engine.removeItem('test-key');
+    expect(engine.getItem('test-key')).toBeNull();
+    expect(engine.length).toStrictEqual(0);
+
+    engine.setItem('test-key', 'abc');
+    engine.clear();
+    expect(engine.length).toStrictEqual(0);
+  });
+});

package/packages/analytics-js/__tests__/services/StoreManager/top-domain/index.test.ts

@@ -0,0 +1,60 @@
+import { Nullable } from '@rudderstack/analytics-js-common/types/Nullable';
+import { CookieOptions } from '@rudderstack/analytics-js-common/types/Store';
+import { domain } from '../../../../src/services/StoreManager/top-domain';
+import { cookie } from '../../../../src/services/StoreManager/component-cookie';
+
+let cookies: Record<string, any> = {};
+
+jest.mock('../../../../src/services/StoreManager/component-cookie', () => {
+  const originalModule = jest.requireActual(
+    '../../../../src/services/StoreManager/component-cookie',
+  );
+
+  return {
+    __esModule: true,
+    ...originalModule,
+    cookie: jest.fn(
+      (name: string, value: Nullable<string | number>, options: CookieOptions): void | any => {
+        if (value || options) {
+          const parts = options.domain?.split('.') || [];
+
+          if (parts[1] === 'co') {
+            return undefined;
+          }
+
+          cookies[name] = value;
+          return cookies[name];
+        }
+
+        if (name) {
+          return cookies[name];
+        }
+
+        return cookies;
+      },
+    ),
+  };
+});
+
+describe('topDomain', () => {
+  beforeEach(() => {
+    cookies = {};
+  });
+
+  it('should match the following urls', () => {
+    expect(jest.isMockFunction(cookie)).toBeTruthy();
+    cookie('test', 1, { domain: window.location.hostname });
+    expect(domain('http://www.google.com')).toEqual('google.com');
+    expect(domain('http://www.google.co.uk')).toEqual('google.co.uk');
+    expect(domain('http://google.co.uk')).toEqual('google.co.uk');
+    expect(domain('http://google.co.il')).toEqual('google.co.il');
+    expect(domain('http://gist.github.com/calvinfo/some_file')).toEqual('github.com');
+    expect(domain('http://localhost:3000')).toEqual('localhost');
+    expect(domain('https://google.com:443/stuff')).toEqual('google.com');
+    expect(domain('http://dev:3000')).toEqual('');
+    expect(domain('http://0.0.0.0')).toEqual('');
+    expect(domain('http://127.0.0.1')).toEqual('');
+    expect(domain('http://86.77.65.90')).toEqual('');
+    expect(domain('http://app.rudderstack.com')).toEqual('rudderstack.com');
+  });
+});

package/packages/analytics-js/babel.config.json

@@ -0,0 +1,15 @@
+{
+  "presets": [
+    [
+      "@babel/env",
+      {
+        "corejs": "3.6",
+        "useBuiltIns": "entry",
+        "bugfixes": true,
+        "debug": false
+      }
+    ],
+    "@babel/typescript"
+  ],
+  "plugins": []
+}