castled-js-sdk 0.0.1 → 0.0.3

package/src/integrations/Mixpanel/browser.js

@@ -0,0 +1,326 @@
+/* eslint-disable class-methods-use-this */
+import get from 'get-value';
+import logger from '../../utils/logUtil';
+import { pick, removeUndefinedAndNullValues, isNotEmpty } from '../../utils/commonUtils';
+import {
+  mapTraits,
+  unionArrays,
+  formatTraits,
+  extendTraits,
+  extractTraits,
+  parseConfigArray,
+  inverseObjectArrays,
+  getConsolidatedPageCalls,
+} from './util';
+import { NAME } from './constants';
+import { loadNativeSdk } from './nativeSdkLoader';
+
+class Mixpanel {
+  constructor(config, analytics, destinationInfo) {
+    if (analytics.logLevel) {
+      logger.setLogLevel(analytics.logLevel);
+    }
+    this.analytics = analytics;
+    this.name = NAME;
+    this.accountId = config.accountId;
+    this.token = config.token;
+    this.people = config.people || false;
+    this.dataResidency = config.dataResidency || 'us';
+    this.setAllTraitsByDefault = config.setAllTraitsByDefault || false;
+    this.superProperties = config.superProperties || [];
+    this.eventIncrements = config.eventIncrements || [];
+    this.propIncrements = config.propIncrements || [];
+    this.sourceName = config.sourceName;
+    this.consolidatedPageCalls = getConsolidatedPageCalls(config);
+    this.trackCategorizedPages = config.trackCategorizedPages || false;
+    this.trackNamedPages = config.trackNamedPages || false;
+    this.groupKeySettings = config.groupKeySettings || [];
+    this.peopleProperties = config.peopleProperties || [];
+    this.crossSubdomainCookie = config.crossSubdomainCookie || false;
+    this.secureCookie = config.secureCookie || false;
+    this.persistenceType = config.persistenceType || 'cookie';
+    this.persistenceName = config.persistenceName;
+    this.traitAliases = {
+      created: '$created',
+      email: '$email',
+      firstName: '$first_name',
+      lastName: '$last_name',
+      lastSeen: '$last_seen',
+      name: '$name',
+      username: '$username',
+      phone: '$phone',
+    };
+    this.identityMergeApi = config.identityMergeApi || 'original';
+    ({
+      shouldApplyDeviceModeTransformation: this.shouldApplyDeviceModeTransformation,
+      propagateEventsUntransformedOnError: this.propagateEventsUntransformedOnError,
+      destinationId: this.destinationId,
+    } = destinationInfo ?? {});
+  }
+
+  init() {
+    logger.debug('===in init Mixpanel===');
+    // eslint-disable-next-line no-var
+    loadNativeSdk();
+    const options = {
+      cross_subdomain_cookie: this.crossSubdomainCookie || false,
+      secure_cookie: this.secureCookie || false,
+    };
+
+    if (this.persistenceName) {
+      options.persistence_name = this.persistenceName;
+    }
+
+    if (this.persistenceType !== 'none') {
+      options.persistence = this.persistenceType;
+    } else {
+      options.disable_persistence = true;
+    }
+
+    if (this.dataResidency === 'eu') {
+      // https://developer.mixpanel.com/docs/implement-mixpanel#section-implementing-mixpanel-in-the-european-union-eu
+      options.api_host = 'https://api-eu.mixpanel.com';
+    }
+    window.mixpanel.init(this.token, options);
+  }
+
+  isLoaded() {
+    logger.debug('in Mixpanel isLoaded');
+    logger.debug(!!(window.mixpanel && window.mixpanel.config));
+    window.mixpanel.register({ mp_lib: 'Rudderstack: web' });
+    return !!window?.mixpanel?.config;
+  }
+
+  isReady() {
+    logger.debug('in Mixpanel isReady');
+    return !!window?.mixpanel?.config;
+  }
+
+  /**
+   * Identify
+   * @param {*} htElement
+   */
+  identify(htElement) {
+    logger.debug('in Mixpanel identify');
+
+    let peopleProperties = parseConfigArray(this.peopleProperties, 'property');
+    peopleProperties = extendTraits(peopleProperties);
+    const superProperties = parseConfigArray(this.superProperties, 'property');
+
+    let userId = htElement.message.userId || htElement.message.anonymousId;
+    if (this.identityMergeApi === 'simplified') {
+      // calling mixpanel .identify() only for known users
+      userId = htElement.message.userId;
+    }
+    let traits = formatTraits(htElement.message);
+    const { email, username } = traits;
+    // id
+    if (userId) window.mixpanel.identify(userId);
+
+    // name tag
+    const nametag = email || username;
+    if (nametag) window.mixpanel.name_tag(nametag);
+
+    traits = extractTraits(traits, this.traitAliases);
+    traits = removeUndefinedAndNullValues(traits);
+
+    // determine which traits to union to existing properties and which to set as new properties
+    const traitsToUnion = {};
+    const traitsToSet = {};
+    Object.keys(traits).forEach((trait) => {
+      if (Object.prototype.hasOwnProperty.call(traits, trait)) {
+        const value = traits[trait];
+        if (Array.isArray(value) && value.length > 0) {
+          traitsToUnion[trait] = value;
+          // since mixpanel doesn't offer a union method for super properties we have to do it manually by retrieving the existing list super property
+          // from mixpanel and manually unioning to it ourselves
+          const existingTrait = window.mixpanel.get_property(trait);
+          if (existingTrait && Array.isArray(existingTrait)) {
+            traits[trait] = unionArrays(existingTrait, value);
+          }
+        } else {
+          traitsToSet[trait] = value;
+        }
+      }
+    });
+
+    if (this.setAllTraitsByDefault) {
+      window.mixpanel.register(traits);
+      if (this.people) {
+        window.mixpanel.people.set(traitsToSet);
+        window.mixpanel.people.union(traitsToUnion);
+      }
+    } else {
+      // explicitly set select traits as people and super properties
+      const mappedSuperProps = mapTraits(superProperties);
+      const superProps = pick(traits, mappedSuperProps || []);
+      if (isNotEmpty(superProps)) window.mixpanel.register(superProps);
+      if (this.people) {
+        const mappedPeopleProps = mapTraits(peopleProperties);
+        const peoplePropsToSet = pick(traitsToSet, mappedPeopleProps || []);
+        const peoplePropsToUnion = pick(traitsToUnion, mappedPeopleProps || []);
+        if (isNotEmpty(peoplePropsToSet)) window.mixpanel.people.set(peoplePropsToSet);
+        if (isNotEmpty(peoplePropsToUnion)) window.mixpanel.people.union(peoplePropsToUnion);
+      }
+    }
+  }
+
+  /**
+   * Page
+   * @param {*} htElement
+   */
+  page(htElement) {
+    logger.debug('in Mixpanel page');
+    const { name, properties } = htElement.message;
+    const { category } = properties;
+    // consolidated Page Calls
+    if (this.consolidatedPageCalls) {
+      window.mixpanel.track('Loaded a Page', properties);
+      return;
+    }
+
+    // categorized pages
+    if (this.trackCategorizedPages && category) {
+      // If this option is checked and name was also passed, used the full name which includes both category & name
+      if (name) {
+        window.mixpanel.track(`Viewed ${category} ${name} Page`, properties);
+        return;
+      }
+      window.mixpanel.track(`Viewed ${category} Page `, properties);
+      return;
+    }
+
+    // named pages
+    if (name && this.trackNamedPages) {
+      window.mixpanel.track(`Viewed ${name} Page`, properties);
+    }
+  }
+
+  /**
+   * Track
+   * https://mixpanel.com/help/reference/javascript#sending-events
+   * https://mixpanel.com/help/reference/javascript#tracking-revenue
+   * @param {*} htElement
+   */
+  track(htElement) {
+    logger.debug('in Mixpanel track');
+    const { message } = htElement;
+    const eventIncrements = parseConfigArray(this.eventIncrements, 'property');
+    const propIncrements = parseConfigArray(this.propIncrements, 'property');
+    const event = get(message, 'event');
+    const revenue = get(message, 'properties.revenue') || get(message, 'properties.total');
+    const { sourceName, people } = this;
+    let props = get(message, 'properties');
+    if (isNotEmpty(props)) {
+      props = inverseObjectArrays(props);
+    }
+    if (sourceName) {
+      props = { ...props };
+      props.rudderstack_source_name = sourceName;
+    }
+
+    // delete mixpanel's reserved prosperties, so they don't conflict
+    delete props.distinct_id;
+    delete props.ip;
+    delete props.mp_name_tag;
+    delete props.mp_note;
+    delete props.token;
+
+    // Mixpanel People operations
+    if (people) {
+      // increment event count, check if the current event exists in eventIncrements
+      if (eventIncrements.indexOf(event) !== -1) {
+        window.mixpanel.people.increment(event);
+        window.mixpanel.people.set(`Last ${event}`, new Date());
+      }
+      // increment property counts
+      Object.keys(props).forEach((prop) => {
+        const value = props[prop];
+        if (value && propIncrements.includes(prop)) {
+          window.mixpanel.people.increment(prop, value);
+        }
+      });
+
+      // track revenue
+      if (revenue) {
+        window.mixpanel.people.track_charge(revenue);
+      }
+    }
+
+    // track the event
+    let query;
+    if (props.link_query) {
+      // DOM query
+      query = props.link_query;
+      delete props.link_query;
+      window.mixpanel.track_links(query, event, props);
+    } else if (props.form_query) {
+      // DOM query
+      query = props.form_query;
+      delete props.form_query;
+      window.mixpanel.track_forms(query, event, props);
+    } else {
+      window.mixpanel.track(event, props);
+    }
+  }
+
+  /**
+   * @param {*} htElement
+   */
+  group(htElement) {
+    logger.debug('in Mixpanel group');
+    const { userId, groupId, traits } = htElement.message;
+    if (!userId) {
+      logger.debug('===Mixpanel: valid userId is required for group===');
+      return;
+    }
+    if (!groupId) {
+      logger.debug('===Mixpanel: valid groupId is required for group===');
+      return;
+    }
+    if (!this.groupKeySettings || this.groupKeySettings.length === 0) {
+      logger.debug('===Mixpanel: groupIdentifierTraits is required for group===');
+      return;
+    }
+    /**
+     * groupIdentifierTraits: [ {trait: "<trait_value>"}, ... ]
+     */
+    const identifierTraitsList = parseConfigArray(this.groupKeySettings, 'groupKey');
+    if (traits && Object.keys(traits).length > 0) {
+      identifierTraitsList.forEach((trait) => {
+        window.mixpanel.get_group(trait, groupId).set_once(traits);
+      });
+    }
+    identifierTraitsList.forEach((trait) => window.mixpanel.set_group(trait, [groupId]));
+  }
+
+  /**
+   * https://github.com/mixpanel/mixpanel-js/blob/master/doc/readme.io/javascript-full-api-reference.md#mixpanelalias
+   * @param {*} htElement
+   */
+  alias(htElement) {
+    logger.debug('in Mixpanel alias');
+    if (this.identityMergeApi === 'simplified') {
+      logger.debug("===Mixpanel: Alias call is deprecated in 'Simplified ID Merge'===");
+      return;
+    }
+
+    const { previousId, userId } = htElement.message;
+    const newId = userId;
+    if (!previousId) {
+      logger.debug('===Mixpanel: previousId is required for alias call===');
+      return;
+    }
+    if (!newId) {
+      logger.debug('===Mixpanel: userId is required for alias call===');
+      return;
+    }
+
+    if (window.mixpanel.get_distinct_id && window.mixpanel.get_distinct_id() === newId) {
+      logger.debug('===Mixpanel: userId is same as previousId. Skipping alias ===');
+      return;
+    }
+    window.mixpanel.alias(newId, previousId);
+  }
+}
+export default Mixpanel;

