relay-runtime 0.0.0-main-dbe0cbb6 → 0.0.0-main-a70cd064

package/store/RelayReader.js.flow

@@ -109,6 +109,7 @@ class RelayReader {
   _selector: SingularReaderSelector;
   _variables: Variables;
   _resolverCache: ResolverCache;
+  _fragmentName: string;
 
   constructor(
     recordSource: RecordSource,
@@ -130,6 +131,7 @@ class RelayReader {
     this._selector = selector;
     this._variables = selector.variables;
     this._resolverCache = resolverCache;
+    this._fragmentName = selector.node.name;
   }
 
   read(): Snapshot {
@@ -267,7 +269,7 @@ class RelayReader {
       // encounter is likely to be the root cause of the error.
       return;
     }
-    const owner = this._selector.node.name;
+    const owner = this._fragmentName;
 
     switch (action) {
       case 'THROW':
@@ -275,9 +277,19 @@ class RelayReader {
         return;
       case 'LOG':
         if (this._missingRequiredFields == null) {
-          this._missingRequiredFields = {action, fields: []};
+          this._missingRequiredFields = {
+            action,
+            fields: [{path: fieldPath, owner}],
+          };
+        } else {
+          this._missingRequiredFields = {
+            action,
+            fields: [
+              ...this._missingRequiredFields.fields,
+              {path: fieldPath, owner},
+            ],
+          };
         }
-        this._missingRequiredFields.fields.push({path: fieldPath, owner});
         return;
       default:
         (action: empty);
@@ -511,6 +523,8 @@ class RelayReader {
     // inputs have changed since a previous evaluation:
     let fragmentValue;
     let fragmentReaderSelector;
+    let fragmentMissingRequiredFields: ?MissingRequiredFields;
+    let previousMissingRequriedFields: ?MissingRequiredFields;
     const fragmentSeenRecordIDs = new Set();
 
     const getDataForResolverFragment = singularReaderSelector => {
@@ -525,11 +539,14 @@ class RelayReader {
       try {
         this._seenRecords = fragmentSeenRecordIDs;
         const resolverFragmentData = {};
+        previousMissingRequriedFields = this._missingRequiredFields;
+        this._missingRequiredFields = null;
         this._createInlineDataOrResolverFragmentPointer(
           singularReaderSelector.node,
           record,
           resolverFragmentData,
         );
+        fragmentMissingRequiredFields = this._missingRequiredFields;
         fragmentValue = resolverFragmentData[FRAGMENTS_KEY]?.[fragment.name];
         invariant(
           typeof fragmentValue === 'object' && fragmentValue !== null,
@@ -538,36 +555,43 @@ class RelayReader {
         return fragmentValue;
       } finally {
         this._seenRecords = existingSeenRecords;
+        this._missingRequiredFields = previousMissingRequriedFields;
       }
     };
     const resolverContext = {getDataForResolverFragment};
 
-    const [result, seenRecord] = this._resolverCache.readFromCacheOrEvaluate(
-      record,
-      field,
-      this._variables,
-      () => {
-        const key = {
-          __id: RelayModernRecord.getDataID(record),
-          __fragmentOwner: this._owner,
-          __fragments: {
-            [fragment.name]: {}, // Arguments to this fragment; not yet supported.
-          },
-        };
-        return withResolverContext(resolverContext, () => {
-          // $FlowFixMe[prop-missing] - resolver module's type signature is a lie
-          const resolverResult = resolverModule(key);
-          return {
-            resolverResult,
-            fragmentValue,
-            resolverID,
-            seenRecordIDs: fragmentSeenRecordIDs,
-            readerSelector: fragmentReaderSelector,
+    const [result, seenRecord, missingRequiredFields] =
+      this._resolverCache.readFromCacheOrEvaluate(
+        record,
+        field,
+        this._variables,
+        () => {
+          const key = {
+            __id: RelayModernRecord.getDataID(record),
+            __fragmentOwner: this._owner,
+            __fragments: {
+              [fragment.name]: {}, // Arguments to this fragment; not yet supported.
+            },
           };
-        });
-      },
-      getDataForResolverFragment,
-    );
+          return withResolverContext(resolverContext, () => {
+            // $FlowFixMe[prop-missing] - resolver module's type signature is a lie
+            const resolverResult = resolverModule(key);
+            return {
+              resolverResult,
+              fragmentValue,
+              resolverID,
+              seenRecordIDs: fragmentSeenRecordIDs,
+              readerSelector: fragmentReaderSelector,
+              missingRequiredFields: fragmentMissingRequiredFields,
+            };
+          });
+        },
+        getDataForResolverFragment,
+      );
+
+    if (missingRequiredFields != null) {
+      this._addMissingRequiredFields(missingRequiredFields);
+    }
     if (seenRecord != null) {
       this._seenRecords.add(seenRecord);
     }
@@ -896,14 +920,37 @@ class RelayReader {
       data[ID_KEY] = RelayModernRecord.getDataID(record);
     }
     const inlineData = {};
+    const parentFragmentName = this._fragmentName;
+    this._fragmentName = fragmentSpreadOrFragment.name;
     this._traverseSelections(
       fragmentSpreadOrFragment.selections,
       record,
       inlineData,
     );
+    this._fragmentName = parentFragmentName;
     // $FlowFixMe[cannot-write] - writing into read-only field
     fragmentPointers[fragmentSpreadOrFragment.name] = inlineData;
   }
+
+  _addMissingRequiredFields(additional: MissingRequiredFields) {
+    if (this._missingRequiredFields == null) {
+      this._missingRequiredFields = additional;
+      return;
+    }
+
+    if (this._missingRequiredFields.action === 'THROW') {
+      return;
+    }
+    if (additional.action === 'THROW') {
+      this._missingRequiredFields = additional;
+      return;
+    }
+
+    this._missingRequiredFields = {
+      action: 'LOG',
+      fields: [...this._missingRequiredFields.fields, ...additional.fields],
+    };
+  }
 }
 
 module.exports = {read};

package/store/RelayStoreTypes.js.flow

@@ -117,9 +117,10 @@ type MissingRequiredField = {|
   owner: string,
 |};
 
-export type MissingRequiredFields =
+export type MissingRequiredFields = $ReadOnly<
   | {|action: 'THROW', field: MissingRequiredField|}
-  | {|action: 'LOG', fields: Array<MissingRequiredField>|};
+  | {|action: 'LOG', fields: Array<MissingRequiredField>|},
+>;
 
 export type ClientEdgeTraversalInfo = {|
   +readerClientEdge: ReaderClientEdge,

package/store/RelayStoreUtils.js.flow

@@ -219,6 +219,7 @@ const RelayStoreUtils = {
   RELAY_RESOLVER_INVALIDATION_KEY: '__resolverValueMayBeInvalid',
   RELAY_RESOLVER_INPUTS_KEY: '__resolverInputValues',
   RELAY_RESOLVER_READER_SELECTOR_KEY: '__resolverReaderSelector',
+  RELAY_RESOLVER_MISSING_REQUIRED_FIELDS_KEY: '__resolverMissingRequiredFields',
 
   formatStorageKey,
   getArgumentValue,

package/store/ResolverCache.js.flow

@@ -15,6 +15,7 @@
 import type {ReaderRelayResolver} from '../util/ReaderNode';
 import type {DataID, Variables} from '../util/RelayRuntimeTypes';
 import type {
+  MissingRequiredFields,
   MutableRecordSource,
   Record,
   SingularReaderSelector,
@@ -26,6 +27,7 @@ const RelayModernRecord = require('./RelayModernRecord');
 const {
   RELAY_RESOLVER_INPUTS_KEY,
   RELAY_RESOLVER_INVALIDATION_KEY,
+  RELAY_RESOLVER_MISSING_REQUIRED_FIELDS_KEY,
   RELAY_RESOLVER_READER_SELECTOR_KEY,
   RELAY_RESOLVER_VALUE_KEY,
   getStorageKey,
@@ -40,6 +42,7 @@ type EvaluationResult<T> = {|
   resolverID: ResolverID,
   seenRecordIDs: Set<DataID>,
   readerSelector: SingularReaderSelector,
+  missingRequiredFields: ?MissingRequiredFields,
 |};
 
 export interface ResolverCache {
@@ -49,7 +52,7 @@ export interface ResolverCache {
     variables: Variables,
     evaluate: () => EvaluationResult<T>,
     getDataForResolverFragment: (SingularReaderSelector) => mixed,
-  ): [T /* Answer */, ?DataID /* Seen record */];
+  ): [T /* Answer */, ?DataID /* Seen record */, ?MissingRequiredFields];
   invalidateDataIDs(
     updatedDataIDs: Set<DataID>, // Mutated in place
   ): void;
@@ -65,8 +68,9 @@ class NoopResolverCache implements ResolverCache {
     variables: Variables,
     evaluate: () => EvaluationResult<T>,
     getDataForResolverFragment: SingularReaderSelector => mixed,
-  ): [T /* Answer */, ?DataID /* Seen record */] {
-    return [evaluate().resolverResult, undefined];
+  ): [T /* Answer */, ?DataID /* Seen record */, ?MissingRequiredFields] {
+    const {resolverResult, missingRequiredFields} = evaluate();
+    return [resolverResult, undefined, missingRequiredFields];
   }
   invalidateDataIDs(updatedDataIDs: Set<DataID>): void {}
 }
@@ -102,7 +106,7 @@ class RecordResolverCache implements ResolverCache {
     variables: Variables,
     evaluate: () => EvaluationResult<T>,
     getDataForResolverFragment: SingularReaderSelector => mixed,
-  ): [T /* Answer */, ?DataID /* Seen record */] {
+  ): [T /* Answer */, ?DataID /* Seen record */, ?MissingRequiredFields] {
     const recordSource = this._getRecordSource();
     const recordID = RelayModernRecord.getDataID(record);
 
@@ -133,6 +137,11 @@ class RecordResolverCache implements ResolverCache {
         RELAY_RESOLVER_READER_SELECTOR_KEY,
         evaluationResult.readerSelector,
       );
+      RelayModernRecord.setValue(
+        linkedRecord,
+        RELAY_RESOLVER_MISSING_REQUIRED_FIELDS_KEY,
+        evaluationResult.missingRequiredFields,
+      );
       recordSource.set(linkedID, linkedRecord);
 
       // Link the resolver value record to the resolver field of the record being read:
@@ -155,7 +164,11 @@ class RecordResolverCache implements ResolverCache {
 
     // $FlowFixMe[incompatible-type] - will always be empty
     const answer: T = linkedRecord[RELAY_RESOLVER_VALUE_KEY];
-    return [answer, linkedID];
+
+    const missingRequiredFields: ?MissingRequiredFields =
+      // $FlowFixMe[incompatible-type] - casting mixed
+      linkedRecord[RELAY_RESOLVER_MISSING_REQUIRED_FIELDS_KEY];
+    return [answer, linkedID, missingRequiredFields];
   }
 
   invalidateDataIDs(