castled-js-sdk 0.0.1 → 0.0.2

package/src/integrations/Iterable/browser.js

@@ -0,0 +1,185 @@
+/* eslint-disable class-methods-use-this */
+import get from 'get-value';
+import Logger from '../../utils/logger';
+import {
+  formPurchaseEventPayload,
+  existsInMapping,
+  extractJWT,
+  prepareInAppMessagesPayload,
+} from './utils';
+import { isNotEmpty, removeUndefinedAndNullValues } from '../../utils/commonUtils';
+import { NAME } from './constants';
+import ScriptLoader from '../../utils/ScriptLoader';
+
+const logger = new Logger(NAME);
+const iterableWebSdk = '@iterable/web-sdk';
+class Iterable {
+  constructor(config, analytics, destinationInfo) {
+    if (analytics.logLevel) {
+      logger.setLogLevel(analytics.logLevel);
+    }
+    this.apiKey = config.apiKey;
+    this.initialisationIdentifier = config.initialisationIdentifier;
+    this.fetchAppEvents = undefined;
+    this.name = NAME;
+    this.analytics = analytics;
+    if (analytics.logLevel) logger.setLogLevel(analytics.logLevel);
+    this.getInAppEventMapping = config.getInAppEventMapping;
+    this.purchaseEventMapping = config.purchaseEventMapping;
+
+    this.sendTrackForInapp = config.sendTrackForInapp;
+    this.animationDuration = config.animationDuration;
+    this.displayInterval = config.displayInterval;
+    this.onOpenScreenReaderMessage = config.onOpenScreenReaderMessage;
+    this.onOpenNodeToTakeFocus = config.onOpenNodeToTakeFocus;
+    this.packageName = config.packageName;
+    this.rightOffset = config.rightOffset;
+    this.topOffset = config.topOffset;
+    this.bottomOffset = config.bottomOffset;
+    this.handleLinks = config.handleLinks;
+
+    this.closeButtonColor = config.closeButtonColor;
+    this.closeButtonSize = config.closeButtonSize;
+    this.closeButtonColorTopOffset = config.closeButtonColorTopOffset;
+    this.closeButtonColorSideOffset = config.closeButtonColorSideOffset;
+    this.iconPath = config.iconPath;
+    this.isRequiredToDismissMessage = config.isRequiredToDismissMessage;
+    this.closeButtonPosition = config.closeButtonPosition;
+
+    ({
+      shouldApplyDeviceModeTransformation: this.shouldApplyDeviceModeTransformation,
+      propagateEventsUntransformedOnError: this.propagateEventsUntransformedOnError,
+      destinationId: this.destinationId,
+    } = destinationInfo ?? {});
+  }
+
+  init() {
+    logger.debug('===In init Iterable===');
+    ScriptLoader('iterable-web', 'https://unpkg.com/@iterable/web-sdk/index.js');
+  }
+
+  isLoaded() {
+    logger.debug('===In isLoaded Iterable===');
+    return !!window[iterableWebSdk];
+  }
+
+  isReady() {
+    logger.debug('===In isReady Iterable===');
+    return !!window[iterableWebSdk];
+  }
+
+  identify(htElement) {
+    logger.debug('===In identify Iterable');
+
+    const { message } = htElement;
+    const { integrations, traits, context, userId } = message;
+    const userEmail = traits?.email || context?.traits?.email;
+
+    const jwtToken = extractJWT(integrations);
+
+    if (!jwtToken) {
+      logger.error('The JWT token was not passed, The SDK could not be initialised');
+      return;
+    }
+
+    // Initialize the iterable SDK with the proper apiKey and the passed JWT
+    const wd = window[iterableWebSdk].initialize(this.apiKey, extractJWT);
+
+    if (this.initialisationIdentifier === 'userId') {
+      wd.setUserID(userId).then(() => {
+        logger.debug('userId set');
+      });
+    } else {
+      wd.setEmail(userEmail).then(() => {
+        logger.debug('userEmail set');
+      });
+    }
+    /* Available pop-up push notification settings configurable from UI
+        this.animationDuration,
+        this.displayInterval,
+        this.onOpenScreenReaderMessage,
+        this.onOpenNodeToTakeFocus,
+        this.packageName,
+        this.rightOffset,
+        this.topOffset,
+        this.bottomOffset,
+        this.handleLinks,
+        this.closeButtonColor,
+        this.closeButtonSize,
+        this.closeButtonColorTopOffset,
+        this.closeButtonColorSideOffset,
+        this.iconPath,
+        this.isRequiredToDismissMessage,
+        this.closeButtonPosition,
+    */
+    // Reference : https://github.com/iterable/iterable-web-sdk
+    const getInAppMessagesPayload = removeUndefinedAndNullValues(prepareInAppMessagesPayload(this));
+
+    const { request } = window[iterableWebSdk].getInAppMessages(getInAppMessagesPayload, {
+      display: 'immediate',
+    });
+    // fetchAppEvents is a class function now available throughout
+    // we will trigger getInAppMessages when event name matches from the ui mapping in config.
+    this.fetchAppEvents = request;
+  }
+
+  track(htElement) {
+    logger.debug('===In track Iterable===');
+
+    const { message } = htElement;
+    const { event, properties } = message;
+    const eventPayload = removeUndefinedAndNullValues(properties);
+    const userEmail = get(message, 'context.traits.email');
+    const userId = get(message, 'userId');
+    if (!event) {
+      logger.error('Event name not present');
+      return;
+    }
+    if (
+      isNotEmpty(this.getInAppEventMapping) &&
+      existsInMapping(this.getInAppEventMapping, event)
+    ) {
+      this.fetchAppEvents();
+      // send a track call for getinappMessages if option enabled in config
+      if (this.sendTrackForInapp) {
+        window[iterableWebSdk]
+          .track({
+            email: userEmail,
+            userId,
+            eventName: 'Track getInAppMessages',
+            dataFields: eventPayload,
+          })
+          .then(logger.debug('Web in-app push triggered'));
+      }
+    } else if (
+      isNotEmpty(this.purchaseEventMapping) &&
+      existsInMapping(this.purchaseEventMapping, event)
+    ) {
+      // purchase events
+      const purchaseEventPayload = formPurchaseEventPayload(message);
+      window[iterableWebSdk].trackPurchase(purchaseEventPayload);
+    } else {
+      // custom events if event is not mapped
+      /* fields available for custom track event
+        {
+            "email": "string",
+            "userId": "string",
+            "eventName": "string",
+            "id": "string",
+            "createdAt": 0,
+            "dataFields": {},
+            "campaignId": 0,
+            "templateId": 0
+        }
+        */
+      // Either email or userId must be passed in to identify the user.
+      // If both are passed in, email takes precedence.
+      logger.debug(`The event ${event} is not mapped in the dashboard, firing a custom event`);
+      window[iterableWebSdk]
+        .track({ email: userEmail, userId, eventName: event, dataFields: eventPayload })
+        .then(logger.debug('Track a custom event.'));
+    }
+  }
+}
+
+export default Iterable;

