relay-runtime 11.0.2 → 12.0.0

package/store/RelayReferenceMarker.js.flow

@@ -22,6 +22,7 @@ const cloneRelayHandleSourceField = require('./cloneRelayHandleSourceField');
 const getOperation = require('../util/getOperation');
 const invariant = require('invariant');
 
+const {getLocalVariables} = require('./RelayConcreteVariables');
 const {generateTypeID} = require('./TypeID');
 
 import type {
@@ -42,6 +43,7 @@ import type {
 } from './RelayStoreTypes';
 
 const {
+  ACTOR_CHANGE,
   CONDITION,
   CLIENT_COMPONENT,
   CLIENT_EXTENSION,
@@ -136,6 +138,10 @@ class RelayReferenceMarker {
     selections.forEach(selection => {
       /* eslint-disable no-fallthrough */
       switch (selection.kind) {
+        case ACTOR_CHANGE:
+          // TODO: T89695151 Support multi-actor record sources in RelayReferenceMarker.js
+          this._traverseLink(selection.linkedField, record);
+          break;
         case LINKED_FIELD:
           if (selection.plural) {
             this._traversePluralLink(selection, record);
@@ -144,7 +150,9 @@ class RelayReferenceMarker {
           }
           break;
         case CONDITION:
-          const conditionValue = this._getVariableValue(selection.condition);
+          const conditionValue = Boolean(
+            this._getVariableValue(selection.condition),
+          );
           if (conditionValue === selection.passingValue) {
             this._traverseSelections(selection.selections, record);
           }
@@ -155,18 +163,22 @@ class RelayReferenceMarker {
             if (typeName != null && typeName === selection.type) {
               this._traverseSelections(selection.selections, record);
             }
-          } else if (RelayFeatureFlags.ENABLE_PRECISE_TYPE_REFINEMENT) {
+          } else {
             const typeName = RelayModernRecord.getType(record);
             const typeID = generateTypeID(typeName);
             this._references.add(typeID);
             this._traverseSelections(selection.selections, record);
-          } else {
-            this._traverseSelections(selection.selections, record);
           }
           break;
-        // $FlowFixMe[incompatible-type]
         case FRAGMENT_SPREAD:
+          const prevVariables = this._variables;
+          this._variables = getLocalVariables(
+            this._variables,
+            selection.fragment.argumentDefinitions,
+            selection.args,
+          );
           this._traverseSelections(selection.fragment.selections, record);
+          this._variables = prevVariables;
           break;
         case LINKED_HANDLE:
           // The selections for a "handle" field are the same as those of the
@@ -197,11 +209,9 @@ class RelayReferenceMarker {
         case SCALAR_HANDLE:
           break;
         case TYPE_DISCRIMINATOR: {
-          if (RelayFeatureFlags.ENABLE_PRECISE_TYPE_REFINEMENT) {
-            const typeName = RelayModernRecord.getType(record);
-            const typeID = generateTypeID(typeName);
-            this._references.add(typeID);
-          }
+          const typeName = RelayModernRecord.getType(record);
+          const typeID = generateTypeID(typeName);
+          this._references.add(typeID);
           break;
         }
         case MODULE_IMPORT:
@@ -253,8 +263,15 @@ class RelayReferenceMarker {
     }
     const normalizationRootNode = operationLoader.get(operationReference);
     if (normalizationRootNode != null) {
-      const selections = getOperation(normalizationRootNode).selections;
-      this._traverseSelections(selections, record);
+      const operation = getOperation(normalizationRootNode);
+      const prevVariables = this._variables;
+      this._variables = getLocalVariables(
+        this._variables,
+        operation.argumentDefinitions,
+        moduleImport.args,
+      );
+      this._traverseSelections(operation.selections, record);
+      this._variables = prevVariables;
     }
     // Otherwise, if the operation is not available, we assume that the data
     // cannot have been processed yet and therefore isn't in the store to

package/store/RelayResponseNormalizer.js.flow

@@ -20,6 +20,11 @@ const invariant = require('invariant');
 const warning = require('warning');
 
 const {
+  ACTOR_IDENTIFIER_FIELD_NAME,
+  getActorIdentifierFromPayload,
+} = require('../multi-actor-environment/ActorUtils');
+const {
+  ACTOR_CHANGE,
   CONDITION,
   CLIENT_COMPONENT,
   CLIENT_EXTENSION,
@@ -36,6 +41,7 @@ const {
   TYPE_DISCRIMINATOR,
 } = require('../util/RelayConcreteNode');
 const {generateClientID, isClientID} = require('./ClientID');
+const {getLocalVariables} = require('./RelayConcreteVariables');
 const {createNormalizationSelector} = require('./RelayModernSelector');
 const {
   refineToReactFlightPayloadData,
@@ -55,8 +61,10 @@ const {
 } = require('./RelayStoreUtils');
 const {generateTypeID, TYPE_SCHEMA_TYPE} = require('./TypeID');
 
+import type {ActorIdentifier} from '../multi-actor-environment/ActorIdentifier';
 import type {PayloadData} from '../network/RelayNetworkTypes';
 import type {
+  NormalizationActorChange,
   NormalizationDefer,
   NormalizationFlightField,
   NormalizationLinkedField,
@@ -67,13 +75,13 @@ import type {
 } from '../util/NormalizationNode';
 import type {DataID, Variables} from '../util/RelayRuntimeTypes';
 import type {
+  FollowupPayload,
   HandleFieldPayload,
   IncrementalDataPlaceholder,
-  ModuleImportPayload,
   MutableRecordSource,
   NormalizationSelector,
-  ReactFlightReachableExecutableDefinitions,
   ReactFlightPayloadDeserializer,
+  ReactFlightReachableExecutableDefinitions,
   ReactFlightServerErrorHandler,
   Record,
   RelayResponsePayload,
@@ -91,6 +99,7 @@ export type NormalizationOptions = {|
   +reactFlightPayloadDeserializer?: ?ReactFlightPayloadDeserializer,
   +reactFlightServerErrorHandler?: ?ReactFlightServerErrorHandler,
   +shouldProcessClientComponents?: ?boolean,
+  +actorIdentifier?: ?ActorIdentifier,
 |};
 
 /**
@@ -118,13 +127,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 +147,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 +180,7 @@ class RelayResponseNormalizer {
       errors: null,
       fieldPayloads: this._handleFieldPayloads,
       incrementalPlaceholders: this._incrementalPlaceholders,
-      moduleImportPayloads: this._moduleImportPayloads,
+      followupPayloads: this._followupPayloads,
       source: this._recordSource,
       isFinal: false,
     };
@@ -208,13 +219,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 +244,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 +261,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 +289,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 +331,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 +377,7 @@ class RelayResponseNormalizer {
           this._variables,
         ),
         typeName: RelayModernRecord.getType(record),
+        actorIdentifier: this._actorIdentifier,
       });
     }
   }
@@ -394,6 +410,7 @@ class RelayResponseNormalizer {
         parentID: RelayModernRecord.getDataID(record),
         node: stream,
         variables: this._variables,
+        actorIdentifier: this._actorIdentifier,
       });
     }
   }
@@ -424,13 +441,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,
       });
     }
   }
@@ -523,6 +543,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 +659,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);
@@ -658,13 +768,16 @@ class RelayResponseNormalizer {
     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 +787,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

@@ -51,13 +51,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

@@ -29,6 +29,7 @@ import type {
   Snapshot,
   StoreSubscriptions,
 } from './RelayStoreTypes';
+import type {ResolverCache} from './ResolverCache';
 
 type Subscription = {|
   callback: (snapshot: Snapshot) => void,
@@ -40,10 +41,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 +80,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;
@@ -150,7 +157,7 @@ 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 = ({