iureiure 1.0.0

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

@@ -0,0 +1,140 @@
+import { DISPLAY_NAME } from '@rudderstack/analytics-js-common/constants/integrations/YandexMetrica/constants';
+import Logger from '../../utils/logger';
+import {
+  removeUndefinedAndNullValues,
+  removeUndefinedAndNullAndEmptyValues,
+} from '../../utils/commonUtils';
+
+const logger = new Logger(DISPLAY_NAME);
+
+// This function is used for sending the track event to yandex.metrica
+const sendEvent = (container, payload) => {
+  window[container].push(payload);
+};
+
+// This object is defined to map the default rudder event to yandex.metrica event
+const ecommerceEventMapping = {
+  order_completed: 'purchase',
+  product_viewed: 'detail',
+  product_list_viewed: 'detail',
+  product_added: 'add',
+  product_removed: 'remove',
+};
+
+// This function is used to map the product properties
+const itemProperties = properties => {
+  const productProperties = {
+    id: properties.product_id || properties.sku,
+    name: properties.name,
+    brand: properties.brand,
+    category: properties.category,
+    coupon: properties.coupon,
+    position: properties.position,
+    price: parseFloat(properties.price),
+    quantity: parseInt(properties.price, 10),
+    variant: properties.variant,
+  };
+  return removeUndefinedAndNullValues(productProperties);
+};
+
+/**
+ *This function is used to populate the payload with ecommerce object with each product's properties
+ * @param {*} eventType
+ * @param {*} properties
+ * @param {*} products
+ * @returns
+ */
+
+const populatePayload = (eventType, properties, products) => {
+  const payload = {};
+  products.push(itemProperties(properties));
+  payload.ecommerce = {
+    ...payload.ecommerce,
+    currencyCode: properties.currency,
+    [eventType]: { products },
+  };
+  return payload;
+};
+
+/**
+ * Returns actionField
+ * @param {*} properties
+ * @param {*} goalId
+ * @returns
+ */
+const getActionField = (properties, goalId) => {
+  const { order_id: orderId, coupon, revenue } = properties;
+  const actionField = {
+    id: orderId,
+    coupon,
+    goal_id: goalId,
+    revenue,
+  };
+
+  // converting the goal_id and revenue in actionField to int and float type
+  actionField.goal_id = actionField.goal_id
+    ? parseInt(actionField.goal_id, 10)
+    : actionField.goal_id;
+  actionField.revenue = actionField.revenue ? parseFloat(actionField.revenue) : actionField.revenue;
+
+  return actionField;
+};
+
+/**
+ * Returns response payload
+ * @param {*} properties
+ * @param {*} eventType
+ * @returns
+ */
+const getResponsePayload = (properties, eventType) => {
+  let responsePayload = {};
+  const productsArray = [];
+  const { products, product_id: productId, name } = properties;
+
+  /**
+   * checking for products array if available each of the product inside is used
+   * populate the final payload else the product information inside the properties is used
+   */
+  if (products && Array.isArray(products)) {
+    products.forEach((element, index) => {
+      if (!(element.product_id || element.name)) {
+        logger.error(`None of product_id or name is present for product at index ${index}`);
+      } else {
+        responsePayload = populatePayload(eventType, element, productsArray);
+      }
+    });
+  } else if (!(productId || name)) {
+    logger.error('None of product_id or name is present for the product');
+  } else {
+    responsePayload = populatePayload(eventType, properties, productsArray);
+  }
+
+  return responsePayload;
+};
+
+/**
+ * This function is used to prepare and return the final payload to be sent
+ * @param {*} eventType - This is the e-commerce event type of yandex.metrica
+ * @param {*} properties - Properties passed in the track call
+ * @param {*} goalId - goalId taken from UI
+ * @returns the responsePayload to be sent to yandex.metrica
+ */
+const ecommEventPayload = (eventType, properties, goalId) => {
+  const { order_id: orderId } = properties;
+
+  const responsePayload = getResponsePayload(properties, eventType);
+
+  // populating actionField object required for purchase event type
+  if (eventType === 'purchase') {
+    if (!orderId) {
+      logger.error('order_id is required for event type purchase');
+    }
+    responsePayload.ecommerce[eventType].actionField = removeUndefinedAndNullAndEmptyValues(
+      getActionField(properties, goalId),
+    );
+  }
+
+  return removeUndefinedAndNullValues(responsePayload);
+};
+
+export { sendEvent, ecommEventPayload, ecommerceEventMapping };

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

