relay-runtime 11.0.1 → 11.0.2

package/store/{RelayModernQueryExecutor.js.flow → OperationExecutor.js.flow}

@@ -76,7 +76,7 @@ export type ExecuteConfig = {|
   +operation: OperationDescriptor,
   +operationExecutions: Map<string, ActiveState>,
   +operationLoader: ?OperationLoader,
-  +operationTracker?: ?OperationTracker,
+  +operationTracker: OperationTracker,
   +optimisticConfig: ?OptimisticResponseConfig,
   +publishQueue: PublishQueue,
   +reactFlightPayloadDeserializer?: ?ReactFlightPayloadDeserializer,
@@ -133,7 +133,7 @@ class Executor {
   _operation: OperationDescriptor;
   _operationExecutions: Map<string, ActiveState>;
   _operationLoader: ?OperationLoader;
-  _operationTracker: ?OperationTracker;
+  _operationTracker: OperationTracker;
   _operationUpdateEpochs: Map<string, number>;
   _optimisticUpdates: null | Array<OptimisticUpdate>;
   _pendingModulePayloadsCount: number;
@@ -244,6 +244,7 @@ class Executor {
       optimisticUpdates.forEach(update =>
         this._publishQueue.revertUpdate(update),
       );
+      // OK: run revert on cancel
       this._publishQueue.run();
     }
     this._incrementalResults.clear();
@@ -276,7 +277,7 @@ class Executor {
       }
       default:
         (this._state: empty);
-        invariant(false, 'RelayModernQueryExecutor: invalid executor state.');
+        invariant(false, 'OperationExecutor: invalid executor state.');
     }
     this._operationExecutions.set(
       this._operation.request.identifier,
@@ -403,7 +404,7 @@ class Executor {
     if (isOptimistic && this._state !== 'started') {
       invariant(
         false,
-        'RelayModernQueryExecutor: optimistic payload received after server payload.',
+        'OperationExecutor: optimistic payload received after server payload.',
       );
     }
     if (isOptimistic) {
@@ -449,6 +450,7 @@ class Executor {
       nonIncrementalResponses,
       incrementalResponses,
     ] = partitionGraphQLResponses(responsesWithData);
+    const hasNonIncrementalResponses = nonIncrementalResponses.length > 0;
 
     // In theory this doesn't preserve the ordering of the batch.
     // The idea is that a batch is always:
@@ -457,16 +459,20 @@ class Executor {
     // The non-incremental payload can appear if the server sends a batch
     // with the initial payload followed by some early-to-resolve incremental
     // payloads (although, can that even happen?)
-    if (nonIncrementalResponses.length > 0) {
+    if (hasNonIncrementalResponses) {
       const payloadFollowups = this._processResponses(nonIncrementalResponses);
-      // Please note that we're passing `this._operation` to the publish
-      // queue here, which will later passed to the store (via notify)
-      // to indicate that this is an operation that caused the store to update
-      const updatedOwners = this._publishQueue.run(this._operation);
-      this._updateOperationTracker(updatedOwners);
+
+      if (!RelayFeatureFlags.ENABLE_BATCHED_STORE_UPDATES) {
+        const updatedOwners = this._publishQueue.run(this._operation);
+        this._updateOperationTracker(updatedOwners);
+      }
+
       this._processPayloadFollowups(payloadFollowups);
-      if (this._incrementalPayloadsPending && !this._retainDisposable) {
-        this._retainDisposable = this._store.retain(this._operation);
+
+      if (!RelayFeatureFlags.ENABLE_BATCHED_STORE_UPDATES) {
+        if (this._incrementalPayloadsPending && !this._retainDisposable) {
+          this._retainDisposable = this._store.retain(this._operation);
+        }
       }
     }
 
@@ -474,13 +480,46 @@ class Executor {
       const payloadFollowups = this._processIncrementalResponses(
         incrementalResponses,
       );
-      // For the incremental case, we're only handling follow-up responses
-      // for already initiated operation (and we're not passing it to
-      // the run(...) call)
-      const updatedOwners = this._publishQueue.run();
-      this._updateOperationTracker(updatedOwners);
+      if (!RelayFeatureFlags.ENABLE_BATCHED_STORE_UPDATES) {
+        // For the incremental case, we're only handling follow-up responses
+        // for already initiated operation (and we're not passing it to
+        // the run(...) call)
+        const updatedOwners = this._publishQueue.run();
+        this._updateOperationTracker(updatedOwners);
+      }
       this._processPayloadFollowups(payloadFollowups);
     }
+    if (
+      this._isSubscriptionOperation &&
+      RelayFeatureFlags.ENABLE_UNIQUE_SUBSCRIPTION_ROOT
+    ) {
+      // We attach the id to allow the `requestSubscription` to read from the store using
+      // the current id in its `onNext` callback
+      if (responsesWithData[0].extensions == null) {
+        // $FlowFixMe[cannot-write]
+        responsesWithData[0].extensions = {
+          __relay_subscription_root_id: this._operation.fragment.dataID,
+        };
+      } else {
+        responsesWithData[0].extensions.__relay_subscription_root_id = this._operation.fragment.dataID;
+      }
+    }
+
+    if (RelayFeatureFlags.ENABLE_BATCHED_STORE_UPDATES) {
+      // OK: run once after each new payload
+      // If we have non-incremental responses, we passing `this._operation` to
+      // the publish queue here, which will later be passed to the store (via
+      // notify) to indicate that this operation caused the store to update
+      const updatedOwners = this._publishQueue.run(
+        hasNonIncrementalResponses ? this._operation : undefined,
+      );
+      if (hasNonIncrementalResponses) {
+        if (this._incrementalPayloadsPending && !this._retainDisposable) {
+          this._retainDisposable = this._store.retain(this._operation);
+        }
+      }
+      this._updateOperationTracker(updatedOwners);
+    }
     this._sink.next(response);
   }
 
@@ -535,6 +574,8 @@ class Executor {
     }
     this._optimisticUpdates = optimisticUpdates;
     optimisticUpdates.forEach(update => this._publishQueue.applyUpdate(update));
+    // OK: only called on construction and when receiving an optimistic payload from network,
+    // which doesn't fall-through to the regular next() handling
     this._publishQueue.run();
   }
 
@@ -634,12 +675,13 @@ class Executor {
         if (this._optimisticUpdates == null) {
           warning(
             false,
-            'RelayModernQueryExecutor: Unexpected ModuleImport optimistic ' +
+            'OperationExecutor: Unexpected ModuleImport optimistic ' +
               'update in operation %s.' +
               this._operation.request.node.params.name,
           );
         } else {
           this._optimisticUpdates.push(...moduleImportOptimisticUpdates);
+          // OK: always have to run() after an module import resolves async
           this._publishQueue.run();
         }
       });
@@ -745,8 +787,10 @@ class Executor {
             }
           });
           if (relayPayloads.length > 0) {
-            const updatedOwners = this._publishQueue.run();
-            this._updateOperationTracker(updatedOwners);
+            if (!RelayFeatureFlags.ENABLE_BATCHED_STORE_UPDATES) {
+              const updatedOwners = this._publishQueue.run();
+              this._updateOperationTracker(updatedOwners);
+            }
             this._processPayloadFollowups(relayPayloads);
           }
         }
@@ -829,6 +873,9 @@ class Executor {
                 moduleImportPayload,
                 getOperation(operation),
               );
+              // OK: always have to run after an async module import resolves
+              const updatedOwners = this._publishQueue.run();
+              this._updateOperationTracker(updatedOwners);
             });
           }
         })
