iureiure 1.0.0

package/packages/analytics-js-plugins/src/nativeDestinationQueue/index.ts

@@ -0,0 +1,159 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable no-param-reassign */
+import type { ApplicationState } from '@rudderstack/analytics-js-common/types/ApplicationState';
+import type {
+  IPluginsManager,
+  PluginName,
+} from '@rudderstack/analytics-js-common/types/PluginsManager';
+import type { IStoreManager } from '@rudderstack/analytics-js-common/types/Store';
+import type { IErrorHandler } from '@rudderstack/analytics-js-common/types/ErrorHandler';
+import type { ILogger } from '@rudderstack/analytics-js-common/types/Logger';
+import type { QueueOpts } from '@rudderstack/analytics-js-common/types/LoadOptions';
+import type { RudderEvent } from '@rudderstack/analytics-js-common/types/Event';
+import type { Destination } from '@rudderstack/analytics-js-common/types/Destination';
+import type { ExtensionPlugin } from '@rudderstack/analytics-js-common/types/PluginEngine';
+import { clone } from 'ramda';
+import { storages } from '../shared-chunks/common';
+import type { DoneCallback, IQueue } from '../types/plugins';
+import { RetryQueue } from '../utilities/retryQueue/RetryQueue';
+import { getNormalizedQueueOptions, isEventDenyListed, sendEventToDestination } from './utilities';
+import { NATIVE_DESTINATION_QUEUE_PLUGIN, QUEUE_NAME } from './constants';
+import { DESTINATION_EVENT_FILTERING_WARNING } from './logMessages';
+import { destinationUtils } from '../shared-chunks/deviceModeDestinations';
+
+const pluginName: PluginName = 'NativeDestinationQueue';
+
+const NativeDestinationQueue = (): ExtensionPlugin => ({
+  name: pluginName,
+  deps: [],
+  initialize: (state: ApplicationState) => {
+    state.plugins.loadedPlugins.value = [...state.plugins.loadedPlugins.value, pluginName];
+  },
+  destinationsEventsQueue: {
+    /**
+     * Initialize the queue for delivery to destinations
+     * @param state Application state
+     * @param pluginsManager PluginsManager instance
+     * @param storeManager StoreManager instance
+     * @param errorHandler Error handler instance
+     * @param logger Logger instance
+     * @returns IQueue instance
+     */
+    init(
+      state: ApplicationState,
+      pluginsManager: IPluginsManager,
+      storeManager: IStoreManager,
+      dmtQueue: IQueue,
+      errorHandler?: IErrorHandler,
+      logger?: ILogger,
+    ): IQueue {
+      const finalQOpts = getNormalizedQueueOptions(
+        state.loadOptions.value.destinationsQueueOptions as QueueOpts,
+      );
+
+      const writeKey = state.lifecycle.writeKey.value as string;
+      const eventsQueue = new RetryQueue(
+        // adding write key to the queue name to avoid conflicts
+        `${QUEUE_NAME}_${writeKey}`,
+        finalQOpts,
+        (rudderEvent: RudderEvent, done: DoneCallback) => {
+          const destinationsToSend = destinationUtils.filterDestinations(
+            rudderEvent.integrations,
+            state.nativeDestinations.initializedDestinations.value,
+          );
+
+          // list of destinations which are enable for DMT
+          const destWithTransformationEnabled: Destination[] = [];
+          const clonedRudderEvent = clone(rudderEvent);
+
+          destinationsToSend.forEach((dest: Destination) => {
+            try {
+              const sendEvent = !isEventDenyListed(
+                clonedRudderEvent.type,
+                clonedRudderEvent.event,
+                dest,
+              );
+              if (!sendEvent) {
+                logger?.warn(
+                  DESTINATION_EVENT_FILTERING_WARNING(
+                    NATIVE_DESTINATION_QUEUE_PLUGIN,
+                    clonedRudderEvent.event,
+                    dest.userFriendlyId,
+                  ),
+                );
+                return;
+              }
+
+              if (dest.shouldApplyDeviceModeTransformation) {
+                destWithTransformationEnabled.push(dest);
+              } else {
+                sendEventToDestination(clonedRudderEvent, dest, errorHandler, logger);
+              }
+            } catch (e) {
+              errorHandler?.onError(e, NATIVE_DESTINATION_QUEUE_PLUGIN);
+            }
+          });
+          if (destWithTransformationEnabled.length > 0) {
+            pluginsManager.invokeSingle(
+              'transformEvent.enqueue',
+              state,
+              dmtQueue,
+              clonedRudderEvent,
+              destWithTransformationEnabled,
+              errorHandler,
+              logger,
+            );
+          }
+
+          // Mark success always
+          done(null);
+        },
+        storeManager,
+        storages.MEMORY_STORAGE,
+      );
+
+      // TODO: This seems to not work as expected. Need to investigate
+      // effect(() => {
+      //   if (state.nativeDestinations.clientDestinationsReady.value === true) {
+      //     eventsQueue.start();
+      //   }
+      // });
+      return eventsQueue;
+    },
+
+    /**
+     * Add event to the queue for delivery to destinations
+     * @param state Application state
+     * @param eventsQueue IQueue instance
+     * @param event RudderEvent object
+     * @param errorHandler Error handler instance
+     * @param logger Logger instance
+     * @returns none
+     */
+    enqueue(
+      state: ApplicationState,
+      eventsQueue: IQueue,
+      event: RudderEvent,
+      errorHandler?: IErrorHandler,
+      logger?: ILogger,
+    ): void {
+      eventsQueue.addItem(event);
+    },
+
+    /**
+     * This extension point is used to directly send the transformed event to the destination
+     * @param state Application state
+     * @param event RudderEvent Object
+     * @param destination Destination Object
+     * @param errorHandler Error handler instance
+     * @param logger Logger instance
+     */
+    enqueueEventToDestination(state, event, destination, errorHandler, logger) {
+      sendEventToDestination(event, destination, errorHandler, logger);
+    },
+  },
+});
+
+export { NativeDestinationQueue };
+
+export default NativeDestinationQueue;

