iureiure 1.0.0

package/packages/analytics-js/src/components/pluginsManager/PluginsManager.ts

@@ -0,0 +1,332 @@
+import { batch, effect } from '@preact/signals-core';
+import type {
+  ExtensionPlugin,
+  IPluginEngine,
+} from '@rudderstack/analytics-js-common/types/PluginEngine';
+import { getNonCloudDestinations } from '@rudderstack/analytics-js-common/utilities/destinations';
+import type {
+  IPluginsManager,
+  PluginName,
+} from '@rudderstack/analytics-js-common/types/PluginsManager';
+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 { PLUGINS_MANAGER } from '@rudderstack/analytics-js-common/constants/loggerContexts';
+import { isFunction } from '@rudderstack/analytics-js-common/utilities/checks';
+import { setExposedGlobal } from '../utilities/globals';
+import { state } from '../../state';
+import {
+  ErrorReportingProvidersToPluginNameMap,
+  ConsentManagersToPluginNameMap,
+  StorageEncryptionVersionsToPluginNameMap,
+} from '../configManager/constants';
+import { UNSUPPORTED_BEACON_API_WARNING } from '../../constants/logMessages';
+import { pluginNamesList } from './pluginNames';
+import {
+  getMandatoryPluginsMap,
+  pluginsInventory,
+  remotePluginsInventory,
+} from './pluginsInventory';
+
+// TODO: we may want to add chained plugins that pass their value to the next one
+// TODO: add retry mechanism for getting remote plugins
+// TODO: add timeout error mechanism for marking remote plugins that failed to load as failed in state
+class PluginsManager implements IPluginsManager {
+  engine: IPluginEngine;
+  errorHandler?: IErrorHandler;
+  logger?: ILogger;
+
+  constructor(engine: IPluginEngine, errorHandler?: IErrorHandler, logger?: ILogger) {
+    this.engine = engine;
+
+    this.errorHandler = errorHandler;
+    this.logger = logger;
+    this.onError = this.onError.bind(this);
+  }
+
+  /**
+   * Orchestrate the plugin loading and registering
+   */
+  init() {
+    state.lifecycle.status.value = 'pluginsLoading';
+    // Expose pluginsCDNPath to global object, so it can be used in the promise that determines
+    // remote plugin cdn path to support proxied plugin remotes
+    if (!__BUNDLE_ALL_PLUGINS__) {
+      setExposedGlobal('pluginsCDNPath', state.lifecycle.pluginsCDNPath.value);
+    }
+    this.setActivePlugins();
+    this.registerLocalPlugins();
+    this.registerRemotePlugins();
+    this.attachEffects();
+  }
+
+  /**
+   * Update state based on plugin loaded status
+   */
+  // eslint-disable-next-line class-methods-use-this
+  attachEffects() {
+    effect(() => {
+      const isAllPluginsReady =
+        state.plugins.activePlugins.value.length === 0 ||
+        state.plugins.loadedPlugins.value.length + state.plugins.failedPlugins.value.length ===
+          state.plugins.totalPluginsToLoad.value;
+
+      if (isAllPluginsReady) {
+        batch(() => {
+          state.plugins.ready.value = true;
+          // TODO: decide what to do if a plugin fails to load for any reason.
+          //  Should we stop here or should we progress?
+          state.lifecycle.status.value = 'pluginsReady';
+        });
+      }
+    });
+  }
+
+  /**
+   * Determine the list of plugins that should be loaded based on sourceConfig & load options
+   */
+  // eslint-disable-next-line class-methods-use-this
+  getPluginsToLoadBasedOnConfig(): PluginName[] {
+    // This contains the default plugins if load option has been omitted by user
+    let pluginsToLoadFromConfig = state.plugins.pluginsToLoadFromConfig.value as PluginName[];
+
+    if (!pluginsToLoadFromConfig) {
+      return [];
+    }
+
+    // Error reporting related plugins
+    const supportedErrReportingProviderPluginNames: string[] = Object.values(
+      ErrorReportingProvidersToPluginNameMap,
+    );
+    if (state.reporting.errorReportingProviderPluginName.value) {
+      pluginsToLoadFromConfig = pluginsToLoadFromConfig.filter(
+        pluginName =>
+          !(
+            pluginName !== state.reporting.errorReportingProviderPluginName.value &&
+            supportedErrReportingProviderPluginNames.includes(pluginName)
+          ),
+      );
+    } else {
+      pluginsToLoadFromConfig = pluginsToLoadFromConfig.filter(
+        pluginName =>
+          !(
+            pluginName === 'ErrorReporting' ||
+            supportedErrReportingProviderPluginNames.includes(pluginName)
+          ),
+      );
+    }
+
+    // Cloud mode (dataplane) events delivery plugins
+    if (state.loadOptions.value.useBeacon === true && state.capabilities.isBeaconAvailable.value) {
+      pluginsToLoadFromConfig = pluginsToLoadFromConfig.filter(
+        pluginName => pluginName !== 'XhrQueue',
+      );
+    } else {
+      if (state.loadOptions.value.useBeacon === true) {
+        this.logger?.warn(UNSUPPORTED_BEACON_API_WARNING(PLUGINS_MANAGER));
+      }
+
+      pluginsToLoadFromConfig = pluginsToLoadFromConfig.filter(
+        pluginName => pluginName !== 'BeaconQueue',
+      );
+    }
+
+    // Enforce default cloud mode event delivery queue plugin is none exists
+    if (
+      !pluginsToLoadFromConfig.includes('XhrQueue') &&
+      !pluginsToLoadFromConfig.includes('BeaconQueue')
+    ) {
+      pluginsToLoadFromConfig.push('XhrQueue');
+    }
+
+    // Device mode destinations related plugins
+    if (
+      getNonCloudDestinations(state.nativeDestinations.configuredDestinations.value ?? [])
+        .length === 0
+    ) {
+      pluginsToLoadFromConfig = pluginsToLoadFromConfig.filter(
+        pluginName =>
+          ![
+            'DeviceModeDestinations',
+            'DeviceModeTransformation',
+            'NativeDestinationQueue',
+          ].includes(pluginName),
+      );
+    }
+
+    // Consent Management related plugins
+    const supportedConsentManagerPlugins: string[] = Object.values(ConsentManagersToPluginNameMap);
+    let filterCondition = (pluginName: PluginName) =>
+      !(
+        pluginName !== state.consents.activeConsentManagerPluginName.value &&
+        supportedConsentManagerPlugins.includes(pluginName)
+      );
+
+    if (!state.consents.enabled.value) {
+      filterCondition = (pluginName: PluginName) =>
+        !supportedConsentManagerPlugins.includes(pluginName);
+    }
+
+    pluginsToLoadFromConfig = pluginsToLoadFromConfig.filter(filterCondition);
+
+    // Storage encryption related plugins
+    const supportedStorageEncryptionPlugins: string[] = Object.values(
+      StorageEncryptionVersionsToPluginNameMap,
+    );
+    pluginsToLoadFromConfig = pluginsToLoadFromConfig.filter(
+      pluginName =>
+        !(
+          pluginName !== state.storage.encryptionPluginName.value &&
+          supportedStorageEncryptionPlugins.includes(pluginName)
+        ),
+    );
+
+    // Storage migrator related plugins
+    if (!state.storage.migrate.value) {
+      pluginsToLoadFromConfig = pluginsToLoadFromConfig.filter(
+        pluginName => pluginName !== 'StorageMigrator',
+      );
+    }
+
+    return [...(Object.keys(getMandatoryPluginsMap()) as PluginName[]), ...pluginsToLoadFromConfig];
+  }
+
+  /**
+   * Determine the list of plugins that should be activated
+   */
+  setActivePlugins() {
+    const pluginsToLoad = this.getPluginsToLoadBasedOnConfig();
+    // Merging available mandatory and optional plugin name list
+    const availablePlugins = [...Object.keys(pluginsInventory), ...pluginNamesList];
+    const activePlugins: PluginName[] = [];
+    const failedPlugins: string[] = [];
+
+    pluginsToLoad.forEach(pluginName => {
+      if (availablePlugins.includes(pluginName)) {
+        activePlugins.push(pluginName);
+      } else {
+        failedPlugins.push(pluginName);
+      }
+    });
+
+    if (failedPlugins.length > 0) {
+      this.onError(
+        new Error(
+          `Ignoring loading of unknown plugins: ${failedPlugins.join(
+            ',',
+          )}. Mandatory plugins: ${Object.keys(getMandatoryPluginsMap()).join(
+            ',',
+          )}. Load option plugins: ${state.plugins.pluginsToLoadFromConfig.value.join(',')}`,
+        ),
+      );
+    }
+
+    batch(() => {
+      state.plugins.totalPluginsToLoad.value = pluginsToLoad.length;
+      state.plugins.activePlugins.value = activePlugins;
+      state.plugins.failedPlugins.value = failedPlugins;
+    });
+  }
+
+  /**
+   * Register plugins that are direct imports to PluginEngine
+   */
+  registerLocalPlugins() {
+    Object.values(pluginsInventory).forEach(localPlugin => {
+      if (
+        isFunction(localPlugin) &&
+        state.plugins.activePlugins.value.includes(localPlugin().name)
+      ) {
+        this.register([localPlugin()]);
+      }
+    });
+  }
+
+  /**
+   * Register plugins that are dynamic imports to PluginEngine
+   */
+  registerRemotePlugins() {
+    const remotePluginsList = remotePluginsInventory(
+      state.plugins.activePlugins.value as PluginName[],
+    );
+
+    Promise.all(
+      Object.keys(remotePluginsList).map(async remotePluginKey => {
+        await remotePluginsList[remotePluginKey as PluginName]()
+          .then((remotePluginModule: any) => this.register([remotePluginModule.default()]))
+          .catch(err => {
+            // TODO: add retry here if dynamic import fails
+            state.plugins.failedPlugins.value = [
+              ...state.plugins.failedPlugins.value,
+              remotePluginKey,
+            ];
+            this.onError(err, remotePluginKey);
+          });
+      }),
+    ).catch(err => {
+      this.onError(err);
+    });
+  }
+
+  /**
+   * Extension point invoke that allows multiple plugins to be registered to it with error handling
+   */
+  invokeMultiple<T = any>(extPoint?: string, ...args: any[]): Nullable<T>[] {
+    try {
+      return this.engine.invokeMultiple(extPoint, ...args);
+    } catch (e) {
+      this.onError(e, extPoint);
+      return [];
+    }
+  }
+
+  /**
+   * Extension point invoke that allows a single plugin to be registered to it with error handling
+   */
+  invokeSingle<T = any>(extPoint?: string, ...args: any[]): Nullable<T> {
+    try {
+      return this.engine.invokeSingle(extPoint, ...args);
+    } catch (e) {
+      this.onError(e, extPoint);
+      return null;
+    }
+  }
+
+  /**
+   * Plugin engine register with error handling
+   */
+  register(plugins: ExtensionPlugin[]) {
+    plugins.forEach(plugin => {
+      try {
+        this.engine.register(plugin, state);
+      } catch (e) {
+        state.plugins.failedPlugins.value = [...state.plugins.failedPlugins.value, plugin.name];
+        this.onError(e);
+      }
+    });
+  }
+
+  // TODO: Implement reset API instead
+  unregisterLocalPlugins() {
+    Object.values(pluginsInventory).forEach(localPlugin => {
+      try {
+        this.engine.unregister(localPlugin().name);
+      } catch (e) {
+        this.onError(e);
+      }
+    });
+  }
+
+  /**
+   * Handle errors
+   */
+  onError(error: unknown, customMessage?: string): void {
+    if (this.errorHandler) {
+      this.errorHandler.onError(error, PLUGINS_MANAGER, customMessage);
+    } else {
+      throw error;
+    }
+  }
+}
+
+export { PluginsManager };

