relay-runtime 11.0.0 → 13.0.0-rc.0

package/store/RelayRecordSource.js.flow

@@ -12,17 +12,83 @@
 
 'use strict';
 
-const RelayRecordSourceMapImpl = require('./RelayRecordSourceMapImpl');
+import type {DataID} from '../util/RelayRuntimeTypes';
+import type {RecordState} from './RelayRecordState';
+import type {
+  MutableRecordSource,
+  Record,
+  RecordObjectMap,
+} from './RelayStoreTypes';
 
-import type {MutableRecordSource, RecordObjectMap} from './RelayStoreTypes';
+const RelayRecordState = require('./RelayRecordState');
 
-class RelayRecordSource {
-  constructor(records?: RecordObjectMap): MutableRecordSource {
-    return RelayRecordSource.create(records);
+const {EXISTENT, NONEXISTENT, UNKNOWN} = RelayRecordState;
+
+/**
+ * An implementation of the `MutableRecordSource` interface (defined in
+ * `RelayStoreTypes`) that holds all records in memory (JS Map).
+ */
+class RelayRecordSource implements MutableRecordSource {
+  _records: Map<DataID, ?Record>;
+
+  constructor(records?: RecordObjectMap) {
+    this._records = new Map();
+    if (records != null) {
+      Object.keys(records).forEach(key => {
+        this._records.set(key, records[key]);
+      });
+    }
   }
 
   static create(records?: RecordObjectMap): MutableRecordSource {
-    return new RelayRecordSourceMapImpl(records);
+    return new RelayRecordSource(records);
+  }
+
+  clear(): void {
+    this._records = new Map();
+  }
+
+  delete(dataID: DataID): void {
+    this._records.set(dataID, null);
+  }
+
+  get(dataID: DataID): ?Record {
+    return this._records.get(dataID);
+  }
+
+  getRecordIDs(): Array<DataID> {
+    return Array.from(this._records.keys());
+  }
+
+  getStatus(dataID: DataID): RecordState {
+    if (!this._records.has(dataID)) {
+      return UNKNOWN;
+    }
+    return this._records.get(dataID) == null ? NONEXISTENT : EXISTENT;
+  }
+
+  has(dataID: DataID): boolean {
+    return this._records.has(dataID);
+  }
+
+  remove(dataID: DataID): void {
+    this._records.delete(dataID);
+  }
+
+  set(dataID: DataID, record: Record): void {
+    this._records.set(dataID, record);
+  }
+
+  size(): number {
+    return this._records.size;
+  }
+
+  toJSON(): {[DataID]: ?Record, ...} {
+    const obj = {};
+    for (const [key, value] of this._records) {
+      obj[key] = value;
+    }
+    return obj;
   }
 }
 

package/store/RelayReferenceMarker.js.flow

@@ -12,19 +12,6 @@
 
 'use strict';
 
-const RelayConcreteNode = require('../util/RelayConcreteNode');
-const RelayFeatureFlags = require('../util/RelayFeatureFlags');
-const RelayModernRecord = require('./RelayModernRecord');
-const RelayStoreReactFlightUtils = require('./RelayStoreReactFlightUtils');
-const RelayStoreUtils = require('./RelayStoreUtils');
-
-const cloneRelayHandleSourceField = require('./cloneRelayHandleSourceField');
-const getOperation = require('../util/getOperation');
-const invariant = require('invariant');
-
-const {generateTypeID} = require('./TypeID');
-
-import type {ReactFlightPayloadQuery} from '../network/RelayNetworkTypes';
 import type {
   NormalizationFlightField,
   NormalizationLinkedField,
@@ -37,12 +24,26 @@ import type {
   DataIDSet,
   NormalizationSelector,
   OperationLoader,
+  ReactFlightReachableExecutableDefinitions,
   Record,
   RecordSource,
 } from './RelayStoreTypes';
 
+const getOperation = require('../util/getOperation');
+const RelayConcreteNode = require('../util/RelayConcreteNode');
+const RelayFeatureFlags = require('../util/RelayFeatureFlags');
+const cloneRelayHandleSourceField = require('./cloneRelayHandleSourceField');
+const {getLocalVariables} = require('./RelayConcreteVariables');
+const RelayModernRecord = require('./RelayModernRecord');
+const RelayStoreReactFlightUtils = require('./RelayStoreReactFlightUtils');
+const RelayStoreUtils = require('./RelayStoreUtils');
+const {generateTypeID} = require('./TypeID');
+const invariant = require('invariant');
+
 const {
+  ACTOR_CHANGE,
   CONDITION,
+  CLIENT_COMPONENT,
   CLIENT_EXTENSION,
   DEFER,
   FLIGHT_FIELD,
@@ -63,6 +64,7 @@ function mark(
   selector: NormalizationSelector,
   references: DataIDSet,
   operationLoader: ?OperationLoader,
+  shouldProcessClientComponents: ?boolean,
 ): void {
   const {dataID, node, variables} = selector;
   const marker = new RelayReferenceMarker(
@@ -70,6 +72,7 @@ function mark(
     variables,
     references,
     operationLoader,
+    shouldProcessClientComponents,
   );
   marker.mark(node, dataID);
 }
@@ -83,18 +86,21 @@ class RelayReferenceMarker {
   _recordSource: RecordSource;
   _references: DataIDSet;
   _variables: Variables;
+  _shouldProcessClientComponents: ?boolean;
 
   constructor(
     recordSource: RecordSource,
     variables: Variables,
     references: DataIDSet,
     operationLoader: ?OperationLoader,
+    shouldProcessClientComponents: ?boolean,
   ) {
     this._operationLoader = operationLoader ?? null;
     this._operationName = null;
     this._recordSource = recordSource;
     this._references = references;
     this._variables = variables;
+    this._shouldProcessClientComponents = shouldProcessClientComponents;
   }
 
   mark(node: NormalizationNode, dataID: DataID): void {
@@ -129,6 +135,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);
@@ -137,7 +147,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);
           }
@@ -148,18 +160,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
@@ -190,11 +206,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:
@@ -210,6 +224,12 @@ class RelayReferenceMarker {
             throw new Error('Flight fields are not yet supported.');
           }
           break;
+        case CLIENT_COMPONENT:
+          if (this._shouldProcessClientComponents === false) {
+            break;
+          }
+          this._traverseSelections(selection.fragment.selections, record);
+          break;
         default:
           (selection: empty);
           invariant(
@@ -240,8 +260,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
@@ -286,12 +313,12 @@ class RelayReferenceMarker {
       return;
     }
 
-    const reachableQueries = RelayModernRecord.getValue(
+    const reachableExecutableDefinitions = RelayModernRecord.getValue(
       reactFlightClientResponseRecord,
-      RelayStoreReactFlightUtils.REACT_FLIGHT_QUERIES_STORAGE_KEY,
+      RelayStoreReactFlightUtils.REACT_FLIGHT_EXECUTABLE_DEFINITIONS_STORAGE_KEY,
     );
 
-    if (!Array.isArray(reachableQueries)) {
+    if (!Array.isArray(reachableExecutableDefinitions)) {
       return;
     }
 
@@ -301,13 +328,13 @@ class RelayReferenceMarker {
       '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<ReactFlightPayloadQuery>)) {
-      this._variables = query.variables;
-      const operationReference = query.module;
+    for (const definition of (reachableExecutableDefinitions: Array<ReactFlightReachableExecutableDefinitions>)) {
+      this._variables = definition.variables;
+      const operationReference = definition.module;
       const normalizationRootNode = operationLoader.get(operationReference);
       if (normalizationRootNode != null) {
         const operation = getOperation(normalizationRootNode);