iureiure 1.0.0

package/packages/analytics-v1.1/src/utils/xhrModule.js

@@ -0,0 +1,117 @@
+/* eslint-disable no-param-reassign */
+/* eslint-disable func-names */
+/* eslint-disable import/no-unresolved */
+/* eslint-disable global-require */
+/* eslint-disable guard-for-in */
+/* eslint-disable no-restricted-syntax */
+/* eslint-disable class-methods-use-this */
+import Queue from '@segment/localstorage-retry';
+import { handleError } from '@rudderstack/analytics-js-common/v1.1/utils/errorHandler';
+import { FAILED_REQUEST_ERR_MSG_PREFIX } from '@rudderstack/analytics-js-common/v1.1/utils/constants';
+import { stringifyWithoutCircularV1 } from '@rudderstack/analytics-js-common/v1.1/utils/ObjectUtils';
+import { logger } from '@rudderstack/analytics-js-common/v1.1/utils/logUtil';
+import { getCurrentTimeFormatted } from './utils';
+import { REQUEST_TIMEOUT_MS } from './constants';
+
+const queueOptions = {
+  maxRetryDelay: 360000,
+  minRetryDelay: 1000,
+  backoffFactor: 2,
+  maxAttempts: 10,
+  maxItems: 100,
+};
+
+class XHRQueue {
+  constructor() {
+    this.url = '';
+    this.writeKey = '';
+  }
+
+  init(writeKey, url, options) {
+    this.url = url;
+    this.writeKey = writeKey;
+    if (options) {
+      // TODO: add checks for value - has to be +ve?
+      Object.assign(queueOptions, options);
+    }
+    this.payloadQueue = new Queue('rudder', queueOptions, (item, done) => {
+      // apply sentAt at flush time and reset on each retry
+      item.message.sentAt = getCurrentTimeFormatted();
+      // send this item for processing, with a callback to enable queue to get the done status
+      // eslint-disable-next-line no-use-before-define
+      this.processQueueElement(
+        item.url,
+        item.headers,
+        item.message,
+        REQUEST_TIMEOUT_MS,
+        // eslint-disable-next-line consistent-return
+        (err, res) => {
+          if (err) {
+            return done(err);
+          }
+          done(null, res);
+        },
+      );
+    });
+
+    // start queue
+    this.payloadQueue.start();
+  }
+
+  /**
+   * the queue item proceesor
+   * @param {*} url to send requests to
+   * @param {*} headers
+   * @param {*} message
+   * @param {*} timeout
+   * @param {*} queueFn the function to call after request completion
+   */
+  processQueueElement(url, headers, message, timeout, queueFn) {
+    try {
+      const xhr = new XMLHttpRequest();
+      xhr.open('POST', url, true);
+      for (const k in headers) {
+        xhr.setRequestHeader(k, headers[k]);
+      }
+      xhr.timeout = timeout;
+      xhr.ontimeout = queueFn;
+      xhr.onerror = queueFn;
+      xhr.onreadystatechange = function () {
+        if (xhr.readyState === 4) {
+          if (xhr.status === 429 || (xhr.status >= 500 && xhr.status < 600)) {
+            const errMessage = `${FAILED_REQUEST_ERR_MSG_PREFIX} "${xhr.status}" status text: "${xhr.statusText}" for URL: "${url}"`;
+            const err = new Error(errMessage);
+            handleError(err);
+            queueFn(err);
+          } else {
+            queueFn(null, xhr.status);
+          }
+        }
+      };
+      const sanitizedPayload = stringifyWithoutCircularV1(message, true);
+      if (sanitizedPayload) {
+        xhr.send(sanitizedPayload);
+      } else {
+        logger.error(`Invalid payload: Event dropped`);
+      }
+    } catch (error) {
+      queueFn(error);
+    }
+  }
+
+  enqueue(message, type) {
+    const headers = {
+      'Content-Type': 'application/json',
+      Authorization: `Basic ${btoa(`${this.writeKey}:`)}`,
+      AnonymousId: btoa(message.anonymousId),
+    };
+    // add items to the queue
+    this.payloadQueue.addItem({
+      url: `${this.url}/v1/${type}`,
+      headers,
+      message,
+    });
+  }
+}
+
+export default XHRQueue;