package/packages/analytics-js/src/components/pluginsManager/bundledBuildPluginImports.ts

@@ -0,0 +1,39 @@
+import { BeaconQueue } from '@rudderstack/analytics-js-plugins/beaconQueue';
+import { Bugsnag } from '@rudderstack/analytics-js-plugins/bugsnag';
+import { CustomConsentManager } from '@rudderstack/analytics-js-plugins/customConsentManager';
+import { DeviceModeDestinations } from '@rudderstack/analytics-js-plugins/deviceModeDestinations';
+import { DeviceModeTransformation } from '@rudderstack/analytics-js-plugins/deviceModeTransformation';
+import { ErrorReporting } from '@rudderstack/analytics-js-plugins/errorReporting';
+import { ExternalAnonymousId } from '@rudderstack/analytics-js-plugins/externalAnonymousId';
+import { GoogleLinker } from '@rudderstack/analytics-js-plugins/googleLinker';
+import { KetchConsentManager } from '@rudderstack/analytics-js-plugins/ketchConsentManager';
+import { NativeDestinationQueue } from '@rudderstack/analytics-js-plugins/nativeDestinationQueue';
+import { OneTrustConsentManager } from '@rudderstack/analytics-js-plugins/oneTrustConsentManager';
+import { StorageEncryption } from '@rudderstack/analytics-js-plugins/storageEncryption';
+import { StorageEncryptionLegacy } from '@rudderstack/analytics-js-plugins/storageEncryptionLegacy';
+import { StorageMigrator } from '@rudderstack/analytics-js-plugins/storageMigrator';
+import { XhrQueue } from '@rudderstack/analytics-js-plugins/xhrQueue';
+import type { PluginMap } from './types';
+
+/**
+ * Map plugin names to direct code imports from plugins package
+ */
+const getBundledBuildPluginImports = (): PluginMap => ({
+  BeaconQueue,
+  Bugsnag,
+  CustomConsentManager,
+  DeviceModeDestinations,
+  DeviceModeTransformation,
+  ErrorReporting,
+  ExternalAnonymousId,
+  GoogleLinker,
+  KetchConsentManager,
+  NativeDestinationQueue,
+  OneTrustConsentManager,
+  StorageEncryption,
+  StorageEncryptionLegacy,
+  StorageMigrator,
+  XhrQueue,
+});
+
+export { getBundledBuildPluginImports };

