castled-js-sdk 0.0.1 → 0.0.2

package/src/features/core/cookieConsent/CookieConsentFactory.js

@@ -0,0 +1,32 @@
+import { OneTrust } from './OneTrust';
+import { Ketch } from './ketch';
+
+const CookieConsentFactory = {
+  initialize(cookieConsentOptions) {
+    /**
+     *
+     * check which type of cookie consent manager needs to be called if enabled
+     * for now we have only OneTrust.
+     * But if new cookie consent manager options are implemented,
+     * we need to make sure only one of them is enabled by the user in the
+     * load options
+     *
+     */
+    if (cookieConsentOptions?.oneTrust?.enabled) {
+      // This is P1. When we have an ui in source side to turn on/off of cookie consent
+      // if (sourceConfig &&
+      //     sourceConfig.cookieConsentManager &&
+      // sourceConfig.cookieConsentManager.oneTrust &&
+      // sourceConfig.cookieConsentManager.oneTrustenabled) {
+      return new OneTrust();
+
+      // }
+    }
+    if (cookieConsentOptions?.ketch?.enabled) {
+      return new Ketch();
+    }
+    return null;
+  },
+};
+
+export default CookieConsentFactory;

package/src/features/core/cookieConsent/OneTrust/browser.js

@@ -0,0 +1,102 @@
+import logger from '../../../../utils/logUtil';
+
+/* eslint-disable class-methods-use-this */
+class OneTrust {
+  isInitialized = false;
+
+  constructor() {
+    // If user does not load onetrust sdk before loading ht events sdk
+    // we will not be filtering any of the destinations.
+    if (!window.OneTrust || !window.OnetrustActiveGroups) {
+      logger.error('OneTrust resources are not accessible.');
+      return;
+    }
+    // OneTrust Cookie Compliance populates a data layer object OnetrustActiveGroups with
+    // the cookie categories that the user has consented to.
+    // Eg: ',C0001,C0003,'
+    // We split it and save it as an array.
+
+    this.userSetConsentGroupIds = window.OnetrustActiveGroups.split(',').filter((n) => n); // Ids user has consented
+
+    // Get information about the cookie script - data includes, consent models, cookies in preference centre, etc.
+    // We get the groups(cookie categorization), user has created in one trust account.
+
+    const oneTrustAllGroupsInfo = window.OneTrust.GetDomainData().Groups;
+    this.userSetConsentGroupNames = [];
+    this.userDeniedConsentGroupIds = [];
+
+    // Get the names of the cookies consented by the user in the browser.
+
+    oneTrustAllGroupsInfo.forEach((group) => {
+      const { CustomGroupId, GroupName } = group;
+      if (this.userSetConsentGroupIds.includes(CustomGroupId)) {
+        this.userSetConsentGroupNames.push(GroupName.toUpperCase().trim());
+      } else {
+        this.userDeniedConsentGroupIds.push(CustomGroupId);
+      }
+    });
+
+    this.userSetConsentGroupIds = this.userSetConsentGroupIds.map((e) => e.toUpperCase());
+    this.isInitialized = true;
+  }
+
+  isEnabled(destConfig) {
+    try {
+      if (!this.isInitialized) {
+        return true;
+      }
+      /**
+     * Structure of onetrust consent group destination config.
+     * 
+     * "oneTrustConsentGroup": [
+                        {
+                            "oneTrustConsentGroup": "Performance Cookies"
+                        },
+                        {
+                            "oneTrustConsentGroup": "Functional Cookies"
+                        },
+                        {
+                            "oneTrustConsentGroup": ""
+                        }
+                    ]
+      *
+     */
+
+      const { oneTrustCookieCategories } = destConfig; // mapping of the destination with the consent group name
+
+      // If the destination do not have this mapping events will be sent.
+
+      if (!oneTrustCookieCategories) {
+        return true;
+      }
+
+      // Change the structure of oneTrustConsentGroup as an array and filter values if empty string
+      // Eg:
+      // ["Performance Cookies", "Functional Cookies"]
+
+      const oneTrustConsentGroupArr = oneTrustCookieCategories
+        .map((c) => c.oneTrustCookieCategory)
+        .filter((n) => n);
+      let containsAllConsent = true;
+      // Check if all the destination's mapped cookie categories are consented by the user in the browser.
+      containsAllConsent = oneTrustConsentGroupArr.every(
+        (element) =>
+          this.userSetConsentGroupIds.includes(element.toUpperCase().trim()) ||
+          this.userSetConsentGroupNames.includes(element.toUpperCase().trim()),
+      );
+      return containsAllConsent;
+    } catch (e) {
+      logger.error(`Error during onetrust cookie consent management ${e}`);
+      return true;
+    }
+  }
+
+  getDeniedList() {
+    if (!this.isInitialized) {
+      return [];
+    }
+    return this.userDeniedConsentGroupIds;
+  }
+}
+
+export default OneTrust;

