castled-js-sdk 0.0.1 → 0.0.2

package/src/integrations/Adroll/browser.js

@@ -0,0 +1,125 @@
+/* eslint-disable no-underscore-dangle */
+/* eslint-disable class-methods-use-this */
+import get from 'get-value';
+import logger from '../../utils/logUtil';
+
+import { getHashFromArray } from '../../utils/commonUtils';
+
+import { NAME } from './constants';
+import ScriptLoader from '../../utils/ScriptLoader';
+import { PRODUCT_EVENTS, ORDER_EVENTS, productEvent, orderEvent } from './util';
+
+class Adroll {
+  constructor(config, analytics, destinationInfo) {
+    if (analytics.logLevel) {
+      logger.setLogLevel(analytics.logLevel);
+    }
+    this.analytics = analytics;
+    this.advId = config.advId;
+    this.pixId = config.pixId;
+    this.name = NAME;
+    window.adroll_adv_id = this.advId;
+    window.adroll_pix_id = this.pixId;
+    this.eventsMap = config.eventsMap || [];
+    ({
+      shouldApplyDeviceModeTransformation: this.shouldApplyDeviceModeTransformation,
+      propagateEventsUntransformedOnError: this.propagateEventsUntransformedOnError,
+      destinationId: this.destinationId,
+    } = destinationInfo ?? {});
+  }
+
+  init() {
+    logger.debug('===In init Adroll===');
+    ScriptLoader('adroll roundtrip', `https://s.adroll.com/j/${this.advId}/roundtrip.js`);
+  }
+
+  isLoaded() {
+    logger.debug('===In isLoaded Adroll===');
+    return !!window.__adroll;
+  }
+
+  isReady() {
+    logger.debug('===In isReady Adroll===');
+    return !!window.__adroll;
+  }
+
+  identify(htElement) {
+    logger.debug('===In Adroll Identify===');
+    const { message } = htElement;
+    const email = get(message, 'context.traits.email') || get(message, 'traits.email');
+
+    if (!email) {
+      logger.error('User parameter (email) is required for identify call');
+      return;
+    }
+    window._adroll_email = email;
+    window.__adroll.record_adroll_email('segment');
+  }
+  // record_adroll_email is used to attach a image pixel to the page connected to the user identified
+
+  track(htElement) {
+    const { message } = htElement;
+    const { userId, event, properties } = message;
+    const eventsHashmap = getHashFromArray(this.eventsMap);
+    let data;
+    if (eventsHashmap[event.toLowerCase()]) {
+      if (userId) {
+        properties.user_id = userId;
+      }
+      if (PRODUCT_EVENTS.indexOf(event.toLowerCase()) !== -1) {
+        data = productEvent(properties);
+      } else if (ORDER_EVENTS.indexOf(event.toLowerCase()) !== -1) {
+        data = orderEvent(properties);
+      } else {
+        if (properties.revenue) {
+          properties.adroll_conversion_value = properties.revenue;
+          delete properties.revenue;
+        }
+        const segmentId = eventsHashmap[event.toLowerCase()];
+        properties.adroll_segments = segmentId;
+        data = properties;
+      }
+      const segmentId = eventsHashmap[event.toLowerCase()];
+      data.adroll_segments = segmentId;
+      window.__adroll.record_user(data);
+    } else {
+      logger.error(`The event ${event} is not mapped to any segmentId. Aborting!`);
+    }
+  }
+  // record_user fires the correct pixel in accordance with the event configured in the dashboard
+  // and the segment associated in adroll
+
+  page(htElement) {
+    logger.debug('=== In Adroll Page ===');
+    const { message } = htElement;
+    const eventsHashmap = getHashFromArray(this.eventsMap);
+    let pageFullName;
+    if (!message.name && !message.category) {
+      pageFullName = `Viewed a Page`;
+    } else if (!message.name && message.category) {
+      pageFullName = `Viewed ${message.category} Page`;
+    } else if (message.name && !message.category) {
+      pageFullName = `Viewed ${message.name} Page`;
+    } else {
+      pageFullName = `Viewed ${message.category} ${message.name} Page`;
+    }
+
+    const segmentId = eventsHashmap[pageFullName.toLowerCase()];
+    if (!segmentId) {
+      logger.error(`The event ${pageFullName} is not mapped to any segmentId. Aborting!`);
+      return;
+    }
+
+    window.__adroll.record_user({
+      adroll_segments: segmentId,
+      name: pageFullName,
+      path: window.location.pathname,
+      referrer: window.document.referrer,
+      search: window.location.search,
+      title: window.document.title,
+      url: window.location.href,
+    });
+  }
+}
+
+export default Adroll;

