@newrelic/browser-agent 1.301.0 → 1.302.0-alpha.0

package/dist/esm/loaders/api/register-api.js

@@ -1,159 +0,0 @@
-/**
- * Copyright 2020-2025 New Relic, Inc. All rights reserved.
- * SPDX-License-Identifier: Apache-2.0
- */
-import { handle } from '../../common/event-emitter/handle';
-import { warn } from '../../common/util/console';
-import { isContainerAgentTarget, isValidTarget } from '../../common/util/target';
-import { FEATURE_NAMES } from '../features/features';
-import { now } from '../../common/timing/now';
-import { SUPPORTABILITY_METRIC_CHANNEL } from '../../features/metrics/constants';
-
-/**
- * @typedef {import('./register-api-types').RegisterAPI} RegisterAPI
- */
-
-/**
- * Builds the api object that will be returned from the register api method.
- * Also conducts certain side-effects, such as harvesting a PageView event when triggered and gathering metadata for the registered entity.
- * @param {Object} agentRef the reference to the base agent instance
- * @param {Object} handlers the shared handlers to be used by both the base agent's API and the external target's API
- * @param {Object} target the target information to be used by the external target's API to send data to the correct location
- * @returns {RegisterAPI} the api object to be returned from the register api method
- */
-export function buildRegisterApi(agentRef, handlers, target) {
-  const attrs = {};
-  warn(54, 'newrelic.register');
-
-  /** @type {Function|undefined} a function that is set and reports when APIs are triggered -- warns the customer of the invalid state  */
-  let invalidApiResponse;
-
-  /**
-       * A promise that indicates when all needed connections for the registered child to be ready to report data
-       * 1. The main agent to be ready (made a RUM call and got its entity guid)
-       * 2. The child to be registered with the main agent (made its own RUM call and got its entity guid)
-       * @type {Promise<RegisterAPI>}
-       */
-  let _connected;
-  if (!agentRef.init.api.allow_registered_children) invalidApiResponse = () => warn(55);
-  if (!target || !isValidTarget(target)) invalidApiResponse = () => warn(48, target);
-
-  /** @type {RegisterAPI} */
-  const api = {
-    addPageAction: (name, attributes = {}) => {
-      report(handlers.addPageAction, [name, {
-        ...attrs,
-        ...attributes
-      }], target);
-    },
-    log: (message, options = {}) => {
-      report(handlers.log, [message, {
-        ...options,
-        customAttributes: {
-          ...attrs,
-          ...(options.customAttributes || {})
-        }
-      }], target);
-    },
-    noticeError: (error, attributes = {}) => {
-      report(handlers.noticeError, [error, {
-        ...attrs,
-        ...attributes
-      }], target);
-    },
-    setApplicationVersion: value => {
-      attrs['application.version'] = value;
-    },
-    setCustomAttribute: (key, value) => {
-      attrs[key] = value;
-    },
-    setUserId: value => {
-      attrs['enduser.id'] = value;
-    },
-    /** metadata */
-    metadata: {
-      customAttributes: attrs,
-      target,
-      /** set in a getter so that later access of the Promise is not polluted before customer is allowed to set a catch block */
-      get connected() {
-        return _connected || Promise.reject(new Error('Failed to connect'));
-      }
-    }
-  };
-  if (invalidApiResponse) {
-    invalidApiResponse();
-  } else {
-    _connected = new Promise((resolve, reject) => {
-      try {
-        const entityManager = agentRef.runtime?.entityManager;
-        /** check if main agent already has main agent entity guid */
-        let mainAgentReady = !!entityManager?.get().entityGuid;
-        /** check if registered target already has entity guid */
-        let registeredEntityGuid = entityManager?.getEntityGuidFor(target.licenseKey, target.applicationID);
-        let registrationReady = !!registeredEntityGuid;
-
-        /** check if we can just resolve immediately without making another connect call */
-        if (mainAgentReady && registrationReady) {
-          target.entityGuid = registeredEntityGuid;
-          resolve(api);
-        } else {
-          /** we need to make a new connection call since we dont already have a registered entity for this call */
-
-          /** if the connect callback doesnt resolve in 15 seconds... reject */
-          const timeout = setTimeout(() => reject(new Error('Failed to connect - Timeout')), 15000);
-
-          // tell the main agent to send a rum call for this target
-          // when the rum call resolves, it will emit an "entity-added" event, see below
-          agentRef.ee.emit('api-send-rum', [attrs, target]);
-
-          // wait for entity events to emit to see when main agent and/or API registration is ready
-          agentRef.ee.on('entity-added', entityEventHandler);
-          function entityEventHandler(entity) {
-            if (isContainerAgentTarget(entity, agentRef)) mainAgentReady ||= true;else {
-              if (target.licenseKey === entity.licenseKey && target.applicationID === entity.applicationID) {
-                registrationReady = true;
-                target.entityGuid = entity.entityGuid;
-              }
-            }
-            if (mainAgentReady && registrationReady) {
-              clearTimeout(timeout);
-              // unsubscribe from the event emitter
-              agentRef.ee.removeEventListener('entity-added', entityEventHandler);
-              resolve(api);
-            }
-          }
-        }
-      } catch (err) {
-        reject(err);
-      }
-    });
-  }
-
-  /**
-     * The reporter method that will be used to report the data to the container agent's API method. If invalid, will log a warning and not execute.
-     * If the api.duplicate_registered_data configuration value is set to true, the data will be reported to BOTH the container and the external target
-     * @param {*} methodToCall the container agent's API method to call
-     * @param {*} args the arguments to supply to the container agent's API method
-     * @param {string} targetEntityGuid the target entity guid, which looks up the target to report the data to from the entity manager. If undefined, will report to the container agent's target.
-     * @returns
-     */
-  const report = async (methodToCall, args, target) => {
-    if (invalidApiResponse) return invalidApiResponse();
-    /** set the timestamp before the async part of waiting for the rum response for better accuracy */
-    const timestamp = now();
-    handle(SUPPORTABILITY_METRIC_CHANNEL, ["API/register/".concat(methodToCall.name, "/called")], undefined, FEATURE_NAMES.metrics, agentRef.ee);
-    try {
-      await _connected;
-      // target should be decorated with entityGuid by the rum resp at this point
-      const shouldDuplicate = agentRef.init.api.duplicate_registered_data;
-      if (shouldDuplicate === true || Array.isArray(shouldDuplicate) && shouldDuplicate.includes(target.entityGuid)) {
-        // also report to container by providing undefined target
-        methodToCall(...args, undefined, timestamp);
-      }
-      methodToCall(...args, target.entityGuid, timestamp); // always report to target
-    } catch (err) {
-      warn(50, err);
-    }
-  };
-  return api;
-}