@@ -855,8 +902,10 @@ class Executor {
       operation,
     );
     this._publishQueue.commitPayload(this._operation, relayPayload);
-    const updatedOwners = this._publishQueue.run();
-    this._updateOperationTracker(updatedOwners);
+    if (!RelayFeatureFlags.ENABLE_BATCHED_STORE_UPDATES) {
+      const updatedOwners = this._publishQueue.run();
+      this._updateOperationTracker(updatedOwners);
+    }
     this._processPayloadFollowups([relayPayload]);
   }
 
@@ -961,8 +1010,10 @@ class Executor {
       const payloadFollowups = this._processIncrementalResponses(
         pendingResponses,
       );
-      const updatedOwners = this._publishQueue.run();
-      this._updateOperationTracker(updatedOwners);
+      if (!RelayFeatureFlags.ENABLE_BATCHED_STORE_UPDATES) {
+        const updatedOwners = this._publishQueue.run();
+        this._updateOperationTracker(updatedOwners);
+      }
       this._processPayloadFollowups(payloadFollowups);
     }
   }
@@ -1291,11 +1342,7 @@ class Executor {
   _updateOperationTracker(
     updatedOwners: ?$ReadOnlyArray<RequestDescriptor>,
   ): void {
-    if (
-      this._operationTracker != null &&
-      updatedOwners != null &&
-      updatedOwners.length > 0
-    ) {
+    if (updatedOwners != null && updatedOwners.length > 0) {
       this._operationTracker.update(
         this._operation.request,
         new Set(updatedOwners),
@@ -1304,9 +1351,7 @@ class Executor {
   }
 
   _completeOperationTracker() {
-    if (this._operationTracker != null) {
-      this._operationTracker.complete(this._operation.request);
-    }
+    this._operationTracker.complete(this._operation.request);
   }
 }
 
@@ -1324,7 +1369,7 @@ function partitionGraphQLResponses(
       if (label == null || path == null) {
         invariant(
           false,
-          'RelayModernQueryExecutor: invalid incremental payload, expected ' +
+          'OperationExecutor: invalid incremental payload, expected ' +
             '`path` and `label` to either both be null/undefined, or ' +
             '`path` to be an `Array<string | number>` and `label` to be a ' +
             '`string`.',
@@ -1376,11 +1421,13 @@ function validateOptimisticResponsePayload(
   if (incrementalPlaceholders != null && incrementalPlaceholders.length !== 0) {
     invariant(
       false,
-      'RelayModernQueryExecutor: optimistic responses cannot be returned ' +
+      'OperationExecutor: optimistic responses cannot be returned ' +
         'for operations that use incremental data delivery (@defer, ' +
         '@stream, and @stream_connection).',
     );
   }
 }
 
-module.exports = {execute};
+module.exports = {
+  execute,
+};

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');
@@ -40,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 +56,7 @@ import type {
   PublishQueue,
   ReactFlightPayloadDeserializer,
   ReactFlightServerErrorHandler,
+  RequiredFieldLogger,
   SelectorStoreUpdater,
   SingularReaderSelector,
   Snapshot,
@@ -108,9 +108,6 @@ 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 =
@@ -150,7 +147,7 @@ class RelayModernEnvironment implements IEnvironment {
     this._getDataID = config.getDataID ?? defaultGetDataID;
     this._publishQueue = new RelayPublishQueue(
       config.store,
-      handlerProvider,
+      config.handlerProvider ?? RelayDefaultHandlerProvider,
       this._getDataID,
     );
     this._scheduler = config.scheduler ?? null;
@@ -240,27 +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,
-        reactFlightServerErrorHandler: this._reactFlightServerErrorHandler,
-        scheduler: this._scheduler,
-        sink,
-        source,
-        store: this._store,
-        updater: null,
-        operationTracker: this._operationTracker,
-        getDataID: this._getDataID,
-        treatMissingFieldsAsNull: this._treatMissingFieldsAsNull,
-        shouldProcessClientComponents: this._shouldProcessClientComponents,
-      });
-      return () => executor.cancel();
+    const subscription = this._execute({
+      createSource: () => RelayObservable.create(_sink => {}),
+      isClientPayload: false,
+      operation: optimisticConfig.operation,
+      optimisticConfig,
+      updater: null,
     }).subscribe({});
     return {
       dispose: () => subscription.unsubscribe(),
@@ -281,29 +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,
-        reactFlightServerErrorHandler: this._reactFlightServerErrorHandler,
-        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,
-        shouldProcessClientComponents: this._shouldProcessClientComponents,
-      });
-      return () => executor.cancel();
+    this._execute({
+      createSource: () => RelayObservable.from({data: payload}),
+      isClientPayload: true,
+      operation: operation,
+      optimisticConfig: null,
+      updater: null,
     }).subscribe({});
   }
 
@@ -372,32 +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,
-        reactFlightServerErrorHandler: this._reactFlightServerErrorHandler,
-        scheduler: this._scheduler,
-        sink,
-        source,
-        store: this._store,
-        updater,
-        operationTracker: this._operationTracker,
-        getDataID: this._getDataID,
-        treatMissingFieldsAsNull: this._treatMissingFieldsAsNull,
-        shouldProcessClientComponents: this._shouldProcessClientComponents,
-      });
-      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,
     });
   }
 
