relay-runtime 18.1.0 → 19.0.0

package/store/ResolverCache.js.flow

@@ -18,30 +18,13 @@ import type {
 import type {DataID, Variables} from '../util/RelayRuntimeTypes';
 import type {
   DataIDSet,
-  ErrorResponseFields,
-  MutableRecordSource,
-  Record,
+  FieldErrors,
   SingularReaderSelector,
   Snapshot,
 } from './RelayStoreTypes';
 
-const recycleNodesInto = require('../util/recycleNodesInto');
 const {RELAY_LIVE_RESOLVER} = require('../util/RelayConcreteNode');
-const RelayFeatureFlags = require('../util/RelayFeatureFlags');
-const shallowFreeze = require('../util/shallowFreeze');
-const {generateClientID} = require('./ClientID');
-const RelayModernRecord = require('./RelayModernRecord');
-const {
-  RELAY_RESOLVER_ERROR_KEY,
-  RELAY_RESOLVER_INVALIDATION_KEY,
-  RELAY_RESOLVER_SNAPSHOT_KEY,
-  RELAY_RESOLVER_VALUE_KEY,
-  getStorageKey,
-} = require('./RelayStoreUtils');
 const invariant = require('invariant');
-const warning = require('warning');
-
-type ResolverID = string;
 
 export type EvaluationResult<T> = {
   resolverResult: ?T,
@@ -52,7 +35,7 @@ export type EvaluationResult<T> = {
 export type ResolverFragmentResult = {
   data: mixed,
   isMissingData: boolean,
-  errorResponseFields: ?ErrorResponseFields,
+  fieldErrors: ?FieldErrors,
 };
 
 export type GetDataForResolverFragmentFn =
@@ -80,9 +63,6 @@ export interface ResolverCache {
   notifyUpdatedSubscribers(updatedDataIDs: DataIDSet): void;
 }
 
-// $FlowFixMe[unclear-type] - will always be empty
-const emptySet: $ReadOnlySet<any> = new Set();
-
 class NoopResolverCache implements ResolverCache {
   readFromCacheOrEvaluate<T>(
     recordID: DataID,
@@ -116,255 +96,6 @@ class NoopResolverCache implements ResolverCache {
   notifyUpdatedSubscribers(updatedDataIDs: DataIDSet): void {}
 }
 
-function addDependencyEdge(
-  edges: Map<ResolverID, Set<DataID>> | Map<DataID, Set<ResolverID>>,
-  from: ResolverID | DataID,
-  to: ResolverID | DataID,
-): void {
-  let set = edges.get(from);
-  if (!set) {
-    set = new Set();
-    edges.set(from, set);
-  }
-  set.add(to);
-}
-
-class RecordResolverCache implements ResolverCache {
-  _resolverIDToRecordIDs: Map<ResolverID, Set<DataID>>;
-  _recordIDToResolverIDs: Map<DataID, Set<ResolverID>>;
-
-  _getRecordSource: () => MutableRecordSource;
-
-  constructor(getRecordSource: () => MutableRecordSource) {
-    this._resolverIDToRecordIDs = new Map();
-    this._recordIDToResolverIDs = new Map();
-    this._getRecordSource = getRecordSource;
-  }
-
-  readFromCacheOrEvaluate<T>(
-    recordID: DataID,
-    field: ReaderRelayResolver | ReaderRelayLiveResolver,
-    variables: Variables,
-    evaluate: () => EvaluationResult<T>,
-    getDataForResolverFragment: GetDataForResolverFragmentFn,
-  ): [
-    ?T /* Answer */,
-    ?DataID /* Seen record */,
-    ?Error,
-    ?Snapshot,
-    ?DataID /* ID of record containing a suspended Live field */,
-    ?DataIDSet /** Set of dirty records after read */,
-  ] {
-    const recordSource = this._getRecordSource();
-
-    // NOTE: Be very careful with `record` in this scope. After `evaluate` has
-    // been called, the `record` we have here may have been replaced in the
-    // Relay store with a new record containing new information about nested
-    // resolvers on this parent record.
-    const record = recordSource.get(recordID);
-    invariant(record != null, 'We expect record to exist in the store.');
-
-    const storageKey = getStorageKey(field, variables);
-    let linkedID = RelayModernRecord.getLinkedRecordID(record, storageKey);
-    let linkedRecord = linkedID == null ? null : recordSource.get(linkedID);
-    if (
-      linkedRecord == null ||
-      this._isInvalid(linkedRecord, getDataForResolverFragment)
-    ) {
-      // Cache miss; evaluate the selector and store the result in a new record:
-      linkedID = linkedID ?? generateClientID(recordID, storageKey);
-      linkedRecord = RelayModernRecord.create(linkedID, '__RELAY_RESOLVER__');
-
-      const evaluationResult = evaluate();
-      shallowFreeze(evaluationResult.resolverResult);
-      RelayModernRecord.setValue(
-        linkedRecord,
-        RELAY_RESOLVER_VALUE_KEY,
-        evaluationResult.resolverResult,
-      );
-      RelayModernRecord.setValue(
-        linkedRecord,
-        RELAY_RESOLVER_SNAPSHOT_KEY,
-        evaluationResult.snapshot,
-      );
-      RelayModernRecord.setValue(
-        linkedRecord,
-        RELAY_RESOLVER_ERROR_KEY,
-        evaluationResult.error,
-      );
-      recordSource.set(linkedID, linkedRecord);
-
-      // Link the resolver value record to the resolver field of the record being read:
-
-      // Note: We get a fresh instance of the parent record from the record
-      // source, because it may have been updated when we traversed into child
-      // resolvers.
-      const currentRecord = recordSource.get(recordID);
-      invariant(
-        currentRecord != null,
-        'Expected the parent record to still be in the record source.',
-      );
-      const nextRecord = RelayModernRecord.clone(currentRecord);
-      RelayModernRecord.setLinkedRecordID(nextRecord, storageKey, linkedID);
-      recordSource.set(recordID, nextRecord);
-
-      if (field.fragment != null) {
-        // Put records observed by the resolver into the dependency graph:
-        const fragmentStorageKey = getStorageKey(field.fragment, variables);
-        const resolverID = generateClientID(recordID, fragmentStorageKey);
-        addDependencyEdge(this._resolverIDToRecordIDs, resolverID, linkedID);
-        addDependencyEdge(this._recordIDToResolverIDs, recordID, 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 = RelayModernRecord.getValue(
-      linkedRecord,
-      RELAY_RESOLVER_VALUE_KEY,
-    );
-
-    // $FlowFixMe[incompatible-type] - casting mixed
-    const snapshot: ?Snapshot = RelayModernRecord.getValue(
-      linkedRecord,
-      RELAY_RESOLVER_SNAPSHOT_KEY,
-    );
-
-    // $FlowFixMe[incompatible-type] - casting mixed
-    const error: ?Error = RelayModernRecord.getValue(
-      linkedRecord,
-      RELAY_RESOLVER_ERROR_KEY,
-    );
-
-    return [answer, linkedID, error, snapshot, undefined, undefined];
-  }
-
-  invalidateDataIDs(
-    updatedDataIDs: Set<DataID>, // Mutated in place
-  ): void {
-    const recordSource = this._getRecordSource();
-    const visited: Set<string> = new Set();
-    const recordsToVisit = Array.from(updatedDataIDs);
-    while (recordsToVisit.length) {
-      const recordID = recordsToVisit.pop();
-      // $FlowFixMe[incompatible-call]
-      updatedDataIDs.add(recordID);
-      // $FlowFixMe[incompatible-call]
-      for (const fragment of this._recordIDToResolverIDs.get(recordID) ??
-        emptySet) {
-        if (!visited.has(fragment)) {
-          for (const anotherRecordID of this._resolverIDToRecordIDs.get(
-            fragment,
-          ) ?? emptySet) {
-            this._markInvalidatedResolverRecord(
-              anotherRecordID,
-              recordSource,
-              updatedDataIDs,
-            );
-            if (!visited.has(anotherRecordID)) {
-              recordsToVisit.push(anotherRecordID);
-            }
-          }
-        }
-      }
-    }
-  }
-
-  _markInvalidatedResolverRecord(
-    dataID: DataID,
-    recordSource: MutableRecordSource, // Written to
-    updatedDataIDs: Set<DataID>, // Mutated in place
-  ) {
-    const record = recordSource.get(dataID);
-    if (!record) {
-      warning(
-        false,
-        'Expected a resolver record with ID %s, but it was missing.',
-        dataID,
-      );
-      return;
-    }
-    const nextRecord = RelayModernRecord.clone(record);
-    RelayModernRecord.setValue(
-      nextRecord,
-      RELAY_RESOLVER_INVALIDATION_KEY,
-      true,
-    );
-    recordSource.set(dataID, nextRecord);
-  }
-
-  _isInvalid(
-    record: Record,
-    getDataForResolverFragment: GetDataForResolverFragmentFn,
-  ): boolean {
-    if (!RelayModernRecord.getValue(record, RELAY_RESOLVER_INVALIDATION_KEY)) {
-      return false;
-    }
-    // $FlowFixMe[incompatible-type] - storing values in records is not typed
-    const snapshot: ?Snapshot = RelayModernRecord.getValue(
-      record,
-      RELAY_RESOLVER_SNAPSHOT_KEY,
-    );
-    const originalInputs = snapshot?.data;
-    const readerSelector: ?SingularReaderSelector = snapshot?.selector;
-    if (originalInputs == null || readerSelector == null) {
-      warning(
-        false,
-        'Expected previous inputs and reader selector on resolver record with ID %s, but they were missing.',
-        RelayModernRecord.getDataID(record),
-      );
-      return true;
-    }
-
-    const {data: latestValues} = getDataForResolverFragment(readerSelector);
-    const recycled = recycleNodesInto(originalInputs, latestValues);
-    if (recycled !== originalInputs) {
-      return true;
-    }
-
-    if (RelayFeatureFlags.MARK_RESOLVER_VALUES_AS_CLEAN_AFTER_FRAGMENT_REREAD) {
-      // This record does not need to be recomputed, we can reuse the cached value.
-      // For subsequent reads we can mark this record as "clean" so that they will
-      // not need to re-read the fragment.
-      const nextRecord = RelayModernRecord.clone(record);
-      RelayModernRecord.setValue(
-        nextRecord,
-        RELAY_RESOLVER_INVALIDATION_KEY,
-        false,
-      );
-
-      const recordSource = this._getRecordSource();
-      recordSource.set(RelayModernRecord.getDataID(record), nextRecord);
-    }
-
-    return false;
-  }
-
-  ensureClientRecord(id: string, typename: string): DataID {
-    invariant(
-      false,
-      'Client Edges to Client Objects are not supported in this version of Relay Store',
-    );
-  }
-
-  notifyUpdatedSubscribers(updatedDataIDs: DataIDSet): void {
-    invariant(
-      false,
-      'Processing @outputType records is not supported in this version of Relay Store',
-    );
-  }
-}
-
 module.exports = {
   NoopResolverCache,
-  RecordResolverCache,
 };

package/store/ResolverFragments.js.flow

@@ -112,12 +112,14 @@ function readFragment(
     fragmentSelector.kind === 'SingularReaderSelector',
     `Expected a singular reader selector for the fragment of the resolver ${fragmentNode.name}, but it was plural.`,
   );
-  const {data, isMissingData, errorResponseFields} =
-    context.getDataForResolverFragment(fragmentSelector, fragmentKey);
+  const {data, isMissingData, fieldErrors} = context.getDataForResolverFragment(
+    fragmentSelector,
+    fragmentKey,
+  );
 
   if (
     isMissingData ||
-    (errorResponseFields != null && errorResponseFields.some(eventShouldThrow))
+    (fieldErrors != null && fieldErrors.some(eventShouldThrow))
   ) {
     throw RESOLVER_FRAGMENT_ERRORED_SENTINEL;
   }

package/store/StoreInspector.js.flow

@@ -32,11 +32,14 @@ if (__DEV__) {
     }
     formattersInstalled = true;
     // $FlowFixMe[incompatible-use] D61394600
+    // $FlowFixMe[cannot-resolve-name]
     if (window.devtoolsFormatters == null) {
       // $FlowFixMe[incompatible-use] D61394600
+      // $FlowFixMe[cannot-resolve-name]
       window.devtoolsFormatters = [];
     }
     // $FlowFixMe[incompatible-use] D61394600
+    // $FlowFixMe[cannot-resolve-name]
     if (!Array.isArray(window.devtoolsFormatters)) {
       return;
     }
@@ -47,6 +50,7 @@ if (__DEV__) {
         'section.',
     );
     // $FlowFixMe[incompatible-use] D61394600
+    // $FlowFixMe[cannot-resolve-name]
     window.devtoolsFormatters.push(...createFormatters());
   };
 
@@ -137,6 +141,7 @@ if (__DEV__) {
   ): ?{[string]: mixed} => {
     const record = source.get(dataID);
     if (record == null) {
+      // $FlowFixMe[incompatible-return]
       return record;
     }
     return new Proxy(

package/store/createRelayContext.js.flow

@@ -12,6 +12,7 @@
 'use strict';
 
 import type {RelayContext} from './RelayStoreTypes.js';
+import type {Context} from 'react';
 import typeof {createContext} from 'react';
 
 const invariant = require('invariant');
@@ -24,10 +25,10 @@ type React = $ReadOnly<{
   ...
 }>;
 
-let relayContext: ?React$Context<RelayContext | null>;
+let relayContext: ?Context<RelayContext | null>;
 let firstReact: ?React;
 
-function createRelayContext(react: React): React$Context<RelayContext | null> {
+function createRelayContext(react: React): Context<RelayContext | null> {
   if (!relayContext) {
     relayContext = react.createContext(null);
     if (__DEV__) {

package/store/createRelayLoggingContext.js.flow

@@ -0,0 +1,46 @@
+/**
+ * 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 strict-local
+ * @format
+ * @oncall relay
+ */
+
+'use strict';
+
+import type {Context} from 'react';
+import typeof {createContext} from 'react';
+
+const invariant = require('invariant');
+
+// Ideally, we'd just import the type of the react module, but this causes Flow
+// problems.
+type React = $ReadOnly<{
+  createContext: createContext<mixed | null>,
+  version: string,
+  ...
+}>;
+
+let relayLoggingContext: ?Context<mixed | null>;
+let firstReact: ?React;
+
+function createRelayLoggingContext(react: React): Context<mixed | null> {
+  if (!relayLoggingContext) {
+    relayLoggingContext = react.createContext(null);
+    if (__DEV__) {
+      relayLoggingContext.displayName = 'RelayLoggingContext';
+    }
+    firstReact = react;
+  }
+  invariant(
+    react === firstReact,
+    '[createRelayLoggingContext]: You are passing a different instance of React',
+    react.version,
+  );
+  return relayLoggingContext;
+}
+
+module.exports = createRelayLoggingContext;

package/store/generateTypenamePrefixedDataID.js.flow

@@ -0,0 +1,25 @@
+/**
+ * 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 strict-local
+ * @format
+ * @oncall relay
+ */
+
+'use strict';
+
+import type {DataID} from 'relay-runtime/util/RelayRuntimeTypes';
+
+const TYPENAME_PREFIX = '__type:';
+
+function generateTypenamePrefixedDataID(
+  typeName: string,
+  dataID: DataID,
+): DataID {
+  return `${TYPENAME_PREFIX}${typeName}:${dataID}`;
+}
+
+module.exports = {generateTypenamePrefixedDataID};

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

@@ -48,6 +48,7 @@ const {
   RELAY_RESOLVER_OUTPUT_TYPE_RECORD_IDS,
   RELAY_RESOLVER_SNAPSHOT_KEY,
   RELAY_RESOLVER_VALUE_KEY,
+  getReadTimeResolverStorageKey,
   getStorageKey,
 } = require('../RelayStoreUtils');
 const getOutputTypeRecordIDs = require('./getOutputTypeRecordIDs');
@@ -129,7 +130,7 @@ class LiveResolverCache implements ResolverCache {
     // resolvers on this parent record.
     const record = expectRecord(recordSource, recordID);
 
-    const storageKey = getStorageKey(field, variables);
+    const storageKey = getReadTimeResolverStorageKey(field, variables);
     let linkedID = RelayModernRecord.getLinkedRecordID(record, storageKey);
     let linkedRecord = linkedID == null ? null : recordSource.get(linkedID);
 
@@ -656,9 +657,7 @@ class LiveResolverCache implements ResolverCache {
     while (recordsToVisit.length) {
       // $FlowFixMe[incompatible-type] We just checked length so we know this is not undefined
       const recordID: string = recordsToVisit.pop();
-      if (RelayFeatureFlags.AVOID_CYCLES_IN_RESOLVER_NOTIFICATION) {
-        visited.add(recordID);
-      }
+      visited.add(recordID);
 
       // $FlowFixMe[incompatible-call]
       updatedDataIDs.add(recordID);
@@ -669,9 +668,7 @@ class LiveResolverCache implements ResolverCache {
       }
       for (const fragment of fragmentSet) {
         if (!visited.has(fragment)) {
-          if (RelayFeatureFlags.AVOID_CYCLES_IN_RESOLVER_NOTIFICATION) {
-            visited.add(fragment);
-          }
+          visited.add(fragment);
 
           const recordSet = this._resolverIDToRecordIDs.get(fragment);
           if (recordSet == null) {
@@ -680,9 +677,7 @@ class LiveResolverCache implements ResolverCache {
           for (const anotherRecordID of recordSet) {
             markInvalidatedResolverRecord(anotherRecordID, recordSource);
             if (!visited.has(anotherRecordID)) {
-              if (RelayFeatureFlags.AVOID_CYCLES_IN_RESOLVER_NOTIFICATION) {
-                visited.add(anotherRecordID);
-              }
+              visited.add(anotherRecordID);
               recordsToVisit.push(anotherRecordID);
             }
           }

package/store/live-resolvers/resolverDataInjector.js.flow

@@ -12,12 +12,12 @@
 'use strict';
 
 import type {Fragment} from '../../util/RelayRuntimeTypes';
-import type {FragmentType} from '../RelayStoreTypes';
+import type {FragmentType, ResolverContext} from '../RelayStoreTypes';
 
 const {readFragment} = require('../ResolverFragments');
 const invariant = require('invariant');
 
-type ResolverFn = ($FlowFixMe, ?$FlowFixMe) => mixed;
+type ResolverFn = ($FlowFixMe, ?$FlowFixMe, ResolverContext) => mixed;
 
 /**
  *
@@ -40,7 +40,11 @@ function resolverDataInjector<TFragmentType: FragmentType, TData: ?{...}>(
   isRequiredField?: boolean,
 ): (fragmentKey: TFragmentType, args: mixed) => mixed {
   const resolverFn: ResolverFn = _resolverFn;
-  return (fragmentKey: TFragmentType, args: mixed): mixed => {
+  return (
+    fragmentKey: TFragmentType,
+    args: mixed,
+    resolverContext: ResolverContext,
+  ): mixed => {
     const data = readFragment(fragment, fragmentKey);
     if (fieldName != null) {
       if (data == null) {
@@ -52,7 +56,7 @@ function resolverDataInjector<TFragmentType: FragmentType, TData: ?{...}>(
             fragment.name,
           );
         } else {
-          return resolverFn(null, args);
+          return resolverFn(null, args, resolverContext); // TODO: This statement does not seem to be covered by a test?
         }
       }
 
@@ -70,7 +74,7 @@ function resolverDataInjector<TFragmentType: FragmentType, TData: ?{...}>(
         }
 
         // $FlowFixMe[invalid-computed-prop]
-        return resolverFn(data[fieldName], args);
+        return resolverFn(data[fieldName], args, resolverContext);
       } else {
         // If both `data` and `fieldName` is available, we expect the
         // `fieldName` field in the `data` object.
@@ -83,7 +87,7 @@ function resolverDataInjector<TFragmentType: FragmentType, TData: ?{...}>(
       }
     } else {
       // By default we will pass the full set of the fragment data to the resolver
-      return resolverFn(data, args);
+      return resolverFn(null, args, resolverContext); // TODO: This statement does not seem to be covered by a test?
     }
   };
 }