iureiure 1.0.0

package/packages/analytics-js-integrations/__tests__/utils/commonUtils.test.js

@@ -0,0 +1,347 @@
+import * as utils from '../../src/utils/commonUtils';
+
+describe('isDefinedAndNotNull Tests', () => {
+  const testObj = {
+    a: 2,
+    b: null,
+    c: undefined,
+    e: true,
+    f: false,
+    g: 'string',
+  };
+  test(' a defined and not null value returns true', () => {
+    const result = utils.isDefinedAndNotNull(testObj.a);
+    expect(result).toBe(true);
+  });
+
+  test(' a defined and null value returns false', () => {
+    const result = utils.isDefinedAndNotNull(testObj.b);
+    expect(result).toBe(false);
+  });
+
+  test(' an undefined value returns false', () => {
+    const result = utils.isDefinedAndNotNull(testObj.c);
+    expect(result).toBe(false);
+  });
+
+  test(" a 'true' value returns true", () => {
+    const result = utils.isDefinedAndNotNull(testObj.e);
+    expect(result).toBe(true);
+  });
+
+  test(" a 'false' value returns true", () => {
+    const result = utils.isDefinedAndNotNull(testObj.f);
+    expect(result).toBe(true);
+  });
+
+  test(' a string value returns true', () => {
+    const result = utils.isDefinedAndNotNull(testObj.g);
+    expect(result).toBe(true);
+  });
+});
+
+describe('getHashFromArray Tests', () => {
+  const testDestMap = [
+    { from: 'prop1', to: 'val1' },
+    { from: 'prop2', to: 'val2' },
+  ];
+  test('A success case', () => {
+    const result = utils.getHashFromArray(testDestMap);
+    expect(result).toStrictEqual({
+      prop1: 'val1',
+      prop2: 'val2',
+    });
+  });
+
+  test('A single object map (not having array of maps) returns empty object', () => {
+    const WrongtestDestMap = { from: 'prop1', to: 'val1' };
+    const result = utils.getHashFromArray(WrongtestDestMap);
+    expect(result).toStrictEqual({});
+  });
+
+  test('null from key returns empty object', () => {
+    const WrongtestDestMap = { from: null, to: 'val1' };
+    const result = utils.getHashFromArray(WrongtestDestMap);
+    expect(result).toStrictEqual({});
+  });
+
+  test('undefined from key returns empty object', () => {
+    const WrongtestDestMap = { from: undefined, to: 'val1' };
+    const result = utils.getHashFromArray(WrongtestDestMap);
+    expect(result).toStrictEqual({});
+  });
+
+  test('empty string from key returns empty object', () => {
+    const WrongtestDestMap = { from: '', to: 'val1' };
+    const result = utils.getHashFromArray(WrongtestDestMap);
+    expect(result).toStrictEqual({});
+  });
+});
+
+describe('getHashFromArrayWithDuplicate Tests', () => {
+  const testDestMap = [
+    { from: 'prop1', to: 'val1' },
+    { from: 'prop1', to: 'val2' },
+    { from: 'prop2', to: 'val2' },
+  ];
+  test('A success case', () => {
+    const result = utils.getHashFromArrayWithDuplicate(testDestMap);
+    expect(result).toStrictEqual({ prop1: ['val1', 'val2'], prop2: ['val2'] });
+  });
+
+  test('A single object map (not having array of maps) returns empty object', () => {
+    const WrongtestDestMap = { from: 'prop1', to: 'val1' };
+    const result = utils.getHashFromArray(WrongtestDestMap);
+    expect(result).toStrictEqual({});
+  });
+
+  test("null 'from' key returns empty object", () => {
+    const WrongtestDestMap = [
+      { from: null, to: 'val1' },
+      { from: null, to: 'val2' },
+      { from: null, to: 'val2' },
+    ];
+    const result = utils.getHashFromArrayWithDuplicate(WrongtestDestMap);
+    expect(result).toStrictEqual({});
+  });
+
+  test("undefined 'from' key returns empty object", () => {
+    const WrongtestDestMap = [
+      { from: undefined, to: 'val1' },
+      { from: undefined, to: 'val2' },
+      { from: undefined, to: 'val2' },
+    ];
+    const result = utils.getHashFromArrayWithDuplicate(WrongtestDestMap);
+    expect(result).toStrictEqual({});
+  });
+
+  test("empty string 'from' key returns empty object", () => {
+    const WrongtestDestMap = [
+      { from: '', to: 'val1' },
+      { from: '', to: 'val2' },
+      { from: '', to: 'val2' },
+    ];
+    const result = utils.getHashFromArrayWithDuplicate(WrongtestDestMap);
+    expect(result).toStrictEqual({});
+  });
+
+  test('Having repeated mapping will sort it out to single mapping', () => {
+    const repeatDestMap = [
+      { from: 'prop1', to: 'val1' },
+      { from: 'prop1', to: 'val2' },
+      { from: 'prop1', to: 'val2' },
+      { from: 'prop2', to: 'val2' },
+    ];
+    const result = utils.getHashFromArrayWithDuplicate(repeatDestMap);
+    expect(result).toStrictEqual({ prop1: ['val1', 'val2'], prop2: ['val2'] });
+  });
+});
+
+describe('getEventMappingFromConfig Tests', () => {
+  test('A success case : Getting mapped data from event hashmap', () => {
+    const eventsHashmap = { prop1: ['val1', 'val2'], prop2: ['val2'] };
+    const result = utils.getEventMappingFromConfig('prop1', eventsHashmap);
+    expect(result).toStrictEqual(['val1', 'val2']);
+  });
+  test('Getting mapped data from from a non-mapped in event hashmap returns null', () => {
+    const eventsHashmap = { prop1: ['val1', 'val2'], prop2: ['val2'] };
+    const result = utils.getEventMappingFromConfig('prop3', eventsHashmap);
+    expect(result).toStrictEqual(null);
+  });
+});
+
+describe('getDestinationExternalID Tests', () => {
+  test('A success case : Getting externalId of a given type', () => {
+    const messageTest = {
+      context: {
+        externalId: [
+          {
+            type: 'kustomerId',
+            id: '12345678',
+          },
+        ],
+      },
+    };
+    const result = utils.getDestinationExternalID(messageTest, 'kustomerId');
+    expect(result).toStrictEqual('12345678');
+  });
+  test('sending externalId as a normal object returns null', () => {
+    const messageTest = {
+      context: {
+        externalId: {
+          type: 'kustomerId',
+          id: '12345678',
+        },
+      },
+    };
+    const result = utils.getDestinationExternalID(messageTest, 'kustomerId');
+    expect(result).toStrictEqual(null);
+  });
+
+  test('sending externalId as a normal object returns null', () => {
+    const messageTest = {
+      context: {
+        externalId: [
+          {
+            type: 'kustomerId',
+            id: '12345678',
+          },
+        ],
+      },
+    };
+    const result = utils.getDestinationExternalID(messageTest, 'testId');
+    expect(result).toStrictEqual(null);
+  });
+});
+
+describe('isDefinedNotNullNotEmpty Tests', () => {
+  test('{} returns false', () => {
+    const testVar = {};
+    const result = utils.isDefinedNotNullNotEmpty(testVar);
+    expect(result).toStrictEqual(false);
+  });
+  test('[] returns false', () => {
+    const testVar = [];
+    const result = utils.isDefinedNotNullNotEmpty(testVar);
+    expect(result).toStrictEqual(false);
+  });
+  test("'' returns false", () => {
+    const testVar = '';
+    const result = utils.isDefinedNotNullNotEmpty(testVar);
+    expect(result).toStrictEqual(false);
+  });
+  test('integer returns true', () => {
+    const testVar = 124;
+    const result = utils.isDefinedNotNullNotEmpty(testVar);
+    expect(result).toStrictEqual(true);
+  });
+  test('true returns true', () => {
+    const testVar = true;
+    const result = utils.isDefinedNotNullNotEmpty(testVar);
+    expect(result).toStrictEqual(true);
+  });
+  test('false returns true', () => {
+    const testVar = false;
+    const result = utils.isDefinedNotNullNotEmpty(testVar);
+    expect(result).toStrictEqual(true);
+  });
+});
+
+describe('isDefinedAndNotNullAndNotEmpty Tests', () => {
+  test('{} returns false', () => {
+    const testVar = {};
+    const result = utils.isDefinedAndNotNullAndNotEmpty(testVar);
+    expect(result).toStrictEqual(false);
+  });
+  test('[] returns false', () => {
+    const testVar = [];
+    const result = utils.isDefinedAndNotNullAndNotEmpty(testVar);
+    expect(result).toStrictEqual(false);
+  });
+  test("'' returns false", () => {
+    const testVar = '';
+    const result = utils.isDefinedAndNotNullAndNotEmpty(testVar);
+    expect(result).toStrictEqual(false);
+  });
+  test('integer returns false', () => {
+    const testVar = 124;
+    const result = utils.isDefinedAndNotNullAndNotEmpty(testVar);
+    expect(result).toStrictEqual(false);
+  });
+  test('true returns false', () => {
+    const testVar = true;
+    const result = utils.isDefinedAndNotNullAndNotEmpty(testVar);
+    expect(result).toStrictEqual(false);
+  });
+  test('false returns false', () => {
+    const testVar = false;
+    const result = utils.isDefinedAndNotNullAndNotEmpty(testVar);
+    expect(result).toStrictEqual(false);
+  });
+});
+
+describe('flattenJson Tests', () => {
+  test('simple string returns object with empty key', () => {
+    const testObj = 'abc';
+    const result = utils.flattenJson(testObj);
+    expect(result).toStrictEqual({ '': 'abc' });
+  });
+  test('simple empty array returns an with empty key with empty array value', () => {
+    const testObj = [];
+    const result = utils.flattenJson(testObj);
+    expect(result).toStrictEqual({ '': [] });
+  });
+  test('simple array of object returns single object with indexed keys', () => {
+    const testObj = [{ prop1: 'val1' }, { prop2: 'val2' }];
+    const result = utils.flattenJson(testObj);
+    expect(result).toStrictEqual({ '[0].prop1': 'val1', '[1].prop2': 'val2' });
+  });
+  test('simple array of object returns single object with indexed keys', () => {
+    const testObj = [{ prop1: 'val1' }, { prop2: 'val2' }];
+    const result = utils.flattenJson(testObj);
+    expect(result).toStrictEqual({ '[0].prop1': 'val1', '[1].prop2': 'val2' });
+  });
+  test('test case with object with array as value', () => {
+    const testObj = { prop1: ['val1', 'val3'], prop2: 'val2' };
+    const result = utils.flattenJson(testObj);
+    expect(result).toStrictEqual({ 'prop1[0]': 'val1', 'prop1[1]': 'val3', prop2: 'val2' });
+  });
+  test('test case with circular referenced object', () => {
+    const testObj = { prop1: { prop2: 'abc' } };
+    testObj.prop3 = testObj;
+    const result = utils.flattenJson(testObj);
+    expect(result).toStrictEqual({ 'prop1.prop2': 'abc', prop3: '[Circular Reference]' });
+  });
+  test('test case with nested object', () => {
+    const testObj = { prop1: { prop2: 'abc' } };
+    const result = utils.flattenJson(testObj);
+    expect(result).toStrictEqual({ 'prop1.prop2': 'abc' });
+  });
+});
+
+describe('pick', () => {
+  test('should return an object with only the specified keys', () => {
+    const obj = { a: 1, b: 2, c: 3 };
+    const result = utils.pick(obj, ['a', 'c']);
+    expect(result).toEqual({ a: 1, c: 3 });
+  });
+
+  test('should return an empty object if the input object is empty', () => {
+    const obj = {};
+    const result = utils.pick(obj, ['a', 'c']);
+    expect(result).toEqual({});
+  });
+
+  test('should throw an error if the input object is null', () => {
+    const obj = null;
+    expect(() => {
+      utils.pick(obj, ['a', 'c']);
+    }).toThrow(new TypeError("Cannot use 'in' operator to search for 'a' in null"));
+  });
+
+  test('should throw an error if the input object is undefined', () => {
+    const obj = undefined;
+    expect(() => {
+      utils.pick(obj, ['a', 'c']);
+    }).toThrow(new TypeError("Cannot use 'in' operator to search for 'a' in undefined"));
+  });
+
+  test('should throw an error if the input object is not an object', () => {
+    const obj = 'string';
+    expect(() => {
+      utils.pick(obj, ['a', 'c']);
+    }).toThrow(new TypeError("Cannot use 'in' operator to search for 'a' in string"));
+  });
+
+  test('should not return any value if the provided keys are not present in the object', () => {
+    const obj = { a: 1, b: 2, c: 3 };
+    const result = utils.pick(obj, ['a', 'd', 'e']);
+    expect(result).toEqual({ a: 1 });
+  });
+
+  test('should return an object by picking fields case sensitively', () => {
+    const obj = { a: 1, b: 2, c: 3, A: 4, B: 5, C: 6 };
+    const result = utils.pick(obj, ['a', 'c', 'A', 'C']);
+    expect(result).toEqual({ a: 1, c: 3, A: 4, C: 6 });
+  });
+});

