relay-runtime 0.0.0-main-98162d36 → 0.0.0-main-47d9d202

package/store/RelayModernFragmentSpecResolver.js.flow

@@ -22,16 +22,17 @@ import type {
   MissingRequiredFields,
   PluralReaderSelector,
   RelayContext,
+  RelayResolverErrors,
   SelectorData,
   SingularReaderSelector,
   Snapshot,
 } from './RelayStoreTypes';
 
 const getPendingOperationsForFragment = require('../util/getPendingOperationsForFragment');
+const handlePotentialSnapshotErrors = require('../util/handlePotentialSnapshotErrors');
 const isScalarAndEqual = require('../util/isScalarAndEqual');
 const recycleNodesInto = require('../util/recycleNodesInto');
 const RelayFeatureFlags = require('../util/RelayFeatureFlags');
-const reportMissingRequiredFields = require('../util/reportMissingRequiredFields');
 const {createRequestDescriptor} = require('./RelayModernOperationDescriptor');
 const {
   areEqualSelectors,
@@ -228,6 +229,7 @@ class SelectorResolver {
   _environment: IEnvironment;
   _isMissingData: boolean;
   _missingRequiredFields: ?MissingRequiredFields;
+  _relayResolverErrors: RelayResolverErrors;
   _rootIsQueryRenderer: boolean;
   _selector: SingularReaderSelector;
   _subscription: ?Disposable;
@@ -244,6 +246,7 @@ class SelectorResolver {
     this._data = snapshot.data;
     this._isMissingData = snapshot.isMissingData;
     this._missingRequiredFields = snapshot.missingRequiredFields;
+    this._relayResolverErrors = snapshot.relayResolverErrors;
     this._environment = environment;
     this._rootIsQueryRenderer = rootIsQueryRenderer;
     this._selector = selector;
@@ -324,12 +327,11 @@ class SelectorResolver {
         }
       }
     }
-    if (this._missingRequiredFields != null) {
-      reportMissingRequiredFields(
-        this._environment,
-        this._missingRequiredFields,
-      );
-    }
+    handlePotentialSnapshotErrors(
+      this._environment,
+      this._missingRequiredFields,
+      this._relayResolverErrors,
+    );
     return this._data;
   }
 
@@ -345,6 +347,7 @@ class SelectorResolver {
     this._data = recycleNodesInto(this._data, snapshot.data);
     this._isMissingData = snapshot.isMissingData;
     this._missingRequiredFields = snapshot.missingRequiredFields;
+    this._relayResolverErrors = snapshot.relayResolverErrors;
     this._selector = selector;
     this._subscription = this._environment.subscribe(snapshot, this._onChange);
   }
@@ -381,6 +384,7 @@ class SelectorResolver {
     this._data = snapshot.data;
     this._isMissingData = snapshot.isMissingData;
     this._missingRequiredFields = snapshot.missingRequiredFields;
+    this._relayResolverErrors = snapshot.relayResolverErrors;
     this._callback();
   };
 }

package/store/RelayReader.js.flow

