iureiure 1.0.0

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

@@ -0,0 +1,107 @@
+import { getHashFromArray, isDefinedAndNotNullAndNotEmpty } from '../../utils/commonUtils';
+
+// default mapping for the events
+const standardEventsListMapping = {
+  cfReady: 'CTA Ready',
+  cfView: 'CTA Viewed',
+  cfConversion: 'CTA Converted',
+  cfCompletion: 'CTA Completed',
+  cfSubmit: 'CTA Form Submitted',
+  cfAddToCart: 'Product Added to Cart',
+  cfClose: 'CTA Closed',
+};
+
+const swapKeyValuePairs = standardEventsMap => {
+  const swappedEventsMap = {};
+  Object.keys(standardEventsMap).forEach(key => {
+    swappedEventsMap[standardEventsMap[key]] = key;
+  });
+  return swappedEventsMap;
+};
+
+/**
+ * This function is used to populate properties to be sent in track call using the event data
+ * @param {*} data - data here, contains all the details about the event.
+ * eg. For event CTA Viewed
+ * data: {
+ * cta_name: {cta.name}
+ * cta_type: {cta.cta_type}
+ * }
+ */
+const populatingProperties = data => {
+  const rudderProperties = {};
+  if (data.cta) {
+    const { cta } = data;
+    rudderProperties.cta_name = cta.name;
+    rudderProperties.cta_type = cta.cta_type;
+    rudderProperties.cta_id = cta.id;
+  }
+  if (data.variant) {
+    rudderProperties.cta_variant = data.variant;
+  }
+  if (data.step) {
+    rudderProperties.cta_step = data.step;
+  }
+  return rudderProperties;
+};
+
+/**
+ * This function is used to trigger a callback.
+ * @param {*} standardEventsMap mapping of events done by the user
+ * @param {*} eventName standard event name
+ * @param {*} data data here, contains all the details about the event.
+ * @param {*} analytics rudderanalytics object
+ * eg. For event CTA Viewed
+ * data: {
+ * cta_name: {cta.name}
+ * cta_type: {cta.cta_type}
+ * }
+ */
+const makeACall = (standardEventsMap, eventName, data, analytics) => {
+  // Updating the event name with any mapping from the webapp if available else
+  // storing default event name in the updatedEvent
+  const updatedEvent = standardEventsMap[eventName]
+    ? standardEventsMap[eventName]
+    : standardEventsListMapping[eventName];
+
+  // Populating Properties
+  let properties = {};
+  if (data) {
+    properties = populatingProperties(data);
+  }
+  if (isDefinedAndNotNullAndNotEmpty(properties)) {
+    analytics.track(updatedEvent, properties);
+  } else {
+    analytics.track(updatedEvent);
+  }
+};
+
+/**
+ * This function has event listeners for the occurring events and to make a call for the event after
+ * collecting the data.
+ * @param {*} userDefinedEventsMapping Mapping of events in the webapp by the user
+ * @param {*} userDefinedEventsList List of requested events by the user.
+ * @param {*} analytics rudderanalytics object
+ */
+const trigger = (userDefinedEventsMapping, userDefinedEventsList, analytics) => {
+  let standardEventsMap = getHashFromArray(userDefinedEventsMapping);
+  standardEventsMap = swapKeyValuePairs(standardEventsMap);
+  const standardEventsList = [
+    'cfReady',
+    'cfView',
+    'cfConversion',
+    'cfCompletion',
+    'cfSubmit',
+    'cfAddToCart',
+    'cfClose',
+  ];
+  standardEventsList.forEach(events => {
+    if (userDefinedEventsList.includes(events)) {
+      window.addEventListener(events, event => {
+        makeACall(standardEventsMap, event.type, event.detail, analytics);
+      });
+    }
+  });
+};
+
+export { makeACall, trigger };

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

