relay-runtime 11.0.1 → 13.0.0-rc.1

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,18 +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 {
   NormalizationFlightField,
   NormalizationLinkedField,
@@ -36,12 +24,24 @@ import type {
   DataIDSet,
   NormalizationSelector,
   OperationLoader,
+  ReactFlightReachableExecutableDefinitions,
   Record,
   RecordSource,
-  ReactFlightReachableExecutableDefinitions,
 } 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,
@@ -125,7 +125,6 @@ class RelayReferenceMarker {
       'RelayReferenceMarker(): Undefined variable `%s`.',
       name,
     );
-    // $FlowFixMe[cannot-write]
     return this._variables[name];
   }
 
@@ -136,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);
@@ -144,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);
           }
@@ -155,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
@@ -197,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:
@@ -253,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