@jmartins-tillster/analytics-react-native 2.21.3

package/packages/plugins/plugin-mixpanel/src/methods/__tests__/group.test.ts

@@ -0,0 +1,49 @@
+import group from '../group';
+import type { GroupEventType } from '@segment/analytics-react-native';
+import type { SegmentMixpanelSettings } from '../../types';
+import { sampleIntegrationSettings } from './__helpers__/constants';
+import { Mixpanel } from '../__mocks__/mixpanel-react-native';
+
+describe('#group', () => {
+  let mixpanel: Mixpanel;
+  const payload = {
+    type: 'group',
+    traits: {
+      company_id: 'the_red_f',
+      coolGroup: false,
+      members: 4,
+    },
+    groupId: '23322',
+  } as GroupEventType;
+  const settings: SegmentMixpanelSettings =
+    sampleIntegrationSettings.integrations.Mixpanel;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    mixpanel = new Mixpanel('1234');
+  });
+
+  it('calls the group method when id is present', () => {
+    const getGroupSpy = jest.spyOn(mixpanel, 'getGroup');
+    settings.groupIdentifierTraits = ['company_id'];
+    const groupId = payload.groupId;
+    const setGroupTrait = 'company_id';
+    const mockedId = '23322';
+    const mockedGroupTrait = 'the_red_f';
+
+    group(payload, mixpanel, settings);
+
+    expect(mixpanel.setGroup).toBeCalledWith(setGroupTrait, groupId);
+    expect(getGroupSpy).toBeCalledWith(mockedGroupTrait, mockedId);
+  });
+
+  it(' does not call the group method when no traits are provided in settings', () => {
+    const getGroupSpy = jest.spyOn(mixpanel, 'getGroup');
+    settings.groupIdentifierTraits = [];
+
+    group(payload, mixpanel, settings);
+
+    expect(mixpanel.setGroup).toBeCalledTimes(0);
+    expect(getGroupSpy).not.toBeCalled();
+  });
+});

package/packages/plugins/plugin-mixpanel/src/methods/__tests__/identify.test.ts

@@ -0,0 +1,103 @@
+import identify from '../identify';
+import type { IdentifyEventType } from '@segment/analytics-react-native';
+import type { SegmentMixpanelSettings } from '../../types';
+import { sampleIntegrationSettings } from './__helpers__/constants';
+import { Mixpanel } from '../__mocks__/mixpanel-react-native';
+
+describe('#identify', () => {
+  let mixpanel: Mixpanel;
+  const payload = {
+    type: 'identify',
+    traits: {
+      firstName: 'John',
+      phone: '(555) 555-5555',
+      foo: 'bar',
+    },
+    userId: 'user',
+  } as IdentifyEventType;
+  const settings: SegmentMixpanelSettings =
+    sampleIntegrationSettings.integrations.Mixpanel;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    mixpanel = new Mixpanel('1234');
+  });
+  it('calls identify with userId', () => {
+    identify(payload, mixpanel, settings);
+
+    expect(mixpanel.identify).toBeCalledWith(payload.userId);
+  });
+
+  it('does not call identify when userId is undefined', () => {
+    payload.userId = undefined;
+
+    identify(payload, mixpanel, settings);
+
+    expect(mixpanel.identify).not.toHaveBeenCalled();
+  });
+
+  it('sets all traits by default', () => {
+    payload.userId = 'userId';
+    settings.setAllTraitsByDefault = true;
+    const mockedTraits = {
+      $first_name: 'John',
+      $phone: '(555) 555-5555',
+      foo: 'bar',
+    };
+    const getPeopleSpy = jest.spyOn(mixpanel, 'getPeople');
+
+    identify(payload, mixpanel, settings);
+
+    expect(mixpanel.registerSuperProperties).toBeCalledWith(mockedTraits);
+    expect(getPeopleSpy).toBeCalled();
+  });
+
+  it('does not set all traits by default', () => {
+    settings.setAllTraitsByDefault = false;
+    const getPeopleSpy = jest.spyOn(mixpanel, 'getPeople');
+
+    identify(payload, mixpanel, settings);
+
+    expect(mixpanel.registerSuperProperties).not.toHaveBeenCalled();
+    expect(getPeopleSpy).not.toHaveBeenCalled();
+  });
+
+  it('registers superProperties', () => {
+    payload.traits!.prop1 = 'string';
+    settings.superProperties = ['prop1'];
+    const mockedTraits = { prop1: 'string' };
+
+    identify(payload, mixpanel, settings);
+
+    expect(mixpanel.registerSuperProperties).toBeCalledWith(mockedTraits);
+  });
+
+  it('does not register superProperties', () => {
+    settings.setAllTraitsByDefault = false;
+    settings.superProperties = [];
+
+    identify(payload, mixpanel, settings);
+
+    expect(mixpanel.registerSuperProperties).not.toHaveBeenCalled();
+  });
+
+  it('registers people Properties', () => {
+    settings.superProperties = [];
+    settings.peopleProperties = ['prop1'];
+    settings.people = true;
+    const getPeopleSpy = jest.spyOn(mixpanel, 'getPeople');
+
+    identify(payload, mixpanel, settings);
+
+    expect(getPeopleSpy).toBeCalledTimes(1);
+  });
+
+  it(' does not register people Properties', () => {
+    settings.peopleProperties = [];
+    const getPeopleSpy = jest.spyOn(mixpanel, 'getPeople');
+
+    identify(payload, mixpanel, settings);
+
+    expect(getPeopleSpy).not.toHaveBeenCalled();
+  });
+});

