relay-runtime 18.2.0 → 19.0.0

package/store/RelayReader.js.flow

@@ -35,8 +35,8 @@ import type {DataID, Variables} from '../util/RelayRuntimeTypes';
 import type {
   ClientEdgeTraversalInfo,
   DataIDSet,
-  ErrorResponseField,
-  ErrorResponseFields,
+  FieldError,
+  FieldErrors,
   MissingClientEdgeRequestInfo,
   Record,
   RecordSource,
@@ -49,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');
@@ -98,7 +99,7 @@ class RelayReader {
   _missingClientEdges: Array<MissingClientEdgeRequestInfo>;
   _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
@@ -128,10 +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 ?? false;
+      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;
@@ -205,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) {
@@ -217,17 +221,21 @@ 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,
       });
     }
   }
@@ -236,22 +244,32 @@ class RelayReader {
     if (this._isWithinUnmatchedTypeRefinement) {
       return;
     }
-    if (this._errorResponseFields == null) {
-      this._errorResponseFields = [];
+    if (this._fieldErrors == null) {
+      this._fieldErrors = [];
     }
 
     // we will add the path later
     const owner = this._fragmentName;
 
-    this._errorResponseFields.push(
+    this._fieldErrors.push(
       this._selector.node.metadata?.throwOnFieldError ?? false
         ? {
             kind: 'missing_expected_data.throw',
             owner,
             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: fieldName},
+        : {
+            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;
@@ -282,6 +300,7 @@ class RelayReader {
       if (record === undefined) {
         this._markDataAsMissing('<record>');
       }
+      // $FlowFixMe[incompatible-return]
       return record;
     }
     const data = prevData || {};
@@ -308,8 +327,8 @@ class RelayReader {
     }
     const owner = this._fragmentName;
 
-    if (this._errorResponseFields == null) {
-      this._errorResponseFields = [];
+    if (this._fieldErrors == null) {
+      this._fieldErrors = [];
     }
 
     let fieldName: string;
@@ -322,18 +341,24 @@ class RelayReader {
 
     switch (selection.action) {
       case 'THROW':
-        this._errorResponseFields.push({
+        this._fieldErrors.push({
           kind: 'missing_required_field.throw',
           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: fieldName,
           owner,
+          // the uiContext is always undefined here.
+          // the loggingContext is provided by hooks - and assigned to uiContext in handlePotentialSnapshotErrors
+          uiContext: undefined,
         });
         return;
       default:
@@ -361,7 +386,7 @@ class RelayReader {
    * any fields within them.
    *
    * 1. Before traversing into the selection(s) marked as `@catch`, the caller
-   *   stores the previous field errors (`this._errorResponseFields`) in a
+   *   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
@@ -376,7 +401,7 @@ class RelayReader {
   _catchErrors<T>(
     _value: T,
     to: CatchFieldTo,
-    previousResponseFields: ?ErrorResponseFields,
+    previousResponseFields: ?FieldErrors,
   ): ?T | Result<T, mixed> {
     let value: T | null | Result<T, mixed> = _value;
     switch (to) {
@@ -384,10 +409,7 @@ class RelayReader {
         value = this._asResult(_value);
         break;
       case 'NULL':
-        if (
-          this._errorResponseFields != null &&
-          this._errorResponseFields.length > 0
-        ) {
+        if (this._fieldErrors != null && this._fieldErrors.length > 0) {
           value = null;
         }
         break;
@@ -395,22 +417,22 @@ class RelayReader {
         (to: empty);
     }
 
-    const childrenErrorResponseFields = this._errorResponseFields;
+    const childrenFieldErrors = this._fieldErrors;
 
-    this._errorResponseFields = previousResponseFields;
+    this._fieldErrors = previousResponseFields;
 
     // Merge any errors encountered within the @catch with the previous field
     // errors, but mark them as "handled" first.
-    if (childrenErrorResponseFields != null) {
-      if (this._errorResponseFields == null) {
-        this._errorResponseFields = [];
+    if (childrenFieldErrors != null) {
+      if (this._fieldErrors == null) {
+        this._fieldErrors = [];
       }
-      for (let i = 0; i < childrenErrorResponseFields.length; i++) {
+      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._errorResponseFields.push(
-          markFieldErrorHasHandled(childrenErrorResponseFields[i]),
+        this._fieldErrors.push(
+          markFieldErrorHasHandled(childrenFieldErrors[i]),
         );
       }
     }
@@ -419,21 +441,18 @@ class RelayReader {
 
   /**
    * Convert a value into a Result object based on the presence of errors in the
-   * `this._errorResponseFields` array.
+   * `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._errorResponseFields == null ||
-      this._errorResponseFields.length === 0
-    ) {
+    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
+    const errors = this._fieldErrors
       .map(error => {
         switch (error.kind) {
           case 'relay_field_payload.error':
@@ -461,7 +480,7 @@ class RelayReader {
             (error.kind: empty);
             invariant(
               false,
-              'Unexpected error errorResponseField kind: %s',
+              'Unexpected error fieldError kind: %s',
               error.kind,
             );
         }
@@ -491,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,
@@ -662,13 +681,31 @@ 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:
@@ -687,8 +724,8 @@ class RelayReader {
     data: SelectorData,
   ): mixed {
     const parentRecordID = RelayModernRecord.getDataID(record);
-    const prevErrors = this._errorResponseFields;
-    this._errorResponseFields = null;
+    const prevErrors = this._fieldErrors;
+    this._fieldErrors = null;
     const result = this._readResolverFieldImpl(field, parentRecordID);
 
     const fieldName = field.alias ?? field.name;
@@ -726,7 +763,7 @@ class RelayReader {
         return {
           data: snapshot.data,
           isMissingData: snapshot.isMissingData,
-          errorResponseFields: snapshot.errorResponseFields,
+          fieldErrors: snapshot.fieldErrors,
         };
       }
 
@@ -739,7 +776,7 @@ class RelayReader {
       return {
         data: snapshot.data,
         isMissingData: snapshot.isMissingData,
-        errorResponseFields: snapshot.errorResponseFields,
+        fieldErrors: snapshot.fieldErrors,
       };
     };
 
@@ -824,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);
         }
       }
@@ -833,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));
           }
         }
       }
@@ -864,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);
       }
     }
 
@@ -896,9 +944,11 @@ class RelayReader {
       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);
-      }
+      });
     }
   }
 
@@ -1068,8 +1118,8 @@ class RelayReader {
         RelayModernRecord.getDataID(record),
         prevData,
       );
-      const prevErrors = this._errorResponseFields;
-      this._errorResponseFields = null;
+      const prevErrors = this._fieldErrors;
+      this._fieldErrors = null;
       const edgeValue = this._traverse(
         field.linkedField,
         storeID,
@@ -1091,8 +1141,13 @@ class RelayReader {
     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(fieldName);
     }
@@ -1111,7 +1166,7 @@ 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(fieldName);
       }
@@ -1128,8 +1183,8 @@ class RelayReader {
       RelayModernRecord.getDataID(record),
       prevData,
     );
-    const prevErrors = this._errorResponseFields;
-    this._errorResponseFields = null;
+    const prevErrors = this._fieldErrors;
+    this._fieldErrors = null;
     // $FlowFixMe[incompatible-variance]
     const value = this._traverse(field, linkedID, prevData);
 
@@ -1139,7 +1194,7 @@ class RelayReader {
   }
 
   /**
-   * Adds a set of field errors to `this._errorResponseFields`, ensuring the
+   * Adds a set of field errors to `this._fieldErrors`, ensuring the
    * `fieldPath` property of existing field errors are prefixed with the given
    * `fieldNameOrIndex`.
    *
@@ -1158,8 +1213,8 @@ class RelayReader {
    * To achieve this, named field readers must do the following to correctly
    * track error filePaths:
    *
-   * 1. Stash the value of `this._errorResponseFields` in a local variable
-   * 2. Set `this._errorResponseFields` to `null`
+   * 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
    *
@@ -1171,12 +1226,12 @@ class RelayReader {
    * field error paths.
    */
   _prependPreviousErrors(
-    prevErrors: ?Array<ErrorResponseField>,
+    prevErrors: ?Array<FieldError>,
     fieldNameOrIndex: string | number,
   ): void {
-    if (this._errorResponseFields != null) {
-      for (let i = 0; i < this._errorResponseFields.length; i++) {
-        const event = this._errorResponseFields[i];
+    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' ||
@@ -1188,13 +1243,13 @@ class RelayReader {
         }
       }
       if (prevErrors != null) {
-        for (let i = this._errorResponseFields.length - 1; i >= 0; i--) {
-          prevErrors.push(this._errorResponseFields[i]);
+        for (let i = this._fieldErrors.length - 1; i >= 0; i--) {
+          prevErrors.push(this._fieldErrors[i]);
         }
-        this._errorResponseFields = prevErrors;
+        this._fieldErrors = prevErrors;
       }
     } else {
-      this._errorResponseFields = prevErrors;
+      this._fieldErrors = prevErrors;
     }
   }
 
@@ -1215,7 +1270,7 @@ class RelayReader {
       if (externalRef === undefined) {
         this._markDataAsMissing(fieldName);
       } else if (externalRef === null) {
-        this._maybeAddErrorResponseFields(record, storageKey);
+        this._maybeAddFieldErrors(record, storageKey);
       }
       return data[fieldName];
     }
@@ -1243,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);
   }
@@ -1274,8 +1334,8 @@ class RelayReader {
       RelayModernRecord.getDataID(record),
       prevData,
     );
-    const prevErrors = this._errorResponseFields;
-    this._errorResponseFields = null;
+    const prevErrors = this._fieldErrors;
+    this._fieldErrors = null;
     const linkedArray = prevData || [];
     linkedIDs.forEach((linkedID, nextIndex) => {
       if (linkedID == null) {
@@ -1295,8 +1355,8 @@ class RelayReader {
         RelayModernRecord.getDataID(record),
         prevItem,
       );
-      const prevErrors = this._errorResponseFields;
-      this._errorResponseFields = null;
+      const prevErrors = this._fieldErrors;
+      this._fieldErrors = null;
       // $FlowFixMe[cannot-write]
       // $FlowFixMe[incompatible-variance]
       linkedArray[nextIndex] = this._traverse(field, linkedID, prevItem);
@@ -1319,10 +1379,15 @@ 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('<module-import>');
@@ -1366,8 +1431,8 @@ class RelayReader {
     record: Record,
     data: SelectorData,
   ) {
-    const prevErrors = this._errorResponseFields;
-    this._errorResponseFields = null;
+    const prevErrors = this._fieldErrors;
+    this._fieldErrors = null;
     let fieldValue = this._readInlineFragment(
       aliasedInlineFragment.fragment,
       record,
@@ -1597,9 +1662,7 @@ class RelayReader {
   }
 }
 
-function markFieldErrorHasHandled(
-  event: ErrorResponseField,
-): ErrorResponseField {
+function markFieldErrorHasHandled(event: FieldError): FieldError {
   switch (event.kind) {
     case 'missing_expected_data.throw':
     case 'missing_required_field.throw':

package/store/RelayReferenceMarker.js.flow

@@ -38,7 +38,8 @@ const RelayStoreUtils = require('./RelayStoreUtils');
 const {generateTypeID} = require('./TypeID');
 const invariant = require('invariant');
 
-const {getStorageKey, getModuleOperationKey} = RelayStoreUtils;
+const {getReadTimeResolverStorageKey, getStorageKey, getModuleOperationKey} =
+  RelayStoreUtils;
 
 function mark(
   recordSource: RecordSource,
@@ -216,8 +217,6 @@ class RelayReferenceMarker {
           this._traverseSelections(selection.fragment.selections, record);
           break;
         case 'RelayResolver':
-          this._traverseResolverField(selection, record);
-          break;
         case 'RelayLiveResolver':
           this._traverseResolverField(selection, record);
           break;
@@ -291,7 +290,7 @@ class RelayReferenceMarker {
     field: NormalizationResolverField | NormalizationLiveResolverField,
     record: Record,
   ): ?DataID {
-    const storageKey = getStorageKey(field, this._variables);
+    const storageKey = getReadTimeResolverStorageKey(field, this._variables);
     const dataID = RelayModernRecord.getLinkedRecordID(record, storageKey);
 
     // If the resolver value has been created, we should retain it.