relay-runtime 10.1.3 → 11.0.2

package/store/DataChecker.js.flow

@@ -46,7 +46,7 @@ import type {
   MutableRecordSource,
   NormalizationSelector,
   OperationLoader,
-  ReactFlightReachableQuery,
+  ReactFlightReachableExecutableDefinitions,
   Record,
   RecordSource,
 } from './RelayStoreTypes';
@@ -58,6 +58,7 @@ export type Availability = {|
 
 const {
   CONDITION,
+  CLIENT_COMPONENT,
   CLIENT_EXTENSION,
   DEFER,
   FLIGHT_FIELD,
@@ -95,6 +96,7 @@ function check(
   handlers: $ReadOnlyArray<MissingFieldHandler>,
   operationLoader: ?OperationLoader,
   getDataID: GetDataID,
+  shouldProcessClientComponents: ?boolean,
 ): Availability {
   const {dataID, node, variables} = selector;
   const checker = new DataChecker(
@@ -104,6 +106,7 @@ function check(
     handlers,
     operationLoader,
     getDataID,
+    shouldProcessClientComponents,
   );
   return checker.check(node, dataID);
 }
@@ -121,6 +124,7 @@ class DataChecker {
   _recordWasMissing: boolean;
   _source: RecordSource;
   _variables: Variables;
+  _shouldProcessClientComponents: ?boolean;
 
   constructor(
     source: RecordSource,
@@ -129,6 +133,7 @@ class DataChecker {
     handlers: $ReadOnlyArray<MissingFieldHandler>,
     operationLoader: ?OperationLoader,
     getDataID: GetDataID,
+    shouldProcessClientComponents: ?boolean,
   ) {
     const mutator = new RelayRecordSourceMutator(source, target);
     this._mostRecentlyInvalidatedAt = null;
@@ -139,6 +144,7 @@ class DataChecker {
     this._recordWasMissing = false;
     this._source = source;
     this._variables = variables;
+    this._shouldProcessClientComponents = shouldProcessClientComponents;
   }
 
   check(node: NormalizationNode, dataID: DataID): Availability {
@@ -161,6 +167,7 @@ class DataChecker {
       'RelayAsyncLoader(): Undefined variable `%s`.',
       name,
     );
+    // $FlowFixMe[cannot-write]
     return this._variables[name];
   }
 
@@ -383,12 +390,7 @@ class DataChecker {
           break;
         // $FlowFixMe[incompatible-type]
         case FRAGMENT_SPREAD:
-          invariant(
-            false,
-            'RelayAsyncLoader(): Unexpected ast kind `%s`.',
-            selection.kind,
-          );
-          // $FlowExpectedError[unreachable-code] - we need the break; for OSS linter
+          this._traverseSelections(selection.fragment.selections, dataID);
           break;
         case CLIENT_EXTENSION:
           const recordWasMissing = this._recordWasMissing;
@@ -423,6 +425,12 @@ class DataChecker {
             throw new Error('Flight fields are not yet supported.');
           }
           break;
+        case CLIENT_COMPONENT:
+          if (this._shouldProcessClientComponents === false) {
+            break;
+          }
+          this._traverseSelections(selection.fragment.selections, dataID);
+          break;
         default:
           (selection: empty);
           invariant(
@@ -527,12 +535,12 @@ class DataChecker {
       linkedID,
       RelayStoreReactFlightUtils.REACT_FLIGHT_TREE_STORAGE_KEY,
     );
-    const reachableQueries = this._mutator.getValue(
+    const reachableExecutableDefinitions = this._mutator.getValue(
       linkedID,
-      RelayStoreReactFlightUtils.REACT_FLIGHT_QUERIES_STORAGE_KEY,
+      RelayStoreReactFlightUtils.REACT_FLIGHT_EXECUTABLE_DEFINITIONS_STORAGE_KEY,
     );
 
-    if (tree == null || !Array.isArray(reachableQueries)) {
+    if (tree == null || !Array.isArray(reachableExecutableDefinitions)) {
       this._handleMissing();
       return;
     }
@@ -543,13 +551,13 @@ class DataChecker {
       'DataChecker: Expected an operationLoader to be configured when using ' +
         'React Flight.',
     );
-    // In Flight, the variables that are in scope for reachable queries aren't
-    // the same as what's in scope for the outer query.
+    // In Flight, the variables that are in scope for reachable executable
+    // definitions aren't the same as what's in scope for the outer query.
     const prevVariables = this._variables;
     // $FlowFixMe[incompatible-cast]
-    for (const query of (reachableQueries: Array<ReactFlightReachableQuery>)) {
-      this._variables = query.variables;
-      const normalizationRootNode = operationLoader.get(query.module);
+    for (const definition of (reachableExecutableDefinitions: Array<ReactFlightReachableExecutableDefinitions>)) {
+      this._variables = definition.variables;
+      const normalizationRootNode = operationLoader.get(definition.module);
       if (normalizationRootNode != null) {
         const operation = getOperation(normalizationRootNode);
         this._traverseSelections(operation.selections, ROOT_ID);

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

@@ -14,6 +14,7 @@
 'use strict';
 
 const RelayError = require('../util/RelayError');
+const RelayFeatureFlags = require('../util/RelayFeatureFlags');
 const RelayModernRecord = require('./RelayModernRecord');
 const RelayObservable = require('../network/RelayObservable');
 const RelayRecordSource = require('./RelayRecordSource');
@@ -24,8 +25,11 @@ const invariant = require('invariant');
 const stableCopy = require('../util/stableCopy');
 const warning = require('warning');
 
-const {generateClientID} = require('./ClientID');
-const {createNormalizationSelector} = require('./RelayModernSelector');
+const {generateClientID, generateUniqueClientID} = require('./ClientID');
+const {
+  createNormalizationSelector,
+  createReaderSelector,
+} = require('./RelayModernSelector');
 const {ROOT_TYPE, TYPENAME_KEY, getStorageKey} = require('./RelayStoreUtils');
 
 import type {
@@ -48,6 +52,7 @@ import type {
   OptimisticUpdate,
   PublishQueue,
   ReactFlightPayloadDeserializer,
+  ReactFlightServerErrorHandler,
   Record,
   RelayResponsePayload,
   SelectorStoreUpdater,
@@ -71,16 +76,18 @@ export type ExecuteConfig = {|
   +operation: OperationDescriptor,
   +operationExecutions: Map<string, ActiveState>,
   +operationLoader: ?OperationLoader,
-  +operationTracker?: ?OperationTracker,
+  +operationTracker: OperationTracker,
   +optimisticConfig: ?OptimisticResponseConfig,
   +publishQueue: PublishQueue,
   +reactFlightPayloadDeserializer?: ?ReactFlightPayloadDeserializer,
+  +reactFlightServerErrorHandler?: ?ReactFlightServerErrorHandler,
   +scheduler?: ?TaskScheduler,
   +sink: Sink<GraphQLResponse>,
   +source: RelayObservable<GraphQLResponse>,
   +store: Store,
   +updater?: ?SelectorStoreUpdater,
   +isClientPayload?: boolean,
+  +shouldProcessClientComponents?: ?boolean,
 |};
 
 export type ActiveState = 'active' | 'inactive';
@@ -126,12 +133,14 @@ class Executor {
   _operation: OperationDescriptor;
   _operationExecutions: Map<string, ActiveState>;
   _operationLoader: ?OperationLoader;
-  _operationTracker: ?OperationTracker;
+  _operationTracker: OperationTracker;
   _operationUpdateEpochs: Map<string, number>;
   _optimisticUpdates: null | Array<OptimisticUpdate>;
   _pendingModulePayloadsCount: number;
   _publishQueue: PublishQueue;
   _reactFlightPayloadDeserializer: ?ReactFlightPayloadDeserializer;
+  _reactFlightServerErrorHandler: ?ReactFlightServerErrorHandler;
+  _shouldProcessClientComponents: ?boolean;
   _scheduler: ?TaskScheduler;
   _sink: Sink<GraphQLResponse>;
   _source: Map<
@@ -144,6 +153,7 @@ class Executor {
   _updater: ?SelectorStoreUpdater;
   _retainDisposable: ?Disposable;
   +_isClientPayload: boolean;
+  +_isSubscriptionOperation: boolean;
 
   constructor({
     operation,
@@ -161,6 +171,8 @@ class Executor {
     getDataID,
     isClientPayload,
     reactFlightPayloadDeserializer,
+    reactFlightServerErrorHandler,
+    shouldProcessClientComponents,
   }: ExecuteConfig): void {
     this._getDataID = getDataID;
     this._treatMissingFieldsAsNull = treatMissingFieldsAsNull;
@@ -184,6 +196,10 @@ class Executor {
     this._updater = updater;
     this._isClientPayload = isClientPayload === true;
     this._reactFlightPayloadDeserializer = reactFlightPayloadDeserializer;
+    this._reactFlightServerErrorHandler = reactFlightServerErrorHandler;
+    this._isSubscriptionOperation =
+      this._operation.request.node.params.operationKind === 'subscription';
+    this._shouldProcessClientComponents = shouldProcessClientComponents;
 
     const id = this._nextSubscriptionId++;
     source.subscribe({
@@ -228,6 +244,7 @@ class Executor {
       optimisticUpdates.forEach(update =>
         this._publishQueue.revertUpdate(update),
       );
+      // OK: run revert on cancel
       this._publishQueue.run();
     }
     this._incrementalResults.clear();
@@ -260,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,
@@ -387,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) {
@@ -433,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:
@@ -441,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);
+        }
       }
     }
 
@@ -458,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);
   }
 
@@ -491,6 +546,8 @@ class Executor {
           getDataID: this._getDataID,
           path: [],
           reactFlightPayloadDeserializer: this._reactFlightPayloadDeserializer,
+          reactFlightServerErrorHandler: this._reactFlightServerErrorHandler,
+          shouldProcessClientComponents: this._shouldProcessClientComponents,
           treatMissingFieldsAsNull,
         },
       );
@@ -517,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();
   }
 
@@ -569,7 +628,9 @@ class Executor {
         getDataID: this._getDataID,
         path: moduleImportPayload.path,
         reactFlightPayloadDeserializer: this._reactFlightPayloadDeserializer,
+        reactFlightServerErrorHandler: this._reactFlightServerErrorHandler,
         treatMissingFieldsAsNull: this._treatMissingFieldsAsNull,
+        shouldProcessClientComponents: this._shouldProcessClientComponents,
       },
     );
   }
@@ -614,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();
         }
       });
@@ -645,7 +707,9 @@ class Executor {
           getDataID: this._getDataID,
           path: [],
           reactFlightPayloadDeserializer: this._reactFlightPayloadDeserializer,
+          reactFlightServerErrorHandler: this._reactFlightServerErrorHandler,
           treatMissingFieldsAsNull: this._treatMissingFieldsAsNull,
+          shouldProcessClientComponents: this._shouldProcessClientComponents,
         },
       );
       this._publishQueue.commitPayload(
@@ -723,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);
           }
         }
@@ -733,9 +799,7 @@ class Executor {
   }
 
   _maybeCompleteSubscriptionOperationTracking() {
-    const isSubscriptionOperation =
-      this._operation.request.node.params.operationKind === 'subscription';
-    if (!isSubscriptionOperation) {
+    if (!this._isSubscriptionOperation) {
       return;
     }
     if (
@@ -744,6 +808,23 @@ class Executor {
     ) {
       this._completeOperationTracker();
     }
+    if (RelayFeatureFlags.ENABLE_UNIQUE_SUBSCRIPTION_ROOT) {
+      const nextID = generateUniqueClientID();
+      this._operation = {
+        request: this._operation.request,
+        fragment: createReaderSelector(
+          this._operation.fragment.node,
+          nextID,
+          this._operation.fragment.variables,
+          this._operation.fragment.owner,
+        ),
+        root: createNormalizationSelector(
+          this._operation.root.node,
+          nextID,
+          this._operation.root.variables,
+        ),
+      };
+    }
   }
 
   /**
@@ -792,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);
             });
           }
         })
@@ -818,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]);
   }
 
@@ -924,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);
     }
   }
@@ -1020,7 +1108,9 @@ class Executor {
         getDataID: this._getDataID,
         path: placeholder.path,
         reactFlightPayloadDeserializer: this._reactFlightPayloadDeserializer,
+        reactFlightServerErrorHandler: this._reactFlightServerErrorHandler,
         treatMissingFieldsAsNull: this._treatMissingFieldsAsNull,
+        shouldProcessClientComponents: this._shouldProcessClientComponents,
       },
     );
     this._publishQueue.commitPayload(this._operation, relayPayload);
@@ -1235,7 +1325,9 @@ class Executor {
       getDataID: this._getDataID,
       path: [...normalizationPath, responseKey, String(itemIndex)],
       reactFlightPayloadDeserializer: this._reactFlightPayloadDeserializer,
+      reactFlightServerErrorHandler: this._reactFlightServerErrorHandler,
       treatMissingFieldsAsNull: this._treatMissingFieldsAsNull,
+      shouldProcessClientComponents: this._shouldProcessClientComponents,
     });
     return {
       fieldPayloads,
@@ -1250,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),
@@ -1263,9 +1351,7 @@ class Executor {
   }
 
   _completeOperationTracker() {
-    if (this._operationTracker != null) {
-      this._operationTracker.complete(this._operation.request);
-    }
+    this._operationTracker.complete(this._operation.request);
   }
 }
 
@@ -1283,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`.',
@@ -1335,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/RelayConcreteVariables.js.flow

@@ -35,6 +35,7 @@ function getFragmentVariables(
     if (argumentVariables.hasOwnProperty(definition.name)) {
       return;
     }
+    // $FlowFixMe[cannot-spread-interface]
     variables = variables || {...argumentVariables};
     switch (definition.kind) {
       case 'LocalArgument':
@@ -51,9 +52,12 @@ function getFragmentVariables(
            * RelayStoreUtils.getStableVariableValue() that variable keys are all
            * present.
            */
+          // $FlowFixMe[incompatible-use]
           variables[definition.name] = undefined;
           break;
         }
+        // $FlowFixMe[incompatible-use]
+        // $FlowFixMe[cannot-write]
         variables[definition.name] = rootVariables[definition.name];
         break;
       default:
@@ -82,6 +86,7 @@ function getOperationVariables(
   const operationVariables = {};
   operation.argumentDefinitions.forEach(def => {
     let value = def.defaultValue;
+    // $FlowFixMe[cannot-write]
     if (variables[def.name] != null) {
       value = variables[def.name];
     }