package/packages/analytics-js-plugins/src/nativeDestinationQueue/logMessages.ts

@@ -0,0 +1,14 @@
+import { LOG_CONTEXT_SEPARATOR } from '@rudderstack/analytics-js-common/constants/logMessages';
+import type { Nullable } from '@rudderstack/analytics-js-common/types/Nullable';
+
+const DESTINATION_EVENT_FILTERING_WARNING = (
+  context: string,
+  eventName: Nullable<string>,
+  destUserFriendlyId: string,
+): string =>
+  `${context}${LOG_CONTEXT_SEPARATOR}The "${eventName}" track event has been filtered for the "${destUserFriendlyId}" destination.`;
+
+const DESTINATION_EVENT_FORWARDING_ERROR = (destUserFriendlyId: string): string =>
+  `Failed to forward event to destination "${destUserFriendlyId}".`;
+
+export { DESTINATION_EVENT_FILTERING_WARNING, DESTINATION_EVENT_FORWARDING_ERROR };

package/packages/analytics-js-plugins/src/nativeDestinationQueue/utilities.ts

@@ -0,0 +1,81 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import { mergeDeepRight } from '@rudderstack/analytics-js-common/utilities/object';
+import type { DestinationsQueueOpts } from '@rudderstack/analytics-js-common/types/LoadOptions';
+import type { Destination } from '@rudderstack/analytics-js-common/types/Destination';
+import type { RudderEvent } from '@rudderstack/analytics-js-common/types/Event';
+import type { IErrorHandler } from '@rudderstack/analytics-js-common/types/ErrorHandler';
+import type { ILogger } from '@rudderstack/analytics-js-common/types/Logger';
+import type { Nullable } from '@rudderstack/analytics-js-common/types/Nullable';
+import type { RudderEventType } from '../types/plugins';
+import { DEFAULT_QUEUE_OPTIONS, NATIVE_DESTINATION_QUEUE_PLUGIN } from './constants';
+import { DESTINATION_EVENT_FORWARDING_ERROR } from './logMessages';
+
+const getNormalizedQueueOptions = (queueOpts: DestinationsQueueOpts): DestinationsQueueOpts =>
+  mergeDeepRight(DEFAULT_QUEUE_OPTIONS, queueOpts);
+
+const isValidEventName = (eventName: Nullable<string>) =>
+  eventName && typeof eventName === 'string';
+
+const isEventDenyListed = (
+  eventType: RudderEventType,
+  eventName: Nullable<string>,
+  dest: Destination,
+) => {
+  if (eventType !== 'track') {
+    return false;
+  }
+
+  const { blacklistedEvents, whitelistedEvents, eventFilteringOption } = dest.config;
+
+  switch (eventFilteringOption) {
+    // Blacklist is chosen for filtering events
+    case 'blacklistedEvents': {
+      if (!isValidEventName(eventName)) {
+        return false;
+      }
+      const trimmedEventName = (eventName as string).trim();
+      if (Array.isArray(blacklistedEvents)) {
+        return blacklistedEvents.some(eventObj => eventObj.eventName.trim() === trimmedEventName);
+      }
+      return false;
+    }
+
+    // Whitelist is chosen for filtering events
+    case 'whitelistedEvents': {
+      if (!isValidEventName(eventName)) {
+        return true;
+      }
+      const trimmedEventName = (eventName as string).trim();
+      if (Array.isArray(whitelistedEvents)) {
+        return !whitelistedEvents.some(eventObj => eventObj.eventName.trim() === trimmedEventName);
+      }
+      return true;
+    }
+
+    case 'disable':
+    default:
+      return false;
+  }
+};
+
+const sendEventToDestination = (
+  item: RudderEvent,
+  dest: Destination,
+  errorHandler?: IErrorHandler,
+  logger?: ILogger,
+) => {
+  const methodName = item.type.toString();
+  try {
+    // Destinations expect the event to be wrapped under the `message` key
+    // This will remain until we update the destinations to accept the event directly
+    dest.instance?.[methodName]?.({ message: item });
+  } catch (err) {
+    errorHandler?.onError(
+      err,
+      NATIVE_DESTINATION_QUEUE_PLUGIN,
+      DESTINATION_EVENT_FORWARDING_ERROR(dest.userFriendlyId),
+    );
+  }
+};
+
+export { getNormalizedQueueOptions, isEventDenyListed, sendEventToDestination };