@@ -0,0 +1,144 @@
+/* eslint-disable no-unused-expressions */
+/* eslint-disable class-methods-use-this */
+import { ScriptLoader } from '@rudderstack/analytics-js-common/v1.1/utils/ScriptLoader';
+import {
+  NAME,
+  DISPLAY_NAME,
+  supportedEvents,
+} from '@rudderstack/analytics-js-common/constants/integrations/Criteo/constants';
+import Logger from '../../utils/logger';
+import {
+  getDeviceType,
+  handleListView,
+  handlingEventDuo,
+  handleProductView,
+  generateExtraData,
+  handleCommonFields,
+} from './utils';
+import { getHashFromArrayWithDuplicate } from '../../utils/commonUtils';
+
+const logger = new Logger(DISPLAY_NAME);
+
+class Criteo {
+  constructor(config, analytics, destinationInfo) {
+    if (analytics.logLevel) {
+      logger.setLogLevel(analytics.logLevel);
+    }
+    this.analytics = analytics;
+    this.name = NAME;
+    this.hashMethod = config.hashMethod;
+    this.accountId = config.accountId;
+    this.url = config.homePageUrl;
+    this.deviceType = getDeviceType(navigator.userAgent);
+    this.fieldMapping = config.fieldMapping;
+    this.eventsToStandard = config.eventsToStandard;
+    this.OPERATOR_LIST = ['eq', 'gt', 'lt', 'ge', 'le', 'in'];
+    ({
+      shouldApplyDeviceModeTransformation: this.shouldApplyDeviceModeTransformation,
+      propagateEventsUntransformedOnError: this.propagateEventsUntransformedOnError,
+      destinationId: this.destinationId,
+    } = destinationInfo ?? {});
+  }
+
+  init() {
+    if (!this.accountId) {
+      logger.error('Account Id is required');
+      return;
+    }
+    window.criteo_q = window.criteo_q || [];
+
+    ScriptLoader('Criteo', `//dynamic.criteo.com/js/ld/ld.js?a=${this.accountId}`);
+    window.criteo_q.push({ event: 'setAccount', account: this.accountId });
+    window.criteo_q.push({ event: 'setSiteType', type: this.deviceType });
+  }
+
+  isLoaded() {
+    return !!(window.criteo_q && window.criteo_q.push !== Array.prototype.push);
+  }
+
+  isReady() {
+    return this.isLoaded();
+  }
+
+  page(rudderElement) {
+    const { name, properties } = rudderElement.message;
+
+    const finalPayload = handleCommonFields(rudderElement, this.hashMethod);
+
+    if (
+      name === 'home' ||
+      (properties && properties.name === 'home') ||
+      (this.url && this.url === window.location.href) ||
+      (properties && properties.url === this.url)
+    ) {
+      const homeEvent = {
+        event: 'viewHome',
+      };
+      finalPayload.push(homeEvent);
+    } else {
+      logger.error('Home page is not detected');
+      return;
+    }
+
+    const extraDataObject = generateExtraData(rudderElement, this.fieldMapping);
+    if (Object.keys(extraDataObject).length > 0) {
+      finalPayload.push({ event: 'setData', ...extraDataObject });
+    }
+
+    window.criteo_q.push(finalPayload);
+  }
+
+  track(rudderElement) {
+    const { event, properties } = rudderElement.message;
+
+    const finalPayload = handleCommonFields(rudderElement, this.hashMethod);
+
+    if (!event) {
+      logger.error('Event name from track call is missing');
+      return;
+    }
+
+    if (!properties || Object.keys(properties).length === 0) {
+      logger.error('Either properties object is missing or empty in the track call');
+      return;
+    }
+
+    const eventMapping = getHashFromArrayWithDuplicate(this.eventsToStandard);
+    const trimmedEvent = event.toLowerCase().trim();
+
+    if (!supportedEvents.includes(trimmedEvent) && !eventMapping[trimmedEvent]) {
+      logger.error(`event ${trimmedEvent} is not supported`);
+      return;
+    }
+    let events = [];
+    if (supportedEvents.includes(trimmedEvent)) {
+      events.push(trimmedEvent);
+    } else {
+      events = eventMapping[trimmedEvent];
+    }
+
+    events.forEach(eventType => {
+      switch (eventType) {
+        case 'product viewed':
+          handleProductView(rudderElement.message, finalPayload);
+          break;
+        case 'cart viewed':
+        case 'order completed':
+          handlingEventDuo(rudderElement.message, finalPayload);
+          break;
+        case 'product list viewed':
+          handleListView(rudderElement.message, finalPayload, this.OPERATOR_LIST);
+          break;
+        default:
+          break;
+      }
+    });
+
+    const extraDataObject = generateExtraData(rudderElement, this.fieldMapping);
+    if (Object.keys(extraDataObject).length > 0) {
+      finalPayload.push({ event: 'setData', ...extraDataObject });
+    }
+    window.criteo_q.push(finalPayload);
+  }
+}
+export default Criteo;

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

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

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

