iureiure 1.0.0

package/packages/analytics-js-integrations/src/integrations/Optimizely/browser.js

@@ -0,0 +1,244 @@
+/* eslint-disable class-methods-use-this */
+import {
+  NAME,
+  DISPLAY_NAME,
+} from '@rudderstack/analytics-js-common/constants/integrations/Optimizely/constants';
+import Logger from '../../utils/logger';
+import { mapRudderPropsToOptimizelyProps } from './utils';
+
+const logger = new Logger(DISPLAY_NAME);
+
+class Optimizely {
+  constructor(config, analytics, destinationInfo) {
+    if (analytics.logLevel) {
+      logger.setLogLevel(analytics.logLevel);
+    }
+    this.analytics = analytics;
+    this.sendExperimentTrack = config.sendExperimentTrack;
+    this.sendExperimentIdentify = config.sendExperimentIdentify;
+    this.sendExperimentTrackAsNonInteractive = config.sendExperimentTrackAsNonInteractive;
+    this.revenueOnlyOnOrderCompleted = config.revenueOnlyOnOrderCompleted;
+    this.trackCategorizedPages = config.trackCategorizedPages;
+    this.trackNamedPages = config.trackNamedPages;
+    this.customCampaignProperties = config.customCampaignProperties
+      ? config.customCampaignProperties
+      : [];
+    this.customExperimentProperties = config.customExperimentProperties
+      ? config.customExperimentProperties
+      : [];
+    this.name = NAME;
+    ({
+      shouldApplyDeviceModeTransformation: this.shouldApplyDeviceModeTransformation,
+      propagateEventsUntransformedOnError: this.propagateEventsUntransformedOnError,
+      destinationId: this.destinationId,
+    } = destinationInfo ?? {});
+  }
+
+  init() {
+    this.initOptimizelyIntegration(this.referrerOverride, this.sendDataToRudder);
+  }
+
+  isLoaded() {
+    return !!(window.optimizely && window.optimizely.push !== Array.prototype.push);
+  }
+
+  isReady() {
+    return this.isLoaded();
+  }
+
+  referrerOverride = referrer => {
+    if (referrer) {
+      window.optimizelyEffectiveReferrer = referrer;
+      return referrer;
+    }
+    return undefined;
+  };
+
+  sendDataToRudder = campaignState => {
+    const { experiment, variation } = campaignState;
+    const context = { integrations: { All: true } };
+    const { audiences, campaignName, id, isInCampaignHoldback } = campaignState;
+
+    // Reformatting this data structure into hash map so concatenating variation ids and names is easier later
+    const audiencesMap = {};
+    audiences.forEach(audience => {
+      audiencesMap[audience.id] = audience.name;
+    });
+
+    const audienceIds = Object.keys(audiencesMap)
+      .sort((a, b) => a.localeCompare(b))
+      .join();
+    const audienceNames = Object.values(audiencesMap)
+      .sort((a, b) => a.localeCompare(b))
+      .join(', ');
+
+    if (this.sendExperimentTrack) {
+      let props = {
+        campaignName,
+        campaignId: id,
+        experimentId: experiment.id,
+        experimentName: experiment.name,
+        variationName: variation.name,
+        variationId: variation.id,
+        audienceId: audienceIds, // eg. '7527562222,7527111138'
+        audienceName: audienceNames, // eg. 'Peaky Blinders, Trust Tree'
+        isInCampaignHoldback,
+      };
+
+      // If this was a redirect experiment and the effective referrer is different from document.referrer,
+      // this value is made available. So if a customer came in via google.com/ad -> tb12.com -> redirect experiment -> Belichickgoat.com
+      // `experiment.referrer` would be google.com/ad here NOT `tb12.com`.
+      if (experiment.referrer) {
+        props.referrer = experiment.referrer;
+        context.page = { referrer: experiment.referrer };
+      }
+
+      // For Google's nonInteraction flag
+      if (this.sendExperimentTrackAsNonInteractive) props.nonInteraction = 1;
+
+      // If customCampaignProperties is provided override the props with it.
+      // If valid customCampaignProperties present it will override existing props.
+      // const data = window.optimizely && window.optimizely.get("data");
+      props = mapRudderPropsToOptimizelyProps(props, campaignState, this.customCampaignProperties);
+
+      // Send to Rudder
+      this.analytics.track('Experiment Viewed', props, context);
+    }
+    if (this.sendExperimentIdentify) {
+      const traits = {};
+      traits[`Experiment: ${experiment.name}`] = variation.name;
+
+      // Send to Rudder
+      this.analytics.identify(traits);
+    }
+  };
+
+  initOptimizelyIntegration(referrerOverride, sendCampaignData) {
+    const newActiveCampaign = (id, referrer) => {
+      try {
+        const state = window?.optimizely?.get('state');
+        if (state) {
+          const activeCampaigns = state.getCampaignStates({
+            isActive: true,
+          });
+          const campaignState = activeCampaigns[id];
+          if (referrer) campaignState.experiment.referrer = referrer;
+          sendCampaignData(campaignState);
+        }
+      } catch (e) {
+        logger.error('Page loaded without Optimizely.')
+      }
+    };
+
+    const checkReferrer = () => {
+      let state;
+      try {
+        state = window?.optimizely?.get('state');
+      } catch (e) {
+        state = undefined;
+      }
+      if (!state) {
+        return undefined;
+      }
+      const referrer = state.getRedirectInfo() && state.getRedirectInfo().referrer;
+      if (!referrer) {
+        return undefined;
+      }
+      referrerOverride(referrer);
+      return referrer;
+    };
+
+    const registerFutureActiveCampaigns = () => {
+      window.optimizely.push({
+        type: 'addListener',
+        filter: {
+          type: 'lifecycle',
+          name: 'campaignDecided',
+        },
+        handler(event) {
+          const { id } = event.data.campaign;
+          newActiveCampaign(id);
+        },
+      });
+    };
+
+    const registerCurrentlyActiveCampaigns = () => {
+      window.optimizely = window.optimizely || [];
+      let state;
+      try {
+        state = window?.optimizely?.get('state');
+      } catch (e) {
+        state = undefined
+      }
+      if (state) {
+        const referrer = checkReferrer();
+        const activeCampaigns = state.getCampaignStates({
+          isActive: true,
+        });
+        Object.keys(activeCampaigns).forEach(id => {
+          if (referrer) {
+            newActiveCampaign(id, referrer);
+          } else {
+            newActiveCampaign(id);
+          }
+        });
+      } else {
+        window.optimizely.push({
+          type: 'addListener',
+          filter: {
+            type: 'lifecycle',
+            name: 'initialized',
+          },
+          handler() {
+            checkReferrer();
+          },
+        });
+      }
+
+    };
+    registerCurrentlyActiveCampaigns();
+    registerFutureActiveCampaigns();
+  }
+
+  track(rudderElement) {
+    const eventProperties = rudderElement.message.properties;
+    const { event } = rudderElement.message;
+    if (eventProperties.revenue && this.revenueOnlyOnOrderCompleted) {
+      if (event === 'Order Completed') {
+        eventProperties.revenue = Math.round(eventProperties.revenue * 100);
+      } else if (event !== 'Order Completed') {
+        delete eventProperties.revenue;
+      }
+    }
+    const eventName = event.replace(/:/g, '_'); // can't have colons so replacing with underscores
+    const payload = {
+      type: 'event',
+      eventName,
+      tags: eventProperties,
+    };
+
+    window.optimizely.push(payload);
+  }
+
+  page(rudderElement) {
+    const clonedRudderElement = rudderElement;
+    const { category } = clonedRudderElement.message.properties;
+    const { name } = clonedRudderElement.message;
+
+    // categorized pages
+    if (category && this.trackCategorizedPages) {
+      clonedRudderElement.message.event = `Viewed ${category} page`;
+      clonedRudderElement.message.type = 'track';
+      this.track(clonedRudderElement);
+    }
+
+    // named pages
+    if (name && this.trackNamedPages) {
+      clonedRudderElement.message.event = `Viewed ${name} page`;
+      clonedRudderElement.message.type = 'track';
+      this.track(clonedRudderElement);
+    }
+  }
+}
+
+export default Optimizely;