package/packages/analytics-js-plugins/src/oneTrustConsentManager/constants.ts

@@ -0,0 +1,3 @@
+const ONETRUST_CONSENT_MANAGER_PLUGIN = 'OneTrustConsentManagerPlugin';
+
+export { ONETRUST_CONSENT_MANAGER_PLUGIN };

package/packages/analytics-js-plugins/src/oneTrustConsentManager/index.ts

@@ -0,0 +1,131 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable no-param-reassign */
+import type { ApplicationState } from '@rudderstack/analytics-js-common/types/ApplicationState';
+import type { DestinationConfig } from '@rudderstack/analytics-js-common/types/Destination';
+import type { ILogger } from '@rudderstack/analytics-js-common/types/Logger';
+import type { ExtensionPlugin } from '@rudderstack/analytics-js-common/types/PluginEngine';
+import type { IStoreManager } from '@rudderstack/analytics-js-common/types/Store';
+import type { IErrorHandler } from '@rudderstack/analytics-js-common/types/ErrorHandler';
+import type { PluginName } from '@rudderstack/analytics-js-common/types/PluginsManager';
+import { DESTINATION_CONSENT_STATUS_ERROR, ONETRUST_ACCESS_ERROR } from './logMessages';
+import { ONETRUST_CONSENT_MANAGER_PLUGIN } from './constants';
+import type { OneTrustGroup } from './types';
+
+const pluginName: PluginName = 'OneTrustConsentManager';
+
+const OneTrustConsentManager = (): ExtensionPlugin => ({
+  name: pluginName,
+  deps: [],
+  initialize: (state: ApplicationState) => {
+    state.plugins.loadedPlugins.value = [...state.plugins.loadedPlugins.value, pluginName];
+  },
+  consentManager: {
+    init(state: ApplicationState, logger?: ILogger): void {
+      // Nothing to initialize
+    },
+
+    updateConsentsInfo(
+      state: ApplicationState,
+      storeManager?: IStoreManager,
+      logger?: ILogger,
+    ): void {
+      if (!(globalThis as any).OneTrust || !(globalThis as any).OnetrustActiveGroups) {
+        logger?.error(ONETRUST_ACCESS_ERROR(ONETRUST_CONSENT_MANAGER_PLUGIN));
+        state.consents.initialized.value = false;
+        return;
+      }
+
+      // Get the groups (cookie categorization), user has created in OneTrust account.
+      const oneTrustAllGroupsInfo: OneTrustGroup[] = (globalThis as any).OneTrust.GetDomainData()
+        .Groups;
+
+      // OneTrustConsentManager SDK populates a data layer object OnetrustActiveGroups with
+      // the cookie categories Ids that the user has consented to.
+      // Eg: ',C0001,C0003,'
+      // We split it and save it as an array.
+      const allowedConsentIds = (globalThis as any).OnetrustActiveGroups.split(',').filter(
+        (n: string) => n,
+      );
+
+      const deniedConsentIds: string[] = [];
+      oneTrustAllGroupsInfo.forEach(({ CustomGroupId }: OneTrustGroup) => {
+        if (!allowedConsentIds.includes(CustomGroupId)) {
+          deniedConsentIds.push(CustomGroupId);
+        }
+      });
+
+      state.consents.initialized.value = true;
+      state.consents.data.value = { allowedConsentIds, deniedConsentIds };
+    },
+
+    isDestinationConsented(
+      state: ApplicationState,
+      destConfig: DestinationConfig,
+      errorHandler?: IErrorHandler,
+      logger?: ILogger,
+    ): boolean {
+      if (!state.consents.initialized.value) {
+        return true;
+      }
+      const allowedConsentIds = state.consents.data.value.allowedConsentIds as string[];
+
+      try {
+        // mapping of the destination with the consent group name
+        const { oneTrustCookieCategories, consentManagement } = destConfig;
+
+        const matchPredicate = (consent: string) => allowedConsentIds.includes(consent);
+
+        // Generic consent management
+        if (consentManagement) {
+          // Get the corresponding consents for the destination
+          const cmpConsents = consentManagement.find(
+            c => c.provider === state.consents.provider.value,
+          )?.consents;
+
+          // If there are no consents configured for the destination for the current provider, events should be sent.
+          if (!cmpConsents) {
+            return true;
+          }
+
+          const configuredConsents = cmpConsents.map(c => c.consent.trim()).filter(n => n);
+
+          // match the configured consents with user provided consents as per
+          // the configured resolution strategy
+          switch (state.consents.resolutionStrategy.value) {
+            case 'or':
+              return configuredConsents.some(matchPredicate) || configuredConsents.length === 0;
+            case 'and':
+            default:
+              return configuredConsents.every(matchPredicate);
+          }
+          // Legacy cookie consent management
+          // TODO: To be removed once the source config API is updated to support generic consent management
+        } else if (oneTrustCookieCategories) {
+          // Change the structure of oneTrustConsentGroup as an array and filter values if empty string
+          // Eg:
+          // ["Performance Cookies", "Functional Cookies"]
+          const configuredConsents = oneTrustCookieCategories
+            .map(c => c.oneTrustCookieCategory.trim())
+            .filter(n => n);
+
+          // Check if all the destination's mapped cookie categories are consented by the user in the browser.
+          return configuredConsents.every(matchPredicate);
+        }
+
+        // If there are no consents configured for the destination for the current provider, events should be sent.
+        return true;
+      } catch (err) {
+        errorHandler?.onError(
+          err,
+          ONETRUST_CONSENT_MANAGER_PLUGIN,
+          DESTINATION_CONSENT_STATUS_ERROR,
+        );
+        return true;
+      }
+    },
+  },
+});
+
+export { OneTrustConsentManager };
+
+export default OneTrustConsentManager;