package/src/integrations/Adroll/constants.js

@@ -0,0 +1,10 @@
+const NAME = 'ADROLL';
+const CNameMapping = {
+  [NAME]: NAME,
+  Adroll: NAME,
+  'Ad roll': NAME,
+  'ad roll': NAME,
+  adroll: NAME,
+};
+
+export { NAME, CNameMapping };

package/src/integrations/Adroll/index.js

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

package/src/integrations/Adroll/util.js

@@ -0,0 +1,48 @@
+// here we map the properties which give information about a singleproduct
+const PRODUCT_EVENTS = ['product clicked', 'product viewed', 'product added'];
+const ORDER_EVENTS = [
+  'cart viewed',
+  'checkout started',
+  'order completed',
+  'order cancelled',
+  'order updated',
+];
+
+const productEvent = (params) => {
+  const properties = params;
+  if (properties.price) {
+    properties.adroll_conversion_value = properties.price;
+    delete properties.price;
+  }
+  return properties;
+};
+
+// here we map the properties which give information about the order
+// like order_id or revenue
+
+const orderEvent = (params) => {
+  const properties = params;
+  if (properties.orderId) {
+    properties.order_id = properties.orderId;
+    delete properties.orderId;
+  }
+  if (properties.revenue) {
+    properties.adroll_conversion_value = properties.revenue;
+    delete properties.revenue;
+  } else {
+    let productRevenue = 0;
+    if (properties.products) {
+      properties.products.forEach((product) => {
+        productRevenue += product.price;
+      });
+    }
+    properties.adroll_conversion_value = productRevenue;
+  }
+  if (properties.currency) {
+    properties.adroll_currency = properties.currency;
+    delete properties.currency;
+  }
+  return properties;
+};
+
+export { PRODUCT_EVENTS, ORDER_EVENTS, productEvent, orderEvent };

package/src/integrations/Amplitude/browser.js

