iureiure 1.0.0

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

@@ -0,0 +1,184 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable no-unused-vars */
+/* eslint-disable no-underscore-dangle */
+/* eslint-disable class-methods-use-this */
+// Research Spec: https://www.notion.so/rudderstacks/Matomo-c5a76c7838b94190a3374887b94a176e
+import {
+  NAME,
+  DISPLAY_NAME,
+} from '@rudderstack/analytics-js-common/constants/integrations/Matomo/constants';
+import Logger from '../../utils/logger';
+import {
+  goalIdMapping,
+  ecommerceEventsMapping,
+  standardEventsMapping,
+  checkCustomDimensions,
+} from './util';
+import { getHashFromArrayWithDuplicate } from '../../utils/commonUtils';
+import { loadNativeSdk } from './nativeSdkLoader';
+
+const logger = new Logger(DISPLAY_NAME);
+
+class Matomo {
+  constructor(config, analytics, destinationInfo) {
+    if (analytics.logLevel) {
+      logger.setLogLevel(analytics.logLevel);
+    }
+    this.analytics = analytics;
+    this.serverUrl = config.serverUrl;
+    this.siteId = config.siteId;
+    this.eventsMapToGoalId = config.eventsMapToGoalId;
+    this.eventsToStandard = config.eventsToStandard;
+    this.name = NAME;
+    this.trackAllContentImpressions = config.trackAllContentImpressions;
+    this.trackVisibleContentImpressions = config.trackVisibleContentImpressions;
+    this.checkOnScroll = config.checkOnScroll;
+    this.timeIntervalInMs = config.timeIntervalInMs;
+    this.logAllContentBlocksOnPage = config.logAllContentBlocksOnPage;
+    this.enableHeartBeatTimer = config.enableHeartBeatTimer;
+    this.activeTimeInseconds = config.activeTimeInseconds;
+    this.enableLinkTracking = config.enableLinkTracking;
+    this.disablePerformanceTracking = config.disablePerformanceTracking;
+    this.enableCrossDomainLinking = config.enableCrossDomainLinking;
+    this.setCrossDomainLinkingTimeout = config.setCrossDomainLinkingTimeout;
+    this.timeout = config.timeout;
+    this.getCrossDomainLinkingUrlParameter = config.getCrossDomainLinkingUrlParameter;
+    this.disableBrowserFeatureDetection = config.disableBrowserFeatureDetection;
+    this.matomoVersion = config.matomoVersion;
+    this.premiseUrl = config.premiseUrl;
+
+    this.ecomEvents = {
+      SET_ECOMMERCE_VIEW: 'SET_ECOMMERCE_VIEW',
+      ADD_ECOMMERCE_ITEM: 'ADD_ECOMMERCE_ITEM',
+      REMOVE_ECOMMERCE_ITEM: 'REMOVE_ECOMMERCE_ITEM',
+      TRACK_ECOMMERCE_ORDER: 'TRACK_ECOMMERCE_ORDER',
+      CLEAR_ECOMMERCE_CART: 'CLEAR_ECOMMERCE_CART',
+      TRACK_ECOMMERCE_CART_UPDATE: 'TRACK_ECOMMERCE_CART_UPDATE',
+    };
+    ({
+      shouldApplyDeviceModeTransformation: this.shouldApplyDeviceModeTransformation,
+      propagateEventsUntransformedOnError: this.propagateEventsUntransformedOnError,
+      destinationId: this.destinationId,
+    } = destinationInfo ?? {});
+  }
+
+  loadScript() {
+    loadNativeSdk(this.matomoVersion, this.premiseUrl, this.serverUrl, this.siteId);
+  }
+
+  init() {
+    this.loadScript();
+  }
+
+  isLoaded() {
+    return !!(window._paq && window._paq.push !== Array.prototype.push);
+  }
+
+  pushValues(condition, values) {
+    if (condition) {
+      window._paq.push(values);
+    }
+  }
+
+  isReady() {
+    // Dashboard Event Settings
+    if (window._paq && window._paq.push !== Array.prototype.push) {
+      // Scans the entire DOM for all content blocks and tracks all impressions once the DOM ready event has been triggered.
+      this.pushValues(this.trackAllContentImpressions, ['trackAllContentImpressions']);
+
+      // Scans the entire DOM for all content blocks when the page is loaded. Tracks an impression only if a content block is actually visible.
+      this.pushValues(
+        this.trackVisibleContentImpressions && this.checkOnScroll && this.timeIntervalInMs,
+        ['trackVisibleContentImpressions', this.checkOnScroll, this.timeIntervalInMs],
+      );
+
+      // Logs all content blocks found within a page to the console.
+      this.pushValues(this.logAllContentBlocksOnPage, ['logAllContentBlocksOnPage']);
+
+      // Installs a heart beat timer to send additional requests to Matomo to measure the time spent in the visit.
+      this.pushValues(this.enableHeartBeatTimer && this.activeTimeInseconds, [
+        'enableHeartBeatTimer',
+        this.activeTimeInseconds,
+      ]);
+
+      //  Installs link tracking on all applicable link elements.
+      this.pushValues(this.enableLinkTracking, ['enableLinkTracking', true]);
+
+      // Disables page performance tracking.
+      this.pushValues(this.disablePerformanceTracking, ['disablePerformanceTracking']);
+
+      // Enables cross domain linking. It is useful if you own multiple domains and would like to track all the actions and
+      // page views of a specific visitor into the same visit.
+      this.pushValues(this.enableCrossDomainLinking, ['enableCrossDomainLinking']);
+
+      // Sets the cross domain linking timeout (in seconds).
+      this.pushValues(this.setCrossDomainLinkingTimeout && this.timeout, [
+        'setCrossDomainLinkingTimeout',
+        this.timeout,
+      ]);
+
+      // Gets the query parameter to append to the links to handle cross domain linking.
+      this.pushValues(this.getCrossDomainLinkingUrlParameter, [
+        'getCrossDomainLinkingUrlParameter',
+      ]);
+
+      // Disables the browser feature detection.
+      this.pushValues(this.disableBrowserFeatureDetection, ['disableBrowserFeatureDetection']);
+    }
+    return false;
+  }
+
+  identify(rudderElement) {
+    const { anonymousId, userId } = rudderElement.message;
+    const matomoUserId = userId || anonymousId;
+    if (!matomoUserId) {
+      logger.error('User parameter (anonymousId or userId) is required for identify call');
+      return;
+    }
+    window._paq.push(['setUserId', matomoUserId]);
+  }
+
+  track(rudderElement) {
+    const { message } = rudderElement;
+    const { event } = message;
+    const goalListMap = getHashFromArrayWithDuplicate(this.eventsMapToGoalId);
+    const standardEventsMap = getHashFromArrayWithDuplicate(this.eventsToStandard);
+    const ecommerceMapping = {
+      'product viewed': this.ecomEvents.SET_ECOMMERCE_VIEW,
+      'product added': this.ecomEvents.ADD_ECOMMERCE_ITEM,
+      'product removed': this.ecomEvents.REMOVE_ECOMMERCE_ITEM,
+      'order completed': this.ecomEvents.TRACK_ECOMMERCE_ORDER,
+      'cart cleared': this.ecomEvents.CLEAR_ECOMMERCE_CART,
+      'update cart': this.ecomEvents.TRACK_ECOMMERCE_CART_UPDATE,
+    };
+
+    if (!event) {
+      logger.error('Event name not present');
+      return;
+    }
+
+    // Checks for custom dimensions in the payload, if present makes appropriate calls
+    checkCustomDimensions(message);
+
+    const trimmedEvent = event.toLowerCase().trim();
+
+    // For every type of track calls we consider the trackGoal function.
+    if (goalListMap[trimmedEvent]) {
+      goalIdMapping(trimmedEvent, goalListMap, message);
+    }
+
+    // Mapping Standard Events
+    if (standardEventsMap[trimmedEvent]) {
+      standardEventsMapping(trimmedEvent, standardEventsMap, message);
+    }
+
+    // Mapping Ecommerce Events
+    ecommerceEventsMapping(ecommerceMapping[trimmedEvent] || 'trackEvent', message);
+  }
+
+  page(rudderElement) {
+    window._paq.push(['trackPageView']);
+  }
+}
+
+export default Matomo;

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

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

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