package/packages/analytics-js-plugins/src/oneTrustConsentManager/logMessages.ts

@@ -0,0 +1,8 @@
+import { LOG_CONTEXT_SEPARATOR } from '@rudderstack/analytics-js-common/constants/logMessages';
+
+const ONETRUST_ACCESS_ERROR = (context: string): string =>
+  `${context}${LOG_CONTEXT_SEPARATOR}Failed to access OneTrust SDK resources. Please ensure that the OneTrust SDK is loaded successfully before RudderStack SDK.`;
+
+const DESTINATION_CONSENT_STATUS_ERROR = `Failed to determine the consent status for the destination. Please check the destination configuration and try again.`;
+
+export { ONETRUST_ACCESS_ERROR, DESTINATION_CONSENT_STATUS_ERROR };

package/packages/analytics-js-plugins/src/oneTrustConsentManager/types.ts

@@ -0,0 +1,4 @@
+export type OneTrustGroup = {
+  CustomGroupId: string;
+  GroupName: string;
+};

package/packages/analytics-js-plugins/src/shared-chunks/common.ts

@@ -0,0 +1,13 @@
+export * as storages from '@rudderstack/analytics-js-common/constants/storages';
+export * as checks from '@rudderstack/analytics-js-common/utilities/checks';
+export * as object from '@rudderstack/analytics-js-common/utilities/object';
+export * as url from '@rudderstack/analytics-js-common/utilities/url';
+export * as uuId from '@rudderstack/analytics-js-common/utilities/uuId';
+export * as http from '@rudderstack/analytics-js-common/utilities/http';
+export * as string from '@rudderstack/analytics-js-common/utilities/string';
+export * as json from '@rudderstack/analytics-js-common/utilities/json';
+export * as timestamp from '@rudderstack/analytics-js-common/utilities/timestamp';
+// eslint-disable-next-line import/no-cycle
+export * as eventsDelivery from '../utilities/eventsDelivery';
+// eslint-disable-next-line import/no-cycle
+export * as encryption from '../storageEncryption/encryptionUtils';

