feat: gainsight PX destination (#1852)

packages/analytics-js-common/src/constants/integrations/Gainsight_PX/constants.ts

@@ -0,0 +1,11 @@
+const DIR_NAME = 'Gainsight_PX';
+const NAME = 'GAINSIGHT_PX';
+const DISPLAY_NAME = 'Gainsight PX';
+
+const DISPLAY_NAME_TO_DIR_NAME_MAP = { [DISPLAY_NAME]: DIR_NAME };
+const CNameMapping = {
+  [NAME]: NAME,
+  Gainsight_PX: NAME,
+};
+
+export { NAME, CNameMapping, DISPLAY_NAME_TO_DIR_NAME_MAP, DISPLAY_NAME, DIR_NAME };

packages/analytics-js-common/src/constants/integrations/client_server_name.js

@@ -79,6 +79,7 @@ const clientToServerNames = {
   COMMANDBAR: 'CommandBar',
   NINETAILED: 'Ninetailed',
   XPIXEL: 'XPixel',
+  GAINSIGHT_PX: 'Gainsight_PX',
 };
 
 export { clientToServerNames };

packages/analytics-js-common/src/constants/integrations/config_to_integration_names.js

@@ -80,6 +80,7 @@ const configToIntNames = {
   COMMANDBAR: 'CommandBar',
   NINETAILED: 'Ninetailed',
   XPIXEL: 'XPixel',
+  GAINSIGHT_PX: 'Gainsight_PX',
 };
 
 export { configToIntNames };

packages/analytics-js-common/src/constants/integrations/destDisplayNamesToFileNamesMap.ts

@@ -158,6 +158,8 @@ import {
   CommandBarDirectoryName,
   NinetailedDisplayName,
   NinetailedDirectoryName,
+  Gainsight_PXDisplayName,
+  Gainsight_PXDirectoryName,
 } from './destinationNames';
 
 // The destination directory name is used as the destination SDK file name in CDN
@@ -241,6 +243,7 @@ const destDisplayNamesToFileNamesMap: Record<string, string> = {
   [SpotifyPixelDisplayName]: SpotifyPixelDirectoryName,
   [CommandBarDisplayName]: CommandBarDirectoryName,
   [NinetailedDisplayName]: NinetailedDirectoryName,
+  [Gainsight_PXDisplayName]: Gainsight_PXDirectoryName,
 };
 
 export { destDisplayNamesToFileNamesMap };

packages/analytics-js-common/src/constants/integrations/destinationNames.ts

@@ -290,3 +290,7 @@
   DISPLAY_NAME as NinetailedDisplayName,
   DIR_NAME as NinetailedDirectoryName,
 } from './Ninetailed/constants';
+export {
+  DISPLAY_NAME as Gainsight_PXDisplayName,
+  DIR_NAME as Gainsight_PXDirectoryName,
+} from './Gainsight_PX/constants';

packages/analytics-js-common/src/constants/integrations/integration_cname.js

@@ -78,6 +78,7 @@
 import { CNameMapping as CommandBar } from './CommandBar/constants';
 import { CNameMapping as Ninetailed } from './Ninetailed/constants';
 import { CNameMapping as XPixel } from './XPixel/constants';
+import { CNameMapping as Gainsight_PX } from './Gainsight_PX/constants';
 // for sdk side native integration identification
 // add a mapping from common names to index.js exported key names as identified by Rudder
 const commonNames = {
@@ -162,6 +163,7 @@
   ...Sprig,
   ...SpotifyPixel,
   ...XPixel,
+  ...Gainsight_PX
 };
 
 export { commonNames };

packages/analytics-js-integrations/__tests__/integrations/Gainsight_PX/browser.test.js

