relay-runtime 11.0.2 → 13.0.0-rc.2

package/store/RelayResponseNormalizer.js.flow

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) Facebook, Inc. and its affiliates.
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
  *
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
@@ -12,17 +12,41 @@
 
 'use strict';
 
-const RelayFeatureFlags = require('../util/RelayFeatureFlags');
-const RelayModernRecord = require('./RelayModernRecord');
-
-const areEqual = require('areEqual');
-const invariant = require('invariant');
-const warning = require('warning');
+import type {ActorIdentifier} from '../multi-actor-environment/ActorIdentifier';
+import type {PayloadData} from '../network/RelayNetworkTypes';
+import type {
+  NormalizationActorChange,
+  NormalizationDefer,
+  NormalizationFlightField,
+  NormalizationLinkedField,
+  NormalizationModuleImport,
+  NormalizationNode,
+  NormalizationScalarField,
+  NormalizationStream,
+} from '../util/NormalizationNode';
+import type {DataID, Variables} from '../util/RelayRuntimeTypes';
+import type {
+  FollowupPayload,
+  HandleFieldPayload,
+  IncrementalDataPlaceholder,
+  MutableRecordSource,
+  NormalizationSelector,
+  ReactFlightPayloadDeserializer,
+  ReactFlightReachableExecutableDefinitions,
+  ReactFlightServerErrorHandler,
+  Record,
+  RelayResponsePayload,
+} from './RelayStoreTypes';
 
 const {
-  CONDITION,
+  ACTOR_IDENTIFIER_FIELD_NAME,
+  getActorIdentifierFromPayload,
+} = require('../multi-actor-environment/ActorUtils');
+const {
+  ACTOR_CHANGE,
   CLIENT_COMPONENT,
   CLIENT_EXTENSION,
+  CONDITION,
   DEFER,
   FLIGHT_FIELD,
   FRAGMENT_SPREAD,
@@ -35,49 +59,31 @@ const {
   STREAM,
   TYPE_DISCRIMINATOR,
 } = require('../util/RelayConcreteNode');
+const RelayFeatureFlags = require('../util/RelayFeatureFlags');
 const {generateClientID, isClientID} = require('./ClientID');
+const {getLocalVariables} = require('./RelayConcreteVariables');
+const RelayModernRecord = require('./RelayModernRecord');
 const {createNormalizationSelector} = require('./RelayModernSelector');
 const {
-  refineToReactFlightPayloadData,
   REACT_FLIGHT_EXECUTABLE_DEFINITIONS_STORAGE_KEY,
   REACT_FLIGHT_TREE_STORAGE_KEY,
   REACT_FLIGHT_TYPE_NAME,
+  refineToReactFlightPayloadData,
 } = require('./RelayStoreReactFlightUtils');
 const {
+  ROOT_ID,
+  ROOT_TYPE,
+  TYPENAME_KEY,
   getArgumentValues,
   getHandleStorageKey,
   getModuleComponentKey,
   getModuleOperationKey,
   getStorageKey,
-  TYPENAME_KEY,
-  ROOT_ID,
-  ROOT_TYPE,
 } = require('./RelayStoreUtils');
-const {generateTypeID, TYPE_SCHEMA_TYPE} = require('./TypeID');
-
-import type {PayloadData} from '../network/RelayNetworkTypes';
-import type {
-  NormalizationDefer,
-  NormalizationFlightField,
-  NormalizationLinkedField,
-  NormalizationModuleImport,
-  NormalizationNode,
-  NormalizationScalarField,
-  NormalizationStream,
-} from '../util/NormalizationNode';
-import type {DataID, Variables} from '../util/RelayRuntimeTypes';
-import type {
-  HandleFieldPayload,
-  IncrementalDataPlaceholder,
-  ModuleImportPayload,
-  MutableRecordSource,
-  NormalizationSelector,
-  ReactFlightReachableExecutableDefinitions,
-  ReactFlightPayloadDeserializer,
-  ReactFlightServerErrorHandler,
-  Record,
-  RelayResponsePayload,
-} from './RelayStoreTypes';
+const {TYPE_SCHEMA_TYPE, generateTypeID} = require('./TypeID');
+const areEqual = require('areEqual');
+const invariant = require('invariant');
+const warning = require('warning');
 
 export type GetDataID = (
   fieldValue: interface {[string]: mixed},
@@ -91,6 +97,7 @@ export type NormalizationOptions = {|
   +reactFlightPayloadDeserializer?: ?ReactFlightPayloadDeserializer,
   +reactFlightServerErrorHandler?: ?ReactFlightServerErrorHandler,
   +shouldProcessClientComponents?: ?boolean,
+  +actorIdentifier?: ?ActorIdentifier,
 |};
 
 /**
@@ -118,13 +125,14 @@ function normalize(
  * Helper for handling payloads.
  */
 class RelayResponseNormalizer {
+  _actorIdentifier: ?ActorIdentifier;
   _getDataId: GetDataID;
   _handleFieldPayloads: Array<HandleFieldPayload>;
   _treatMissingFieldsAsNull: boolean;
   _incrementalPlaceholders: Array<IncrementalDataPlaceholder>;
   _isClientExtension: boolean;
   _isUnmatchedAbstractType: boolean;
-  _moduleImportPayloads: Array<ModuleImportPayload>;
+  _followupPayloads: Array<FollowupPayload>;
   _path: Array<string>;
   _recordSource: MutableRecordSource;
   _variables: Variables;
@@ -137,13 +145,14 @@ class RelayResponseNormalizer {
     variables: Variables,
     options: NormalizationOptions,
   ) {
+    this._actorIdentifier = options.actorIdentifier;
     this._getDataId = options.getDataID;
     this._handleFieldPayloads = [];
     this._treatMissingFieldsAsNull = options.treatMissingFieldsAsNull;
     this._incrementalPlaceholders = [];
     this._isClientExtension = false;
     this._isUnmatchedAbstractType = false;
-    this._moduleImportPayloads = [];
+    this._followupPayloads = [];
     this._path = options.path ? [...options.path] : [];
     this._recordSource = recordSource;
     this._variables = variables;
@@ -169,7 +178,7 @@ class RelayResponseNormalizer {
       errors: null,
       fieldPayloads: this._handleFieldPayloads,
       incrementalPlaceholders: this._incrementalPlaceholders,
-      moduleImportPayloads: this._moduleImportPayloads,
+      followupPayloads: this._followupPayloads,
       source: this._recordSource,
       isFinal: false,
     };
@@ -181,7 +190,6 @@ class RelayResponseNormalizer {
       'RelayResponseNormalizer(): Undefined variable `%s`.',
       name,
     );
-    // $FlowFixMe[cannot-write]
     return this._variables[name];
   }
 
@@ -208,13 +216,22 @@ class RelayResponseNormalizer {
           this._normalizeField(node, selection, record, data);
           break;
         case CONDITION:
-          const conditionValue = this._getVariableValue(selection.condition);
+          const conditionValue = Boolean(
+            this._getVariableValue(selection.condition),
+          );
           if (conditionValue === selection.passingValue) {
             this._traverseSelections(selection, record, data);
           }
           break;
         case FRAGMENT_SPREAD: {
+          const prevVariables = this._variables;
+          this._variables = getLocalVariables(
+            this._variables,
+            selection.fragment.argumentDefinitions,
+            selection.args,
+          );
           this._traverseSelections(selection.fragment, record, data);
+          this._variables = prevVariables;
           break;
         }
         case INLINE_FRAGMENT: {
@@ -224,7 +241,7 @@ class RelayResponseNormalizer {
             if (typeName === selection.type) {
               this._traverseSelections(selection, record, data);
             }
-          } else if (RelayFeatureFlags.ENABLE_PRECISE_TYPE_REFINEMENT) {
+          } else {
             const implementsInterface = data.hasOwnProperty(abstractKey);
             const typeName = RelayModernRecord.getType(record);
             const typeID = generateTypeID(typeName);
@@ -241,36 +258,24 @@ class RelayResponseNormalizer {
             if (implementsInterface) {
               this._traverseSelections(selection, record, data);
             }
-          } else {
-            // legacy behavior for abstract refinements: always normalize even
-            // if the type doesn't conform, but track if the type matches or not
-            // for determining whether response fields are expected to be present
-            const implementsInterface = data.hasOwnProperty(abstractKey);
-            const parentIsUnmatchedAbstractType = this._isUnmatchedAbstractType;
-            this._isUnmatchedAbstractType =
-              this._isUnmatchedAbstractType || !implementsInterface;
-            this._traverseSelections(selection, record, data);
-            this._isUnmatchedAbstractType = parentIsUnmatchedAbstractType;
           }
           break;
         }
         case TYPE_DISCRIMINATOR: {
-          if (RelayFeatureFlags.ENABLE_PRECISE_TYPE_REFINEMENT) {
-            const {abstractKey} = selection;
-            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,
-            );
+          const {abstractKey} = selection;
+          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,
+          );
           break;
         }
         case LINKED_HANDLE:
@@ -281,13 +286,17 @@ class RelayResponseNormalizer {
           const fieldKey = getStorageKey(selection, this._variables);
           const handleKey = getHandleStorageKey(selection, this._variables);
           this._handleFieldPayloads.push({
+            /* $FlowFixMe[class-object-subtyping] added when improving typing
+             * for this parameters */
             args,
             dataID: RelayModernRecord.getDataID(record),
             fieldKey,
             handle: selection.handle,
             handleKey,
             handleArgs: selection.handleArgs
-              ? getArgumentValues(selection.handleArgs, this._variables)
+              ? /* $FlowFixMe[class-object-subtyping] added when improving typing
+                 * for this parameters */
+                getArgumentValues(selection.handleArgs, this._variables)
               : {},
           });
           break;
@@ -319,6 +328,9 @@ class RelayResponseNormalizer {
             throw new Error('Flight fields are not yet supported.');
           }
           break;
+        case ACTOR_CHANGE:
+          this._normalizeActorChange(node, selection, record, data);
+          break;
         default:
           (selection: empty);
           invariant(
@@ -362,6 +374,7 @@ class RelayResponseNormalizer {
           this._variables,
         ),
         typeName: RelayModernRecord.getType(record),
+        actorIdentifier: this._actorIdentifier,
       });
     }
   }
@@ -394,6 +407,7 @@ class RelayResponseNormalizer {
         parentID: RelayModernRecord.getDataID(record),
         node: stream,
         variables: this._variables,
+        actorIdentifier: this._actorIdentifier,
       });
     }
   }
