relay-runtime 11.0.0 → 13.0.0-rc.0

package/store/ClientID.js.flow

@@ -4,7 +4,7 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @flow strict
+ * @flow strict-local
  * @format
  */
 
@@ -14,6 +14,9 @@
 
 import type {DataID} from '../util/RelayRuntimeTypes';
 
+const RelayFeatureFlags = require('../util/RelayFeatureFlags');
+const {intern} = require('../util/StringInterner');
+
 const PREFIX = 'client:';
 
 function generateClientID(
@@ -21,7 +24,11 @@ function generateClientID(
   storageKey: string,
   index?: number,
 ): DataID {
-  let key = id + ':' + storageKey;
+  const internedId =
+    RelayFeatureFlags.STRING_INTERN_LEVEL <= 0
+      ? id
+      : intern(id, RelayFeatureFlags.MAX_DATA_ID_LENGTH);
+  let key = internedId + ':' + storageKey;
   if (index != null) {
     key += ':' + index;
   }
@@ -40,4 +47,8 @@ function generateUniqueClientID(): DataID {
   return `${PREFIX}local:${localID++}`;
 }
 
-module.exports = {generateClientID, generateUniqueClientID, isClientID};
+module.exports = {
+  generateClientID,
+  generateUniqueClientID,
+  isClientID,
+};

package/store/DataChecker.js.flow

@@ -13,23 +13,7 @@
 
 'use strict';
 
-const RelayConcreteNode = require('../util/RelayConcreteNode');
-const RelayFeatureFlags = require('../util/RelayFeatureFlags');
-const RelayModernRecord = require('./RelayModernRecord');
-const RelayRecordSourceMutator = require('../mutations/RelayRecordSourceMutator');
-const RelayRecordSourceProxy = require('../mutations/RelayRecordSourceProxy');
-const RelayStoreReactFlightUtils = require('./RelayStoreReactFlightUtils');
-const RelayStoreUtils = require('./RelayStoreUtils');
-
-const cloneRelayHandleSourceField = require('./cloneRelayHandleSourceField');
-const cloneRelayScalarHandleSourceField = require('./cloneRelayScalarHandleSourceField');
-const getOperation = require('../util/getOperation');
-const invariant = require('invariant');
-
-const {isClientID} = require('./ClientID');
-const {EXISTENT, UNKNOWN} = require('./RelayRecordState');
-const {generateTypeID} = require('./TypeID');
-
+import type {ActorIdentifier} from '../multi-actor-environment/ActorIdentifier';
 import type {
   NormalizationField,
   NormalizationFlightField,
@@ -46,18 +30,36 @@ import type {
   MutableRecordSource,
   NormalizationSelector,
   OperationLoader,
-  ReactFlightReachableQuery,
+  ReactFlightReachableExecutableDefinitions,
   Record,
   RecordSource,
 } from './RelayStoreTypes';
 
+const RelayRecordSourceMutator = require('../mutations/RelayRecordSourceMutator');
+const RelayRecordSourceProxy = require('../mutations/RelayRecordSourceProxy');
+const getOperation = require('../util/getOperation');
+const RelayConcreteNode = require('../util/RelayConcreteNode');
+const RelayFeatureFlags = require('../util/RelayFeatureFlags');
+const {isClientID} = require('./ClientID');
+const cloneRelayHandleSourceField = require('./cloneRelayHandleSourceField');
+const cloneRelayScalarHandleSourceField = require('./cloneRelayScalarHandleSourceField');
+const {getLocalVariables} = require('./RelayConcreteVariables');
+const RelayModernRecord = require('./RelayModernRecord');
+const {EXISTENT, UNKNOWN} = require('./RelayRecordState');
+const RelayStoreReactFlightUtils = require('./RelayStoreReactFlightUtils');
+const RelayStoreUtils = require('./RelayStoreUtils');
+const {generateTypeID} = require('./TypeID');
+const invariant = require('invariant');
+
 export type Availability = {|
   +status: 'available' | 'missing',
   +mostRecentlyInvalidatedAt: ?number,
 |};
 
 const {
+  ACTOR_CHANGE,
   CONDITION,
+  CLIENT_COMPONENT,
   CLIENT_EXTENSION,
   DEFER,
   FLIGHT_FIELD,
@@ -71,12 +73,8 @@ const {
   STREAM,
   TYPE_DISCRIMINATOR,
 } = RelayConcreteNode;
-const {
-  ROOT_ID,
-  getModuleOperationKey,
-  getStorageKey,
-  getArgumentValues,
-} = RelayStoreUtils;
+const {ROOT_ID, getModuleOperationKey, getStorageKey, getArgumentValues} =
+  RelayStoreUtils;
 
 /**
  * Synchronously check whether the records required to fulfill the given
@@ -89,21 +87,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 +123,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 {
@@ -177,6 +221,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 +348,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 +367,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 +393,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 +428,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 +444,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 +469,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 +506,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 +570,37 @@ 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 +617,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 +633,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);