iureiure 1.0.0

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

@@ -0,0 +1,150 @@
+/* eslint-disable @typescript-eslint/no-use-before-define */
+/* eslint-disable no-template-curly-in-string */
+import { ScriptLoader } from '@rudderstack/analytics-js-common/v1.1/utils/ScriptLoader';
+import {
+  NAME,
+  DISPLAY_NAME,
+} from '@rudderstack/analytics-js-common/constants/integrations/Keen/constants';
+import Logger from '../../utils/logger';
+
+const logger = new Logger(DISPLAY_NAME);
+
+class Keen {
+  constructor(config, analytics, destinationInfo) {
+    if (analytics.logLevel) {
+      logger.setLogLevel(analytics.logLevel);
+    }
+    this.analytics = analytics;
+    this.projectID = config.projectID;
+    this.writeKey = config.writeKey;
+    this.ipAddon = config.ipAddon;
+    this.uaAddon = config.uaAddon;
+    this.urlAddon = config.urlAddon;
+    this.referrerAddon = config.referrerAddon;
+    this.client = null;
+    this.name = NAME;
+    ({
+      shouldApplyDeviceModeTransformation: this.shouldApplyDeviceModeTransformation,
+      propagateEventsUntransformedOnError: this.propagateEventsUntransformedOnError,
+      destinationId: this.destinationId,
+    } = destinationInfo ?? {});
+  }
+
+  init() {
+    ScriptLoader('keen-integration', 'https://cdn.jsdelivr.net/npm/keen-tracking@4');
+
+    const check = setInterval(checkAndInitKeen.bind(this), 1000);
+    function initKeen(object) {
+      const client = new window.KeenTracking({
+        projectId: object.projectID,
+        writeKey: object.writeKey,
+      });
+      return client;
+    }
+    function checkAndInitKeen() {
+      if (typeof window.KeenTracking !== 'undefined') {
+        this.client = initKeen(this);
+        clearInterval(check);
+      }
+    }
+  }
+
+  isLoaded() {
+    return !!(this.client != null);
+  }
+
+  isReady() {
+    return this.isLoaded();
+  }
+
+  identify(rudderElement) {
+    const { message } = rudderElement;
+    let { userId } = message;
+    const { context, anonymousId } = message;
+    const { traits } = context;
+    let properties = message?.properties || {};
+
+    userId = userId || anonymousId;
+    properties.user = {
+      userId,
+      traits,
+    };
+    properties = this.getAddOn(properties);
+    this.client.extendEvents(properties);
+  }
+
+  track(rudderElement) {
+    const { event } = rudderElement.message;
+    let { properties } = rudderElement.message;
+    properties = this.getAddOn(properties);
+    this.client.recordEvent(event, properties);
+  }
+
+  page(rudderElement) {
+    let { properties } = rudderElement.message;
+    const pageName = rudderElement.message.name;
+    const pageCategory = properties.category || undefined;
+    let name = 'Loaded a Page';
+    if (pageName) {
+      name = `Viewed ${pageName} page`;
+    }
+    if (pageCategory && pageName) {
+      name = `Viewed ${pageCategory} ${pageName} page`;
+    }
+    properties = this.getAddOn(properties);
+    this.client.recordEvent(name, properties);
+  }
+
+  getAddOn(properties) {
+    const params = properties;
+    const addOns = [];
+    if (this.ipAddon) {
+      params.ip_address = '${keen.ip}';
+      addOns.push({
+        name: 'keen:ip_to_geo',
+        input: {
+          ip: 'ip_address',
+        },
+        output: 'ip_geo_info',
+      });
+    }
+    if (this.uaAddon) {
+      params.user_agent = '${keen.user_agent}';
+      addOns.push({
+        name: 'keen:ua_parser',
+        input: {
+          ua_string: 'user_agent',
+        },
+        output: 'parsed_user_agent',
+      });
+    }
+    if (this.urlAddon) {
+      params.page_url = document.location.href;
+      addOns.push({
+        name: 'keen:url_parser',
+        input: {
+          url: 'page_url',
+        },
+        output: 'parsed_page_url',
+      });
+    }
+    if (this.referrerAddon) {
+      params.page_url = document.location.href;
+      params.referrer_url = document.referrer;
+      addOns.push({
+        name: 'keen:referrer_parser',
+        input: {
+          referrer_url: 'referrer_url',
+          page_url: 'page_url',
+        },
+        output: 'referrer_info',
+      });
+    }
+    params.keen = {
+      addons: addOns,
+    };
+    return params;
+  }
+}
+
+export default Keen;

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

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

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

