iureiure 1.0.0

package/packages/analytics-js-common/__tests__/utilities/json.test.ts

@@ -0,0 +1,155 @@
+import { clone } from 'ramda';
+import { stringifyWithoutCircular } from '../../src/utilities/json';
+
+const identifyTraitsPayloadMock: Record<string, any> = {
+  firstName: 'Dummy Name',
+  phone: '1234567890',
+  email: 'dummy@email.com',
+  custom_flavor: 'chocolate',
+  custom_date: new Date(2022, 1, 21, 0, 0, 0),
+  address: [
+    {
+      label: 'office',
+      city: 'Brussels',
+      country: 'Belgium',
+    },
+    {
+      label: 'home',
+      city: 'Kolkata',
+      country: 'India',
+      nested: {
+        type: 'flat',
+        rooms: [
+          {
+            name: 'kitchen',
+            size: 'small',
+          },
+          {
+            // eslint-disable-next-line sonarjs/no-duplicate-string
+            name: 'living room',
+            size: 'large',
+          },
+          {
+            name: 'bedroom',
+            size: 'large',
+          },
+        ],
+      },
+    },
+    {
+      label: 'work',
+      city: 'Kolkata',
+      country: 'India',
+    },
+  ],
+  stringArray: ['string1', 'string2', 'string3'],
+  numberArray: [1, 2, 3],
+};
+
+const circularReferenceNotice = '[Circular Reference]';
+
+describe('Common Utils - JSON', () => {
+  describe('stringifyWithoutCircular', () => {
+    it('should stringify json with circular references', () => {
+      const objWithCircular = clone(identifyTraitsPayloadMock);
+      objWithCircular.myself = objWithCircular;
+
+      const json = stringifyWithoutCircular(objWithCircular);
+      expect(json).toContain(circularReferenceNotice);
+    });
+
+    it('should stringify json with circular references and exclude null values', () => {
+      const objWithCircular = clone(identifyTraitsPayloadMock);
+      objWithCircular.myself = objWithCircular;
+      objWithCircular.keyToExclude = null;
+      objWithCircular.keyToNotExclude = '';
+
+      const json = stringifyWithoutCircular(objWithCircular, true);
+      expect(json).toContain(circularReferenceNotice);
+      expect(json).not.toContain('keyToExclude');
+      expect(json).toContain('keyToNotExclude');
+    });
+
+    it('should stringify json with out circular references', () => {
+      const objWithoutCircular = clone(identifyTraitsPayloadMock);
+      objWithoutCircular.myself = {};
+
+      const json = stringifyWithoutCircular(objWithoutCircular);
+      expect(json).not.toContain(circularReferenceNotice);
+    });
+
+    it('should stringify json with out circular references and reused objects', () => {
+      const objWithoutCircular = clone(identifyTraitsPayloadMock);
+      const reusableArray = [1, 2, 3];
+      const reusableObject = { dummy: 'val' };
+      objWithoutCircular.reused = reusableArray;
+      objWithoutCircular.reusedAgain = [1, 2, reusableArray];
+      objWithoutCircular.reusedObj = reusableObject;
+      objWithoutCircular.reusedObjAgain = { reused: reusableObject };
+      objWithoutCircular.reusedObjAgainWithItself = { reused: reusableObject };
+
+      const json = stringifyWithoutCircular(objWithoutCircular);
+      expect(json).not.toContain(circularReferenceNotice);
+    });
+
+    it('should stringify json with circular references for nested circular objects', () => {
+      const objWithoutCircular = clone(identifyTraitsPayloadMock);
+      const reusableObject = { dummy: 'val' };
+      const objWithCircular = clone(reusableObject);
+      objWithCircular.myself = objWithCircular;
+      objWithoutCircular.reusedObjAgainWithItself = { reused: reusableObject };
+      objWithoutCircular.objWithCircular = objWithCircular;
+
+      const json = stringifyWithoutCircular(objWithoutCircular);
+      expect(json).toContain(circularReferenceNotice);
+    });
+
+    it('should stringify json for all input types', () => {
+      const array = [1, 2, 3];
+      const number = 1;
+      const string = '';
+      const object = {};
+      const date = new Date(2023, 1, 20, 0, 0, 0);
+
+      const arrayJson = stringifyWithoutCircular(array);
+      const numberJson = stringifyWithoutCircular(number);
+      const stringJson = stringifyWithoutCircular(string);
+      const objectJson = stringifyWithoutCircular(object);
+      const dateJson = stringifyWithoutCircular(date);
+      const nullJson = stringifyWithoutCircular(null);
+      const undefinedJson = stringifyWithoutCircular(undefined);
+
+      expect(arrayJson).toBe('[1,2,3]');
+      expect(numberJson).toBe('1');
+      expect(stringJson).toBe('""');
+      expect(objectJson).toBe('{}');
+      expect(dateJson).toBe('"2023-02-19T18:30:00.000Z"');
+      expect(nullJson).toBe('null');
+      expect(undefinedJson).toBe(undefined);
+    });
+
+    it('should stringify json after removing the exclude keys', () => {
+      const objWithoutCircular = clone(identifyTraitsPayloadMock);
+
+      const json = stringifyWithoutCircular(objWithoutCircular, true, ['size', 'city']);
+      expect(json).not.toContain('size');
+      expect(json).not.toContain('city');
+    });
+
+    it('should return null for input containing BigInt values', () => {
+      const mockLogger = {
+        warn: jest.fn(),
+      };
+
+      const objWithBigInt = {
+        bigInt: BigInt(9007199254740991),
+      };
+      const json = stringifyWithoutCircular(objWithBigInt, false, [], mockLogger);
+      expect(json).toBe(null);
+      expect(mockLogger.warn).toHaveBeenCalledWith(
+        'Failed to convert the value to a JSON string.',
+        new TypeError('Do not know how to serialize a BigInt'),
+      );
+    });
+  });
+});

