castled-js-sdk 0.0.1 → 0.0.2

package/src/integrations/Drip/browser.js

@@ -0,0 +1,169 @@
+/* eslint-disable class-methods-use-this */
+/* eslint-disable no-underscore-dangle */
+import get from 'get-value';
+import logger from '../../utils/logUtil';
+import { isDefinedAndNotNull, removeUndefinedAndNullValues } from '../../utils/commonUtils';
+import { getDestinationExternalID } from './utils';
+
+import { extractCustomFields } from '../../utils/utils';
+import { NAME } from './constants';
+import { loadNativeSdk } from './nativeSdkLoader';
+
+class Drip {
+  constructor(config, analytics, destinationInfo) {
+    if (analytics.logLevel) {
+      logger.setLogLevel(analytics.logLevel);
+    }
+    this.analytics = analytics;
+    this.accountId = config.accountId;
+    this.campaignId = config.campaignId;
+    this.name = NAME;
+    this.exclusionFields = [
+      'email',
+      'new_email',
+      'newEmail',
+      'tags',
+      'remove_tags',
+      'removeTags',
+      'prospect',
+      'eu_consent',
+      'euConsent',
+      'eu_consent_message',
+      'euConsentMessage',
+    ];
+    ({
+      shouldApplyDeviceModeTransformation: this.shouldApplyDeviceModeTransformation,
+      propagateEventsUntransformedOnError: this.propagateEventsUntransformedOnError,
+      destinationId: this.destinationId,
+    } = destinationInfo ?? {});
+  }
+
+  init() {
+    logger.debug('===In init Drip===');
+
+    loadNativeSdk(this.accountId);
+  }
+
+  isLoaded() {
+    logger.debug('===In isLoaded Drip===');
+    return !!window._dcq;
+  }
+
+  isReady() {
+    logger.debug('===In isReady Drip===');
+    return !!window._dcq;
+  }
+
+  identify(htElement) {
+    logger.debug('===In Drip identify===');
+
+    const { message } = htElement;
+    const { context } = message;
+    if (!context?.traits) {
+      logger.error('user context or traits not present');
+      return;
+    }
+
+    const email = get(message, 'context.traits.email');
+    if (!email) {
+      logger.error('email is required for identify');
+      return;
+    }
+
+    let euConsent = get(message, 'context.traits.euConsent');
+    if (
+      euConsent &&
+      !(euConsent.toLowerCase() === 'granted' || euConsent.toLowerCase() === 'denied')
+    ) {
+      euConsent = null;
+    }
+
+    let payload = {
+      email,
+      new_email: get(message, 'context.traits.newEmail'),
+      user_id: get(message, 'userId') || get(message, 'anonymousId'),
+      tags: get(message, 'context.traits.tags'),
+      remove_tags: get(message, 'context.traits.removeTags'),
+      prospect: get(message, 'context.traits.prospect'),
+      eu_consent: euConsent,
+      eu_consent_message: get(message, 'context.traits.euConsentMessage'),
+    };
+
+    let extraFields = {};
+    try {
+      extraFields = extractCustomFields(
+        message,
+        extraFields,
+        ['context.traits'],
+        this.exclusionFields,
+      );
+    } catch (err) {
+      logger.debug(`Error occured at extractCustomFields ${err}`);
+    }
+
+    payload = {
+      ...payload,
+      ...extraFields,
+    };
+
+    payload = removeUndefinedAndNullValues(payload);
+    window._dcq.push(['identify', payload]);
+
+    const campaignId = getDestinationExternalID(message, 'dripCampaignId') || this.campaignId;
+
+    if (campaignId) {
+      const fields = payload;
+      delete fields.campaignId;
+      delete fields.doubleOptin;
+      delete fields.tags;
+
+      let campaignPayload = {
+        fields,
+        campaign_id: campaignId,
+        double_optin: get(message, 'context.traits.doubleOptin'),
+      };
+      campaignPayload = removeUndefinedAndNullValues(campaignPayload);
+      window._dcq.push(['subscribe', campaignPayload]);
+    }
+  }
+
+  track(htElement) {
+    logger.debug('===In Drip track===');
+
+    const { message } = htElement;
+    const { event } = message;
+
+    if (!event) {
+      logger.error('Event name not present');
+      return;
+    }
+
+    const email = get(message, 'properties.email') || get(message, 'context.traits.email');
+    if (!email) {
+      logger.error('email is required for track');
+      return;
+    }
+
+    let payload = get(message, 'properties');
+
+    if (isDefinedAndNotNull(payload.revenue)) {
+      const cents = Math.round(payload.revenue * 100);
+      if (cents) {
+        payload.value = cents;
+      }
+
+      delete payload.revenue;
+    }
+
+    payload = {
+      ...payload,
+      email,
+      occurred_at: get(message, 'properties.occurred_at') || get(message, 'originalTimestamp'),
+    };
+
+    payload = removeUndefinedAndNullValues(payload);
+    window._dcq.push(['track', event, payload]);
+  }
+}
+
+export default Drip;

