iureiure 1.0.0

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

@@ -0,0 +1,36 @@
+import { LOAD_ORIGIN } from '@rudderstack/analytics-js-common/v1.1/utils/constants';
+
+function loadNativeSdk(clientKey) {
+  (function () {
+    window.sib = {
+      equeue: [],
+      client_key: clientKey,
+    };
+    window.sendinblue = {};
+    for (var j = ['track', 'identify', 'trackLink', 'page'], i = 0; i < j.length; i++) {
+      (function (k) {
+        window.sendinblue[k] = function () {
+          var arg = Array.prototype.slice.call(arguments);
+          (
+            window.sib[k] ||
+            function () {
+              var t = {};
+              t[k] = arg;
+              window.sib.equeue.push(t);
+            }
+          )(arg[0], arg[1], arg[2], arg[3]);
+        };
+      })(j[i]);
+    }
+    var n = document.createElement('script'),
+      i = document.getElementsByTagName('script')[0];
+    (n.type = 'text/javascript'),
+      (n.id = 'sendinblue-js'),
+      (n.async = !0),
+      (n.src = 'https://sibautomation.com/sa.js?key=' + clientKey),
+      n.setAttribute('data-loader', LOAD_ORIGIN),
+      i.parentNode.insertBefore(n, i);
+  })();
+}
+
+export { loadNativeSdk };

package/packages/analytics-js-integrations/src/integrations/Sendinblue/utils.js

@@ -0,0 +1,129 @@
+import {
+  NAME,
+  DISPLAY_NAME,
+  excludeReservedTraits,
+  excludePageProperties,
+} from '@rudderstack/analytics-js-common/constants/integrations/Sendinblue/constants';
+import { getDefinedTraits } from '../../utils/utils';
+import {
+  getHashFromArray,
+  removeUndefinedAndNullValues,
+  isNotEmpty,
+} from '../../utils/commonUtils';
+
+/**
+ * Get destination specific options from integrations options
+ * By default, it will return options for the destination using its display name
+ * If display name is not present, it will return options for the destination using its name
+ * The fallback is only for backward compatibility with SDK versions < v1.1
+ * @param {object} integrationsOptions Integrations options object
+ * @returns destination specific options
+ */
+const getDestinationOptions = integrationsOptions =>
+  integrationsOptions && (integrationsOptions[DISPLAY_NAME] || integrationsOptions[NAME]);
+
+// FIRSTNAME, LASTNAME, SMS are the default created contact attributes in sendinblue
+const prepareDefaultContactAttributes = message => {
+  const { firstName, lastName, phone } = getDefinedTraits(message);
+  return { FIRSTNAME: firstName, LASTNAME: lastName, SMS: phone };
+};
+
+/**
+ * Function to remove duplicate traits from user traits
+ * @param {*} userTraits {"FIRSTNAME":"John","firstname":"John","location":"San Francisco","LOCATIOn":"San Francisco"}
+ * @param {*} attributeMap {"area_code":"AREA","location":"LOCATION"}
+ * @returns // {"FIRSTNAME":"John","LOCATIOn":"San Francisco"}
+ */
+const refineUserTraits = (userTraits, attributeMap) => {
+  const refinedTraits = userTraits;
+  Object.keys(userTraits).forEach(key => {
+    if (
+      excludeReservedTraits.includes(key) ||
+      Object.prototype.hasOwnProperty.call(attributeMap, key)
+    ) {
+      delete refinedTraits[key];
+    }
+  });
+  return refinedTraits;
+};
+
+/**
+ * Function to prepare user traits for identify and track call.
+ * User traits is a combination of some reserved traits and transformation of reset of the traits with the help of contact attribute mapping defined in webapp.
+ * Reserved traits -> first name, last name, phone, email
+ * Contact attribute mapping -> [{"from":"area_code","to":"AREA"},{"from":"location","to":"LOCATION"}]
+ * @param {*} message
+ * @param {*} contactAttributeMapping traits to Sendinblue contact attribute mapping defined in webapp
+ * @returns
+ */
+const prepareUserTraits = (message, contactAttributeMapping) => {
+  const { traits } = message.context;
+  const reservedTraits = prepareDefaultContactAttributes(message);
+
+  // convert destination.Config.contactAttributeMapping to hashMap
+  const attributeMap = getHashFromArray(contactAttributeMapping, 'from', 'to', false);
+
+  let userTraits = traits;
+  Object.keys(attributeMap).forEach(key => {
+    const traitValue = traits[key];
+    if (traitValue) {
+      userTraits[attributeMap[key]] = traitValue;
+    }
+  });
+
+  userTraits = { ...reservedTraits, ...userTraits };
+  userTraits = refineUserTraits(userTraits, attributeMap);
+
+  // eslint-disable-next-line consistent-return
+  return removeUndefinedAndNullValues(userTraits);
+};
+
+// Prepare track event data. Event data consists `id` and `data`.
+// id -> from integration object or messageId
+// data -> properties
+const prepareTrackEventData = message => {
+  const { properties, integrations, messageId } = message;
+  let eventData = {};
+  if (isNotEmpty(properties)) {
+    let id;
+    const sendInBlueIntgConfig = getDestinationOptions(integrations);
+    if (sendInBlueIntgConfig) {
+      const key = sendInBlueIntgConfig.propertiesIdKey;
+      if (key) {
+        id = properties[key];
+      }
+    }
+
+    id = id || messageId;
+    eventData = { id, data: removeUndefinedAndNullValues(properties) };
+  }
+  return eventData;
+};
+
+const refinePageProperties = properties => {
+  const refinedProperties = properties;
+  excludePageProperties.forEach(key => delete refinedProperties[key]);
+  return refinedProperties;
+};
+
+const preparePagePayload = message => {
+  const { properties, context } = message;
+  const { page } = context;
+
+  const title = properties?.title || page?.title;
+  const url = properties?.url || page?.url;
+  const path = properties?.path || page?.path;
+  const referrer = properties?.referrer || page?.referrer;
+
+  const refinedProperties = refinePageProperties(properties);
+  const payload = {
+    ma_title: title,
+    ma_url: url,
+    ma_path: path,
+    ma_referrer: referrer,
+    ...refinedProperties,
+  };
+  return removeUndefinedAndNullValues(payload);
+};
+
+export { prepareUserTraits, prepareTrackEventData, preparePagePayload, getDestinationOptions };

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

