relay-runtime 11.0.2 → 12.0.0

package/store/RelayOperationTracker.js.flow

@@ -17,17 +17,21 @@ const invariant = require('invariant');
 import type {RequestDescriptor} from './RelayStoreTypes';
 
 class RelayOperationTracker {
-  _ownersToPendingOperationsIdentifier: Map<string, Set<string>>;
-  _pendingOperationsToOwnersIdentifier: Map<string, Set<string>>;
-  _ownersIdentifierToPromise: Map<
+  _ownersToPendingOperations: Map<string, Map<string, RequestDescriptor>>;
+  _pendingOperationsToOwners: Map<string, Set<string>>;
+  _ownersToPendingPromise: Map<
     string,
-    {|promise: Promise<void>, resolve: () => void|},
+    {|
+      promise: Promise<void>,
+      resolve: () => void,
+      pendingOperations: $ReadOnlyArray<RequestDescriptor>,
+    |},
   >;
 
   constructor() {
-    this._ownersToPendingOperationsIdentifier = new Map();
-    this._pendingOperationsToOwnersIdentifier = new Map();
-    this._ownersIdentifierToPromise = new Map();
+    this._ownersToPendingOperations = new Map();
+    this._pendingOperationsToOwners = new Map();
+    this._ownersToPendingPromise = new Map();
   }
 
   /**
@@ -45,7 +49,7 @@ class RelayOperationTracker {
     const newlyAffectedOwnersIdentifier = new Set();
     for (const owner of affectedOwners) {
       const ownerIdentifier = owner.identifier;
-      const pendingOperationsAffectingOwner = this._ownersToPendingOperationsIdentifier.get(
+      const pendingOperationsAffectingOwner = this._ownersToPendingOperations.get(
         ownerIdentifier,
       );
       if (pendingOperationsAffectingOwner != null) {
@@ -53,14 +57,17 @@ class RelayOperationTracker {
         // 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(pendingOperationIdentifier)) {
-          pendingOperationsAffectingOwner.add(pendingOperationIdentifier);
+          pendingOperationsAffectingOwner.set(
+            pendingOperationIdentifier,
+            pendingOperation,
+          );
           newlyAffectedOwnersIdentifier.add(ownerIdentifier);
         }
       } else {
         // This is a new `ownerIdentifier` that is affected by the operation
-        this._ownersToPendingOperationsIdentifier.set(
+        this._ownersToPendingOperations.set(
           ownerIdentifier,
-          new Set([pendingOperationIdentifier]),
+          new Map([[pendingOperationIdentifier, pendingOperation]]),
         );
         newlyAffectedOwnersIdentifier.add(ownerIdentifier);
       }
@@ -72,19 +79,18 @@ class RelayOperationTracker {
     }
 
     // But, if some owners were affected we need to add them to
-    // the `_pendingOperationsToOwnersIdentifier` set
-    const ownersAffectedByOperationIdentifier =
-      this._pendingOperationsToOwnersIdentifier.get(
-        pendingOperationIdentifier,
-      ) || new Set();
+    // the `_pendingOperationsToOwners` set
+    const ownersAffectedByPendingOperation =
+      this._pendingOperationsToOwners.get(pendingOperationIdentifier) ||
+      new Set();
 
     for (const ownerIdentifier of newlyAffectedOwnersIdentifier) {
       this._resolveOwnerResolvers(ownerIdentifier);
-      ownersAffectedByOperationIdentifier.add(ownerIdentifier);
+      ownersAffectedByPendingOperation.add(ownerIdentifier);
     }
-    this._pendingOperationsToOwnersIdentifier.set(
+    this._pendingOperationsToOwners.set(
       pendingOperationIdentifier,
-      ownersAffectedByOperationIdentifier,
+      ownersAffectedByPendingOperation,
     );
   }
 
@@ -94,7 +100,7 @@ class RelayOperationTracker {
    */
   complete(pendingOperation: RequestDescriptor): void {
     const pendingOperationIdentifier = pendingOperation.identifier;
-    const affectedOwnersIdentifier = this._pendingOperationsToOwnersIdentifier.get(
+    const affectedOwnersIdentifier = this._pendingOperationsToOwners.get(
       pendingOperationIdentifier,
     );
     if (affectedOwnersIdentifier == null) {
@@ -107,7 +113,7 @@ class RelayOperationTracker {
     // and some other operations
     const updatedOwnersIdentifier = new Set();
     for (const ownerIdentifier of affectedOwnersIdentifier) {
-      const pendingOperationsAffectingOwner = this._ownersToPendingOperationsIdentifier.get(
+      const pendingOperationsAffectingOwner = this._ownersToPendingOperations.get(
         ownerIdentifier,
       );
       if (!pendingOperationsAffectingOwner) {
@@ -124,7 +130,7 @@ class RelayOperationTracker {
     // Complete subscriptions for all owners, affected by `pendingOperationIdentifier`
     for (const ownerIdentifier of completedOwnersIdentifier) {
       this._resolveOwnerResolvers(ownerIdentifier);
-      this._ownersToPendingOperationsIdentifier.delete(ownerIdentifier);
+      this._ownersToPendingOperations.delete(ownerIdentifier);
     }
 
     // Update all ownerIdentifier that were updated by `pendingOperationIdentifier` but still
@@ -134,31 +140,42 @@ class RelayOperationTracker {
     }
 
     // Finally, remove pending operation identifier
-    this._pendingOperationsToOwnersIdentifier.delete(
-      pendingOperationIdentifier,
-    );
+    this._pendingOperationsToOwners.delete(pendingOperationIdentifier);
   }
 
   _resolveOwnerResolvers(ownerIdentifier: string): void {
-    const promiseEntry = this._ownersIdentifierToPromise.get(ownerIdentifier);
+    const promiseEntry = this._ownersToPendingPromise.get(ownerIdentifier);
     if (promiseEntry != null) {
       promiseEntry.resolve();
     }
-    this._ownersIdentifierToPromise.delete(ownerIdentifier);
+    this._ownersToPendingPromise.delete(ownerIdentifier);
   }
 
-  getPromiseForPendingOperationsAffectingOwner(
+  getPendingOperationsAffectingOwner(
     owner: RequestDescriptor,
-  ): Promise<void> | null {
+  ): {|
+    promise: Promise<void>,
+    pendingOperations: $ReadOnlyArray<RequestDescriptor>,
+  |} | null {
     const ownerIdentifier = owner.identifier;
-    if (!this._ownersToPendingOperationsIdentifier.has(ownerIdentifier)) {
+    const pendingOperationsForOwner = this._ownersToPendingOperations.get(
+      ownerIdentifier,
+    );
+    if (
+      pendingOperationsForOwner == null ||
+      pendingOperationsForOwner.size === 0
+    ) {
       return null;
     }
-    const cachedPromiseEntry = this._ownersIdentifierToPromise.get(
+
+    const cachedPromiseEntry = this._ownersToPendingPromise.get(
       ownerIdentifier,
     );
     if (cachedPromiseEntry != null) {
-      return cachedPromiseEntry.promise;
+      return {
+        promise: cachedPromiseEntry.promise,
+        pendingOperations: cachedPromiseEntry.pendingOperations,
+      };
     }
     let resolve;
     const promise = new Promise(r => {
@@ -169,8 +186,13 @@ class RelayOperationTracker {
       'RelayOperationTracker: Expected resolver to be defined. If you' +
         'are seeing this, it is likely a bug in Relay.',
     );
-    this._ownersIdentifierToPromise.set(ownerIdentifier, {promise, resolve});
-    return promise;
+    const pendingOperations = Array.from(pendingOperationsForOwner.values());
+    this._ownersToPendingPromise.set(ownerIdentifier, {
+      promise,
+      resolve,
+      pendingOperations,
+    });
+    return {promise, pendingOperations};
   }
 }
 

package/store/RelayPublishQueue.js.flow

@@ -55,7 +55,7 @@ type PendingUpdater = {|
 |};
 
 const applyWithGuard =
-  global.ErrorUtils?.applyWithGuard ??
+  global?.ErrorUtils?.applyWithGuard ??
   ((callback, context, args, onError, name) => callback.apply(context, args));
 
 /**
@@ -185,7 +185,20 @@ class RelayPublishQueue implements PublishQueue {
   run(
     sourceOperation?: OperationDescriptor,
   ): $ReadOnlyArray<RequestDescriptor> {
+    const runWillClearGcHold =
+      this._appliedOptimisticUpdates === 0 && !!this._gcHold;
+    const runIsANoop =
+      // this._pendingBackupRebase is true if an applied optimistic
+      // update has potentially been reverted or if this._pendingData is not empty.
+      !this._pendingBackupRebase &&
+      this._pendingOptimisticUpdates.size === 0 &&
+      !runWillClearGcHold;
+
     if (__DEV__) {
+      warning(
+        !runIsANoop,
+        'RelayPublishQueue.run was called, but the call would have been a noop.',
+      );
       warning(
         this._isRunning !== true,
         'A store update was detected within another store update. Please ' +
@@ -194,6 +207,14 @@ class RelayPublishQueue implements PublishQueue {
       );
       this._isRunning = true;
     }
+
+    if (runIsANoop) {
+      if (__DEV__) {
+        this._isRunning = false;
+      }
+      return [];
+    }
+
     if (this._pendingBackupRebase) {
       if (this._hasStoreSnapshot) {
         this._store.restore();
@@ -347,17 +368,19 @@ class RelayPublishQueue implements PublishQueue {
       } else {
         const {operation, payload, updater} = optimisticUpdate;
         const {source, fieldPayloads} = payload;
-        const recordSourceSelectorProxy = new RelayRecordSourceSelectorProxy(
-          mutator,
-          recordSourceProxy,
-          operation.fragment,
-        );
-        let selectorData;
         if (source) {
           recordSourceProxy.publishSource(source, fieldPayloads);
-          selectorData = lookupSelector(source, operation.fragment);
         }
         if (updater) {
+          let selectorData;
+          if (source) {
+            selectorData = lookupSelector(source, operation.fragment);
+          }
+          const recordSourceSelectorProxy = new RelayRecordSourceSelectorProxy(
+            mutator,
+            recordSourceProxy,
+            operation.fragment,
+          );
           applyWithGuard(
             updater,
             null,

package/store/RelayReader.js.flow

@@ -12,12 +12,14 @@
 
 'use strict';
 
+const ClientID = require('./ClientID');
 const RelayFeatureFlags = require('../util/RelayFeatureFlags');
 const RelayModernRecord = require('./RelayModernRecord');
 
 const invariant = require('invariant');
 
 const {
+  ACTOR_CHANGE,
   CLIENT_EXTENSION,
   CONDITION,
   DEFER,
@@ -45,6 +47,7 @@ const {
   getStorageKey,
   getModuleComponentKey,
 } = require('./RelayStoreUtils');
+const {NoopResolverCache} = require('./ResolverCache');
 const {withResolverContext} = require('./ResolverFragments');
 const {generateTypeID} = require('./TypeID');
 
@@ -54,6 +57,7 @@ import type {
   ReaderFragmentSpread,
   ReaderInlineDataFragmentSpread,
   ReaderLinkedField,
+  ReaderActorChange,
   ReaderModuleImport,
   ReaderNode,
   ReaderRelayResolver,
@@ -72,12 +76,18 @@ import type {
   MissingRequiredFields,
   DataIDSet,
 } from './RelayStoreTypes';
+import type {ResolverCache} from './ResolverCache';
 
 function read(
   recordSource: RecordSource,
   selector: SingularReaderSelector,
+  resolverCache?: ResolverCache,
 ): Snapshot {
-  const reader = new RelayReader(recordSource, selector);
+  const reader = new RelayReader(
+    recordSource,
+    selector,
+    resolverCache ?? new NoopResolverCache(),
+  );
   return reader.read();
 }
 
@@ -93,8 +103,13 @@ class RelayReader {
   _seenRecords: DataIDSet;
   _selector: SingularReaderSelector;
   _variables: Variables;
+  _resolverCache: ResolverCache;
 
-  constructor(recordSource: RecordSource, selector: SingularReaderSelector) {
+  constructor(
+    recordSource: RecordSource,
+    selector: SingularReaderSelector,
+    resolverCache: ResolverCache,
+  ) {
     this._isMissingData = false;
     this._isWithinUnmatchedTypeRefinement = false;
     this._missingRequiredFields = null;
@@ -103,6 +118,7 @@ class RelayReader {
     this._seenRecords = new Set();
     this._selector = selector;
     this._variables = selector.variables;
+    this._resolverCache = resolverCache;
   }
 
   read(): Snapshot {
@@ -126,7 +142,18 @@ class RelayReader {
     // match, then no data is expected to be present.
     if (isDataExpectedToBePresent && abstractKey == null && record != null) {
       const recordType = RelayModernRecord.getType(record);
-      if (recordType !== node.type && dataID !== ROOT_ID) {
+      if (
+        recordType !== node.type &&
+        // The root record type is a special `__Root` type and may not match the
+        // type on the ast, so ignore type mismatches at the root.
+        // We currently detect whether we're at the root by checking against ROOT_ID,
+        // but this does not work for mutations/subscriptions which generate unique
+        // root ids. This is acceptable in practice as we don't read data for mutations/
+        // subscriptions in a situation where we would use isMissingData to decide whether
+        // to suspend or not.
+        // TODO T96653810: Correctly detect reading from root of mutation/subscription
+        dataID !== ROOT_ID
+      ) {
         isDataExpectedToBePresent = false;
       }
     }
@@ -135,12 +162,7 @@ class RelayReader {
     // then data is only expected to be present if the record type is known to
     // implement the interface. If we aren't sure whether the record implements
     // the interface, that itself constitutes "expected" data being missing.
-    if (
-      isDataExpectedToBePresent &&
-      abstractKey != null &&
-      record != null &&
-      RelayFeatureFlags.ENABLE_PRECISE_TYPE_REFINEMENT
-    ) {
+    if (isDataExpectedToBePresent && abstractKey != null && record != null) {
       const recordType = RelayModernRecord.getType(record);
       const typeID = generateTypeID(recordType);
       const typeRecord = this._recordSource.get(typeID);
@@ -267,7 +289,9 @@ class RelayReader {
           }
           break;
         case CONDITION:
-          const conditionValue = this._getVariableValue(selection.condition);
+          const conditionValue = Boolean(
+            this._getVariableValue(selection.condition),
+          );
           if (conditionValue === selection.passingValue) {
             const hasExpectedData = this._traverseSelections(
               selection.selections,
@@ -294,7 +318,7 @@ class RelayReader {
                 return false;
               }
             }
-          } else if (RelayFeatureFlags.ENABLE_PRECISE_TYPE_REFINEMENT) {
+          } else {
             // Similar to the logic in read(): data is only expected to be present
             // if the record is known to conform to the interface. If we don't know
             // whether the type conforms or not, that constitutes missing data.
@@ -324,10 +348,6 @@ class RelayReader {
               // Don't know if the type implements the interface or not
               this._isMissingData = true;
             }
-          } else {
-            // legacy behavior for abstract refinements: always read even
-            // if the type doesn't conform and don't reset isMissingData
-            this._traverseSelections(selection.selections, record, data);
           }
           break;
         }
@@ -383,6 +403,9 @@ class RelayReader {
             throw new Error('Flight fields are not yet supported.');
           }
           break;
+        case ACTOR_CHANGE:
+          this._readActorChange(selection, record, data);
+          break;
         default:
           (selection: empty);
           invariant(
@@ -409,6 +432,12 @@ class RelayReader {
         } else {
           return this._readLink(selection.field, record, data);
         }
+      case RELAY_RESOLVER:
+        if (!RelayFeatureFlags.ENABLE_RELAY_RESOLVERS) {
+          throw new Error('Relay Resolver fields are not yet supported.');
+        }
+        this._readResolverField(selection.field, record, data);
+        break;
       default:
         (selection.field.kind: empty);
         invariant(
@@ -420,40 +449,84 @@ class RelayReader {
   }
 
   _readResolverField(
-    selection: ReaderRelayResolver,
+    field: 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 {resolverModule, fragment} = field;
+    const storageKey = getStorageKey(field, this._variables);
+    const resolverID = ClientID.generateClientID(
+      RelayModernRecord.getDataID(record),
+      storageKey,
+    );
+
+    // Found when reading the resolver fragment, which can happen either when
+    // evaluating the resolver and it calls readFragment, or when checking if the
+    // inputs have changed since a previous evaluation:
+    let fragmentValue;
+    let fragmentReaderSelector;
+    const fragmentSeenRecordIDs = new Set();
+
+    const getDataForResolverFragment = singularReaderSelector => {
+      if (fragmentValue != null) {
+        // It was already read when checking for input staleness; no need to read it again.
+        // Note that the variables like fragmentSeenRecordIDs in the outer closure will have
+        // already been set and will still be used in this case.
+        return fragmentValue;
+      }
+      fragmentReaderSelector = singularReaderSelector;
+      const existingSeenRecords = this._seenRecords;
+      try {
+        this._seenRecords = fragmentSeenRecordIDs;
         const resolverFragmentData = {};
         this._createInlineDataOrResolverFragmentPointer(
           singularReaderSelector.node,
           record,
           resolverFragmentData,
         );
-        const answer = resolverFragmentData[FRAGMENTS_KEY]?.[fragment.name];
+        fragmentValue = resolverFragmentData[FRAGMENTS_KEY]?.[fragment.name];
         invariant(
-          typeof answer === 'object' && answer !== null,
+          typeof fragmentValue === 'object' && fragmentValue !== null,
           `Expected reader data to contain a __fragments property with a property for the fragment named ${fragment.name}, but it is missing.`,
         );
-        return answer;
-      },
+        return fragmentValue;
+      } finally {
+        this._seenRecords = existingSeenRecords;
+      }
     };
-    const resolverResult = withResolverContext(resolverContext, () =>
-      // $FlowFixMe[prop-missing] - resolver module's type signature is a lie
-      resolverModule(key),
+    const resolverContext = {getDataForResolverFragment};
+
+    const [result, seenRecord] = this._resolverCache.readFromCacheOrEvaluate(
+      record,
+      field,
+      this._variables,
+      () => {
+        const key = {
+          __id: RelayModernRecord.getDataID(record),
+          __fragmentOwner: this._owner,
+          __fragments: {
+            [fragment.name]: {}, // Arguments to this fragment; not yet supported.
+          },
+        };
+        return withResolverContext(resolverContext, () => {
+          // $FlowFixMe[prop-missing] - resolver module's type signature is a lie
+          const resolverResult = resolverModule(key);
+          return {
+            resolverResult,
+            fragmentValue,
+            resolverID,
+            seenRecordIDs: fragmentSeenRecordIDs,
+            readerSelector: fragmentReaderSelector,
+          };
+        });
+      },
+      getDataForResolverFragment,
     );
-    data[alias ?? name] = resolverResult;
-    return resolverResult;
+    if (seenRecord != null) {
+      this._seenRecords.add(seenRecord);
+    }
+    data[storageKey] = result;
+    return result;
   }
 
   _readFlightField(
@@ -538,6 +611,42 @@ class RelayReader {
     return value;
   }
 
+  _readActorChange(
+    field: ReaderActorChange,
+    record: Record,
+    data: SelectorData,
+  ): ?mixed {
+    const applicationName = field.alias ?? field.name;
+    const storageKey = getStorageKey(field, this._variables);
+    const externalRef = RelayModernRecord.getActorLinkedRecordID(
+      record,
+      storageKey,
+    );
+
+    if (externalRef == null) {
+      data[applicationName] = externalRef;
+      if (externalRef === undefined) {
+        this._isMissingData = true;
+      }
+      return data[applicationName];
+    }
+    const [actorIdentifier, dataID] = externalRef;
+
+    const fragmentRef = {};
+    this._createFragmentPointer(
+      field.fragmentSpread,
+      {
+        __id: dataID,
+      },
+      fragmentRef,
+    );
+    data[applicationName] = {
+      __fragmentRef: fragmentRef,
+      __viewer: actorIdentifier,
+    };
+    return data[applicationName];
+  }
+
   _readPluralLink(
     field: ReaderLinkedField,
     record: Record,
@@ -620,7 +729,7 @@ class RelayReader {
       {
         kind: 'FragmentSpread',
         name: moduleImport.fragmentName,
-        args: null,
+        args: moduleImport.args,
       },
       record,
       data,
@@ -651,12 +760,9 @@ class RelayReader {
       ? getArgumentValues(fragmentSpread.args, this._variables)
       : {};
     data[FRAGMENT_OWNER_KEY] = this._owner;
-
-    if (RelayFeatureFlags.ENABLE_PRECISE_TYPE_REFINEMENT) {
-      data[
-        IS_WITHIN_UNMATCHED_TYPE_REFINEMENT
-      ] = this._isWithinUnmatchedTypeRefinement;
-    }
+    data[
+      IS_WITHIN_UNMATCHED_TYPE_REFINEMENT
+    ] = this._isWithinUnmatchedTypeRefinement;
   }
 
   _createInlineDataOrResolverFragmentPointer(

package/store/RelayRecordSource.js.flow

@@ -12,17 +12,83 @@
 
 'use strict';
 
-const RelayRecordSourceMapImpl = require('./RelayRecordSourceMapImpl');
+const RelayRecordState = require('./RelayRecordState');
 
-import type {MutableRecordSource, RecordObjectMap} from './RelayStoreTypes';
+import type {DataID} from '../util/RelayRuntimeTypes';
+import type {RecordState} from './RelayRecordState';
+import type {
+  MutableRecordSource,
+  Record,
+  RecordObjectMap,
+} from './RelayStoreTypes';
 
-class RelayRecordSource {
-  constructor(records?: RecordObjectMap): MutableRecordSource {
-    return RelayRecordSource.create(records);
+const {EXISTENT, NONEXISTENT, UNKNOWN} = RelayRecordState;
+
+/**
+ * An implementation of the `MutableRecordSource` interface (defined in
+ * `RelayStoreTypes`) that holds all records in memory (JS Map).
+ */
+class RelayRecordSource implements MutableRecordSource {
+  _records: Map<DataID, ?Record>;
+
+  constructor(records?: RecordObjectMap) {
+    this._records = new Map();
+    if (records != null) {
+      Object.keys(records).forEach(key => {
+        this._records.set(key, records[key]);
+      });
+    }
   }
 
   static create(records?: RecordObjectMap): MutableRecordSource {
-    return new RelayRecordSourceMapImpl(records);
+    return new RelayRecordSource(records);
+  }
+
+  clear(): void {
+    this._records = new Map();
+  }
+
+  delete(dataID: DataID): void {
+    this._records.set(dataID, null);
+  }
+
+  get(dataID: DataID): ?Record {
+    return this._records.get(dataID);
+  }
+
+  getRecordIDs(): Array<DataID> {
+    return Array.from(this._records.keys());
+  }
+
+  getStatus(dataID: DataID): RecordState {
+    if (!this._records.has(dataID)) {
+      return UNKNOWN;
+    }
+    return this._records.get(dataID) == null ? NONEXISTENT : EXISTENT;
+  }
+
+  has(dataID: DataID): boolean {
+    return this._records.has(dataID);
+  }
+
+  remove(dataID: DataID): void {
+    this._records.delete(dataID);
+  }
+
+  set(dataID: DataID, record: Record): void {
+    this._records.set(dataID, record);
+  }
+
+  size(): number {
+    return this._records.size;
+  }
+
+  toJSON(): {[DataID]: ?Record, ...} {
+    const obj = {};
+    for (const [key, value] of this._records) {
+      obj[key] = value;
+    }
+    return obj;
   }
 }