package/packages/analytics-js-common/__tests__/utilities/object.test.ts

@@ -0,0 +1,287 @@
+// eslint-disable-next-line max-classes-per-file
+import {
+  mergeDeepRight,
+  mergeDeepRightObjectArrays,
+  isNonEmptyObject,
+  isObjectAndNotNull,
+  isObjectLiteralAndNotNull,
+  removeUndefinedValues,
+  removeUndefinedAndNullValues,
+} from '../../src/utilities/object';
+
+const identifyTraitsPayloadMock = {
+  firstName: 'Dummy Name',
+  phone: '1234567890',
+  email: 'dummy@email.com',
+  custom_flavor: 'chocolate',
+  custom_date: new Date(2022, 1, 21, 0, 0, 0),
+  address: [
+    {
+      label: 'office',
+      city: 'Brussels',
+      country: 'Belgium',
+    },
+    {
+      label: 'home',
+      city: 'Kolkata',
+      country: 'India',
+      nested: {
+        type: 'flat',
+        rooms: [
+          {
+            name: 'kitchen',
+            size: 'small',
+          },
+          {
+            // eslint-disable-next-line sonarjs/no-duplicate-string
+            name: 'living room',
+            size: 'large',
+          },
+          {
+            name: 'bedroom',
+            size: 'large',
+          },
+        ],
+      },
+    },
+    {
+      label: 'work',
+      city: 'Kolkata',
+      country: 'India',
+    },
+  ],
+  stringArray: ['string1', 'string2', 'string3'],
+  numberArray: [1, 2, 3],
+};
+
+const trackTraitsOverridePayloadMock = {
+  address: [
+    {
+      label: 'Head office',
+      city: 'NYC',
+    },
+    {
+      label: 'home',
+      city: 'Kolkata',
+      country: 'India',
+      nested: {
+        type: 'detached house',
+        rooms: [
+          {
+            name: 'bath',
+          },
+          {
+            name: 'living room',
+            size: 'extra large',
+          },
+        ],
+      },
+    },
+  ],
+  stringArray: ['newString1', 'newString2'],
+  numberArray: [4, 5],
+};
+
+const expectedMergedTraitsPayload = {
+  firstName: 'Dummy Name',
+  phone: '1234567890',
+  email: 'dummy@email.com',
+  custom_flavor: 'chocolate',
+  custom_date: new Date(2022, 1, 21, 0, 0, 0),
+  address: [
+    {
+      label: 'Head office',
+      city: 'NYC',
+      country: 'Belgium',
+    },
+    {
+      label: 'home',
+      city: 'Kolkata',
+      country: 'India',
+      nested: {
+        type: 'detached house',
+        rooms: [
+          {
+            name: 'bath',
+            size: 'small',
+          },
+          {
+            name: 'living room',
+            size: 'extra large',
+          },
+          {
+            name: 'bedroom',
+            size: 'large',
+          },
+        ],
+      },
+    },
+    {
+      label: 'work',
+      city: 'Kolkata',
+      country: 'India',
+    },
+  ],
+  stringArray: ['newString1', 'newString2', 'string3'],
+  numberArray: [4, 5, 3],
+};
+
+describe('Common Utils - Object', () => {
+  describe('mergeDeepRight', () => {
+    it('should merge right object array items', () => {
+      const mergedArray = mergeDeepRightObjectArrays(
+        identifyTraitsPayloadMock.address,
+        trackTraitsOverridePayloadMock.address,
+      );
+      expect(mergedArray).toEqual(expectedMergedTraitsPayload.address);
+    });
+
+    it('should merge right non object array items', () => {
+      const mergedArray = mergeDeepRightObjectArrays(
+        identifyTraitsPayloadMock.stringArray,
+        trackTraitsOverridePayloadMock.stringArray,
+      );
+      const mergedNumberArray = mergeDeepRightObjectArrays(
+        identifyTraitsPayloadMock.numberArray,
+        trackTraitsOverridePayloadMock.numberArray,
+      );
+      expect(mergedArray).toEqual(expectedMergedTraitsPayload.stringArray);
+      expect(mergedNumberArray).toEqual(expectedMergedTraitsPayload.numberArray);
+    });
+
+    it('should merge right nested object properties', () => {
+      const mergedArray = mergeDeepRight(identifyTraitsPayloadMock, trackTraitsOverridePayloadMock);
+      expect(mergedArray).toEqual(expectedMergedTraitsPayload);
+    });
+  });
+
+  describe('isObjectAndNotNull', () => {
+    it('should detect if value is an Object and not null', () => {
+      class DummyClass {}
+      const nullCheck = isObjectAndNotNull(null);
+      const objCheck = isObjectAndNotNull({});
+      const classInstanceCheck = isObjectAndNotNull(new DummyClass());
+      const arrayCheck = isObjectAndNotNull([]);
+      const functionCheck = isObjectAndNotNull(() => {});
+      const dateCheck = isObjectAndNotNull(new Date());
+      const errorCheck = isObjectAndNotNull(new Error('error'));
+      // eslint-disable-next-line prefer-regex-literals
+      const regExpCheck = isObjectAndNotNull(new RegExp(/^a/));
+      expect(nullCheck).toBeFalsy();
+      expect(objCheck).toBeTruthy();
+      expect(classInstanceCheck).toBeTruthy();
+      expect(arrayCheck).toBeFalsy();
+      expect(functionCheck).toBeFalsy();
+      expect(dateCheck).toBeTruthy();
+      expect(errorCheck).toBeTruthy();
+      expect(regExpCheck).toBeTruthy();
+    });
+  });
+
+  describe('isObjectLiteralAndNotNull', () => {
+    it('should detect if value is an Object and not null', () => {
+      class DummyClass {}
+      const nullCheck = isObjectLiteralAndNotNull(null);
+      const objCheck = isObjectLiteralAndNotNull({});
+      const classInstanceCheck = isObjectLiteralAndNotNull(new DummyClass());
+      const arrayCheck = isObjectLiteralAndNotNull([]);
+      const functionCheck = isObjectLiteralAndNotNull(() => {});
+      const dateCheck = isObjectLiteralAndNotNull(new Date());
+      const errorCheck = isObjectLiteralAndNotNull(new Error('error'));
+      // eslint-disable-next-line prefer-regex-literals
+      const regExpCheck = isObjectLiteralAndNotNull(new RegExp(/^a/));
+      expect(nullCheck).toBeFalsy();
+      expect(objCheck).toBeTruthy();
+      expect(classInstanceCheck).toBeTruthy();
+      expect(arrayCheck).toBeFalsy();
+      expect(functionCheck).toBeFalsy();
+      expect(dateCheck).toBeFalsy();
+      expect(errorCheck).toBeFalsy();
+      expect(regExpCheck).toBeFalsy();
+    });
+  });
+
+  describe('isNonEmptyObject', () => {
+    it('should return true for valid object with data', () => {
+      const validObj = {
+        key1: 'value',
+        key2: 1234567,
+      };
+      const outcome = isNonEmptyObject(validObj);
+      expect(outcome).toEqual(true);
+    });
+
+    it('should return false for undefined/null or empty object', () => {
+      const outcome1 = isNonEmptyObject(undefined);
+      const outcome2 = isNonEmptyObject(null);
+      const outcome3 = isNonEmptyObject({});
+      expect(outcome1).toEqual(false);
+      expect(outcome2).toEqual(false);
+      expect(outcome3).toEqual(false);
+    });
+  });
+
+  describe('removeUndefinedValues', () => {
+    it('should remove undefined values from deeply nested object', () => {
+      const nestedObj = {
+        key1: 'value',
+        key2: undefined,
+        key3: {
+          key4: 'value',
+          key5: undefined,
+          key6: {
+            key7: 'value',
+            key8: undefined,
+          },
+        },
+        key9: {
+          key10: undefined,
+        },
+      };
+      const outcome = removeUndefinedValues(nestedObj);
+      expect(outcome).toStrictEqual({
+        key1: 'value',
+        key3: {
+          key4: 'value',
+          key6: {
+            key7: 'value',
+          },
+        },
+        key9: {},
+      });
+    });
+  });
+
+  describe('removeUndefinedAndNullValues', () => {
+    it('should remove undefined and null values from deeply nested object', () => {
+      const nestedObj = {
+        key1: 'value',
+        key2: undefined,
+        key3: {
+          key4: 'value',
+          key5: undefined,
+          key6: {
+            key7: 'value',
+            key8: undefined,
+          },
+          key11: null,
+        },
+        key9: null,
+        key10: {
+          key11: null,
+        },
+      };
+      const outcome = removeUndefinedAndNullValues(nestedObj);
+      expect(outcome).toStrictEqual({
+        key1: 'value',
+        key3: {
+          key4: 'value',
+          key6: {
+            key7: 'value',
+          },
+        },
+        key10: {},
+      });
+    });
+  });
+});