package/packages/plugins/plugin-mixpanel/src/methods/__tests__/screen.test.ts

@@ -0,0 +1,119 @@
+import screen from '../screen';
+import type { ScreenEventType } from '@segment/analytics-react-native';
+import type { SegmentMixpanelSettings } from '../../types';
+import { sampleIntegrationSettings } from './__helpers__/constants';
+import { Mixpanel } from '../__mocks__/mixpanel-react-native';
+import track from '../track';
+
+jest.mock('../track.ts');
+
+describe('#screen', () => {
+  let mixpanel: Mixpanel;
+  const payload = {
+    type: 'screen',
+    properties: {
+      isFirstTime: true,
+      foo: 'bar',
+    },
+    name: 'Home',
+  } as ScreenEventType;
+  const settings: SegmentMixpanelSettings =
+    sampleIntegrationSettings.integrations.Mixpanel;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    mixpanel = new Mixpanel('1234');
+  });
+
+  it('tracks consolidated screens', () => {
+    settings.consolidatedPageCalls = true;
+    const eventName = 'Loaded a Screen';
+
+    screen(payload, mixpanel, settings);
+
+    expect(track).toBeCalledWith(
+      eventName,
+      {
+        ...payload.properties,
+        name: 'Home',
+      },
+      settings,
+      mixpanel
+    );
+  });
+
+  it('does not track consolidated screens', () => {
+    settings.consolidatedPageCalls = false;
+
+    screen(payload, mixpanel, settings);
+
+    expect(track).not.toHaveBeenCalled();
+  });
+
+  it('tracks all screens', () => {
+    settings.trackAllPages = true;
+    const eventName = `Viewed ${payload.name} Screen`;
+
+    screen(payload, mixpanel, settings);
+
+    expect(track).toBeCalledWith(
+      eventName,
+      payload.properties,
+      settings,
+      mixpanel
+    );
+  });
+
+  it('does not track all screens', () => {
+    settings.trackAllPages = false;
+
+    screen(payload, mixpanel, settings);
+
+    expect(track).not.toHaveBeenCalled();
+  });
+
+  it('tracks named pages', () => {
+    settings.trackNamedPages = true;
+    const eventName = `Viewed ${payload.name} Screen`;
+
+    screen(payload, mixpanel, settings);
+
+    expect(track).toBeCalledWith(
+      eventName,
+      payload.properties,
+      settings,
+      mixpanel
+    );
+  });
+
+  it('does not track named pages', () => {
+    settings.trackNamedPages = false;
+
+    screen(payload, mixpanel, settings);
+
+    expect(track).not.toHaveBeenCalled();
+  });
+
+  it('tracks categorized pages', () => {
+    payload.properties.category = 'e-commerce';
+    settings.trackCategorizedPages = true;
+    const eventName = `Viewed ${payload.properties.category} Screen`;
+
+    screen(payload, mixpanel, settings);
+
+    expect(track).toBeCalledWith(
+      eventName,
+      payload.properties,
+      settings,
+      mixpanel
+    );
+  });
+
+  it('does not track categorized pages', () => {
+    settings.trackCategorizedPages = false;
+
+    screen(payload, mixpanel, settings);
+
+    expect(track).not.toHaveBeenCalled();
+  });
+});

package/packages/plugins/plugin-mixpanel/src/methods/__tests__/track.test.ts