@@ -424,13 +438,16 @@ class RelayResponseNormalizer {
       operationReference ?? null,
     );
     if (operationReference != null) {
-      this._moduleImportPayloads.push({
+      this._followupPayloads.push({
+        kind: 'ModuleImportPayload',
+        args: moduleImport.args,
         data,
         dataID: RelayModernRecord.getDataID(record),
         operationReference,
         path: [...this._path],
         typeName,
         variables: this._variables,
+        actorIdentifier: this._actorIdentifier,
       });
     }
   }
@@ -488,7 +505,11 @@ class RelayResponseNormalizer {
           this._validateConflictingFieldsWithIdenticalId(
             record,
             storageKey,
-            fieldValue,
+            // When using `treatMissingFieldsAsNull` the conflicting validation raises a false positive
+            // because the value is set using `null` but validated using `fieldValue` which at this point
+            // will be `undefined`.
+            // Setting this to `null` matches the value that we actually set to the `fieldValue`.
+            null,
           );
         }
       }
@@ -523,6 +544,99 @@ class RelayResponseNormalizer {
     }
   }
 
+  _normalizeActorChange(
+    parent: NormalizationNode,
+    selection: NormalizationActorChange,
+    record: Record,
+    data: PayloadData,
+  ) {
+    const field = selection.linkedField;
+    invariant(
+      typeof data === 'object' && data,
+      '_normalizeActorChange(): Expected data for field `%s` to be an object.',
+      field.name,
+    );
+    const responseKey = field.alias || field.name;
+    const storageKey = getStorageKey(field, this._variables);
+    const fieldValue = data[responseKey];
+
+    if (fieldValue == null) {
+      if (fieldValue === undefined) {
+        const isOptionalField =
+          this._isClientExtension || this._isUnmatchedAbstractType;
+
+        if (isOptionalField) {
+          return;
+        } else if (!this._treatMissingFieldsAsNull) {
+          if (__DEV__) {
+            warning(
+              false,
+              'RelayResponseNormalizer: Payload did not contain a value ' +
+                'for field `%s: %s`. Check that you are parsing with the same ' +
+                'query that was used to fetch the payload.',
+              responseKey,
+              storageKey,
+            );
+          }
+          return;
+        }
+      }
+      RelayModernRecord.setValue(record, storageKey, null);
+      return;
+    }
+
+    const actorIdentifier = getActorIdentifierFromPayload(fieldValue);
+    if (actorIdentifier == null) {
+      if (__DEV__) {
+        warning(
+          false,
+          'RelayResponseNormalizer: Payload did not contain a value ' +
+            'for field `%s`. Check that you are parsing with the same ' +
+            'query that was used to fetch the payload. Payload is `%s`.',
+          ACTOR_IDENTIFIER_FIELD_NAME,
+          JSON.stringify(fieldValue, null, 2),
+        );
+      }
+      RelayModernRecord.setValue(record, storageKey, null);
+      return;
+    }
+
+    // $FlowFixMe[incompatible-call]
+    const typeName = field.concreteType ?? this._getRecordType(fieldValue);
+    const nextID =
+      this._getDataId(
+        // $FlowFixMe[incompatible-call]
+        fieldValue,
+        typeName,
+      ) ||
+      RelayModernRecord.getLinkedRecordID(record, storageKey) ||
+      generateClientID(RelayModernRecord.getDataID(record), storageKey);
+
+    invariant(
+      typeof nextID === 'string',
+      'RelayResponseNormalizer: Expected id on field `%s` to be a string.',
+      storageKey,
+    );
+
+    RelayModernRecord.setActorLinkedRecordID(
+      record,
+      storageKey,
+      actorIdentifier,
+      nextID,
+    );
+
+    this._followupPayloads.push({
+      kind: 'ActorPayload',
+      data: (fieldValue: $FlowFixMe),
+      dataID: nextID,
+      path: [...this._path, responseKey],
+      typeName,
+      variables: this._variables,
+      node: field,
+      actorIdentifier,
+    });
+  }
+
   _normalizeFlightField(
     parent: NormalizationNode,
     selection: NormalizationFlightField,
@@ -546,20 +660,17 @@ class RelayResponseNormalizer {
           // Field not expected to exist regardless of whether the server is pruning null
           // fields or not.
           return;
-        } else if (!this._treatMissingFieldsAsNull) {
+        } else {
           // Not optional and the server is not pruning null fields: field is expected
           // to be present
-          if (__DEV__) {
-            warning(
-              false,
-              'RelayResponseNormalizer: Payload did not contain a value ' +
-                'for field `%s: %s`. Check that you are parsing with the same ' +
-                'query that was used to fetch the payload.',
-              responseKey,
-              storageKey,
-            );
-          }
-          return;
+          invariant(
+            this._treatMissingFieldsAsNull,
+            'RelayResponseNormalizer: Payload did not contain a value for ' +
+              'field `%s: %s`. Check that you are parsing with the same ' +
+              'query that was used to fetch the payload.',
+            responseKey,
+            storageKey,
+          );
         }
       }
       RelayModernRecord.setValue(record, storageKey, null);