@@ -0,0 +1,245 @@
+/* eslint-disable no-underscore-dangle */
+/* eslint-disable class-methods-use-this */
+import is from 'is';
+import extend from '@ndhoule/extend';
+import each from 'component-each';
+import {
+  NAME,
+  DISPLAY_NAME,
+} from '@rudderstack/analytics-js-common/constants/integrations/Kissmetrics/constants';
+import Logger from '../../utils/logger';
+import { getRevenue } from '../../utils/utils';
+import { loadeNativeSdk } from './nativeSdkLoader';
+
+const logger = new Logger(DISPLAY_NAME);
+
+class Kissmetrics {
+  constructor(config, analytics, destinationInfo) {
+    if (analytics.logLevel) {
+      logger.setLogLevel(analytics.logLevel);
+    }
+    this.analytics = analytics;
+    this.apiKey = config.apiKey;
+    this.prefixProperties = config.prefixProperties;
+    this.name = NAME;
+    ({
+      shouldApplyDeviceModeTransformation: this.shouldApplyDeviceModeTransformation,
+      propagateEventsUntransformedOnError: this.propagateEventsUntransformedOnError,
+      destinationId: this.destinationId,
+    } = destinationInfo ?? {});
+  }
+
+  init() {
+    loadeNativeSdk(this.apiKey);
+
+    if (this.isEnvMobile()) {
+      window._kmq.push(['set', { 'Mobile Session': 'Yes' }]);
+    }
+  }
+
+  isLoaded() {
+    return is.object(window.KM);
+  }
+
+  isReady() {
+    return this.isLoaded();
+  }
+
+  isEnvMobile() {
+    const mobileRegex = /android|blackberry|iemobile|opera mini|ipad|iphone|ipod/i;
+    return mobileRegex.test(navigator.userAgent);
+  }
+
+  // source : https://github.com/segment-integrations/analytics.js-integration-kissmetrics/blob/master/lib/index.js
+  toUnixTimestamp(date) {
+    const newDate = new Date(date);
+    return Math.floor(newDate.getTime() / 1000);
+  }
+
+  // source : https://github.com/segment-integrations/analytics.js-integration-kissmetrics/blob/master/lib/index.js
+  clean(obj) {
+    let ret = {};
+
+    Object.keys(obj).forEach(key => {
+      if (Object.prototype.hasOwnProperty.call(obj, key)) {
+        const value = obj[key];
+        if (is.date(value)) {
+          // convert date to unix
+          ret[key] = this.toUnixTimestamp(value);
+        } else if (is.bool(value) || is.number(value)) {
+          // leave boolean and  numbers as is
+          ret[key] = value;
+        } else if (value.toString() !== '[object Object]') {
+          // convert non objects to strings
+          ret[key] = value.toString();
+        } else {
+          // json
+          // must flatten including the name of the original trait/property
+          const nestedObj = {};
+          nestedObj[key] = value;
+          const flattenedObj = this.flatten(nestedObj, { safe: true });
+
+          // stringify arrays inside nested object to be consistent with top level behavior of arrays
+          Object.keys(flattenedObj).forEach(objKey => {
+            if (is.array(flattenedObj[objKey])) {
+              flattenedObj[objKey] = flattenedObj[objKey].toString();
+            }
+          });
+
+          ret = extend(ret, flattenedObj);
+          delete ret[key];
+        }
+      }
+    });
+    return ret;
+  }
+
+  // source : https://github.com/segment-integrations/analytics.js-integration-kissmetrics/blob/master/lib/index.js
+  flatten(target, opts) {
+    const options = opts || {};
+    const delimiter = options.delimiter || '.';
+    let { maxDepth } = options;
+    const { safe } = options;
+    let currentDepth = 1;
+    const output = {};
+
+    // eslint-disable-next-line consistent-return
+    function step(object, prev) {
+      // eslint-disable-next-line no-restricted-syntax
+      for (const key in object) {
+        if (Object.prototype.hasOwnProperty.call(object, key)) {
+          const value = object[key];
+          const isarray = safe && is.array(value);
+          const type = Object.prototype.toString.call(value);
+          const isobject = type === '[object Object]' || type === '[object Array]';
+          const arr = [];
+
+          const newKey = prev ? prev + delimiter + key : key;
+
+          if (!options.maxDepth) {
+            maxDepth = currentDepth + 1;
+          }
+
+          Object.keys(value).forEach(valueKey => {
+            if (Object.prototype.hasOwnProperty.call(value, valueKey)) {
+              arr.push(valueKey);
+            }
+          });
+
+          if (!isarray && isobject && arr.length > 0 && currentDepth < maxDepth) {
+            // eslint-disable-next-line no-plusplus
+            ++currentDepth;
+            return step(value, newKey);
+          }
+
+          output[newKey] = value;
+        }
+      }
+    }
+
+    step(target);
+
+    return output;
+  }
+
+  //  source : https://github.com/segment-integrations/analytics.js-integration-kissmetrics/blob/master/lib/index.js
+  prefix(event, properties) {
+    const prefixed = {};
+    each(properties, (key, val) => {
+      if (key === 'Billing Amount') {
+        prefixed[key] = val;
+      } else if (key === 'revenue') {
+        prefixed[`${event} - ${key}`] = val;
+        prefixed['Billing Amount'] = val;
+      } else {
+        prefixed[`${event} - ${key}`] = val;
+      }
+    });
+    return prefixed;
+  }
+
+  identify(rudderElement) {
+    const { userId, context } = rudderElement.message;
+    const { traits } = context;
+    const userTraits = this.clean(traits);
+
+    if (userId && userId !== '') {
+      window._kmq.push(['identify', userId]);
+    }
+    if (traits) {
+      window._kmq.push(['set', userTraits]);
+    }
+  }
+
+  track(rudderElement) {
+    const { event } = rudderElement.message;
+    let properties = JSON.parse(JSON.stringify(rudderElement.message.properties));
+    const timestamp = this.toUnixTimestamp(new Date());
+
+    const revenue = getRevenue(properties);
+    if (revenue) {
+      properties.revenue = revenue;
+    }
+
+    const { products } = properties;
+    if (products) {
+      delete properties.products;
+    }
+
+    properties = this.clean(properties);
+
+    if (this.prefixProperties) {
+      properties = this.prefix(event, properties);
+    }
+    window._kmq.push(['record', event, properties]);
+
+    const iterator = function pushItem(product, i) {
+      let item = product;
+      if (this.prefixProperties) item = this.prefix(event, item);
+      item._t = timestamp + i;
+      item._d = 1;
+      window.KM.set(item);
+    }.bind(this);
+
+    if (products) {
+      window._kmq.push(() => {
+        each(products, iterator);
+      });
+    }
+  }
+
+  page(rudderElement) {
+    let { properties } = rudderElement.message;
+    const pageName = rudderElement.message.name;
+    const pageCategory = properties.category || undefined;
+    let name = 'Loaded a Page';
+    if (pageName) {
+      name = `Viewed ${pageName} page`;
+    }
+    if (pageCategory && pageName) {
+      name = `Viewed ${pageCategory} ${pageName} page`;
+    }
+
+    if (this.prefixProperties) {
+      properties = this.prefix('Page', properties);
+    }
+
+    window._kmq.push(['record', name, properties]);
+  }
+
+  alias(rudderElement) {
+    const { previousId, userId } = rudderElement.message;
+    window._kmq.push(['alias', userId, previousId]);
+  }
+
+  group(rudderElement) {
+    const { groupId, traits } = rudderElement.message;
+    const groupTraits = this.prefix('Group', traits);
+    if (groupId) {
+      groupTraits['Group - id'] = groupId;
+    }
+    window._kmq.push(['set', groupTraits]);
+  }
+}
+
+export default Kissmetrics;

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

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

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