@@ -0,0 +1,346 @@
+import md5 from 'md5';
+import { DISPLAY_NAME } from '@rudderstack/analytics-js-common/constants/integrations/Criteo/constants';
+import Logger from '../../utils/logger';
+import { getHashFromArray, isDefinedAndNotNull } from '../../utils/commonUtils';
+
+const logger = new Logger(DISPLAY_NAME);
+
+/**
+ * Ref : https://help.criteo.com/kb/guide/en/all-criteo-onetag-events-and-parameters-vZbzbEeY86/Steps/775825,868657,868659
+ * Ref : https://help.criteo.com/kb/guide/en/all-criteo-onetag-events-and-parameters-vZbzbEeY86/Steps/775825
+ * @param {*} rudderElement
+ * @param {*} hashMethod
+ * @returns
+ */
+const handleCommonFields = (rudderElement, hashMethod) => {
+  const { message } = rudderElement;
+  const { properties, userId, anonymousId } = message;
+
+  const setEmail = {};
+  const setZipcode = {};
+
+  const finalRequest = [
+    { event: 'setCustomerId', id: md5(userId).toString() },
+    { event: 'setRetailerVisitorId', id: md5(anonymousId).toString() },
+  ];
+
+  if (properties?.email) {
+    const email = properties.email.trim().toLowerCase();
+    setEmail.event = 'setEmail';
+    setEmail.hash_method = hashMethod;
+    setEmail.email = hashMethod === 'md5' ? md5(email) : email;
+    finalRequest.push(setEmail);
+  }
+
+  if (properties?.zipCode) {
+    setZipcode.event = 'setZipcode';
+    setZipcode.zipCode = properties.zipCode || properties.zip;
+    finalRequest.push(setZipcode);
+  }
+
+  return finalRequest;
+};
+const generateExtraData = (rudderElement, fieldMapping) => {
+  const { message } = rudderElement;
+  const extraData = {};
+  const fieldMapHashmap = getHashFromArray(fieldMapping, 'from', 'to', false);
+
+  Object.keys(fieldMapHashmap).forEach(field => {
+    if (isDefinedAndNotNull(message.properties[field])) {
+      extraData[fieldMapHashmap[field]] = message.properties[field];
+    }
+  });
+  return extraData;
+};
+
+const handleProductView = (message, finalPayload) => {
+  const { properties } = message;
+  if (properties.product_id) {
+    const viewItemObject = {
+      event: 'viewItem',
+      item: String(properties.product_id),
+    };
+
+    if (properties.price && !Number.isNaN(parseFloat(properties.price))) {
+      viewItemObject.price = parseFloat(properties.price);
+    }
+
+    if (
+      properties.availability &&
+      (properties.availability === 1 || properties.availability === 0)
+    ) {
+      viewItemObject.availability = properties.availability;
+    }
+    finalPayload.push(viewItemObject);
+  } else {
+    logger.error('product_id is a mandatory field to use for Product Tag');
+  }
+
+  // Final example payload supported by destination
+  // window.criteo_q.push(
+  //   { event: "setAccount", account: YOUR_PARTNER_ID},
+  //   {
+  //     event: "setEmail",
+  //     email: "##Email Address##",
+  //     hash_method: "##Hash Method##",
+  //   },
+  //   { event: "setSiteType", type: deviceType},
+  //   { event: "setCustomerId", id: "##Customer Id##" },
+  //   { event: "setRetailerVisitorId", id: "##Visitor Id##"},
+  //   { event: "setZipcode", zipcode: "##Zip Code##" },
+  //   {
+  //     event: "viewItem",
+  //     item: "##Product ID##",
+  //     price: "##price##",
+  //     availability: "##Availability##",
+  //   }
+  // );
+};
+
+/**
+ * Validates product properties
+ * @param {*} product
+ * @param {*} index
+ * @returns
+ */
+const validateProduct = (product, index) => {
+  if (product.product_id && product.price && product.quantity) {
+    const elementaryProduct = {
+      id: String(product.product_id),
+      price: parseFloat(product.price),
+      quantity: parseInt(product.quantity, 10),
+    };
+    return !Number.isNaN(elementaryProduct.price) && !Number.isNaN(elementaryProduct.quantity);
+  }
+  logger.info(`product at index ${index} is skipped for insufficient information`);
+  return false;
+};
+
+/**
+ * Returns transformed products array
+ * @param {*} properties
+ * @returns
+ */
+const getProductInfo = properties => {
+  const productInfo = [];
+
+  if (properties?.products && properties.products.length > 0) {
+    properties.products.forEach((product, index) => {
+      if (validateProduct(product, index)) {
+        productInfo.push({
+          id: String(product.product_id),
+          price: parseFloat(product.price),
+          quantity: parseInt(product.quantity, 10),
+        });
+      }
+    });
+  } else {
+    logger.error('Payload should consist of at least one product information');
+  }
+
+  return productInfo;
+};
+
+/**
+ * Adds order completed event to finalPayload
+ * @param {*} properties
+ * @param {*} finalPayload
+ * @param {*} productInfo
+ * @returns
+ */
+const processCompletedOrderEvent = (properties, finalPayload, productInfo) => {
+  const trackTransactionObject = {
+    event: 'trackTransaction',
+    id: String(properties.order_id),
+    item: productInfo,
+  };
+
+  if (!trackTransactionObject.id) {
+    logger.error('order_id (Transaction Id) is a mandatory field');
+    return;
+  }
+
+  if (properties.new_customer === 1 || properties.new_customer === 0) {
+    trackTransactionObject.new_customer = properties.new_customer;
+  }
+
+  if (properties.deduplication === 1 || properties.deduplication === 0) {
+    trackTransactionObject.deduplication = properties.deduplication;
+  }
+
+  finalPayload.push(trackTransactionObject);
+};
+
+/**
+ * Adds view cart event to finalPayload
+ * @param {*} properties
+ * @param {*} finalPayload
+ * @param {*} productInfo
+ */
+const processViewedCartEvent = (finalPayload, productInfo) => {
+  const viewBasketObject = {
+    event: 'viewBasket',
+    item: productInfo,
+  };
+  finalPayload.push(viewBasketObject);
+};
+
+/**
+ * Handles events
+ * @param {*} message
+ * @param {*} finalPayload
+ * @returns
+ */
+const handlingEventDuo = (message, finalPayload) => {
+  const { event, properties } = message;
+  const eventType = event.toLowerCase().trim();
+  const productInfo = getProductInfo(properties);
+
+  if (productInfo.length === 0) {
+    logger.error(
+      'None of the products had sufficient information or information is wrongly formatted',
+    );
+    return;
+  }
+
+  if (eventType === 'cart viewed') {
+    processViewedCartEvent(finalPayload, productInfo);
+    // final example payload supported by the destination
+    // window.criteo_q.push(
+    //   { event: "setAccount", account: YOUR_PARTNER_ID},
+    //   {
+    //     event: "setEmail",
+    //     email: "##Email Address##",
+    //     hash_method: "##Hash Method##",
+    //   },
+    //   { event: "setSiteType", type: deviceType},
+    //   { event: "setCustomerId", id: "##Customer Id##" },
+    //   { event: "setRetailerVisitorId", id: "##Visitor Id##"},
+    //   { event: "setZipcode", zipcode: "##Zip Code##" },
+    //   {
+    //     event: "viewBasket",
+    //     item: [
+    //       {
+    //         id: "##Product Id##",
+    //         price: "##Price##",
+    //         quantity: "##Quantity##",
+    //       },
+    //       // add a line for each additional line in the basket
+    //     ],
+    //   }
+    // );
+  }
+
+  if (eventType === 'order completed') {
+    processCompletedOrderEvent(properties, finalPayload, productInfo);
+    // final example payload supported by destination
+    //   window.criteo_q.push(
+    //     { event: "setAccount", account: YOUR_PARTNER_ID},
+    //     { event: "setEmail", email: "##Email Address##", hash_method: "##Hash Method##" },
+    //     { event: "setSiteType", type: deviceType},
+    //     { event: "setCustomerId", id: "##Customer Id##" },
+    //     { event: "setRetailerVisitorId", id: "##Visitor Id##"},
+    //     { event: "setZipcode", zipcode: "##Zip Code##" },
+    //     { event: "trackTransaction",
+    //       id: "##Transaction ID##",
+    //       new_customer: ##New Customer##,
+    //       deduplication: ##Deduplication##,
+    //       item: [
+    //        {id: "##Product Id##", price: "##Price##", quantity: "##Quantity##" }
+    //        //add a line for each additional line in the basket
+    //      ]}
+    //   );
+
+    // }
+  }
+};
+
+/**
+ * Returns filterArray
+ * @param {*} properties
+ * @param {*} OPERATOR_LIST
+ * @returns
+ */
+const getFilterArray = (properties, OPERATOR_LIST) => {
+  const filterArray = [];
+  const FILTER_FIELDS = ['name', 'value'];
+  if (properties.filters) {
+    properties.filters.forEach(filter => {
+      const filterObject = {};
+      Object.keys(filter).forEach(key => {
+        if (
+          FILTER_FIELDS.includes(key) ||
+          (key === 'operator' && OPERATOR_LIST.includes(filter.operator))
+        ) {
+          filterObject[key] = filter[key];
+        }
+      });
+      filterArray.push(filterObject);
+    });
+  }
+
+  return filterArray;
+};
+
+const handleListView = (message, finalPayload, OPERATOR_LIST) => {
+  const { properties } = message;
+  const productIdList = [];
+  const viewListObj = {};
+
+  if (properties.products && properties.products.length > 0) {
+    properties.products.forEach(product => {
+      if (product.product_id) {
+        productIdList.push(String(product.product_id));
+      }
+    });
+    if (productIdList.length === 0) {
+      logger.error('None of the product information had product_id');
+      return;
+    }
+  } else {
+    logger.error('The payload should consist of at least one product information');
+    return;
+  }
+
+  viewListObj.event = 'viewList';
+  viewListObj.item = productIdList;
+  viewListObj.category = String(properties.category);
+  viewListObj.keywords = String(properties.keywords);
+  if (properties.page_number && !Number.isNaN(parseInt(properties.page_number, 10))) {
+    viewListObj.page_number = parseInt(properties.page_number, 10);
+  }
+
+  const filterArray = getFilterArray(properties, OPERATOR_LIST);
+  if (filterArray.length > 0) {
+    viewListObj.filters = filterArray;
+  }
+  finalPayload.push(viewListObj);
+};
+
+/**
+ * Returns device type
+ * @param {*} userAgent
+ * @returns
+ */
+const getDeviceType = userAgent => {
+  let deviceType;
+
+  if (/iPad/.test(userAgent)) {
+    deviceType = 't';
+  } else if (/Mobile|iP(hone|od)|Android|BlackBerry|IEMobile|Silk/.test(userAgent)) {
+    deviceType = 'm';
+  } else {
+    deviceType = 'd';
+  }
+
+  return deviceType;
+};
+
+export {
+  getDeviceType,
+  handleListView,
+  handlingEventDuo,
+  handleProductView,
+  generateExtraData,
+  handleCommonFields,
+};

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