package/src/integrations/Drip/constants.js

@@ -0,0 +1,8 @@
+const NAME = 'DRIP';
+const CNameMapping = {
+  [NAME]: NAME,
+  Drip: NAME,
+  drip: NAME,
+};
+
+export { NAME, CNameMapping };

package/src/integrations/Drip/index.js

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

package/src/integrations/Drip/nativeSdkLoader.js

@@ -0,0 +1,10 @@
+import ScriptLoader, { LOAD_ORIGIN } from '../../utils/ScriptLoader';
+
+function loadNativeSdk(accountId) {
+  window._dcq = window._dcq || [];
+  window._dcs = window._dcs || {};
+  window._dcs.account = accountId;
+  ScriptLoader('drip', `//tag.getdrip.com/${window._dcs.account}.js`);
+}
+
+export { loadNativeSdk };

package/src/integrations/Drip/utils.js

@@ -0,0 +1,29 @@
+// 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?.externalId) {
+    externalIdArray = message.context.externalId;
+  }
+  if (externalIdArray) {
+    externalIdArray.forEach((extIdObj) => {
+      if (extIdObj.type === type) {
+        destinationExternalId = extIdObj.id;
+      }
+    });
+  }
+  return destinationExternalId;
+}
+
+export { getDestinationExternalID };

package/src/integrations/Engage/browser.js

@@ -0,0 +1,124 @@
+/* eslint-disable class-methods-use-this */
+import logger from '../../utils/logUtil';
+import { NAME } from './constants';
+import { refinePayload, getDestinationExternalID } from './utils';
+import { getDefinedTraits } from '../../utils/utils';
+import { removeUndefinedAndNullValues } from '../../utils/commonUtils';
+import { loadNativeSdk } from './nativeSdkLoader';
+
+class Engage {
+  constructor(config, analytics, destinationInfo) {
+    if (analytics.logLevel) {
+      logger.setLogLevel(analytics.logLevel);
+    }
+    this.analytics = analytics;
+    this.api_key = config.publicKey;
+    this.api_secret = config.privateKey;
+    this.name = NAME;
+    this.listsIds = config.listsIds;
+    ({
+      shouldApplyDeviceModeTransformation: this.shouldApplyDeviceModeTransformation,
+      propagateEventsUntransformedOnError: this.propagateEventsUntransformedOnError,
+      destinationId: this.destinationId,
+    } = destinationInfo ?? {});
+  }
+
+  init() {
+    logger.debug('===In init Engage===');
+
+    loadNativeSdk();
+
+    window.Engage.init({
+      key: this.api_key,
+      secret: this.api_secret,
+    });
+  }
+
+  isLoaded() {
+    logger.debug('===In isLoaded Engage===');
+
+    return !!window.Engage;
+  }
+
+  isReady() {
+    logger.debug('===In isReady Engage===');
+    return !!window.Engage;
+  }
+
+  identify(htElement) {
+    logger.debug('===In Engage identify');
+
+    const { message } = htElement;
+    const engageId = getDestinationExternalID(message, 'engageId');
+    const { userIdOnly, firstName, phone, lastName } = getDefinedTraits(message);
+    if (!engageId && !userIdOnly) {
+      logger.error('externalId or userId is required for Identify call.');
+      return;
+    }
+    const { originalTimestamp, context } = message;
+
+    const { traits } = context;
+    let payload = refinePayload(traits, true);
+
+    payload.number = phone;
+    payload.last_name = lastName;
+    payload.first_name = firstName;
+    payload.created_at = originalTimestamp;
+    payload = removeUndefinedAndNullValues(payload);
+    payload.id = engageId || userIdOnly;
+    window.Engage.identify(payload);
+  }
+
+  track(htElement) {
+    logger.debug('===In Engage track===');
+    const { message } = htElement;
+    const { event, properties, originalTimestamp } = message;
+    let engageId = getDestinationExternalID(message, 'engageId');
+    if (!engageId) {
+      const { userIdOnly } = getDefinedTraits(message);
+      engageId = userIdOnly || null;
+    }
+    if (!engageId) {
+      logger.error('externalId or userId is required for track call.');
+      return;
+    }
+    if (!event) {
+      logger.error('[ Engage ]:: Event name not present');
+      return;
+    }
+    let payload = refinePayload(properties);
+    payload = removeUndefinedAndNullValues(payload);
+    window.Engage.track(engageId, {
+      event,
+      timestamp: originalTimestamp,
+      properties: payload,
+    });
+  }
+
+  page(htElement) {
+    logger.debug('===In Engage page===');
+    const { message } = htElement;
+    const { name, properties, originalTimestamp, category } = message;
+    let engageId = getDestinationExternalID(message, 'engageId');
+    if (!engageId) {
+      const { userIdOnly } = getDefinedTraits(message);
+      engageId = userIdOnly || null;
+    }
+    if (!engageId) {
+      logger.error('externalId or userId is required for page call.');
+      return;
+    }
+    let payload = refinePayload(properties);
+    payload = removeUndefinedAndNullValues(payload);
+    const pageCat = category ? `${category} ` : '';
+    const pageName = name ? `${name} ` : '';
+    const eventName = `Viewed ${pageCat}${pageName}Page`;
+    window.Engage.track(engageId, {
+      event: eventName,
+      timestamp: originalTimestamp,
+      properties: payload,
+    });
+  }
+}
+
+export default Engage;