package/packages/analytics-js-integrations/__tests__/utils/utils.test.js

@@ -0,0 +1,337 @@
+/* eslint-disable sonarjs/no-duplicate-string */
+import * as utils from '../../src/utils/utils';
+
+describe('extractCustomFields Tests', () => {
+  test('A success case', () => {
+    const testMessageObj = {
+      context: {
+        traits: {
+          name: 'rudder',
+          city: 'kolkata',
+          locality: 'test',
+        },
+      },
+      properties: {
+        category: 'test cat',
+        path: '/test',
+        url: 'http://localhost',
+        referrer: '',
+        title: 'test page',
+        organization: 'Rudderstack',
+      },
+    };
+    const testPayload = {};
+    const testKeys = ['traits', 'context.traits', 'properties'];
+    const exclusionFields = [
+      'firstName',
+      'lastName',
+      'phone',
+      'title',
+      'organization',
+      'city',
+      'region',
+      'country',
+      'zip',
+      'image',
+      'timezone',
+    ];
+    const result = utils.extractCustomFields(
+      testMessageObj,
+      testPayload,
+      testKeys,
+      exclusionFields,
+    );
+    expect(result).toStrictEqual({
+      category: 'test cat',
+      locality: 'test',
+      name: 'rudder',
+      path: '/test',
+      referrer: '',
+      url: 'http://localhost',
+    });
+  });
+  test('If a key of message for extraction is absent, returns the destination payload as it is', () => {
+    const testMessageObj = {
+      context: {},
+      properties: {
+        category: 'test cat',
+        path: '/test',
+        url: 'http://localhost',
+        referrer: '',
+        title: 'test page',
+        organization: 'Rudderstack',
+      },
+    };
+    const testPayload = {
+      testKey: 'testVal',
+    };
+    const testKeys = ['context.traits'];
+    const exclusionFields = [
+      'firstName',
+      'lastName',
+      'phone',
+      'title',
+      'organization',
+      'city',
+      'region',
+      'country',
+      'zip',
+      'image',
+      'timezone',
+    ];
+    const result = utils.extractCustomFields(
+      testMessageObj,
+      testPayload,
+      testKeys,
+      exclusionFields,
+    );
+    expect(result).toStrictEqual({
+      testKey: 'testVal',
+    });
+  });
+});
+
+describe('getDefinedTraits Tests', () => {
+  test('A success case', () => {
+    const testMessageObj = {
+      userId: 'user123',
+      context: {
+        traits: {
+          firstname: 'rudder',
+          lastname: 'stack',
+          city: 'kolkata',
+          locality: 'test',
+          email: 'abc@gmail.com',
+          address: {
+            country: 'India',
+          },
+        },
+      },
+      properties: {
+        category: 'test cat',
+        path: '/test',
+        url: 'http://localhost',
+        referrer: '',
+        title: 'test page',
+        organization: 'Rudderstack',
+      },
+    };
+
+    const result = utils.getDefinedTraits(testMessageObj);
+    expect(result).toStrictEqual({
+      city: 'kolkata',
+      country: 'India',
+      email: 'abc@gmail.com',
+      firstName: 'rudder',
+      lastName: 'stack',
+      name: 'rudder stack',
+      phone: undefined,
+      state: undefined,
+      userId: 'user123',
+      userIdOnly: 'user123',
+    });
+  });
+});
+
+describe('constructPayload Tests', () => {
+  test('A success case', () => {
+    const testMessageObj = {
+      locality: 'test',
+      email: 'abc@gmail.com',
+      address: {
+        country: 'India',
+      },
+    };
+
+    const testMapper = [
+      {
+        destKey: 'newLocality',
+        sourceKeys: 'locality',
+      },
+      {
+        destKey: 'newEmail',
+        sourceKeys: 'email',
+      },
+      {
+        destKey: 'country',
+        sourceKeys: 'address.country',
+      },
+    ];
+
+    const result = utils.constructPayload(testMessageObj, testMapper);
+    expect(result).toStrictEqual({
+      country: 'India',
+      newEmail: 'abc@gmail.com',
+      newLocality: 'test',
+    });
+  });
+  test('with array of source keys, only first available value should be mapped', () => {
+    const testMessageObj = {
+      country: 'India',
+      locality: 'test',
+      email: 'abc@gmail.com',
+      address: {
+        country: 'USA',
+      },
+    };
+
+    const testMapper = [
+      {
+        destKey: 'newLocality',
+        sourceKeys: 'locality',
+      },
+      {
+        destKey: 'newEmail',
+        sourceKeys: 'email',
+      },
+      {
+        destKey: 'country',
+        sourceKeys: ['country', 'address.country'],
+      },
+    ];
+
+    const result = utils.constructPayload(testMessageObj, testMapper);
+    expect(result).toStrictEqual({
+      country: 'India',
+      newEmail: 'abc@gmail.com',
+      newLocality: 'test',
+    });
+  });
+});
+
+describe('getDataFromSource Tests', () => {
+  test('A success case', () => {
+    let itemsObject;
+    const testMessageObj = {
+      locality: 'test',
+    };
+
+    const testMapper = [
+      {
+        destKey: 'newLocality',
+        sourceKeys: 'locality',
+      },
+    ];
+
+    testMapper.forEach(mapping => {
+      itemsObject = {
+        ...utils.getDataFromSource(mapping.sourceKeys, mapping.destKey, testMessageObj),
+      };
+    });
+    expect(itemsObject).toStrictEqual({ newLocality: 'test' });
+  });
+  test('If an array of source keys is provided, maps from the first available value, ', () => {
+    let itemsObject;
+    const testMessageObj = {
+      locality: 'test',
+      email: 'abc@gmail.com',
+      country: 'India',
+      COUNTRY: 'Bharat',
+    };
+
+    const testMapper = [
+      {
+        destKey: 'country',
+        sourceKeys: ['COUNTRY', 'country'],
+      },
+    ];
+
+    testMapper.forEach(mapping => {
+      itemsObject = {
+        ...utils.getDataFromSource(mapping.sourceKeys, mapping.destKey, testMessageObj),
+      };
+    });
+    expect(itemsObject).toStrictEqual({ country: 'Bharat' });
+  });
+  test('If nested object source mapping is provided, returns {}', () => {
+    let itemsObject;
+    const testMessageObj = {
+      address: {
+        country: 'India',
+      },
+    };
+
+    const testMapper = [
+      {
+        destKey: 'country',
+        sourceKeys: 'address.country',
+      },
+    ];
+
+    testMapper.forEach(mapping => {
+      itemsObject = {
+        ...utils.getDataFromSource(mapping.sourceKeys, mapping.destKey, testMessageObj),
+      };
+    });
+    expect(itemsObject).toStrictEqual({});
+  });
+  test('Even though test mapper contains key mapping object for multiple keys, only one of the mapped key is returned', () => {
+    let itemsObject;
+    const testMessageObj = {
+      locality: 'test',
+      country: 'India',
+    };
+
+    const testMapper = [
+      {
+        destKey: 'newLocality',
+        sourceKeys: 'locality',
+      },
+      {
+        destKey: 'newCountry',
+        sourceKeys: 'country',
+      },
+    ];
+
+    testMapper.forEach(mapping => {
+      itemsObject = {
+        ...utils.getDataFromSource(mapping.sourceKeys, mapping.destKey, testMessageObj),
+      };
+    });
+    expect(itemsObject).toStrictEqual({ newCountry: 'India' });
+  });
+});
+
+describe('flattenJsonPayload Tests', () => {
+  test('simple string returns object with empty key', () => {
+    const testObj = 'abc';
+    const result = utils.flattenJsonPayload(testObj);
+    expect(result).toStrictEqual({ '': 'abc' });
+  });
+  test('simple empty array returns an with empty key with empty array value', () => {
+    const testObj = [];
+    const result = utils.flattenJsonPayload(testObj);
+    expect(result).toStrictEqual({ '': [] });
+  });
+  test('simple array of object returns single object with indexed keys', () => {
+    const testObj = [{ prop1: 'val1' }, { prop2: 'val2' }];
+    const result = utils.flattenJsonPayload(testObj);
+    expect(result).toStrictEqual({ '0.prop1': 'val1', '1.prop2': 'val2' });
+  });
+  test('simple array of object returns single object with indexed keys', () => {
+    const testObj = [{ prop1: 'val1' }, { prop2: 'val2' }];
+    const result = utils.flattenJsonPayload(testObj);
+    expect(result).toStrictEqual({ '0.prop1': 'val1', '1.prop2': 'val2' });
+  });
+  test('test case with object with array as value', () => {
+    const testObj = { prop1: ['val1', 'val3'], prop2: 'val2' };
+    const result = utils.flattenJsonPayload(testObj);
+    expect(result).toStrictEqual({ 'prop1.0': 'val1', 'prop1.1': 'val3', prop2: 'val2' });
+  });
+  test('test case with nested object', () => {
+    const testObj = { prop1: { prop2: 'abc' } };
+    const result = utils.flattenJsonPayload(testObj);
+    expect(result).toStrictEqual({ 'prop1.prop2': 'abc' });
+  });
+  test('test case with circular referenced object', () => {
+    const testObj = { prop1: { prop2: 'abc' } };
+    testObj.prop3 = testObj;
+    const result = utils.flattenJsonPayload(testObj);
+    expect(result).toStrictEqual({ 'prop1.prop2': 'abc', "prop3": "[Circular Reference]" });
+  });
+  test('test case with specified delimeter', () => {
+    const testObj = { prop1: { prop2: 'abc' } };
+    const result = utils.flattenJsonPayload(testObj, '-');
+    expect(result).toStrictEqual({ '-.prop1.prop2': 'abc' });
+  });
+});

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

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