@@ -417,50 +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,
-        reactFlightServerErrorHandler: this._reactFlightServerErrorHandler,
-        scheduler: this._scheduler,
-        sink,
-        source,
-        store: this._store,
-        updater,
-        operationTracker: this._operationTracker,
-        getDataID: this._getDataID,
-        treatMissingFieldsAsNull: this._treatMissingFieldsAsNull,
-        shouldProcessClientComponents: this._shouldProcessClientComponents,
-      });
-      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,
     });
   }
 
@@ -479,33 +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,
-        shouldProcessClientComponents: this._shouldProcessClientComponents,
+        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

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');
@@ -770,8 +769,4 @@ function getAvailabilityStatus(
   return {status: 'available', fetchTime: operationFetchTime ?? null};
 }
 
-RelayProfiler.instrumentMethods(RelayModernStore.prototype, {
-  lookup: 'RelayModernStore.prototype.lookup',
-});
-
 module.exports = RelayModernStore;

package/store/RelayPublishQueue.js.flow

@@ -12,7 +12,6 @@
 
 'use strict';
 
-const ErrorUtils = require('ErrorUtils');
 const RelayReader = require('./RelayReader');
 const RelayRecordSource = require('./RelayRecordSource');
 const RelayRecordSourceMutator = require('../mutations/RelayRecordSourceMutator');