package/src/integrations/Engage/constants.js

@@ -0,0 +1,16 @@
+const NAME = 'ENGAGE';
+const CNameMapping = {
+  [NAME]: NAME,
+  Engage: NAME,
+  engage: NAME,
+};
+const identifyExcludeFields = [
+  'firstName',
+  'firstname',
+  'first_name',
+  'lastName',
+  'lastname',
+  'last_name',
+  'phone',
+];
+export { NAME, CNameMapping, identifyExcludeFields };

package/src/integrations/Engage/index.js

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

package/src/integrations/Engage/nativeSdkLoader.js

@@ -0,0 +1,25 @@
+import { LOAD_ORIGIN } from '../../utils/ScriptLoader';
+
+function loadNativeSdk() {
+  !(function (n) {
+    if (!window.Engage) {
+      (window[n] = window[n] || {}),
+        (window[n].queue = window[n].queue || []),
+        (window.Engage = window.Engage || {});
+      for (var e = ['init', 'identify', 'addAttribute', 'track'], i = 0; i < e.length; i++)
+        window.Engage[e[i]] = w(e[i]);
+      var d = document.createElement('script');
+      (d.src = '//d2969mkc0xw38n.cloudfront.net/next/engage.min.js'),
+        d.setAttribute('data-loader', LOAD_ORIGIN),
+        (d.async = !0),
+        document.head.appendChild(d);
+    }
+    function w(e) {
+      return function () {
+        window[n].queue.push([e].concat([].slice.call(arguments)));
+      };
+    }
+  })('engage');
+}
+
+export { loadNativeSdk };

package/src/integrations/Engage/utils.js

@@ -0,0 +1,69 @@
+import { identifyExcludeFields } from './constants';
+
+// 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?.externalId) {
+    externalIdArray = message.context.externalId;
+  }
+  if (externalIdArray) {
+    externalIdArray.forEach((extIdObj) => {
+      if (extIdObj.type === type) {
+        destinationExternalId = extIdObj.id;
+      }
+    });
+  }
+  return destinationExternalId;
+}
+
+/**
+ * Flatens the input payload
+ * @param {*} payload Input payload that needs to be flattened
+ * @returns the flattened payload at all levels
+ */
+const flattenPayload = (payload) => {
+  const flattenedPayload = {};
+  if (payload) {
+    Object.keys(payload).forEach((v) => {
+      if (typeof payload[v] === 'object' && !Array.isArray(payload[v])) {
+        const temp = flattenPayload(payload[v]);
+        Object.keys(temp).forEach((i) => {
+          flattenedPayload[i] = temp[i];
+        });
+      } else {
+        flattenedPayload[v] = payload[v];
+      }
+    });
+  }
+  return flattenedPayload;
+};
+
+/**
+ * @param {*} attributes payload that needs modification and transistion to payload
+ * @param {*} specificGenericFields fields that should be overlooked when adding fields to payload
+ * @returns payload
+ */
+const refinePayload = (attributes, identifyFlag = false) => {
+  const flattenedPayload = flattenPayload(attributes);
+  const payload = {};
+  Object.keys(flattenedPayload).forEach((v) => {
+    if (!identifyFlag || !identifyExcludeFields.includes(v)) {
+      payload[v] = flattenedPayload[v];
+    }
+  });
+  return payload;
+};
+
+export { getDestinationExternalID, refinePayload };