@@ -0,0 +1,352 @@
+/* eslint-disable no-underscore-dangle */
+/* eslint-disable class-methods-use-this */
+import Logger from '../../utils/logger';
+import { type } from '../../utils/utils';
+import { NAME } from './constants';
+
+import { loadNativeSdk } from './nativeSdkLoader';
+import { getTraitsToSetOnce, getTraitsToIncrement } from './utils';
+
+const logger = new Logger(NAME);
+
+class Amplitude {
+  constructor(config, analytics, destinationInfo) {
+    if (analytics.logLevel) {
+      logger.setLogLevel(analytics.logLevel);
+    }
+    this.name = NAME;
+    this.analytics = analytics;
+    this.apiKey = config.apiKey;
+    this.trackAllPages = config.trackAllPages || false;
+    this.trackNamedPages = config.trackNamedPages || false;
+    this.trackCategorizedPages = config.trackCategorizedPages || false;
+    this.trackUtmProperties = config.trackUtmProperties || false;
+    this.trackReferrer = config.trackReferrer || false;
+    this.batchEvents = config.batchEvents || false;
+    this.eventUploadThreshold = +config.eventUploadThreshold || 30;
+    this.eventUploadPeriodMillis = +config.eventUploadPeriodMillis || 30000;
+    this.forceHttps = config.forceHttps || false;
+    this.trackGclid = config.trackGclid || false;
+    this.saveParamsReferrerOncePerSession = config.saveParamsReferrerOncePerSession || false;
+    this.deviceIdFromUrlParam = config.deviceIdFromUrlParam || false;
+    this.trackRevenuePerProduct = config.trackRevenuePerProduct || false;
+    this.preferAnonymousIdForDeviceId = config.preferAnonymousIdForDeviceId || false;
+    this.traitsToSetOnce = getTraitsToSetOnce(config);
+    this.traitsToIncrement = getTraitsToIncrement(config);
+    this.appendFieldsToEventProps = config.appendFieldsToEventProps || false;
+    this.unsetParamsReferrerOnNewSession = config.unsetParamsReferrerOnNewSession || false;
+    this.trackProductsOnce = config.trackProductsOnce || false;
+    this.versionName = config.versionName;
+    ({
+      shouldApplyDeviceModeTransformation: this.shouldApplyDeviceModeTransformation,
+      propagateEventsUntransformedOnError: this.propagateEventsUntransformedOnError,
+      destinationId: this.destinationId,
+    } = destinationInfo ?? {});
+  }
+
+  init() {
+    if (this.analytics.loadIntegration) {
+      loadNativeSdk(window, document);
+    }
+
+    const initOptions = {
+      includeUtm: this.trackUtmProperties,
+      batchEvents: this.batchEvents,
+      eventUploadThreshold: this.eventUploadThreshold,
+      eventUploadPeriodMillis: this.eventUploadPeriodMillis,
+      forceHttps: this.forceHttps,
+      includeGclid: this.trackGclid,
+      includeReferrer: this.trackReferrer,
+      saveParamsReferrerOncePerSession: this.saveParamsReferrerOncePerSession,
+      deviceIdFromUrlParam: this.deviceIdFromUrlParam,
+      unsetParamsReferrerOnNewSession: this.unsetParamsReferrerOnNewSession,
+      deviceId:
+        this.preferAnonymousIdForDeviceId && this.analytics && this.analytics.getAnonymousId(),
+    };
+    window.amplitude.getInstance().init(this.apiKey, null, initOptions);
+    if (this.versionName) {
+      window.amplitude.getInstance().setVersionName(this.versionName);
+    }
+  }
+
+  isLoaded() {
+    logger.debug('in Amplitude isLoaded');
+    return !!window?.amplitude?.getInstance()?.options;
+  }
+
+  isReady() {
+    return !!window?.amplitude?.getInstance()?.options;
+  }
+
+  identify(htElement) {
+    logger.debug('in Amplitude identify');
+
+    this.setDeviceId(htElement);
+
+    // htElement.message.context will always be present as part of identify event payload.
+    const { traits } = htElement.message.context;
+    const { userId } = htElement.message;
+
+    if (userId) {
+      window.amplitude.getInstance().setUserId(userId);
+    }
+
+    if (traits) {
+      const amplitudeIdentify = new window.amplitude.Identify();
+      Object.keys(traits).forEach((trait) => {
+        const shouldIncrement = this.traitsToIncrement.includes(trait);
+        const shouldSetOnce = this.traitsToSetOnce.includes(trait);
+
+        if (shouldIncrement) {
+          amplitudeIdentify.add(trait, traits[trait]);
+        }
+
+        if (shouldSetOnce) {
+          amplitudeIdentify.setOnce(trait, traits[trait]);
+        }
+
+        if (!shouldIncrement && !shouldSetOnce) {
+          amplitudeIdentify.set(trait, traits[trait]);
+        }
+      });
+      window.amplitude.identify(amplitudeIdentify);
+    }
+  }
+
+  track(htElement) {
+    logger.debug('in Amplitude track');
+    this.setDeviceId(htElement);
+
+    const { properties } = htElement.message;
+
+    // message.properties will always be present as part of track event.
+    const { products } = properties;
+
+    const clonedTrackEvent = {};
+    Object.assign(clonedTrackEvent, htElement.message);
+
+    // For track products once, we will send the products in a single call.
+    if (this.trackProductsOnce) {
+      if (products && type(products) === 'array') {
+        // track all the products in a single event.
+        const allProducts = [];
+
+        const productKeys = Object.keys(products);
+        for (let index = 0; index < productKeys.length; index += 1) {
+          let product = {};
+          product = this.getProductAttributes(products[index]);
+          allProducts.push(product);
+        }
+
+        clonedTrackEvent.properties.products = allProducts;
+
+        this.logEventAndCorrespondingRevenue(clonedTrackEvent, this.trackRevenuePerProduct); // we do not want to track revenue as a whole if trackRevenuePerProduct is enabled.
+
+        // If trackRevenuePerProduct is enabled, track revenues per product.
+        if (this.trackRevenuePerProduct) {
+          const trackEventMessage = {};
+          Object.assign(trackEventMessage, clonedTrackEvent);
+          this.trackingEventAndRevenuePerProduct(trackEventMessage, products, false); // also track revenue only and not event per product.
+        }
+      } else {
+        // track event and revenue as a whole as products array is not available.
+        this.logEventAndCorrespondingRevenue(clonedTrackEvent, false);
+      }
+      return;
+    }
+
+    if (products && type(products) === 'array') {
+      // track events iterating over product array individually.
+
+      // Log the actuall event without products array. We will subsequently track each product with 'Product Purchased' event.
+      delete clonedTrackEvent.properties.products;
+      this.logEventAndCorrespondingRevenue(clonedTrackEvent, this.trackRevenuePerProduct);
+
+      const trackEventMessage = {};
+      Object.assign(trackEventMessage, clonedTrackEvent);
+
+      // track products and revenue per product basis.
+      this.trackingEventAndRevenuePerProduct(trackEventMessage, products, true); // track both event and revenue on per product basis.
+    } else {
+      // track event and revenue as a whole as no product array is present.
+      this.logEventAndCorrespondingRevenue(clonedTrackEvent, false);
+    }
+  }
+
+  trackingEventAndRevenuePerProduct(trackEventMessage, products, shouldTrackEventPerProduct) {
+    const eventMessage = trackEventMessage;
+    let { revenueType } = eventMessage.properties;
+    const { revenue, revenue_type: revenueTtype } = eventMessage.properties;
+    revenueType = revenueType || revenueTtype;
+    products.forEach((product) => {
+      eventMessage.properties = product;
+      eventMessage.event = 'Product Purchased';
+      if (this.trackRevenuePerProduct) {
+        if (revenueType) {
+          eventMessage.properties.revenueType = revenueType;
+        }
+        if (revenue) {
+          eventMessage.properties.revenue = revenue;
+        }
+        this.trackRevenue(eventMessage);
+      }
+      if (shouldTrackEventPerProduct) {
+        this.logEventAndCorrespondingRevenue(eventMessage, true);
+      }
+    });
+  }
+
+  // Always to be called for general and top level events (and not product level)
+  // For these events we expect top level revenue property.
+  logEventAndCorrespondingRevenue(rudderMessage, dontTrackRevenue) {
+    const { properties, event } = rudderMessage;
+
+    window.amplitude.getInstance().logEvent(event, properties);
+    if (properties.revenue && !dontTrackRevenue) {
+      this.trackRevenue(rudderMessage);
+    }
+  }
+
+  /**
+   * track page events base on destination settings. If more than one settings is enabled, multiple events may be logged for a single page event.
+   * For example, if category of a page is present, and both trackAllPages and trackCategorizedPages are enabled, then 2 events will be tracked for
+   * a single pageview - 'Loaded a page' and `Viewed page ${category}`.
+   *
+   * @memberof Amplitude
+   */
+  page(htElement) {
+    logger.debug('in Amplitude page');
+    this.setDeviceId(htElement);
+
+    const { properties, name, category, integrations } = htElement.message;
+    const useNewPageEventNameFormat = integrations?.AM?.useNewPageEventNameFormat || false;
+    // all pages
+    if (this.trackAllPages) {
+      const event = 'Loaded a page';
+      window.amplitude.getInstance().logEvent(event, properties);
+    }
+
+    // categorized pages
+    if (category && this.trackCategorizedPages) {
+      let event;
+      if (!useNewPageEventNameFormat) event = `Viewed page ${category}`;
+      else event = `Viewed ${category} Page`;
+      window.amplitude.getInstance().logEvent(event, properties);
+    }
+
+    // named pages
+    if (name && this.trackNamedPages) {
+      let event;
+      if (!useNewPageEventNameFormat) event = `Viewed page ${name}`;
+      else event = `Viewed ${name} Page`;
+      window.amplitude.getInstance().logEvent(event, properties);
+    }
+  }
+
+  group(htElement) {
+    logger.debug('in Amplitude group');
+
+    this.setDeviceId(htElement);
+
+    const { groupId, traits } = htElement.message;
+
+    const { groupTypeTrait } = this;
+    const { groupValueTrait } = this;
+    let groupType;
+    let groupValue;
+
+    if (groupTypeTrait && groupValueTrait && traits) {
+      groupType = traits[groupTypeTrait];
+      groupValue = traits[groupValueTrait];
+    }
+
+    if (groupType && groupValue) {
+      window.amplitude.getInstance().setGroup(groupTypeTrait, groupValueTrait);
+    } else if (groupId) {
+      // Similar as segment but not sure whether we need it as our cloud mode supports only the above if block
+      window.amplitude.getInstance().setGroup('[Rudderstack] Group', groupId);
+    }
+
+    // https://developers.amplitude.com/docs/setting-user-properties#setting-group-properties
+    // no other api for setting group properties for javascript
+  }
+
+  setDeviceId(htElement) {
+    const { anonymousId } = htElement.message;
+    if (this.preferAnonymousIdForDeviceId && anonymousId) {
+      window.amplitude.getInstance().setDeviceId(anonymousId);
+    }
+  }
+
+  /**
+   * Tracks revenue with logRevenueV2() api based on revenue/price present in event payload. If neither of revenue/price present, it returns.
+   * The event payload may contain ruddermessage of an original track event payload (from trackEvent method) or it is derived from a product
+   * array (from trackingRevenuePerProduct) in an e-comm event.
+   *
+   * @param {*} rudderMessage
+   * @returns
+   * @memberof Amplitude
+   */
+  trackRevenue(rudderMessage) {
+    const mapRevenueType = {
+      'order completed': 'Purchase',
+      'completed order': 'Purchase',
+      'product purchased': 'Purchase',
+    };
+
+    const { properties, event } = rudderMessage;
+    let { price, productId, quantity } = properties;
+    const { revenue, product_id: pId, revenue_type: revenueTtype } = properties;
+    const revenueType =
+      properties.revenueType || revenueTtype || mapRevenueType[event.toLowerCase()];
+
+    productId = productId || pId;
+
+    // If neither revenue nor price is present, then return
+    // else send price and quantity from properties to amplitude
+    // If price not present set price as revenue's value and force quantity to be 1.
+    // Ultimately set quantity to 1 if not already present from above logic.
+    if (!revenue && !price) {
+      logger.warn('Neither "revenue" nor "price" is available. Hence, not logging revenue');
+      return;
+    }
+
+    if (!price) {
+      price = revenue;
+      quantity = 1;
+    }
+    if (!quantity) {
+      quantity = 1;
+    }
+    const amplitudeRevenue = new window.amplitude.Revenue()
+      .setPrice(price)
+      .setQuantity(quantity)
+      .setEventProperties(properties);
+    if (revenueType) {
+      amplitudeRevenue.setRevenueType(revenueType);
+    }
+
+    if (productId) {
+      amplitudeRevenue.setProductId(productId);
+    }
+    if (amplitudeRevenue._properties) {
+      delete amplitudeRevenue._properties.price;
+      delete amplitudeRevenue._properties.productId;
+      delete amplitudeRevenue._properties.quantity;
+    }
+    window.amplitude.getInstance().logRevenueV2(amplitudeRevenue);
+  }
+
+  getProductAttributes(product) {
+    return {
+      productId: product.productId || product.product_id,
+      sku: product.sku,
+      name: product.name,
+      price: product.price,
+      quantity: product.quantity,
+      category: product.category,
+    };
+  }
+}
+
+export default Amplitude;