package/src/integrations/Iterable/constants.js

@@ -0,0 +1,8 @@
+const NAME = 'ITERABLE';
+const CNameMapping = {
+  [NAME]: NAME,
+  Iterable: NAME,
+  iterable: NAME,
+};
+
+export { NAME, CNameMapping };

package/src/integrations/Iterable/index.js

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

package/src/integrations/Iterable/utils.js

@@ -0,0 +1,111 @@
+import { getDataFromSource } from '../../utils/utils';
+import { isDefinedAndNotNull } from '../../utils/commonUtils';
+
+const ITEMS_MAPPING = [
+  { src: 'product_id', dest: 'id' },
+  { src: 'sku', dest: 'sku' },
+  { src: 'name', dest: 'name' },
+  { src: 'price', dest: 'price' },
+  { src: 'quantity', dest: 'quantity' },
+  { src: 'image_url', dest: 'imageUrl' },
+  { src: 'url', dest: 'url' },
+];
+
+function getMappingObject(properties, mappings) {
+  let itemsObject = {};
+  mappings.forEach((mapping) => {
+    itemsObject = {
+      ...getDataFromSource(mapping.src, mapping.dest, properties),
+      ...itemsObject,
+    };
+  });
+  return itemsObject;
+}
+
+function formPurchaseEventPayload(message) {
+  const purchaseEventPayload = {};
+  const { products, order_id: orderId, checkout_id: checkoutId, total } = message.properties;
+  purchaseEventPayload.id = orderId || checkoutId;
+  purchaseEventPayload.total = total;
+  purchaseEventPayload.items = [];
+  const lineItems = [];
+  if (products) {
+    products.forEach((p) => {
+      const product = getMappingObject(p, ITEMS_MAPPING);
+      lineItems.push(product);
+    });
+  } else {
+    const {
+      product_id: productId,
+      sku,
+      price,
+      quantity,
+      image_url: imageUrl,
+      url,
+      name,
+    } = message.properties;
+    // if product related info is on properties root
+    const product = {
+      url,
+      sku,
+      name,
+      price,
+      quantity,
+      imageUrl,
+      id: productId,
+    };
+    lineItems.push(product);
+  }
+  purchaseEventPayload.items = lineItems;
+  return purchaseEventPayload;
+}
+
+function existsInMapping(mappedEvents, event) {
+  let mapped = false;
+  mappedEvents.forEach((e) => {
+    if (e.eventName.toLowerCase() === event.toLowerCase()) mapped = true;
+  });
+  return mapped;
+}
+
+/**
+ * Returns jwt token
+ * @param {*} integrations
+ * @returns
+ */
+const extractJWT = (integrations) => {
+  if (integrations?.ITERABLE) {
+    const { jwt_token: jwtToken } = integrations.ITERABLE;
+    return isDefinedAndNotNull(jwtToken) ? jwtToken : undefined;
+  }
+  return undefined;
+};
+
+/**
+ * Returns inappmessages payload
+ * @param {*} config
+ * @returns
+ */
+const prepareInAppMessagesPayload = (config) => ({
+  count: 20,
+  animationDuration: Number(config.animationDuration) || 400,
+  displayInterval: Number(config.displayInterval) || 30000,
+  onOpenScreenReaderMessage: config.onOpenScreenReaderMessage,
+  onOpenNodeToTakeFocus: config.onOpenNodeToTakeFocus,
+  packageName: config.packageName,
+  rightOffset: config.rightOffset,
+  topOffset: config.topOffset,
+  bottomOffset: config.bottomOffset,
+  handleLinks: config.handleLinks,
+  closeButton: {
+    color: config.closeButtonColor || 'red',
+    size: config.closeButtonSize || '16px',
+    topOffset: config.closeButtonColorTopOffset || '4%',
+    sideOffset: config.closeButtonColorSideOffset || '4%',
+    iconPath: config.iconPath,
+    isRequiredToDismissMessage: config.isRequiredToDismissMessage,
+    position: config.closeButtonPosition || 'top-right',
+  },
+});
+
+export { formPurchaseEventPayload, existsInMapping, extractJWT, prepareInAppMessagesPayload };