@@ -0,0 +1,163 @@
+import * as AdobeAnalytics from './AdobeAnalytics';
+import * as Amplitude from './Amplitude';
+import * as Appcues from './Appcues';
+import * as BingAds from './BingAds';
+import * as Braze from './Braze';
+import * as Bugsnag from './Bugsnag';
+import * as Chartbeat from './Chartbeat';
+import * as Clevertap from './Clevertap';
+import * as Comscore from './Comscore';
+import * as Criteo from './Criteo';
+import * as CustomerIO from './CustomerIO';
+import * as Drip from './Drip';
+import * as FBPixel from './FacebookPixel';
+import * as Fullstory from './Fullstory';
+import * as GA from './GA';
+import * as GA4 from './GA4';
+import * as GoogleAds from './GoogleAds';
+import * as GoogleTagManager from './GoogleTagManager';
+import * as Heap from './Heap';
+import * as Hotjar from './Hotjar';
+import * as HubSpot from './HubSpot';
+import * as INTERCOM from './INTERCOM';
+import * as Keen from './Keen';
+import * as Kissmetrics from './Kissmetrics';
+import * as Klaviyo from './Klaviyo';
+import * as LinkedInInsightTag from './LinkedInInsightTag';
+import * as Lotame from './Lotame';
+import * as Lytics from './Lytics';
+import * as Mixpanel from './Mixpanel';
+import * as MoEngage from './MoEngage';
+import * as Optimizely from './Optimizely';
+import * as Pendo from './Pendo';
+import * as PinterestTag from './PinterestTag';
+import * as QuantumMetric from './QuantumMetric';
+import * as Posthog from './Posthog';
+import * as ProfitWell from './ProfitWell';
+import * as Qualtrics from './Qualtrics';
+import * as RedditPixel from './RedditPixel';
+import * as Sentry from './Sentry';
+import * as SnapPixel from './SnapPixel';
+import * as TVSquared from './TVSquared';
+import * as VWO from './VWO';
+import * as GoogleOptimize from './GoogleOptimize';
+import * as PostAffiliatePro from './PostAffiliatePro';
+import * as LaunchDarkly from './LaunchDarkly';
+import * as GA360 from './GA360';
+import * as DCMFloodlight from './DCMFloodlight';
+import * as Adroll from './Adroll';
+import * as Vero from './Vero';
+import * as Matomo from './Matomo';
+import * as Rockerbox from './Rockerbox';
+import * as Mouseflow from './Mouseflow';
+import * as ConvertFlow from './ConvertFlow';
+import * as SnapEngage from './SnapEngage';
+import * as LiveChat from './LiveChat';
+import * as Shynet from './Shynet';
+import * as Woopra from './Woopra';
+import * as RollBar from './RollBar';
+import * as QuoraPixel from './QuoraPixel';
+import * as Iterable from './Iterable';
+import * as Engage from './Engage';
+import * as June from './June';
+import * as Refiner from './Refiner';
+import * as YandexMetrica from './YandexMetrica';
+import * as Podsights from './Podsights';
+import * as Qualaroo from './Qualaroo';
+import * as Axeptio from './Axeptio';
+import * as Satismeter from './Satismeter';
+import * as MicrosoftClarity from './MicrosoftClarity';
+import * as Sendinblue from './Sendinblue';
+import * as Olark from './Olark';
+import * as Lemnisk from './Lemnisk';
+import * as TiktokAds from './TiktokAds';
+import * as ActiveCampaign from './ActiveCampaign';
+import * as Sprig from './Sprig';
+import * as SpotifyPixel from './SpotifyPixel';
+import * as CommandBar from './CommandBar';
+import * as Ninetailed from './Ninetailed';
+// the key names should match the destination.name value to keep parity everywhere
+// (config-plan name, native destination.name , exported integration name(this one below))
+
+const integrations = {
+  ADOBE_ANALYTICS: AdobeAnalytics.default,
+  AM: Amplitude.default,
+  APPCUES: Appcues.default,
+  BINGADS: BingAds.default,
+  BRAZE: Braze.default,
+  BUGSNAG: Bugsnag.default,
+  CHARTBEAT: Chartbeat.default,
+  CLEVERTAP: Clevertap.default,
+  COMSCORE: Comscore.default,
+  CRITEO: Criteo.default,
+  COMMANDBAR: CommandBar.default,
+  CUSTOMERIO: CustomerIO.default,
+  DCM_FLOODLIGHT: DCMFloodlight.default,
+  DRIP: Drip.default,
+  FACEBOOK_PIXEL: FBPixel.default,
+  FULLSTORY: Fullstory.default,
+  GA4: GA4.default,
+  GA: GA.default,
+  GOOGLEADS: GoogleAds.default,
+  GTM: GoogleTagManager.default,
+  HEAP: Heap.default,
+  HOTJAR: Hotjar.default,
+  HS: HubSpot.default,
+  INTERCOM: INTERCOM.default,
+  KEEN: Keen.default,
+  KISSMETRICS: Kissmetrics.default,
+  KLAVIYO: Klaviyo.default,
+  LINKEDIN_INSIGHT_TAG: LinkedInInsightTag.default,
+  LOTAME: Lotame.default,
+  LYTICS: Lytics.default,
+  MOENGAGE: MoEngage.default,
+  MP: Mixpanel.default,
+  OPTIMIZELY: Optimizely.default,
+  PENDO: Pendo.default,
+  PINTEREST_TAG: PinterestTag.default,
+  QUANTUMMETRIC: QuantumMetric.default,
+  POSTHOG: Posthog.default,
+  PROFITWELL: ProfitWell.default,
+  QUALTRICS: Qualtrics.default,
+  REDDIT_PIXEL: RedditPixel.default,
+  SENTRY: Sentry.default,
+  SNAP_PIXEL: SnapPixel.default,
+  TVSQUARED: TVSquared.default,
+  VWO: VWO.default,
+  GOOGLE_OPTIMIZE: GoogleOptimize.default,
+  POST_AFFILIATE_PRO: PostAffiliatePro.default,
+  LAUNCHDARKLY: LaunchDarkly.default,
+  GA360: GA360.default,
+  ADROLL: Adroll.default,
+  VERO: Vero.default,
+  MATOMO: Matomo.default,
+  ROCKERBOX: Rockerbox.default,
+  MOUSEFLOW: Mouseflow.default,
+  CONVERTFLOW: ConvertFlow.default,
+  SNAPENGAGE: SnapEngage.default,
+  LIVECHAT: LiveChat.default,
+  SHYNET: Shynet.default,
+  WOOPRA: Woopra.default,
+  ROLLBAR: RollBar.default,
+  QUORA_PIXEL: QuoraPixel.default,
+  ITERABLE: Iterable.default,
+  ENGAGE: Engage.default,
+  JUNE: June.default,
+  REFINER: Refiner.default,
+  YANDEX_METRICA: YandexMetrica.default,
+  PODSIGHTS: Podsights.default,
+  QUALAROO: Qualaroo.default,
+  AXEPTIO: Axeptio.default,
+  SATISMETER: Satismeter.default,
+  MICROSOFT_CLARITY: MicrosoftClarity.default,
+  SENDINBLUE: Sendinblue.default,
+  OLARK: Olark.default,
+  LEMNISK: Lemnisk.default,
+  TIKTOK_ADS: TiktokAds.default,
+  ACTIVE_CAMPAIGN: ActiveCampaign.default,
+  SPRIG: Sprig.default,
+  SPOTIFYPIXEL: SpotifyPixel.default,
+  NINETAILED: Ninetailed.default,
+};
+
+export { integrations };

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