package/packages/analytics-js-plugins/src/shared-chunks/deviceModeDestinations.ts

@@ -0,0 +1,3 @@
+export * as eventMethodOverloads from '@rudderstack/analytics-js-common/utilities/eventMethodOverloads';
+export * as destinations from '@rudderstack/analytics-js-common/utilities/destinations';
+export * as destinationUtils from '../utilities/destination';

package/packages/analytics-js-plugins/src/storageEncryption/constants.ts

@@ -0,0 +1 @@
+export const ENCRYPTION_PREFIX_V3 = 'RS_ENC_v3_';

package/packages/analytics-js-plugins/src/storageEncryption/encryptionUtils.ts

@@ -0,0 +1,14 @@
+import { fromBase64, toBase64 } from '@rudderstack/analytics-js-common/utilities/string';
+import { ENCRYPTION_PREFIX_V3 } from './constants';
+
+const encrypt = (value: string): string => `${ENCRYPTION_PREFIX_V3}${toBase64(value)}`;
+
+const decrypt = (value: string): string => {
+  if (value.startsWith(ENCRYPTION_PREFIX_V3)) {
+    return fromBase64(value.substring(ENCRYPTION_PREFIX_V3.length));
+  }
+
+  return value;
+};
+
+export { encrypt, decrypt };

package/packages/analytics-js-plugins/src/storageEncryption/index.ts

@@ -0,0 +1,26 @@
+/* eslint-disable no-param-reassign */
+import type { ApplicationState } from '@rudderstack/analytics-js-common/types/ApplicationState';
+import type { ExtensionPlugin } from '@rudderstack/analytics-js-common/types/PluginEngine';
+import type { PluginName } from '@rudderstack/analytics-js-common/types/PluginsManager';
+import { encryption } from '../shared-chunks/common';
+
+const pluginName: PluginName = 'StorageEncryption';
+
+const StorageEncryption = (): ExtensionPlugin => ({
+  name: pluginName,
+  initialize: (state: ApplicationState) => {
+    state.plugins.loadedPlugins.value = [...state.plugins.loadedPlugins.value, pluginName];
+  },
+  storage: {
+    encrypt(value: any): string {
+      return encryption.encrypt(value);
+    },
+    decrypt(value: string): string {
+      return encryption.decrypt(value);
+    },
+  },
+});
+
+export { StorageEncryption };
+
+export default StorageEncryption;

package/packages/analytics-js-plugins/src/storageEncryptionLegacy/constants.ts