package/packages/analytics-js-integrations/src/integrations/Optimizely/index.js

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

package/packages/analytics-js-integrations/src/integrations/Optimizely/utils.js

@@ -0,0 +1,23 @@
+/**
+ * Returns updated mapped properties
+ * @param {*} props
+ * @param {*} campaignState
+ * @param {*} customCampaignProperties
+ * @returns
+ */
+const mapRudderPropsToOptimizelyProps = (props, campaignState, customCampaignProperties) => {
+  const properties = props;
+  if (campaignState && customCampaignProperties.length > 0) {
+    customCampaignProperties.forEach(customCampaignProperty => {
+      const rudderProp = customCampaignProperties[customCampaignProperty].from;
+      const optimizelyProp = customCampaignProperties[customCampaignProperty].to;
+      if (typeof properties[optimizelyProp] !== 'undefined') {
+        properties[rudderProp] = properties[optimizelyProp];
+        delete properties[optimizelyProp];
+      }
+    });
+  }
+  return properties;
+};
+
+export { mapRudderPropsToOptimizelyProps };

package/packages/analytics-js-integrations/src/integrations/Pendo/browser.js

@@ -0,0 +1,123 @@
+/* eslint-disable class-methods-use-this */
+/* eslint-disable lines-between-class-members */
+import {
+  NAME,
+  DISPLAY_NAME,
+} from '@rudderstack/analytics-js-common/constants/integrations/Pendo/constants';
+import Logger from '../../utils/logger';
+import { loadNativeSdk } from './nativeSdkLoader';
+
+const logger = new Logger(DISPLAY_NAME);
+
+class Pendo {
+  constructor(config, analytics, destinationInfo) {
+    if (analytics.logLevel) {
+      logger.setLogLevel(analytics.logLevel);
+    }
+    this.analytics = analytics;
+    this.apiKey = !config.apiKey ? '' : config.apiKey;
+    this.name = NAME;
+    ({
+      shouldApplyDeviceModeTransformation: this.shouldApplyDeviceModeTransformation,
+      propagateEventsUntransformedOnError: this.propagateEventsUntransformedOnError,
+      destinationId: this.destinationId,
+    } = destinationInfo ?? {});
+  }
+
+  init() {
+    loadNativeSdk(this.apiKey);
+    this.initializeMe();
+  }
+
+  initializeMe() {
+    const userId =
+      this.analytics.getUserId() || this.constructPendoAnonymousId(this.analytics.getAnonymousId());
+
+    const accountObj = {
+      id: this.analytics.getGroupId(),
+      ...this.analytics.getGroupTraits(),
+    };
+    const visitorObj = { id: userId, ...this.analytics.getUserTraits() };
+
+    window.pendo.initialize({ account: accountObj, visitor: visitorObj });
+  }
+
+  isLoaded() {
+    return !!(window.pendo && window.pendo.push !== Array.prototype.push);
+  }
+
+  isReady() {
+    return this.isLoaded();
+  }
+
+  constructPendoAnonymousId(id) {
+    return `_PENDO_T_${id}`;
+  }
+  /* utility functions --- Ends here ---  */
+
+  /*
+   * PENDO MAPPED FUNCTIONS :: identify, track, group
+   */
+
+  /* Pendo's identify call works intelligently, once u have identified a visitor/user,
+   *or associated a visitor to a group/account then Pendo save this data in local storage and
+   *any further upcoming calls are done taking user info from local.
+   * To track user pendo maps user to Visitor in Pendo.
+   */
+  identify(rudderElement) {
+    let visitorObj = {};
+    let accountObj = {};
+    const { userId, anonymousId, groupId, context, traits } = rudderElement.message;
+    const id = userId || this.constructPendoAnonymousId(anonymousId);
+    const userTraits = context?.traits || {};
+    visitorObj = {
+      id,
+      ...userTraits,
+    };
+
+    const groupTraits = traits || {};
+    if (groupId) {
+      accountObj = { id: groupId, ...groupTraits };
+    }
+    window.pendo.identify({ visitor: visitorObj, account: accountObj });
+  }
+
+  /*
+   *Group call maps to an account for which visitor belongs.
+   *It is same as identify call but here we send account object.
+   */
+  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.pendo.identify({ account: accountObj, visitor: visitorObj });
+  }
+
+  /* Once user is identified Pendo makes Track call to track user activity.
+   */
+  track(rudderElement) {
+    const { event, properties } = rudderElement.message;
+    if (!event) {
+      logger.error('Cannot call un-named track event');
+      return;
+    }
+    const props = properties;
+    window.pendo.track(event, props);
+  }
+}
+
+export default Pendo;