package/src/integrations/June/browser.js

@@ -0,0 +1,98 @@
+/* eslint-disable class-methods-use-this */
+/* eslint-disable no-underscore-dangle */
+import get from 'get-value';
+import logger from '../../utils/logUtil';
+import { NAME } from './constants';
+import ScriptLoader from '../../utils/ScriptLoader';
+import { getDestinationExternalID } from '../../utils/commonUtils';
+
+class June {
+  constructor(config, analytics, destinationInfo) {
+    if (analytics.logLevel) {
+      logger.setLogLevel(analytics.logLevel);
+    }
+    this.analytics = analytics;
+    this.name = NAME;
+    this.apiKey = config.apiKey;
+    ({
+      shouldApplyDeviceModeTransformation: this.shouldApplyDeviceModeTransformation,
+      propagateEventsUntransformedOnError: this.propagateEventsUntransformedOnError,
+      destinationId: this.destinationId,
+    } = destinationInfo ?? {});
+  }
+
+  loadScript() {
+    window.analytics = {};
+    ScriptLoader(
+      'june-integration',
+      'https://unpkg.com/@june-so/analytics-next/dist/umd/standalone.js',
+    );
+    window.analytics._writeKey = this.apiKey;
+  }
+
+  init() {
+    logger.debug('===In init June===');
+    this.loadScript();
+  }
+
+  isLoaded() {
+    logger.debug('===In isLoaded June===');
+    return !!window.analytics && typeof window.analytics === 'object';
+  }
+
+  isReady() {
+    logger.debug('===In isReady June===');
+    return !!window.analytics && typeof window.analytics === 'object';
+  }
+
+  page(htElement) {
+    logger.debug('===In June page===');
+    const { name, properties } = htElement.message;
+    window.analytics.page(name, properties);
+  }
+
+  identify(htElement) {
+    logger.debug('===In June identify===');
+    const { message } = htElement;
+    const userId =
+      get(message, 'userId') ||
+      get(message, 'context.traits.userId') ||
+      get(message, 'context.traits.Id');
+    if (!userId) {
+      logger.error('userId is required for an identify call');
+      return;
+    }
+    const traits = get(message, 'context.traits');
+    window.analytics.identify(userId, traits);
+  }
+
+  track(htElement) {
+    logger.debug('===In June track===');
+    let groupId;
+    const { message } = htElement;
+    const externalGroupId = getDestinationExternalID(message, 'juneGroupId');
+    const { event } = message;
+    let { properties } = message;
+    ({ groupId, ...properties } = properties || {});
+    groupId = externalGroupId || groupId;
+
+    if (groupId) {
+      window.analytics.track(event, properties, { groupId });
+    } else {
+      window.analytics.track(event, properties);
+    }
+  }
+
+  group(htElement) {
+    logger.debug('===In June group===');
+    const { groupId } = htElement.message;
+    if (!groupId) {
+      logger.error('groupId is required for group call');
+      return;
+    }
+    const { traits } = htElement.message;
+    window.analytics.group(groupId, traits);
+  }
+}
+
+export default June;