package/src/features/core/cookieConsent/OneTrust/index.js

@@ -0,0 +1,3 @@
+import OneTrust from './browser';
+
+export { OneTrust };

package/src/features/core/cookieConsent/ketch/browser.js

@@ -0,0 +1,114 @@
+import logger from '../../../../utils/logUtil';
+import { Cookie } from '../../../../utils/storage/cookie';
+
+/* eslint-disable class-methods-use-this */
+class Ketch {
+  constructor() {
+    this.userConsentedPurposes = [];
+    this.userDeniedPurposes = [];
+
+    // updateKetchConsent callback function to update current consent purpose state
+    // this will be called from ketch rudderstack plugin
+    window.updateKetchConsent = (consent) => {
+      if (consent) {
+        this.userConsentedPurposes = [];
+        this.userDeniedPurposes = [];
+        this.updatePurposes(consent);
+      }
+    };
+
+    // getKetchUserConsentedPurposes returns current ketch opted-in purposes
+    window.getKetchUserConsentedPurposes = () => this.userConsentedPurposes.slice();
+
+    // getKetchUserDeniedPurposes returns current ketch opted-out purposes
+    window.getKetchUserDeniedPurposes = () => this.userDeniedPurposes.slice();
+
+    // initialize purposes with existing user consent state
+    if (window.ketchConsent) {
+      this.updatePurposes(window.ketchConsent);
+    } else {
+      const consent = this.getConsent();
+      this.updatePurposes(consent);
+    }
+  }
+
+  updatePurposes = (consent) => {
+    if (consent) {
+      Object.entries(consent).forEach((e) => {
+        const purposeCode = e[0];
+        const isConsented = e[1];
+        if (isConsented) {
+          this.userConsentedPurposes.push(purposeCode);
+        } else {
+          this.userDeniedPurposes.push(purposeCode);
+        }
+      });
+    }
+  };
+
+  isEnabled(destConfig) {
+    try {
+      /**
+       * Structure of ketch consent purpose destination config.
+       *
+       * "ketchConsentPurposes": [
+       * {
+       * "purpose" : "analytics"
+       * }
+       * ]
+       *
+       */
+
+      const { ketchConsentPurposes } = destConfig; // mapping of the destination with the consent group name
+
+      // If the destination do not have this mapping events will be sent.
+      if (!ketchConsentPurposes || ketchConsentPurposes.length === 0) {
+        return true;
+      }
+
+      const purposes = ketchConsentPurposes.map((p) => p.purpose).filter((n) => n);
+
+      let containsAnyOfConsent = true;
+      // Check if any of the destination's mapped ketch purposes are consented by the user in the browser.
+      containsAnyOfConsent = purposes.some((element) =>
+        this.userConsentedPurposes.includes(element.trim()),
+      );
+      return containsAnyOfConsent;
+    } catch (e) {
+      logger.error(`Error occured checking ketch consent state ${e}`);
+      return true;
+    }
+  }
+
+  getDeniedList() {
+    return this.userDeniedPurposes;
+  }
+
+  getConsent() {
+    const value = Cookie.get('_ketch_consent_v1_');
+    if (!value) {
+      return undefined;
+    }
+    let consentObj;
+    try {
+      consentObj = JSON.parse(atob(value));
+    } catch (e) {
+      logger.error(`Error occured while parsing consent cookie ${e}`);
+      return undefined;
+    }
+    if (!consentObj) {
+      return undefined;
+    }
+    const consent = {};
+    Object.entries(consentObj).forEach((e) => {
+      const purposeCode = e[0];
+      const purposeValue = e[1];
+      if (purposeValue && purposeValue.status) {
+        consent[purposeCode] = purposeValue.status === 'granted';
+      }
+    });
+    return consent;
+  }
+}
+
+export default Ketch;

