relay-runtime 18.1.0 → 19.0.0

package/store/RelayReader.js.flow

@@ -11,8 +11,11 @@
 
 'use strict';
 
+import type {Result} from '../experimental';
 import type {
+  CatchFieldTo,
   ReaderActorChange,
+  ReaderAliasedInlineFragmentSpread,
   ReaderCatchField,
   ReaderClientEdge,
   ReaderFragment,
@@ -32,10 +35,9 @@ import type {DataID, Variables} from '../util/RelayRuntimeTypes';
 import type {
   ClientEdgeTraversalInfo,
   DataIDSet,
-  ErrorResponseField,
-  ErrorResponseFields,
+  FieldError,
+  FieldErrors,
   MissingClientEdgeRequestInfo,
-  MissingLiveResolverField,
   Record,
   RecordSource,
   RequestDescriptor,
@@ -47,6 +49,7 @@ import type {
 import type {Arguments} from './RelayStoreUtils';
 import type {EvaluationResult, ResolverCache} from './ResolverCache';
 
+const RelayFeatureFlags = require('../util/RelayFeatureFlags');
 const {
   isSuspenseSentinel,
 } = require('./live-resolvers/LiveResolverSuspenseSentinel');
@@ -72,8 +75,6 @@ const {
 const {generateTypeID} = require('./TypeID');
 const invariant = require('invariant');
 
-type RequiredOrCatchField = ReaderRequiredField | ReaderCatchField;
-
 function read(
   recordSource: RecordSource,
   selector: SingularReaderSelector,
@@ -96,10 +97,16 @@ class RelayReader {
   _clientEdgeTraversalPath: Array<ClientEdgeTraversalInfo | null>;
   _isMissingData: boolean;
   _missingClientEdges: Array<MissingClientEdgeRequestInfo>;
-  _missingLiveResolverFields: Array<MissingLiveResolverField>;
+  _missingLiveResolverFields: Array<DataID>;
   _isWithinUnmatchedTypeRefinement: boolean;
-  _errorResponseFields: ?ErrorResponseFields;
+  _fieldErrors: ?FieldErrors;
   _owner: RequestDescriptor;
+  // Exec time resolvers are run before reaching the Relay store so the store already contains
+  // the normalized data; the same as if the data were sent from the server. However, since a
+  // resolver could be used at read time or exec time in different queries, the reader AST for
+  // a resolver is the read time AST. At runtime, this flag is used to ignore the extra
+  // information in the read time resolver AST and use the "standard", non-resolver read paths
+  _useExecTimeResolvers: boolean;
   _recordSource: RecordSource;
   _seenRecords: DataIDSet;
   _updatedDataIDs: DataIDSet;
@@ -122,8 +129,13 @@ class RelayReader {
     this._missingLiveResolverFields = [];
     this._isMissingData = false;
     this._isWithinUnmatchedTypeRefinement = false;
-    this._errorResponseFields = null;
+    this._fieldErrors = null;
     this._owner = selector.owner;
+    this._useExecTimeResolvers =
+      this._owner.node.operation.use_exec_time_resolvers ??
+      this._owner.node.operation.exec_time_resolvers_enabled_provider?.get() ===
+        true ??
+      false;
     this._recordSource = recordSource;
     this._seenRecords = new Set();
     this._selector = selector;
@@ -175,7 +187,14 @@ class RelayReader {
     }
 
     this._isWithinUnmatchedTypeRefinement = !isDataExpectedToBePresent;
-    const data = this._traverse(node, dataID, null);
+    let data = this._traverse(node, dataID, null);
+
+    // If the fragment/operation was marked with @catch, we need to handle any
+    // errors that were encountered while reading the fields within it.
+    const catchTo = this._selector.node.metadata?.catchTo;
+    if (catchTo != null) {
+      data = this._catchErrors(data, catchTo, null) as $FlowFixMe;
+    }
 
     if (this._updatedDataIDs.size > 0) {
       this._resolverCache.notifyUpdatedSubscribers(this._updatedDataIDs);
@@ -190,11 +209,11 @@ class RelayReader {
       missingLiveResolverFields: this._missingLiveResolverFields,
       seenRecords: this._seenRecords,
       selector: this._selector,
-      errorResponseFields: this._errorResponseFields,
+      fieldErrors: this._fieldErrors,
     };
   }
 
-  _maybeAddErrorResponseFields(record: Record, storageKey: string): void {
+  _maybeAddFieldErrors(record: Record, storageKey: string): void {
     const errors = RelayModernRecord.getErrors(record, storageKey);
 
     if (errors == null) {
@@ -202,42 +221,55 @@ class RelayReader {
     }
     const owner = this._fragmentName;
 
-    if (this._errorResponseFields == null) {
-      this._errorResponseFields = [];
+    if (this._fieldErrors == null) {
+      this._fieldErrors = [];
     }
-    for (const error of errors) {
-      this._errorResponseFields.push({
+    for (let i = 0; i < errors.length; i++) {
+      const error = errors[i];
+      this._fieldErrors.push({
         kind: 'relay_field_payload.error',
         owner,
         fieldPath: (error.path ?? []).join('.'),
         error,
         shouldThrow: this._selector.node.metadata?.throwOnFieldError ?? false,
         handled: false,
+        // the uiContext is always undefined here.
+        // the loggingContext is provided by hooks - and assigned to uiContext in handlePotentialSnapshotErrors
+        uiContext: undefined,
       });
     }
   }
 
-  _markDataAsMissing(): void {
+  _markDataAsMissing(fieldName: string): void {
     if (this._isWithinUnmatchedTypeRefinement) {
       return;
     }
-    if (this._errorResponseFields == null) {
-      this._errorResponseFields = [];
+    if (this._fieldErrors == null) {
+      this._fieldErrors = [];
     }
 
     // we will add the path later
-    const fieldPath = '';
     const owner = this._fragmentName;
 
-    this._errorResponseFields.push(
+    this._fieldErrors.push(
       this._selector.node.metadata?.throwOnFieldError ?? false
         ? {
             kind: 'missing_expected_data.throw',
             owner,
-            fieldPath,
+            fieldPath: fieldName,
             handled: false,
+            // the uiContext is always undefined here.
+            // the loggingContext is provided by hooks - and assigned to uiContext in handlePotentialSnapshotErrors
+            uiContext: undefined,
           }
-        : {kind: 'missing_expected_data.log', owner, fieldPath},
+        : {
+            kind: 'missing_expected_data.log',
+            owner,
+            fieldPath: fieldName,
+            // the uiContext is always undefined here.
+            // the loggingContext is provided by hooks - and assigned to uiContext in handlePotentialSnapshotErrors
+            uiContext: undefined,
+          },
     );
 
     this._isMissingData = true;
@@ -266,8 +298,9 @@ class RelayReader {
     this._seenRecords.add(dataID);
     if (record == null) {
       if (record === undefined) {
-        this._markDataAsMissing();
+        this._markDataAsMissing('<record>');
       }
+      // $FlowFixMe[incompatible-return]
       return record;
     }
     const data = prevData || {};
@@ -288,53 +321,139 @@ class RelayReader {
     return this._variables[name];
   }
 
-  _maybeReportUnexpectedNull(fieldPath: string, action: 'LOG' | 'THROW') {
+  _maybeReportUnexpectedNull(selection: ReaderRequiredField) {
+    if (selection.action === 'NONE') {
+      return;
+    }
     const owner = this._fragmentName;
 
-    if (this._errorResponseFields == null) {
-      this._errorResponseFields = [];
+    if (this._fieldErrors == null) {
+      this._fieldErrors = [];
     }
 
-    switch (action) {
+    let fieldName: string;
+    if (selection.field.linkedField != null) {
+      fieldName =
+        selection.field.linkedField.alias ?? selection.field.linkedField.name;
+    } else {
+      fieldName = selection.field.alias ?? selection.field.name;
+    }
+
+    switch (selection.action) {
       case 'THROW':
-        this._errorResponseFields.push({
+        this._fieldErrors.push({
           kind: 'missing_required_field.throw',
-          fieldPath,
+          fieldPath: fieldName,
           owner,
           handled: false,
+          // the uiContext is always undefined here.
+          // the loggingContext is provided by hooks - and assigned to uiContext in handlePotentialSnapshotErrors
+          uiContext: undefined,
         });
         return;
       case 'LOG':
-        this._errorResponseFields.push({
+        this._fieldErrors.push({
           kind: 'missing_required_field.log',
-          fieldPath,
+          fieldPath: fieldName,
           owner,
+          // the uiContext is always undefined here.
+          // the loggingContext is provided by hooks - and assigned to uiContext in handlePotentialSnapshotErrors
+          uiContext: undefined,
         });
         return;
       default:
-        (action: empty);
+        (selection.action: empty);
     }
   }
 
-  _handleCatchToResult(
-    selection: ReaderCatchField,
-    record: Record,
-    data: SelectorData,
+  _handleRequiredFieldValue(
+    selection: ReaderRequiredField,
     value: mixed,
-  ) {
-    const field = selection.field?.backingField ?? selection.field;
-    const fieldName = field?.alias ?? field?.name;
+  ): boolean /*should continue to siblings*/ {
+    if (value == null) {
+      this._maybeReportUnexpectedNull(selection);
+      // We are going to throw, or our parent is going to get nulled out.
+      // Either way, sibling values are going to be ignored, so we can
+      // bail early here as an optimization.
+      return false;
+    }
+    return true;
+  }
 
-    // ReaderClientExtension doesn't have `alias` or `name`
-    // so we don't support this yet
-    invariant(
-      fieldName != null,
-      "Couldn't determine field name for this field. It might be a ReaderClientExtension - which is not yet supported.",
-    );
+  /**
+   * Fields, aliased inline fragments, fragments and operations with `@catch`
+   * directives must handle the case that errors were encountered while reading
+   * any fields within them.
+   *
+   * 1. Before traversing into the selection(s) marked as `@catch`, the caller
+   *   stores the previous field errors (`this._fieldErrors`) in a
+   *   variable.
+   * 2. After traversing into the selection(s) marked as `@catch`, the caller
+   *   calls this method with the resulting value, the `to` value from the
+   *   `@catch` directive, and the previous field errors.
+   *
+   * This method will then:
+   *
+   * 1. Compute the correct value to return based on any errors encountered and the supplied `to` type.
+   * 2. Mark any errors encountered within the `@catch` as "handled" to ensure they don't cause the reader to throw.
+   * 3. Merge any errors encountered within the `@catch` with the previous field errors.
+   */
+  _catchErrors<T>(
+    _value: T,
+    to: CatchFieldTo,
+    previousResponseFields: ?FieldErrors,
+  ): ?T | Result<T, mixed> {
+    let value: T | null | Result<T, mixed> = _value;
+    switch (to) {
+      case 'RESULT':
+        value = this._asResult(_value);
+        break;
+      case 'NULL':
+        if (this._fieldErrors != null && this._fieldErrors.length > 0) {
+          value = null;
+        }
+        break;
+      default:
+        (to: empty);
+    }
+
+    const childrenFieldErrors = this._fieldErrors;
+
+    this._fieldErrors = previousResponseFields;
+
+    // Merge any errors encountered within the @catch with the previous field
+    // errors, but mark them as "handled" first.
+    if (childrenFieldErrors != null) {
+      if (this._fieldErrors == null) {
+        this._fieldErrors = [];
+      }
+      for (let i = 0; i < childrenFieldErrors.length; i++) {
+        // We mark any errors encountered within the @catch as "handled"
+        // to ensure that they don't cause the reader to throw, but can
+        // still be logged.
+        this._fieldErrors.push(
+          markFieldErrorHasHandled(childrenFieldErrors[i]),
+        );
+      }
+    }
+    return value;
+  }
+
+  /**
+   * Convert a value into a Result object based on the presence of errors in the
+   * `this._fieldErrors` array.
+   *
+   * **Note**: This method does _not_ mark errors as handled. It is the caller's
+   * responsibility to ensure that errors are marked as handled.
+   */
+  _asResult<T>(value: T): Result<T, mixed> {
+    if (this._fieldErrors == null || this._fieldErrors.length === 0) {
+      return {ok: true, value};
+    }
 
     // TODO: Should we be hiding log level events here?
-    const errors = this._errorResponseFields
-      ?.map(error => {
+    const errors = this._fieldErrors
+      .map(error => {
         switch (error.kind) {
           case 'relay_field_payload.error':
             const {message, ...displayError} = error.error;
@@ -361,31 +480,14 @@ class RelayReader {
             (error.kind: empty);
             invariant(
               false,
-              'Unexpected error errorResponseField kind: %s',
+              'Unexpected error fieldError kind: %s',
               error.kind,
             );
         }
       })
       .filter(Boolean);
 
-    data[fieldName] = errors != null ? {ok: false, errors} : {ok: true, value};
-  }
-
-  _handleRequiredFieldValue(
-    selection: ReaderRequiredField,
-    value: mixed,
-  ): boolean /*should continue to siblings*/ {
-    if (value == null) {
-      const {action} = selection;
-      if (action !== 'NONE') {
-        this._maybeReportUnexpectedNull(selection.path, action);
-      }
-      // We are going to throw, or our parent is going to get nulled out.
-      // Either way, sibling values are going to be ignored, so we can
-      // bail early here as an optimization.
-      return false;
-    }
-    return true;
+    return {ok: false, errors};
   }
 
   _traverseSelections(
@@ -408,9 +510,9 @@ class RelayReader {
           }
           break;
         case 'CatchField': {
-          const previousResponseFields = this._errorResponseFields;
+          const previousResponseFields = this._fieldErrors;
 
-          this._errorResponseFields = null;
+          this._fieldErrors = null;
 
           const catchFieldValue = this._readClientSideDirectiveField(
             selection,
@@ -418,27 +520,20 @@ class RelayReader {
             data,
           );
 
-          if (selection.to === 'RESULT') {
-            this._handleCatchToResult(selection, record, data, catchFieldValue);
-          }
-
-          const childrenErrorResponseFields = this._errorResponseFields;
-
-          this._errorResponseFields = previousResponseFields;
+          const field = selection.field?.backingField ?? selection.field;
+          const fieldName = field?.alias ?? field?.name;
+          // ReaderClientExtension doesn't have `alias` or `name`
+          // so we don't support this yet
+          invariant(
+            fieldName != null,
+            "Couldn't determine field name for this field. It might be a ReaderClientExtension - which is not yet supported.",
+          );
 
-          if (childrenErrorResponseFields != null) {
-            if (this._errorResponseFields == null) {
-              this._errorResponseFields = [];
-            }
-            for (let i = 0; i < childrenErrorResponseFields.length; i++) {
-              // We mark any errors encountered within the @catch as "handled"
-              // to ensure that they don't cause the reader to throw, but can
-              // still be logged.
-              this._errorResponseFields.push(
-                markFieldErrorHasHandled(childrenErrorResponseFields[i]),
-              );
-            }
-          }
+          data[fieldName] = this._catchErrors(
+            catchFieldValue,
+            selection.to,
+            previousResponseFields,
+          );
 
           break;
         }
@@ -482,23 +577,18 @@ class RelayReader {
         }
         case 'RelayLiveResolver':
         case 'RelayResolver': {
-          this._readResolverField(selection, record, data);
+          if (this._useExecTimeResolvers) {
+            this._readScalar(selection, record, data);
+          } else {
+            this._readResolverField(selection, record, data);
+          }
           break;
         }
         case 'FragmentSpread':
           this._createFragmentPointer(selection, record, data);
           break;
         case 'AliasedInlineFragmentSpread': {
-          let fieldValue = this._readInlineFragment(
-            selection.fragment,
-            record,
-            {},
-            true,
-          );
-          if (fieldValue === false) {
-            fieldValue = null;
-          }
-          data[selection.name] = fieldValue;
+          this._readAliasedInlineFragment(selection, record, data);
           break;
         }
         case 'ModuleImport':
@@ -550,7 +640,20 @@ class RelayReader {
           break;
         case 'ClientEdgeToClientObject':
         case 'ClientEdgeToServerObject':
-          this._readClientEdge(selection, record, data);
+          if (
+            this._useExecTimeResolvers &&
+            (selection.backingField.kind === 'RelayResolver' ||
+              selection.backingField.kind === 'RelayLiveResolver')
+          ) {
+            const {linkedField} = selection;
+            if (linkedField.plural) {
+              this._readPluralLink(linkedField, record, data);
+            } else {
+              this._readLink(linkedField, record, data);
+            }
+          } else {
+            this._readClientEdge(selection, record, data);
+          }
           break;
         default:
           (selection: empty);
@@ -565,7 +668,7 @@ class RelayReader {
   }
 
   _readClientSideDirectiveField(
-    selection: RequiredOrCatchField,
+    selection: ReaderRequiredField | ReaderCatchField,
     record: Record,
     data: SelectorData,
   ): ?mixed {
@@ -578,19 +681,39 @@ class RelayReader {
         } else {
           return this._readLink(selection.field, record, data);
         }
+
       case 'RelayResolver':
-        return this._readResolverField(selection.field, record, data);
-      case 'RelayLiveResolver':
-        return this._readResolverField(selection.field, record, data);
+      case 'RelayLiveResolver': {
+        if (this._useExecTimeResolvers) {
+          return this._readScalar(selection.field, record, data);
+        } else {
+          return this._readResolverField(selection.field, record, data);
+        }
+      }
       case 'ClientEdgeToClientObject':
       case 'ClientEdgeToServerObject':
-        return this._readClientEdge(selection.field, record, data);
+        if (
+          this._useExecTimeResolvers &&
+          (selection.field.backingField.kind === 'RelayResolver' ||
+            selection.field.backingField.kind === 'RelayLiveResolver')
+        ) {
+          const {field} = selection;
+          if (field.linkedField.plural) {
+            return this._readPluralLink(field.linkedField, record, data);
+          } else {
+            return this._readLink(field.linkedField, record, data);
+          }
+        } else {
+          return this._readClientEdge(selection.field, record, data);
+        }
+      case 'AliasedInlineFragmentSpread':
+        return this._readAliasedInlineFragment(selection.field, record, data);
       default:
         (selection.field.kind: empty);
         invariant(
           false,
           'RelayReader(): Unexpected ast kind `%s`.',
-          selection.kind,
+          selection.field.kind,
         );
     }
   }
@@ -601,9 +724,12 @@ class RelayReader {
     data: SelectorData,
   ): mixed {
     const parentRecordID = RelayModernRecord.getDataID(record);
+    const prevErrors = this._fieldErrors;
+    this._fieldErrors = null;
     const result = this._readResolverFieldImpl(field, parentRecordID);
 
     const fieldName = field.alias ?? field.name;
+    this._prependPreviousErrors(prevErrors, fieldName);
     data[fieldName] = result;
     return result;
   }
@@ -637,7 +763,7 @@ class RelayReader {
         return {
           data: snapshot.data,
           isMissingData: snapshot.isMissingData,
-          errorResponseFields: snapshot.errorResponseFields,
+          fieldErrors: snapshot.fieldErrors,
         };
       }
 
@@ -650,7 +776,7 @@ class RelayReader {
       return {
         data: snapshot.data,
         isMissingData: snapshot.isMissingData,
-        errorResponseFields: snapshot.errorResponseFields,
+        fieldErrors: snapshot.fieldErrors,
       };
     };
 
@@ -735,7 +861,8 @@ class RelayReader {
     // upwards to mimic the behavior of having traversed into that fragment directly.
     if (cachedSnapshot != null) {
       if (cachedSnapshot.missingClientEdges != null) {
-        for (const missing of cachedSnapshot.missingClientEdges) {
+        for (let i = 0; i < cachedSnapshot.missingClientEdges.length; i++) {
+          const missing = cachedSnapshot.missingClientEdges[i];
           this._missingClientEdges.push(missing);
         }
       }
@@ -744,27 +871,34 @@ class RelayReader {
           this._isMissingData ||
           cachedSnapshot.missingLiveResolverFields.length > 0;
 
-        for (const missingResolverField of cachedSnapshot.missingLiveResolverFields) {
+        for (
+          let i = 0;
+          i < cachedSnapshot.missingLiveResolverFields.length;
+          i++
+        ) {
+          const missingResolverField =
+            cachedSnapshot.missingLiveResolverFields[i];
           this._missingLiveResolverFields.push(missingResolverField);
         }
       }
-      if (cachedSnapshot.errorResponseFields != null) {
-        if (this._errorResponseFields == null) {
-          this._errorResponseFields = [];
+      if (cachedSnapshot.fieldErrors != null) {
+        if (this._fieldErrors == null) {
+          this._fieldErrors = [];
         }
-        for (const error of cachedSnapshot.errorResponseFields) {
+        for (let i = 0; i < cachedSnapshot.fieldErrors.length; i++) {
+          const error = cachedSnapshot.fieldErrors[i];
           if (this._selector.node.metadata?.throwOnFieldError === true) {
             // If this fragment is @throwOnFieldError, any destructive error
             // encountered inside a resolver's fragment is equivilent to the
             // resolver field having a field error, and we want that to cause this
             // fragment to throw. So, we propagate all errors as is.
-            this._errorResponseFields.push(error);
+            this._fieldErrors.push(error);
           } else {
             // If this fragment is _not_ @throwOnFieldError, we will simply
             // accept that any destructive errors encountered in the resolver's
             // root fragment will cause the resolver to return null, and well
             // pass the errors along to the logger marked as "handled".
-            this._errorResponseFields.push(markFieldErrorHasHandled(error));
+            this._fieldErrors.push(markFieldErrorHasHandled(error));
           }
         }
       }
@@ -775,18 +909,21 @@ class RelayReader {
     // the errors can be attached to this read's snapshot. This allows the error
     // to be logged.
     if (resolverError) {
-      const errorEvent = {
+      const errorEvent: FieldError = {
         kind: 'relay_resolver.error',
         fieldPath,
         owner: this._fragmentName,
         error: resolverError,
         shouldThrow: this._selector.node.metadata?.throwOnFieldError ?? false,
         handled: false,
+        // the uiContext is always undefined here.
+        // the loggingContext is provided by hooks - and assigned to uiContext in handlePotentialSnapshotErrors
+        uiContext: undefined,
       };
-      if (this._errorResponseFields == null) {
-        this._errorResponseFields = [errorEvent];
+      if (this._fieldErrors == null) {
+        this._fieldErrors = [errorEvent];
       } else {
-        this._errorResponseFields.push(errorEvent);
+        this._fieldErrors.push(errorEvent);
       }
     }
 
@@ -804,15 +941,14 @@ class RelayReader {
     // they know when to unsuspend.
     if (suspenseID != null) {
       this._isMissingData = true;
-      this._missingLiveResolverFields.push({
-        path: `${this._fragmentName}.${fieldPath}`,
-        liveStateID: suspenseID,
-      });
+      this._missingLiveResolverFields.push(suspenseID);
     }
     if (updatedDataIDs != null) {
-      for (const recordID of updatedDataIDs) {
+      // Iterating a Set with for of is okay
+      // eslint-disable-next-line relay-internal/no-for-of-loops
+      updatedDataIDs.forEach(recordID => {
         this._updatedDataIDs.add(recordID);
-      }
+      });
     }
   }
 
@@ -982,12 +1118,15 @@ class RelayReader {
         RelayModernRecord.getDataID(record),
         prevData,
       );
+      const prevErrors = this._fieldErrors;
+      this._fieldErrors = null;
       const edgeValue = this._traverse(
         field.linkedField,
         storeID,
         // $FlowFixMe[incompatible-variance]
         prevData,
       );
+      this._prependPreviousErrors(prevErrors, fieldName);
       this._clientEdgeTraversalPath.pop();
       data[fieldName] = edgeValue;
       return edgeValue;
@@ -995,17 +1134,22 @@ class RelayReader {
   }
 
   _readScalar(
-    field: ReaderScalarField,
+    field: ReaderScalarField | ReaderRelayResolver | ReaderRelayLiveResolver,
     record: Record,
     data: SelectorData,
   ): ?mixed {
     const fieldName = field.alias ?? field.name;
     const storageKey = getStorageKey(field, this._variables);
     const value = RelayModernRecord.getValue(record, storageKey);
-    if (value === null) {
-      this._maybeAddErrorResponseFields(record, storageKey);
+    if (
+      value === null ||
+      (RelayFeatureFlags.ENABLE_NONCOMPLIANT_ERROR_HANDLING_ON_LISTS &&
+        Array.isArray(value) &&
+        value.length === 0)
+    ) {
+      this._maybeAddFieldErrors(record, storageKey);
     } else if (value === undefined) {
-      this._markDataAsMissing();
+      this._markDataAsMissing(fieldName);
     }
     data[fieldName] = value;
     return value;
@@ -1022,9 +1166,9 @@ class RelayReader {
     if (linkedID == null) {
       data[fieldName] = linkedID;
       if (linkedID === null) {
-        this._maybeAddErrorResponseFields(record, storageKey);
+        this._maybeAddFieldErrors(record, storageKey);
       } else if (linkedID === undefined) {
-        this._markDataAsMissing();
+        this._markDataAsMissing(fieldName);
       }
       return linkedID;
     }
@@ -1039,12 +1183,76 @@ class RelayReader {
       RelayModernRecord.getDataID(record),
       prevData,
     );
+    const prevErrors = this._fieldErrors;
+    this._fieldErrors = null;
     // $FlowFixMe[incompatible-variance]
     const value = this._traverse(field, linkedID, prevData);
+
+    this._prependPreviousErrors(prevErrors, fieldName);
     data[fieldName] = value;
     return value;
   }
 
+  /**
+   * Adds a set of field errors to `this._fieldErrors`, ensuring the
+   * `fieldPath` property of existing field errors are prefixed with the given
+   * `fieldNameOrIndex`.
+   *
+   * In order to make field errors maximally useful in logs/errors, we want to
+   * include the path to the field that caused the error. A naive approach would
+   * be to maintain a path property on RelayReader which we push/pop field names
+   * to as we traverse into fields/etc. However, this would be expensive to
+   * maintain, and in the common case where there are no field errors, the work
+   * would go unused.
+   *
+   * Instead, we take a lazy approach where as we exit the recurison into a
+   * field/etc we prepend any errors encountered while traversing that field
+   * with the field name. This is somewhat more expensive in the error case, but
+   * ~free in the common case where there are no errors.
+   *
+   * To achieve this, named field readers must do the following to correctly
+   * track error filePaths:
+   *
+   * 1. Stash the value of `this._fieldErrors` in a local variable
+   * 2. Set `this._fieldErrors` to `null`
+   * 3. Traverse into the field
+   * 4. Call this method with the stashed errors and the field's name
+   *
+   * Similarly, when creating field errors, we simply initialize the `fieldPath`
+   * as the direct field name.
+   *
+   * Today we only use this apporach for `missing_expected_data` and
+   * `missing_required_field` errors, but we intend to broaden it to handle all
+   * field error paths.
+   */
+  _prependPreviousErrors(
+    prevErrors: ?Array<FieldError>,
+    fieldNameOrIndex: string | number,
+  ): void {
+    if (this._fieldErrors != null) {
+      for (let i = 0; i < this._fieldErrors.length; i++) {
+        const event = this._fieldErrors[i];
+        if (
+          event.owner === this._fragmentName &&
+          (event.kind === 'missing_expected_data.throw' ||
+            event.kind === 'missing_expected_data.log' ||
+            event.kind === 'missing_required_field.throw' ||
+            event.kind === 'missing_required_field.log')
+        ) {
+          event.fieldPath = `${fieldNameOrIndex}.${event.fieldPath}`;
+        }
+      }
+      if (prevErrors != null) {
+        for (let i = this._fieldErrors.length - 1; i >= 0; i--) {
+          prevErrors.push(this._fieldErrors[i]);
+        }
+        this._fieldErrors = prevErrors;
+      }
+    } else {
+      this._fieldErrors = prevErrors;
+    }
+  }
+
   _readActorChange(
     field: ReaderActorChange,
     record: Record,
@@ -1060,9 +1268,9 @@ class RelayReader {
     if (externalRef == null) {
       data[fieldName] = externalRef;
       if (externalRef === undefined) {
-        this._markDataAsMissing();
+        this._markDataAsMissing(fieldName);
       } else if (externalRef === null) {
-        this._maybeAddErrorResponseFields(record, storageKey);
+        this._maybeAddFieldErrors(record, storageKey);
       }
       return data[fieldName];
     }
@@ -1090,8 +1298,13 @@ class RelayReader {
   ): ?mixed {
     const storageKey = getStorageKey(field, this._variables);
     const linkedIDs = RelayModernRecord.getLinkedRecordIDs(record, storageKey);
-    if (linkedIDs === null) {
-      this._maybeAddErrorResponseFields(record, storageKey);
+    if (
+      linkedIDs === null ||
+      (RelayFeatureFlags.ENABLE_NONCOMPLIANT_ERROR_HANDLING_ON_LISTS &&
+        Array.isArray(linkedIDs) &&
+        linkedIDs.length === 0)
+    ) {
+      this._maybeAddFieldErrors(record, storageKey);
     }
     return this._readLinkedIds(field, linkedIDs, record, data);
   }
@@ -1107,7 +1320,7 @@ class RelayReader {
     if (linkedIDs == null) {
       data[fieldName] = linkedIDs;
       if (linkedIDs === undefined) {
-        this._markDataAsMissing();
+        this._markDataAsMissing(fieldName);
       }
       return linkedIDs;
     }
@@ -1121,11 +1334,13 @@ class RelayReader {
       RelayModernRecord.getDataID(record),
       prevData,
     );
+    const prevErrors = this._fieldErrors;
+    this._fieldErrors = null;
     const linkedArray = prevData || [];
     linkedIDs.forEach((linkedID, nextIndex) => {
       if (linkedID == null) {
         if (linkedID === undefined) {
-          this._markDataAsMissing();
+          this._markDataAsMissing(String(nextIndex));
         }
         // $FlowFixMe[cannot-write]
         linkedArray[nextIndex] = linkedID;
@@ -1140,10 +1355,14 @@ class RelayReader {
         RelayModernRecord.getDataID(record),
         prevItem,
       );
+      const prevErrors = this._fieldErrors;
+      this._fieldErrors = null;
       // $FlowFixMe[cannot-write]
       // $FlowFixMe[incompatible-variance]
       linkedArray[nextIndex] = this._traverse(field, linkedID, prevItem);
+      this._prependPreviousErrors(prevErrors, nextIndex);
     });
+    this._prependPreviousErrors(prevErrors, fieldName);
     data[fieldName] = linkedArray;
     return linkedArray;
   }
@@ -1160,13 +1379,18 @@ class RelayReader {
     // Determine the component module from the store: if the field is missing
     // it means we don't know what component to render the match with.
     const componentKey = getModuleComponentKey(moduleImport.documentName);
+    const relayStoreComponent = RelayModernRecord.getValue(
+      record,
+      componentKey,
+    );
     // componentModuleProvider is used by Client 3D for read time resolvers.
     const component =
-      moduleImport.componentModuleProvider ??
-      RelayModernRecord.getValue(record, componentKey);
+      relayStoreComponent !== undefined
+        ? relayStoreComponent
+        : moduleImport.componentModuleProvider;
     if (component == null) {
       if (component === undefined) {
-        this._markDataAsMissing();
+        this._markDataAsMissing('<module-import>');
       }
       return;
     }
@@ -1189,6 +1413,39 @@ class RelayReader {
     data[MODULE_COMPONENT_KEY] = component;
   }
 
+  /**
+   * Aliased inline fragments allow the user to check if the data in an inline
+   * fragment was fetched. Data in the inline fragment can be conditional in the
+   * case of a type condition on the inline fragment or directives like `@skip`
+   * or `@include`.
+   *
+   * We model aliased inline fragments as a special reader node wrapped around a
+   * regular inline fragment reader node.
+   *
+   * This allows us to read the inline fragment as normal, check if it matched,
+   * and then define the alias to either contain the inline fragment's data, or
+   * null.
+   */
+  _readAliasedInlineFragment(
+    aliasedInlineFragment: ReaderAliasedInlineFragmentSpread,
+    record: Record,
+    data: SelectorData,
+  ) {
+    const prevErrors = this._fieldErrors;
+    this._fieldErrors = null;
+    let fieldValue = this._readInlineFragment(
+      aliasedInlineFragment.fragment,
+      record,
+      {},
+      true,
+    );
+    this._prependPreviousErrors(prevErrors, aliasedInlineFragment.name);
+    if (fieldValue === false) {
+      fieldValue = null;
+    }
+    data[aliasedInlineFragment.name] = fieldValue;
+  }
+
   // Has three possible return values:
   // * null: The type condition did not match
   // * undefined: We are missing data
@@ -1398,16 +1655,14 @@ class RelayReader {
       // fetched the `__is[AbstractType]` flag for this concrete type. In this
       // case we need to report that we are missing data, in case that field is
       // still in flight.
-      this._markDataAsMissing();
+      this._markDataAsMissing('<abstract-type-hint>');
     }
     // $FlowFixMe Casting record value
     return implementsInterface;
   }
 }
 
-function markFieldErrorHasHandled(
-  event: ErrorResponseField,
-): ErrorResponseField {
+function markFieldErrorHasHandled(event: FieldError): FieldError {
   switch (event.kind) {
     case 'missing_expected_data.throw':
     case 'missing_required_field.throw':