@@ -0,0 +1,20 @@
+import { LOAD_ORIGIN } from '@rudderstack/analytics-js-common/v1.1/utils/constants';
+
+function loadNativeSdk(matomoVersion, premiseUrl, serverUrl, siteId) {
+  window._paq = window._paq || [];
+  (function (matomoVersion, premiseUrl, serverUrl, siteId) {
+    let u = serverUrl || '';
+    window._paq.push(['setTrackerUrl', `${u}matomo.php`]);
+    window._paq.push(['setSiteId', siteId]);
+    const d = document;
+    const g = d.createElement('script');
+    const s = d.getElementsByTagName('script')[0];
+    g.async = true;
+    u = u.replace('https://', '');
+    g.src = matomoVersion === 'premise' ? premiseUrl : `//cdn.matomo.cloud/${u}matomo.js`;
+    g.setAttribute('data-loader', LOAD_ORIGIN);
+    s.parentNode.insertBefore(g, s);
+  })(matomoVersion, premiseUrl, serverUrl, siteId);
+}
+
+export { loadNativeSdk };

package/packages/analytics-js-integrations/src/integrations/Matomo/util.js

@@ -0,0 +1,433 @@
+/* eslint-disable no-underscore-dangle */
+import each from '@ndhoule/each';
+import {
+  NAME,
+  DISPLAY_NAME,
+} from '@rudderstack/analytics-js-common/constants/integrations/Matomo/constants';
+import Logger from '../../utils/logger';
+import { getHashFromArray } from '../../utils/commonUtils';
+
+const logger = new Logger(DISPLAY_NAME);
+
+/**
+ * Get destination specific options from integrations options
+ * By default, it will return options for the destination using its display name
+ * If display name is not present, it will return options for the destination using its name
+ * The fallback is only for backward compatibility with SDK versions < v1.1
+ * @param {object} integrationsOptions Integrations options object
+ * @returns destination specific options
+ */
+const getDestinationOptions = integrationsOptions =>
+  integrationsOptions && (integrationsOptions[DISPLAY_NAME] || integrationsOptions[NAME]);
+const userParameterRequiredErrorMessage = 'User parameter (sku or product_id) is required';
+
+/** If any event name matches with the goals list provided by the dashboard
+ * we will call the trackGoal with the id provided in the mapping.
+ * @param  {} event
+ * @param  {} goalListMap
+ */
+const goalIdMapping = (event, goalListMap, message) => {
+  const revenue = message.properties?.revenue;
+  each((val, key) => {
+    if (key === event) {
+      val.forEach(v => {
+        if (revenue) window._paq.push(['trackGoal', v, revenue]);
+        else window._paq.push(['trackGoal', v]);
+      });
+    }
+  }, goalListMap);
+};
+
+/**
+ * Matomo trackLink call
+ * @param {*} properties
+ * @param {*} context
+ * @returns
+ */
+const trackLink = (properties, context) => {
+  const { url: linkUrl, linkType } = properties;
+  const url = linkUrl || context?.page?.url || undefined;
+
+  if (!url) {
+    logger.error('URL is missing');
+    return;
+  }
+
+  if (linkType !== 'link' && linkType !== 'download') {
+    logger.error("linkType can only be ('link' or 'download')");
+    return;
+  }
+
+  window._paq.push(['trackLink', url, linkType]);
+};
+
+/**
+ * Matomo trackSiteSearch call
+ * @param {*} properties
+ * @param {*} context
+ */
+const trackSiteSearch = (properties, context) => {
+  let { keyword } = properties;
+  const { category, resultsCount, search } = properties;
+  keyword = keyword || search || context?.page?.search;
+  window._paq.push(['trackSiteSearch', keyword, category, resultsCount]);
+};
+
+/**
+ * Matomo trackContentImpressionsWithinNode call
+ * @param {*} properties
+ * @returns
+ */
+const trackContentImpressionsWithinNode = properties => {
+  const domId = properties.domId || properties.dom_id;
+
+  if (!domId) {
+    logger.error('domId is missing');
+    return;
+  }
+
+  window._paq.push(['trackContentImpressionsWithinNode', document.getElementById(domId)]);
+};
+
+/**
+ * Matomo trackContentInteractionNode call
+ * @param {*} properties
+ */
+const trackContentInteractionNode = properties => {
+  const { contentInteraction, dom_id: dId } = properties;
+  const domId = properties.domId || dId;
+  window._paq.push([
+    'trackContentInteractionNode',
+    document.getElementById(domId),
+    contentInteraction,
+  ]);
+};
+
+/**
+ * Matomo trackContentImpression call
+ * @param {*} properties
+ */
+const trackContentImpression = properties => {
+  const { contentName, contentPiece, contentTarget } = properties;
+  window._paq.push(['trackContentImpression', contentName, contentPiece, contentTarget]);
+};
+
+/**
+ * Matomo trackContentInteraction call
+ * @param {*} properties
+ */
+const trackContentInteraction = properties => {
+  const { contentInteraction, contentName, contentPiece, contentTarget } = properties;
+  window._paq.push([
+    'trackContentInteraction',
+    contentInteraction,
+    contentName,
+    contentPiece,
+    contentTarget,
+  ]);
+};
+
+/**
+ * Making a call for each standard events
+ * @param {*} value
+ * @param {*} message
+ */
+const makeACall = (value, message) => {
+  const { context } = message;
+  const properties = message?.properties || {};
+
+  value.forEach(v => {
+    switch (v) {
+      case 'trackLink':
+        trackLink(properties, context);
+        break;
+
+      case 'trackSiteSearch':
+        trackSiteSearch(properties, context);
+        break;
+
+      case 'ping':
+        window._paq.push(['ping']);
+        break;
+
+      case 'trackContentImpressionsWithinNode':
+        trackContentImpressionsWithinNode(properties);
+        break;
+
+      case 'trackContentInteractionNode':
+        trackContentInteractionNode(properties);
+        break;
+
+      case 'trackContentImpression':
+        trackContentImpression(properties);
+        break;
+
+      case 'trackContentInteraction':
+        trackContentInteraction(properties);
+        break;
+
+      default:
+        break;
+    }
+  });
+};
+
+/** Mapping Standard Events
+ If any event name matches with the standard events list provided in the dashboard
+ @param  {} event
+ @param  {} standardEventsMap
+ @param  {} message
+ */
+const standardEventsMapping = (event, standardEventsMap, message) => {
+  each((val, key) => {
+    if (key === event) {
+      makeACall(val, message);
+    }
+  }, standardEventsMap);
+};
+
+/**
+ * setEcommerceView matomo event
+ * @param {*} properties
+ * @returns
+ */
+const handleSetEcommerceView = properties => {
+  const {
+    sku,
+    product_id: productId,
+    name: productName,
+    category: categoryName,
+    price,
+  } = properties;
+  const productSKU = sku || productId;
+
+  if (!productSKU) {
+    logger.error(userParameterRequiredErrorMessage);
+    return;
+  }
+
+  if (!productName) {
+    logger.error('User parameter name is required');
+    return;
+  }
+
+  if (!categoryName) {
+    logger.error('User parameter category is required');
+    return;
+  }
+
+  if (!price) {
+    logger.error('User parameter price is required');
+    return;
+  }
+
+  window._paq.push(['setEcommerceView', productSKU, productName, categoryName, price]);
+  window._paq.push(['trackPageView']);
+};
+
+/**
+ * addEcommerceItem matomo event
+ * @param {*} properties
+ * @returns
+ */
+const handleAddEcommerceItem = properties => {
+  const { sku, product_id: productId, name, category, price, quantity } = properties;
+  if (!sku && !productId) {
+    logger.error(userParameterRequiredErrorMessage);
+    return;
+  }
+
+  window._paq.push(['addEcommerceItem', sku || productId, name, category, price, quantity]);
+};
+
+/**
+ * removeEcommerceItem matomo event
+ * @param {*} properties
+ * @returns
+ */
+const handleRemoveEcommerceItem = properties => {
+  const { sku, product_id: productId } = properties;
+  const productSKU = sku || productId;
+  if (!productSKU) {
+    logger.error(userParameterRequiredErrorMessage);
+    return;
+  }
+
+  window._paq.push(['removeEcommerceItem', productSKU]);
+};
+
+/**
+ * Returns grand and sub total values
+ * @param {*} total
+ * @param {*} products
+ * @param {*} shipping
+ * @param {*} tax
+ * @param {*} subT
+ * @returns
+ */
+const calculateGrandAndSubTotal = (total, products, shipping, tax, subT) => {
+  if (total) {
+    return { grandTotal: parseFloat(total), subT };
+  }
+
+  /** grandTotal is a mandatory field
+   * If grandTotal is not found inside the properties, we are calculating it manually
+   */
+  let grandTotal = 0;
+  let subTotal = subT;
+
+  if (Array.isArray(products) && products.length > 0) {
+    products.forEach(product => {
+      if (product.price && product.quantity) {
+        grandTotal += parseFloat(product.price) * parseFloat(product.quantity);
+      }
+    });
+  }
+
+  /** subTotal is not a listed property in "Order Completed" event
+   * if user doesn't provide this property, then we are calculating it from grandTotal
+   * ref: https://matomo.org/faq/reports/analyse-ecommerce-reporting-to-improve-your-sales/#conversions-overview
+   */
+  if (!subTotal) {
+    subTotal = grandTotal;
+  }
+
+  // ref: https://matomo.org/faq/reports/analyse-ecommerce-reporting-to-improve-your-sales/#conversions-overview
+  if (shipping) {
+    grandTotal += parseFloat(shipping);
+  }
+  if (tax) {
+    grandTotal += parseFloat(tax);
+  }
+
+  return { grandTotal, subTotal };
+};
+
+/**
+ * trackEcommerceOrder matomo event
+ * @param {*} properties
+ * @param {*} products
+ * @returns
+ */
+const handleTrackEcommerceOrder = (properties, products) => {
+  const { order_id: oId, total, revenue, tax, shipping, discount, subTotal: subT } = properties;
+  let { orderId } = properties;
+  orderId = orderId || oId;
+  const { grandTotal, subTotal } = calculateGrandAndSubTotal(
+    total || revenue,
+    products,
+    shipping,
+    tax,
+    subT,
+  );
+
+  if (!oId && !orderId) {
+    logger.error('User parameter order_id is required');
+    return;
+  }
+
+  if (!grandTotal) {
+    logger.error('User parameter (total or revenue) is required');
+    return;
+  }
+
+  window._paq.push(['trackEcommerceOrder', orderId, grandTotal, subTotal, tax, shipping, discount]);
+};
+
+/**
+ * trackEcommerceCartUpdate matomo event
+ * @param {*} properties
+ */
+const handleTrackEcommerceCartUpdate = properties => {
+  const grandTotal = properties.total || properties.revenue;
+  window._paq.push(['trackEcommerceCartUpdate', grandTotal]);
+};
+
+/**
+ * trackEvent matomo event
+ * @param {*} event
+ * @param {*} properties
+ * @returns
+ */
+const handleGenericTrackEvent = (event, properties) => {
+  const { category, action, value } = properties;
+  if (!category) {
+    logger.error('User parameter category is required');
+    return;
+  }
+  if (!action) {
+    logger.error('User parameter action is required');
+    return;
+  }
+
+  window._paq.push(['trackEvent', category, action, event, value]);
+};
+
+/** Mapping Ecommerce Events
+ * @param  {} event
+ * @param  {} message
+ */
+const ecommerceEventsMapping = (event, message) => {
+  let products;
+
+  const properties = message?.properties || {};
+  if (properties) {
+    products = properties.products;
+  }
+
+  switch (event) {
+    case 'SET_ECOMMERCE_VIEW':
+      handleSetEcommerceView(properties);
+      break;
+
+    case 'ADD_ECOMMERCE_ITEM':
+      handleAddEcommerceItem(properties);
+      break;
+
+    case 'REMOVE_ECOMMERCE_ITEM':
+      handleRemoveEcommerceItem(properties);
+      break;
+
+    case 'TRACK_ECOMMERCE_ORDER':
+      handleTrackEcommerceOrder(properties, products);
+      break;
+
+    case 'CLEAR_ECOMMERCE_CART':
+      window._paq.push(['clearEcommerceCart']);
+      break;
+
+    case 'TRACK_ECOMMERCE_CART_UPDATE':
+      handleTrackEcommerceCartUpdate(properties);
+      break;
+
+    default:
+      // Generic track Event
+      handleGenericTrackEvent(message.event, properties);
+      break;
+  }
+};
+
+/**
+ * Checks for custom dimensions in the payload
+ * If present, we make setCustomDimension() function call
+ * @param  {} message
+ */
+const checkCustomDimensions = message => {
+  const { integrations } = message;
+  const matomoIntgConfig = getDestinationOptions(integrations);
+  if (matomoIntgConfig) {
+    const customDimension = matomoIntgConfig?.customDimension;
+    if (customDimension) {
+      const customDimensionsMap = getHashFromArray(
+        customDimension,
+        'dimensionId',
+        'dimensionValue',
+      );
+      each((val, key) => {
+        window._paq.push(['setCustomDimension', key, val]);
+      }, customDimensionsMap);
+    }
+  }
+};
+
+export { goalIdMapping, ecommerceEventsMapping, standardEventsMapping, checkCustomDimensions };

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

