relay-runtime 11.0.0-rc.0 → 12.0.0

package/store/ClientID.js.flow

@@ -40,4 +40,8 @@ function generateUniqueClientID(): DataID {
   return `${PREFIX}local:${localID++}`;
 }
 
-module.exports = {generateClientID, generateUniqueClientID, isClientID};
+module.exports = {
+  generateClientID,
+  generateUniqueClientID,
+  isClientID,
+};

package/store/DataChecker.js.flow

@@ -27,9 +27,11 @@ const getOperation = require('../util/getOperation');
 const invariant = require('invariant');
 
 const {isClientID} = require('./ClientID');
+const {getLocalVariables} = require('./RelayConcreteVariables');
 const {EXISTENT, UNKNOWN} = require('./RelayRecordState');
 const {generateTypeID} = require('./TypeID');
 
+import type {ActorIdentifier} from '../multi-actor-environment/ActorIdentifier';
 import type {
   NormalizationField,
   NormalizationFlightField,
@@ -46,7 +48,7 @@ import type {
   MutableRecordSource,
   NormalizationSelector,
   OperationLoader,
-  ReactFlightReachableQuery,
+  ReactFlightReachableExecutableDefinitions,
   Record,
   RecordSource,
 } from './RelayStoreTypes';
@@ -57,7 +59,9 @@ export type Availability = {|
 |};
 
 const {
+  ACTOR_CHANGE,
   CONDITION,
+  CLIENT_COMPONENT,
   CLIENT_EXTENSION,
   DEFER,
   FLIGHT_FIELD,
@@ -89,21 +93,25 @@ const {
  * If all records are present, returns `true`, otherwise `false`.
  */
 function check(
-  source: RecordSource,
-  target: MutableRecordSource,
+  getSourceForActor: (actorIdentifier: ActorIdentifier) => RecordSource,
+  getTargetForActor: (actorIdentifier: ActorIdentifier) => MutableRecordSource,
+  defaultActorIdentifier: ActorIdentifier,
   selector: NormalizationSelector,
   handlers: $ReadOnlyArray<MissingFieldHandler>,
   operationLoader: ?OperationLoader,
   getDataID: GetDataID,
+  shouldProcessClientComponents: ?boolean,
 ): Availability {
   const {dataID, node, variables} = selector;
   const checker = new DataChecker(
-    source,
-    target,
+    getSourceForActor,
+    getTargetForActor,
+    defaultActorIdentifier,
     variables,
     handlers,
     operationLoader,
     getDataID,
+    shouldProcessClientComponents,
   );
   return checker.check(node, dataID);
 }
@@ -121,24 +129,66 @@ class DataChecker {
   _recordWasMissing: boolean;
   _source: RecordSource;
   _variables: Variables;
+  _shouldProcessClientComponents: ?boolean;
+  +_getSourceForActor: (actorIdentifier: ActorIdentifier) => RecordSource;
+  +_getTargetForActor: (
+    actorIdentifier: ActorIdentifier,
+  ) => MutableRecordSource;
+  +_getDataID: GetDataID;
+  +_mutatorRecordSourceProxyCache: Map<
+    ActorIdentifier,
+    [RelayRecordSourceMutator, RelayRecordSourceProxy],
+  >;
 
   constructor(
-    source: RecordSource,
-    target: MutableRecordSource,
+    getSourceForActor: (actorIdentifier: ActorIdentifier) => RecordSource,
+    getTargetForActor: (
+      actorIdentifier: ActorIdentifier,
+    ) => MutableRecordSource,
+    defaultActorIdentifier: ActorIdentifier,
     variables: Variables,
     handlers: $ReadOnlyArray<MissingFieldHandler>,
     operationLoader: ?OperationLoader,
     getDataID: GetDataID,
+    shouldProcessClientComponents: ?boolean,
   ) {
-    const mutator = new RelayRecordSourceMutator(source, target);
+    this._getSourceForActor = getSourceForActor;
+    this._getTargetForActor = getTargetForActor;
+    this._getDataID = getDataID;
+    this._source = getSourceForActor(defaultActorIdentifier);
+    this._mutatorRecordSourceProxyCache = new Map();
+    const [mutator, recordSourceProxy] = this._getMutatorAndRecordProxyForActor(
+      defaultActorIdentifier,
+    );
     this._mostRecentlyInvalidatedAt = null;
     this._handlers = handlers;
     this._mutator = mutator;
     this._operationLoader = operationLoader ?? null;
-    this._recordSourceProxy = new RelayRecordSourceProxy(mutator, getDataID);
+    this._recordSourceProxy = recordSourceProxy;
     this._recordWasMissing = false;
-    this._source = source;
     this._variables = variables;
+    this._shouldProcessClientComponents = shouldProcessClientComponents;
+  }
+
+  _getMutatorAndRecordProxyForActor(
+    actorIdentifier: ActorIdentifier,
+  ): [RelayRecordSourceMutator, RelayRecordSourceProxy] {
+    let tuple = this._mutatorRecordSourceProxyCache.get(actorIdentifier);
+    if (tuple == null) {
+      const target = this._getTargetForActor(actorIdentifier);
+
+      const mutator = new RelayRecordSourceMutator(
+        this._getSourceForActor(actorIdentifier),
+        target,
+      );
+      const recordSourceProxy = new RelayRecordSourceProxy(
+        mutator,
+        this._getDataID,
+      );
+      tuple = [mutator, recordSourceProxy];
+      this._mutatorRecordSourceProxyCache.set(actorIdentifier, tuple);
+    }
+    return tuple;
   }
 
   check(node: NormalizationNode, dataID: DataID): Availability {
@@ -161,6 +211,7 @@ class DataChecker {
       'RelayAsyncLoader(): Undefined variable `%s`.',
       name,
     );
+    // $FlowFixMe[cannot-write]
     return this._variables[name];
   }
 
@@ -177,6 +228,8 @@ class DataChecker {
     ...
   } {
     return {
+      /* $FlowFixMe[class-object-subtyping] added when improving typing for
+       * this parameters */
       args: field.args ? getArgumentValues(field.args, this._variables) : {},
       // Getting a snapshot of the record state is potentially expensive since
       // we will need to merge the sink and source records. Since we do not create
@@ -302,8 +355,13 @@ class DataChecker {
             this._checkLink(selection, dataID);
           }
           break;
+        case ACTOR_CHANGE:
+          this._checkActorChange(selection.linkedField, dataID);
+          break;
         case CONDITION:
-          const conditionValue = this._getVariableValue(selection.condition);
+          const conditionValue = Boolean(
+            this._getVariableValue(selection.condition),
+          );
           if (conditionValue === selection.passingValue) {
             this._traverseSelections(selection.selections, dataID);
           }
@@ -316,7 +374,7 @@ class DataChecker {
             if (typeName === selection.type) {
               this._traverseSelections(selection.selections, dataID);
             }
-          } else if (RelayFeatureFlags.ENABLE_PRECISE_TYPE_REFINEMENT) {
+          } else {
             // Abstract refinement: check data depending on whether the type
             // conforms to the interface/union or not:
             // - Type known to _not_ implement the interface: don't check the selections.
@@ -342,10 +400,6 @@ class DataChecker {
               // missing so don't bother reading the fragment
               this._handleMissing();
             } // else false: known to not implement the interface
-          } else {
-            // legacy behavior for abstract refinements: always check even
-            // if the type doesn't conform
-            this._traverseSelections(selection.selections, dataID);
           }
           break;
         }
@@ -381,9 +435,15 @@ class DataChecker {
         case STREAM:
           this._traverseSelections(selection.selections, dataID);
           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, dataID);
+          this._variables = prevVariables;
           break;
         case CLIENT_EXTENSION:
           const recordWasMissing = this._recordWasMissing;
@@ -391,25 +451,23 @@ class DataChecker {
           this._recordWasMissing = recordWasMissing;
           break;
         case TYPE_DISCRIMINATOR:
-          if (RelayFeatureFlags.ENABLE_PRECISE_TYPE_REFINEMENT) {
-            const {abstractKey} = selection;
-            const recordType = this._mutator.getType(dataID);
-            invariant(
-              recordType != null,
-              'DataChecker: Expected record `%s` to have a known type',
-              dataID,
-            );
-            const typeID = generateTypeID(recordType);
-            const implementsInterface = this._mutator.getValue(
-              typeID,
-              abstractKey,
-            );
-            if (implementsInterface == null) {
-              // unsure if the type implements the interface: data is
-              // missing
-              this._handleMissing();
-            } // else: if it does or doesn't implement, we don't need to check or skip anything else
-          }
+          const {abstractKey} = selection;
+          const recordType = this._mutator.getType(dataID);
+          invariant(
+            recordType != null,
+            'DataChecker: Expected record `%s` to have a known type',
+            dataID,
+          );
+          const typeID = generateTypeID(recordType);
+          const implementsInterface = this._mutator.getValue(
+            typeID,
+            abstractKey,
+          );
+          if (implementsInterface == null) {
+            // unsure if the type implements the interface: data is
+            // missing
+            this._handleMissing();
+          } // else: if it does or doesn't implement, we don't need to check or skip anything else
           break;
         case FLIGHT_FIELD:
           if (RelayFeatureFlags.ENABLE_REACT_FLIGHT_COMPONENT_FIELD) {
@@ -418,6 +476,12 @@ class DataChecker {
             throw new Error('Flight fields are not yet supported.');
           }
           break;
+        case CLIENT_COMPONENT:
+          if (this._shouldProcessClientComponents === false) {
+            break;
+          }
+          this._traverseSelections(selection.fragment.selections, dataID);
+          break;
         default:
           (selection: empty);
           invariant(
@@ -449,7 +513,14 @@ class DataChecker {
     const normalizationRootNode = operationLoader.get(operationReference);
     if (normalizationRootNode != null) {
       const operation = getOperation(normalizationRootNode);
+      const prevVariables = this._variables;
+      this._variables = getLocalVariables(
+        this._variables,
+        operation.argumentDefinitions,
+        moduleImport.args,
+      );
       this._traverse(operation, dataID);
+      this._variables = prevVariables;
     } else {
       // If the fragment is not available, we assume that the data cannot have been
       // processed yet and must therefore be missing.
@@ -506,6 +577,39 @@ class DataChecker {
     }
   }
 
+  _checkActorChange(field: NormalizationLinkedField, dataID: DataID): void {
+    const storageKey = getStorageKey(field, this._variables);
+    const record = this._source.get(dataID);
+    const tuple =
+      record != null
+        ? RelayModernRecord.getActorLinkedRecordID(record, storageKey)
+        : record;
+
+    if (tuple == null) {
+      if (tuple === undefined) {
+        this._handleMissing();
+      }
+    } else {
+      const [actorIdentifier, linkedID] = tuple;
+      const prevSource = this._source;
+      const prevMutator = this._mutator;
+      const prevRecordSourceProxy = this._recordSourceProxy;
+
+      const [
+        mutator,
+        recordSourceProxy,
+      ] = this._getMutatorAndRecordProxyForActor(actorIdentifier);
+
+      this._source = this._getSourceForActor(actorIdentifier);
+      this._mutator = mutator;
+      this._recordSourceProxy = recordSourceProxy;
+      this._traverse(field, linkedID);
+      this._source = prevSource;
+      this._mutator = prevMutator;
+      this._recordSourceProxy = prevRecordSourceProxy;
+    }
+  }
+
   _checkFlightField(field: NormalizationFlightField, dataID: DataID): void {
     const storageKey = getStorageKey(field, this._variables);
     const linkedID = this._mutator.getLinkedRecordID(dataID, storageKey);
@@ -522,12 +626,12 @@ class DataChecker {
       linkedID,
       RelayStoreReactFlightUtils.REACT_FLIGHT_TREE_STORAGE_KEY,
     );
-    const reachableQueries = this._mutator.getValue(
+    const reachableExecutableDefinitions = this._mutator.getValue(
       linkedID,
-      RelayStoreReactFlightUtils.REACT_FLIGHT_QUERIES_STORAGE_KEY,
+      RelayStoreReactFlightUtils.REACT_FLIGHT_EXECUTABLE_DEFINITIONS_STORAGE_KEY,
     );
 
-    if (tree == null || !Array.isArray(reachableQueries)) {
+    if (tree == null || !Array.isArray(reachableExecutableDefinitions)) {
       this._handleMissing();
       return;
     }
@@ -538,13 +642,13 @@ class DataChecker {
       '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<ReactFlightReachableQuery>)) {
-      this._variables = query.variables;
-      const normalizationRootNode = operationLoader.get(query.module);
+    for (const definition of (reachableExecutableDefinitions: Array<ReactFlightReachableExecutableDefinitions>)) {
+      this._variables = definition.variables;
+      const normalizationRootNode = operationLoader.get(definition.module);
       if (normalizationRootNode != null) {
         const operation = getOperation(normalizationRootNode);
         this._traverseSelections(operation.selections, ROOT_ID);