package/packages/analytics-js/src/components/pluginsManager/defaultPluginsList.ts

@@ -0,0 +1,24 @@
+import type { PluginName } from '@rudderstack/analytics-js-common/types/PluginsManager';
+
+/**
+ * Plugins to be loaded in the plugins loadOption is not defined
+ */
+const defaultOptionalPluginsList: PluginName[] = [
+  'BeaconQueue',
+  'Bugsnag',
+  'CustomConsentManager',
+  'DeviceModeDestinations',
+  'DeviceModeTransformation',
+  'ErrorReporting',
+  'ExternalAnonymousId',
+  'GoogleLinker',
+  'KetchConsentManager',
+  'NativeDestinationQueue',
+  'OneTrustConsentManager',
+  'StorageEncryption',
+  'StorageEncryptionLegacy',
+  'StorageMigrator',
+  'XhrQueue',
+];
+
+export { defaultOptionalPluginsList };

package/packages/analytics-js/src/components/pluginsManager/federatedModulesBuildPluginImports.ts

@@ -0,0 +1,68 @@
+import type { ExtensionPlugin } from '@rudderstack/analytics-js-common/types/PluginEngine';
+import type { PluginName } from '@rudderstack/analytics-js-common/types/PluginsManager';
+import type { PluginMap } from './types';
+import { pluginNamesList } from './pluginNames';
+
+/**
+ * Get the lazy loaded dynamic import for a plugin name
+ */
+const getFederatedModuleImport = (
+  pluginName: PluginName,
+): (() => Promise<ExtensionPlugin>) | undefined => {
+  switch (pluginName) {
+    case 'BeaconQueue':
+      return () => import('rudderAnalyticsRemotePlugins/BeaconQueue');
+    case 'Bugsnag':
+      return () => import('rudderAnalyticsRemotePlugins/Bugsnag');
+    case 'CustomConsentManager':
+      return () => import('rudderAnalyticsRemotePlugins/CustomConsentManager');
+    case 'DeviceModeDestinations':
+      return () => import('rudderAnalyticsRemotePlugins/DeviceModeDestinations');
+    case 'DeviceModeTransformation':
+      return () => import('rudderAnalyticsRemotePlugins/DeviceModeTransformation');
+    case 'ErrorReporting':
+      return () => import('rudderAnalyticsRemotePlugins/ErrorReporting');
+    case 'ExternalAnonymousId':
+      return () => import('rudderAnalyticsRemotePlugins/ExternalAnonymousId');
+    case 'GoogleLinker':
+      return () => import('rudderAnalyticsRemotePlugins/GoogleLinker');
+    case 'KetchConsentManager':
+      return () => import('rudderAnalyticsRemotePlugins/KetchConsentManager');
+    case 'NativeDestinationQueue':
+      return () => import('rudderAnalyticsRemotePlugins/NativeDestinationQueue');
+    case 'OneTrustConsentManager':
+      return () => import('rudderAnalyticsRemotePlugins/OneTrustConsentManager');
+    case 'StorageEncryption':
+      return () => import('rudderAnalyticsRemotePlugins/StorageEncryption');
+    case 'StorageEncryptionLegacy':
+      return () => import('rudderAnalyticsRemotePlugins/StorageEncryptionLegacy');
+    case 'StorageMigrator':
+      return () => import('rudderAnalyticsRemotePlugins/StorageMigrator');
+    case 'XhrQueue':
+      return () => import('rudderAnalyticsRemotePlugins/XhrQueue');
+    default:
+      return undefined;
+  }
+};
+
+/**
+ * Map of active plugin names to their dynamic import
+ */
+const federatedModulesBuildPluginImports = (
+  activePluginNames: PluginName[],
+): PluginMap<Promise<ExtensionPlugin>> => {
+  const remotePlugins = {} as PluginMap<Promise<ExtensionPlugin>>;
+
+  activePluginNames.forEach(pluginName => {
+    if (pluginNamesList.includes(pluginName)) {
+      const lazyLoadImport = getFederatedModuleImport(pluginName);
+      if (lazyLoadImport) {
+        remotePlugins[pluginName] = lazyLoadImport;
+      }
+    }
+  });
+
+  return remotePlugins;
+};
+
+export { federatedModulesBuildPluginImports };