package/packages/analytics-js-integrations/src/integrations/Pendo/index.js

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

package/packages/analytics-js-integrations/src/integrations/Pendo/nativeSdkLoader.js

@@ -0,0 +1,32 @@
+import { LOAD_ORIGIN } from '@rudderstack/analytics-js-common/v1.1/utils/constants';
+
+function loadNativeSdk(apiKey) {
+  (function (apiKey) {
+    (function (p, e, n, d, o) {
+      let v;
+      let w;
+      let x;
+      let y;
+      let z;
+      o = p[d] = p[d] || {};
+      o._q = [];
+      v = ['initialize', 'identify', 'updateOptions', 'pageLoad', 'track'];
+      for (w = 0, x = v.length; w < x; ++w)
+        (function (m) {
+          o[m] =
+            o[m] ||
+            function () {
+              o._q[m === v[0] ? 'unshift' : 'push']([m].concat([].slice.call(arguments, 0)));
+            };
+        })(v[w]);
+      y = e.createElement(n);
+      y.setAttribute('data-loader', LOAD_ORIGIN);
+      y.async = !0;
+      y.src = `https://cdn.pendo.io/agent/static/${apiKey}/pendo.js`;
+      z = e.getElementsByTagName(n)[0];
+      z.parentNode.insertBefore(y, z);
+    })(window, document, 'script', 'pendo');
+  })(apiKey);
+}
+
+export { loadNativeSdk };