package/src/integrations/Mixpanel/constants.js

@@ -0,0 +1,11 @@
+const NAME = 'MP';
+const CNameMapping = {
+  [NAME]: NAME,
+  MIXPANEL: NAME,
+  Mixpanel: NAME,
+  'MIX PANEL': NAME,
+  'Mix panel': NAME,
+  'Mix Panel': NAME,
+};
+
+export { NAME, CNameMapping };

package/src/integrations/Mixpanel/index.js

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

package/src/integrations/Mixpanel/nativeSdkLoader.js

@@ -0,0 +1,71 @@
+import { LOAD_ORIGIN } from '../../utils/ScriptLoader';
+
+function loadNativeSdk(f, b) {
+  (function (f, b) {
+    if (!b.__SV) {
+      var e, g, i, h;
+      window.mixpanel = b;
+      b._i = [];
+      b.init = function (e, f, c) {
+        function g(a, d) {
+          var b = d.split('.');
+          2 == b.length && ((a = a[b[0]]), (d = b[1]));
+          a[d] = function () {
+            a.push([d].concat(Array.prototype.slice.call(arguments, 0)));
+          };
+        }
+        var a = b;
+        'undefined' !== typeof c ? (a = b[c] = []) : (c = 'mixpanel');
+        a.people = a.people || [];
+        a.toString = function (a) {
+          var d = 'mixpanel';
+          'mixpanel' !== c && (d += '.' + c);
+          a || (d += ' (stub)');
+          return d;
+        };
+        a.people.toString = function () {
+          return a.toString(1) + '.people (stub)';
+        };
+        i =
+          'disable time_event track track_pageview track_links track_forms track_with_groups add_group set_group remove_group register register_once alias unregister identify name_tag set_config reset opt_in_tracking opt_out_tracking has_opted_in_tracking has_opted_out_tracking clear_opt_in_out_tracking start_batch_senders people.set people.set_once people.unset people.increment people.append people.union people.track_charge people.clear_charges people.delete_user people.remove'.split(
+            ' ',
+          );
+        for (h = 0; h < i.length; h++) g(a, i[h]);
+        var j = 'set set_once union unset remove delete'.split(' ');
+        a.get_group = function () {
+          function b(c) {
+            d[c] = function () {
+              call2_args = arguments;
+              call2 = [c].concat(Array.prototype.slice.call(call2_args, 0));
+              a.push([e, call2]);
+            };
+          }
+          for (
+            var d = {}, e = ['get_group'].concat(Array.prototype.slice.call(arguments, 0)), c = 0;
+            c < j.length;
+            c++
+          )
+            b(j[c]);
+          return d;
+        };
+        b._i.push([e, f, c]);
+      };
+      b.__SV = 1.2;
+      e = f.createElement('script');
+      e.type = 'text/javascript';
+      e.async = !0;
+      e.setAttribute('data-loader', LOAD_ORIGIN);
+      e.src =
+        'undefined' !== typeof MIXPANEL_CUSTOM_LIB_URL
+          ? MIXPANEL_CUSTOM_LIB_URL
+          : 'file:' === f.location.protocol &&
+            '//cdn.mxpnl.com/libs/mixpanel-2-latest.min.js'.match(/^\/\//)
+          ? 'https://cdn.mxpnl.com/libs/mixpanel-2-latest.min.js'
+          : '//cdn.mxpnl.com/libs/mixpanel-2-latest.min.js';
+      g = f.getElementsByTagName('script')[0];
+      g.parentNode.insertBefore(e, g);
+    }
+  })(document, window.mixpanel || []);
+}
+
+export { loadNativeSdk };

package/src/integrations/Mixpanel/util.js

@@ -0,0 +1,178 @@
+import logger from '../../utils/logUtil';
+import { getDefinedTraits, extractCustomFields } from '../../utils/utils';
+
+const keysToExtract = ['context.traits'];
+const exclusionKeys = [
+  'email',
+  'E-mail',
+  'Email',
+  'phone',
+  'Phone',
+  'name',
+  'Name',
+  'lastName',
+  'lastname',
+  'last_name',
+  'firstName',
+  'firstname',
+  'first_name',
+];
+
+const traitAliases = {
+  created: '$created',
+  email: '$email',
+  firstName: '$first_name',
+  lastName: '$last_name',
+  lastSeen: '$last_seen',
+  name: '$name',
+  username: '$username',
+  phone: '$phone',
+};
+
+const formatTraits = (message) => {
+  const { email, firstName, lastName, phone, name } = getDefinedTraits(message);
+  let outgoingTraits = {
+    email,
+    firstName,
+    lastName,
+    phone,
+    name,
+  };
+  // Extract other K-V property from traits about user custom properties
+  try {
+    outgoingTraits = extractCustomFields(message, outgoingTraits, keysToExtract, exclusionKeys);
+  } catch (err) {
+    logger.debug(`Error occured at extractCustomFields ${err}`);
+  }
+  return outgoingTraits;
+};
+
+const parseConfigArray = (arr, key) => {
+  if (!arr) {
+    logger.debug('===Mixpanel: arr is undefined or null===');
+    return;
+  }
+  // eslint-disable-next-line consistent-return
+  return arr.map((item) => item[key]);
+};
+
+/**
+ * Since Mixpanel doesn't support lists of objects, invert each list of objects to a set of lists of object properties.
+ * Treats list transformation atomically, e.g. will only transform if EVERY item in list is an object
+ *
+ * @api private
+ * @param {Object} props
+ * @example
+ * input: {products: [{sku: 32, revenue: 99}, {sku:2, revenue: 103}]}
+ * output: {products_skus: [32, 2], products_revenues: [99, 103]}
+ */
+const inverseObjectArrays = (input) => {
+  const response = input;
+  Object.keys(input).forEach((key) => {
+    let markToDelete = false;
+    if (Array.isArray(input[key])) {
+      // [{sku: 32, revenue: 99}, {sku:2, revenue: 103}]
+      const tempArray = input[key];
+      tempArray.forEach((obj) => {
+        // operate if object encountered in array
+        if (typeof obj === 'object') {
+          // {sku: 32, revenue: 99}
+          Object.entries(obj).forEach((k) => {
+            const attrKey = `${key}_${k[0]}s`;
+            if (attrKey in response) response[attrKey].push(k[1]);
+            else response[attrKey] = [k[1]];
+          });
+          markToDelete = true;
+        }
+      });
+      if (markToDelete) delete response[key];
+    }
+  });
+  return response;
+};
+
+const extractTraits = (traits, traitAliasesParam) => {
+  const extractedTraits = traits;
+  Object.keys(traitAliasesParam).forEach((key) => {
+    const value = traitAliasesParam[key];
+    extractedTraits[value] = extractedTraits[key];
+    delete extractedTraits[key];
+  });
+  return extractedTraits;
+};
+
+/**
+ * Return union of two arrays
+ *
+ * @param {Array} x
+ * @param {Array} y
+ * @return {Array} res
+ */
+const unionArrays = (x, y) => {
+  const res = new Set();
+  // store items of each array as set entries to avoid duplicates
+  x.forEach((value) => {
+    res.add(value);
+  });
+  y.forEach((value) => {
+    res.add(value);
+  });
+  return [...res];
+};
+
+/**
+ * extend Mixpanel's special trait keys in the given `arr`.
+ * @param {Array} arr
+ * @return {Array}
+ */
+const extendTraits = (arr) => {
+  const keys = [];
+  Object.keys(traitAliases).forEach((key) => {
+    keys.push(key);
+  });
+
+  keys.forEach((key) => {
+    if (arr.indexOf(key) < 0) {
+      arr.push(key);
+    }
+  });
+
+  return arr;
+};
+
+/**
+ * Map Special traits in the given `arr`.
+ * From the TraitAliases for Mixpanel's special props
+ *
+ * @param {Array} arr
+ * @return {Array}
+ */
+const mapTraits = (arr) => {
+  const ret = new Array(arr.length);
+
+  arr.forEach((key) => {
+    if (Object.prototype.hasOwnProperty.call(traitAliases, key)) {
+      ret.push(traitAliases[key]);
+    } else {
+      ret.push(key);
+    }
+  });
+
+  return ret;
+};
+
+const getConsolidatedPageCalls = (config) =>
+  Object.prototype.hasOwnProperty.call(config, 'consolidatedPageCalls')
+    ? config.consolidatedPageCalls
+    : true;
+
+export {
+  mapTraits,
+  unionArrays,
+  extendTraits,
+  formatTraits,
+  extractTraits,
+  parseConfigArray,
+  inverseObjectArrays,
+  getConsolidatedPageCalls,
+};