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

package/util/handlePotentialSnapshotErrors.js.flow

@@ -11,19 +11,17 @@
 
 'use strict';
 
-import type {TRelayFieldErrorForDisplay} from '../store/RelayErrorTrie';
 import type {
+  ErrorResponseField,
   ErrorResponseFields,
   IEnvironment,
-  MissingRequiredFields,
 } from '../store/RelayStoreTypes';
 
-const {RelayFieldError} = require('../store/RelayErrorTrie');
+const invariant = require('invariant');
 
 function handleFieldErrors(
   environment: IEnvironment,
   errorResponseFields: ErrorResponseFields,
-  shouldThrow: boolean,
 ) {
   for (const fieldError of errorResponseFields) {
     // First we log all events. Note that the logger may opt to throw its own
@@ -32,79 +30,66 @@ function handleFieldErrors(
     environment.relayFieldLogger(fieldError);
   }
 
-  // when a user adds the throwOnFieldError flag, they opt into also throwing on missing fields.
-  if (shouldThrow) {
-    throw new RelayFieldError(
-      `Relay: Unexpected response payload - this object includes an errors property in which you can access the underlying errors`,
-      errorResponseFields.map((event): TRelayFieldErrorForDisplay => {
-        switch (event.kind) {
-          case 'relay_field_payload.error':
-            //TODO: [relay] Provide a payloadErrorResolver to allow exposing custom error shape.
-            const {message, ...displayError} = event.error;
-            return displayError;
-          case 'missing_expected_data.throw':
-            return {path: event.fieldPath.split('.')};
-          case 'missing_expected_data.log':
-            return {path: event.fieldPath.split('.')};
-          case 'relay_resolver.error':
-            return {path: event.fieldPath.split('.')};
-          default:
-            (event.kind: empty);
-            throw new Error('Relay: Unexpected event kind');
-        }
-      }),
-    );
+  for (const fieldError of errorResponseFields) {
+    if (eventShouldThrow(fieldError)) {
+      switch (fieldError.kind) {
+        case 'relay_resolver.error':
+          throw new Error(
+            `Relay: Resolver error at path '${fieldError.fieldPath}' in '${fieldError.owner}'.`,
+          );
+        case 'relay_field_payload.error':
+          throw new Error(
+            `Relay: Unexpected response payload - this object includes an errors property in which you can access the underlying errors`,
+          );
+        case 'missing_expected_data.throw':
+          throw new Error(
+            `Relay: Missing expected data at path '${fieldError.fieldPath}' in '${fieldError.owner}'.`,
+          );
+        case 'missing_required_field.throw':
+          throw new Error(
+            `Relay: Missing @required value at path '${fieldError.fieldPath}' in '${fieldError.owner}'.`,
+          );
+        case 'missing_required_field.log':
+        case 'missing_expected_data.log':
+          // These should have already been filtered out. Sadly, Flow Type
+          // Guards don't work well with refining discriminated unions, so we
+          // can't assert this via types.
+          break;
+        default:
+          (fieldError.kind: empty);
+          invariant(false, 'Relay: Unexpected event kind: %s', fieldError.kind);
+      }
+    }
   }
 }
 
-function handleMissingRequiredFields(
-  environment: IEnvironment,
-  missingRequiredFields: MissingRequiredFields,
-) {
-  switch (missingRequiredFields.action) {
-    case 'THROW': {
-      const {path, owner} = missingRequiredFields.field;
-      // This gives the consumer the chance to throw their own error if they so wish.
-      environment.relayFieldLogger({
-        kind: 'missing_required_field.throw',
-        owner,
-        fieldPath: path,
-      });
-      throw new Error(
-        `Relay: Missing @required value at path '${path}' in '${owner}'.`,
-      );
-    }
-    case 'LOG':
-      missingRequiredFields.fields.forEach(({path, owner}) => {
-        environment.relayFieldLogger({
-          kind: 'missing_required_field.log',
-          owner,
-          fieldPath: path,
-        });
-      });
-      break;
-    default: {
-      (missingRequiredFields.action: empty);
-    }
+function eventShouldThrow(event: ErrorResponseField): boolean {
+  switch (event.kind) {
+    case 'relay_resolver.error':
+    case 'relay_field_payload.error':
+      return event.shouldThrow && !event.handled;
+    case 'missing_expected_data.throw':
+    case 'missing_required_field.throw':
+      return !event.handled;
+    case 'missing_required_field.log':
+    case 'missing_expected_data.log':
+      return false;
+    default:
+      (event.kind: empty);
+      throw new Error('Relay: Unexpected event kind');
   }
 }
 
 function handlePotentialSnapshotErrors(
   environment: IEnvironment,
-  missingRequiredFields: ?MissingRequiredFields,
   errorResponseFields: ?ErrorResponseFields,
-  throwOnFieldError: boolean,
 ) {
-  if (missingRequiredFields != null) {
-    handleMissingRequiredFields(environment, missingRequiredFields);
-  }
-
   /**
    * Inside handleFieldErrors, we check for throwOnFieldError - but this fn logs the error anyway by default
    * which is why this still should run in any case there's errors.
    */
   if (errorResponseFields != null) {
-    handleFieldErrors(environment, errorResponseFields, throwOnFieldError);
+    handleFieldErrors(environment, errorResponseFields);
   }
 }