package/packages/analytics-js-common/__tests__/utilities/string.test.ts

@@ -0,0 +1,104 @@
+import {
+  removeDoubleSpaces,
+  trim,
+  tryStringify,
+  toBase64,
+  fromBase64,
+} from '../../src/utilities/string';
+
+describe('Common Utils - String', () => {
+  it('should trim string', () => {
+    expect(trim('  a a  ')).toBe('a a');
+  });
+
+  it('should remove double spaces from string', () => {
+    expect(removeDoubleSpaces('  a  a  ')).toBe(' a a ');
+  });
+
+  it('should stringify object', () => {
+    expect(tryStringify({ a: 1 })).toBe('{"a":1}');
+  });
+
+  it('should not stringify string', () => {
+    expect(tryStringify('a')).toBe('a');
+  });
+
+  it('should not stringify undefined', () => {
+    expect(tryStringify(undefined)).toBe(undefined);
+  });
+
+  it('should not stringify null', () => {
+    expect(tryStringify(null)).toBe(null);
+  });
+
+  it('should stringify number', () => {
+    expect(tryStringify(1)).toBe('1');
+  });
+
+  it('should stringify boolean', () => {
+    expect(tryStringify(true)).toBe('true');
+  });
+
+  it('should stringify array', () => {
+    expect(tryStringify([1, 2, 3])).toBe('[1,2,3]');
+  });
+
+  it('should return null if value contains circular dependency in the object or errors', () => {
+    function Foo() {
+      this.abc = 'Hello';
+      this.circular = this;
+    }
+
+    const foo = new Foo();
+    expect(tryStringify(foo)).toBe(null);
+  });
+
+  it('should return null if for BigInt values', () => {
+    // JSON.stringify fails for BigInt values
+    expect(tryStringify(BigInt(9007199254740991))).toBe(null);
+  });
+
+  describe('toBase64', () => {
+    it('should convert string to base64', () => {
+      expect(toBase64('abc')).toBe('YWJj');
+    });
+
+    it('should convert string with special characters to base64', () => {
+      expect(toBase64('abc!@#$%^&*()_+')).toBe('YWJjIUAjJCVeJiooKV8r');
+    });
+
+    it('should convert string with unicode characters to base64', () => {
+      expect(toBase64('你好')).toBe('5L2g5aW9');
+    });
+
+    it('should convert string with unicode characters and special characters to base64', () => {
+      expect(toBase64('你好!@#$%^&*()_+310')).toBe('5L2g5aW9IUAjJCVeJiooKV8rMzEw');
+    });
+
+    it('should convert string with emoji to base64', () => {
+      expect(toBase64('👋')).toBe('8J+Riw==');
+    });
+  });
+
+  describe('fromBase64', () => {
+    it('should convert base64 to string', () => {
+      expect(fromBase64('YWJj')).toBe('abc');
+    });
+
+    it('should convert base64 with special characters to string', () => {
+      expect(fromBase64('YWJjIUAjJCVeJiooKV8r')).toBe('abc!@#$%^&*()_+');
+    });
+
+    it('should convert base64 with unicode characters to string', () => {
+      expect(fromBase64('5L2g5aW9')).toBe('你好');
+    });
+
+    it('should convert base64 with unicode characters and special characters to string', () => {
+      expect(fromBase64('5L2g5aW9IUAjJCVeJiooKV8rMzEw')).toBe('你好!@#$%^&*()_+310');
+    });
+
+    it('should convert base64 with emoji to string', () => {
+      expect(fromBase64('8J+Riw==')).toBe('👋');
+    });
+  });
+});

