relay-runtime 0.0.0-main-2abce249 → 0.0.0-main-f74fe29f

package/store/RelayReader.js.flow

@@ -43,7 +43,7 @@ import type {
   SingularReaderSelector,
   Snapshot,
 } from './RelayStoreTypes';
-import type {ResolverCache} from './ResolverCache';
+import type {EvaluationResult, ResolverCache} from './ResolverCache';
 
 const {
   ACTOR_CHANGE,
@@ -536,54 +536,26 @@ class RelayReader {
     // Found when reading the resolver fragment, which can happen either when
     // evaluating the resolver and it calls readFragment, or when checking if the
     // inputs have changed since a previous evaluation:
-    let fragmentValue;
-    let fragmentReaderSelector;
-    let fragmentMissingRequiredFields: ?MissingRequiredFields;
-    let previousMissingRequriedFields: ?MissingRequiredFields;
-
-    let currentResolverErrors: RelayResolverErrors = [];
-    let previousResolverErrors: RelayResolverErrors;
-    const fragmentSeenRecordIDs = new Set();
+    let snapshot: ?Snapshot;
 
     const getDataForResolverFragment = singularReaderSelector => {
-      if (fragmentValue != null) {
+      if (snapshot != null) {
         // It was already read when checking for input staleness; no need to read it again.
         // Note that the variables like fragmentSeenRecordIDs in the outer closure will have
         // already been set and will still be used in this case.
-        return fragmentValue;
-      }
-      fragmentReaderSelector = singularReaderSelector;
-      const existingSeenRecords = this._seenRecords;
-      try {
-        this._seenRecords = fragmentSeenRecordIDs;
-        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,
-          `Expected reader data to contain a __fragments property with a property for the fragment named ${fragment.name}, but it is missing.`,
-        );
-        return fragmentValue;
-      } finally {
-        this._seenRecords = existingSeenRecords;
-        this._missingRequiredFields = previousMissingRequriedFields;
-        this._resolverErrors = previousResolverErrors;
+        return snapshot.data;
       }
+
+      snapshot = read(
+        this._recordSource,
+        singularReaderSelector,
+        this._resolverCache,
+      );
+      return snapshot.data;
     };
     const resolverContext = {getDataForResolverFragment};
 
-    const evaluate = () => {
+    const evaluate = (): EvaluationResult<mixed> => {
       const key = {
         __id: RelayModernRecord.getDataID(record),
         __fragmentOwner: this._owner,
@@ -593,30 +565,29 @@ class RelayReader {
       };
       return withResolverContext(resolverContext, () => {
         let resolverResult = null;
+        let resolverError = 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({
+          resolverError = {
             field: {path, owner: this._fragmentName},
             error: e,
-          });
+          };
         }
+
         return {
           resolverResult,
-          errors: currentResolverErrors,
-          fragmentValue,
+          snapshot: snapshot,
           resolverID,
-          seenRecordIDs: fragmentSeenRecordIDs,
-          readerSelector: fragmentReaderSelector,
-          missingRequiredFields: fragmentMissingRequiredFields,
+          error: resolverError,
         };
       });
     };
 
-    const [result, seenRecord, resolverErrors, missingRequiredFields] =
+    const [result, seenRecord, resolverError, cachedSnapshot] =
       this._resolverCache.readFromCacheOrEvaluate(
         record,
         field,
@@ -625,11 +596,22 @@ class RelayReader {
         getDataForResolverFragment,
       );
 
-    for (const resolverError of resolverErrors) {
-      this._resolverErrors.push(resolverError);
+    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);
+        }
+      }
+      for (const error of cachedSnapshot.relayResolverErrors) {
+        this._resolverErrors.push(error);
+      }
+      this._isMissingData = this._isMissingData || cachedSnapshot.isMissingData;
     }
-    if (missingRequiredFields != null) {
-      this._addMissingRequiredFields(missingRequiredFields);
+    if (resolverError) {
+      this._resolverErrors.push(resolverError);
     }
     if (seenRecord != null) {
       this._seenRecords.add(seenRecord);

package/store/RelayStoreUtils.js.flow

@@ -217,9 +217,7 @@ const RelayStoreUtils = {
   IS_WITHIN_UNMATCHED_TYPE_REFINEMENT: '__isWithinUnmatchedTypeRefinement',
   RELAY_RESOLVER_VALUE_KEY: '__resolverValue',
   RELAY_RESOLVER_INVALIDATION_KEY: '__resolverValueMayBeInvalid',
-  RELAY_RESOLVER_INPUTS_KEY: '__resolverInputValues',
-  RELAY_RESOLVER_READER_SELECTOR_KEY: '__resolverReaderSelector',
-  RELAY_RESOLVER_MISSING_REQUIRED_FIELDS_KEY: '__resolverMissingRequiredFields',
+  RELAY_RESOLVER_SNAPSHOT_KEY: '__resolverSnapshot',
   RELAY_RESOLVER_ERROR_KEY: '__resolverError',
 
   formatStorageKey,

package/store/ResolverCache.js.flow

@@ -18,11 +18,11 @@ import type {
 } from '../util/ReaderNode';
 import type {DataID, Variables} from '../util/RelayRuntimeTypes';
 import type {
-  MissingRequiredFields,
   MutableRecordSource,
   Record,
-  RelayResolverErrors,
+  RelayResolverError,
   SingularReaderSelector,
+  Snapshot,
 } from './RelayStoreTypes';
 
 const recycleNodesInto = require('../util/recycleNodesInto');
@@ -31,10 +31,8 @@ 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,
-  RELAY_RESOLVER_READER_SELECTOR_KEY,
+  RELAY_RESOLVER_SNAPSHOT_KEY,
   RELAY_RESOLVER_VALUE_KEY,
   getStorageKey,
 } = require('./RelayStoreUtils');
@@ -43,14 +41,11 @@ const warning = require('warning');
 
 type ResolverID = string;
 
-type EvaluationResult<T> = {|
+export type EvaluationResult<T> = {|
   resolverResult: T,
-  fragmentValue: {...},
   resolverID: ResolverID,
-  seenRecordIDs: Set<DataID>,
-  readerSelector: SingularReaderSelector,
-  errors: RelayResolverErrors,
-  missingRequiredFields: ?MissingRequiredFields,
+  snapshot: ?Snapshot,
+  error: ?RelayResolverError,
 |};
 
 export interface ResolverCache {
@@ -63,8 +58,8 @@ export interface ResolverCache {
   ): [
     T /* Answer */,
     ?DataID /* Seen record */,
-    RelayResolverErrors,
-    ?MissingRequiredFields,
+    ?RelayResolverError,
+    ?Snapshot,
   ];
   invalidateDataIDs(
     updatedDataIDs: Set<DataID>, // Mutated in place
@@ -85,15 +80,16 @@ class NoopResolverCache implements ResolverCache {
   ): [
     T /* Answer */,
     ?DataID /* Seen record */,
-    RelayResolverErrors,
-    ?MissingRequiredFields,
+    ?RelayResolverError,
+    ?Snapshot,
   ] {
     invariant(
       field.kind !== RELAY_LIVE_RESOLVER,
       'This store does not support Live Resolvers',
     );
-    const {resolverResult, missingRequiredFields, errors} = evaluate();
-    return [resolverResult, undefined, errors, missingRequiredFields];
+    const {resolverResult, snapshot, error} = evaluate();
+
+    return [resolverResult, undefined, error, snapshot];
   }
   invalidateDataIDs(updatedDataIDs: Set<DataID>): void {}
   createClientRecord(id: string, typeName: string): string {
@@ -138,8 +134,8 @@ class RecordResolverCache implements ResolverCache {
   ): [
     T /* Answer */,
     ?DataID /* Seen record */,
-    RelayResolverErrors,
-    ?MissingRequiredFields,
+    ?RelayResolverError,
+    ?Snapshot,
   ] {
     const recordSource = this._getRecordSource();
     const recordID = RelayModernRecord.getDataID(record);
@@ -163,23 +159,13 @@ class RecordResolverCache implements ResolverCache {
       );
       RelayModernRecord.setValue(
         linkedRecord,
-        RELAY_RESOLVER_INPUTS_KEY,
-        evaluationResult.fragmentValue,
-      );
-      RelayModernRecord.setValue(
-        linkedRecord,
-        RELAY_RESOLVER_READER_SELECTOR_KEY,
-        evaluationResult.readerSelector,
-      );
-      RelayModernRecord.setValue(
-        linkedRecord,
-        RELAY_RESOLVER_MISSING_REQUIRED_FIELDS_KEY,
-        evaluationResult.missingRequiredFields,
+        RELAY_RESOLVER_SNAPSHOT_KEY,
+        evaluationResult.snapshot,
       );
       RelayModernRecord.setValue(
         linkedRecord,
         RELAY_RESOLVER_ERROR_KEY,
-        evaluationResult.errors,
+        evaluationResult.error,
       );
       recordSource.set(linkedID, linkedRecord);
 
@@ -192,25 +178,26 @@ class RecordResolverCache implements ResolverCache {
       const resolverID = evaluationResult.resolverID;
       addDependencyEdge(this._resolverIDToRecordIDs, resolverID, linkedID);
       addDependencyEdge(this._recordIDToResolverIDs, recordID, resolverID);
-      for (const seenRecordID of evaluationResult.seenRecordIDs) {
-        addDependencyEdge(
-          this._recordIDToResolverIDs,
-          seenRecordID,
-          resolverID,
-        );
+      const seenRecordIds = evaluationResult.snapshot?.seenRecords;
+      if (seenRecordIds != null) {
+        for (const seenRecordID of seenRecordIds) {
+          addDependencyEdge(
+            this._recordIDToResolverIDs,
+            seenRecordID,
+            resolverID,
+          );
+        }
       }
     }
 
     // $FlowFixMe[incompatible-type] - will always be empty
     const answer: T = linkedRecord[RELAY_RESOLVER_VALUE_KEY];
-
-    const missingRequiredFields: ?MissingRequiredFields =
-      // $FlowFixMe[incompatible-type] - casting mixed
-      linkedRecord[RELAY_RESOLVER_MISSING_REQUIRED_FIELDS_KEY];
-
     // $FlowFixMe[incompatible-type] - casting mixed
-    const errors: RelayResolverErrors = linkedRecord[RELAY_RESOLVER_ERROR_KEY];
-    return [answer, linkedID, errors, missingRequiredFields];
+    const snapshot: ?Snapshot = linkedRecord[RELAY_RESOLVER_SNAPSHOT_KEY];
+    // $FlowFixMe[incompatible-type] - casting mixed
+    const error: ?RelayResolverError = linkedRecord[RELAY_RESOLVER_ERROR_KEY];
+
+    return [answer, linkedID, error, snapshot];
   }
 
   invalidateDataIDs(
@@ -272,15 +259,13 @@ class RecordResolverCache implements ResolverCache {
     if (!RelayModernRecord.getValue(record, RELAY_RESOLVER_INVALIDATION_KEY)) {
       return false;
     }
-    const originalInputs = RelayModernRecord.getValue(
-      record,
-      RELAY_RESOLVER_INPUTS_KEY,
-    );
     // $FlowFixMe[incompatible-type] - storing values in records is not typed
-    const readerSelector: ?SingularReaderSelector = RelayModernRecord.getValue(
+    const snapshot: ?Snapshot = RelayModernRecord.getValue(
       record,
-      RELAY_RESOLVER_READER_SELECTOR_KEY,
+      RELAY_RESOLVER_SNAPSHOT_KEY,
     );
+    const originalInputs = snapshot?.data;
+    const readerSelector: ?SingularReaderSelector = snapshot?.selector;
     if (originalInputs == null || readerSelector == null) {
       warning(
         false,

package/store/experimental-live-resolvers/LiveResolverCache.js.flow

@@ -18,13 +18,13 @@ import type {
 } from '../../util/ReaderNode';
 import type {DataID, Variables} from '../../util/RelayRuntimeTypes';
 import type {
-  MissingRequiredFields,
   MutableRecordSource,
   Record,
-  RelayResolverErrors,
+  RelayResolverError,
   SingularReaderSelector,
+  Snapshot,
 } from '../RelayStoreTypes';
-import type {ResolverCache} from '../ResolverCache';
+import type {EvaluationResult, ResolverCache} from '../ResolverCache';
 import type {LiveState} from './LiveResolverStore';
 
 const recycleNodesInto = require('../../util/recycleNodesInto');
@@ -34,10 +34,8 @@ const RelayModernRecord = require('../RelayModernRecord');
 const RelayRecordSource = require('../RelayRecordSource');
 const {
   RELAY_RESOLVER_ERROR_KEY,
-  RELAY_RESOLVER_INPUTS_KEY,
   RELAY_RESOLVER_INVALIDATION_KEY,
-  RELAY_RESOLVER_MISSING_REQUIRED_FIELDS_KEY,
-  RELAY_RESOLVER_READER_SELECTOR_KEY,
+  RELAY_RESOLVER_SNAPSHOT_KEY,
   RELAY_RESOLVER_VALUE_KEY,
   getStorageKey,
 } = require('../RelayStoreUtils');
@@ -59,16 +57,6 @@ const RELAY_RESOLVER_LIVE_STATE_DIRTY = '__resolverLiveStateDirty';
 
 type ResolverID = string;
 
-type EvaluationResult<T> = {|
-  resolverResult: T,
-  fragmentValue: {...},
-  resolverID: ResolverID,
-  seenRecordIDs: Set<DataID>,
-  readerSelector: SingularReaderSelector,
-  errors: RelayResolverErrors,
-  missingRequiredFields: ?MissingRequiredFields,
-|};
-
 // $FlowFixMe[unclear-type] - will always be empty
 const emptySet: $ReadOnlySet<any> = new Set();
 
@@ -111,8 +99,8 @@ class LiveResolverCache implements ResolverCache {
   ): [
     T /* Answer */,
     ?DataID /* Seen record */,
-    RelayResolverErrors,
-    ?MissingRequiredFields,
+    ?RelayResolverError,
+    ?Snapshot,
   ] {
     const recordSource = this._getRecordSource();
     const recordID = RelayModernRecord.getDataID(record);
@@ -151,23 +139,13 @@ class LiveResolverCache implements ResolverCache {
       }
       RelayModernRecord.setValue(
         linkedRecord,
-        RELAY_RESOLVER_INPUTS_KEY,
-        evaluationResult.fragmentValue,
-      );
-      RelayModernRecord.setValue(
-        linkedRecord,
-        RELAY_RESOLVER_READER_SELECTOR_KEY,
-        evaluationResult.readerSelector,
-      );
-      RelayModernRecord.setValue(
-        linkedRecord,
-        RELAY_RESOLVER_MISSING_REQUIRED_FIELDS_KEY,
-        evaluationResult.missingRequiredFields,
+        RELAY_RESOLVER_SNAPSHOT_KEY,
+        evaluationResult.snapshot,
       );
       RelayModernRecord.setValue(
         linkedRecord,
         RELAY_RESOLVER_ERROR_KEY,
-        evaluationResult.errors,
+        evaluationResult.error,
       );
       recordSource.set(linkedID, linkedRecord);
 
@@ -180,12 +158,15 @@ class LiveResolverCache implements ResolverCache {
       const resolverID = evaluationResult.resolverID;
       addDependencyEdge(this._resolverIDToRecordIDs, resolverID, linkedID);
       addDependencyEdge(this._recordIDToResolverIDs, recordID, resolverID);
-      for (const seenRecordID of evaluationResult.seenRecordIDs) {
-        addDependencyEdge(
-          this._recordIDToResolverIDs,
-          seenRecordID,
-          resolverID,
-        );
+      const seenRecordIds = evaluationResult.snapshot?.seenRecords;
+      if (seenRecordIds != null) {
+        for (const seenRecordID of seenRecordIds) {
+          addDependencyEdge(
+            this._recordIDToResolverIDs,
+            seenRecordID,
+            resolverID,
+          );
+        }
       }
     } else if (
       field.kind === RELAY_LIVE_RESOLVER &&
@@ -219,14 +200,12 @@ class LiveResolverCache implements ResolverCache {
 
     // $FlowFixMe[incompatible-type] - will always be empty
     const answer: T = linkedRecord[RELAY_RESOLVER_VALUE_KEY];
-
-    const missingRequiredFields: ?MissingRequiredFields =
-      // $FlowFixMe[incompatible-type] - casting mixed
-      linkedRecord[RELAY_RESOLVER_MISSING_REQUIRED_FIELDS_KEY];
-
     // $FlowFixMe[incompatible-type] - casting mixed
-    const errors: RelayResolverErrors = linkedRecord[RELAY_RESOLVER_ERROR_KEY];
-    return [answer, linkedID, errors, missingRequiredFields];
+    const snapshot: ?Snapshot = linkedRecord[RELAY_RESOLVER_SNAPSHOT_KEY];
+    // $FlowFixMe[incompatible-type] - casting mixed
+    const error: ?RelayResolverError = linkedRecord[RELAY_RESOLVER_ERROR_KEY];
+
+    return [answer, linkedID, error, snapshot];
   }
 
   // Register a new Live State object in the store, subscribing to future
@@ -371,15 +350,13 @@ class LiveResolverCache implements ResolverCache {
     if (!RelayModernRecord.getValue(record, RELAY_RESOLVER_INVALIDATION_KEY)) {
       return false;
     }
-    const originalInputs = RelayModernRecord.getValue(
-      record,
-      RELAY_RESOLVER_INPUTS_KEY,
-    );
     // $FlowFixMe[incompatible-type] - storing values in records is not typed
-    const readerSelector: ?SingularReaderSelector = RelayModernRecord.getValue(
+    const snapshot: ?Snapshot = RelayModernRecord.getValue(
       record,
-      RELAY_RESOLVER_READER_SELECTOR_KEY,
+      RELAY_RESOLVER_SNAPSHOT_KEY,
     );
+    const originalInputs = snapshot?.data;
+    const readerSelector: ?SingularReaderSelector = snapshot?.selector;
     if (originalInputs == null || readerSelector == null) {
       warning(
         false,