@@ -35,6 +35,7 @@ import type {
   MissingRequiredFields,
   Record,
   RecordSource,
+  RelayResolverErrors,
   RequestDescriptor,
   SelectorData,
   SingularReaderSelector,
@@ -109,6 +110,7 @@ class RelayReader {
   _selector: SingularReaderSelector;
   _variables: Variables;
   _resolverCache: ResolverCache;
+  _resolverErrors: RelayResolverErrors;
   _fragmentName: string;
 
   constructor(
@@ -131,6 +133,7 @@ class RelayReader {
     this._selector = selector;
     this._variables = selector.variables;
     this._resolverCache = resolverCache;
+    this._resolverErrors = [];
     this._fragmentName = selector.node.name;
   }
 
@@ -204,6 +207,7 @@ class RelayReader {
       seenRecords: this._seenRecords,
       selector: this._selector,
       missingRequiredFields: this._missingRequiredFields,
+      relayResolverErrors: this._resolverErrors,
     };
   }
 
@@ -525,6 +529,9 @@ class RelayReader {
     let fragmentReaderSelector;
     let fragmentMissingRequiredFields: ?MissingRequiredFields;
     let previousMissingRequriedFields: ?MissingRequiredFields;
+
+    let currentResolverErrors: RelayResolverErrors;
+    let previousResolverErrors: RelayResolverErrors;
     const fragmentSeenRecordIDs = new Set();
 
     const getDataForResolverFragment = singularReaderSelector => {
@@ -541,12 +548,16 @@ class RelayReader {
         const resolverFragmentData = {};
         previousMissingRequriedFields = this._missingRequiredFields;
         this._missingRequiredFields = null;
+
+        previousResolverErrors = this._resolverErrors;
+        this._resolverErrors = [];
         this._createInlineDataOrResolverFragmentPointer(
           singularReaderSelector.node,
           record,
           resolverFragmentData,
         );
         fragmentMissingRequiredFields = this._missingRequiredFields;
+        currentResolverErrors = this._resolverErrors;
         fragmentValue = resolverFragmentData[FRAGMENTS_KEY]?.[fragment.name];
         invariant(
           typeof fragmentValue === 'object' && fragmentValue !== null,
@@ -556,39 +567,56 @@ class RelayReader {
       } finally {
         this._seenRecords = existingSeenRecords;
         this._missingRequiredFields = previousMissingRequriedFields;
+        this._resolverErrors = previousResolverErrors;
       }
     };
     const resolverContext = {getDataForResolverFragment};
 
-    const [result, seenRecord, missingRequiredFields] =
+    const evaluate = () => {
+      const key = {
+        __id: RelayModernRecord.getDataID(record),
+        __fragmentOwner: this._owner,
+        __fragments: {
+          [fragment.name]: {}, // Arguments to this fragment; not yet supported.
+        },
+      };
+      return withResolverContext(resolverContext, () => {
+        let resolverResult = null;
+        try {
+          // $FlowFixMe[prop-missing] - resolver module's type signature is a lie
+          resolverResult = resolverModule(key);
+        } catch (e) {
+          // `field.path` is typed as nullable while we rollout compiler changes.
+          const path = field.path ?? '[UNKNOWN]';
+          currentResolverErrors.push({
+            field: {path, owner: this._fragmentName},
+            error: e,
+          });
+        }
+        return {
+          resolverResult,
+          errors: currentResolverErrors,
+          fragmentValue,
+          resolverID,
+          seenRecordIDs: fragmentSeenRecordIDs,
+          readerSelector: fragmentReaderSelector,
+          missingRequiredFields: fragmentMissingRequiredFields,
+        };
+      });
+    };
+
+    const [result, seenRecord, resolverErrors, 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.
-            },
-          };
-          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,
-            };
-          });
-        },
+        evaluate,
         getDataForResolverFragment,
       );
 
+    for (const resolverError of resolverErrors) {
+      this._resolverErrors.push(resolverError);
+    }
     if (missingRequiredFields != null) {
       this._addMissingRequiredFields(missingRequiredFields);
     }

package/store/RelayStoreSubscriptions.js.flow

