relay-runtime 18.2.0 → 19.0.0

package/store/RelayResponseNormalizer.js.flow

@@ -29,7 +29,9 @@ import type {RelayErrorTrie} from './RelayErrorTrie';
 import type {
   FollowupPayload,
   HandleFieldPayload,
+  IdCollisionTypenameLogEvent,
   IncrementalDataPlaceholder,
+  LogFunction,
   MutableRecordSource,
   NormalizationSelector,
   Record,
@@ -72,6 +74,7 @@ export type GetDataID = (
 export type NormalizationOptions = {
   +getDataID: GetDataID,
   +treatMissingFieldsAsNull: boolean,
+  +log: ?LogFunction,
   +path?: $ReadOnlyArray<string>,
   +shouldProcessClientComponents?: ?boolean,
   +actorIdentifier?: ?ActorIdentifier,
@@ -116,6 +119,7 @@ class RelayResponseNormalizer {
   _variables: Variables;
   _shouldProcessClientComponents: ?boolean;
   _errorTrie: RelayErrorTrie | null;
+  _log: ?LogFunction;
 
   constructor(
     recordSource: MutableRecordSource,
@@ -134,6 +138,7 @@ class RelayResponseNormalizer {
     this._recordSource = recordSource;
     this._variables = variables;
     this._shouldProcessClientComponents = options.shouldProcessClientComponents;
+    this._log = options.log;
   }
 
   normalizeResponse(
@@ -319,8 +324,6 @@ class RelayResponseNormalizer {
           this._normalizeActorChange(selection, record, data);
           break;
         case 'RelayResolver':
-          this._normalizeResolver(selection, record, data);
-          break;
         case 'RelayLiveResolver':
           this._normalizeResolver(selection, record, data);
           break;
@@ -472,12 +475,11 @@ class RelayResponseNormalizer {
     const responseKey = selection.alias || selection.name;
     const storageKey = getStorageKey(selection, this._variables);
     const fieldValue = data[responseKey];
-    if (
-      fieldValue == null ||
-      (RelayFeatureFlags.ENABLE_NONCOMPLIANT_ERROR_HANDLING_ON_LISTS &&
-        Array.isArray(fieldValue) &&
-        fieldValue.length === 0)
-    ) {
+    const isNoncompliantlyNullish =
+      RelayFeatureFlags.ENABLE_NONCOMPLIANT_ERROR_HANDLING_ON_LISTS &&
+      Array.isArray(fieldValue) &&
+      fieldValue.length === 0;
+    if (fieldValue == null || isNoncompliantlyNullish) {
       if (fieldValue === undefined) {
         // Fields may be missing in the response in two main cases:
         // - Inside a client extension: the server will not generally return
@@ -511,20 +513,27 @@ class RelayResponseNormalizer {
           return;
         }
       }
-      if (__DEV__) {
-        if (selection.kind === 'ScalarField') {
-          this._validateConflictingFieldsWithIdenticalId(
-            record,
-            storageKey,
-            // When using `treatMissingFieldsAsNull` the conflicting validation raises a false positive
-            // because the value is set using `null` but validated using `fieldValue` which at this point
-            // will be `undefined`.
-            // Setting this to `null` matches the value that we actually set to the `fieldValue`.
-            null,
-          );
+      if (selection.kind === 'ScalarField') {
+        this._validateConflictingFieldsWithIdenticalId(
+          record,
+          storageKey,
+          // When using `treatMissingFieldsAsNull` the conflicting validation raises a false positive
+          // because the value is set using `null` but validated using `fieldValue` which at this point
+          // will be `undefined`.
+          // Setting this to `null` matches the value that we actually set to the `fieldValue`.
+          null,
+        );
+      }
+      if (isNoncompliantlyNullish) {
+        // We need to preserve the fact that we received an empty list
+        if (selection.kind === 'LinkedField') {
+          RelayModernRecord.setLinkedRecordIDs(record, storageKey, []);
+        } else {
+          RelayModernRecord.setValue(record, storageKey, []);
         }
+      } else {
+        RelayModernRecord.setValue(record, storageKey, null);
       }
-      RelayModernRecord.setValue(record, storageKey, null);
       const errorTrie = this._errorTrie;
       if (errorTrie != null) {
         const errors = getErrorsByKey(errorTrie, responseKey);
@@ -536,13 +545,11 @@ class RelayResponseNormalizer {
     }
 
     if (selection.kind === 'ScalarField') {
-      if (__DEV__) {
-        this._validateConflictingFieldsWithIdenticalId(
-          record,
-          storageKey,
-          fieldValue,
-        );
-      }
+      this._validateConflictingFieldsWithIdenticalId(
+        record,
+        storageKey,
+        fieldValue,
+      );
       RelayModernRecord.setValue(record, storageKey, fieldValue);
     } else if (selection.kind === 'LinkedField') {
       this._path.push(responseKey);
@@ -686,13 +693,11 @@ class RelayResponseNormalizer {
       'RelayResponseNormalizer: Expected id on field `%s` to be a string.',
       storageKey,
     );
-    if (__DEV__) {
-      this._validateConflictingLinkedFieldsWithIdenticalId(
-        RelayModernRecord.getLinkedRecordID(record, storageKey),
-        nextID,
-        storageKey,
-      );
-    }
+    this._validateConflictingLinkedFieldsWithIdenticalId(
+      RelayModernRecord.getLinkedRecordID(record, storageKey),
+      nextID,
+      storageKey,
+    );
     RelayModernRecord.setLinkedRecordID(record, storageKey, nextID);
     let nextRecord = this._recordSource.get(nextID);
     if (!nextRecord) {
@@ -700,7 +705,7 @@ class RelayResponseNormalizer {
       const typeName = field.concreteType || this._getRecordType(fieldValue);
       nextRecord = RelayModernRecord.create(nextID, typeName);
       this._recordSource.set(nextID, nextRecord);
-    } else if (__DEV__) {
+    } else {
       this._validateRecordType(nextRecord, field, fieldValue);
     }
     // $FlowFixMe[incompatible-variance]
@@ -766,19 +771,15 @@ class RelayResponseNormalizer {
         const typeName = field.concreteType || this._getRecordType(item);
         nextRecord = RelayModernRecord.create(nextID, typeName);
         this._recordSource.set(nextID, nextRecord);
-      } else if (__DEV__) {
+      } else {
         this._validateRecordType(nextRecord, field, item);
       }
-      // NOTE: the check to strip __DEV__ code only works for simple
-      // `if (__DEV__)`
-      if (__DEV__) {
-        if (prevIDs) {
-          this._validateConflictingLinkedFieldsWithIdenticalId(
-            prevIDs[nextIndex],
-            nextID,
-            storageKey,
-          );
-        }
+      if (prevIDs) {
+        this._validateConflictingLinkedFieldsWithIdenticalId(
+          prevIDs[nextIndex],
+          nextID,
+          storageKey,
+        );
       }
       // $FlowFixMe[incompatible-variance]
       this._traverseSelections(field, nextRecord, item);
@@ -796,20 +797,42 @@ class RelayResponseNormalizer {
     field: NormalizationLinkedField,
     payload: Object,
   ): void {
-    const typeName = field.concreteType ?? this._getRecordType(payload);
-    const dataID = RelayModernRecord.getDataID(record);
-    warning(
-      (isClientID(dataID) && dataID !== ROOT_ID) ||
-        RelayModernRecord.getType(record) === typeName,
-      'RelayResponseNormalizer: Invalid record `%s`. Expected %s to be ' +
-        'consistent, but the record was assigned conflicting types `%s` ' +
-        'and `%s`. The GraphQL server likely violated the globally unique ' +
-        'id requirement by returning the same id for different objects.',
-      dataID,
-      TYPENAME_KEY,
-      RelayModernRecord.getType(record),
-      typeName,
-    );
+    if (RelayFeatureFlags.ENABLE_STORE_ID_COLLISION_LOGGING) {
+      const typeName = field.concreteType ?? this._getRecordType(payload);
+      const dataID = RelayModernRecord.getDataID(record);
+      const expected =
+        (isClientID(dataID) && dataID !== ROOT_ID) ||
+        RelayModernRecord.getType(record) === typeName;
+      if (!expected) {
+        const logEvent: IdCollisionTypenameLogEvent = {
+          name: 'idCollision.typename',
+          previous_typename: RelayModernRecord.getType(record),
+          new_typename: typeName,
+        };
+        if (this._log != null) {
+          this._log(logEvent);
+        }
+      }
+    }
+    // NOTE: Only emit a warning in DEV
+    if (__DEV__) {
+      const typeName = field.concreteType ?? this._getRecordType(payload);
+      const dataID = RelayModernRecord.getDataID(record);
+      const expected =
+        (isClientID(dataID) && dataID !== ROOT_ID) ||
+        RelayModernRecord.getType(record) === typeName;
+      warning(
+        expected,
+        'RelayResponseNormalizer: Invalid record `%s`. Expected %s to be ' +
+          'consistent, but the record was assigned conflicting types `%s` ' +
+          'and `%s`. The GraphQL server likely violated the globally unique ' +
+          'id requirement by returning the same id for different objects.',
+        dataID,
+        TYPENAME_KEY,
+        RelayModernRecord.getType(record),
+        typeName,
+      );
+    }
   }
 
   /**
@@ -820,14 +843,16 @@ class RelayResponseNormalizer {
     storageKey: string,
     fieldValue: mixed,
   ): void {
-    // NOTE: Only call this function in DEV
+    // NOTE: Only emit a warning in DEV
     if (__DEV__) {
+      const previousValue = RelayModernRecord.getValue(record, storageKey);
       const dataID = RelayModernRecord.getDataID(record);
-      var previousValue = RelayModernRecord.getValue(record, storageKey);
-      warning(
+      const expected =
         storageKey === TYPENAME_KEY ||
-          previousValue === undefined ||
-          areEqual(previousValue, fieldValue),
+        previousValue === undefined ||
+        areEqual(previousValue, fieldValue);
+      warning(
+        expected,
         'RelayResponseNormalizer: Invalid record. The record contains two ' +
           'instances of the same id: `%s` with conflicting field, %s and its values: %s and %s. ' +
           'If two fields are different but share ' +
@@ -848,10 +873,11 @@ class RelayResponseNormalizer {
     nextID: DataID,
     storageKey: string,
   ): void {
-    // NOTE: Only call this function in DEV
+    // NOTE: Only emit a warning in DEV
     if (__DEV__) {
+      const expected = prevID === undefined || prevID === nextID;
       warning(
-        prevID === undefined || prevID === nextID,
+        expected,
         'RelayResponseNormalizer: Invalid record. The record contains ' +
           'references to the conflicting field, %s and its id values: %s and %s. ' +
           'We need to make sure that the record the field points ' +

package/store/RelayStoreSubscriptions.js.flow

@@ -115,7 +115,7 @@ class RelayStoreSubscriptions implements StoreSubscriptions {
           missingLiveResolverFields: backup.missingLiveResolverFields,
           seenRecords: backup.seenRecords,
           selector: backup.selector,
-          errorResponseFields: backup.errorResponseFields,
+          fieldErrors: backup.fieldErrors,
         };
       } else {
         // This subscription was created during the optimisitic state. We should
@@ -185,7 +185,7 @@ class RelayStoreSubscriptions implements StoreSubscriptions {
       missingLiveResolverFields: nextSnapshot.missingLiveResolverFields,
       seenRecords: nextSnapshot.seenRecords,
       selector: nextSnapshot.selector,
-      errorResponseFields: nextSnapshot.errorResponseFields,
+      fieldErrors: nextSnapshot.fieldErrors,
     }: Snapshot);
     if (__DEV__) {
       deepFreeze(nextSnapshot);

package/store/RelayStoreTypes.js.flow

@@ -116,7 +116,7 @@ export type NormalizationSelector = {
   +variables: Variables,
 };
 
-export type ErrorResponseField =
+export type FieldError =
   | RelayFieldPayloadErrorEvent
   | MissingExpectedDataLogEvent
   | MissingExpectedDataThrowEvent
@@ -124,7 +124,7 @@ export type ErrorResponseField =
   | MissingRequiredFieldLogEvent
   | MissingRequiredFieldThrowEvent;
 
-export type ErrorResponseFields = Array<ErrorResponseField>;
+export type FieldErrors = Array<FieldError>;
 
 export type ClientEdgeTraversalInfo = {
   +readerClientEdge: ReaderClientEdgeToServerObject,
@@ -149,7 +149,7 @@ export type Snapshot = {
   +missingClientEdges: null | $ReadOnlyArray<MissingClientEdgeRequestInfo>,
   +seenRecords: DataIDSet,
   +selector: SingularReaderSelector,
-  +errorResponseFields: ?ErrorResponseFields,
+  +fieldErrors: ?FieldErrors,
 };
 
 /**
@@ -684,6 +684,11 @@ export type ExecuteCompleteLogEvent = {
   +executeId: number,
 };
 
+export type ExecuteUnsubscribeLogEvent = {
+  +name: 'execute.unsubscribe',
+  +executeId: number,
+};
+
 export type ExecuteNormalizeStart = {
   +name: 'execute.normalize.start',
   +operation: OperationDescriptor,
@@ -781,12 +786,23 @@ export type UseFragmentSubscriptionMissedUpdates = {
   +hasDataChanges: boolean,
 };
 
+/**
+ * This event is logged when two strong objects share the same id,
+ * but have different types, resulting in an collision in the store.
+ */
+export type IdCollisionTypenameLogEvent = {
+  +name: 'idCollision.typename',
+  +previous_typename: string,
+  +new_typename: string,
+};
+
 export type LogEvent =
   | SuspenseFragmentLogEvent
   | SuspenseQueryLogEvent
   | QueryResourceFetchLogEvent
   | QueryResourceRetainLogEvent
   | FragmentResourceMissingDataLogEvent
+  | IdCollisionTypenameLogEvent
   | PendingOperationFoundLogEvent
   | NetworkInfoLogEvent
   | NetworkStartLogEvent
@@ -800,6 +816,7 @@ export type LogEvent =
   | ExecuteAsyncModuleLogEvent
   | ExecuteErrorLogEvent
   | ExecuteCompleteLogEvent
+  | ExecuteUnsubscribeLogEvent
   | ExecuteNormalizeStart
   | ExecuteNormalizeEnd
   | StoreDataCheckerStartEvent
@@ -1270,6 +1287,8 @@ export type MissingExpectedDataLogEvent = {
   +kind: 'missing_expected_data.log',
   +owner: string,
   fieldPath: string, // Purposefully mutable to allow lazy construction in RelayReader
+  // To populate this, you should pass the value to a ReactRelayLoggingContext
+  +uiContext: mixed | void,
 };
 
 /**
@@ -1297,6 +1316,8 @@ export type MissingExpectedDataThrowEvent = {
   +owner: string,
   fieldPath: string, // Purposefully mutable to allow lazy construction in RelayReader
   +handled: boolean,
+  // To populate this, you should pass the value to a ReactRelayLoggingContext
+  +uiContext: mixed | void,
 };
 
 /**
@@ -1307,6 +1328,8 @@ export type MissingRequiredFieldLogEvent = {
   +kind: 'missing_required_field.log',
   +owner: string,
   fieldPath: string, // Purposefully mutable to allow lazy construction in RelayReader
+  // To populate this, you should pass the value to a ReactRelayLoggingContext
+  +uiContext: mixed | void,
 };
 
 /**
@@ -1325,6 +1348,8 @@ export type MissingRequiredFieldThrowEvent = {
   +owner: string,
   fieldPath: string, // Purposefully mutable to allow lazy construction in RelayReader
   +handled: boolean,
+  // To populate this, you should pass the value to a ReactRelayLoggingContext
+  +uiContext: mixed | void,
 };
 
 /**
@@ -1346,6 +1371,8 @@ export type RelayResolverErrorEvent = {
   +error: Error,
   +shouldThrow: boolean,
   +handled: boolean,
+  // To populate this, you should pass the value to a ReactRelayLoggingContext
+  +uiContext: mixed | void,
 };
 
 /**
@@ -1372,6 +1399,8 @@ export type RelayFieldPayloadErrorEvent = {
   +error: TRelayFieldError,
   +shouldThrow: boolean,
   +handled: boolean,
+  // To populate this, you should pass the value to a ReactRelayLoggingContext
+  +uiContext: mixed | void,
 };
 
 /**
@@ -1481,7 +1510,7 @@ export type ConcreteClientEdgeResolverReturnType<T = any> = {
  * returns a callback which should be called when the value _may_ have changed.
  *
  * While over-notification (subscription notifications when the read value has
- * not actually changed) is suported, for performance reasons, it is recommended
+ * not actually changed) is supported, for performance reasons, it is recommended
  * that the provider of the LiveState value confirms that the value has indeed
  * change before notifying Relay of the change.
  */

package/store/RelayStoreUtils.js.flow

@@ -15,6 +15,8 @@ import type {
   NormalizationArgument,
   NormalizationField,
   NormalizationHandle,
+  NormalizationLiveResolverField,
+  NormalizationResolverField,
 } from '../util/NormalizationNode';
 import type {
   ReaderActorChange,
@@ -28,6 +30,7 @@ import type {Variables} from '../util/RelayRuntimeTypes';
 
 const getRelayHandleKey = require('../util/getRelayHandleKey');
 const RelayConcreteNode = require('../util/RelayConcreteNode');
+const RelayFeatureFlags = require('../util/RelayFeatureFlags');
 const {stableCopy} = require('../util/stableCopy');
 const invariant = require('invariant');
 
@@ -42,6 +45,8 @@ const ERRORS_KEY: '__errors' = '__errors';
 const MODULE_COMPONENT_KEY_PREFIX = '__module_component_';
 const MODULE_OPERATION_KEY_PREFIX = '__module_operation_';
 
+const RELAY_READ_TIME_RESOLVER_KEY_PREFIX = '$r:';
+
 function getArgumentValue(
   arg: NormalizationArgument | ReaderArgument,
   variables: Variables,
@@ -163,6 +168,28 @@ function getStorageKey(
     : name;
 }
 
+/**
+ * This is a special case of getStorageKey that should be used when dealing with
+ * read time resolver fields. A resolver may be used at both exec time and at read
+ * time within the same project. However, the value of the read time resolver is
+ * wrapped while the value of the exec time resolver is a standard Relay object. To
+ * disambiguate in the case that both types may exist on the same record, the read
+ * time resolver storage keys are prefixed.
+ */
+function getReadTimeResolverStorageKey(
+  field:
+    | ReaderRelayResolver
+    | ReaderRelayLiveResolver
+    | NormalizationResolverField
+    | NormalizationLiveResolverField,
+  variables: Variables,
+): string {
+  const storageKey = getStorageKey(field, variables);
+  return RelayFeatureFlags.ENABLE_READ_TIME_RESOLVER_STORAGE_KEY_PREFIX
+    ? '$r:' + storageKey // Using inlined string to test the performance impact
+    : storageKey;
+}
+
 /**
  * Given a field the method returns an array of arguments.
  * For Relay resolver fields, we store arguments on the field and fragment
@@ -271,12 +298,14 @@ const RelayStoreUtils = {
   RELAY_RESOLVER_SNAPSHOT_KEY: '__resolverSnapshot',
   RELAY_RESOLVER_ERROR_KEY: '__resolverError',
   RELAY_RESOLVER_OUTPUT_TYPE_RECORD_IDS: '__resolverOutputTypeRecordIDs',
+  RELAY_READ_TIME_RESOLVER_KEY_PREFIX,
 
   formatStorageKey,
   getArgumentValue,
   getArgumentValues,
   getHandleStorageKey,
   getStorageKey,
+  getReadTimeResolverStorageKey,
   getStableStorageKey,
   getModuleComponentKey,
   getModuleOperationKey,

package/store/ResolverCache.js.flow

@@ -18,7 +18,7 @@ import type {
 import type {DataID, Variables} from '../util/RelayRuntimeTypes';
 import type {
   DataIDSet,
-  ErrorResponseFields,
+  FieldErrors,
   SingularReaderSelector,
   Snapshot,
 } from './RelayStoreTypes';
@@ -35,7 +35,7 @@ export type EvaluationResult<T> = {
 export type ResolverFragmentResult = {
   data: mixed,
   isMissingData: boolean,
-  errorResponseFields: ?ErrorResponseFields,
+  fieldErrors: ?FieldErrors,
 };
 
 export type GetDataForResolverFragmentFn =

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);