package/dist/types/common/util/target.d.ts

@@ -1,18 +0,0 @@
-/**
- * Copyright 2020-2025 New Relic, Inc. All rights reserved.
- * SPDX-License-Identifier: Apache-2.0
- */
-/**
- * @param {Object} [target] - the target to be validated
- * @param {boolean} [allowUndefined=true]
- * @returns {boolean}
- */
-export function isValidTarget(target?: Object): boolean;
-/**
- * Checks if the target matches the container agent target
- * @param {*} target the target to be validated
- * @param {*} agentRef the agent reference to be validated
- * @returns {boolean}
- */
-export function isContainerAgentTarget(target: any, agentRef: any): boolean;
-//# sourceMappingURL=target.d.ts.map

package/dist/types/common/util/target.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"target.d.ts","sourceRoot":"","sources":["../../../../src/common/util/target.js"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;GAIG;AACH,uCAJW,MAAM,GAEJ,OAAO,CAOnB;AAED;;;;;GAKG;AACH,+CAJW,GAAC,YACD,GAAC,GACC,OAAO,CAKnB"}

package/dist/types/features/utils/entity-manager.d.ts

@@ -1,11 +0,0 @@
-export class EntityManager {
-    constructor(agentRef: any);
-    agentRef: any;
-    get(entityGuid?: string): any;
-    getEntityGuidFor(licenseKey: any, applicationID: any): any;
-    set(entityGuid: any, entity: any): void;
-    clear(): void;
-    setDefaultEntity(entity: any): void;
-    #private;
-}
-//# sourceMappingURL=entity-manager.d.ts.map

package/dist/types/features/utils/entity-manager.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"entity-manager.d.ts","sourceRoot":"","sources":["../../../../src/features/utils/entity-manager.js"],"names":[],"mappings":"AAOA;IAIE,2BAGC;IAFC,cAAwB;IAI1B,8BAEC;IAED,2DAGC;IAED,wCAUC;IAED,cAEC;IAED,oCAEC;;CACF"}

package/dist/types/features/utils/event-store-manager.d.ts