@@ -0,0 +1,23 @@
+import { LOAD_ORIGIN } from '@rudderstack/analytics-js-common/v1.1/utils/constants';
+
+function loadeNativeSdk(apiKey) {
+  window._kmq = window._kmq || [];
+
+  const _kmk = window._kmk || apiKey;
+  function _kms(u) {
+    setTimeout(function () {
+      const d = document;
+      const f = d.getElementsByTagName('script')[0];
+      const s = d.createElement('script');
+      s.type = 'text/javascript';
+      s.async = true;
+      s.setAttribute('data-loader', LOAD_ORIGIN);
+      s.src = u;
+      f.parentNode.insertBefore(s, f);
+    }, 1);
+  }
+  _kms('//i.kissmetrics.com/i.js');
+  _kms(`//scripts.kissmetrics.com/${_kmk}.2.js`);
+}
+
+export { loadeNativeSdk };

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

@@ -0,0 +1,197 @@
+/* eslint-disable class-methods-use-this */
+/* eslint-disable no-underscore-dangle */
+import get from 'get-value';
+import { ScriptLoader } from '@rudderstack/analytics-js-common/v1.1/utils/ScriptLoader';
+import {
+  NAME,
+  DISPLAY_NAME,
+} from '@rudderstack/analytics-js-common/constants/integrations/Klaviyo/constants';
+import Logger from '../../utils/logger';
+import { extractCustomFields, getDefinedTraits } from '../../utils/utils';
+import ecommEventPayload from './util';
+import { isNotEmpty } from '../../utils/commonUtils';
+
+const logger = new Logger(DISPLAY_NAME);
+
+class Klaviyo {
+  constructor(config, analytics, destinationInfo) {
+    if (analytics.logLevel) {
+      logger.setLogLevel(analytics.logLevel);
+    }
+    this.analytics = analytics;
+    this.publicApiKey = config.publicApiKey;
+    this.sendPageAsTrack = config.sendPageAsTrack;
+    this.additionalPageInfo = config.additionalPageInfo;
+    this.enforceEmailAsPrimary = config.enforceEmailAsPrimary;
+    this.name = NAME;
+    this.keysToExtract = ['context.traits'];
+    this.exclusionKeys = [
+      'email',
+      'E-mail',
+      'Email',
+      'firstName',
+      'firstname',
+      'first_name',
+      'lastName',
+      'lastname',
+      'last_name',
+      'phone',
+      'Phone',
+      'title',
+      'organization',
+      'city',
+      'City',
+      'region',
+      'country',
+      'Country',
+      'zip',
+      'image',
+      'timezone',
+      'anonymousId',
+      'userId',
+      'properties',
+    ];
+    this.ecomExclusionKeys = [
+      'name',
+      'product_id',
+      'sku',
+      'image_url',
+      'url',
+      'brand',
+      'price',
+      'compare_at_price',
+      'quantity',
+      'categories',
+      'products',
+      'product_names',
+      'order_id',
+      'value',
+      'checkout_url',
+      'item_names',
+      'items',
+      'checkout_url',
+    ];
+    this.ecomEvents = ['product viewed', 'product clicked', 'product added', 'checkout started'];
+    this.eventNameMapping = {
+      'product viewed': 'Viewed Product',
+      'product clicked': 'Viewed Product',
+      'product added': 'Added to Cart',
+      'checkout started': 'Started Checkout',
+    };
+    ({
+      shouldApplyDeviceModeTransformation: this.shouldApplyDeviceModeTransformation,
+      propagateEventsUntransformedOnError: this.propagateEventsUntransformedOnError,
+      destinationId: this.destinationId,
+    } = destinationInfo ?? {});
+  }
+
+  init() {
+    ScriptLoader(
+      'klaviyo-integration',
+      `https://static.klaviyo.com/onsite/js/klaviyo.js?company_id=${this.publicApiKey}`,
+    );
+  }
+
+  isLoaded() {
+    return !!(window._learnq && window._learnq.push !== Array.prototype.push);
+  }
+
+  isReady() {
+    return this.isLoaded();
+  }
+
+  identify(rudderElement) {
+    const { message } = rudderElement;
+    if (!(message.context && message.context.traits)) {
+      logger.error('user traits not present');
+      return;
+    }
+
+    const { userId, email, phone, firstName, lastName, city, country, state } =
+      getDefinedTraits(message);
+
+    let payload = {
+      $id: userId,
+      $email: email,
+      $phone_number: phone,
+      $first_name: firstName,
+      $last_name: lastName,
+      $city: city,
+      $country: country,
+      $organization: get(message, 'context.traits.organization'),
+      $title: get(message, 'context.traits.title'),
+      $region: get(message, 'context.traits.region') || state,
+      $zip: get(message, 'context.traits.zip') || get(message, 'context.traits.address.postalCode'),
+      $address1: get(message, 'context.traits.address.street'),
+    };
+    if (!payload.$email && !payload.$phone_number && !payload.$id) {
+      logger.error('user id, phone or email not present');
+      return;
+    }
+    if (this.enforceEmailAsPrimary) {
+      delete payload.$id;
+      payload._id = userId;
+    }
+    // Extract other K-V property from traits about user custom properties
+    try {
+      payload = extractCustomFields(message, payload, this.keysToExtract, this.exclusionKeys);
+    } catch (err) {
+      logger.error(`Error occured at extractCustomFields ${err}`);
+    }
+    window._learnq.push(['identify', payload]);
+  }
+
+  track(rudderElement) {
+    const { message } = rudderElement;
+    const properties = message?.properties || {};
+
+    const event = message.event ? message.event.trim().toLowerCase() : message.event;
+    if (this.ecomEvents.includes(event)) {
+      let payload = ecommEventPayload(this.eventNameMapping[event], message);
+      const eventName = this.eventNameMapping[event];
+      const customProperties = extractCustomFields(
+        message,
+        {},
+        ['properties'],
+        this.ecomExclusionKeys,
+      );
+      if (isNotEmpty(customProperties)) {
+        payload = { ...payload, ...customProperties };
+      }
+      if (isNotEmpty(payload)) {
+        window._learnq.push(['track', eventName, payload]);
+      }
+    } else {
+      const propsPayload = properties;
+      if (propsPayload.revenue) {
+        propsPayload.$value = propsPayload.revenue;
+        delete propsPayload.revenue;
+      }
+      window._learnq.push(['track', event, propsPayload]);
+    }
+  }
+
+  page(rudderElement) {
+    const { message } = rudderElement;
+    const properties = message?.properties || {};
+    if (this.sendPageAsTrack) {
+      let eventName;
+      if (properties?.category && message.name) {
+        eventName = `Viewed ${properties.category} ${message.name} page`;
+      } else if (message.name) {
+        eventName = `Viewed ${message.name} page`;
+      } else {
+        eventName = 'Viewed a Page';
+      }
+      if (this.additionalPageInfo && message.properties) {
+        window._learnq.push(['track', `${eventName}`, message.properties]);
+      } else {
+        window._learnq.push(['track', `${eventName}`]);
+      }
+    } else {
+      window._learnq.push(['track']);
+    }
+  }
+}
+
+export default Klaviyo;

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

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