@@ -0,0 +1,110 @@
+import mixpanelTrack from '../track';
+import type { JsonMap } from '@segment/analytics-react-native';
+import type { SegmentMixpanelSettings } from '../../types';
+import { sampleIntegrationSettings } from './__helpers__/constants';
+import { Mixpanel } from '../__mocks__/mixpanel-react-native';
+
+describe('#mixpanelTrack', () => {
+  let mixpanel: Mixpanel;
+  const properties = {
+    firstName: 'John',
+    phone: '(555) 555-5555',
+    foo: 'bar',
+  } as JsonMap;
+  const eventName = 'Test Event';
+  const settings: SegmentMixpanelSettings =
+    sampleIntegrationSettings.integrations.Mixpanel;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    mixpanel = new Mixpanel('1234');
+  });
+
+  it('tracks the raw event', () => {
+    mixpanelTrack(eventName, properties, settings, mixpanel);
+
+    expect(mixpanel.track).toBeCalledWith(eventName, properties);
+  });
+
+  it('calls People API if setting is true', () => {
+    settings.people = true;
+    const getPeopleSpy = jest.spyOn(mixpanel, 'getPeople');
+    const newProperties = {
+      ...properties,
+      prop1: 'string',
+      prop2: 34,
+      prop3: false,
+    };
+
+    mixpanelTrack(eventName, newProperties, settings, mixpanel);
+
+    expect(getPeopleSpy).toBeCalled();
+  });
+
+  it('returns if people setting is false', () => {
+    settings.people = false;
+    const getPeopleSpy = jest.spyOn(mixpanel, 'getPeople');
+
+    mixpanelTrack(eventName, properties, settings, mixpanel);
+
+    expect(getPeopleSpy).not.toHaveBeenCalled();
+  });
+
+  it('sets the increment value if present', () => {
+    settings.people = true;
+    settings.propIncrements = ['incProp'];
+    const newProperties = { ...properties, incProp: 10 };
+    const getPeopleSpy = jest.spyOn(mixpanel, 'getPeople');
+
+    mixpanelTrack(eventName, newProperties, settings, mixpanel);
+
+    expect(getPeopleSpy).toBeCalledTimes(1);
+  });
+
+  it('does not set the increment value if it is not a number', () => {
+    const newProperties = { incProp: 'string' };
+    settings.propIncrements = ['prop1', 'prop2'];
+    const getPeopleSpy = jest.spyOn(mixpanel, 'getPeople');
+
+    mixpanelTrack(eventName, newProperties, settings, mixpanel);
+
+    expect(getPeopleSpy).not.toHaveBeenCalled();
+  });
+
+  it('sets event increment values', () => {
+    settings.propIncrements = [];
+    settings.eventIncrements = ['Test Event'];
+    const getPeopleSpy = jest.spyOn(mixpanel, 'getPeople');
+
+    mixpanelTrack(eventName, properties, settings, mixpanel);
+
+    expect(getPeopleSpy).toBeCalledTimes(2);
+  });
+
+  it('does not set event increment values if event name is undefined', () => {
+    settings.eventIncrements = ['Real Event'];
+    const getPeopleSpy = jest.spyOn(mixpanel, 'getPeople');
+
+    mixpanelTrack(eventName, properties, settings, mixpanel);
+
+    expect(getPeopleSpy).not.toHaveBeenCalled();
+  });
+
+  it('sets revenue', () => {
+    const newProperties = { revenue: 15 };
+    settings.eventIncrements = [];
+    const getPeopleSpy = jest.spyOn(mixpanel, 'getPeople');
+
+    mixpanelTrack(eventName, newProperties, settings, mixpanel);
+
+    expect(getPeopleSpy).toBeCalled();
+  });
+
+  it('does not set revenue', () => {
+    const getPeopleSpy = jest.spyOn(mixpanel, 'getPeople');
+
+    mixpanelTrack(eventName, properties, settings, mixpanel);
+
+    expect(getPeopleSpy).not.toHaveBeenCalled();
+  });
+});

package/packages/plugins/plugin-mixpanel/src/methods/alias.ts

@@ -0,0 +1,28 @@
+import type { Mixpanel } from 'mixpanel-react-native';
+import {
+  AliasEventType,
+  ErrorType,
+  SegmentClient,
+  SegmentError,
+} from '@segment/analytics-react-native';
+
+export default async (
+  event: AliasEventType,
+  mixpanel: Mixpanel,
+  analytics: SegmentClient
+) => {
+  let distinctId = '';
+  const newId = event.userId as string;
+
+  try {
+    distinctId = await mixpanel.getDistinctId();
+  } catch (e) {
+    analytics.reportInternalError(
+      new SegmentError(ErrorType.PluginError, JSON.stringify(e), e)
+    );
+    analytics.logger.warn(e);
+  }
+  if (distinctId !== '') {
+    mixpanel.alias(newId, distinctId);
+  }
+};