@@ -105,6 +105,7 @@ class RelayStoreSubscriptions implements StoreSubscriptions {
           seenRecords: backup.seenRecords,
           selector: backup.selector,
           missingRequiredFields: backup.missingRequiredFields,
+          relayResolverErrors: backup.relayResolverErrors,
         };
       } else {
         subscription.stale = true;
@@ -167,6 +168,7 @@ class RelayStoreSubscriptions implements StoreSubscriptions {
       seenRecords: nextSnapshot.seenRecords,
       selector: nextSnapshot.selector,
       missingRequiredFields: nextSnapshot.missingRequiredFields,
+      relayResolverErrors: nextSnapshot.relayResolverErrors,
     }: Snapshot);
     if (__DEV__) {
       deepFreeze(nextSnapshot);

package/store/RelayStoreTypes.js.flow

@@ -113,14 +113,14 @@ export type NormalizationSelector = {|
   +variables: Variables,
 |};
 
-type MissingRequiredField = {|
+type FieldLocation = {|
   path: string,
   owner: string,
 |};
 
 export type MissingRequiredFields = $ReadOnly<
-  | {|action: 'THROW', field: MissingRequiredField|}
-  | {|action: 'LOG', fields: Array<MissingRequiredField>|},
+  | {|action: 'THROW', field: FieldLocation|}
+  | {|action: 'LOG', fields: Array<FieldLocation>|},
 >;
 
 export type ClientEdgeTraversalInfo = {|
@@ -136,6 +136,13 @@ export type MissingClientEdgeRequestInfo = {|
   +clientEdgeDestinationID: DataID,
 |};
 
+export type RelayResolverError = {|
+  field: FieldLocation,
+  error: Error,
+|};
+
+export type RelayResolverErrors = Array<RelayResolverError>;
+
 /**
  * A representation of a selector and its results at a particular point in time.
  */
@@ -146,6 +153,7 @@ export type Snapshot = {|
   +seenRecords: DataIDSet,
   +selector: SingularReaderSelector,
   +missingRequiredFields: ?MissingRequiredFields,
+  +relayResolverErrors: RelayResolverErrors,
 |};
 
 /**
@@ -1073,6 +1081,12 @@ export type RequiredFieldLogger = (
       +kind: 'missing_field.throw',
       +owner: string,
       +fieldPath: string,
+    |}
+  | {|
+      +kind: 'relay_resolver.error',
+      +owner: string,
+      +fieldPath: string,
+      +error: Error,
     |},
 ) => void;
 

package/store/RelayStoreUtils.js.flow

@@ -220,6 +220,7 @@ const RelayStoreUtils = {
   RELAY_RESOLVER_INPUTS_KEY: '__resolverInputValues',
   RELAY_RESOLVER_READER_SELECTOR_KEY: '__resolverReaderSelector',
   RELAY_RESOLVER_MISSING_REQUIRED_FIELDS_KEY: '__resolverMissingRequiredFields',
+  RELAY_RESOLVER_ERROR_KEY: '__resolverError',
 
   formatStorageKey,
   getArgumentValue,

package/store/ResolverCache.js.flow

@@ -18,6 +18,7 @@ import type {
   MissingRequiredFields,
   MutableRecordSource,
   Record,
+  RelayResolverErrors,
   SingularReaderSelector,
 } from './RelayStoreTypes';
 
@@ -25,6 +26,7 @@ const recycleNodesInto = require('../util/recycleNodesInto');
 const {generateClientID} = require('./ClientID');
 const RelayModernRecord = require('./RelayModernRecord');
 const {
+  RELAY_RESOLVER_ERROR_KEY,
   RELAY_RESOLVER_INPUTS_KEY,
   RELAY_RESOLVER_INVALIDATION_KEY,
   RELAY_RESOLVER_MISSING_REQUIRED_FIELDS_KEY,
@@ -42,6 +44,7 @@ type EvaluationResult<T> = {|
   resolverID: ResolverID,
   seenRecordIDs: Set<DataID>,
   readerSelector: SingularReaderSelector,
+  errors: RelayResolverErrors,
   missingRequiredFields: ?MissingRequiredFields,
 |};
 
@@ -52,7 +55,12 @@ export interface ResolverCache {
     variables: Variables,
     evaluate: () => EvaluationResult<T>,
     getDataForResolverFragment: (SingularReaderSelector) => mixed,
-  ): [T /* Answer */, ?DataID /* Seen record */, ?MissingRequiredFields];
+  ): [
+    T /* Answer */,
+    ?DataID /* Seen record */,
+    RelayResolverErrors,
+    ?MissingRequiredFields,
+  ];
   invalidateDataIDs(
     updatedDataIDs: Set<DataID>, // Mutated in place
   ): void;
@@ -68,9 +76,14 @@ class NoopResolverCache implements ResolverCache {
     variables: Variables,
     evaluate: () => EvaluationResult<T>,
     getDataForResolverFragment: SingularReaderSelector => mixed,
-  ): [T /* Answer */, ?DataID /* Seen record */, ?MissingRequiredFields] {
-    const {resolverResult, missingRequiredFields} = evaluate();
-    return [resolverResult, undefined, missingRequiredFields];
+  ): [
+    T /* Answer */,
+    ?DataID /* Seen record */,
+    RelayResolverErrors,
+    ?MissingRequiredFields,
+  ] {
+    const {resolverResult, missingRequiredFields, errors} = evaluate();
+    return [resolverResult, undefined, errors, missingRequiredFields];
   }
   invalidateDataIDs(updatedDataIDs: Set<DataID>): void {}
 }
