relay-runtime 10.1.3 → 11.0.2

package/store/RelayOperationTracker.js.flow

@@ -17,17 +17,17 @@ const invariant = require('invariant');
 import type {RequestDescriptor} from './RelayStoreTypes';
 
 class RelayOperationTracker {
-  _ownersToPendingOperations: Map<RequestDescriptor, Set<RequestDescriptor>>;
-  _pendingOperationsToOwners: Map<RequestDescriptor, Set<RequestDescriptor>>;
-  _ownersToPromise: Map<
-    RequestDescriptor,
+  _ownersToPendingOperationsIdentifier: Map<string, Set<string>>;
+  _pendingOperationsToOwnersIdentifier: Map<string, Set<string>>;
+  _ownersIdentifierToPromise: Map<
+    string,
     {|promise: Promise<void>, resolve: () => void|},
   >;
 
   constructor() {
-    this._ownersToPendingOperations = new Map();
-    this._pendingOperationsToOwners = new Map();
-    this._ownersToPromise = new Map();
+    this._ownersToPendingOperationsIdentifier = new Map();
+    this._pendingOperationsToOwnersIdentifier = new Map();
+    this._ownersIdentifierToPromise = new Map();
   }
 
   /**
@@ -41,43 +41,50 @@ class RelayOperationTracker {
     if (affectedOwners.size === 0) {
       return;
     }
-    const newlyAffectedOwners = new Set();
+    const pendingOperationIdentifier = pendingOperation.identifier;
+    const newlyAffectedOwnersIdentifier = new Set();
     for (const owner of affectedOwners) {
-      const pendingOperationsAffectingOwner = this._ownersToPendingOperations.get(
-        owner,
+      const ownerIdentifier = owner.identifier;
+      const pendingOperationsAffectingOwner = this._ownersToPendingOperationsIdentifier.get(
+        ownerIdentifier,
       );
       if (pendingOperationsAffectingOwner != null) {
-        // In this case the `owner` already affected by some operations
+        // In this case the `ownerIdentifier` already affected by some operations
         // We just need to detect, is it the same operation that we already
         // have in the list, or it's a new operation
-        if (!pendingOperationsAffectingOwner.has(pendingOperation)) {
-          pendingOperationsAffectingOwner.add(pendingOperation);
-          newlyAffectedOwners.add(owner);
+        if (!pendingOperationsAffectingOwner.has(pendingOperationIdentifier)) {
+          pendingOperationsAffectingOwner.add(pendingOperationIdentifier);
+          newlyAffectedOwnersIdentifier.add(ownerIdentifier);
         }
       } else {
-        // This is a new `owner` that is affected by the operation
-        this._ownersToPendingOperations.set(owner, new Set([pendingOperation]));
-        newlyAffectedOwners.add(owner);
+        // This is a new `ownerIdentifier` that is affected by the operation
+        this._ownersToPendingOperationsIdentifier.set(
+          ownerIdentifier,
+          new Set([pendingOperationIdentifier]),
+        );
+        newlyAffectedOwnersIdentifier.add(ownerIdentifier);
       }
     }
 
     // No new owners were affected by this operation, we may stop here
-    if (newlyAffectedOwners.size === 0) {
+    if (newlyAffectedOwnersIdentifier.size === 0) {
       return;
     }
 
     // But, if some owners were affected we need to add them to
-    // the `_pendingOperationsToOwners` set
-    const ownersAffectedByOperation =
-      this._pendingOperationsToOwners.get(pendingOperation) || new Set();
-
-    for (const owner of newlyAffectedOwners) {
-      this._resolveOwnerResolvers(owner);
-      ownersAffectedByOperation.add(owner);
+    // the `_pendingOperationsToOwnersIdentifier` set
+    const ownersAffectedByOperationIdentifier =
+      this._pendingOperationsToOwnersIdentifier.get(
+        pendingOperationIdentifier,
+      ) || new Set();
+
+    for (const ownerIdentifier of newlyAffectedOwnersIdentifier) {
+      this._resolveOwnerResolvers(ownerIdentifier);
+      ownersAffectedByOperationIdentifier.add(ownerIdentifier);
     }
-    this._pendingOperationsToOwners.set(
-      pendingOperation,
-      ownersAffectedByOperation,
+    this._pendingOperationsToOwnersIdentifier.set(
+      pendingOperationIdentifier,
+      ownersAffectedByOperationIdentifier,
     );
   }
 
@@ -86,64 +93,70 @@ class RelayOperationTracker {
    * from all tracking maps
    */
   complete(pendingOperation: RequestDescriptor): void {
-    const affectedOwners = this._pendingOperationsToOwners.get(
-      pendingOperation,
+    const pendingOperationIdentifier = pendingOperation.identifier;
+    const affectedOwnersIdentifier = this._pendingOperationsToOwnersIdentifier.get(
+      pendingOperationIdentifier,
     );
-    if (affectedOwners == null) {
+    if (affectedOwnersIdentifier == null) {
       return;
     }
-    // These were the owners affected only by `pendingOperation`
-    const completedOwners = new Set();
+    // These were the owners affected only by `pendingOperationIdentifier`
+    const completedOwnersIdentifier = new Set();
 
-    // These were the owners affected by `pendingOperation`
+    // These were the owners affected by `pendingOperationIdentifier`
     // and some other operations
-    const updatedOwners = new Set();
-    for (const owner of affectedOwners) {
-      const pendingOperationsAffectingOwner = this._ownersToPendingOperations.get(
-        owner,
+    const updatedOwnersIdentifier = new Set();
+    for (const ownerIdentifier of affectedOwnersIdentifier) {
+      const pendingOperationsAffectingOwner = this._ownersToPendingOperationsIdentifier.get(
+        ownerIdentifier,
       );
       if (!pendingOperationsAffectingOwner) {
         continue;
       }
-      pendingOperationsAffectingOwner.delete(pendingOperation);
+      pendingOperationsAffectingOwner.delete(pendingOperationIdentifier);
       if (pendingOperationsAffectingOwner.size > 0) {
-        updatedOwners.add(owner);
+        updatedOwnersIdentifier.add(ownerIdentifier);
       } else {
-        completedOwners.add(owner);
+        completedOwnersIdentifier.add(ownerIdentifier);
       }
     }
 
-    // Complete subscriptions for all owners, affected by `pendingOperation`
-    for (const owner of completedOwners) {
-      this._resolveOwnerResolvers(owner);
-      this._ownersToPendingOperations.delete(owner);
+    // Complete subscriptions for all owners, affected by `pendingOperationIdentifier`
+    for (const ownerIdentifier of completedOwnersIdentifier) {
+      this._resolveOwnerResolvers(ownerIdentifier);
+      this._ownersToPendingOperationsIdentifier.delete(ownerIdentifier);
     }
 
-    // Update all owner that were updated by `pendingOperation` but still
+    // Update all ownerIdentifier that were updated by `pendingOperationIdentifier` but still
     // are affected by other operations
-    for (const owner of updatedOwners) {
-      this._resolveOwnerResolvers(owner);
+    for (const ownerIdentifier of updatedOwnersIdentifier) {
+      this._resolveOwnerResolvers(ownerIdentifier);
     }
 
-    // Finally, remove pending operation
-    this._pendingOperationsToOwners.delete(pendingOperation);
+    // Finally, remove pending operation identifier
+    this._pendingOperationsToOwnersIdentifier.delete(
+      pendingOperationIdentifier,
+    );
   }
 
-  _resolveOwnerResolvers(owner: RequestDescriptor): void {
-    const promiseEntry = this._ownersToPromise.get(owner);
+  _resolveOwnerResolvers(ownerIdentifier: string): void {
+    const promiseEntry = this._ownersIdentifierToPromise.get(ownerIdentifier);
     if (promiseEntry != null) {
       promiseEntry.resolve();
     }
-    this._ownersToPromise.delete(owner);
+    this._ownersIdentifierToPromise.delete(ownerIdentifier);
   }
 
   getPromiseForPendingOperationsAffectingOwner(
     owner: RequestDescriptor,
   ): Promise<void> | null {
-    if (!this._ownersToPendingOperations.has(owner)) {
+    const ownerIdentifier = owner.identifier;
+    if (!this._ownersToPendingOperationsIdentifier.has(ownerIdentifier)) {
       return null;
     }
-    const cachedPromiseEntry = this._ownersToPromise.get(owner);
+    const cachedPromiseEntry = this._ownersIdentifierToPromise.get(
+      ownerIdentifier,
+    );
     if (cachedPromiseEntry != null) {
       return cachedPromiseEntry.promise;
     }
@@ -156,7 +169,7 @@ class RelayOperationTracker {
       'RelayOperationTracker: Expected resolver to be defined. If you' +
         'are seeing this, it is likely a bug in Relay.',
     );
-    this._ownersToPromise.set(owner, {promise, resolve});
+    this._ownersIdentifierToPromise.set(ownerIdentifier, {promise, resolve});
     return promise;
   }
 }

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],

package/store/RelayReader.js.flow

@@ -28,6 +28,7 @@ const {
   LINKED_FIELD,
   MODULE_IMPORT,
   REQUIRED_FIELD,
+  RELAY_RESOLVER,
   SCALAR_FIELD,
   STREAM,
 } = require('../util/RelayConcreteNode');
@@ -44,15 +45,18 @@ const {
   getStorageKey,
   getModuleComponentKey,
 } = require('./RelayStoreUtils');
+const {withResolverContext} = require('./ResolverFragments');
 const {generateTypeID} = require('./TypeID');
 
 import type {
   ReaderFlightField,
+  ReaderFragment,
   ReaderFragmentSpread,
   ReaderInlineDataFragmentSpread,
   ReaderLinkedField,
   ReaderModuleImport,
   ReaderNode,
+  ReaderRelayResolver,
   ReaderRequiredField,
   ReaderScalarField,
   ReaderSelection,
@@ -66,6 +70,7 @@ import type {
   SingularReaderSelector,
   Snapshot,
   MissingRequiredFields,
+  DataIDSet,
 } from './RelayStoreTypes';
 
 function read(
@@ -85,7 +90,7 @@ class RelayReader {
   _missingRequiredFields: ?MissingRequiredFields;
   _owner: RequestDescriptor;
   _recordSource: RecordSource;
-  _seenRecords: {[dataID: DataID]: ?Record, ...};
+  _seenRecords: DataIDSet;
   _selector: SingularReaderSelector;
   _variables: Variables;
 
@@ -95,7 +100,7 @@ class RelayReader {
     this._missingRequiredFields = null;
     this._owner = selector.owner;
     this._recordSource = recordSource;
-    this._seenRecords = {};
+    this._seenRecords = new Set();
     this._selector = selector;
     this._variables = selector.variables;
   }
@@ -169,7 +174,7 @@ class RelayReader {
     prevData: ?SelectorData,
   ): ?SelectorData {
     const record = this._recordSource.get(dataID);
-    this._seenRecords[dataID] = record;
+    this._seenRecords.add(dataID);
     if (record == null) {
       if (record === undefined) {
         this._isMissingData = true;
@@ -191,6 +196,7 @@ class RelayReader {
       'RelayReader(): Undefined variable `%s`.',
       name,
     );
+    // $FlowFixMe[cannot-write]
     return this._variables[name];
   }
 
@@ -325,6 +331,13 @@ class RelayReader {
           }
           break;
         }
+        case RELAY_RESOLVER: {
+          if (!RelayFeatureFlags.ENABLE_RELAY_RESOLVERS) {
+            throw new Error('Relay Resolver fields are not yet supported.');
+          }
+          this._readResolverField(selection, record, data);
+          break;
+        }
         case FRAGMENT_SPREAD:
           this._createFragmentPointer(selection, record, data);
           break;
@@ -332,7 +345,11 @@ class RelayReader {
           this._readModuleImport(selection, record, data);
           break;
         case INLINE_DATA_FRAGMENT_SPREAD:
-          this._createInlineDataFragmentPointer(selection, record, data);
+          this._createInlineDataOrResolverFragmentPointer(
+            selection,
+            record,
+            data,
+          );
           break;
         case DEFER:
         case CLIENT_EXTENSION: {
@@ -402,6 +419,43 @@ class RelayReader {
     }
   }
 
+  _readResolverField(
+    selection: ReaderRelayResolver,
+    record: Record,
+    data: SelectorData,
+  ): ?mixed {
+    const {name, alias, resolverModule, fragment} = selection;
+    const key = {
+      __id: RelayModernRecord.getDataID(record),
+      __fragmentOwner: this._owner,
+      __fragments: {
+        [fragment.name]: {}, // Arguments to this fragment; not yet supported.
+      },
+    };
+    const resolverContext = {
+      getDataForResolverFragment: singularReaderSelector => {
+        const resolverFragmentData = {};
+        this._createInlineDataOrResolverFragmentPointer(
+          singularReaderSelector.node,
+          record,
+          resolverFragmentData,
+        );
+        const answer = resolverFragmentData[FRAGMENTS_KEY]?.[fragment.name];
+        invariant(
+          typeof answer === 'object' && answer !== null,
+          `Expected reader data to contain a __fragments property with a property for the fragment named ${fragment.name}, but it is missing.`,
+        );
+        return answer;
+      },
+    };
+    const resolverResult = withResolverContext(resolverContext, () =>
+      // $FlowFixMe[prop-missing] - resolver module's type signature is a lie
+      resolverModule(key),
+    );
+    data[alias ?? name] = resolverResult;
+    return resolverResult;
+  }
+
   _readFlightField(
     field: ReaderFlightField,
     record: Record,
@@ -423,9 +477,7 @@ class RelayReader {
     const reactFlightClientResponseRecord = this._recordSource.get(
       reactFlightClientResponseRecordID,
     );
-    this._seenRecords[
-      reactFlightClientResponseRecordID
-    ] = reactFlightClientResponseRecord;
+    this._seenRecords.add(reactFlightClientResponseRecordID);
     if (reactFlightClientResponseRecord == null) {
       data[applicationName] = reactFlightClientResponseRecord;
       if (reactFlightClientResponseRecord === undefined) {
@@ -607,8 +659,8 @@ class RelayReader {
     }
   }
 
-  _createInlineDataFragmentPointer(
-    inlineDataFragmentSpread: ReaderInlineDataFragmentSpread,
+  _createInlineDataOrResolverFragmentPointer(
+    fragmentSpreadOrFragment: ReaderInlineDataFragmentSpread | ReaderFragment,
     record: Record,
     data: SelectorData,
   ): void {
@@ -626,12 +678,12 @@ class RelayReader {
     }
     const inlineData = {};
     this._traverseSelections(
-      inlineDataFragmentSpread.selections,
+      fragmentSpreadOrFragment.selections,
       record,
       inlineData,
     );
     // $FlowFixMe[cannot-write] - writing into read-only field
-    fragmentPointers[inlineDataFragmentSpread.name] = inlineData;
+    fragmentPointers[fragmentSpreadOrFragment.name] = inlineData;
   }
 }
 

package/store/RelayRecordSource.js.flow

@@ -14,14 +14,14 @@
 
 const RelayRecordSourceMapImpl = require('./RelayRecordSourceMapImpl');
 
-import type {MutableRecordSource, RecordMap} from './RelayStoreTypes';
+import type {MutableRecordSource, RecordObjectMap} from './RelayStoreTypes';
 
 class RelayRecordSource {
-  constructor(records?: RecordMap): MutableRecordSource {
+  constructor(records?: RecordObjectMap): MutableRecordSource {
     return RelayRecordSource.create(records);
   }
 
-  static create(records?: RecordMap): MutableRecordSource {
+  static create(records?: RecordObjectMap): MutableRecordSource {
     return new RelayRecordSourceMapImpl(records);
   }
 }

package/store/RelayRecordSourceMapImpl.js.flow

@@ -16,7 +16,11 @@ const RelayRecordState = require('./RelayRecordState');
 
 import type {DataID} from '../util/RelayRuntimeTypes';
 import type {RecordState} from './RelayRecordState';
-import type {MutableRecordSource, Record, RecordMap} from './RelayStoreTypes';
+import type {
+  MutableRecordSource,
+  Record,
+  RecordObjectMap,
+} from './RelayStoreTypes';
 
 const {EXISTENT, NONEXISTENT, UNKNOWN} = RelayRecordState;
 
@@ -27,7 +31,7 @@ const {EXISTENT, NONEXISTENT, UNKNOWN} = RelayRecordState;
 class RelayMapRecordSourceMapImpl implements MutableRecordSource {
   _records: Map<DataID, ?Record>;
 
-  constructor(records?: RecordMap) {
+  constructor(records?: RecordObjectMap) {
     this._records = new Map();
     if (records != null) {
       Object.keys(records).forEach(key => {

package/store/RelayReferenceMarker.js.flow

@@ -24,7 +24,6 @@ const invariant = require('invariant');
 
 const {generateTypeID} = require('./TypeID');
 
-import type {ReactFlightPayloadQuery} from '../network/RelayNetworkTypes';
 import type {
   NormalizationFlightField,
   NormalizationLinkedField,
@@ -34,14 +33,17 @@ import type {
 } from '../util/NormalizationNode';
 import type {DataID, Variables} from '../util/RelayRuntimeTypes';
 import type {
+  DataIDSet,
   NormalizationSelector,
   OperationLoader,
   Record,
   RecordSource,
+  ReactFlightReachableExecutableDefinitions,
 } from './RelayStoreTypes';
 
 const {
   CONDITION,
+  CLIENT_COMPONENT,
   CLIENT_EXTENSION,
   DEFER,
   FLIGHT_FIELD,
@@ -60,8 +62,9 @@ const {ROOT_ID, getStorageKey, getModuleOperationKey} = RelayStoreUtils;
 function mark(
   recordSource: RecordSource,
   selector: NormalizationSelector,
-  references: Set<DataID>,
+  references: DataIDSet,
   operationLoader: ?OperationLoader,
+  shouldProcessClientComponents: ?boolean,
 ): void {
   const {dataID, node, variables} = selector;
   const marker = new RelayReferenceMarker(
@@ -69,6 +72,7 @@ function mark(
     variables,
     references,
     operationLoader,
+    shouldProcessClientComponents,
   );
   marker.mark(node, dataID);
 }
@@ -80,20 +84,23 @@ class RelayReferenceMarker {
   _operationLoader: OperationLoader | null;
   _operationName: ?string;
   _recordSource: RecordSource;
-  _references: Set<DataID>;
+  _references: DataIDSet;
   _variables: Variables;
+  _shouldProcessClientComponents: ?boolean;
 
   constructor(
     recordSource: RecordSource,
     variables: Variables,
-    references: Set<DataID>,
+    references: DataIDSet,
     operationLoader: ?OperationLoader,
+    shouldProcessClientComponents: ?boolean,
   ) {
     this._operationLoader = operationLoader ?? null;
     this._operationName = null;
     this._recordSource = recordSource;
     this._references = references;
     this._variables = variables;
+    this._shouldProcessClientComponents = shouldProcessClientComponents;
   }
 
   mark(node: NormalizationNode, dataID: DataID): void {
@@ -118,6 +125,7 @@ class RelayReferenceMarker {
       'RelayReferenceMarker(): Undefined variable `%s`.',
       name,
     );
+    // $FlowFixMe[cannot-write]
     return this._variables[name];
   }
 
@@ -158,12 +166,8 @@ class RelayReferenceMarker {
           break;
         // $FlowFixMe[incompatible-type]
         case FRAGMENT_SPREAD:
-          invariant(
-            false,
-            'RelayReferenceMarker(): Unexpected fragment spread `...%s`, ' +
-              'expected all fragments to be inlined.',
-            selection.name,
-          );
+          this._traverseSelections(selection.fragment.selections, record);
+          break;
         case LINKED_HANDLE:
           // The selections for a "handle" field are the same as those of the
           // original linked field where the handle was applied. Reference marking
@@ -213,6 +217,12 @@ class RelayReferenceMarker {
             throw new Error('Flight fields are not yet supported.');
           }
           break;
+        case CLIENT_COMPONENT:
+          if (this._shouldProcessClientComponents === false) {
+            break;
+          }
+          this._traverseSelections(selection.fragment.selections, record);
+          break;
         default:
           (selection: empty);
           invariant(
@@ -289,12 +299,12 @@ class RelayReferenceMarker {
       return;
     }
 
-    const reachableQueries = RelayModernRecord.getValue(
+    const reachableExecutableDefinitions = RelayModernRecord.getValue(
       reactFlightClientResponseRecord,
-      RelayStoreReactFlightUtils.REACT_FLIGHT_QUERIES_STORAGE_KEY,
+      RelayStoreReactFlightUtils.REACT_FLIGHT_EXECUTABLE_DEFINITIONS_STORAGE_KEY,
     );
 
-    if (!Array.isArray(reachableQueries)) {
+    if (!Array.isArray(reachableExecutableDefinitions)) {
       return;
     }
 
@@ -304,13 +314,13 @@ class RelayReferenceMarker {
       '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<ReactFlightPayloadQuery>)) {
-      this._variables = query.variables;
-      const operationReference = query.module;
+    for (const definition of (reachableExecutableDefinitions: Array<ReactFlightReachableExecutableDefinitions>)) {
+      this._variables = definition.variables;
+      const operationReference = definition.module;
       const normalizationRootNode = operationLoader.get(operationReference);
       if (normalizationRootNode != null) {
         const operation = getOperation(normalizationRootNode);