package/src/integrations/June/constants.js

@@ -0,0 +1,8 @@
+const NAME = 'JUNE';
+const CNameMapping = {
+  [NAME]: NAME,
+  June: NAME,
+  june: NAME,
+};
+
+export { NAME, CNameMapping };

package/src/integrations/June/index.js

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

package/src/integrations/Keen/browser.js

@@ -0,0 +1,153 @@
+/* eslint-disable no-template-curly-in-string */
+/* eslint-disable no-use-before-define */
+import logger from '../../utils/logUtil';
+import ScriptLoader from '../../utils/ScriptLoader';
+import { NAME } from './constants';
+
+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() {
+    logger.debug('===in init Keen===');
+    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() {
+    logger.debug('in Keen isLoaded');
+    return !!(this.client != null);
+  }
+
+  isReady() {
+    return !!(this.client != null);
+  }
+
+  identify(htElement) {
+    logger.debug('in Keen identify');
+
+    const { message } = htElement;
+    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(htElement) {
+    logger.debug('in Keen track');
+
+    const { event } = htElement.message;
+    let { properties } = htElement.message;
+    properties = this.getAddOn(properties);
+    this.client.recordEvent(event, properties);
+  }
+
+  page(htElement) {
+    logger.debug('in Keen 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`;
+    }
+    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 { Keen };

package/src/integrations/Keen/constants.js

@@ -0,0 +1,10 @@
+const NAME = 'KEEN';
+const CNameMapping = {
+  [NAME]: NAME,
+  Keen: NAME,
+  'Keen.io': NAME,
+  keen: NAME,
+  'keen.io': NAME,
+};
+
+export { NAME, CNameMapping };

package/src/integrations/Keen/index.js

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