package/packages/analytics-v1.1/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "extends": "../../tsconfig.build.json",
+  "compilerOptions": {
+    "target": "es5",
+    "declarationDir": "./dist/dts"
+  },
+  "include": ["./package.json", "./src/**/*", "../../types/**/*", "../analytics-js-common/src/**/*"]
+}

package/packages/analytics-v1.1/tsconfig.spec.json

@@ -0,0 +1,26 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../dist/out-tsc",
+    "module": "commonjs",
+    "noEmit": true,
+    "sourceMap": true,
+    "inlineSourceMap": true,
+    "isolatedModules": true,
+    "verbatimModuleSyntax": false,
+    "types": ["jest", "node"],
+    "target": "es6"
+  },
+  "include": [
+    "jest.config.mjs",
+    "__tests__/**/*.ts",
+    "__mocks__/**/*.ts",
+    "__fixtures__/**/*.ts",
+    "__tests__/**/*.js",
+    "__mocks__/**/*.js",
+    "__fixtures__/**/*.js",
+    "src/**/*.ts",
+    "src/**/*.js",
+    "src/**/*.d.ts"
+  ]
+}

package/packages/analytics-v1.1/types/index.d.ts

@@ -0,0 +1,472 @@
+declare module 'rudder-sdk-js' {
+  /**
+   * Represents the integration options object
+   * Example usages:
+   * integrationOptions { All: false, "Google Analytics": true, "Braze": true}
+   * integrationOptions { All: true, "Chartbeat": false, "Customer.io": false}
+   */
+  interface integrationOptions {
+    // Defaults to true
+    // If set to false, specific integration should be set to true to send the event
+    All?: boolean;
+    // Destination name: true/false/integration specific information
+    [index: string]: boolean | undefined | apiObject;
+  }
+
+  /**
+   * Represents the queue options parameter in loadOptions type
+   */
+  interface queueOptions {
+    // Upper cap on maximum delay for an event
+    maxRetryDelay?: number;
+    // Minimum delay before sending an event
+    minRetryDelay?: number;
+    // Exponential base
+    backoffFactor?: number;
+    // Maximum number of attempts
+    maxAttempts?: number;
+    // Maximum number of events in storage
+    maxItems?: number;
+  }
+
+  /**
+   * Represents the beacon queue options parameter in loadOptions type
+   */
+  interface beaconQueueOptions {
+    // Maximum number of events in storage
+    maxItems?: number;
+    // Time in milliseconds to flush the queue autometically
+    flushQueueInterval?: number;
+  }
+
+  /**
+   * Represents the beacon queue options parameter in loadOptions type
+   */
+  interface cookieConsentManager {
+    // OneTrust
+    oneTrust?: {
+      enabled: boolean;
+    };
+    // Ketch
+    ketch?: {
+      enabled: boolean;
+    };
+  }
+
+  /**
+   * Represents the options parameter for anonymousId
+   */
+  interface anonymousIdOptions {
+    autoCapture?: {
+      enabled?: boolean;
+      source?: string;
+    };
+  }
+
+  /**
+   * Represents residency server input the options
+   */
+  enum RESIDENCY_SERVER {
+    US = 'US',
+    EU = 'EU',
+  }
+
+  /**
+   * Represents the options parameter in the load API
+   */
+  interface loadOptions {
+    integrations?: integrationOptions;
+    // defaults to https://api.rudderstack.com
+    configUrl?: string;
+    queueOptions?: queueOptions;
+    // Defaults to true
+    loadIntegration?: boolean;
+    lockIntegrationsVersion?: boolean;
+    // Defaults to false
+    secureCookie?: boolean;
+    // Defaults to "Lax" (see https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Set-Cookie/SameSite)
+    sameSiteCookie?: string;
+    logLevel?: string;
+    getSourceConfig?: () => string | apiObject | Promise<apiObject> | Promise<string>;
+    setCookieDomain?: string;
+    sendAdblockPage?: boolean;
+    sendAdblockPageOptions?: apiOptions;
+    clientSuppliedCallbacks?: { string: () => void };
+    useBeacon?: boolean; // Defaults to false
+    beaconQueueOptions?: beaconQueueOptions;
+    cookieConsentManager?: cookieConsentManager;
+    anonymousIdOptions?: anonymousIdOptions;
+    // defaults to https://cdn.rudderlabs.com/v1.1/js-integrations
+    destSDKBaseURL?: string;
+    sessions?: {
+      autoTrack?: boolean; // Defaults to true
+      timeout?: number; // Defaults to 30 mins
+    };
+    residencyServer?: RESIDENCY_SERVER;
+    // Controls whether the SDK should polyfill unsupported browser API's if they are detected as missing
+    // Defaults to true
+    polyfillIfRequired?: boolean;
+    uaChTrackLevel?: 'none' | 'default' | 'full';
+    onLoaded?: (analytics: any) => void;
+    useGlobalIntegrationsConfigInEvents?: boolean; // Default is false
+  }
+
+  /**
+   * Represents the options parameter in the APIs
+   */
+  interface apiOptions {
+    integrations?: integrationOptions;
+    anonymousId?: string;
+    // ISO 8601 date string
+    originalTimestamp?: string;
+    // Merged with event's contextual information
+    [index: string]:
+      | string
+      | number
+      | boolean
+      | apiObject
+      | (string | number | boolean | apiObject)[]
+      | integrationOptions
+      | undefined;
+  }
+
+  /**
+   * Represents a generic object in the APIs
+   * Use for parameters like properties, traits etc.
+   */
+  interface apiObject {
+    [index: string]:
+      | string
+      | number
+      | boolean
+      | apiObject
+      | (string | number | boolean | apiObject)[]
+      | undefined;
+  }
+
+  /**
+   * Represents the callback in the APIs
+   */
+  type apiCallback = () => void;
+
+  /**
+   * Call control pane to get client configs
+   * @param writeKey
+   * @param dataPlaneUrl
+   * @param options
+   */
+  function load(writeKey: string, dataPlaneUrl: string, options?: loadOptions): void;
+
+  /**
+   * To register a callback for SDK ready state
+   * @param callback
+   */
+  function ready(callback: apiCallback): void;
+
+  /**
+   * To record a page view event
+   * @param category
+   * @param name
+   * @param properties
+   * @param options
+   * @param callback
+   */
+  function page(
+    category?: string,
+    name?: string,
+    properties?: apiObject,
+    options?: apiOptions,
+    callback?: apiCallback,
+  ): void;
+
+  /**
+   * To record a page view event
+   * @param category
+   * @param name
+   * @param properties
+   * @param callback
+   */
+  function page(category: string, name: string, properties: apiObject, callback: apiCallback): void;
+
+  /**
+   * To record a page view event
+   * @param category
+   * @param name
+   * @param callback
+   */
+  function page(category: string, name: string, callback: apiCallback): void;
+
+  /**
+   * To record a page view event
+   * @param name
+   * @param properties
+   * @param options
+   * @param callback
+   */
+  function page(
+    name: string,
+    properties?: apiObject,
+    options?: apiOptions,
+    callback?: apiCallback,
+  ): void;
+
+  /**
+   * To record a page view event
+   * @param name
+   * @param properties
+   * @param callback
+   */
+  function page(name: string, properties: apiObject, callback: apiCallback): void;
+
+  /**
+   *
+   * @param name
+   * @param callback
+   */
+  function page(name: string, callback: apiCallback): void;
+
+  /**
+   *
+   * @param properties
+   * @param options
+   * @param callback
+   */
+  function page(properties: apiObject, options: apiOptions, callback?: apiCallback): void;
+
+  /**
+   * To record a page view event
+   * @param properties
+   * @param callback
+   */
+  function page(properties: apiObject, callback?: apiCallback): void;
+
+  /**
+   * To record a user track event
+   * @param event
+   * @param properties
+   * @param options
+   * @param callback
+   */
+  function track(
+    event: string,
+    properties?: apiObject,
+    options?: apiOptions,
+    callback?: apiCallback,
+  ): void;
+
+  /**
+   * To record a user track event
+   * @param event
+   * @param properties
+   * @param callback
+   */
+  function track(event: string, properties: apiObject, callback: apiCallback): void;
+
+  /**
+   * To record a user track event
+   * @param event
+   * @param callback
+   */
+  function track(event: string, callback: apiCallback): void;
+
+  /**
+   * To record a user identification event
+   * @param userId
+   * @param traits
+   * @param options
+   * @param callback
+   */
+  function identify(
+    userId?: string,
+    traits?: apiObject,
+    options?: apiOptions,
+    callback?: apiCallback,
+  ): void;
+
+  /**
+   * To record a user identification event
+   * @param userId
+   * @param traits
+   * @param callback
+   */
+  function identify(userId: string, traits: apiObject, callback: apiCallback): void;
+
+  /**
+   * To record a user identification event
+   * @param userId
+   * @param callback
+   */
+  function identify(userId: string, callback: apiCallback): void;
+
+  /**
+   *
+   * @param traits
+   * @param options
+   * @param callback
+   */
+  function identify(traits: apiObject, options: apiOptions, callback?: apiCallback): void;
+
+  /**
+   *
+   * @param traits
+   * @param callback
+   */
+  function identify(traits: apiObject, callback?: apiCallback): void;
+
+  /**
+   * To record a user alias event
+   * @param to
+   * @param from
+   * @param options
+   * @param callback
+   */
+  function alias(to: string, from?: string, options?: apiOptions, callback?: apiCallback): void;
+
+  /**
+   * To record a user alias event
+   * @param to
+   * @param from
+   * @param callback
+   */
+  function alias(to: string, from: string, callback: apiCallback): void;
+
+  /**
+   * To record a user alias event
+   * @param to
+   * @param callback
+   */
+  function alias(to: string, callback: apiCallback): void;
+
+  /**
+   * To record a user alias event
+   * @param to
+   * @param options
+   * @param callback
+   */
+  function alias(to: string, options: apiOptions, callback?: apiCallback): void;
+
+  /**
+   * To record a user group event
+   * @param groupId
+   * @param traits
+   * @param options
+   * @param callback
+   */
+  function group(
+    groupId: string,
+    traits?: apiObject,
+    options?: apiOptions,
+    callback?: apiCallback,
+  ): void;
+
+  /**
+   * To record a user group event
+   * @param groupId
+   * @param traits
+   * @param callback
+   */
+  function group(groupId: string, traits: apiObject, callback: apiCallback): void;
+
+  /**
+   * To record a user group event
+   * @param groupId
+   * @param callback
+   */
+  function group(groupId: string, callback: apiCallback): void;
+
+  /**
+   * To record a user group event
+   * @param traits
+   * @param options
+   * @param callback
+   */
+  function group(traits: apiObject, options: apiOptions, callback?: apiCallback): void;
+
+  /**
+   * To record a user group event
+   * @param traits
+   * @param callback
+   */
+  function group(traits: apiObject, callback?: apiCallback): void;
+
+  /**
+   * To get anonymousId set in the SDK
+   */
+  function getAnonymousId(options?: anonymousIdOptions): string;
+
+  /**
+   * To set anonymousId
+   * @param anonymousId
+   * @param rudderAmpLinkerParm AMP Linker ID string
+   */
+  function setAnonymousId(anonymousId?: string, rudderAmpLinkerParm?: string): void;
+
+  /**
+   * Clear user information
+   * @param flag If true, clears anonymousId as well
+   */
+  function reset(flag?: boolean): void;
+
+  /**
+   * To get userId set in the SDK
+   */
+  function getUserId(): string;
+
+  /**
+   * To get user traits set in the SDK
+   */
+  function getUserTraits(): apiObject;
+
+  /**
+   * To get groupId set in the SDK
+   */
+  function getGroupId(): string;
+
+  /**
+   * To get group traits set in the SDK
+   */
+  function getGroupTraits(): apiObject;
+
+  /**
+   * To manually start user session in the SDK
+   */
+  function startSession(sessionId?: number): void;
+
+  /**
+   * To manually end user session in the SDK
+   */
+  function endSession(): void;
+
+  /**
+   * To fetch the current sessionId
+   */
+  function getSessionId(): number | null;
+
+  export {
+    integrationOptions,
+    loadOptions,
+    apiOptions,
+    queueOptions,
+    apiObject,
+    apiCallback,
+    anonymousIdOptions,
+    load,
+    ready,
+    reset,
+    page,
+    track,
+    identify,
+    alias,
+    group,
+    setAnonymousId,
+    getAnonymousId,
+    getUserId,
+    getUserTraits,
+    getGroupId,
+    getGroupTraits,
+    startSession,
+    endSession,
+    RESIDENCY_SERVER,
+    getSessionId,
+  };
+}