castled-js-sdk 0.0.1 → 0.0.3

package/src/integrations/Kissmetrics/browser.js

@@ -0,0 +1,254 @@
+/* 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 { getRevenue } from '../../utils/utils';
+import logger from '../../utils/logUtil';
+import { NAME } from './constants';
+import { loadeNativeSdk } from './nativeSdkLoader';
+
+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() {
+    logger.debug('===in init Kissmetrics===');
+    loadeNativeSdk(this.apiKey);
+
+    if (this.isEnvMobile()) {
+      window._kmq.push(['set', { 'Mobile Session': 'Yes' }]);
+    }
+  }
+
+  isLoaded() {
+    return is.object(window.KM);
+  }
+
+  isReady() {
+    return is.object(window.KM);
+  }
+
+  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
+          logger.debug(value.toString());
+          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(htElement) {
+    logger.debug('in KissMetrics identify');
+
+    const { userId, context } = htElement.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(htElement) {
+    logger.debug('in KissMetrics track');
+
+    const { event } = htElement.message;
+    let properties = JSON.parse(JSON.stringify(htElement.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);
+    logger.debug(JSON.stringify(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(htElement) {
+    logger.debug('in KissMetrics page');
+
+    let { properties } = htElement.message;
+    const pageName = htElement.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(htElement) {
+    logger.debug('in KissMetrics alias');
+
+    const { previousId, userId } = htElement.message;
+    window._kmq.push(['alias', userId, previousId]);
+  }
+
+  group(htElement) {
+    logger.debug('in KissMetrics group');
+
+    const { groupId, traits } = htElement.message;
+    const groupTraits = this.prefix('Group', traits);
+    if (groupId) {
+      groupTraits['Group - id'] = groupId;
+    }
+    window._kmq.push(['set', groupTraits]);
+  }
+}
+
+export { Kissmetrics };

package/src/integrations/Kissmetrics/constants.js

@@ -0,0 +1,8 @@
+const NAME = 'KISSMETRICS';
+const CNameMapping = {
+  [NAME]: NAME,
+  Kissmetrics: NAME,
+  kissmetrics: NAME,
+};
+
+export { NAME, CNameMapping };

package/src/integrations/Kissmetrics/index.js

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

package/src/integrations/Kissmetrics/nativeSdkLoader.js

@@ -0,0 +1,23 @@
+import { LOAD_ORIGIN } from '../../utils/ScriptLoader';
+
+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/src/integrations/Klaviyo/browser.js

@@ -0,0 +1,195 @@
+/* eslint-disable class-methods-use-this */
+/* eslint-disable no-underscore-dangle */
+import get from 'get-value';
+import logger from '../../utils/logUtil';
+import ScriptLoader from '../../utils/ScriptLoader';
+import { extractCustomFields, getDefinedTraits } from '../../utils/utils';
+import ecommEventPayload from './util';
+import { isNotEmpty } from '../../utils/commonUtils';
+import { NAME } from './constants';
+
+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() {
+    logger.debug('===in init Klaviyo===');
+    ScriptLoader(
+      'klaviyo-integration',
+      `https://static.klaviyo.com/onsite/js/klaviyo.js?company_id=${this.publicApiKey}`,
+    );
+  }
+
+  isLoaded() {
+    logger.debug('===in isLoaded Klaviyo===');
+
+    return !!(window._learnq && window._learnq.push !== Array.prototype.push);
+  }
+
+  isReady() {
+    logger.debug('===in isReady Klaviyo===');
+
+    return !!(window._learnq && window._learnq.push !== Array.prototype.push);
+  }
+
+  identify(htElement) {
+    const { message } = htElement;
+    if (!(message.context && message.context.traits)) {
+      logger.error('user traits not present');
+      return;
+    }
+
+    const { userId, email, phone, firstName, lastName, city, country } = 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'),
+      $zip: get(message, 'context.traits.zip'),
+    };
+    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.debug(`Error occured at extractCustomFields ${err}`);
+    }
+    window._learnq.push(['identify', payload]);
+  }
+
+  track(htElement) {
+    const { message } = htElement;
+    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(htElement) {
+    const { message } = htElement;
+    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/src/integrations/Klaviyo/constants.js

@@ -0,0 +1,8 @@
+const NAME = 'KLAVIYO';
+const CNameMapping = {
+  [NAME]: NAME,
+  Klaviyo: NAME,
+  klaviyo: NAME,
+};
+
+export { NAME, CNameMapping };

package/src/integrations/Klaviyo/index.js

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

package/src/integrations/Klaviyo/util.js

@@ -0,0 +1,91 @@
+/* eslint-disable no-param-reassign */
+import get from 'get-value';
+import { isNotEmpty, removeUndefinedAndNullValues } from '../../utils/commonUtils';
+
+const categoryKey = 'properties.categories';
+
+const itemsPayload = (item) => {
+  const itemObj = {
+    ProductID: item.product_id,
+    SKU: item.sku,
+    ProductName: item.name,
+    Quantity: item.quantity,
+    ItemPrice: item.price,
+    RowTotal: item.total,
+    ProductURL: item.url,
+    ImageURL: item.image_url,
+    ProductCategories: item.categories,
+  };
+  return itemObj;
+};
+
+/**
+ * Returns items array
+ * @param {*} items
+ * @returns
+ */
+const prepareItemsArray = (items) => {
+  const itemArr = [];
+  items.forEach((element) => {
+    let item = itemsPayload(element);
+    item = removeUndefinedAndNullValues(item);
+    if (isNotEmpty(item)) {
+      itemArr.push(item);
+    }
+  });
+  return itemArr;
+};
+
+const ecommEventPayload = (event, message) => {
+  let payload = {};
+  switch (event) {
+    case 'Viewed Product': {
+      payload.ProductName = get(message, 'properties.name');
+      payload.ProductID = get(message, 'properties.product_id');
+      payload.SKU = get(message, 'properties.sku');
+      payload.ImageURL = get(message, 'properties.image_url');
+      payload.URL = get(message, 'properties.url');
+      payload.Brand = get(message, 'properties.brand');
+      payload.Price = get(message, 'properties.price');
+      payload.CompareAtPrice = get(message, 'properties.compare_at_price');
+      payload.Categories = get(message, categoryKey);
+      break;
+    }
+    case 'Added to Cart': {
+      payload.$value = get(message, 'properties.value');
+      payload.AddedItemProductName = get(message, 'properties.name');
+      payload.AddedItemProductID = get(message, 'properties.product_id');
+      payload.AddedItemSKU = get(message, 'properties.sku');
+      payload.AddedItemImageURL = get(message, 'properties.image_url');
+      payload.AddedItemURL = get(message, 'properties.url');
+      payload.AddedItemPrice = get(message, 'properties.price');
+      payload.AddedItemQuantity = get(message, 'properties.quantity');
+      payload.AddedItemCategories = get(message, categoryKey);
+      payload.ItemNames = get(message, 'properties.item_names');
+      payload.CheckoutURL = get(message, 'properties.checkout_url');
+      if (message.properties.items && Array.isArray(message.properties.items)) {
+        payload.Items = prepareItemsArray(message.properties.items);
+      }
+      break;
+    }
+    case 'Started Checkout': {
+      payload.$event_id = get(message, 'properties.order_id');
+      payload.$value = get(message, 'properties.value');
+      payload.Categories = get(message, categoryKey);
+      payload.CheckoutURL = get(message, 'properties.checkout_url');
+      payload.ItemNames = get(message, 'item_names');
+      if (message.properties.items && Array.isArray(message.properties.items)) {
+        payload.Items = prepareItemsArray(message.properties.items);
+      }
+      break;
+    }
+    default:
+      break;
+  }
+  if (payload) {
+    payload = removeUndefinedAndNullValues(payload);
+  }
+  return payload;
+};
+
+export default ecommEventPayload;

package/src/integrations/LaunchDarkly/browser.js

@@ -0,0 +1,74 @@
+/* eslint-disable class-methods-use-this */
+import get from 'get-value';
+import logger from '../../utils/logUtil';
+import ScriptLoader from '../../utils/ScriptLoader';
+import createUser from './utils';
+import { NAME } from './constants';
+
+class LaunchDarkly {
+  constructor(config, analytics, destinationInfo) {
+    if (analytics.logLevel) {
+      logger.setLogLevel(analytics.logLevel);
+    }
+    this.analytics = analytics;
+    this.name = NAME;
+    this.clientSideId = config.clientSideId;
+    this.anonymousUsersSharedKey = config.anonymousUsersSharedKey;
+    ({
+      shouldApplyDeviceModeTransformation: this.shouldApplyDeviceModeTransformation,
+      propagateEventsUntransformedOnError: this.propagateEventsUntransformedOnError,
+      destinationId: this.destinationId,
+    } = destinationInfo ?? {});
+  }
+
+  init() {
+    logger.debug('===in init LaunchDarkly===');
+    if (!this.clientSideId) {
+      logger.error(
+        `${this.name} :: Unable to initialize destination - clientSideId is missing in config`,
+      );
+      return;
+    }
+    ScriptLoader(null, 'https://unpkg.com/launchdarkly-js-client-sdk@2');
+  }
+
+  isLoaded() {
+    logger.debug('===In isLoaded LaunchDarkly===');
+    return !!window.LDClient;
+  }
+
+  isReady() {
+    logger.debug('===In isReady LaunchDarkly===');
+    return this.isLoaded();
+  }
+
+  identify(htElement) {
+    const { message } = htElement;
+    const anonymousUsersSharedKey =
+      get(message, `integrations.${NAME}.key`) || this.anonymousUsersSharedKey;
+    this.launchDarklyUser = createUser(message, anonymousUsersSharedKey);
+
+    if (window.ldclient) {
+      window.ldclient.identify(this.launchDarklyUser);
+    } else {
+      window.ldclient = window.LDClient.initialize(this.clientSideId, this.launchDarklyUser);
+    }
+  }
+
+  track(htElement) {
+    const { event, properties } = htElement.message;
+    if (window.ldclient) {
+      window.ldclient.track(event, properties);
+    } else logger.error('=== In LaunchDarkly, track is not supported before identify ===');
+  }
+
+  alias(htElement) {
+    const { message } = htElement;
+    const newUser = { key: message.userId };
+
+    if (window.ldclient) {
+      window.ldclient.alias(newUser, this.launchDarklyUser);
+    } else logger.error('=== In LaunchDarkly, alias is not supported before identify ===');
+  }
+}
+export default LaunchDarkly;

package/src/integrations/LaunchDarkly/constants.js

@@ -0,0 +1,11 @@
+const NAME = 'LAUNCHDARKLY';
+const CNameMapping = {
+  [NAME]: NAME,
+  LaunchDarkly: NAME,
+  Launch_Darkly: NAME,
+  'Launch Darkly': NAME,
+  launchDarkly: NAME,
+  'launch darkly': NAME,
+};
+
+export { NAME, CNameMapping };

package/src/integrations/LaunchDarkly/index.js

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