@@ -1,85 +0,0 @@
-/**
- * This layer allows multiple browser entity apps, or "target", to each have their own segregated storage instance.
- * The purpose is so the harvester can send data to different apps within the same agent. Each feature should have a manager if it needs this capability.
- */
-export class EventStoreManager {
-    /**
-     * @param {object} agentRef - reference to base agent class
-     * @param {EventBuffer|EventAggregator} storageClass - the type of storage to use in this manager; 'EventBuffer' (1), 'EventAggregator' (2)
-     * @param {string} [defaultEntityGuid] - the entity guid to use as the default storage instance; if not provided, a new one is created
-     * @param {Object} featureAgg - the feature aggregate instance that initialized this manager
-     */
-    constructor(agentRef: object, storageClass: EventBuffer | EventAggregator, defaultEntityGuid?: string, featureAgg: Object);
-    agentRef: object;
-    entityManager: any;
-    StorageClass: any;
-    appStorageMap: Map<string, any>;
-    featureAgg: Object;
-    setEventStore(targetEntityGuid: any): void;
-    /** IMPORTANT
-     * This class must contain an union of all methods from all supported storage classes and conceptualize away the target app argument.
-     */
-    get length(): any;
-    /**
-     * Calls the merge method on the underlying storage class.
-     * @param {*} matcher
-     * @param {*} data
-     * @param {*} targetEntityGuid
-     * @returns {boolean} True if the merge was successful
-     */
-    merge(matcher: any, data: any, targetEntityGuid: any): boolean;
-    /**
-     * Calls the isEmpty method on the underlying storage class. If target is provided, runs just for the target, otherwise runs for all apps.
-     * @param {object} optsIfPresent - exists if called during harvest interval, @see AggregateBase.makeHarvestPayload
-     * @param {object} target - specific app's storage to check; if not provided, this method takes into account all apps recorded by this manager
-     * @returns {boolean} True if the target's storage is empty, or target does not exist in map (defaults to all storages)
-     */
-    isEmpty(optsIfPresent: object, targetEntityGuid: any): boolean;
-    /**
-     * Calls the add method on the underlying storage class.
-     * @param {string} event - the event element to store
-     * @param {object} targetEntityGuid - the entity guid lookup to store event under; if not provided, this method adds to the default
-     * @returns {boolean} True if the event was successfully added
-     */
-    add(event: string, targetEntityGuid: object): boolean;
-    /** This is only used by the Metrics feature which has no need to add metric under a different app atm. */
-    addMetric(type: any, name: any, params: any, value: any): any;
-    /**
-     * Calls the get method on the underlying storage class. If target is provided, runs just for the target, otherwise runs for all apps.
-     * @param {object=} opts - exists if called during harvest interval, @see AggregateBase.makeHarvestPayload
-     * @param {object=} target - specific app to fetch; if not provided, this method fetches from all apps
-     * @returns {Array} Objects of `data` labeled with their respective `target` app to be sent to
-     */
-    get(opts?: object | undefined, targetEntityGuid: any): any[];
-    /**
-     * Calls the byteSize method on the underlying storage class
-     * @param {*} targetEntityGuid
-     * @returns
-     */
-    byteSize(targetEntityGuid: any): any;
-    /**
-     * Calls the wouldExceedMaxSize method on the underlying storage class
-     * @param {*} incomingSize
-     * @param {*} targetEntityGuid
-     * @returns
-     */
-    wouldExceedMaxSize(incomingSize: any, targetEntityGuid: any): any;
-    /**
-     * Calls the save method on the underlying storage class. If target is provided, runs just for the target, otherwise runs for all apps.
-     * @param {*} optsIfPresent
-     * @param {*} targetEntityGuid
-     * @returns
-     */
-    save(optsIfPresent: any, targetEntityGuid: any): any;
-    /**
-     * Calls the clear method on the underlying storage class. If target is provided, runs just for the target, otherwise runs for all apps.
-     * @param {*} optsIfPresent
-     * @param {*} targetEntityGuid
-     * @returns
-     */
-    clear(optsIfPresent: any, targetEntityGuid: any): any;
-    reloadSave(optsIfPresent: any, targetEntityGuid: any): any;
-    clearSave(optsIfPresent: any, targetEntityGuid: any): any;
-    #private;
-}
-//# sourceMappingURL=event-store-manager.d.ts.map