@@ -55,6 +54,10 @@ type PendingUpdater = {|
   +updater: StoreUpdater,
 |};
 
+const applyWithGuard =
+  global.ErrorUtils?.applyWithGuard ??
+  ((callback, context, args, onError, name) => callback.apply(context, args));
+
 /**
  * Coordinates the concurrent modification of a `Store` due to optimistic and
  * non-revertable client updates and server payloads:
@@ -299,7 +302,7 @@ class RelayPublishQueue implements PublishQueue {
           mutator,
           this._getDataID,
         );
-        ErrorUtils.applyWithGuard(
+        applyWithGuard(
           updater,
           null,
           [recordSourceProxy],
@@ -334,7 +337,7 @@ class RelayPublishQueue implements PublishQueue {
     const processUpdate = optimisticUpdate => {
       if (optimisticUpdate.storeUpdater) {
         const {storeUpdater} = optimisticUpdate;
-        ErrorUtils.applyWithGuard(
+        applyWithGuard(
           storeUpdater,
           null,
           [recordSourceProxy],
@@ -355,7 +358,7 @@ class RelayPublishQueue implements PublishQueue {
           selectorData = lookupSelector(source, operation.fragment);
         }
         if (updater) {
-          ErrorUtils.applyWithGuard(
+          applyWithGuard(
             updater,
             null,
             [recordSourceSelectorProxy, selectorData],