relay-runtime 0.0.0-main-b6199194 → 0.0.0-main-042ceca3

package/store/RelayErrorTrie.js.flow

@@ -16,16 +16,6 @@ import type {PayloadError} from '../network/RelayNetworkTypes';
 // $FlowFixMe[recursive-definition]
 const SELF: Self = Symbol('$SELF');
 
-class RelayFieldError extends Error {
-  constructor(message: string, errors: Array<TRelayFieldErrorForDisplay> = []) {
-    super(message);
-    this.name = 'RelayFieldError';
-    this.message = message;
-    this.errors = errors;
-  }
-  errors: Array<TRelayFieldErrorForDisplay>;
-}
-
 export opaque type Self = typeof SELF;
 
 export type TRelayFieldErrorForDisplay = $ReadOnly<{
@@ -180,11 +170,9 @@ module.exports = ({
   buildErrorTrie,
   getNestedErrorTrieByKey,
   getErrorsByKey,
-  RelayFieldError,
 }: {
   SELF: typeof SELF,
   buildErrorTrie: typeof buildErrorTrie,
   getNestedErrorTrieByKey: typeof getNestedErrorTrieByKey,
   getErrorsByKey: typeof getErrorsByKey,
-  RelayFieldError: Class<RelayFieldError>,
 });

package/store/RelayModernFragmentSpecResolver.js.flow

@@ -19,7 +19,6 @@ import type {
   FragmentSpecResolver,
   FragmentSpecResults,
   IEnvironment,
-  MissingRequiredFields,
   PluralReaderSelector,
   RelayContext,
   SelectorData,
@@ -227,7 +226,6 @@ class SelectorResolver {
   _data: ?SelectorData;
   _environment: IEnvironment;
   _isMissingData: boolean;
-  _missingRequiredFields: ?MissingRequiredFields;
   _errorResponseFields: ?ErrorResponseFields;
   _rootIsQueryRenderer: boolean;
   _selector: SingularReaderSelector;
@@ -244,7 +242,6 @@ class SelectorResolver {
     this._callback = callback;
     this._data = snapshot.data;
     this._isMissingData = snapshot.isMissingData;
-    this._missingRequiredFields = snapshot.missingRequiredFields;
     this._errorResponseFields = snapshot.errorResponseFields;
     this._environment = environment;
     this._rootIsQueryRenderer = rootIsQueryRenderer;
@@ -326,12 +323,7 @@ class SelectorResolver {
         }
       }
     }
-    handlePotentialSnapshotErrors(
-      this._environment,
-      this._missingRequiredFields,
-      this._errorResponseFields,
-      this._selector.node.metadata?.throwOnFieldError ?? false,
-    );
+    handlePotentialSnapshotErrors(this._environment, this._errorResponseFields);
     return this._data;
   }
 
@@ -346,7 +338,6 @@ class SelectorResolver {
     const snapshot = this._environment.lookup(selector);
     this._data = recycleNodesInto(this._data, snapshot.data);
     this._isMissingData = snapshot.isMissingData;
-    this._missingRequiredFields = snapshot.missingRequiredFields;
     this._errorResponseFields = snapshot.errorResponseFields;
     this._selector = selector;
     this._subscription = this._environment.subscribe(snapshot, this._onChange);
@@ -383,7 +374,6 @@ class SelectorResolver {
   _onChange = (snapshot: Snapshot): void => {
     this._data = snapshot.data;
     this._isMissingData = snapshot.isMissingData;
-    this._missingRequiredFields = snapshot.missingRequiredFields;
     this._errorResponseFields = snapshot.errorResponseFields;
     this._callback();
   };

package/store/RelayReader.js.flow

@@ -35,7 +35,6 @@ import type {
   ErrorResponseFields,
   MissingClientEdgeRequestInfo,
   MissingLiveResolverField,
-  MissingRequiredFields,
   Record,
   RecordSource,
   RequestDescriptor,
@@ -99,7 +98,6 @@ class RelayReader {
   _missingClientEdges: Array<MissingClientEdgeRequestInfo>;
   _missingLiveResolverFields: Array<MissingLiveResolverField>;
   _isWithinUnmatchedTypeRefinement: boolean;
-  _missingRequiredFields: ?MissingRequiredFields;
   _errorResponseFields: ?ErrorResponseFields;
   _owner: RequestDescriptor;
   _recordSource: RecordSource;
@@ -124,7 +122,6 @@ class RelayReader {
     this._missingLiveResolverFields = [];
     this._isMissingData = false;
     this._isWithinUnmatchedTypeRefinement = false;
-    this._missingRequiredFields = null;
     this._errorResponseFields = null;
     this._owner = selector.owner;
     this._recordSource = recordSource;
@@ -193,7 +190,6 @@ class RelayReader {
       missingLiveResolverFields: this._missingLiveResolverFields,
       seenRecords: this._seenRecords,
       selector: this._selector,
-      missingRequiredFields: this._missingRequiredFields,
       errorResponseFields: this._errorResponseFields,
     };
   }
@@ -216,6 +212,7 @@ class RelayReader {
         fieldPath: (error.path ?? []).join('.'),
         error,
         shouldThrow: this._selector.node.metadata?.throwOnFieldError ?? false,
+        handled: false,
       });
     }
   }
@@ -231,7 +228,12 @@ class RelayReader {
 
     this._errorResponseFields.push(
       this._selector.node.metadata?.throwOnFieldError ?? false
-        ? {kind: 'missing_expected_data.throw', owner, fieldPath}
+        ? {
+            kind: 'missing_expected_data.throw',
+            owner,
+            fieldPath,
+            handled: false,
+          }
         : {kind: 'missing_expected_data.log', owner, fieldPath},
     );
 
@@ -284,33 +286,27 @@ class RelayReader {
   }
 
   _maybeReportUnexpectedNull(fieldPath: string, action: 'LOG' | 'THROW') {
-    if (this._missingRequiredFields?.action === 'THROW') {
-      // Chained @required directives may cause a parent `@required(action:
-      // THROW)` field to become null, so the first missing field we
-      // encounter is likely to be the root cause of the error.
-      return;
-    }
     const owner = this._fragmentName;
 
+    if (this._errorResponseFields == null) {
+      this._errorResponseFields = [];
+    }
+
     switch (action) {
       case 'THROW':
-        this._missingRequiredFields = {action, field: {path: fieldPath, owner}};
+        this._errorResponseFields.push({
+          kind: 'missing_required_field.throw',
+          fieldPath,
+          owner,
+          handled: false,
+        });
         return;
       case 'LOG':
-        if (this._missingRequiredFields == null) {
-          this._missingRequiredFields = {
-            action,
-            fields: [{path: fieldPath, owner}],
-          };
-        } else {
-          this._missingRequiredFields = {
-            action,
-            fields: [
-              ...this._missingRequiredFields.fields,
-              {path: fieldPath, owner},
-            ],
-          };
-        }
+        this._errorResponseFields.push({
+          kind: 'missing_required_field.log',
+          fieldPath,
+          owner,
+        });
         return;
       default:
         (action: empty);
@@ -333,43 +329,40 @@ class RelayReader {
       "Couldn't determine field name for this field. It might be a ReaderClientExtension - which is not yet supported.",
     );
 
-    let errors = this._errorResponseFields?.map(error => {
-      switch (error.kind) {
-        case 'relay_field_payload.error':
-          const {message, ...displayError} = error.error;
-          return displayError;
-        case 'missing_expected_data.throw':
-        case 'missing_expected_data.log':
-          return {
-            path: error.fieldPath.split('.'),
-          };
-        case 'relay_resolver.error':
-          return {
-            message: `Relay: Error in resolver for field at ${error.fieldPath} in ${error.owner}`,
-          };
-        default:
-          (error.kind: empty);
-          invariant(
-            false,
-            'Unexpected error errorResponseField kind: %s',
-            error.kind,
-          );
-      }
-    });
-
-    // If we have a nested @required(THROW) that will throw,
-    // we want to catch that error and provide it
-    if (this._missingRequiredFields?.action === 'THROW') {
-      const {owner, path} = this._missingRequiredFields.field;
-      const missingFieldError = {
-        message: `Relay: Missing @required value at path '${path}' in '${owner}'.`,
-      };
-      if (errors == null) {
-        errors = [missingFieldError];
-      } else {
-        errors.push(missingFieldError);
-      }
-    }
+    const errors = this._errorResponseFields
+      ?.map(error => {
+        switch (error.kind) {
+          case 'relay_field_payload.error':
+            const {message, ...displayError} = error.error;
+            return displayError;
+          case 'missing_expected_data.throw':
+          case 'missing_expected_data.log':
+            return {
+              path: error.fieldPath.split('.'),
+            };
+          case 'relay_resolver.error':
+            return {
+              message: `Relay: Error in resolver for field at ${error.fieldPath} in ${error.owner}`,
+            };
+          case 'missing_required_field.throw':
+            // If we have a nested @required(THROW) that will throw,
+            // we want to catch that error and provide it
+            return {
+              message: `Relay: Missing @required value at path '${error.fieldPath}' in '${error.owner}'.`,
+            };
+          case 'missing_required_field.log':
+            // For backwards compatibility, we don't surface log level missing required fields
+            return null;
+          default:
+            (error.kind: empty);
+            invariant(
+              false,
+              'Unexpected error errorResponseField kind: %s',
+              error.kind,
+            );
+        }
+      })
+      .filter(Boolean);
 
     data[fieldName] = errors != null ? {ok: false, errors} : {ok: true, value};
   }
@@ -412,10 +405,8 @@ class RelayReader {
           break;
         case 'CatchField': {
           const previousResponseFields = this._errorResponseFields;
-          const previousMissingRequiredFields = this._missingRequiredFields;
 
           this._errorResponseFields = null;
-          this._missingRequiredFields = null;
 
           const catchFieldValue = this._readClientSideDirectiveField(
             selection,
@@ -427,15 +418,23 @@ class RelayReader {
             this._handleCatchToResult(selection, record, data, catchFieldValue);
           }
 
-          const childrenMissingRequiredFields = this._missingRequiredFields;
+          const childrenErrorResponseFields = this._errorResponseFields;
 
           this._errorResponseFields = previousResponseFields;
-          this._missingRequiredFields = previousMissingRequiredFields;
 
           // If we encountered non-throwing @required fields, in the children,
           // we want to preserve those errors in the snapshot.
-          if (childrenMissingRequiredFields?.action === 'LOG') {
-            this._addMissingRequiredFields(childrenMissingRequiredFields);
+          if (childrenErrorResponseFields != null) {
+            for (let i = 0; i < childrenErrorResponseFields.length; i++) {
+              const event = childrenErrorResponseFields[i];
+              if (event.kind === 'missing_required_field.log') {
+                if (this._errorResponseFields == null) {
+                  this._errorResponseFields = [event];
+                } else {
+                  this._errorResponseFields.push(event);
+                }
+              }
+            }
           }
 
           break;
@@ -647,7 +646,7 @@ class RelayReader {
         return {
           data: snapshot.data,
           isMissingData: snapshot.isMissingData,
-          missingRequiredFields: snapshot.missingRequiredFields,
+          errorResponseFields: snapshot.errorResponseFields,
         };
       }
 
@@ -660,7 +659,7 @@ class RelayReader {
       return {
         data: snapshot.data,
         isMissingData: snapshot.isMissingData,
-        missingRequiredFields: snapshot.missingRequiredFields,
+        errorResponseFields: snapshot.errorResponseFields,
       };
     };
 
@@ -744,9 +743,6 @@ class RelayReader {
     // errors, or be in a suspended state. Here we propagate those cases
     // upwards to mimic the behavior of having traversed into that fragment directly.
     if (cachedSnapshot != null) {
-      if (cachedSnapshot.missingRequiredFields != null) {
-        this._addMissingRequiredFields(cachedSnapshot.missingRequiredFields);
-      }
       if (cachedSnapshot.missingClientEdges != null) {
         for (const missing of cachedSnapshot.missingClientEdges) {
           this._missingClientEdges.push(missing);
@@ -767,9 +763,13 @@ class RelayReader {
         }
         for (const error of cachedSnapshot.errorResponseFields) {
           // TODO: In reality we should propagate _all_ errors, but
-          // for now we're only propagating resolver errors for backwards
-          // compatibility with previous behavior.
-          if (error.kind === 'relay_resolver.error') {
+          // for now we're only propagating resolver errors and missing field
+          // errors for backwards compatibility with previous behavior.
+          if (
+            error.kind === 'relay_resolver.error' ||
+            error.kind === 'missing_required_field.throw' ||
+            error.kind === 'missing_required_field.log'
+          ) {
             this._errorResponseFields.push(error);
           }
         }
@@ -789,6 +789,7 @@ class RelayReader {
         shouldThrow:
           this._selector.node.metadata?.throwOnFieldError ??
           RelayFeatureFlags.ENABLE_FIELD_ERROR_HANDLING_THROW_BY_DEFAULT,
+        handled: false,
       };
       if (this._errorResponseFields == null) {
         this._errorResponseFields = [errorEvent];
@@ -1392,26 +1393,6 @@ class RelayReader {
     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],
-    };
-  }
-
   _implementsInterface(record: Record, abstractKey: string): ?boolean {
     const typeName = RelayModernRecord.getType(record);
     const typeRecord = this._recordSource.get(generateTypeID(typeName));

package/store/RelayStoreSubscriptions.js.flow

@@ -115,7 +115,6 @@ class RelayStoreSubscriptions implements StoreSubscriptions {
           missingLiveResolverFields: backup.missingLiveResolverFields,
           seenRecords: backup.seenRecords,
           selector: backup.selector,
-          missingRequiredFields: backup.missingRequiredFields,
           errorResponseFields: backup.errorResponseFields,
         };
       } else {
@@ -186,7 +185,6 @@ class RelayStoreSubscriptions implements StoreSubscriptions {
       missingLiveResolverFields: nextSnapshot.missingLiveResolverFields,
       seenRecords: nextSnapshot.seenRecords,
       selector: nextSnapshot.selector,
-      missingRequiredFields: nextSnapshot.missingRequiredFields,
       errorResponseFields: nextSnapshot.errorResponseFields,
     }: Snapshot);
     if (__DEV__) {

package/store/RelayStoreTypes.js.flow

@@ -116,22 +116,15 @@ export type NormalizationSelector = {
   +variables: Variables,
 };
 
-type FieldLocation = {
-  path: string,
-  owner: string,
-};
-
-export type MissingRequiredFields = $ReadOnly<
-  | {action: 'THROW', field: FieldLocation}
-  | {action: 'LOG', fields: Array<FieldLocation>},
->;
-
-export type ErrorResponseFields = Array<
+export type ErrorResponseField =
   | RelayFieldPayloadErrorEvent
   | MissingExpectedDataLogEvent
   | MissingExpectedDataThrowEvent
-  | RelayResolverErrorEvent,
->;
+  | RelayResolverErrorEvent
+  | MissingRequiredFieldLogEvent
+  | MissingRequiredFieldThrowEvent;
+
+export type ErrorResponseFields = Array<ErrorResponseField>;
 
 export type ClientEdgeTraversalInfo = {
   +readerClientEdge: ReaderClientEdgeToServerObject,
@@ -161,7 +154,6 @@ export type Snapshot = {
   +missingClientEdges: null | $ReadOnlyArray<MissingClientEdgeRequestInfo>,
   +seenRecords: DataIDSet,
   +selector: SingularReaderSelector,
-  +missingRequiredFields: ?MissingRequiredFields,
   +errorResponseFields: ?ErrorResponseFields,
 };
 
@@ -1292,18 +1284,23 @@ export type MissingExpectedDataLogEvent = {
  *
  * Relay will throw immediately after logging this event. If you wish to
  * customize the error being thrown, you may throw your own error.
+ *
+ * *NOTE*: Only throw on this event if `handled` is false. Errors that have been
+ * handled by a `@catch` directive or by making a resolver null will have
+ * `handled: true` and should not trigger a throw.
  */
 export type MissingExpectedDataThrowEvent = {
   +kind: 'missing_expected_data.throw',
   +owner: string,
   +fieldPath: string,
+  +handled: boolean,
 };
 
 /**
  * A field was marked as @required(action: LOG) but was null or missing in the
  * store.
  */
-export type MissingFieldLogEvent = {
+export type MissingRequiredFieldLogEvent = {
   +kind: 'missing_required_field.log',
   +owner: string,
   +fieldPath: string,
@@ -1315,11 +1312,16 @@ export type MissingFieldLogEvent = {
  *
  * Relay will throw immediately after logging this event. If you wish to
  * customize the error being thrown, you may throw your own error.
+ *
+ * *NOTE*: Only throw on this event if `handled` is false. Errors that have been
+ * handled by a `@catch` directive or by making a resolver null will have
+ * `handled: true` and should not trigger a throw.
  */
-export type MissingFieldThrowEvent = {
+export type MissingRequiredFieldThrowEvent = {
   +kind: 'missing_required_field.throw',
   +owner: string,
   +fieldPath: string,
+  +handled: boolean,
 };
 
 /**
@@ -1329,6 +1331,10 @@ export type MissingFieldThrowEvent = {
  *
  * If `@throwOnFieldError` was used on the parent query/fragment/mutation, you
  * will also receive a TODO
+ *
+ * *NOTE*: Only throw on this event if `handled` is false. Errors that have been
+ * handled by a `@catch` directive or by making a resolver null will have
+ * `handled: true` and should not trigger a throw.
  */
 export type RelayResolverErrorEvent = {
   +kind: 'relay_resolver.error',
@@ -1336,6 +1342,7 @@ export type RelayResolverErrorEvent = {
   +fieldPath: string,
   +error: Error,
   +shouldThrow: boolean,
+  +handled: boolean,
 };
 
 /**
@@ -1350,6 +1357,10 @@ export type RelayResolverErrorEvent = {
  *
  * https://relay.dev/docs/next/guides/catch-directive/
  * https://relay.dev/docs/next/guides/throw-on-field-error-directive/
+ *
+ * *NOTE*: Only throw on this event if `handled` is false. Errors that have been
+ * handled by a `@catch` directive or by making a resolver null will have
+ * `handled: true` and should not trigger a throw.
  */
 export type RelayFieldPayloadErrorEvent = {
   +kind: 'relay_field_payload.error',
@@ -1357,6 +1368,7 @@ export type RelayFieldPayloadErrorEvent = {
   +fieldPath: string,
   +error: TRelayFieldError,
   +shouldThrow: boolean,
+  +handled: boolean,
 };
 
 /**
@@ -1365,8 +1377,8 @@ export type RelayFieldPayloadErrorEvent = {
 export type RelayFieldLoggerEvent =
   | MissingExpectedDataLogEvent
   | MissingExpectedDataThrowEvent
-  | MissingFieldLogEvent
-  | MissingFieldThrowEvent
+  | MissingRequiredFieldLogEvent
+  | MissingRequiredFieldThrowEvent
   | RelayResolverErrorEvent
   | RelayFieldPayloadErrorEvent;
 

package/store/ResolverCache.js.flow

@@ -11,7 +11,6 @@
 
 'use strict';
 
-import type {MissingRequiredFields} from '..';
 import type {
   ReaderRelayLiveResolver,
   ReaderRelayResolver,
@@ -19,6 +18,7 @@ import type {
 import type {DataID, Variables} from '../util/RelayRuntimeTypes';
 import type {
   DataIDSet,
+  ErrorResponseFields,
   MutableRecordSource,
   Record,
   SingularReaderSelector,
@@ -52,7 +52,7 @@ export type EvaluationResult<T> = {
 export type ResolverFragmentResult = {
   data: mixed,
   isMissingData: boolean,
-  missingRequiredFields: ?MissingRequiredFields,
+  errorResponseFields: ?ErrorResponseFields,
 };
 
 export type GetDataForResolverFragmentFn =

package/store/ResolverFragments.js.flow

@@ -111,13 +111,16 @@ function readFragment(
     fragmentSelector.kind === 'SingularReaderSelector',
     `Expected a singular reader selector for the fragment of the resolver ${fragmentNode.name}, but it was plural.`,
   );
-  const {data, isMissingData, missingRequiredFields} =
+  const {data, isMissingData, errorResponseFields} =
     context.getDataForResolverFragment(fragmentSelector, fragmentKey);
 
   if (
     isMissingData ||
-    (missingRequiredFields != null && missingRequiredFields.action === 'THROW')
-    // TODO: Also consider @throwOnFieldError
+    (errorResponseFields != null &&
+      errorResponseFields.some(
+        // TODO: Also consider @throwOnFieldError
+        event => event.kind === 'missing_required_field.throw',
+      ))
   ) {
     throw RESOLVER_FRAGMENT_ERRORED_SENTINEL;
   }

package/store/observeFragmentExperimental.js.flow

@@ -210,12 +210,7 @@ function snapshotToFragmentState<TFragmentType: FragmentType, TData>(
   }
 
   try {
-    handlePotentialSnapshotErrors(
-      environment,
-      snapshot.missingRequiredFields,
-      snapshot.errorResponseFields,
-      snapshot.selector.node.metadata?.throwOnFieldError ?? false,
-    );
+    handlePotentialSnapshotErrors(environment, snapshot.errorResponseFields);
   } catch (error) {
     return {error, state: 'error'};
   }