package/dist/types/features/utils/event-store-manager.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"event-store-manager.d.ts","sourceRoot":"","sources":["../../../../src/features/utils/event-store-manager.js"],"names":[],"mappings":"AAMA;;;GAGG;AACH;IACE;;;;;OAKG;IACH,sBALW,MAAM,gBACN,WAAW,GAAC,eAAe,sBAC3B,MAAM,cACN,MAAM,EAShB;IANC,iBAAwB;IACxB,mBAAmD;IACnD,kBAAgC;IAChC,gCAAkG;IAClG,mBAA4B;IAc9B,2CAQC;IAED;;OAEG;IAEH,kBAEC;IAED;;;;;;OAMG;IACH,eALW,GAAC,QACD,GAAC,oBACD,GAAC,GACC,OAAO,CAInB;IAED;;;;;OAKG;IACH,uBAJW,MAAM,0BAEJ,OAAO,CASnB;IAED;;;;;OAKG;IACH,WAJW,MAAM,oBACN,MAAM,GACJ,OAAO,CAInB;IAED,0GAA0G;IAC1G,8DAEC;IAED;;;;;OAKG;IACH,WAJW,MAAM,YAAC,gCAgBjB;IAED;;;;OAIG;IACH,2BAHW,GAAC,OAKX;IAED;;;;;OAKG;IACH,iCAJW,GAAC,oBACD,GAAC,OAKX;IAED;;;;;OAKG;IACH,oBAJW,GAAC,oBACD,GAAC,OAMX;IAED;;;;;OAKG;IACH,qBAJW,GAAC,oBACD,GAAC,OAMX;IAGD,2DAEC;IAED,0DAEC;;CACF"}

package/dist/types/loaders/api/register-api.d.ts

@@ -1,14 +0,0 @@
-/**
- * @typedef {import('./register-api-types').RegisterAPI} RegisterAPI
- */
-/**
- * Builds the api object that will be returned from the register api method.
- * Also conducts certain side-effects, such as harvesting a PageView event when triggered and gathering metadata for the registered entity.
- * @param {Object} agentRef the reference to the base agent instance
- * @param {Object} handlers the shared handlers to be used by both the base agent's API and the external target's API
- * @param {Object} target the target information to be used by the external target's API to send data to the correct location
- * @returns {RegisterAPI} the api object to be returned from the register api method
- */
-export function buildRegisterApi(agentRef: Object, handlers: Object, target: Object): RegisterAPI;
-export type RegisterAPI = import("./register-api-types").RegisterAPI;
-//# sourceMappingURL=register-api.d.ts.map

package/dist/types/loaders/api/register-api.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"register-api.d.ts","sourceRoot":"","sources":["../../../../src/loaders/api/register-api.js"],"names":[],"mappings":"AAWA;;GAEG;AAEH;;;;;;;GAOG;AACH,2CALW,MAAM,YACN,MAAM,UACN,MAAM,GACJ,WAAW,CAkIvB;0BA3IY,OAAO,sBAAsB,EAAE,WAAW"}

package/src/common/util/target.js

@@ -1,27 +0,0 @@
-/**
- * Copyright 2020-2025 New Relic, Inc. All rights reserved.
- * SPDX-License-Identifier: Apache-2.0
- */
-
-/**
- * @param {Object} [target] - the target to be validated
- * @param {boolean} [allowUndefined=true]
- * @returns {boolean}
- */
-export function isValidTarget (target) {
-  /** target can be undefined to support legacy/default behaviors - main agent does not supply a target */
-  if (!target) return true
-  /** if not undefined, we require specific values */
-  return !!(target.licenseKey && target.applicationID)
-}
-
-/**
- * Checks if the target matches the container agent target
- * @param {*} target the target to be validated
- * @param {*} agentRef the agent reference to be validated
- * @returns {boolean}
- */
-export function isContainerAgentTarget (target, agentRef) {
-  if (!target) return true
-  return (target.licenseKey === agentRef.info.licenseKey && target.applicationID === agentRef.info.applicationID)
-}

package/src/features/utils/entity-manager.js