package/packages/analytics-js-common/__tests__/utilities/timezone.test.ts

@@ -0,0 +1,9 @@
+import { getTimezone } from '../../src/utilities/timezone';
+
+describe('Common Utils - Timezone', () => {
+  it('should return timezone of the user', () => {
+    const timezone = getTimezone();
+    expect(typeof timezone).toBe('string');
+    expect(timezone.startsWith('GMT')).toBe(true);
+  });
+});

package/packages/analytics-js-common/__tests__/utilities/uuid.test.ts

@@ -0,0 +1,35 @@
+import { hasCrypto } from '../../src/utilities/crypto';
+import { generateUUID } from '../../src/utilities/uuId';
+
+jest.mock('../../src/utilities/crypto', () => {
+  const originalModule = jest.requireActual('../../src/utilities/crypto');
+
+  return {
+    __esModule: true,
+    ...originalModule,
+    hasCrypto: jest.fn(),
+  };
+});
+
+describe('Common Utils - UUId', () => {
+  const originalWindowCrypto = global.crypto;
+  const uuIdForMockedRandom = '80808080-8080-4080-8080-808080808080';
+
+  beforeAll(() => {
+    global.crypto.getRandomValues = arr => arr;
+  });
+
+  afterAll(() => {
+    global.crypto = originalWindowCrypto;
+  });
+
+  it('should generate UUID for modern browsers with crypto.getRandomValues', () => {
+    (hasCrypto as jest.Mock).mockReturnValue(true);
+    expect(generateUUID()).not.toBe(uuIdForMockedRandom);
+  });
+
+  it('should generate UUID for legacy browsers with Math.random', () => {
+    (hasCrypto as jest.Mock).mockReturnValue(false);
+    expect(generateUUID()).toBe(uuIdForMockedRandom);
+  });
+});