@@ -0,0 +1,69 @@
+import {
+  NAME,
+  DISPLAY_NAME,
+} from '@rudderstack/analytics-js-common/constants/integrations/MicrosoftClarity/constants';
+import Logger from '../../utils/logger';
+/* eslint-disable class-methods-use-this */
+
+import { loadNativeSdk } from './nativeSdkLoader';
+
+const logger = new Logger(DISPLAY_NAME);
+class MicrosoftClarity {
+  constructor(config, analytics, destinationInfo) {
+    if (analytics.logLevel) {
+      logger.setLogLevel(analytics.logLevel);
+    }
+    this.analytics = analytics;
+    this.name = NAME;
+    this.projectId = config.projectId;
+    this.cookieConsent = config.cookieConsent;
+    ({
+      shouldApplyDeviceModeTransformation: this.shouldApplyDeviceModeTransformation,
+      propagateEventsUntransformedOnError: this.propagateEventsUntransformedOnError,
+      destinationId: this.destinationId,
+    } = destinationInfo ?? {});
+  }
+
+  loadScript() {
+    loadNativeSdk(this.cookieConsent, this.projectId);
+  }
+
+  init() {
+    this.loadScript();
+  }
+
+  isLoaded() {
+    return !!window.clarity;
+  }
+
+  isReady() {
+    return this.isLoaded();
+  }
+
+  identify(rudderElement) {
+    const { message } = rudderElement;
+    const { userId, context } = message;
+    if (!userId) {
+      logger.error('userId is required for an identify call');
+      return;
+    }
+    let sessionId;
+    let customPageId;
+    if (context?.sessionId) {
+      sessionId = context.sessionId;
+    }
+    if (context?.traits?.customPageId) {
+      customPageId = context.traits.customPageId;
+    }
+    window.clarity('identify', userId, sessionId, customPageId);
+    if (context?.traits) {
+      const { traits } = context;
+      const keys = Object.keys(traits);
+      keys.forEach(key => {
+        window.clarity('set', key, traits[key]);
+      });
+    }
+  }
+}
+
+export default MicrosoftClarity;

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

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