relay-runtime 20.1.0 → 21.0.0

package/store/RelayResponseNormalizer.js.flow

@@ -15,7 +15,9 @@ import type {ActorIdentifier} from '../multi-actor-environment/ActorIdentifier';
 import type {PayloadData, PayloadError} from '../network/RelayNetworkTypes';
 import type {
   NormalizationActorChange,
+  NormalizationClientEdgeToClientObject,
   NormalizationDefer,
+  NormalizationInlineFragment,
   NormalizationLinkedField,
   NormalizationLiveResolverField,
   NormalizationModuleImport,
@@ -54,6 +56,7 @@ const RelayModernRecord = require('./RelayModernRecord');
 const {createNormalizationSelector} = require('./RelayModernSelector');
 const {
   ROOT_ID,
+  ROOT_TYPE,
   TYPENAME_KEY,
   getArgumentValues,
   getHandleStorageKey,
@@ -67,15 +70,16 @@ const invariant = require('invariant');
 const warning = require('warning');
 
 export type GetDataID = (
-  fieldValue: {+[string]: mixed},
+  fieldValue: {+[string]: unknown},
   typeName: string,
-) => mixed;
+) => unknown;
 
 export type NormalizationOptions = {
   +getDataID: GetDataID,
   +treatMissingFieldsAsNull: boolean,
+  +deferDeduplicatedFields: boolean,
   +log: ?LogFunction,
-  +path?: $ReadOnlyArray<string>,
+  +path?: ReadonlyArray<string>,
   +shouldProcessClientComponents?: ?boolean,
   +actorIdentifier?: ?ActorIdentifier,
 };
@@ -112,6 +116,7 @@ class RelayResponseNormalizer {
   _getDataId: GetDataID;
   _handleFieldPayloads: Array<HandleFieldPayload>;
   _treatMissingFieldsAsNull: boolean;
+  _deferDeduplicatedFields: boolean;
   _incrementalPlaceholders: Array<IncrementalDataPlaceholder>;
   _isClientExtension: boolean;
   _isUnmatchedAbstractType: boolean;
@@ -123,6 +128,17 @@ class RelayResponseNormalizer {
   _shouldProcessClientComponents: ?boolean;
   _errorTrie: RelayErrorTrie | null;
   _log: ?LogFunction;
+  _s2cExecutions: Map<
+    DataID,
+    {
+      selections: Array<
+        | NormalizationClientEdgeToClientObject
+        | NormalizationLiveResolverField
+        | NormalizationResolverField,
+      >,
+      typeName: string,
+    },
+  >;
 
   constructor(
     recordSource: MutableRecordSource,
@@ -134,6 +150,7 @@ class RelayResponseNormalizer {
     this._getDataId = options.getDataID;
     this._handleFieldPayloads = [];
     this._treatMissingFieldsAsNull = options.treatMissingFieldsAsNull;
+    this._deferDeduplicatedFields = options.deferDeduplicatedFields;
     this._incrementalPlaceholders = [];
     this._isClientExtension = false;
     this._isUnmatchedAbstractType = false;
@@ -144,6 +161,7 @@ class RelayResponseNormalizer {
     this._variables = variables;
     this._shouldProcessClientComponents = options.shouldProcessClientComponents;
     this._log = options.log;
+    this._s2cExecutions = new Map();
   }
 
   normalizeResponse(
@@ -164,10 +182,20 @@ class RelayResponseNormalizer {
     return {
       errors,
       fieldPayloads: this._handleFieldPayloads,
-      incrementalPlaceholders: this._incrementalPlaceholders,
       followupPayloads: this._followupPayloads,
-      source: this._recordSource,
+      incrementalPlaceholders: this._incrementalPlaceholders,
       isFinal: false,
+      s2cExecutions:
+        this._s2cExecutions.size > 0
+          ? Array.from(this._s2cExecutions.entries()).map(
+              ([recordID, entry]) => ({
+                recordID,
+                selections: entry.selections,
+                typeName: entry.typeName,
+              }),
+            )
+          : undefined,
+      source: this._recordSource,
     };
   }
 
@@ -192,7 +220,7 @@ class RelayResponseNormalizer {
     }
   }
 
-  _getVariableValue(name: string): mixed {
+  _getVariableValue(name: string): unknown {
     invariant(
       this._variables.hasOwnProperty(name),
       'RelayResponseNormalizer(): Undefined variable `%s`.',
@@ -202,7 +230,7 @@ class RelayResponseNormalizer {
   }
 
   _getRecordType(data: PayloadData): string {
-    const typeName = (data: any)[TYPENAME_KEY];
+    const typeName = (data as any)[TYPENAME_KEY];
     invariant(
       typeName != null,
       'RelayResponseNormalizer(): Expected a typename for record `%s`.',
@@ -243,35 +271,16 @@ class RelayResponseNormalizer {
           break;
         }
         case 'InlineFragment': {
-          const {abstractKey} = selection;
-          if (abstractKey == null) {
-            const typeName = RelayModernRecord.getType(record);
-            if (typeName === selection.type) {
-              this._traverseSelections(selection, record, data);
-            }
-          } else {
-            const implementsInterface = data.hasOwnProperty(abstractKey);
-            const typeName = RelayModernRecord.getType(record);
-            const typeID = generateTypeID(typeName);
-            let typeRecord = this._recordSource.get(typeID);
-            if (typeRecord == null) {
-              typeRecord = RelayModernRecord.create(typeID, TYPE_SCHEMA_TYPE);
-              this._recordSource.set(typeID, typeRecord);
-            }
-            RelayModernRecord.setValue(
-              typeRecord,
-              abstractKey,
-              implementsInterface,
-            );
-            if (implementsInterface) {
-              this._traverseSelections(selection, record, data);
-            }
-          }
+          this._normalizeInlineFragment(selection, record, data);
           break;
         }
         case 'TypeDiscriminator': {
           const {abstractKey} = selection;
-          const implementsInterface = data.hasOwnProperty(abstractKey);
+          // $FlowFixMe[method-unbinding] - data could be prototype less
+          const implementsInterface = Object.prototype.hasOwnProperty.call(
+            data,
+            abstractKey,
+          );
           const typeName = RelayModernRecord.getType(record);
           const typeID = generateTypeID(typeName);
           let typeRecord = this._recordSource.get(typeID);
@@ -298,10 +307,10 @@ class RelayResponseNormalizer {
             dataID: RelayModernRecord.getDataID(record),
             fieldKey,
             handle: selection.handle,
-            handleKey,
             handleArgs: selection.handleArgs
               ? getArgumentValues(selection.handleArgs, this._variables)
               : {},
+            handleKey,
           });
           break;
         case 'ModuleImport':
@@ -332,15 +341,21 @@ class RelayResponseNormalizer {
         case 'RelayLiveResolver':
           if (!this._useExecTimeResolvers) {
             this._normalizeResolver(selection, record, data);
+          } else if (selection.resolverInfo?.rootFragment != null) {
+            this._collectS2CExecution(selection, record);
           }
           break;
         case 'ClientEdgeToClientObject':
           if (!this._useExecTimeResolvers) {
             this._normalizeResolver(selection.backingField, record, data);
+          } else if (
+            selection.backingField.resolverInfo?.rootFragment != null
+          ) {
+            this._collectS2CExecution(selection, record);
           }
           break;
         default:
-          (selection: empty);
+          selection as empty;
           invariant(
             false,
             'RelayResponseNormalizer(): Unexpected ast kind `%s`.',
@@ -350,16 +365,75 @@ class RelayResponseNormalizer {
     }
   }
 
+  _normalizeInlineFragment(
+    selection: NormalizationInlineFragment,
+    record: Record,
+    data: PayloadData,
+  ) {
+    const {abstractKey} = selection;
+    if (abstractKey == null) {
+      const typeName = RelayModernRecord.getType(record);
+      if (
+        typeName === selection.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
+        typeName === ROOT_TYPE
+      ) {
+        this._traverseSelections(selection, record, data);
+      }
+    } else {
+      // $FlowFixMe[method-unbinding] - data could be prototype less
+      const implementsInterface = Object.prototype.hasOwnProperty.call(
+        data,
+        abstractKey,
+      );
+      const typeName = RelayModernRecord.getType(record);
+      const typeID = generateTypeID(typeName);
+      let typeRecord = this._recordSource.get(typeID);
+      if (typeRecord == null) {
+        typeRecord = RelayModernRecord.create(typeID, TYPE_SCHEMA_TYPE);
+        this._recordSource.set(typeID, typeRecord);
+      }
+      RelayModernRecord.setValue(typeRecord, abstractKey, implementsInterface);
+      if (implementsInterface) {
+        this._traverseSelections(selection, record, data);
+      }
+    }
+  }
+
   _normalizeResolver(
     resolver: NormalizationResolverField | NormalizationLiveResolverField,
     record: Record,
     data: PayloadData,
   ) {
     if (resolver.fragment != null) {
-      this._traverseSelections(resolver.fragment, record, data);
+      this._normalizeInlineFragment(resolver.fragment, record, data);
     }
   }
 
+  _collectS2CExecution(
+    selection:
+      | NormalizationClientEdgeToClientObject
+      | NormalizationLiveResolverField
+      | NormalizationResolverField,
+    record: Record,
+  ): void {
+    const recordID = RelayModernRecord.getDataID(record);
+    const typeName = RelayModernRecord.getType(record);
+    let entry = this._s2cExecutions.get(recordID);
+    if (entry == null) {
+      entry = {selections: [], typeName};
+      this._s2cExecutions.set(recordID, entry);
+    }
+    entry.selections.push(selection);
+  }
+
   _normalizeDefer(
     defer: NormalizationDefer,
     record: Record,
@@ -382,8 +456,9 @@ class RelayResponseNormalizer {
       // Otherwise data *for this selection* should not be present: enqueue
       // metadata to process the subsequent response chunk.
       this._incrementalPlaceholders.push({
-        kind: 'defer',
+        actorIdentifier: this._actorIdentifier,
         data,
+        kind: 'defer',
         label: defer.label,
         path: [...this._path],
         selector: createNormalizationSelector(
@@ -392,7 +467,6 @@ class RelayResponseNormalizer {
           this._variables,
         ),
         typeName: RelayModernRecord.getType(record),
-        actorIdentifier: this._actorIdentifier,
       });
     }
   }
@@ -419,13 +493,13 @@ class RelayResponseNormalizer {
       // If streaming is enabled, *also* emit metadata to process any
       // response chunks that may be delivered.
       this._incrementalPlaceholders.push({
+        actorIdentifier: this._actorIdentifier,
         kind: 'stream',
         label: stream.label,
-        path: [...this._path],
-        parentID: RelayModernRecord.getDataID(record),
         node: stream,
+        parentID: RelayModernRecord.getDataID(record),
+        path: [...this._path],
         variables: this._variables,
-        actorIdentifier: this._actorIdentifier,
       });
     }
   }
@@ -458,15 +532,15 @@ class RelayResponseNormalizer {
     );
     if (operationReference != null) {
       this._followupPayloads.push({
-        kind: 'ModuleImportPayload',
+        actorIdentifier: this._actorIdentifier,
         args: moduleImport.args,
         data,
         dataID: RelayModernRecord.getDataID(record),
+        kind: 'ModuleImportPayload',
         operationReference,
         path: [...this._path],
         typeName,
         variables: this._variables,
-        actorIdentifier: this._actorIdentifier,
       });
     }
   }
@@ -500,7 +574,9 @@ class RelayResponseNormalizer {
         // client is assumed to be correctly configured with
         // treatMissingFieldsAsNull=true.
         const isOptionalField =
-          this._isClientExtension || this._isUnmatchedAbstractType;
+          this._isClientExtension ||
+          this._isUnmatchedAbstractType ||
+          this._deferDeduplicatedFields;
 
         if (isOptionalField) {
           // Field not expected to exist regardless of whether the server is pruning null
@@ -575,7 +651,7 @@ class RelayResponseNormalizer {
       this._errorTrie = oldErrorTrie;
       this._path.pop();
     } else {
-      (selection: empty);
+      selection as empty;
       invariant(
         false,
         'RelayResponseNormalizer(): Unexpected ast kind `%s` during normalization.',
@@ -640,11 +716,11 @@ class RelayResponseNormalizer {
       return;
     }
 
-    // $FlowFixMe[incompatible-call]
+    // $FlowFixMe[incompatible-type]
     const typeName = field.concreteType ?? this._getRecordType(fieldValue);
     const nextID =
       this._getDataId(
-        // $FlowFixMe[incompatible-call]
+        // $FlowFixMe[incompatible-type]
         fieldValue,
         typeName,
       ) ||
@@ -665,14 +741,14 @@ class RelayResponseNormalizer {
     );
 
     this._followupPayloads.push({
-      kind: 'ActorPayload',
-      data: (fieldValue: $FlowFixMe),
+      actorIdentifier,
+      data: fieldValue as $FlowFixMe,
       dataID: nextID,
+      kind: 'ActorPayload',
+      node: field,
       path: [...this._path, responseKey],
       typeName,
       variables: this._variables,
-      node: field,
-      actorIdentifier,
     });
   }
 
@@ -680,7 +756,7 @@ class RelayResponseNormalizer {
     field: NormalizationLinkedField,
     record: Record,
     storageKey: string,
-    fieldValue: mixed,
+    fieldValue: unknown,
   ): void {
     invariant(
       typeof fieldValue === 'object' && fieldValue,
@@ -725,7 +801,7 @@ class RelayResponseNormalizer {
     field: NormalizationLinkedField,
     record: Record,
     storageKey: string,
-    fieldValue: mixed,
+    fieldValue: unknown,
   ): void {
     invariant(
       Array.isArray(fieldValue),
@@ -815,8 +891,8 @@ class RelayResponseNormalizer {
       if (!expected) {
         const logEvent: IdCollisionTypenameLogEvent = {
           name: 'idCollision.typename',
-          previous_typename: RelayModernRecord.getType(record),
           new_typename: typeName,
+          previous_typename: RelayModernRecord.getType(record),
         };
         if (this._log != null) {
           this._log(logEvent);
@@ -850,7 +926,7 @@ class RelayResponseNormalizer {
   _validateConflictingFieldsWithIdenticalId(
     record: Record,
     storageKey: string,
-    fieldValue: mixed,
+    fieldValue: unknown,
   ): void {
     // NOTE: Only emit a warning in DEV
     if (__DEV__) {

package/store/RelayStoreSubscriptions.js.flow

@@ -43,6 +43,9 @@ class RelayStoreSubscriptions implements StoreSubscriptions {
   __log: ?LogFunction;
   _resolverCache: ResolverCache;
   _resolverContext: ?ResolverContext;
+  // Stores `subscriptions` with stale snapshots, used for reducing the traversal
+  // that has to happen on `notify`
+  _staleSubscriptions: Set<Subscription>;
 
   constructor(
     log?: ?LogFunction,
@@ -50,6 +53,7 @@ class RelayStoreSubscriptions implements StoreSubscriptions {
     resolverContext?: ResolverContext,
   ) {
     this._subscriptions = new Set();
+    this._staleSubscriptions = new Set();
     this.__log = log;
     this._resolverCache = resolverCache;
     this._resolverContext = resolverContext;
@@ -59,9 +63,17 @@ class RelayStoreSubscriptions implements StoreSubscriptions {
     snapshot: Snapshot,
     callback: (snapshot: Snapshot) => void,
   ): Disposable {
-    const subscription = {backup: null, callback, snapshot, stale: false};
+    const subscription: Subscription = {
+      backup: null,
+      callback,
+      snapshot,
+      stale: false,
+    };
     const dispose = () => {
       this._subscriptions.delete(subscription);
+      if (RelayFeatureFlags.OPTIMIZE_NOTIFY && subscription.stale) {
+        this._staleSubscriptions.delete(subscription);
+      }
     };
     this._subscriptions.add(subscription);
     return {dispose};
@@ -89,11 +101,12 @@ class RelayStoreSubscriptions implements StoreSubscriptions {
       const backup = RelayReader.read(
         source,
         snapshot.selector,
+        this.__log,
         this._resolverCache,
         this._resolverContext,
       );
       const nextData = recycleNodesInto(snapshot.data, backup.data);
-      (backup: $FlowFixMe).data = nextData; // backup owns the snapshot and can safely mutate
+      (backup as $FlowFixMe).data = nextData; // backup owns the snapshot and can safely mutate
       subscription.backup = backup;
     });
   }
@@ -107,20 +120,26 @@ class RelayStoreSubscriptions implements StoreSubscriptions {
           // This subscription's data changed in the optimistic state. We will
           // need to re-read.
           subscription.stale = true;
+          if (RelayFeatureFlags.OPTIMIZE_NOTIFY) {
+            this._staleSubscriptions.add(subscription);
+          }
         }
         subscription.snapshot = {
           data: subscription.snapshot.data,
+          fieldErrors: backup.fieldErrors,
           isMissingData: backup.isMissingData,
           missingClientEdges: backup.missingClientEdges,
           missingLiveResolverFields: backup.missingLiveResolverFields,
           seenRecords: backup.seenRecords,
           selector: backup.selector,
-          fieldErrors: backup.fieldErrors,
         };
       } else {
         // This subscription was created during the optimisitic state. We should
         // re-read.
         subscription.stale = true;
+        if (RelayFeatureFlags.OPTIMIZE_NOTIFY) {
+          this._staleSubscriptions.add(subscription);
+        }
       }
     });
   }
@@ -146,6 +165,27 @@ class RelayStoreSubscriptions implements StoreSubscriptions {
     });
   }
 
+  updateStaleSubscriptions(
+    source: RecordSource,
+    updatedRecordIDs: DataIDSet,
+    updatedOwners: Array<RequestDescriptor>,
+    sourceOperation?: OperationDescriptor,
+  ) {
+    const hasUpdatedRecords = updatedRecordIDs.size !== 0;
+    this._staleSubscriptions.forEach(subscription => {
+      const owner = this._updateSubscription(
+        source,
+        subscription,
+        updatedRecordIDs,
+        hasUpdatedRecords,
+        sourceOperation,
+      );
+      if (owner != null) {
+        updatedOwners.push(owner);
+      }
+    });
+  }
+
   /**
    * Notifies the callback for the subscription if the data for the associated
    * snapshot has changed.
@@ -173,32 +213,36 @@ class RelayStoreSubscriptions implements StoreSubscriptions {
         ? RelayReader.read(
             source,
             snapshot.selector,
+            this.__log,
             this._resolverCache,
             this._resolverContext,
           )
         : backup;
     const nextData = recycleNodesInto(snapshot.data, nextSnapshot.data);
-    nextSnapshot = ({
+    nextSnapshot = {
       data: nextData,
+      fieldErrors: nextSnapshot.fieldErrors,
       isMissingData: nextSnapshot.isMissingData,
       missingClientEdges: nextSnapshot.missingClientEdges,
       missingLiveResolverFields: nextSnapshot.missingLiveResolverFields,
       seenRecords: nextSnapshot.seenRecords,
       selector: nextSnapshot.selector,
-      fieldErrors: nextSnapshot.fieldErrors,
-    }: Snapshot);
+    } as Snapshot;
     if (__DEV__) {
       deepFreeze(nextSnapshot);
     }
     subscription.snapshot = nextSnapshot;
     subscription.stale = false;
+    if (RelayFeatureFlags.OPTIMIZE_NOTIFY && stale) {
+      this._staleSubscriptions.delete(subscription);
+    }
     if (nextSnapshot.data !== snapshot.data) {
       if (this.__log && RelayFeatureFlags.ENABLE_NOTIFY_SUBSCRIPTION) {
         this.__log({
           name: 'store.notify.subscription',
-          sourceOperation,
-          snapshot,
           nextSnapshot,
+          snapshot,
+          sourceOperation,
         });
       }
       callback(nextSnapshot);