@@ -1,45 +0,0 @@
-/**
- * Copyright 2020-2025 New Relic, Inc. All rights reserved.
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import { DEFAULT_KEY } from '../../common/constants/agent-constants'
-
-export class EntityManager {
-  #entities = new Map()
-  #entityGuidLookup = {}
-
-  constructor (agentRef) {
-    this.agentRef = agentRef
-    this.#entities.set(DEFAULT_KEY, { licenseKey: agentRef.info.licenseKey, applicationID: agentRef.info.applicationID })
-  }
-
-  get (entityGuid = DEFAULT_KEY) {
-    return this.#entities.get(entityGuid)
-  }
-
-  getEntityGuidFor (licenseKey, applicationID) {
-    if (!this.#entityGuidLookup[licenseKey] || !this.#entityGuidLookup[applicationID]) return
-    return this.#entityGuidLookup[licenseKey].filter(x => this.#entityGuidLookup[applicationID].includes(x))[0]
-  }
-
-  set (entityGuid, entity) {
-    if (this.#entities.has(entityGuid)) return
-    this.#entities.set(entityGuid, entity)
-
-    this.#entityGuidLookup[entity.licenseKey] ??= []
-    this.#entityGuidLookup[entity.licenseKey].push(entityGuid)
-    this.#entityGuidLookup[entity.applicationID] ??= []
-    this.#entityGuidLookup[entity.applicationID].push(entityGuid)
-
-    this.agentRef.ee.emit('entity-added', [entity])
-  }
-
-  clear () {
-    this.#entities.clear()
-  }
-
-  setDefaultEntity (entity) {
-    this.#entities.set(DEFAULT_KEY, entity)
-  }
-}

package/src/features/utils/event-store-manager.js

@@ -1,165 +0,0 @@
-/**
- * Copyright 2020-2025 New Relic, Inc. All rights reserved.
- * SPDX-License-Identifier: Apache-2.0
- */
-import { DEFAULT_KEY, MAX_PAYLOAD_SIZE } from '../../common/constants/agent-constants'
-import { isContainerAgentTarget } from '../../common/util/target'
-/**
- * This layer allows multiple browser entity apps, or "target", to each have their own segregated storage instance.
- * The purpose is so the harvester can send data to different apps within the same agent. Each feature should have a manager if it needs this capability.
- */
-export class EventStoreManager {
-  /**
-   * @param {object} agentRef - reference to base agent class
-   * @param {EventBuffer|EventAggregator} storageClass - the type of storage to use in this manager; 'EventBuffer' (1), 'EventAggregator' (2)
-   * @param {string} [defaultEntityGuid] - the entity guid to use as the default storage instance; if not provided, a new one is created
-   * @param {Object} featureAgg - the feature aggregate instance that initialized this manager
-   */
-  constructor (agentRef, storageClass, defaultEntityGuid, featureAgg) {
-    this.agentRef = agentRef
-    this.entityManager = agentRef.runtime.entityManager
-    this.StorageClass = storageClass
-    this.appStorageMap = new Map([[DEFAULT_KEY, new this.StorageClass(MAX_PAYLOAD_SIZE, featureAgg)]])
-    this.featureAgg = featureAgg
-    this.setEventStore(defaultEntityGuid)
-  }
-
-  /**
-   * Always returns a storage instance.  Creates one if one does not exist.  If a lookup is not provided, uses the DEFAULT namespace
-   * @param {string=} targetEntityGuid the lookup
-   * @returns {*} ALWAYS returns a storage instance
-   */
-  #getEventStore (targetEntityGuid = DEFAULT_KEY) {
-    if (!this.appStorageMap.has(targetEntityGuid)) this.setEventStore(targetEntityGuid)
-    return this.appStorageMap.get(targetEntityGuid)
-  }
-
-  setEventStore (targetEntityGuid) {
-    /** we should already have an event store for the default */
-    if (!targetEntityGuid) return
-    /** if the target is the container agent, SHARE the default storage -- otherwise create a new event store */
-    const eventStorage = (isContainerAgentTarget(this.entityManager.get(targetEntityGuid), this.agentRef))
-      ? this.appStorageMap.get(DEFAULT_KEY)
-      : new this.StorageClass(MAX_PAYLOAD_SIZE, this.featureAgg)
-    this.appStorageMap.set(targetEntityGuid, eventStorage)
-  }
-
-  /** IMPORTANT
-   * This class must contain an union of all methods from all supported storage classes and conceptualize away the target app argument.
-   */
-
-  get length () {
-    return this.#getEventStore().length
-  }
-
-  /**
-   * Calls the merge method on the underlying storage class.
-   * @param {*} matcher
-   * @param {*} data
-   * @param {*} targetEntityGuid
-   * @returns {boolean} True if the merge was successful
-   */
-  merge (matcher, data, targetEntityGuid) {
-    return this.#getEventStore(targetEntityGuid).merge(matcher, data)
-  }
-
-  /**
-   * Calls the isEmpty method on the underlying storage class. If target is provided, runs just for the target, otherwise runs for all apps.
-   * @param {object} optsIfPresent - exists if called during harvest interval, @see AggregateBase.makeHarvestPayload
-   * @param {object} target - specific app's storage to check; if not provided, this method takes into account all apps recorded by this manager
-   * @returns {boolean} True if the target's storage is empty, or target does not exist in map (defaults to all storages)
-   */
-  isEmpty (optsIfPresent, targetEntityGuid) {
-    if (targetEntityGuid) return this.#getEventStore(targetEntityGuid).isEmpty(optsIfPresent)
-
-    for (const eventStore of this.appStorageMap.values()) {
-      if (!eventStore.isEmpty(optsIfPresent)) return false
-    }
-    return true
-  }
-
-  /**
-   * Calls the add method on the underlying storage class.
-   * @param {string} event - the event element to store
-   * @param {object} targetEntityGuid - the entity guid lookup to store event under; if not provided, this method adds to the default
-   * @returns {boolean} True if the event was successfully added
-   */
-  add (event, targetEntityGuid) {
-    return this.#getEventStore(targetEntityGuid).add(event)
-  }
-
-  /** This is only used by the Metrics feature which has no need to add metric under a different app atm. */
-  addMetric (type, name, params, value) {
-    return this.#getEventStore().addMetric(type, name, params, value)
-  }
-
-  /**
-   * Calls the get method on the underlying storage class. If target is provided, runs just for the target, otherwise runs for all apps.
-   * @param {object=} opts - exists if called during harvest interval, @see AggregateBase.makeHarvestPayload
-   * @param {object=} target - specific app to fetch; if not provided, this method fetches from all apps
-   * @returns {Array} Objects of `data` labeled with their respective `target` app to be sent to
-   */
-  get (opts, targetEntityGuid) {
-    if (targetEntityGuid) return [{ targetApp: this.entityManager.get(targetEntityGuid), data: this.#getEventStore(targetEntityGuid).get(opts) }]
-    const allPayloads = []
-    this.appStorageMap.forEach((eventStore, targetEntityGuid) => {
-      // We shouldnt harvest unless we have a valid entity guid.  It was ONLY stored under the default key temporarily
-      // until a real key was returned in the RUM call. The real key SHARES the event store with the default key, and
-      // should be the key that is honored to get the event store to ensure a valid connection was made.
-      if (targetEntityGuid === DEFAULT_KEY) return
-      const targetApp = this.entityManager.get(targetEntityGuid)
-      if (targetApp) allPayloads.push({ targetApp, data: eventStore.get(opts) })
-    })
-    return allPayloads
-  }
-
-  /**
-   * Calls the byteSize method on the underlying storage class
-   * @param {*} targetEntityGuid
-   * @returns
-   */
-  byteSize (targetEntityGuid) {
-    return this.#getEventStore(targetEntityGuid).byteSize()
-  }
-
-  /**
-   * Calls the wouldExceedMaxSize method on the underlying storage class
-   * @param {*} incomingSize
-   * @param {*} targetEntityGuid
-   * @returns
-   */
-  wouldExceedMaxSize (incomingSize, targetEntityGuid) {
-    return this.#getEventStore(targetEntityGuid).wouldExceedMaxSize(incomingSize)
-  }
-
-  /**
-   * Calls the save method on the underlying storage class. If target is provided, runs just for the target, otherwise runs for all apps.
-   * @param {*} optsIfPresent
-   * @param {*} targetEntityGuid
-   * @returns
-   */
-  save (optsIfPresent, targetEntityGuid) {
-    if (targetEntityGuid) return this.#getEventStore(targetEntityGuid).save(optsIfPresent)
-    this.appStorageMap.forEach((eventStore) => eventStore.save(optsIfPresent))
-  }
-
-  /**
-   * Calls the clear method on the underlying storage class. If target is provided, runs just for the target, otherwise runs for all apps.
-   * @param {*} optsIfPresent
-   * @param {*} targetEntityGuid
-   * @returns
-   */
-  clear (optsIfPresent, targetEntityGuid) {
-    if (targetEntityGuid) return this.#getEventStore(targetEntityGuid).clear(optsIfPresent)
-    this.appStorageMap.forEach((eventStore) => eventStore.clear(optsIfPresent))
-  }
-
-  // Unlike the methods above, the following will have a target as they are called by AggregateBase.postHarvestCleanup callback on harvest finish after getting & sending the data.
-  reloadSave (optsIfPresent, targetEntityGuid) {
-    return this.#getEventStore(targetEntityGuid).reloadSave(optsIfPresent)
-  }
-
-  clearSave (optsIfPresent, targetEntityGuid) {
-    return this.#getEventStore(targetEntityGuid).clearSave(optsIfPresent)
-  }
-}