package/packages/analytics-js-integrations/src/integrations/PinterestTag/browser.js

@@ -0,0 +1,240 @@
+/* eslint-disable class-methods-use-this */
+import get from 'get-value';
+import {
+  NAME,
+  DISPLAY_NAME,
+} from '@rudderstack/analytics-js-common/constants/integrations/PinterestTag/constants';
+import sha256 from 'crypto-js/sha256';
+import Logger from '../../utils/logger';
+import {
+  propertyMapping,
+  searchPropertyMapping,
+  productPropertyMapping,
+  pinterestPropertySupport,
+} from './propertyMappingConfig';
+import {
+  getDefinedTraits,
+  getDataFromSource,
+  flattenJsonPayload,
+  isDefinedAndNotNull,
+} from '../../utils/utils';
+import { getDestinationEventName } from './utils';
+import { loadNativeSdk } from './nativeSdkLoader';
+
+const logger = new Logger(DISPLAY_NAME);
+
+export default class PinterestTag {
+  constructor(config, analytics, destinationInfo) {
+    if (analytics.logLevel) {
+      logger.setLogLevel(analytics.logLevel);
+    }
+    this.analytics = analytics;
+    this.tagId = !config.tagId ? '' : config.tagId;
+    this.enhancedMatch = config.enhancedMatch || false;
+    this.customProperties = config.customProperties || [];
+    this.userDefinedEventsMapping = config.eventsMapping || [];
+    this.name = NAME;
+    this.deduplicationKey = config.deduplicationKey;
+    ({
+      shouldApplyDeviceModeTransformation: this.shouldApplyDeviceModeTransformation,
+      propagateEventsUntransformedOnError: this.propagateEventsUntransformedOnError,
+      destinationId: this.destinationId,
+    } = destinationInfo ?? {});
+    this.sendAsCustomEvent = config.sendAsCustomEvent || false;
+  }
+
+  loadScript() {
+    loadNativeSdk();
+  }
+
+  handleEnhancedMatch() {
+    const userTraits = this.analytics.getUserTraits();
+    const { email } = userTraits;
+    if (email && this.enhancedMatch) {
+      window.pintrk('load', this.tagId, {
+        em: email,
+      });
+    } else {
+      window.pintrk('load', this.tagId);
+    }
+    window.pintrk('page');
+  }
+
+  init() {
+    this.loadScript();
+    this.handleEnhancedMatch();
+  }
+
+  isLoaded() {
+    return !!(window.pintrk && window.pintrk.push !== Array.prototype.push);
+  }
+
+  isReady() {
+    return this.isLoaded();
+  }
+
+  // ref :- https://developers.pinterest.com/docs/conversions/conversion-management/#Understanding%20Limited%20Data%20Processing#%0A%2CCPRA%20Related%20Data%20Fields:~:text=using%20SHA%2D256.-,%3C,%3E,-To%20specifically%20not
+  generateLdpObject(message) {
+    if (!message) {
+      const { userTraits } = this.analytics;
+      const optOutType = userTraits?.optOutType || '';
+      const state =
+        userTraits?.state ||
+        userTraits?.State ||
+        userTraits?.address?.state ||
+        userTraits?.address?.State ||
+        '';
+      const country =
+        userTraits?.country ||
+        userTraits?.Country ||
+        userTraits?.address?.country ||
+        userTraits?.address?.Country ||
+        '';
+      return {
+        opt_out_type: optOutType,
+        st: optOutType ? sha256(state).toString() : '',
+        country: optOutType ? sha256(country).toString() : '',
+      };
+    }
+
+    const optOutType = message.context.traits?.optOutType || message.properties?.optOutType || '';
+    const { state, country } = getDefinedTraits(message);
+    return {
+      opt_out_type: optOutType,
+      st: optOutType ? sha256(state || '').toString() : '',
+      country: optOutType ? sha256(country || '').toString() : '',
+    };
+  }
+
+  setLdp(message) {
+    window.pintrk('set', this.generateLdpObject(message));
+  }
+
+  sendPinterestTrack(eventName, pinterestObject) {
+    window.pintrk('track', eventName, pinterestObject);
+  }
+
+  /**
+   * Send rudder property and mappings array. This function will return data mapping destination property
+   * @param {*} properties
+   * @param {*} mappings
+   * @returns Pinterest Products
+   */
+  getMappingObject(properties, mappings, isPersist = false) {
+    let pinterestObject = {};
+    mappings.forEach(mapping => {
+      pinterestObject = {
+        ...getDataFromSource(mapping.src, mapping.dest, properties),
+        ...pinterestObject,
+      };
+    });
+    if (isPersist) {
+      return {
+        ...pinterestObject,
+        ...properties,
+      };
+    }
+    return pinterestObject;
+  }
+
+  /**
+   * This function  simply copies data from rudder payload to new object provided all
+   * the key in properties is present in pinterestPropertySupport
+   * @param {rudder properties} properties
+   * @returns
+   */
+  getRawPayload(properties) {
+    const data = {};
+    const mappedProps = this.getMappingObject(properties, propertyMapping, true);
+    Object.keys(mappedProps).forEach(p => {
+      if (pinterestPropertySupport.includes(p)) {
+        data[p] = mappedProps[p];
+      }
+    });
+    // This logic maps rudder query to search_query for Products Searched events
+    if (isDefinedAndNotNull(properties[searchPropertyMapping.src])) {
+      data[searchPropertyMapping.dest] = properties[searchPropertyMapping.src];
+    }
+    return data;
+  }
+
+  /**
+   * This function will generate required pinterest object to be sent.
+   * getRawPayload() will generate all the destination property excepts lineItems.
+   * If rudder payload has products array then line_items is generated
+   * If it does not have product array, it will move the whole message.properties into line items. ex: Product Added
+   *
+   * @param {rudder payload} properties
+   * @returns
+   */
+  generatePinterestObject(properties) {
+    const pinterestObject = this.getRawPayload(properties);
+
+    let { products } = properties;
+    if (!products) {
+      products = [properties];
+    }
+    if (products) {
+      const lineItems = [];
+      products.forEach(p => {
+        const product = this.getMappingObject(p, productPropertyMapping);
+        lineItems.push(product);
+      });
+      pinterestObject.line_items = lineItems;
+    }
+
+    if (this.customProperties.length > 0 && Object.keys(properties).length > 0) {
+      const flattenPayload = flattenJsonPayload(properties);
+
+      this.customProperties.forEach(custom => {
+        // This check fails if user is sending boolean value as false
+        // Adding toString because if the property value is boolean then it never gets reflected in destination
+        if (isDefinedAndNotNull(flattenPayload[custom.properties])) {
+          pinterestObject[custom.properties] = flattenPayload[custom.properties].toString();
+        }
+      });
+    }
+    return pinterestObject;
+  }
+
+  track(rudderElement) {
+    const { message } = rudderElement;
+    if (!message?.event) {
+      return;
+    }
+    const { properties, event, messageId } = message;
+    const destEventArray = getDestinationEventName(
+      event,
+      this.userDefinedEventsMapping,
+      this.sendAsCustomEvent,
+    );
+    destEventArray.forEach(eventName => {
+      const pinterestObject = this.generatePinterestObject(properties);
+      pinterestObject.event_id = get(message, `${this.deduplicationKey}`) || messageId;
+      this.setLdp(message);
+      this.sendPinterestTrack(eventName, pinterestObject);
+    });
+  }
+
+  page(rudderElement) {
+    const { category, name } = rudderElement.message;
+    const pageObject = { name: name || '' };
+    let event = 'PageVisit';
+    if (category) {
+      pageObject.category = category;
+      event = 'ViewCategory';
+    }
+    this.setLdp(rudderElement.message);
+    window.pintrk('track', event, pageObject);
+  }
+
+  identify(rudderElement) {
+    const { context } = rudderElement.message;
+    const userTraits = context?.traits || {};
+    const { email } = userTraits;
+    if (email) {
+      const ldpObject = this.generateLdpObject();
+      window.pintrk('set', { em: email, ...ldpObject });
+    }
+  }
+}

package/packages/analytics-js-integrations/src/integrations/PinterestTag/index.js

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

package/packages/analytics-js-integrations/src/integrations/PinterestTag/nativeSdkLoader.js

@@ -0,0 +1,19 @@
+import { LOAD_ORIGIN } from '@rudderstack/analytics-js-common/v1.1/utils/constants';
+
+function loadNativeSdk(e) {
+  !(function (e) {
+    if (!window.pintrk) {
+      window.pintrk = function () {
+        window.pintrk.queue.push(Array.prototype.slice.call(arguments));
+      };
+      const n = window.pintrk;
+      (n.queue = []), (n.version = '3.0');
+      const t = document.createElement('script');
+      (t.async = !0), (t.src = e), t.setAttribute('data-loader', LOAD_ORIGIN);
+      const r = document.getElementsByTagName('script')[0];
+      r.parentNode.insertBefore(t, r);
+    }
+  })('https://s.pinimg.com/ct/core.js');
+}
+
+export { loadNativeSdk };