package/packages/plugins/plugin-mixpanel/src/methods/group.ts

@@ -0,0 +1,26 @@
+import type { Mixpanel } from 'mixpanel-react-native';
+import type { GroupEventType } from '@segment/analytics-react-native';
+import type { SegmentMixpanelSettings } from '../types';
+
+export default (
+  event: GroupEventType,
+  mixpanel: Mixpanel,
+  settings: SegmentMixpanelSettings
+) => {
+  const groupId = event.groupId;
+  const groupTraits = settings.groupIdentifierTraits;
+
+  if (groupTraits !== undefined) {
+    for (const groupTrait of groupTraits) {
+      for (const eventTrait in event.traits) {
+        if (groupTrait.toLocaleLowerCase() === eventTrait.toLocaleLowerCase()) {
+          const group = event.traits[groupTrait] as string;
+          const traits = event.traits;
+
+          mixpanel.getGroup(group, groupId).setOnce('properties', traits);
+        }
+      }
+      mixpanel.setGroup(groupTrait, groupId);
+    }
+  }
+};

package/packages/plugins/plugin-mixpanel/src/methods/identify.ts

@@ -0,0 +1,72 @@
+import type { Mixpanel } from 'mixpanel-react-native';
+import {
+  IdentifyEventType,
+  generateMapTransform,
+} from '@segment/analytics-react-native';
+import type { SegmentMixpanelSettings } from '../types';
+
+const traitMap: { [key: string]: string } = {
+  firstName: '$first_name',
+  lastName: '$last_name',
+  createdAt: '$created',
+  lastSeen: '$last_seen',
+  email: '$email',
+  name: '$name',
+  username: '$username',
+  phone: '$phone',
+};
+
+const mapTransform = generateMapTransform(traitMap, {});
+
+export default (
+  event: IdentifyEventType,
+  mixpanel: Mixpanel,
+  settings: SegmentMixpanelSettings
+) => {
+  const userId = event.userId;
+  const mixpanelTraits = mapTransform(event.traits ?? {});
+
+  if (userId !== undefined) {
+    void mixpanel.identify(userId);
+  }
+
+  if (settings.setAllTraitsByDefault === true) {
+    mixpanel.registerSuperProperties(mixpanelTraits);
+
+    if (settings.people === true) {
+      mixpanel.getPeople().set(mixpanelTraits);
+    }
+  }
+
+  if (
+    settings.superProperties !== undefined &&
+    settings.superProperties.length
+  ) {
+    const superProperties = settings.superProperties;
+    const superPropertyTraits: { [key: string]: unknown } = {};
+
+    for (const superProperty of superProperties) {
+      superPropertyTraits[superProperty] = mixpanelTraits[superProperty];
+    }
+
+    const mappedSuperProperties = mapTransform(superPropertyTraits);
+    mixpanel.registerSuperProperties(mappedSuperProperties);
+  }
+
+  if (
+    event.traits !== undefined &&
+    settings.people === true &&
+    settings.peopleProperties !== undefined &&
+    settings.peopleProperties.length
+  ) {
+    const peopleProperties = settings.peopleProperties;
+    const peoplePropertyTraits: { [key: string]: unknown } = {};
+
+    for (const peopleProperty of peopleProperties) {
+      peoplePropertyTraits[peopleProperty] = event.traits[peopleProperty];
+    }
+
+    const mappedPeopleProperties = mapTransform(peoplePropertyTraits);
+    mixpanel.getPeople().set(mappedPeopleProperties);
+  }
+};

package/packages/plugins/plugin-mixpanel/src/methods/screen.ts