@@ -0,0 +1,85 @@
+/* eslint-disable no-underscore-dangle */
+/* eslint-disable class-methods-use-this */
+import {
+  NAME,
+  DISPLAY_NAME,
+} from '@rudderstack/analytics-js-common/constants/integrations/CustomerIO/constants';
+import Logger from '../../utils/logger';
+import { loadNativeSdk } from './nativeSdkLoader';
+
+const logger = new Logger(DISPLAY_NAME);
+
+class CustomerIO {
+  constructor(config, analytics, destinationInfo) {
+    if (analytics.logLevel) {
+      logger.setLogLevel(analytics.logLevel);
+    }
+    const {
+      dataUseInApp = false,
+      siteID,
+      apiKey,
+      datacenterEU,
+      datacenter,
+      sendPageNameInSDK,
+    } = config;
+
+    this.analytics = analytics;
+    this.siteID = siteID;
+    this.apiKey = apiKey;
+    this.datacenterEU = datacenterEU;
+    this.datacenter = datacenter;
+    this.sendPageNameInSDK = sendPageNameInSDK;
+    this.dataUseInApp = dataUseInApp;
+    this.name = NAME;
+    ({
+      shouldApplyDeviceModeTransformation: this.shouldApplyDeviceModeTransformation,
+      propagateEventsUntransformedOnError: this.propagateEventsUntransformedOnError,
+      destinationId: this.destinationId,
+    } = destinationInfo ?? {});
+  }
+
+  init() {
+    const { siteID, datacenter, datacenterEU } = this;
+    loadNativeSdk(siteID, datacenter, datacenterEU);
+  }
+
+  isLoaded() {
+    return !!(window._cio && window._cio.push !== Array.prototype.push);
+  }
+
+  isReady() {
+    return this.isLoaded();
+  }
+
+  identify(rudderElement) {
+    const { userId, context } = rudderElement.message;
+    const { traits } = context || {};
+    if (!userId) {
+      logger.error('userId is required for Identify call');
+      return;
+    }
+    const createAt = traits.createdAt;
+    if (createAt) {
+      traits.created_at = Math.floor(new Date(createAt).getTime() / 1000);
+    }
+    traits.id = userId;
+    window._cio.identify(traits);
+  }
+
+  track(rudderElement) {
+    const eventName = rudderElement.message.event;
+    const { properties } = rudderElement.message;
+    window._cio.track(eventName, properties);
+  }
+
+  page(rudderElement) {
+    if (this.sendPageNameInSDK === false) {
+      window._cio.page(rudderElement.message.properties);
+    } else {
+      const name = rudderElement.message.name || rudderElement.message.properties.url;
+      window._cio.page(name, rudderElement.message.properties);
+    }
+  }
+}
+
+export default CustomerIO;

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

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