@@ -0,0 +1,2 @@
+export const ENCRYPTION_PREFIX_V1 = 'RudderEncrypt:';
+export const ENCRYPTION_KEY_V1 = 'Rudder';

package/packages/analytics-js-plugins/src/storageEncryptionLegacy/index.ts

@@ -0,0 +1,26 @@
+/* eslint-disable no-param-reassign */
+import type { ApplicationState } from '@rudderstack/analytics-js-common/types/ApplicationState';
+import type { ExtensionPlugin } from '@rudderstack/analytics-js-common/types/PluginEngine';
+import type { PluginName } from '@rudderstack/analytics-js-common/types/PluginsManager';
+import { decrypt, encrypt } from './legacyEncryptionUtils';
+
+const pluginName: PluginName = 'StorageEncryptionLegacy';
+
+const StorageEncryptionLegacy = (): ExtensionPlugin => ({
+  name: pluginName,
+  initialize: (state: ApplicationState) => {
+    state.plugins.loadedPlugins.value = [...state.plugins.loadedPlugins.value, pluginName];
+  },
+  storage: {
+    encrypt(value: any): string {
+      return encrypt(value);
+    },
+    decrypt(value: string): string {
+      return decrypt(value);
+    },
+  },
+});
+
+export { StorageEncryptionLegacy };
+
+export default StorageEncryptionLegacy;

package/packages/analytics-js-plugins/src/storageEncryptionLegacy/legacyEncryptionUtils.ts

@@ -0,0 +1,18 @@
+import { AES } from 'crypto-es/lib/aes';
+import { Utf8 } from 'crypto-es/lib/core';
+import { ENCRYPTION_PREFIX_V1, ENCRYPTION_KEY_V1 } from './constants';
+
+const encrypt = (value: string): string =>
+  `${ENCRYPTION_PREFIX_V1}${AES.encrypt(value, ENCRYPTION_KEY_V1).toString()}`;
+
+const decrypt = (value: string): string => {
+  if (value.startsWith(ENCRYPTION_PREFIX_V1)) {
+    return AES.decrypt(value.substring(ENCRYPTION_PREFIX_V1.length), ENCRYPTION_KEY_V1).toString(
+      Utf8,
+    );
+  }
+
+  return value;
+};
+
+export { encrypt, decrypt };

package/packages/analytics-js-plugins/src/storageMigrator/constants.ts

@@ -0,0 +1,3 @@
+const STORAGE_MIGRATOR_PLUGIN = 'StorageMigratorPlugin';
+
+export { STORAGE_MIGRATOR_PLUGIN };

package/packages/analytics-js-plugins/src/storageMigrator/index.ts

@@ -0,0 +1,59 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable no-param-reassign */
+import type { ExtensionPlugin } from '@rudderstack/analytics-js-common/types/PluginEngine';
+import type { IStorage } from '@rudderstack/analytics-js-common/types/Store';
+import type { ApplicationState } from '@rudderstack/analytics-js-common/types/ApplicationState';
+import type { ILogger } from '@rudderstack/analytics-js-common/types/Logger';
+import type { Nullable } from '@rudderstack/analytics-js-common/types/Nullable';
+import type { IErrorHandler } from '@rudderstack/analytics-js-common/types/ErrorHandler';
+import type { PluginName } from '@rudderstack/analytics-js-common/types/PluginsManager';
+import { checks, encryption } from '../shared-chunks/common';
+import { decrypt as decryptLegacy } from '../storageEncryptionLegacy/legacyEncryptionUtils';
+import { STORAGE_MIGRATION_ERROR } from './logMessages';
+import { STORAGE_MIGRATOR_PLUGIN } from './constants';
+
+const pluginName: PluginName = 'StorageMigrator';
+
+const StorageMigrator = (): ExtensionPlugin => ({
+  name: pluginName,
+  initialize: (state: ApplicationState) => {
+    state.plugins.loadedPlugins.value = [...state.plugins.loadedPlugins.value, pluginName];
+  },
+  storage: {
+    migrate(
+      key: string,
+      storageEngine: IStorage,
+      errorHandler?: IErrorHandler,
+      logger?: ILogger,
+    ): Nullable<string> {
+      try {
+        const storedVal = storageEngine.getItem(key);
+        if (checks.isNullOrUndefined(storedVal)) {
+          return null;
+        }
+
+        let decryptedVal = decryptLegacy(storedVal as string);
+
+        // The value is not encrypted using legacy encryption
+        // Try latest
+        if (decryptedVal === storedVal) {
+          decryptedVal = encryption.decrypt(storedVal);
+        }
+
+        if (checks.isNullOrUndefined(decryptedVal)) {
+          return null;
+        }
+
+        // storejs that is used in localstorage engine already deserializes json strings but swallows errors
+        return JSON.parse(decryptedVal);
+      } catch (err) {
+        errorHandler?.onError(err, STORAGE_MIGRATOR_PLUGIN, STORAGE_MIGRATION_ERROR(key));
+        return null;
+      }
+    },
+  },
+});
+
+export { StorageMigrator };
+
+export default StorageMigrator;