package/packages/analytics-js-common/__tests__/v1.1/utils/ObjectUtils.test.js

@@ -0,0 +1,113 @@
+import { clone } from 'ramda';
+import { isInstanceOfEvent, stringifyWithoutCircularV1 } from '../../../src/v1.1/utils/ObjectUtils';
+
+const identifyTraitsPayloadMock = {
+  firstName: 'Dummy Name',
+  phone: '1234567890',
+  email: 'dummy@email.com',
+  custom_flavor: 'chocolate',
+  custom_date: new Date(2022, 1, 21, 0, 0, 0),
+  address: [
+    {
+      label: 'office',
+      city: 'Brussels',
+      country: 'Belgium',
+    },
+    {
+      label: 'home',
+      city: 'Kolkata',
+      country: 'India',
+      nested: {
+        type: 'flat',
+        rooms: [
+          {
+            name: 'kitchen',
+            size: 'small',
+          },
+          {
+            // eslint-disable-next-line sonarjs/no-duplicate-string
+            name: 'living room',
+            size: 'large',
+          },
+          {
+            name: 'bedroom',
+            size: 'large',
+          },
+        ],
+      },
+    },
+    {
+      label: 'work',
+      city: 'Kolkata',
+      country: 'India',
+    },
+  ],
+};
+
+const circularReferenceNotice = '[Circular Reference]';
+
+describe('Object utilities', () => {
+  it('should stringify json with circular references', () => {
+    const objWithCircular = clone(identifyTraitsPayloadMock);
+    objWithCircular.myself = objWithCircular;
+
+    const json = stringifyWithoutCircularV1(objWithCircular);
+    expect(json).toContain(circularReferenceNotice);
+  });
+
+  it('should stringify json with circular references and exclude null values', () => {
+    const objWithCircular = clone(identifyTraitsPayloadMock);
+    objWithCircular.myself = objWithCircular;
+    objWithCircular.keyToExclude = null;
+    objWithCircular.keyToNotExclude = '';
+
+    const json = stringifyWithoutCircularV1(objWithCircular, true);
+    expect(json).toContain(circularReferenceNotice);
+    expect(json).not.toContain('keyToExclude');
+    expect(json).toContain('keyToNotExclude');
+  });
+
+  it('should stringify json with out circular references', () => {
+    const objWithoutCircular = clone(identifyTraitsPayloadMock);
+    objWithoutCircular.myself = {};
+
+    const json = stringifyWithoutCircularV1(objWithoutCircular);
+    expect(json).not.toContain(circularReferenceNotice);
+  });
+
+  it('should stringify json with out circular references and reused objects', () => {
+    const objWithoutCircular = clone(identifyTraitsPayloadMock);
+    const reusableArray = [1, 2, 3];
+    const reusableObject = { dummy: 'val' };
+    objWithoutCircular.reused = reusableArray;
+    objWithoutCircular.reusedAgain = [1, 2, reusableArray];
+    objWithoutCircular.reusedObj = reusableObject;
+    objWithoutCircular.reusedObjAgain = { reused: reusableObject };
+    objWithoutCircular.reusedObjAgainWithItself = { reused: reusableObject };
+
+    const json = stringifyWithoutCircularV1(objWithoutCircular);
+    expect(json).not.toContain(circularReferenceNotice);
+  });
+
+  it('should stringify json with circular references for nested circular objects', () => {
+    const objWithoutCircular = clone(identifyTraitsPayloadMock);
+    const reusableObject = { dummy: 'val' };
+    const objWithCircular = clone(reusableObject);
+    objWithCircular.myself = objWithCircular;
+    objWithoutCircular.reusedObjAgainWithItself = { reused: reusableObject };
+    objWithoutCircular.objWithCircular = objWithCircular;
+
+    const json = stringifyWithoutCircularV1(objWithoutCircular);
+    expect(json).toContain(circularReferenceNotice);
+  });
+
+  it('should detect if value is an Event', () => {
+    const check = isInstanceOfEvent(new Event('Error'));
+    expect(check).toBeTruthy();
+  });
+
+  it('should detect if value is not an Event', () => {
+    const check = isInstanceOfEvent(new Error('Error'));
+    expect(check).not.toBeTruthy();
+  });
+});