package/src/features/core/cookieConsent/ketch/index.js

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

package/src/features/core/deviceModeTransformation/transformationHandler.js

@@ -0,0 +1,189 @@
+/* eslint-disable compat/compat */
+/* eslint-disable class-methods-use-this */
+/* eslint-disable no-param-reassign */
+/* eslint-disable prefer-promise-reject-errors */
+/* eslint-disable consistent-return */
+import { removeTrailingSlashes } from '../../../utils/utils';
+import { createPayload } from './util';
+import { handleError } from '../../../utils/errorHandler';
+import { stringifyWithoutCircular } from '../../../utils/ObjectUtils';
+
+const timeout = 10 * 1000;
+const EVENT_CHECK_INTERVAL = 100;
+const RETRY_INTERVAL = 500;
+const backoffFactor = 2;
+
+class TransformationsHandler {
+  constructor() {
+    this.retryAttempt = 3; // default value for retry
+    this.queue = [];
+    this.isTransformationProcessing = false;
+    this.authToken = null;
+  }
+
+  init(writeKey, dataPlaneUrl, authToken) {
+    this.dataPlaneUrl = removeTrailingSlashes(dataPlaneUrl);
+    this.writeKey = writeKey;
+    this.authToken = authToken || this.authToken;
+    this.start();
+  }
+
+  // Enqueue the events and callbacks
+  enqueue(event, destinationIds, cb) {
+    this.queue.push({
+      event,
+      destinationIds,
+      cb,
+    });
+  }
+
+  /**
+   * A helper function that will take one payload at a time and send it to transformation server
+   * and return the response
+   *
+   */
+  sendEventForTransformation(payload, retryAttempt) {
+    return new Promise((resolve, reject) => {
+      const url = `${this.dataPlaneUrl}/transform`;
+      const headers = {
+        'Content-Type': 'application/json',
+        Authorization: `Basic ${btoa(`${this.writeKey}:`)}`,
+      };
+
+      try {
+        const xhr = new XMLHttpRequest();
+        xhr.open('POST', url, true);
+        Object.keys(headers).forEach((k) => xhr.setRequestHeader(k, headers[k]));
+        xhr.timeout = timeout;
+
+        xhr.onreadystatechange = () => {
+          if (xhr.readyState === 4) {
+            try {
+              const { status } = xhr;
+              let { response } = xhr;
+
+              switch (status) {
+                case 200: {
+                  response = JSON.parse(response);
+                  /**
+                   * Sample Response format:
+                   * {
+                      "transformedBatch" :[
+                        {
+                          "id": "destination-id",
+                          "payload": [
+                            {
+                              "orderNo":1,
+                              "status": "200",
+                              "event": {
+                                "message": { ...}
+                            }]
+                        }]
+                      } 
+                  */
+                  resolve({
+                    status,
+                    transformedPayload: response.transformedBatch,
+                  });
+                  return;
+                }
+                case 400: {
+                  const errorMessage = response ? `${response}` : `Invalid request payload`;
+                  resolve({
+                    status,
+                    errorMessage,
+                  });
+                  return;
+                }
+                case 404: {
+                  resolve({
+                    status,
+                  });
+                  return;
+                }
+                default: {
+                  // If the request is not successful
+                  // retry till the retryAttempt is exhausted
+                  if (retryAttempt > 0) {
+                    const newRetryAttempt = retryAttempt - 1;
+                    setTimeout(
+                      () =>
+                        this.sendEventForTransformation(payload, newRetryAttempt)
+                          .then(resolve)
+                          .catch(reject),
+                      RETRY_INTERVAL * backoffFactor ** (this.retryAttempt - newRetryAttempt),
+                    );
+                  } else {
+                    // Even after all the retries event transformation
+                    // is not successful, return the response with a flag retryExhausted
+                    resolve({
+                      status,
+                      errorMessage: 'Retries exhausted',
+                    });
+                  }
+                }
+              }
+            } catch (err) {
+              reject(err);
+            }
+          }
+        };
+        xhr.send(stringifyWithoutCircular(payload, true));
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+
+  checkQueueLengthAndProcess() {
+    if (this.queue.length > 0) {
+      this.process();
+    }
+  }
+
+  /**
+   * A helper function that will process the transformation
+   * and return the transformed event payload
+   *
+   */
+  process() {
+    this.isTransformationProcessing = true;
+    const firstElement = this.queue.shift();
+    const payload = createPayload(firstElement.event, firstElement.destinationIds, this.authToken);
+
+    // Send event for transformation with payload, writekey and retryAttempt
+    this.sendEventForTransformation(payload, this.retryAttempt)
+      .then((outcome) => {
+        this.isTransformationProcessing = false;
+        firstElement.cb(outcome);
+        this.checkQueueLengthAndProcess();
+      })
+      .catch((err) => {
+        if (typeof err === 'string') {
+          handleError(err);
+        } else {
+          handleError(err.message);
+        }
+        this.isTransformationProcessing = false;
+        // send only status as response in case of unhandled error occurs
+        firstElement.cb({ status: 0 });
+        this.checkQueueLengthAndProcess();
+      });
+  }
+
+  start() {
+    setInterval(() => {
+      if (!this.isTransformationProcessing) {
+        this.checkQueueLengthAndProcess();
+      }
+    }, EVENT_CHECK_INTERVAL);
+  }
+
+  setAuthToken(token) {
+    this.authToken = token;
+  }
+}
+
+const DeviceModeTransformations = new TransformationsHandler();
+
+export { DeviceModeTransformations };

package/src/features/core/deviceModeTransformation/util.js

@@ -0,0 +1,23 @@
+/**
+ * A helper function that will take htElement as an event and generate
+ * a batch payload that will be sent to transformation server
+ *
+ */
+const createPayload = (event, destinationIds, token) => {
+  const orderNo = Date.now();
+  const payload = {
+    metadata: {
+      'Custom-Authorization': token,
+    },
+    batch: [
+      {
+        orderNo,
+        destinationIds,
+        event: event.message,
+      },
+    ],
+  };
+  return payload;
+};
+
+export { createPayload };

package/src/features/core/metrics/errorReporting/ErrorReportingService.js

@@ -0,0 +1,116 @@
+import { get } from '../../../../utils/utils';
+import { BugsnagProvider, ERROR_REPORT_PROVIDER_NAME_BUGSNAG } from './providers/Bugsnag';
+import { ERROR_REPORTING_SERVICE_GLOBAL_KEY_NAME } from '../../../../utils/constants';
+
+const DEFAULT_ERROR_REPORT_PROVIDER = ERROR_REPORT_PROVIDER_NAME_BUGSNAG;
+const AVAILABLE_ERROR_REPORT_PROVIDERS = [ERROR_REPORT_PROVIDER_NAME_BUGSNAG];
+const ERRORS_COLLECTION_ENABLED_CONFIG_KEY = 'statsCollection.errors.enabled';
+const ERRORS_COLLECTION_PROVIDER_NAME_CONFIG_KEY = 'statsCollection.errors.provider';
+
+const getErrorCollectionEnabledFromConfig = (sourceConfig) =>
+  get(sourceConfig, ERRORS_COLLECTION_ENABLED_CONFIG_KEY) || false;
+
+const getProviderNameFromConfig = (sourceConfig) =>
+  get(sourceConfig, ERRORS_COLLECTION_PROVIDER_NAME_CONFIG_KEY);
+
+class ErrorReportingService {
+  constructor(logger) {
+    this.isEnabled = false;
+    this.providerName = DEFAULT_ERROR_REPORT_PROVIDER;
+    this.provider = undefined;
+    this.logger = logger;
+    this.onClientReady = this.onClientReady.bind(this);
+    this.exposeToGlobal = this.exposeToGlobal.bind(this);
+  }
+
+  init(sourceConfig, sourceId) {
+    if (!sourceConfig || !sourceId) {
+      this.logger.error(
+        `[Analytics] ErrorReporting :: Invalid configuration or missing source id provided.`,
+      );
+      return;
+    }
+
+    // Initialize error reporting based on enable option from sourceConfig
+    if (getErrorCollectionEnabledFromConfig(sourceConfig) === true) {
+      this.enable();
+      this.setProviderName(getProviderNameFromConfig(sourceConfig));
+      this.initProvider(sourceConfig, sourceId);
+    } else {
+      this.disable();
+    }
+  }
+
+  enable() {
+    this.isEnabled = true;
+  }
+
+  disable() {
+    this.isEnabled = false;
+  }
+
+  setProviderName(providerName) {
+    if (!providerName) {
+      this.providerName = DEFAULT_ERROR_REPORT_PROVIDER;
+      return;
+    }
+
+    if (providerName && !AVAILABLE_ERROR_REPORT_PROVIDERS.includes(providerName)) {
+      this.logger.error(
+        `[Analytics] ErrorReporting :: Invalid error reporting provider value. Value should be one of: ${AVAILABLE_ERROR_REPORT_PROVIDERS.join(
+          ',',
+        )}`,
+      );
+      return;
+    }
+
+    this.providerName = providerName;
+  }
+
+  initProvider(sourceConfig, sourceId) {
+    // eslint-disable-next-line sonarjs/no-small-switch
+    switch (this.providerName) {
+      case ERROR_REPORT_PROVIDER_NAME_BUGSNAG:
+        this.provider = new BugsnagProvider(sourceId, this.onClientReady);
+        break;
+      default:
+        break;
+    }
+  }
+
+  onClientReady() {
+    this.exposeToGlobal();
+  }
+
+  // Expose the error reporting service as global variable after provider is ready,
+  // so it can be used without injecting the service to consumer methods
+  exposeToGlobal() {
+    if (!window.HtEventsGlobals) {
+      window.HtEventsGlobals = {};
+    }
+
+    window.HtEventsGlobals[ERROR_REPORTING_SERVICE_GLOBAL_KEY_NAME] = this;
+  }
+
+  leaveBreadcrumb(breadcrumb) {
+    if (this.provider) {
+      try {
+        this.provider.leaveBreadcrumb(breadcrumb);
+      } catch (e) {
+        this.logger.error(`[Analytics] ErrorReporting :: leaveBreadcrumb method ${e.toString()}`);
+      }
+    }
+  }
+
+  notify(error) {
+    if (this.provider) {
+      try {
+        this.provider.notify(error);
+      } catch (e) {
+        this.logger.error(`[Analytics] ErrorReporting :: notify method ${e.toString()}`);
+      }
+    }
+  }
+}
+
+export { ErrorReportingService };