package/packages/analytics-js/src/components/pluginsManager/index.ts

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

package/packages/analytics-js/src/components/pluginsManager/pluginNames.ts

@@ -0,0 +1,29 @@
+import type { PluginName } from '@rudderstack/analytics-js-common/types/PluginsManager';
+
+/**
+ * List of plugin names that are loaded as direct imports in all builds
+ */
+const localPluginNames: PluginName[] = [];
+
+/**
+ * List of plugin names that are loaded as dynamic imports in modern builds
+ */
+const pluginNamesList: PluginName[] = [
+  'BeaconQueue',
+  'Bugsnag',
+  'CustomConsentManager',
+  'DeviceModeDestinations',
+  'DeviceModeTransformation',
+  'ErrorReporting',
+  'ExternalAnonymousId',
+  'GoogleLinker',
+  'KetchConsentManager',
+  'NativeDestinationQueue',
+  'OneTrustConsentManager',
+  'StorageEncryption',
+  'StorageEncryptionLegacy',
+  'StorageMigrator',
+  'XhrQueue',
+];
+
+export { localPluginNames, pluginNamesList };

package/packages/analytics-js/src/components/pluginsManager/pluginsInventory.ts

@@ -0,0 +1,47 @@
+import type { ExtensionPlugin } from '@rudderstack/analytics-js-common/types/PluginEngine';
+import type { PluginName } from '@rudderstack/analytics-js-common/types/PluginsManager';
+import type { PluginMap } from './types';
+import { getBundledBuildPluginImports } from './bundledBuildPluginImports';
+import { federatedModulesBuildPluginImports } from './federatedModulesBuildPluginImports';
+
+/**
+ * Map of mandatory plugin names and direct imports
+ */
+const getMandatoryPluginsMap = (): PluginMap => ({}) as PluginMap;
+
+/**
+ * Map of optional plugin names and direct imports for legacy builds
+ */
+const getOptionalPluginsMap = (): PluginMap => {
+  if (!__BUNDLE_ALL_PLUGINS__) {
+    return {} as PluginMap;
+  }
+
+  return getBundledBuildPluginImports();
+};
+
+/**
+ * Map of optional plugin names and dynamic imports for modern builds
+ */
+const getRemotePluginsMap = (
+  activePluginNames: PluginName[],
+): PluginMap<Promise<ExtensionPlugin>> => {
+  if (__BUNDLE_ALL_PLUGINS__) {
+    return {} as PluginMap<Promise<ExtensionPlugin>>;
+  }
+
+  return federatedModulesBuildPluginImports?.(activePluginNames) || {};
+};
+
+const pluginsInventory: PluginMap = {
+  ...getMandatoryPluginsMap(),
+  ...getOptionalPluginsMap(),
+};
+
+const remotePluginsInventory = (
+  activePluginNames: PluginName[],
+): PluginMap<Promise<ExtensionPlugin>> => ({
+  ...getRemotePluginsMap(activePluginNames),
+});
+
+export { pluginsInventory, remotePluginsInventory, getMandatoryPluginsMap };

package/packages/analytics-js/src/components/pluginsManager/types.ts

@@ -0,0 +1,4 @@
+import type { ExtensionPlugin } from '@rudderstack/analytics-js-common/types/PluginEngine';
+import type { PluginName } from '@rudderstack/analytics-js-common/types/PluginsManager';
+
+export type PluginMap<T = ExtensionPlugin> = Record<PluginName, () => T>;