relay-runtime 13.0.3 → 13.2.0

package/store/RelayModernEnvironment.js.flow

@@ -342,7 +342,7 @@ class RelayModernEnvironment implements IEnvironment {
   |}): RelayObservable<GraphQLResponse> {
     return this._execute({
       createSource: () =>
-        this._network.execute(
+        this.getNetwork().execute(
           operation.request.node.params,
           operation.request.variables,
           operation.request.cacheConfig || {},
@@ -372,7 +372,7 @@ class RelayModernEnvironment implements IEnvironment {
   |}): RelayObservable<GraphQLResponse> {
     return this._execute({
       createSource: () =>
-        this._network.execute(
+        this.getNetwork().execute(
           operation.request.node.params,
           operation.request.variables,
           operation.request.cacheConfig || {},
@@ -412,7 +412,7 @@ class RelayModernEnvironment implements IEnvironment {
     }
     return this._execute({
       createSource: () =>
-        this._network.execute(
+        this.getNetwork().execute(
           operation.request.node.params,
           operation.request.variables,
           {

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/RelayModernSelector.js.flow

@@ -402,14 +402,7 @@ function getVariablesFromPluralFragment(
   return variables;
 }
 
-/**
- * @public
- *
- * Determine if two selectors are equal (represent the same selection). Note
- * that this function returns `false` when the two queries/fragments are
- * different objects, even if they select the same fields.
- */
-function areEqualSelectors(
+function areEqualSingularSelectors(
   thisSelector: SingularReaderSelector,
   thatSelector: SingularReaderSelector,
 ): boolean {
@@ -421,6 +414,37 @@ function areEqualSelectors(
   );
 }
 
+/**
+ * @public
+ *
+ * Determine if two selectors are equal (represent the same selection). Note
+ * that this function returns `false` when the two queries/fragments are
+ * different objects, even if they select the same fields.
+ */
+function areEqualSelectors(
+  a: ?(SingularReaderSelector | PluralReaderSelector),
+  b: ?(SingularReaderSelector | PluralReaderSelector),
+): boolean {
+  if (
+    a?.kind === 'SingularReaderSelector' &&
+    b?.kind === 'SingularReaderSelector'
+  ) {
+    return areEqualSingularSelectors(a, b);
+  } else if (
+    a?.kind === 'PluralReaderSelector' &&
+    b?.kind === 'PluralReaderSelector'
+  ) {
+    return (
+      a.selectors.length === b.selectors.length &&
+      a.selectors.every((s, i) => areEqualSingularSelectors(s, b.selectors[i]))
+    );
+  } else if (a == null && b == null) {
+    return true;
+  } else {
+    return false;
+  }
+}
+
 function createReaderSelector(
   fragment: ReaderFragment,
   dataID: DataID,

package/store/RelayReader.js.flow

@@ -22,6 +22,7 @@ import type {
   ReaderLinkedField,
   ReaderModuleImport,
   ReaderNode,
+  ReaderRelayLiveResolver,
   ReaderRelayResolver,
   ReaderRequiredField,
   ReaderScalarField,
@@ -35,6 +36,7 @@ import type {
   MissingRequiredFields,
   Record,
   RecordSource,
+  RelayResolverErrors,
   RequestDescriptor,
   SelectorData,
   SingularReaderSelector,
@@ -54,6 +56,7 @@ const {
   INLINE_FRAGMENT,
   LINKED_FIELD,
   MODULE_IMPORT,
+  RELAY_LIVE_RESOLVER,
   RELAY_RESOLVER,
   REQUIRED_FIELD,
   SCALAR_FIELD,
@@ -109,6 +112,7 @@ class RelayReader {
   _selector: SingularReaderSelector;
   _variables: Variables;
   _resolverCache: ResolverCache;
+  _resolverErrors: RelayResolverErrors;
   _fragmentName: string;
 
   constructor(
@@ -131,6 +135,7 @@ class RelayReader {
     this._selector = selector;
     this._variables = selector.variables;
     this._resolverCache = resolverCache;
+    this._resolverErrors = [];
     this._fragmentName = selector.node.name;
   }
 
@@ -204,6 +209,7 @@ class RelayReader {
       seenRecords: this._seenRecords,
       selector: this._selector,
       missingRequiredFields: this._missingRequiredFields,
+      relayResolverErrors: this._resolverErrors,
     };
   }
 
@@ -391,6 +397,13 @@ class RelayReader {
           }
           break;
         }
+        case RELAY_LIVE_RESOLVER: {
+          if (!RelayFeatureFlags.ENABLE_RELAY_RESOLVERS) {
+            throw new Error('Relay Resolver fields are not yet supported.');
+          }
+          this._readResolverField(selection, record, data);
+          break;
+        }
         case RELAY_RESOLVER: {
           if (!RelayFeatureFlags.ENABLE_RELAY_RESOLVERS) {
             throw new Error('Relay Resolver fields are not yet supported.');
@@ -496,6 +509,11 @@ class RelayReader {
           throw new Error('Relay Resolver fields are not yet supported.');
         }
         return this._readResolverField(selection.field, record, data);
+      case RELAY_LIVE_RESOLVER:
+        if (!RelayFeatureFlags.ENABLE_RELAY_RESOLVERS) {
+          throw new Error('Relay Resolver fields are not yet supported.');
+        }
+        return this._readResolverField(selection.field, record, data);
       default:
         (selection.field.kind: empty);
         invariant(
@@ -507,7 +525,7 @@ class RelayReader {
   }
 
   _readResolverField(
-    field: ReaderRelayResolver,
+    field: ReaderRelayResolver | ReaderRelayLiveResolver,
     record: Record,
     data: SelectorData,
   ): mixed {
@@ -525,6 +543,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 +562,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 +581,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/RelayResponseNormalizer.js.flow

@@ -86,7 +86,7 @@ const invariant = require('invariant');
 const warning = require('warning');
 
 export type GetDataID = (
-  fieldValue: interface {[string]: mixed},
+  fieldValue: {[string]: mixed},
   typeName: string,
 ) => mixed;
 

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

@@ -26,7 +26,6 @@ import type {
   UploadableMap,
 } from '../network/RelayNetworkTypes';
 import type RelayObservable from '../network/RelayObservable';
-import type {GraphQLTaggedNode} from '../query/GraphQLTag';
 import type {RequestIdentifier} from '../util/getRequestIdentifier';
 import type {
   NormalizationArgument,
@@ -44,8 +43,9 @@ import type {
   CacheConfig,
   DataID,
   Disposable,
-  OperationType,
   RenderPolicy,
+  UpdatableQuery,
+  UpdatableQueryType,
   Variables,
 } from '../util/RelayRuntimeTypes';
 import type {InvalidationState} from './RelayModernStore';
@@ -57,7 +57,7 @@ export type OperationTracker = RelayOperationTracker;
 
 export type MutationParameters = {|
   +response: {...},
-  +variables: interface {},
+  +variables: {...},
   +rawResponse?: {...},
 |};
 
@@ -112,14 +112,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 = {|
@@ -135,6 +135,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.
  */
@@ -145,6 +152,7 @@ export type Snapshot = {|
   +seenRecords: DataIDSet,
   +selector: SingularReaderSelector,
   +missingRequiredFields: ?MissingRequiredFields,
+  +relayResolverErrors: RelayResolverErrors,
 |};
 
 /**
@@ -466,8 +474,8 @@ export interface RecordSourceProxy {
   get(dataID: DataID): ?RecordProxy;
   getRoot(): RecordProxy;
   invalidateStore(): void;
-  readUpdatableQuery_EXPERIMENTAL<TQuery: OperationType>(
-    query: GraphQLTaggedNode,
+  readUpdatableQuery_EXPERIMENTAL<TQuery: UpdatableQueryType>(
+    query: UpdatableQuery<TQuery['variables'], TQuery['response']>,
     variables: TQuery['variables'],
   ): TQuery['response'];
 }
@@ -1072,6 +1080,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

@@ -29,7 +29,7 @@ const RelayConcreteNode = require('../util/RelayConcreteNode');
 const stableCopy = require('../util/stableCopy');
 const invariant = require('invariant');
 
-export type Arguments = interface {+[string]: mixed};
+export type Arguments = {+[string]: mixed};
 
 const {VARIABLE, LITERAL, OBJECT_VALUE, LIST_VALUE} = RelayConcreteNode;
 
@@ -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

@@ -12,19 +12,25 @@
 
 'use strict';
 
-import type {ReaderRelayResolver} from '../util/ReaderNode';
+import type {
+  ReaderRelayLiveResolver,
+  ReaderRelayResolver,
+} from '../util/ReaderNode';
 import type {DataID, Variables} from '../util/RelayRuntimeTypes';
 import type {
   MissingRequiredFields,
   MutableRecordSource,
   Record,
+  RelayResolverErrors,
   SingularReaderSelector,
 } from './RelayStoreTypes';
 
 const recycleNodesInto = require('../util/recycleNodesInto');
+const {RELAY_LIVE_RESOLVER} = require('../util/RelayConcreteNode');
 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,
@@ -32,6 +38,7 @@ const {
   RELAY_RESOLVER_VALUE_KEY,
   getStorageKey,
 } = require('./RelayStoreUtils');
+const invariant = require('invariant');
 const warning = require('warning');
 
 type ResolverID = string;
@@ -42,17 +49,23 @@ type EvaluationResult<T> = {|
   resolverID: ResolverID,
   seenRecordIDs: Set<DataID>,
   readerSelector: SingularReaderSelector,
+  errors: RelayResolverErrors,
   missingRequiredFields: ?MissingRequiredFields,
 |};
 
 export interface ResolverCache {
   readFromCacheOrEvaluate<T>(
     record: Record,
-    field: ReaderRelayResolver,
+    field: ReaderRelayResolver | ReaderRelayLiveResolver,
     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;
@@ -64,13 +77,22 @@ const emptySet: $ReadOnlySet<any> = new Set();
 class NoopResolverCache implements ResolverCache {
   readFromCacheOrEvaluate<T>(
     record: Record,
-    field: ReaderRelayResolver,
+    field: ReaderRelayResolver | ReaderRelayLiveResolver,
     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,
+  ] {
+    invariant(
+      field.kind !== RELAY_LIVE_RESOLVER,
+      'This store does not support Live Resolvers',
+    );
+    const {resolverResult, missingRequiredFields, errors} = evaluate();
+    return [resolverResult, undefined, errors, missingRequiredFields];
   }
   invalidateDataIDs(updatedDataIDs: Set<DataID>): void {}
 }
@@ -102,11 +124,16 @@ class RecordResolverCache implements ResolverCache {
 
   readFromCacheOrEvaluate<T>(
     record: Record,
-    field: ReaderRelayResolver,
+    field: ReaderRelayResolver | ReaderRelayLiveResolver,
     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 +169,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 +200,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/store/defaultGetDataID.js.flow

@@ -15,7 +15,7 @@
 const {VIEWER_ID, VIEWER_TYPE} = require('./ViewerPattern');
 
 function defaultGetDataID(
-  fieldValue: interface {[string]: mixed},
+  fieldValue: {[string]: mixed},
   typeName: string,
 ): mixed {
   if (typeName === VIEWER_TYPE) {