@@ -655,16 +766,20 @@ class RelayResponseNormalizer {
       reactFlightClientResponse,
     );
 
-    const reachableExecutableDefinitions: Array<ReactFlightReachableExecutableDefinitions> = [];
+    const reachableExecutableDefinitions: Array<ReactFlightReachableExecutableDefinitions> =
+      [];
     for (const query of reactFlightPayload.queries) {
       if (query.response.data != null) {
-        this._moduleImportPayloads.push({
+        this._followupPayloads.push({
+          kind: 'ModuleImportPayload',
+          args: null,
           data: query.response.data,
           dataID: ROOT_ID,
           operationReference: query.module,
           path: [],
           typeName: ROOT_TYPE,
           variables: query.variables,
+          actorIdentifier: this._actorIdentifier,
         });
       }
       reachableExecutableDefinitions.push({
@@ -674,13 +789,16 @@ class RelayResponseNormalizer {
     }
     for (const fragment of reactFlightPayload.fragments) {
       if (fragment.response.data != null) {
-        this._moduleImportPayloads.push({
+        this._followupPayloads.push({
+          kind: 'ModuleImportPayload',
+          args: null,
           data: fragment.response.data,
           dataID: fragment.__id,
           operationReference: fragment.module,
           path: [],
           typeName: fragment.__typename,
           variables: fragment.variables,
+          actorIdentifier: this._actorIdentifier,
         });
       }
       reachableExecutableDefinitions.push({

package/store/RelayStoreReactFlightUtils.js.flow

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) Facebook, Inc. and its affiliates.
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
  *
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
@@ -12,13 +12,12 @@
 
 'use strict';
 
-const invariant = require('invariant');
-
-const {getType} = require('./RelayModernRecord');
-
 import type {ReactFlightPayloadData} from '../network/RelayNetworkTypes';
 import type {ReactFlightClientResponse, Record} from './RelayStoreTypes';
 
+const {getType} = require('./RelayModernRecord');
+const invariant = require('invariant');
+
 // Reachable (client) executable definitions encountered while server component
 // rendering
 const REACT_FLIGHT_EXECUTABLE_DEFINITIONS_STORAGE_KEY = 'executableDefinitions';
@@ -51,13 +50,7 @@ function getReactFlightClientResponse(
       'got %s.',
     record,
   );
-  const response: ?ReactFlightClientResponse = (record[
-    REACT_FLIGHT_TREE_STORAGE_KEY
-  ]: $FlowFixMe);
-  if (response != null) {
-    return response;
-  }
-  return null;
+  return (record[REACT_FLIGHT_TREE_STORAGE_KEY]: $FlowFixMe);
 }
 
 module.exports = {

package/store/RelayStoreSubscriptions.js.flow

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) Facebook, Inc. and its affiliates.
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
  *
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
@@ -12,23 +12,23 @@
 
 'use strict';
 
-const RelayFeatureFlags = require('../util/RelayFeatureFlags');
-const RelayReader = require('./RelayReader');
-
-const deepFreeze = require('../util/deepFreeze');
-const hasOverlappingIDs = require('./hasOverlappingIDs');
-const recycleNodesInto = require('../util/recycleNodesInto');
-
 import type {Disposable} from '../util/RelayRuntimeTypes';
 import type {
+  DataIDSet,
   LogFunction,
   OperationDescriptor,
-  DataIDSet,
   RecordSource,
   RequestDescriptor,
   Snapshot,
   StoreSubscriptions,
 } from './RelayStoreTypes';
+import type {ResolverCache} from './ResolverCache';
+
+const deepFreeze = require('../util/deepFreeze');
+const recycleNodesInto = require('../util/recycleNodesInto');
+const RelayFeatureFlags = require('../util/RelayFeatureFlags');
+const hasOverlappingIDs = require('./hasOverlappingIDs');
+const RelayReader = require('./RelayReader');
 
 type Subscription = {|
   callback: (snapshot: Snapshot) => void,
@@ -40,10 +40,12 @@ type Subscription = {|
 class RelayStoreSubscriptions implements StoreSubscriptions {
   _subscriptions: Set<Subscription>;
   __log: ?LogFunction;
+  _resolverCache: ResolverCache;
 
-  constructor(log?: ?LogFunction) {
+  constructor(log?: ?LogFunction, resolverCache: ResolverCache) {
     this._subscriptions = new Set();
     this.__log = log;
+    this._resolverCache = resolverCache;
   }
 
   subscribe(
@@ -77,7 +79,11 @@ class RelayStoreSubscriptions implements StoreSubscriptions {
         return;
       }
       const snapshot = subscription.snapshot;
-      const backup = RelayReader.read(source, snapshot.selector);
+      const backup = RelayReader.read(
+        source,
+        snapshot.selector,
+        this._resolverCache,
+      );
       const nextData = recycleNodesInto(snapshot.data, backup.data);
       (backup: $FlowFixMe).data = nextData; // backup owns the snapshot and can safely mutate
       subscription.backup = backup;
@@ -95,6 +101,7 @@ class RelayStoreSubscriptions implements StoreSubscriptions {
         subscription.snapshot = {
           data: subscription.snapshot.data,
           isMissingData: backup.isMissingData,
+          missingClientEdges: backup.missingClientEdges,
           seenRecords: backup.seenRecords,
           selector: backup.selector,
           missingRequiredFields: backup.missingRequiredFields,
@@ -150,12 +157,13 @@ class RelayStoreSubscriptions implements StoreSubscriptions {
     }
     let nextSnapshot: Snapshot =
       hasOverlappingUpdates || !backup
-        ? RelayReader.read(source, snapshot.selector)
+        ? RelayReader.read(source, snapshot.selector, this._resolverCache)
         : backup;
     const nextData = recycleNodesInto(snapshot.data, nextSnapshot.data);
     nextSnapshot = ({
       data: nextData,
       isMissingData: nextSnapshot.isMissingData,
+      missingClientEdges: nextSnapshot.missingClientEdges,
       seenRecords: nextSnapshot.seenRecords,
       selector: nextSnapshot.selector,
       missingRequiredFields: nextSnapshot.missingRequiredFields,