package/packages/analytics-js-plugins/src/storageMigrator/logMessages.ts

@@ -0,0 +1,4 @@
+const STORAGE_MIGRATION_ERROR = (key: string): string =>
+  `Failed to retrieve or parse data for ${key} from storage.`;
+
+export { STORAGE_MIGRATION_ERROR };

package/packages/analytics-js-plugins/src/types/plugins.ts

@@ -0,0 +1,69 @@
+import type { IStore, IStoreManager } from '@rudderstack/analytics-js-common/types/Store';
+import type { Nullable } from '@rudderstack/analytics-js-common/types/Nullable';
+
+export type { Bugsnag as BugsnagLib } from '@bugsnag/js';
+
+export type RudderEventType = 'page' | 'track' | 'identify' | 'alias' | 'group';
+
+export type LogLevel = 'LOG' | 'INFO' | 'DEBUG' | 'WARN' | 'ERROR' | 'NONE';
+
+export type QueueItem<T = QueueItemData> = {
+  item: T;
+  attemptNumber: number;
+  time: number;
+  id: string;
+};
+
+export type QueueItemData =
+  | Record<string, any>
+  | string
+  | number
+  | Record<string, any>[]
+  | string[]
+  | number[];
+
+/**
+ * @callback QueueProcessCallback
+ * @param {any} item The item added to the queue to process
+ * @param {Function} done A function to call when processing is completed.
+ * @param {Number} retryAttemptNumber The number of times this item has been attempted to retry
+ * @param {Number} maxRetryAttempts The maximum number of times this item should be attempted to retry
+ * @param {Number} willBeRetried A boolean indicating if the item will be retried later
+ */
+export type QueueProcessCallback<T = any> = (
+  item: T,
+  done: DoneCallback,
+  retryAttemptNumber?: number,
+  maxRetryAttempts?: number,
+  willBeRetried?: boolean,
+) => void;
+
+export type QueueBatchItemsSizeCalculatorCallback<T = any> = (item: T) => number;
+
+/**
+ * @callback DoneCallback
+ * @param {Error} Optional error parameter if the processing failed
+ * @param {Response} Optional response parameter to emit for async handling
+ */
+export type DoneCallback = (error?: any, response?: any) => void;
+
+export interface IQueue<T = any> {
+  name: string;
+  id: string;
+  processQueueCb: QueueProcessCallback;
+  store: IStore;
+  storeManager: IStoreManager;
+  maxItems: number;
+  timeouts: Record<string, number>;
+  scheduleTimeoutActive: boolean;
+  attachListeners?(): void;
+  getStorageEntry(name?: string): Nullable<QueueItem<T>[] | Record<string, any> | number>;
+  setStorageEntry(
+    name?: string,
+    value?: Nullable<QueueItem<T>[] | Record<string, any> | number>,
+  ): void;
+  start(): void;
+  stop(): void;
+  enqueue(item: QueueItem<T>): void;
+  addItem(item: T): void;
+}

package/packages/analytics-js-plugins/src/utilities/constants.ts

@@ -0,0 +1,3 @@
+const EVENT_PAYLOAD_SIZE_BYTES_LIMIT = 32 * 1024; // 32 KB
+
+export { EVENT_PAYLOAD_SIZE_BYTES_LIMIT };