@@ -0,0 +1,43 @@
+import type { Mixpanel } from 'mixpanel-react-native';
+import type { ScreenEventType, JsonMap } from '@segment/analytics-react-native';
+import type { SegmentMixpanelSettings } from '../types';
+
+import track from './track';
+
+export default (
+  event: ScreenEventType,
+  mixpanel: Mixpanel,
+  settings: SegmentMixpanelSettings
+) => {
+  const callTrack = (eventName: string, properties: JsonMap) => {
+    track(eventName, properties, settings, mixpanel);
+  };
+  const properties = event.properties;
+
+  if (settings.consolidatedPageCalls === true) {
+    const eventName = 'Loaded a Screen';
+    const screenName = event.name;
+
+    if (screenName !== undefined) {
+      properties.name = screenName;
+    }
+
+    callTrack(eventName, properties);
+  } else if (settings.trackAllPages === true) {
+    const eventName = `Viewed ${event.name} Screen`;
+
+    callTrack(eventName, properties);
+  } else if (settings.trackNamedPages === true && event.name !== undefined) {
+    const eventName = `Viewed ${event.name} Screen`;
+
+    callTrack(eventName, properties);
+  } else if (
+    settings.trackCategorizedPages === true &&
+    event.properties?.category !== undefined
+  ) {
+    const category = event.properties.category;
+    const eventName = `Viewed ${category?.toString() ?? ''} Screen`;
+
+    callTrack(eventName, properties);
+  }
+};

package/packages/plugins/plugin-mixpanel/src/methods/track.ts

@@ -0,0 +1,60 @@
+import type { Mixpanel } from 'mixpanel-react-native';
+import type { JsonMap } from '@segment/analytics-react-native';
+import type { SegmentMixpanelSettings } from '../types';
+
+export default (
+  eventName: string,
+  properties: JsonMap,
+  settings: SegmentMixpanelSettings,
+  mixpanel: Mixpanel
+) => {
+  //track raw event
+  mixpanel.track(eventName, properties);
+
+  //everything else is for people setting
+  if (settings.people !== true) {
+    return;
+  }
+
+  if (
+    settings.propIncrements !== undefined &&
+    settings.propIncrements?.length > 0
+  ) {
+    const propIncrements = settings.propIncrements;
+
+    for (const propString of propIncrements) {
+      for (const property in properties) {
+        if (propString.toLowerCase() === property.toLowerCase()) {
+          const incrementValue = properties[property];
+          if (typeof incrementValue === 'number') {
+            mixpanel.getPeople().increment(property, incrementValue);
+          }
+        }
+      }
+    }
+  }
+
+  if (
+    settings.eventIncrements !== undefined &&
+    settings.eventIncrements.length > 0
+  ) {
+    const eventIncrements = settings.eventIncrements;
+
+    for (const eventString of eventIncrements) {
+      if (eventString.toLowerCase() === eventName.toLowerCase()) {
+        const property = eventName;
+        mixpanel.getPeople().increment(property, 1);
+
+        const lastEvent = `Last ${property}`;
+        const lastDate = Date();
+        mixpanel.getPeople().set(lastEvent, lastDate);
+      }
+    }
+  }
+
+  if (properties.revenue !== undefined) {
+    const revenue = properties.revenue as number;
+
+    mixpanel.getPeople().trackCharge(revenue, properties);
+  }
+};

package/packages/plugins/plugin-mixpanel/src/types.ts

@@ -0,0 +1,15 @@
+export type SegmentMixpanelSettings = {
+  enableEuropeanEndpoint?: boolean;
+  token: string;
+  consolidatedPageCalls?: boolean;
+  trackAllPages?: boolean;
+  trackNamedPages?: boolean;
+  trackCategorizedPages?: boolean;
+  people?: boolean;
+  setAllTraitsByDefault?: boolean;
+  superProperties?: string[];
+  peopleProperties?: string[];
+  groupIdentifierTraits?: string[];
+  eventIncrements?: string[];
+  propIncrements?: string[];
+};

package/packages/plugins/plugin-mixpanel/tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "extends": "../../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "lib/typescript",
+    "rootDir": ".",
+    "baseUrl": "."
+  },
+  "include": ["src/**/*", "types.d.ts"],
+  "references": [{ "path": "../../core" }]
+}

package/packages/plugins/plugin-onetrust/CHANGELOG.md

@@ -0,0 +1,16 @@
+### Dependencies
+
+* **@segment/analytics-react-native:** upgraded to 2.19.0
+* **@segment/sovran-react-native:** upgraded to 1.1.1
+
+### Dependencies
+
+* **@segment/analytics-react-native:** upgraded to 2.18.0
+* **@segment/sovran-react-native:** upgraded to 1.1.0
+
+## @segment/analytics-react-native-plugin-onetrust-v1.0.0 (2023-10-20)
+
+
+### Features
+
+* add consent management and support for onetrust cmp ([#882](https://github.com/segmentio/analytics-react-native/issues/882)) ([375684f](https://github.com/segmentio/analytics-react-native/commit/375684f99ac4324d30c009924ad004098d9feb38))

package/packages/plugins/plugin-onetrust/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Segment
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.