@@ -0,0 +1,48 @@
+// util function to convert the input to string type
+function convertToString(input) {
+  if (input) {
+    if (typeof input === 'string') {
+      return input;
+    }
+
+    return String(input);
+  }
+  return '';
+}
+
+// convert string to words
+function toWords(input) {
+  const regex =
+    /[A-Z\xC0-\xD6\xD8-\xDE]?[a-z\xDF-\xF6\xF8-\xFF]+|[A-Z\xC0-\xD6\xD8-\xDE]+(?![a-z\xDF-\xF6\xF8-\xFF])|\d+/g;
+
+  return convertToString(input).match(regex);
+}
+
+// convert the input array to camel case
+function toCamelCase(inputArray) {
+  let result = '';
+  if (!inputArray) return result;
+
+  for (let i = 0, len = inputArray.length; i < len; i += 1) {
+    const currentStr = inputArray[i];
+
+    let tempStr = currentStr.toLowerCase();
+
+    if (i !== 0) {
+      // convert first letter to upper case (the word is in lowercase)
+      tempStr = tempStr.substr(0, 1).toUpperCase() + tempStr.substr(1);
+    }
+    result += tempStr;
+  }
+  return result;
+}
+
+// this function call all other functions
+
+function camelcase(input) {
+  const words = toWords(input);
+
+  return toCamelCase(words);
+}
+
+export default camelcase;

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