@@ -106,7 +119,12 @@ class RecordResolverCache implements ResolverCache {
     variables: Variables,
     evaluate: () => EvaluationResult<T>,
     getDataForResolverFragment: SingularReaderSelector => mixed,
-  ): [T /* Answer */, ?DataID /* Seen record */, ?MissingRequiredFields] {
+  ): [
+    T /* Answer */,
+    ?DataID /* Seen record */,
+    RelayResolverErrors,
+    ?MissingRequiredFields,
+  ] {
     const recordSource = this._getRecordSource();
     const recordID = RelayModernRecord.getDataID(record);
 
@@ -142,6 +160,11 @@ class RecordResolverCache implements ResolverCache {
         RELAY_RESOLVER_MISSING_REQUIRED_FIELDS_KEY,
         evaluationResult.missingRequiredFields,
       );
+      RelayModernRecord.setValue(
+        linkedRecord,
+        RELAY_RESOLVER_ERROR_KEY,
+        evaluationResult.errors,
+      );
       recordSource.set(linkedID, linkedRecord);
 
       // Link the resolver value record to the resolver field of the record being read:
@@ -168,7 +191,10 @@ class RecordResolverCache implements ResolverCache {
     const missingRequiredFields: ?MissingRequiredFields =
       // $FlowFixMe[incompatible-type] - casting mixed
       linkedRecord[RELAY_RESOLVER_MISSING_REQUIRED_FIELDS_KEY];
-    return [answer, linkedID, missingRequiredFields];
+
+    // $FlowFixMe[incompatible-type] - casting mixed
+    const errors: RelayResolverErrors = linkedRecord[RELAY_RESOLVER_ERROR_KEY];
+    return [answer, linkedID, errors, missingRequiredFields];
   }
 
   invalidateDataIDs(

package/util/handlePotentialSnapshotErrors.js.flow

@@ -0,0 +1,63 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow
+ * @emails oncall+relay
+ * @format
+ */
+
+'use strict';
+
+import type {
+  IEnvironment,
+  MissingRequiredFields,
+  RelayResolverErrors,
+} from '../store/RelayStoreTypes';
+
+function handlePotentialSnapshotErrors(
+  environment: IEnvironment,
+  missingRequiredFields: ?MissingRequiredFields,
+  relayResolverErrors: RelayResolverErrors,
+) {
+  for (const resolverError of relayResolverErrors) {
+    environment.requiredFieldLogger({
+      kind: 'relay_resolver.error',
+      owner: resolverError.field.owner,
+      fieldPath: resolverError.field.path,
+      error: resolverError.error,
+    });
+  }
+  if (missingRequiredFields != null) {
+    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.requiredFieldLogger({
+          kind: 'missing_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.requiredFieldLogger({
+            kind: 'missing_field.log',
+            owner,
+            fieldPath: path,
+          });
+        });
+        break;
+      default: {
+        (missingRequiredFields.action: empty);
+      }
+    }
+  }
+}
+
+module.exports = handlePotentialSnapshotErrors;

package/lib/util/reportMissingRequiredFields.js

@@ -1,48 +0,0 @@
-/**
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- *
- * 
- * @emails oncall+relay
- * @format
- */
-'use strict';
-
-function reportMissingRequiredFields(environment, missingRequiredFields) {
-  switch (missingRequiredFields.action) {
-    case 'THROW':
-      {
-        var _missingRequiredField = missingRequiredFields.field,
-            path = _missingRequiredField.path,
-            owner = _missingRequiredField.owner; // This gives the consumer the chance to throw their own error if they so wish.
-
-        environment.requiredFieldLogger({
-          kind: 'missing_field.throw',
-          owner: owner,
-          fieldPath: path
-        });
-        throw new Error("Relay: Missing @required value at path '".concat(path, "' in '").concat(owner, "'."));
-      }
-
-    case 'LOG':
-      missingRequiredFields.fields.forEach(function (_ref) {
-        var path = _ref.path,
-            owner = _ref.owner;
-        environment.requiredFieldLogger({
-          kind: 'missing_field.log',
-          owner: owner,
-          fieldPath: path
-        });
-      });
-      break;
-
-    default:
-      {
-        missingRequiredFields.action;
-      }
-  }
-}
-
-module.exports = reportMissingRequiredFields;

package/util/reportMissingRequiredFields.js.flow

@@ -1,51 +0,0 @@
-/**
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- *
- * @flow
- * @emails oncall+relay
- * @format
- */
-
-'use strict';
-
-import type {
-  IEnvironment,
-  MissingRequiredFields,
-} from '../store/RelayStoreTypes';
-
-function reportMissingRequiredFields(
-  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.requiredFieldLogger({
-        kind: 'missing_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.requiredFieldLogger({
-          kind: 'missing_field.log',
-          owner,
-          fieldPath: path,
-        });
-      });
-      break;
-    default: {
-      (missingRequiredFields.action: empty);
-    }
-  }
-}
-
-module.exports = reportMissingRequiredFields;