@@ -0,0 +1,120 @@
+/* eslint-disable class-methods-use-this */
+import get from 'get-value';
+import {
+  NAME,
+  DISPLAY_NAME,
+} from '@rudderstack/analytics-js-common/constants/integrations/Sentry/constants';
+import Logger from '../../utils/logger';
+import { SentryScriptLoader, sentryInit } from './utils';
+import { removeUndefinedAndNullValues } from '../../utils/commonUtils';
+import { getDefinedTraits, isObject } from '../../utils/utils';
+
+const logger = new Logger(DISPLAY_NAME);
+
+class Sentry {
+  constructor(config, analytics, destinationInfo) {
+    if (analytics.logLevel) {
+      logger.setLogLevel(analytics.logLevel);
+    }
+    this.analytics = analytics;
+    this.name = NAME;
+    this.dsn = config.dsn;
+    this.debugMode = config.debugMode;
+    this.environment = config.environment;
+    this.ignoreErrors = config.ignoreErrors;
+    this.includePathsArray = config.includePaths;
+    this.logger = config.logger;
+    this.allowUrls = config.allowUrls;
+    this.denyUrls = config.denyUrls;
+    this.release = config.release;
+    this.customVersionProperty = config.customVersionProperty;
+    this.serverName = config.serverName;
+    ({
+      shouldApplyDeviceModeTransformation: this.shouldApplyDeviceModeTransformation,
+      propagateEventsUntransformedOnError: this.propagateEventsUntransformedOnError,
+      destinationId: this.destinationId,
+    } = destinationInfo ?? {});
+  }
+
+  init() {
+    if (!this.dsn) {
+      logger.error('DSN is a mandatory field');
+      return;
+    }
+    SentryScriptLoader(
+      'sentry',
+      `https://browser.sentry-cdn.com/6.13.1/bundle.min.js`,
+      `sha384-vUP3nL55ipf9vVr3gDgKyDuYwcwOC8nZGAksntVhezPcr2QXl1Ls81oolaVSkPm+`,
+    );
+
+    SentryScriptLoader(
+      'plugin',
+      `https://browser.sentry-cdn.com/6.13.1/rewriteframes.min.js`,
+      `sha384-WOm9k3kzVt1COFAB/zCXOFx4lDMtJh/2vmEizIwgog7OW0P/dPwl3s8f6MdwrD7q`,
+    );
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  isLoaded() {
+    return !!(
+      window.Sentry &&
+      isObject(window.Sentry) &&
+      window.Sentry.setUser &&
+      window.Sentry.Integrations.RewriteFrames
+    );
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  isReady() {
+    if (
+      window.Sentry &&
+      isObject(window.Sentry) &&
+      window.Sentry.setUser &&
+      window.Sentry.Integrations.RewriteFrames
+    ) {
+      const sentryConfig = sentryInit(
+        this.allowUrls,
+        this.denyUrls,
+        this.ignoreErrors,
+        this.includePathsArray,
+        this.customVersionProperty,
+        this.release,
+        this.dsn,
+        this.debugMode,
+        this.environment,
+        this.serverName,
+      );
+      window.Sentry.init(sentryConfig);
+      if (this.logger) {
+        window.Sentry.setTag('logger', this.logger);
+      }
+      return true;
+    }
+    return false;
+  }
+
+  identify(rudderElement) {
+    const { message } = rudderElement;
+    const { traits } = message.context;
+    const { email, name } = getDefinedTraits(message); // userId sent as id and username sent as name
+    const userId = get(message, 'userId');
+    const ipAddress = get(message, 'context.traits.ip_address');
+
+    if (!userId && !email && !name && !ipAddress) {
+      // if no user identification property is present the event will be dropped
+      logger.error('Any one of userId, email, name and ip_address is mandatory');
+      return;
+    }
+
+    const payload = {
+      id: userId,
+      email,
+      username: name,
+      ip_address: ipAddress,
+      ...traits,
+    };
+
+    window.Sentry.setUser(removeUndefinedAndNullValues(payload));
+  }
+}
+export default Sentry;

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

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

package/packages/analytics-js-integrations/src/integrations/Sentry/utils.js

@@ -0,0 +1,84 @@
+/* eslint-disable no-restricted-syntax */
+/* eslint-disable no-param-reassign */
+/* eslint-disable object-shorthand */
+import { DISPLAY_NAME } from '@rudderstack/analytics-js-common/constants/integrations/Sentry/constants';
+import { LOAD_ORIGIN } from '@rudderstack/analytics-js-common/v1.1/utils/constants';
+import Logger from '../../utils/logger';
+import { isDefinedAndNotNullAndNotEmpty } from '../../utils/commonUtils';
+
+const logger = new Logger(DISPLAY_NAME);
+
+const convertObjectToArray = (objectInput, propertyName) =>
+  objectInput
+    .map(objectItem => objectItem[propertyName])
+    .filter(e => isDefinedAndNotNullAndNotEmpty(e));
+
+const SentryScriptLoader = (id, src, integrity) => {
+  logger.info(`In script loader - ${id}`);
+  const js = document.createElement('script');
+  js.src = src;
+  js.integrity = integrity;
+  js.crossOrigin = 'anonymous';
+  js.type = 'text/javascript';
+  js.id = id;
+  js.setAttribute('data-loader', LOAD_ORIGIN);
+  const e = document.getElementsByTagName('script')[0];
+  logger.info('==parent script==', e);
+  logger.info('==adding script==', js);
+  e.parentNode.insertBefore(js, e);
+};
+
+const sentryInit = (
+  allowUrls,
+  denyUrls,
+  ignoreErrors,
+  includePathsArray,
+  customVersionProperty,
+  release,
+  DSN,
+  debugMode,
+  environment,
+  serverName,
+) => {
+  const formattedAllowUrls = convertObjectToArray(allowUrls, 'allowUrls');
+  const formattedDenyUrls = convertObjectToArray(denyUrls, 'denyUrls');
+  const formattedIgnoreErrors = convertObjectToArray(ignoreErrors, 'ignoreErrors');
+  const formattedIncludePaths = convertObjectToArray(includePathsArray, 'includePaths');
+
+  const customRelease = customVersionProperty ? window[customVersionProperty] : null;
+
+  const sentryConfig = {
+    dsn: DSN,
+    debug: debugMode,
+    environment: environment || null,
+    release: customRelease || release || null,
+    serverName: serverName || null,
+    allowUrls: formattedAllowUrls,
+    denyUrls: formattedDenyUrls,
+    ignoreErrors: formattedIgnoreErrors,
+  };
+
+  if (formattedIncludePaths.length > 0) {
+    sentryConfig.integrations = [
+      new window.Sentry.Integrations.RewriteFrames({
+        iteratee(frame) {
+          for (const path of formattedIncludePaths) {
+            try {
+              if (frame.filename.match(new RegExp(path))) {
+                frame.in_app = true;
+                return frame;
+              }
+            } catch (e) {
+              // ignored
+            }
+          }
+          frame.in_app = false;
+          return frame;
+        },
+      }),
+    ];
+  }
+  return sentryConfig;
+};
+
+export { SentryScriptLoader, convertObjectToArray, sentryInit };

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

@@ -0,0 +1,99 @@
+/* eslint-disable func-names */
+/* eslint-disable compat/compat */
+import {
+  NAME,
+  DISPLAY_NAME,
+} from '@rudderstack/analytics-js-common/constants/integrations/Shynet/constants';
+import Logger from '../../utils/logger';
+import { generateUUID } from '../../utils/utils';
+
+const logger = new Logger(DISPLAY_NAME);
+
+class Shynet {
+  constructor(config, analytics, destinationInfo) {
+    if (analytics.logLevel) {
+      logger.setLogLevel(analytics.logLevel);
+    }
+    this.analytics = analytics;
+    const { heartBeatFrequencyInMs } = config;
+    const { shynetServiceUrl } = config;
+    this.scriptCheck = false;
+    this.name = NAME;
+    ({
+      shouldApplyDeviceModeTransformation: this.shouldApplyDeviceModeTransformation,
+      propagateEventsUntransformedOnError: this.propagateEventsUntransformedOnError,
+      destinationId: this.destinationId,
+    } = destinationInfo ?? {});
+
+    this.shynetScript = {
+      idempotency: null,
+      heartBeatTaskId: null,
+      skipHeartBeat: false,
+      sendHeartBeat(referrerName, url) {
+        try {
+          if (this.skipHeartbeat) {
+            return;
+          }
+
+          this.skipHeartbeat = true;
+          const xhr = new XMLHttpRequest();
+          xhr.open('POST', `${shynetServiceUrl}`, true);
+          xhr.setRequestHeader('Content-Type', 'application/json');
+          xhr.onload = function () {
+            this.skipHeartBeat = false;
+          };
+          xhr.onerror = function () {
+            this.skipHeartBeat = false;
+          };
+          const payloadBody = JSON.stringify({
+            idempotency: this.idempotency,
+            referrer: referrerName,
+            location: url,
+            loadTime: window.performance.now(),
+          });
+          xhr.send(payloadBody);
+        } catch (exp) {
+          logger.info(`Error Sending ${NAME} Event`, exp.message);
+        }
+      },
+      newPageLoad(referrer, url) {
+        if (this.heartBeatTaskId != null) {
+          clearInterval(this.heartBeatTaskId);
+        }
+        this.idempotency = generateUUID();
+        this.skipHeartbeat = false;
+        // taking default as 5 sec as used in shynet doc
+        this.heartBeatTaskId = setInterval(
+          this.sendHeartBeat,
+          parseInt(heartBeatFrequencyInMs || 5000, 10),
+        );
+        this.sendHeartBeat(referrer, url);
+      },
+    };
+    this.scriptCheck = true;
+  }
+
+  init() {
+    return this.scriptCheck;
+  }
+
+  isLoaded() {
+    return this.scriptCheck;
+  }
+
+  isReady() {
+    return this.isLoaded();
+  }
+
+  page(rudderElement) {
+    try {
+      this.shynetScript.newPageLoad(
+        rudderElement?.message?.properties?.referrer,
+        rudderElement?.message?.properties?.url,
+      );
+    } catch (exp) {
+      logger.info(exp.message);
+    }
+  }
+}
+export default Shynet;

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

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

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

@@ -0,0 +1,74 @@
+/* eslint-disable no-underscore-dangle */
+/* eslint-disable class-methods-use-this */
+import get from 'get-value';
+import {
+  NAME,
+  DISPLAY_NAME,
+} from '@rudderstack/analytics-js-common/constants/integrations/SnapEngage/constants';
+import Logger from '../../utils/logger';
+import { recordingLiveChatEvents } from './util';
+import { getHashFromArray } from '../../utils/commonUtils';
+import { isObject } from '../../utils/utils';
+import { loadNativeSdk } from './nativeSdkLoader';
+
+const logger = new Logger(DISPLAY_NAME);
+
+class SnapEngage {
+  constructor(config, analytics, destinationInfo) {
+    if (analytics.logLevel) {
+      logger.setLogLevel(analytics.logLevel);
+    }
+    this.analytics = analytics;
+    this.widgetId = config.widgetId;
+    this.recordLiveChatEvents = config.recordLiveChatEvents;
+    this.eventsToStandard = config.eventsToStandard;
+    this.updateEventNames = config.updateEventNames;
+    this.name = NAME;
+    ({
+      shouldApplyDeviceModeTransformation: this.shouldApplyDeviceModeTransformation,
+      propagateEventsUntransformedOnError: this.propagateEventsUntransformedOnError,
+      destinationId: this.destinationId,
+    } = destinationInfo ?? {});
+  }
+
+  loadScript() {
+    loadNativeSdk(this.widgetId);
+  }
+
+  init() {
+    this.loadScript();
+  }
+
+  isLoaded() {
+    return !!(window.SnapEngage && isObject(window.SnapEngage));
+  }
+
+  isReady() {
+    // Dashboard Other Settings
+    if (this.recordLiveChatEvents) {
+      const standardEventsMap = getHashFromArray(this.eventsToStandard);
+
+      recordingLiveChatEvents(this.updateEventNames, standardEventsMap, this.analytics);
+    }
+    return !!window.SnapEngage;
+  }
+
+  identify(rudderElement) {
+    const { message } = rudderElement;
+    const email = get(message, 'context.traits.email') || get(message, 'traits.email');
+
+    if (!email) {
+      logger.error('User parameter (email) is required for identify call');
+      return;
+    }
+    window.SnapEngage.setUserEmail(email);
+
+    const name = get(message, 'context.traits.name') || get(message, 'traits.name');
+
+    if (name) {
+      window.SnapEngage.setUserName(name);
+    }
+  }
+}
+
+export default SnapEngage;

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

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

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

@@ -0,0 +1,24 @@
+import { LOAD_ORIGIN } from '@rudderstack/analytics-js-common/v1.1/utils/constants';
+
+function loadNativeSdk(widgetId) {
+  (function (widgetId) {
+    const se = document.createElement('script');
+    se.type = 'text/javascript';
+    se.async = true;
+    se.src = `https://storage.googleapis.com/code.snapengage.com/js/${widgetId}.js`;
+    se.setAttribute('data-loader', LOAD_ORIGIN);
+    let done = false;
+    se.onload = se.onreadystatechange = function () {
+      if (
+        !done &&
+        (!this.readyState || this.readyState === 'loaded' || this.readyState === 'complete')
+      ) {
+        done = true;
+      }
+    };
+    const s = document.getElementsByTagName('script')[0];
+    s.parentNode.insertBefore(se, s);
+  })(widgetId);
+}
+
+export { loadNativeSdk };

package/packages/analytics-js-integrations/src/integrations/SnapEngage/util.js

@@ -0,0 +1,63 @@
+const integrationContext = {
+  name: 'snapengage',
+  version: '1.0.0',
+};
+
+/**
+ * Exchanges key with value
+ * @param {*} data
+ * @returns
+ */
+function flip(data) {
+  return Object.fromEntries(Object.entries(data).map(([key, value]) => [value, key]));
+}
+
+function recordingLiveChatEvents(updateEventNames, standardEventsMap, analytics) {
+  const eventNames = flip(standardEventsMap);
+
+  window.SnapEngage.setCallback('StartChat', () => {
+    let eventName = 'Live Chat Conversation Started';
+    if (updateEventNames && eventNames?.startChat) {
+      eventName = eventNames.startChat;
+    }
+    analytics.track(`${eventName}`, {}, { context: { integration: integrationContext } });
+  });
+
+  window.SnapEngage.setCallback('ChatMessageReceived', agent => {
+    let eventName = 'Live Chat Message Received';
+    if (updateEventNames && eventNames?.chatMessageReceived) {
+      eventName = eventNames.chatMessageReceived;
+    }
+    analytics.track(
+      `${eventName}`,
+      { agentUsername: agent },
+      { context: { integration: integrationContext } },
+    );
+  });
+
+  window.SnapEngage.setCallback('ChatMessageSent', () => {
+    let eventName = 'Live Chat Message Sent';
+    if (updateEventNames && eventNames?.chatMessageSent) {
+      eventName = eventNames.chatMessageSent;
+    }
+    analytics.track(`${eventName}`, {}, { context: { integration: integrationContext } });
+  });
+
+  window.SnapEngage.setCallback('Close', () => {
+    let eventName = 'Live Chat Conversation Ended';
+    if (updateEventNames && eventNames?.close) {
+      eventName = eventNames.close;
+    }
+    analytics.track(`${eventName}`, {}, { context: { integration: integrationContext } });
+  });
+
+  window.SnapEngage.setCallback('InlineButtonClicked', () => {
+    let eventName = 'Inline Button Clicked';
+    if (updateEventNames && eventNames?.inlineButtonClicked) {
+      eventName = eventNames.inlineButtonClicked;
+    }
+    analytics.track(`${eventName}`, {}, { context: { integration: integrationContext } });
+  });
+}
+
+export { integrationContext, recordingLiveChatEvents };