@@ -0,0 +1,173 @@
+import Gainsight_PX from '../../../src/integrations/Gainsight_PX/browser';
+import { loadNativeSdk } from '../../../src/integrations/Gainsight_PX/nativeSdkLoader';
+import { getDestinationOptions } from '../../../src/integrations/Gainsight_PX/utils';
+
+// Mock the external dependencies
+jest.mock('../../../src/integrations/Gainsight_PX/nativeSdkLoader');
+jest.mock('../../../src/integrations/Gainsight_PX/utils');
+
+describe('Gainsight_PX', () => {
+  let gainsightPX;
+  let mockAnalytics;
+  let mockConfig;
+
+  beforeEach(() => {
+    // Reset mocks
+    jest.clearAllMocks();
+
+    // Mock window.aptrinsic
+    window.aptrinsic = jest.fn();
+
+    // Mock analytics object
+    mockAnalytics = {
+      logLevel: 'debug',
+      getUserId: jest.fn(),
+      getUserTraits: jest.fn(),
+      getGroupId: jest.fn(),
+      getGroupTraits: jest.fn(),
+      loadOnlyIntegrations: {},
+    };
+
+    // Mock config
+    mockConfig = {
+      productTagKey: 'test-product-key',
+      dataCenter: 'US',
+    };
+
+    gainsightPX = new Gainsight_PX(mockConfig, mockAnalytics);
+  });
+
+  describe('init', () => {
+    it('should load native SDK and initialize', () => {
+      getDestinationOptions.mockReturnValue({ someOption: 'value' });
+      mockAnalytics.getUserId.mockReturnValue('test-user-id');
+      mockAnalytics.getUserTraits.mockReturnValue({ name: 'Test User' });
+      mockAnalytics.getGroupId.mockReturnValue('test-group-id');
+      mockAnalytics.getGroupTraits.mockReturnValue({ plan: 'premium' });
+
+      gainsightPX.init();
+
+      expect(loadNativeSdk).toHaveBeenCalledWith('test-product-key', 'US', { someOption: 'value' });
+      expect(window.aptrinsic).toHaveBeenCalledWith(
+        'identify',
+        { id: 'test-user-id', name: 'Test User' },
+        { id: 'test-group-id', plan: 'premium' }
+      );
+    });
+
+    it('should not call identify if user ID is not present', () => {
+      mockAnalytics.getUserId.mockReturnValue(null);
+
+      gainsightPX.init();
+
+      expect(loadNativeSdk).toHaveBeenCalled();
+      expect(window.aptrinsic).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('identify', () => {
+    it('should call aptrinsic identify with user data', () => {
+      const rudderElement = {
+        message: {
+          userId: 'test-user-id',
+          context: {
+            traits: { name: 'Test User', email: '[email protected]' },
+          },
+        },
+      };
+
+      gainsightPX.identify(rudderElement);
+
+      expect(window.aptrinsic).toHaveBeenCalledWith(
+        'identify',
+        { id: 'test-user-id', name: 'Test User', email: '[email protected]' },
+        {}
+      );
+    });
+
+    it('should not call aptrinsic identify if userId is missing', () => {
+      const rudderElement = {
+        message: {
+          context: {
+            traits: { name: 'Test User' },
+          },
+        },
+      };
+
+      gainsightPX.identify(rudderElement);
+
+      expect(window.aptrinsic).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('group', () => {
+    it('should call aptrinsic identify with group data', () => {
+      const rudderElement = {
+        message: {
+          userId: 'test-user-id',
+          groupId: 'test-group-id',
+          traits: { plan: 'premium' },
+          context: {
+            traits: { name: 'Test User' },
+          },
+        },
+      };
+
+      gainsightPX.group(rudderElement);
+
+      expect(window.aptrinsic).toHaveBeenCalledWith(
+        'identify',
+        { id: 'test-user-id', name: 'Test User' },
+        { id: 'test-group-id', plan: 'premium' }
+      );
+    });
+
+    it('should use anonymousId if groupId is not present', () => {
+      const rudderElement = {
+        message: {
+          anonymousId: 'anon-id',
+          traits: { plan: 'basic' },
+        },
+      };
+
+      gainsightPX.group(rudderElement);
+
+      expect(window.aptrinsic).toHaveBeenCalledWith(
+        'identify',
+        {},
+        { id: 'anon-id', plan: 'basic' }
+      );
+    });
+  });
+
+  describe('track', () => {
+    it('should call aptrinsic track with event data', () => {
+      const rudderElement = {
+        message: {
+          event: 'Test Event',
+          properties: { category: 'test', value: 10 },
+        },
+      };
+
+      gainsightPX.track(rudderElement);
+
+      expect(window.aptrinsic).toHaveBeenCalledWith(
+        'track',
+        'Test Event',
+        { category: 'test', value: 10 }
+      );
+    });
+
+    it('should not call aptrinsic track if event name is missing', () => {
+      const rudderElement = {
+        message: {
+          properties: { category: 'test' },
+        },
+      };
+
+      gainsightPX.track(rudderElement);
+
+      expect(window.aptrinsic).not.toHaveBeenCalled();
+    });
+  });
+});

packages/analytics-js-integrations/src/integrations/Gainsight_PX/browser.js

@@ -0,0 +1,119 @@
+/* eslint-disable class-methods-use-this */
+/* eslint-disable lines-between-class-members */
+import {
+  NAME,
+  DISPLAY_NAME,
+} from '@rudderstack/analytics-js-common/constants/integrations/Gainsight_PX/constants';
+import Logger from '../../utils/logger';
+import { loadNativeSdk } from './nativeSdkLoader';
+import { getDestinationOptions } from './utils';
+
+const logger = new Logger(DISPLAY_NAME);
+
+class Gainsight_PX {
+  constructor(config, analytics, destinationInfo) {
+    if (analytics.logLevel) {
+      logger.setLogLevel(analytics.logLevel);
+    }
+    this.analytics = analytics;
+    this.productKey = config.productTagKey;
+    this.dataCenter = !config.dataCenter ? 'US' : config.dataCenter;
+    this.name = NAME;
+    ({
+      shouldApplyDeviceModeTransformation: this.shouldApplyDeviceModeTransformation,
+      propagateEventsUntransformedOnError: this.propagateEventsUntransformedOnError,
+      destinationId: this.destinationId,
+    } = destinationInfo ?? {});
+  }
+
+  init() {
+    const pxConfig = getDestinationOptions(this.analytics.loadOnlyIntegrations) || {};
+    loadNativeSdk(this.productKey, this.dataCenter, pxConfig);
+    this.initializeMe();
+  }
+
+  initializeMe() {
+    const userId = this.analytics.getUserId();
+
+    // Only proceed with identify if user ID is defined
+    if (userId) {
+      const visitorObj = { id: userId, ...this.analytics.getUserTraits() };
+
+      const accountObj = {
+        id: this.analytics.getGroupId(),
+        ...this.analytics.getGroupTraits(),
+      };
+
+      window.aptrinsic('identify', visitorObj, accountObj);
+    }
+  }
+
+  isLoaded() {
+    return !!(window.aptrinsic && window.aptrinsic.init);
+  }
+
+  isReady() {
+    return this.isLoaded();
+  }
+
+  /* utility functions --- Ends here ---  */
+
+  /*
+   * Gainsight_PX MAPPED FUNCTIONS :: identify, track, group
+   */
+
+  identify(rudderElement) {
+    let visitorObj = {};
+    const accountObj = {};
+    const { userId, context } = rudderElement.message;
+    const id = userId;
+    const userTraits = context?.traits || {};
+    visitorObj = {
+      id,
+      ...userTraits,
+    };
+
+    if (!userId) {
+      return;
+    }
+    window.aptrinsic('identify', visitorObj, accountObj);
+  }
+
+  /*
+   *Group call maps to an account for which visitor belongs.
+   *It is same as identify call
+   */
+  group(rudderElement) {
+    let accountObj = {};
+    let visitorObj = {};
+    const { userId, traits, context, groupId, anonymousId } = rudderElement.message;
+    accountObj.id = groupId || anonymousId;
+    accountObj = {
+      ...accountObj,
+      ...traits,
+    };
+
+    const userTraits = context?.traits || {};
+    if (userId) {
+      visitorObj = {
+        id: userId,
+        ...userTraits,
+      };
+    }
+
+    window.aptrinsic('identify',visitorObj, accountObj);
+  }
+
+  // Custom Events
+  track(rudderElement) {
+    const { event, properties } = rudderElement.message;
+    if (!event) {
+      logger.error('Cannot send un-named custom event');
+      return;
+    }
+    const props = properties;
+    window.aptrinsic('track', event, props);
+  }
+}
+
+export default Gainsight_PX;

packages/analytics-js-integrations/src/integrations/Gainsight_PX/index.js

@@ -0,0 +1 @@
+export { default as Gainsight_PX } from './browser';

packages/analytics-js-integrations/src/integrations/Gainsight_PX/nativeSdkLoader.js

@@ -0,0 +1,29 @@
+import { LOAD_ORIGIN } from '@rudderstack/analytics-js-common/v1.1/utils/constants';
+
+function loadNativeSdk(productKey, dataCenter, pxConfig) {
+  let hostName = 'web-sdk.aptrinsic.com';
+  switch (dataCenter) {
+    case 'EU':
+      hostName = 'web-sdk-eu.aptrinsic.com';
+      break;
+    case 'US2':
+      hostName = 'web-sdk-us2.aptrinsic.com';
+      break;
+  }
+  const sdkUrl= "https://" + hostName + "/api/aptrinsic.js";
+
+  (function(n,t,a,e, co){
+      var i="aptrinsic";
+      n[i]=n[i]||function(){
+        (n[i].q=n[i].q||[]).push(arguments)
+      },n[i].p=e;
+      n[i].c=co;
+      var r=t.createElement("script");
+      r.async=!0,r.src=a+"?a="+e;
+      r.setAttribute('data-loader', LOAD_ORIGIN);
+      var c=t.getElementsByTagName("script")[0];
+      c.parentNode.insertBefore(r,c)
+   })(window, document, sdkUrl, productKey, pxConfig);
+}
+
+export { loadNativeSdk };