relay-runtime 11.0.0 → 13.0.0-rc.0

package/store/RelayModernFragmentSpecResolver.js.flow

@@ -12,29 +12,13 @@
 
 'use strict';
 
-const RelayFeatureFlags = require('../util/RelayFeatureFlags');
-
-const areEqual = require('areEqual');
-const invariant = require('invariant');
-const isScalarAndEqual = require('../util/isScalarAndEqual');
-const reportMissingRequiredFields = require('../util/reportMissingRequiredFields');
-const warning = require('warning');
-
-const {getPromiseForActiveRequest} = require('../query/fetchQueryInternal');
-const {createRequestDescriptor} = require('./RelayModernOperationDescriptor');
-const {
-  areEqualSelectors,
-  createReaderSelector,
-  getSelectorsFromObject,
-} = require('./RelayModernSelector');
-
 import type {ConcreteRequest} from '../util/RelayConcreteNode';
 import type {Disposable, Variables} from '../util/RelayRuntimeTypes';
 import type {
-  IEnvironment,
   FragmentMap,
   FragmentSpecResolver,
   FragmentSpecResults,
+  IEnvironment,
   MissingRequiredFields,
   PluralReaderSelector,
   RelayContext,
@@ -43,10 +27,25 @@ import type {
   Snapshot,
 } from './RelayStoreTypes';
 
+const getPendingOperationsForFragment = require('../util/getPendingOperationsForFragment');
+const isScalarAndEqual = require('../util/isScalarAndEqual');
+const recycleNodesInto = require('../util/recycleNodesInto');
+const RelayFeatureFlags = require('../util/RelayFeatureFlags');
+const reportMissingRequiredFields = require('../util/reportMissingRequiredFields');
+const {createRequestDescriptor} = require('./RelayModernOperationDescriptor');
+const {
+  areEqualSelectors,
+  createReaderSelector,
+  getSelectorsFromObject,
+} = require('./RelayModernSelector');
+const areEqual = require('areEqual');
+const invariant = require('invariant');
+const warning = require('warning');
+
 type Props = {[key: string]: mixed, ...};
 type Resolvers = {
   [key: string]: ?(SelectorListResolver | SelectorResolver),
-  ...,
+  ...
 };
 
 /**
@@ -137,13 +136,16 @@ class RelayModernFragmentSpecResolver implements FragmentSpecResolver {
     return this._data;
   }
 
-  setCallback(callback: () => void): void {
+  setCallback(props: Props, callback: () => void): void {
     this._callback = callback;
+    if (RelayFeatureFlags.ENABLE_CONTAINERS_SUBSCRIBE_ON_COMMIT === true) {
+      this.setProps(props);
+    }
   }
 
   setProps(props: Props): void {
-    const ownedSelectors = getSelectorsFromObject(this._fragments, props);
     this._props = {};
+    const ownedSelectors = getSelectorsFromObject(this._fragments, props);
 
     for (const key in ownedSelectors) {
       if (ownedSelectors.hasOwnProperty(key)) {
@@ -160,6 +162,7 @@ class RelayModernFragmentSpecResolver implements FragmentSpecResolver {
               this._context.environment,
               this._rootIsQueryRenderer,
               ownedSelector,
+              this._callback != null,
               this._onChange,
             );
           } else {
@@ -176,6 +179,7 @@ class RelayModernFragmentSpecResolver implements FragmentSpecResolver {
               this._context.environment,
               this._rootIsQueryRenderer,
               ownedSelector,
+              this._callback != null,
               this._onChange,
             );
           } else {
@@ -232,6 +236,7 @@ class SelectorResolver {
     environment: IEnvironment,
     rootIsQueryRenderer: boolean,
     selector: SingularReaderSelector,
+    subscribeOnConstruction: boolean,
     callback: () => void,
   ) {
     const snapshot = environment.lookup(selector);
@@ -242,7 +247,13 @@ class SelectorResolver {
     this._environment = environment;
     this._rootIsQueryRenderer = rootIsQueryRenderer;
     this._selector = selector;
-    this._subscription = environment.subscribe(snapshot, this._onChange);
+    if (RelayFeatureFlags.ENABLE_CONTAINERS_SUBSCRIBE_ON_COMMIT === true) {
+      if (subscribeOnConstruction) {
+        this._subscription = environment.subscribe(snapshot, this._onChange);
+      }
+    } else {
+      this._subscription = environment.subscribe(snapshot, this._onChange);
+    }
   }
 
   dispose(): void {
@@ -253,10 +264,7 @@ class SelectorResolver {
   }
 
   resolve(): ?Object {
-    if (
-      RelayFeatureFlags.ENABLE_RELAY_CONTAINERS_SUSPENSE === true &&
-      this._isMissingData === true
-    ) {
+    if (this._isMissingData === true) {
       // NOTE: This branch exists to handle the case in which:
       // - A RelayModern container is rendered as a descendant of a Relay Hook
       //   root using a "partial" renderPolicy (this means that eargerly
@@ -278,11 +286,12 @@ class SelectorResolver {
       // This should eventually go away with something like @optional, where we only
       // suspend at specific boundaries depending on whether the boundary
       // can be fulfilled or not.
-      const promise =
-        getPromiseForActiveRequest(this._environment, this._selector.owner) ??
-        this._environment
-          .getOperationTracker()
-          .getPromiseForPendingOperationsAffectingOwner(this._selector.owner);
+      const pendingOperationsResult = getPendingOperationsForFragment(
+        this._environment,
+        this._selector.node,
+        this._selector.owner,
+      );
+      const promise: void | Promise<void> = pendingOperationsResult?.promise;
       if (promise != null) {
         if (this._rootIsQueryRenderer) {
           warning(
@@ -293,6 +302,8 @@ class SelectorResolver {
             this._selector.node.name,
           );
         } else {
+          const pendingOperations =
+            pendingOperationsResult?.pendingOperations ?? [];
           warning(
             false,
             'Relay: Relay Container for fragment `%s` suspended. When using ' +
@@ -300,6 +311,15 @@ class SelectorResolver {
               'of a Relay Container.',
             this._selector.node.name,
           );
+          this._environment.__log({
+            name: 'suspense.fragment',
+            data: this._data,
+            fragment: this._selector.node,
+            isRelayHooks: false,
+            isMissingData: this._isMissingData,
+            isPromiseCached: false,
+            pendingOperations,
+          });
           throw promise;
         }
       }
@@ -322,7 +342,7 @@ class SelectorResolver {
     }
     this.dispose();
     const snapshot = this._environment.lookup(selector);
-    this._data = snapshot.data;
+    this._data = recycleNodesInto(this._data, snapshot.data);
     this._isMissingData = snapshot.isMissingData;
     this._missingRequiredFields = snapshot.missingRequiredFields;
     this._selector = selector;
@@ -375,11 +395,13 @@ class SelectorListResolver {
   _resolvers: Array<SelectorResolver>;
   _rootIsQueryRenderer: boolean;
   _stale: boolean;
+  _subscribeOnConstruction: boolean;
 
   constructor(
     environment: IEnvironment,
     rootIsQueryRenderer: boolean,
     selector: PluralReaderSelector,
+    subscribeOnConstruction: boolean,
     callback: () => void,
   ) {
     this._callback = callback;
@@ -388,6 +410,7 @@ class SelectorListResolver {
     this._resolvers = [];
     this._stale = true;
     this._rootIsQueryRenderer = rootIsQueryRenderer;
+    this._subscribeOnConstruction = subscribeOnConstruction;
 
     this.setSelector(selector);
   }
@@ -433,6 +456,7 @@ class SelectorListResolver {
           this._environment,
           this._rootIsQueryRenderer,
           selectors[ii],
+          this._subscribeOnConstruction,
           this._onChange,
         );
       }

package/store/RelayModernOperationDescriptor.js.flow

@@ -12,9 +12,18 @@
 
 'use strict';
 
+import type {ConcreteRequest} from '../util/RelayConcreteNode';
+import type {
+  CacheConfig,
+  DataID,
+  OperationType,
+  Variables,
+  VariablesOf,
+} from '../util/RelayRuntimeTypes';
+import type {OperationDescriptor, RequestDescriptor} from './RelayStoreTypes';
+
 const deepFreeze = require('../util/deepFreeze');
 const getRequestIdentifier = require('../util/getRequestIdentifier');
-
 const {getOperationVariables} = require('./RelayConcreteVariables');
 const {
   createNormalizationSelector,
@@ -22,19 +31,15 @@ const {
 } = require('./RelayModernSelector');
 const {ROOT_ID} = require('./RelayStoreUtils');
 
-import type {ConcreteRequest} from '../util/RelayConcreteNode';
-import type {CacheConfig, DataID, Variables} from '../util/RelayRuntimeTypes';
-import type {OperationDescriptor, RequestDescriptor} from './RelayStoreTypes';
-
 /**
  * Creates an instance of the `OperationDescriptor` type defined in
  * `RelayStoreTypes` given an operation and some variables. The input variables
  * are filtered to exclude variables that do not match defined arguments on the
  * operation, and default values are populated for null values.
  */
-function createOperationDescriptor(
+function createOperationDescriptor<TQuery: OperationType>(
   request: ConcreteRequest,
-  variables: Variables,
+  variables: VariablesOf<TQuery>,
   cacheConfig?: ?CacheConfig,
   dataID?: DataID = ROOT_ID,
 ): OperationDescriptor {

package/store/RelayModernRecord.js.flow

@@ -12,23 +12,24 @@
 
 'use strict';
 
-const areEqual = require('areEqual');
-const deepFreeze = require('../util/deepFreeze');
-const invariant = require('invariant');
-const warning = require('warning');
+import type {ActorIdentifier} from '../multi-actor-environment/ActorIdentifier';
+import type {DataID} from '../util/RelayRuntimeTypes';
+import type {Record} from './RelayStoreTypes';
 
+const deepFreeze = require('../util/deepFreeze');
 const {isClientID} = require('./ClientID');
 const {
+  ACTOR_IDENTIFIER_KEY,
   ID_KEY,
+  INVALIDATED_AT_KEY,
   REF_KEY,
   REFS_KEY,
-  TYPENAME_KEY,
-  INVALIDATED_AT_KEY,
   ROOT_ID,
+  TYPENAME_KEY,
 } = require('./RelayStoreUtils');
-
-import type {DataID} from '../util/RelayRuntimeTypes';
-import type {Record} from './RelayStoreTypes';
+const areEqual = require('areEqual');
+const invariant = require('invariant');
+const warning = require('warning');
 
 /**
  * @public
@@ -172,10 +173,14 @@ function getLinkedRecordID(record: Record, storageKey: string): ?DataID {
   invariant(
     typeof link === 'object' && link && typeof link[REF_KEY] === 'string',
     'RelayModernRecord.getLinkedRecordID(): Expected `%s.%s` to be a linked ID, ' +
-      'was `%s`.',
+      'was `%s`.%s',
     record[ID_KEY],
     storageKey,
     JSON.stringify(link),
+    typeof link === 'object' && link[REFS_KEY] !== undefined
+      ? ' It appears to be a plural linked record: did you mean to call ' +
+          'getLinkedRecords() instead of getLinkedRecord()?'
+      : '',
   );
   return link[REF_KEY];
 }
@@ -197,10 +202,14 @@ function getLinkedRecordIDs(
   invariant(
     typeof links === 'object' && Array.isArray(links[REFS_KEY]),
     'RelayModernRecord.getLinkedRecordIDs(): Expected `%s.%s` to contain an array ' +
-      'of linked IDs, got `%s`.',
+      'of linked IDs, got `%s`.%s',
     record[ID_KEY],
     storageKey,
     JSON.stringify(links),
+    typeof links === 'object' && links[REF_KEY] !== undefined
+      ? ' It appears to be a singular linked record: did you mean to call ' +
+          'getLinkedRecord() instead of getLinkedRecords()?'
+      : '',
   );
   // assume items of the array are ids
   return (links[REFS_KEY]: any);
@@ -384,6 +393,51 @@ function setLinkedRecordIDs(
   record[storageKey] = links;
 }
 
+/**
+ * @public
+ *
+ * Set the value of a field to a reference to another record in the actor specific store.
+ */
+function setActorLinkedRecordID(
+  record: Record,
+  storageKey: string,
+  actorIdentifier: ActorIdentifier,
+  linkedID: DataID,
+): void {
+  // See perf note above for why we aren't using computed property access.
+  const link = {};
+  link[REF_KEY] = linkedID;
+  link[ACTOR_IDENTIFIER_KEY] = actorIdentifier;
+  record[storageKey] = link;
+}
+
+/**
+ * @public
+ *
+ * Get link to a record and the actor identifier for the store.
+ */
+function getActorLinkedRecordID(
+  record: Record,
+  storageKey: string,
+): ?[ActorIdentifier, DataID] {
+  const link = record[storageKey];
+  if (link == null) {
+    return link;
+  }
+  invariant(
+    typeof link === 'object' &&
+      typeof link[REF_KEY] === 'string' &&
+      link[ACTOR_IDENTIFIER_KEY] != null,
+    'RelayModernRecord.getActorLinkedRecordID(): Expected `%s.%s` to be an actor specific linked ID, ' +
+      'was `%s`.',
+    record[ID_KEY],
+    storageKey,
+    JSON.stringify(link),
+  );
+
+  return [(link[ACTOR_IDENTIFIER_KEY]: any), (link[REF_KEY]: any)];
+}
+
 module.exports = {
   clone,
   copyFields,
@@ -400,4 +454,6 @@ module.exports = {
   setLinkedRecordID,
   setLinkedRecordIDs,
   update,
+  getActorLinkedRecordID,
+  setActorLinkedRecordID,
 };

package/store/RelayModernSelector.js.flow

@@ -12,22 +12,11 @@
 
 'use strict';
 
-const areEqual = require('areEqual');
-const invariant = require('invariant');
-const warning = require('warning');
-
-const {getFragmentVariables} = require('./RelayConcreteVariables');
-const {
-  FRAGMENT_OWNER_KEY,
-  FRAGMENTS_KEY,
-  ID_KEY,
-  IS_WITHIN_UNMATCHED_TYPE_REFINEMENT,
-} = require('./RelayStoreUtils');
-
 import type {NormalizationSelectableNode} from '../util/NormalizationNode';
 import type {ReaderFragment} from '../util/ReaderNode';
 import type {DataID, Variables} from '../util/RelayRuntimeTypes';
 import type {
+  ClientEdgeTraversalPath,
   NormalizationSelector,
   PluralReaderSelector,
   ReaderSelector,
@@ -35,6 +24,18 @@ import type {
   SingularReaderSelector,
 } from './RelayStoreTypes';
 
+const {getFragmentVariables} = require('./RelayConcreteVariables');
+const {
+  CLIENT_EDGE_TRAVERSAL_PATH,
+  FRAGMENT_OWNER_KEY,
+  FRAGMENTS_KEY,
+  ID_KEY,
+  IS_WITHIN_UNMATCHED_TYPE_REFINEMENT,
+} = require('./RelayStoreUtils');
+const areEqual = require('areEqual');
+const invariant = require('invariant');
+const warning = require('warning');
+
 /**
  * @public
  *
@@ -80,6 +81,7 @@ function getSingularSelector(
   const mixedOwner = item[FRAGMENT_OWNER_KEY];
   const isWithinUnmatchedTypeRefinement =
     item[IS_WITHIN_UNMATCHED_TYPE_REFINEMENT] === true;
+  const mixedClientEdgeTraversalPath = item[CLIENT_EDGE_TRAVERSAL_PATH];
   if (
     typeof dataID === 'string' &&
     typeof fragments === 'object' &&
@@ -87,22 +89,28 @@ function getSingularSelector(
     typeof fragments[fragment.name] === 'object' &&
     fragments[fragment.name] !== null &&
     typeof mixedOwner === 'object' &&
-    mixedOwner !== null
+    mixedOwner !== null &&
+    (mixedClientEdgeTraversalPath == null ||
+      Array.isArray(mixedClientEdgeTraversalPath))
   ) {
     const owner: RequestDescriptor = (mixedOwner: $FlowFixMe);
-    const argumentVariables = fragments[fragment.name];
+    const clientEdgeTraversalPath: ?ClientEdgeTraversalPath =
+      (mixedClientEdgeTraversalPath: $FlowFixMe);
 
+    const argumentVariables = fragments[fragment.name];
     const fragmentVariables = getFragmentVariables(
       fragment,
       owner.variables,
       argumentVariables,
     );
+
     return createReaderSelector(
       fragment,
       dataID,
       fragmentVariables,
       owner,
       isWithinUnmatchedTypeRefinement,
+      clientEdgeTraversalPath,
     );
   }
 
@@ -419,11 +427,13 @@ function createReaderSelector(
   variables: Variables,
   request: RequestDescriptor,
   isWithinUnmatchedTypeRefinement: boolean = false,
+  clientEdgeTraversalPath: ?ClientEdgeTraversalPath,
 ): SingularReaderSelector {
   return {
     kind: 'SingularReaderSelector',
     dataID,
     isWithinUnmatchedTypeRefinement,
+    clientEdgeTraversalPath: clientEdgeTraversalPath ?? null,
     node: fragment,
     variables,
     owner: request,

package/store/RelayModernStore.js.flow

@@ -12,30 +12,13 @@
 
 'use strict';
 
-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');
-const RelayStoreSubscriptions = require('./RelayStoreSubscriptions');
-const RelayStoreSubscriptionsUsingMapByID = require('./RelayStoreSubscriptionsUsingMapByID');
-const RelayStoreUtils = require('./RelayStoreUtils');
-
-const deepFreeze = require('../util/deepFreeze');
-const defaultGetDataID = require('./defaultGetDataID');
-const invariant = require('invariant');
-const resolveImmediate = require('../util/resolveImmediate');
-
-const {ROOT_ID, ROOT_TYPE} = require('./RelayStoreUtils');
-
+import type {ActorIdentifier} from '../multi-actor-environment/ActorIdentifier';
 import type {DataID, Disposable} from '../util/RelayRuntimeTypes';
 import type {Availability} from './DataChecker';
 import type {GetDataID} from './RelayResponseNormalizer';
 import type {
   CheckOptions,
+  DataIDSet,
   LogFunction,
   MutableRecordSource,
   OperationAvailability,
@@ -48,8 +31,28 @@ import type {
   Snapshot,
   Store,
   StoreSubscriptions,
-  DataIDSet,
 } from './RelayStoreTypes';
+import type {ResolverCache} from './ResolverCache';
+
+const {
+  INTERNAL_ACTOR_IDENTIFIER_DO_NOT_USE,
+  assertInternalActorIndentifier,
+} = require('../multi-actor-environment/ActorIdentifier');
+const deepFreeze = require('../util/deepFreeze');
+const RelayFeatureFlags = require('../util/RelayFeatureFlags');
+const resolveImmediate = require('../util/resolveImmediate');
+const DataChecker = require('./DataChecker');
+const defaultGetDataID = require('./defaultGetDataID');
+const RelayModernRecord = require('./RelayModernRecord');
+const RelayOptimisticRecordSource = require('./RelayOptimisticRecordSource');
+const RelayReader = require('./RelayReader');
+const RelayReferenceMarker = require('./RelayReferenceMarker');
+const RelayStoreReactFlightUtils = require('./RelayStoreReactFlightUtils');
+const RelayStoreSubscriptions = require('./RelayStoreSubscriptions');
+const RelayStoreUtils = require('./RelayStoreUtils');
+const {ROOT_ID, ROOT_TYPE} = require('./RelayStoreUtils');
+const {RecordResolverCache} = require('./ResolverCache');
+const invariant = require('invariant');
 
 export opaque type InvalidationState = {|
   dataIDs: $ReadOnlyArray<DataID>,
@@ -90,6 +93,7 @@ class RelayModernStore implements Store {
   _operationLoader: ?OperationLoader;
   _optimisticSource: ?MutableRecordSource;
   _recordSource: MutableRecordSource;
+  _resolverCache: ResolverCache;
   _releaseBuffer: Array<string>;
   _roots: Map<
     string,
@@ -103,6 +107,7 @@ class RelayModernStore implements Store {
   _shouldScheduleGC: boolean;
   _storeSubscriptions: StoreSubscriptions;
   _updatedRecordIDs: DataIDSet;
+  _shouldProcessClientComponents: ?boolean;
 
   constructor(
     source: MutableRecordSource,
@@ -113,6 +118,7 @@ class RelayModernStore implements Store {
       getDataID?: ?GetDataID,
       gcReleaseBufferSize?: ?number,
       queryCacheExpirationTime?: ?number,
+      shouldProcessClientComponents?: ?boolean,
     |},
   ) {
     // Prevent mutation of a record from outside the store.
@@ -143,11 +149,16 @@ class RelayModernStore implements Store {
     this._releaseBuffer = [];
     this._roots = new Map();
     this._shouldScheduleGC = false;
-    this._storeSubscriptions =
-      RelayFeatureFlags.ENABLE_STORE_SUBSCRIPTIONS_REFACTOR === true
-        ? new RelayStoreSubscriptionsUsingMapByID(options?.log)
-        : new RelayStoreSubscriptions(options?.log);
+    this._resolverCache = new RecordResolverCache(() =>
+      this._getMutableRecordSource(),
+    );
+    this._storeSubscriptions = new RelayStoreSubscriptions(
+      options?.log,
+      this._resolverCache,
+    );
     this._updatedRecordIDs = new Set();
+    this._shouldProcessClientComponents =
+      options?.shouldProcessClientComponents;
 
     initializeRecordSource(this._recordSource);
   }
@@ -156,12 +167,16 @@ class RelayModernStore implements Store {
     return this._optimisticSource ?? this._recordSource;
   }
 
+  _getMutableRecordSource(): MutableRecordSource {
+    return this._optimisticSource ?? this._recordSource;
+  }
+
   check(
     operation: OperationDescriptor,
     options?: CheckOptions,
   ): OperationAvailability {
     const selector = operation.root;
-    const source = this._optimisticSource ?? this._recordSource;
+    const source = this._getMutableRecordSource();
     const globalInvalidationEpoch = this._globalInvalidationEpoch;
 
     const rootEntry = this._roots.get(operation.request.identifier);
@@ -170,7 +185,7 @@ class RelayModernStore implements Store {
     // Check if store has been globally invalidated
     if (globalInvalidationEpoch != null) {
       // If so, check if the operation we're checking was last written
-      // before or after invalidation occured.
+      // before or after invalidation occurred.
       if (
         operationLastWrittenAt == null ||
         operationLastWrittenAt <= globalInvalidationEpoch
@@ -183,15 +198,29 @@ class RelayModernStore implements Store {
       }
     }
 
-    const target = options?.target ?? source;
     const handlers = options?.handlers ?? [];
+    const getSourceForActor =
+      options?.getSourceForActor ??
+      (actorIdentifier => {
+        assertInternalActorIndentifier(actorIdentifier);
+        return source;
+      });
+    const getTargetForActor =
+      options?.getTargetForActor ??
+      (actorIdentifier => {
+        assertInternalActorIndentifier(actorIdentifier);
+        return source;
+      });
+
     const operationAvailability = DataChecker.check(
-      source,
-      target,
+      getSourceForActor,
+      getTargetForActor,
+      options?.defaultActorIdentifier ?? INTERNAL_ACTOR_IDENTIFIER_DO_NOT_USE,
       selector,
       handlers,
       this._operationLoader,
       this._getDataID,
+      this._shouldProcessClientComponents,
     );
 
     return getAvailabilityStatus(
@@ -270,7 +299,7 @@ class RelayModernStore implements Store {
 
   lookup(selector: SingularReaderSelector): Snapshot {
     const source = this.getSource();
-    const snapshot = RelayReader.read(source, selector);
+    const snapshot = RelayReader.read(source, selector, this._resolverCache);
     if (__DEV__) {
       deepFreeze(snapshot);
     }
@@ -298,6 +327,13 @@ class RelayModernStore implements Store {
       this._globalInvalidationEpoch = this._currentWriteEpoch;
     }
 
+    if (RelayFeatureFlags.ENABLE_RELAY_RESOLVERS) {
+      // When a record is updated, we need to also handle records that depend on it,
+      // specifically Relay Resolver result records containing results based on the
+      // updated records. This both adds to updatedRecordIDs and invalidates any
+      // cached data as needed.
+      this._resolverCache.invalidateDataIDs(this._updatedRecordIDs);
+    }
     const source = this.getSource();
     const updatedOwners = [];
     this._storeSubscriptions.updateSubscriptions(
@@ -360,7 +396,7 @@ class RelayModernStore implements Store {
   }
 
   publish(source: RecordSource, idsMarkedForInvalidation?: DataIDSet): void {
-    const target = this._optimisticSource ?? this._recordSource;
+    const target = this._getMutableRecordSource();
     updateTargetFromSource(
       target,
       source,
@@ -413,6 +449,10 @@ class RelayModernStore implements Store {
     return 'RelayModernStore()';
   }
 
+  getEpoch(): number {
+    return this._currentWriteEpoch;
+  }
+
   // Internal API
   __getUpdatedRecordIDs(): DataIDSet {
     return this._updatedRecordIDs;
@@ -574,6 +614,7 @@ class RelayModernStore implements Store {
           selector,
           references,
           this._operationLoader,
+          this._shouldProcessClientComponents,
         );
         // Yield for other work after each operation
         yield;
@@ -672,7 +713,6 @@ function updateTargetFromSource(
         currentWriteEpoch,
       );
       invalidatedRecordIDs.add(dataID);
-      // $FlowFixMe[incompatible-call]
       target.set(dataID, nextRecord);
     });
   }
@@ -764,8 +804,4 @@ function getAvailabilityStatus(
   return {status: 'available', fetchTime: operationFetchTime ?? null};
 }
 
-RelayProfiler.instrumentMethods(RelayModernStore.prototype, {
-  lookup: 'RelayModernStore.prototype.lookup',
-});
-
 module.exports = RelayModernStore;