package/src/integrations/Amplitude/constants.js

@@ -0,0 +1,9 @@
+const NAME = 'AM';
+const CNameMapping = {
+  [NAME]: NAME,
+  AMPLITUDE: NAME,
+  Amplitude: NAME,
+  am: NAME,
+};
+
+export { NAME, CNameMapping };

package/src/integrations/Amplitude/index.js

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

package/src/integrations/Amplitude/nativeSdkLoader.js

@@ -0,0 +1,112 @@
+import { LOAD_ORIGIN } from '../../utils/ScriptLoader';
+
+function loadNativeSdk(e, t) {
+  var n = e.amplitude || { _q: [], _iq: {} };
+  var r = t.createElement('script');
+  r.type = 'text/javascript';
+  r.integrity = 'sha384-5fhzC8Xw3m+x5cBag4AMKRdf900vw3AoaLty2vYfcKIX1iEsYRHZF4RLXIsu2o+F';
+  r.crossOrigin = 'anonymous';
+  r.async = true;
+  r.setAttribute('data-loader', LOAD_ORIGIN);
+  r.src = 'https://cdn.amplitude.com/libs/amplitude-8.21.4-min.gz.js';
+  r.onload = function () {
+    if (!e.amplitude.runQueuedFunctions) {
+      console.log('[Amplitude] Error: could not load SDK');
+    }
+  };
+  var s = t.getElementsByTagName('script')[0];
+  s.parentNode.insertBefore(r, s);
+  function i(e, t) {
+    e.prototype[t] = function () {
+      this._q.push([t].concat(Array.prototype.slice.call(arguments, 0)));
+      return this;
+    };
+  }
+  var o = function () {
+    this._q = [];
+    return this;
+  };
+  var a = [
+    'add',
+    'append',
+    'clearAll',
+    'prepend',
+    'set',
+    'setOnce',
+    'unset',
+    'preInsert',
+    'postInsert',
+    'remove',
+  ];
+  for (var c = 0; c < a.length; c++) {
+    i(o, a[c]);
+  }
+  n.Identify = o;
+  var l = function () {
+    this._q = [];
+    return this;
+  };
+  var u = ['setProductId', 'setQuantity', 'setPrice', 'setRevenueType', 'setEventProperties'];
+  for (var p = 0; p < u.length; p++) {
+    i(l, u[p]);
+  }
+  n.Revenue = l;
+  var d = [
+    'init',
+    'logEvent',
+    'logRevenue',
+    'setUserId',
+    'setUserProperties',
+    'setOptOut',
+    'setVersionName',
+    'setDomain',
+    'setDeviceId',
+    'enableTracking',
+    'setGlobalUserProperties',
+    'identify',
+    'clearUserProperties',
+    'setGroup',
+    'logRevenueV2',
+    'regenerateDeviceId',
+    'groupIdentify',
+    'onInit',
+    'onNewSessionStart',
+    'logEventWithTimestamp',
+    'logEventWithGroups',
+    'setSessionId',
+    'resetSessionId',
+    'getDeviceId',
+    'getUserId',
+    'setMinTimeBetweenSessionsMillis',
+    'setEventUploadThreshold',
+    'setUseDynamicConfig',
+    'setServerZone',
+    'setServerUrl',
+    'sendEvents',
+    'setLibrary',
+    'setTransport',
+  ];
+  function v(t) {
+    function e(e) {
+      t[e] = function () {
+        t._q.push([e].concat(Array.prototype.slice.call(arguments, 0)));
+      };
+    }
+    for (var n = 0; n < d.length; n++) {
+      e(d[n]);
+    }
+  }
+  v(n);
+  n.getInstance = function (e) {
+    e = (!e || e.length === 0 ? '$default_instance' : e).toLowerCase();
+    if (!Object.prototype.hasOwnProperty.call(n._iq, e)) {
+      n._iq[e] = { _q: [] };
+      v(n._iq[e]);
+    }
+    return n._iq[e];
+  };
+  e.amplitude = n;
+}
+window, document;
+
+export { loadNativeSdk };