@@ -0,0 +1,214 @@
+import _isUndefined from 'lodash.isundefined';
+import _isEmpty from 'lodash.isempty';
+import _pickBy from 'lodash.pickby';
+import _toString from 'lodash.tostring';
+import { pick as ramdaPick } from 'ramda';
+
+const isDefined = x => !_isUndefined(x);
+const isNotEmpty = x => !_isEmpty(x);
+const isNotNull = x => x != null;
+const isDefinedAndNotNull = x => isDefined(x) && isNotNull(x);
+const isDefinedAndNotNullAndNotEmpty = x => isDefined(x) && isNotNull(x) && isNotEmpty(x);
+const removeUndefinedValues = obj => _pickBy(obj, isDefined);
+const removeNullValues = obj => _pickBy(obj, isNotNull);
+const removeUndefinedAndNullValues = obj => _pickBy(obj, isDefinedAndNotNull);
+const removeUndefinedAndNullAndEmptyValues = obj => _pickBy(obj, isDefinedAndNotNullAndNotEmpty);
+const isBlank = value => _isEmpty(_toString(value).trim());
+const pick = (argObj, argArr) => ramdaPick(argArr, argObj);
+
+/**
+ *
+ * Convert an array map to hashmap(value as an array)
+ * @param  {} arrays [{"from":"prop1","to":"val1"},{"from":"prop1","to":"val2"},{"from":"prop2","to":"val2"}]
+ * @param  {} fromKey="from"
+ * @param  {} toKey="to"
+ * @param  {} isLowerCase=true
+ * @param  {} return hashmap {"prop1":["val1","val2"],"prop2":["val2"]}
+ */
+const getHashFromArrayWithDuplicate = (
+  arrays,
+  fromKey = 'from',
+  toKey = 'to',
+  isLowerCase = true,
+) => {
+  const hashMap = {};
+  if (Array.isArray(arrays)) {
+    arrays.forEach(array => {
+      if (!isNotEmpty(array[fromKey])) return;
+      const key = isLowerCase ? array[fromKey].toLowerCase().trim() : array[fromKey].trim();
+
+      if (hashMap[key]) {
+        const val = hashMap[key];
+        if (!val.includes(array[toKey])) {
+          hashMap[key].push(array[toKey]);
+        }
+      } else {
+        hashMap[key] = [array[toKey]];
+      }
+    });
+  }
+  return hashMap;
+};
+
+/**
+ *
+ * Convert an array map to hashmap
+ * @param  {} arrays [{"from":"prop1","to":"val1"},{"from":"prop2","to":"val2"}]
+ * @param  {} fromKey="from"
+ * @param  {} toKey="to"
+ * @param  {} isLowerCase=true
+ * @param  {} return hashmap {"prop1":"val1","prop2:"val2"}
+ */
+const getHashFromArray = (arrays, fromKey = 'from', toKey = 'to', isLowerCase = true) => {
+  const hashMap = {};
+  if (Array.isArray(arrays)) {
+    arrays.forEach(array => {
+      if (!isNotEmpty(array[fromKey])) return;
+      hashMap[isLowerCase ? array[fromKey].toLowerCase() : array[fromKey]] = array[toKey];
+    });
+  }
+  return hashMap;
+};
+
+/**
+ * @param  {} timestamp
+ * @param  {} return iso format of date
+ */
+const toIso = timestamp => new Date(timestamp).toISOString();
+
+// function to flatten a json
+function flattenJson(data, separator = '.', mode = 'normal') {
+  const result = {};
+  let l;
+
+  // a recursive function to loop through the array of the data
+  function recurse(cur, prop, visited = new Set()) {
+    let i;
+    if (visited.has(cur)) {
+      result[prop] = '[Circular Reference]';
+      return;
+    }
+
+    visited.add(cur);
+    if (Object(cur) !== cur) {
+      result[prop] = cur;
+    } else if (Array.isArray(cur)) {
+      for (i = 0, l = cur.length; i < l; i += 1) {
+        if (mode === 'strict') {
+          recurse(cur[i], `${prop}${separator}${i}`, visited);
+        } else {
+          recurse(cur[i], `${prop}[${i}]`, visited);
+        }
+      }
+      if (l === 0) {
+        result[prop] = [];
+      }
+    } else {
+      let isEmptyFlag = true;
+      Object.keys(cur).forEach(key => {
+        isEmptyFlag = false;
+        recurse(cur[key], prop ? `${prop}${separator}${key}` : key, visited);
+      });
+      if (isEmptyFlag && prop) result[prop] = {};
+    }
+    visited.delete(cur);
+  }
+
+  recurse(data, '');
+  return result;
+}
+
+/**
+ * Check whether the passed eventname is mapped in the config
+ * and return the mapped event name.
+ * @param {*} event
+ * @param {*} eventsHashmap
+ * @returns mappedEventName
+ */
+function getEventMappingFromConfig(event, eventsHashmap) {
+  // if the event name is mapped in the config, use the mapped name
+  // else use the original event name
+  if (eventsHashmap[event]) {
+    return eventsHashmap[event];
+  }
+  return null;
+}
+
+// External ID format
+// {
+//   "context": {
+//     "externalId": [
+//       {
+//         "type": "kustomerId",
+//         "id": "12345678"
+//       }
+//     ]
+//   }
+// }
+// to get destination specific external id passed in context.
+function getDestinationExternalID(message, type) {
+  let externalIdArray = null;
+  let destinationExternalId = null;
+  if (message.context && message.context.externalId) {
+    externalIdArray = message.context.externalId;
+  }
+  if (externalIdArray && Array.isArray(externalIdArray)) {
+    externalIdArray.forEach(extIdObj => {
+      if (extIdObj.type === type) {
+        destinationExternalId = extIdObj.id;
+      }
+    });
+  }
+  return destinationExternalId;
+}
+
+/**
+ * Function to check if value is Defined, Not null and Not Empty.
+ * Created this function, Because existing isDefinedAndNotNullAndNotEmpty(123) is returning false due to lodash _.isEmpty function.
+ * _.isEmpty is used to detect empty collections/objects and it will return true for Integer, Boolean values.
+ * ref: https://github.com/lodash/lodash/issues/496
+ * @param {*} value 123
+ * @returns yes
+ */
+const isDefinedNotNullNotEmpty = value =>
+  !(
+    value === undefined ||
+    value === null ||
+    Number.isNaN(value) ||
+    (typeof value === 'object' && Object.keys(value).length === 0) ||
+    (typeof value === 'string' && value.trim().length === 0)
+  );
+
+const validateEmail = email => {
+  const regex =
+    /^(([^\s"(),.:;<>@[\\\]]+(\.[^\s"(),.:;<>@[\\\]]+)*)|(".+"))@((\[(?:\d{1,3}\.){3}\d{1,3}])|(([\dA-Za-z-]+\.)+[A-Za-z]{2,}))$/;
+  return !!regex.test(email);
+};
+
+const validatePhoneWithCountryCode = phone => {
+  const regex = /^\+(?:[\d{] ?){6,14}\d$/;
+  return !!regex.test(phone);
+};
+
+export {
+  getEventMappingFromConfig,
+  getHashFromArrayWithDuplicate,
+  getHashFromArray,
+  getDestinationExternalID,
+  toIso,
+  flattenJson,
+  removeUndefinedValues,
+  removeUndefinedAndNullValues,
+  removeNullValues,
+  removeUndefinedAndNullAndEmptyValues,
+  isDefined,
+  isNotEmpty,
+  isNotNull,
+  isDefinedAndNotNull,
+  isDefinedAndNotNullAndNotEmpty,
+  isDefinedNotNullNotEmpty,
+  isBlank,
+  pick,
+  validateEmail,
+  validatePhoneWithCountryCode,
+};

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

@@ -0,0 +1,4 @@
+const GENERIC_TRUE_VALUES = ['true', 'True', 'TRUE', 't', 'T', '1'];
+const GENERIC_FALSE_VALUES = ['false', 'False', 'FALSE', 'f', 'F', '0'];
+
+export { GENERIC_TRUE_VALUES, GENERIC_FALSE_VALUES };

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

@@ -0,0 +1,106 @@
+const LogLevel = {
+  LOG: {
+    value: 0,
+    method: console.log,
+  },
+  INFO: {
+    value: 1,
+    method: console.info,
+  },
+  DEBUG: {
+    value: 2,
+    method: console.debug,
+  },
+  WARN: {
+    value: 3,
+    method: console.warn,
+  },
+  ERROR: {
+    value: 4,
+    method: console.error,
+  },
+};
+
+class Logger {
+  constructor(scope, level) {
+    this.level = +level || LogLevel.ERROR.value;
+    this.scope = scope || '';
+  }
+
+  setLogLevel(levelStr) {
+    if (levelStr && typeof levelStr === 'string') {
+      const lvlStr = levelStr.toUpperCase();
+      this.level = LogLevel[lvlStr] ? LogLevel[lvlStr].value : this.level;
+    }
+  }
+
+  setScope(scopeVal) {
+    this.scope = scopeVal || this.scope;
+  }
+
+  log(...args) {
+    this.logBase(args, LogLevel.LOG.value);
+  }
+
+  info(...args) {
+    this.logBase(args, LogLevel.INFO.value);
+  }
+
+  debug(...args) {
+    this.logBase(args, LogLevel.DEBUG.value);
+  }
+
+  warn(...args) {
+    this.logBase(args, LogLevel.WARN.value);
+  }
+
+  error(...args) {
+    this.logBase(args, LogLevel.ERROR.value);
+  }
+
+  logBase(args, logLevel) {
+    if (this.level <= logLevel) {
+      const logVal = Object.values(LogLevel).find(val => val.value === logLevel);
+      logVal.method(...this.getLogData(args));
+    }
+  }
+
+  /**
+   * Formats the console message using `scope`
+   * @param {*} logArgs
+   * @returns updated log arguments
+   */
+  getLogData(logArgs) {
+    if (Array.isArray(logArgs) && logArgs.length > 0) {
+      // prefix SDK identifier
+      let msg = `%c RS SDK`;
+
+      // format the log message using `scope`
+      if (this.scope) {
+        msg = `${msg} - ${this.scope}`;
+      }
+
+      // trim whitespaces
+      const orgMsg = logArgs[0].trim();
+
+      // prepare the final message
+      msg = `${msg} %c ${orgMsg}`;
+
+      const retArgs = [];
+      retArgs.push(msg);
+
+      // add style for the prefix
+      retArgs.push('font-weight: bold; background: black; color: white;');
+
+      // reset the style for the actual message
+      retArgs.push('font-weight: normal;');
+
+      // append rest of the original arguments
+      retArgs.push(...logArgs.slice(1));
+      return retArgs;
+    }
+    return logArgs;
+  }
+}
+
+export default Logger;