relay-runtime 10.1.3 → 11.0.2

package/store/RelayModernEnvironment.js.flow

@@ -13,9 +13,9 @@
 
 'use strict';
 
+const OperationExecutor = require('./OperationExecutor');
 const RelayDefaultHandlerProvider = require('../handlers/RelayDefaultHandlerProvider');
 const RelayFeatureFlags = require('../util/RelayFeatureFlags');
-const RelayModernQueryExecutor = require('./RelayModernQueryExecutor');
 const RelayObservable = require('../network/RelayObservable');
 const RelayOperationTracker = require('../store/RelayOperationTracker');
 const RelayPublishQueue = require('./RelayPublishQueue');
@@ -33,7 +33,6 @@ import type {
   PayloadData,
   UploadableMap,
 } from '../network/RelayNetworkTypes';
-import type {Observer} from '../network/RelayObservable';
 import type {RequestParameters} from '../util/RelayConcreteNode';
 import type {
   CacheConfig,
@@ -41,14 +40,13 @@ import type {
   RenderPolicy,
   Variables,
 } from '../util/RelayRuntimeTypes';
-import type {ActiveState} from './RelayModernQueryExecutor';
-import type {TaskScheduler} from './RelayModernQueryExecutor';
+import type {ActiveState, TaskScheduler} from './OperationExecutor';
 import type {GetDataID} from './RelayResponseNormalizer';
 import type {
+  ExecuteMutationConfig,
   IEnvironment,
   LogFunction,
   MissingFieldHandler,
-  RequiredFieldLogger,
   OperationAvailability,
   OperationDescriptor,
   OperationLoader,
@@ -57,6 +55,8 @@ import type {
   OptimisticUpdateFunction,
   PublishQueue,
   ReactFlightPayloadDeserializer,
+  ReactFlightServerErrorHandler,
+  RequiredFieldLogger,
   SelectorStoreUpdater,
   SingularReaderSelector,
   Snapshot,
@@ -71,21 +71,18 @@ export type EnvironmentConfig = {|
   +log?: ?LogFunction,
   +operationLoader?: ?OperationLoader,
   +reactFlightPayloadDeserializer?: ?ReactFlightPayloadDeserializer,
+  +reactFlightServerErrorHandler?: ?ReactFlightServerErrorHandler,
   +network: INetwork,
   +scheduler?: ?TaskScheduler,
   +store: Store,
   +missingFieldHandlers?: ?$ReadOnlyArray<MissingFieldHandler>,
   +operationTracker?: ?OperationTracker,
-  /**
-   * This method is likely to change in future versions, use at your own risk.
-   * It can potentially break existing calls like store.get(<id>),
-   * because the internal ID might not be the `id` field on the node anymore
-   */
-  +UNSTABLE_DO_NOT_USE_getDataID?: ?GetDataID,
+  +getDataID?: ?GetDataID,
   +UNSTABLE_defaultRenderPolicy?: ?RenderPolicy,
   +options?: mixed,
   +isServer?: boolean,
   +requiredFieldLogger?: ?RequiredFieldLogger,
+  +shouldProcessClientComponents?: ?boolean,
 |};
 
 class RelayModernEnvironment implements IEnvironment {
@@ -93,6 +90,8 @@ class RelayModernEnvironment implements IEnvironment {
   +_defaultRenderPolicy: RenderPolicy;
   _operationLoader: ?OperationLoader;
   _reactFlightPayloadDeserializer: ?ReactFlightPayloadDeserializer;
+  _reactFlightServerErrorHandler: ?ReactFlightServerErrorHandler;
+  _shouldProcessClientComponents: ?boolean;
   _network: INetwork;
   _publishQueue: PublishQueue;
   _scheduler: ?TaskScheduler;
@@ -109,13 +108,11 @@ class RelayModernEnvironment implements IEnvironment {
 
   constructor(config: EnvironmentConfig) {
     this.configName = config.configName;
-    const handlerProvider = config.handlerProvider
-      ? config.handlerProvider
-      : RelayDefaultHandlerProvider;
     this._treatMissingFieldsAsNull = config.treatMissingFieldsAsNull === true;
     const operationLoader = config.operationLoader;
     const reactFlightPayloadDeserializer =
       config.reactFlightPayloadDeserializer;
+    const reactFlightServerErrorHandler = config.reactFlightServerErrorHandler;
     if (__DEV__) {
       if (operationLoader != null) {
         invariant(
@@ -147,10 +144,10 @@ class RelayModernEnvironment implements IEnvironment {
     this._operationLoader = operationLoader;
     this._operationExecutions = new Map();
     this._network = this.__wrapNetworkWithLogObserver(config.network);
-    this._getDataID = config.UNSTABLE_DO_NOT_USE_getDataID ?? defaultGetDataID;
+    this._getDataID = config.getDataID ?? defaultGetDataID;
     this._publishQueue = new RelayPublishQueue(
       config.store,
-      handlerProvider,
+      config.handlerProvider ?? RelayDefaultHandlerProvider,
       this._getDataID,
     );
     this._scheduler = config.scheduler ?? null;
@@ -182,6 +179,8 @@ class RelayModernEnvironment implements IEnvironment {
     this._operationTracker =
       config.operationTracker ?? new RelayOperationTracker();
     this._reactFlightPayloadDeserializer = reactFlightPayloadDeserializer;
+    this._reactFlightServerErrorHandler = reactFlightServerErrorHandler;
+    this._shouldProcessClientComponents = config.shouldProcessClientComponents;
   }
 
   getStore(): Store {
@@ -238,25 +237,12 @@ class RelayModernEnvironment implements IEnvironment {
   }
 
   applyMutation(optimisticConfig: OptimisticResponseConfig): Disposable {
-    const subscription = RelayObservable.create(sink => {
-      const source = RelayObservable.create(_sink => {});
-      const executor = RelayModernQueryExecutor.execute({
-        operation: optimisticConfig.operation,
-        operationExecutions: this._operationExecutions,
-        operationLoader: this._operationLoader,
-        optimisticConfig,
-        publishQueue: this._publishQueue,
-        reactFlightPayloadDeserializer: this._reactFlightPayloadDeserializer,
-        scheduler: this._scheduler,
-        sink,
-        source,
-        store: this._store,
-        updater: null,
-        operationTracker: this._operationTracker,
-        getDataID: this._getDataID,
-        treatMissingFieldsAsNull: this._treatMissingFieldsAsNull,
-      });
-      return () => executor.cancel();
+    const subscription = this._execute({
+      createSource: () => RelayObservable.create(_sink => {}),
+      isClientPayload: false,
+      operation: optimisticConfig.operation,
+      optimisticConfig,
+      updater: null,
     }).subscribe({});
     return {
       dispose: () => subscription.unsubscribe(),
@@ -277,27 +263,12 @@ class RelayModernEnvironment implements IEnvironment {
   }
 
   commitPayload(operation: OperationDescriptor, payload: PayloadData): void {
-    RelayObservable.create(sink => {
-      const executor = RelayModernQueryExecutor.execute({
-        operation: operation,
-        operationExecutions: this._operationExecutions,
-        operationLoader: this._operationLoader,
-        optimisticConfig: null,
-        publishQueue: this._publishQueue,
-        reactFlightPayloadDeserializer: this._reactFlightPayloadDeserializer,
-        scheduler: this._scheduler,
-        sink,
-        source: RelayObservable.from({
-          data: payload,
-        }),
-        store: this._store,
-        updater: null,
-        operationTracker: this._operationTracker,
-        getDataID: this._getDataID,
-        isClientPayload: true,
-        treatMissingFieldsAsNull: this._treatMissingFieldsAsNull,
-      });
-      return () => executor.cancel();
+    this._execute({
+      createSource: () => RelayObservable.from({data: payload}),
+      isClientPayload: true,
+      operation: operation,
+      optimisticConfig: null,
+      updater: null,
     }).subscribe({});
   }
 
@@ -366,30 +337,18 @@ class RelayModernEnvironment implements IEnvironment {
     operation: OperationDescriptor,
     updater?: ?SelectorStoreUpdater,
   |}): RelayObservable<GraphQLResponse> {
-    return RelayObservable.create(sink => {
-      const source = this._network.execute(
-        operation.request.node.params,
-        operation.request.variables,
-        operation.request.cacheConfig || {},
-        null,
-      );
-      const executor = RelayModernQueryExecutor.execute({
-        operation,
-        operationExecutions: this._operationExecutions,
-        operationLoader: this._operationLoader,
-        optimisticConfig: null,
-        publishQueue: this._publishQueue,
-        reactFlightPayloadDeserializer: this._reactFlightPayloadDeserializer,
-        scheduler: this._scheduler,
-        sink,
-        source,
-        store: this._store,
-        updater,
-        operationTracker: this._operationTracker,
-        getDataID: this._getDataID,
-        treatMissingFieldsAsNull: this._treatMissingFieldsAsNull,
-      });
-      return () => executor.cancel();
+    return this._execute({
+      createSource: () =>
+        this._network.execute(
+          operation.request.node.params,
+          operation.request.variables,
+          operation.request.cacheConfig || {},
+          null,
+        ),
+      isClientPayload: false,
+      operation,
+      optimisticConfig: null,
+      updater,
     });
   }
 
@@ -409,48 +368,30 @@ class RelayModernEnvironment implements IEnvironment {
     optimisticUpdater,
     updater,
     uploadables,
-  }: {|
-    operation: OperationDescriptor,
-    optimisticUpdater?: ?SelectorStoreUpdater,
-    optimisticResponse?: ?Object,
-    updater?: ?SelectorStoreUpdater,
-    uploadables?: ?UploadableMap,
-  |}): RelayObservable<GraphQLResponse> {
-    return RelayObservable.create(sink => {
-      let optimisticConfig;
-      if (optimisticResponse || optimisticUpdater) {
-        optimisticConfig = {
-          operation: operation,
-          response: optimisticResponse,
-          updater: optimisticUpdater,
-        };
-      }
-      const source = this._network.execute(
-        operation.request.node.params,
-        operation.request.variables,
-        {
-          ...operation.request.cacheConfig,
-          force: true,
-        },
-        uploadables,
-      );
-      const executor = RelayModernQueryExecutor.execute({
-        operation,
-        operationExecutions: this._operationExecutions,
-        operationLoader: this._operationLoader,
-        optimisticConfig,
-        publishQueue: this._publishQueue,
-        reactFlightPayloadDeserializer: this._reactFlightPayloadDeserializer,
-        scheduler: this._scheduler,
-        sink,
-        source,
-        store: this._store,
-        updater,
-        operationTracker: this._operationTracker,
-        getDataID: this._getDataID,
-        treatMissingFieldsAsNull: this._treatMissingFieldsAsNull,
-      });
-      return () => executor.cancel();
+  }: ExecuteMutationConfig): RelayObservable<GraphQLResponse> {
+    let optimisticConfig;
+    if (optimisticResponse || optimisticUpdater) {
+      optimisticConfig = {
+        operation: operation,
+        response: optimisticResponse,
+        updater: optimisticUpdater,
+      };
+    }
+    return this._execute({
+      createSource: () =>
+        this._network.execute(
+          operation.request.node.params,
+          operation.request.variables,
+          {
+            ...operation.request.cacheConfig,
+            force: true,
+          },
+          uploadables,
+        ),
+      isClientPayload: false,
+      operation,
+      optimisticConfig,
+      updater,
     });
   }
 
@@ -469,31 +410,59 @@ class RelayModernEnvironment implements IEnvironment {
   }: {|
     operation: OperationDescriptor,
     source: RelayObservable<GraphQLResponse>,
+  |}): RelayObservable<GraphQLResponse> {
+    return this._execute({
+      createSource: () => source,
+      isClientPayload: false,
+      operation,
+      optimisticConfig: null,
+      updater: null,
+    });
+  }
+
+  toJSON(): mixed {
+    return `RelayModernEnvironment(${this.configName ?? ''})`;
+  }
+
+  _execute({
+    createSource,
+    isClientPayload,
+    operation,
+    optimisticConfig,
+    updater,
+  }: {|
+    createSource: () => RelayObservable<GraphQLResponse>,
+    isClientPayload: boolean,
+    operation: OperationDescriptor,
+    optimisticConfig: ?OptimisticResponseConfig,
+    updater: ?SelectorStoreUpdater,
   |}): RelayObservable<GraphQLResponse> {
     return RelayObservable.create(sink => {
-      const executor = RelayModernQueryExecutor.execute({
+      const executor = OperationExecutor.execute({
+        getDataID: this._getDataID,
+        isClientPayload,
         operation,
         operationExecutions: this._operationExecutions,
         operationLoader: this._operationLoader,
         operationTracker: this._operationTracker,
-        optimisticConfig: null,
+        optimisticConfig,
         publishQueue: this._publishQueue,
         reactFlightPayloadDeserializer: this._reactFlightPayloadDeserializer,
+        reactFlightServerErrorHandler: this._reactFlightServerErrorHandler,
         scheduler: this._scheduler,
+        shouldProcessClientComponents: this._shouldProcessClientComponents,
         sink,
-        source,
+        // NOTE: Some product tests expect `Network.execute` to be called only
+        //       when the Observable is executed.
+        source: createSource(),
         store: this._store,
-        getDataID: this._getDataID,
         treatMissingFieldsAsNull: this._treatMissingFieldsAsNull,
+        updater,
       });
       return () => executor.cancel();
     });
   }
 
-  toJSON(): mixed {
-    return `RelayModernEnvironment(${this.configName ?? ''})`;
-  }
-
   /**
    * Wraps the network with logging to ensure that network requests are
    * always logged. Relying on each network callsite to be wrapped is
@@ -517,6 +486,7 @@ class RelayModernEnvironment implements IEnvironment {
               transactionID,
               params,
               variables,
+              cacheConfig,
             });
           },
           next: response => {

package/store/RelayModernFragmentSpecResolver.js.flow

@@ -71,6 +71,7 @@ type Resolvers = {
 class RelayModernFragmentSpecResolver implements FragmentSpecResolver {
   _callback: ?() => void;
   _context: RelayContext;
+  _rootIsQueryRenderer: boolean;
   _data: Object;
   _fragments: FragmentMap;
   _props: Props;
@@ -82,6 +83,7 @@ class RelayModernFragmentSpecResolver implements FragmentSpecResolver {
     fragments: FragmentMap,
     props: Props,
     callback?: () => void,
+    rootIsQueryRenderer: boolean,
   ) {
     this._callback = callback;
     this._context = context;
@@ -90,6 +92,7 @@ class RelayModernFragmentSpecResolver implements FragmentSpecResolver {
     this._props = {};
     this._resolvers = {};
     this._stale = false;
+    this._rootIsQueryRenderer = rootIsQueryRenderer;
 
     this.setProps(props);
   }
@@ -155,6 +158,7 @@ class RelayModernFragmentSpecResolver implements FragmentSpecResolver {
           if (resolver == null) {
             resolver = new SelectorListResolver(
               this._context.environment,
+              this._rootIsQueryRenderer,
               ownedSelector,
               this._onChange,
             );
@@ -170,6 +174,7 @@ class RelayModernFragmentSpecResolver implements FragmentSpecResolver {
           if (resolver == null) {
             resolver = new SelectorResolver(
               this._context.environment,
+              this._rootIsQueryRenderer,
               ownedSelector,
               this._onChange,
             );
@@ -219,11 +224,13 @@ class SelectorResolver {
   _environment: IEnvironment;
   _isMissingData: boolean;
   _missingRequiredFields: ?MissingRequiredFields;
+  _rootIsQueryRenderer: boolean;
   _selector: SingularReaderSelector;
   _subscription: ?Disposable;
 
   constructor(
     environment: IEnvironment,
+    rootIsQueryRenderer: boolean,
     selector: SingularReaderSelector,
     callback: () => void,
   ) {
@@ -233,6 +240,7 @@ class SelectorResolver {
     this._isMissingData = snapshot.isMissingData;
     this._missingRequiredFields = snapshot.missingRequiredFields;
     this._environment = environment;
+    this._rootIsQueryRenderer = rootIsQueryRenderer;
     this._selector = selector;
     this._subscription = environment.subscribe(snapshot, this._onChange);
   }
@@ -276,14 +284,24 @@ class SelectorResolver {
           .getOperationTracker()
           .getPromiseForPendingOperationsAffectingOwner(this._selector.owner);
       if (promise != null) {
-        warning(
-          false,
-          'Relay: Relay Container for fragment `%s` suspended. When using ' +
-            'features such as @defer or @module, use `useFragment` instead ' +
-            'of a Relay Container.',
-          this._selector.node.name,
-        );
-        throw promise;
+        if (this._rootIsQueryRenderer) {
+          warning(
+            false,
+            'Relay: Relay Container for fragment `%s` has missing data and ' +
+              'would suspend. When using features such as @defer or @module, ' +
+              'use `useFragment` instead of a Relay Container.',
+            this._selector.node.name,
+          );
+        } else {
+          warning(
+            false,
+            'Relay: Relay Container for fragment `%s` suspended. When using ' +
+              'features such as @defer or @module, use `useFragment` instead ' +
+              'of a Relay Container.',
+            this._selector.node.name,
+          );
+          throw promise;
+        }
       }
     }
     if (this._missingRequiredFields != null) {
@@ -355,10 +373,12 @@ class SelectorListResolver {
   _data: Array<?SelectorData>;
   _environment: IEnvironment;
   _resolvers: Array<SelectorResolver>;
+  _rootIsQueryRenderer: boolean;
   _stale: boolean;
 
   constructor(
     environment: IEnvironment,
+    rootIsQueryRenderer: boolean,
     selector: PluralReaderSelector,
     callback: () => void,
   ) {
@@ -367,6 +387,7 @@ class SelectorListResolver {
     this._environment = environment;
     this._resolvers = [];
     this._stale = true;
+    this._rootIsQueryRenderer = rootIsQueryRenderer;
 
     this.setSelector(selector);
   }
@@ -410,6 +431,7 @@ class SelectorListResolver {
       } else {
         this._resolvers[ii] = new SelectorResolver(
           this._environment,
+          this._rootIsQueryRenderer,
           selectors[ii],
           this._onChange,
         );

package/store/RelayModernStore.js.flow

@@ -16,7 +16,6 @@ const DataChecker = require('./DataChecker');
 const RelayFeatureFlags = require('../util/RelayFeatureFlags');
 const RelayModernRecord = require('./RelayModernRecord');
 const RelayOptimisticRecordSource = require('./RelayOptimisticRecordSource');
-const RelayProfiler = require('../util/RelayProfiler');
 const RelayReader = require('./RelayReader');
 const RelayReferenceMarker = require('./RelayReferenceMarker');
 const RelayStoreReactFlightUtils = require('./RelayStoreReactFlightUtils');
@@ -48,7 +47,7 @@ import type {
   Snapshot,
   Store,
   StoreSubscriptions,
-  UpdatedRecords,
+  DataIDSet,
 } from './RelayStoreTypes';
 
 export opaque type InvalidationState = {|
@@ -61,7 +60,7 @@ type InvalidationSubscription = {|
   invalidationState: InvalidationState,
 |};
 
-const DEFAULT_RELEASE_BUFFER_SIZE = 0;
+const DEFAULT_RELEASE_BUFFER_SIZE = 10;
 
 /**
  * @public
@@ -84,7 +83,7 @@ class RelayModernStore implements Store {
   _getDataID: GetDataID;
   _globalInvalidationEpoch: ?number;
   _invalidationSubscriptions: Set<InvalidationSubscription>;
-  _invalidatedRecordIDs: Set<DataID>;
+  _invalidatedRecordIDs: DataIDSet;
   __log: ?LogFunction;
   _queryCacheExpirationTime: ?number;
   _operationLoader: ?OperationLoader;
@@ -102,7 +101,8 @@ class RelayModernStore implements Store {
   >;
   _shouldScheduleGC: boolean;
   _storeSubscriptions: StoreSubscriptions;
-  _updatedRecordIDs: UpdatedRecords;
+  _updatedRecordIDs: DataIDSet;
+  _shouldProcessClientComponents: ?boolean;
 
   constructor(
     source: MutableRecordSource,
@@ -110,9 +110,10 @@ class RelayModernStore implements Store {
       gcScheduler?: ?Scheduler,
       log?: ?LogFunction,
       operationLoader?: ?OperationLoader,
-      UNSTABLE_DO_NOT_USE_getDataID?: ?GetDataID,
+      getDataID?: ?GetDataID,
       gcReleaseBufferSize?: ?number,
       queryCacheExpirationTime?: ?number,
+      shouldProcessClientComponents?: ?boolean,
     |},
   ) {
     // Prevent mutation of a record from outside the store.
@@ -131,8 +132,7 @@ class RelayModernStore implements Store {
       options?.gcReleaseBufferSize ?? DEFAULT_RELEASE_BUFFER_SIZE;
     this._gcRun = null;
     this._gcScheduler = options?.gcScheduler ?? resolveImmediate;
-    this._getDataID =
-      options?.UNSTABLE_DO_NOT_USE_getDataID ?? defaultGetDataID;
+    this._getDataID = options?.getDataID ?? defaultGetDataID;
     this._globalInvalidationEpoch = null;
     this._invalidationSubscriptions = new Set();
     this._invalidatedRecordIDs = new Set();
@@ -146,9 +146,11 @@ class RelayModernStore implements Store {
     this._shouldScheduleGC = false;
     this._storeSubscriptions =
       RelayFeatureFlags.ENABLE_STORE_SUBSCRIPTIONS_REFACTOR === true
-        ? new RelayStoreSubscriptionsUsingMapByID()
-        : new RelayStoreSubscriptions();
-    this._updatedRecordIDs = {};
+        ? new RelayStoreSubscriptionsUsingMapByID(options?.log)
+        : new RelayStoreSubscriptions(options?.log);
+    this._updatedRecordIDs = new Set();
+    this._shouldProcessClientComponents =
+      options?.shouldProcessClientComponents;
 
     initializeRecordSource(this._recordSource);
   }
@@ -193,6 +195,7 @@ class RelayModernStore implements Store {
       handlers,
       this._operationLoader,
       this._getDataID,
+      this._shouldProcessClientComponents,
     );
 
     return getAvailabilityStatus(
@@ -287,6 +290,7 @@ class RelayModernStore implements Store {
     if (log != null) {
       log({
         name: 'store.notify.start',
+        sourceOperation,
       });
     }
 
@@ -304,6 +308,7 @@ class RelayModernStore implements Store {
       source,
       this._updatedRecordIDs,
       updatedOwners,
+      sourceOperation,
     );
     this._invalidationSubscriptions.forEach(subscription => {
       this._updateInvalidationSubscription(
@@ -314,12 +319,13 @@ class RelayModernStore implements Store {
     if (log != null) {
       log({
         name: 'store.notify.complete',
+        sourceOperation,
         updatedRecordIDs: this._updatedRecordIDs,
         invalidatedRecordIDs: this._invalidatedRecordIDs,
       });
     }
 
-    this._updatedRecordIDs = {};
+    this._updatedRecordIDs.clear();
     this._invalidatedRecordIDs.clear();
 
     // If a source operation was provided (indicating the operation
@@ -357,7 +363,7 @@ class RelayModernStore implements Store {
     return updatedOwners;
   }
 
-  publish(source: RecordSource, idsMarkedForInvalidation?: Set<DataID>): void {
+  publish(source: RecordSource, idsMarkedForInvalidation?: DataIDSet): void {
     const target = this._optimisticSource ?? this._recordSource;
     updateTargetFromSource(
       target,
@@ -412,7 +418,7 @@ class RelayModernStore implements Store {
   }
 
   // Internal API
-  __getUpdatedRecordIDs(): UpdatedRecords {
+  __getUpdatedRecordIDs(): DataIDSet {
     return this._updatedRecordIDs;
   }
 
@@ -572,6 +578,7 @@ class RelayModernStore implements Store {
           selector,
           references,
           this._operationLoader,
+          this._shouldProcessClientComponents,
         );
         // Yield for other work after each operation
         yield;
@@ -626,9 +633,9 @@ function updateTargetFromSource(
   target: MutableRecordSource,
   source: RecordSource,
   currentWriteEpoch: number,
-  idsMarkedForInvalidation: ?Set<DataID>,
-  updatedRecordIDs: UpdatedRecords,
-  invalidatedRecordIDs: Set<DataID>,
+  idsMarkedForInvalidation: ?DataIDSet,
+  updatedRecordIDs: DataIDSet,
+  invalidatedRecordIDs: DataIDSet,
 ): void {
   // First, update any records that were marked for invalidation.
   // For each provided dataID that was invalidated, we write the
@@ -670,6 +677,7 @@ function updateTargetFromSource(
         currentWriteEpoch,
       );
       invalidatedRecordIDs.add(dataID);
+      // $FlowFixMe[incompatible-call]
       target.set(dataID, nextRecord);
     });
   }
@@ -702,17 +710,17 @@ function updateTargetFromSource(
         if (__DEV__) {
           RelayModernRecord.freeze(nextRecord);
         }
-        updatedRecordIDs[dataID] = true;
+        updatedRecordIDs.add(dataID);
         target.set(dataID, nextRecord);
       }
     } else if (sourceRecord === null) {
       target.delete(dataID);
       if (targetRecord !== null) {
-        updatedRecordIDs[dataID] = true;
+        updatedRecordIDs.add(dataID);
       }
     } else if (sourceRecord) {
       target.set(dataID, sourceRecord);
-      updatedRecordIDs[dataID] = true;
+      updatedRecordIDs.add(dataID);
     } // don't add explicit undefined
   }
 }
@@ -761,8 +769,4 @@ function getAvailabilityStatus(
   return {status: 'available', fetchTime: operationFetchTime ?? null};
 }
 
-RelayProfiler.instrumentMethods(RelayModernStore.prototype, {
-  lookup: 'RelayModernStore.prototype.lookup',
-});
-
 module.exports = RelayModernStore;