relay-runtime 20.1.1 → 21.0.1

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

@@ -46,6 +46,7 @@ const {
   RELAY_RESOLVER_ERROR_KEY,
   RELAY_RESOLVER_INVALIDATION_KEY,
   RELAY_RESOLVER_OUTPUT_TYPE_RECORD_IDS,
+  RELAY_RESOLVER_RECORD_TYPENAME,
   RELAY_RESOLVER_SNAPSHOT_KEY,
   RELAY_RESOLVER_VALUE_KEY,
   getReadTimeResolverStorageKey,
@@ -63,7 +64,6 @@ const RELAY_RESOLVER_LIVE_STATE_SUBSCRIPTION_KEY =
   '__resolverLiveStateSubscription';
 const RELAY_RESOLVER_LIVE_STATE_VALUE = '__resolverLiveStateValue';
 const RELAY_RESOLVER_LIVE_STATE_DIRTY = '__resolverLiveStateDirty';
-const RELAY_RESOLVER_RECORD_TYPENAME = '__RELAY_RESOLVER__';
 const MODEL_PROPERTY_NAME = '__relay_model_instance';
 
 /**
@@ -181,7 +181,7 @@ class LiveResolverCache implements ResolverCache {
             evaluationResult.error == null,
             'Did not expect resolver to have both a value and an error.',
           );
-          const liveState: LiveState<mixed> =
+          const liveState: LiveState<unknown> =
             // $FlowFixMe[incompatible-type] - casting mixed
             evaluationResult.resolverResult;
           updatedDataIDs = this._setLiveStateValue(
@@ -261,7 +261,7 @@ class LiveResolverCache implements ResolverCache {
       linkedID = linkedID ?? generateClientID(recordID, storageKey);
       linkedRecord = RelayModernRecord.clone(linkedRecord);
       // $FlowFixMe[incompatible-type] - casting mixed
-      const liveState: LiveState<mixed> = RelayModernRecord.getValue(
+      const liveState: LiveState<unknown> = RelayModernRecord.getValue(
         linkedRecord,
         RELAY_RESOLVER_LIVE_STATE_VALUE,
       );
@@ -327,7 +327,7 @@ class LiveResolverCache implements ResolverCache {
     );
 
     // $FlowFixMe[incompatible-type] - casting mixed
-    const liveState: LiveState<mixed> = RelayModernRecord.getValue(
+    const liveState: LiveState<unknown> = RelayModernRecord.getValue(
       liveStateRecord,
       RELAY_RESOLVER_LIVE_STATE_VALUE,
     );
@@ -345,7 +345,7 @@ class LiveResolverCache implements ResolverCache {
   _setLiveStateValue(
     linkedRecord: Record,
     linkedID: DataID,
-    liveState: LiveState<mixed>,
+    liveState: LiveState<unknown>,
     field: ReaderRelayLiveResolver,
     variables: Variables,
   ): DataIDSet | null {
@@ -474,14 +474,39 @@ class LiveResolverCache implements ResolverCache {
     }
   }
 
+  // Returns true if source is published
+  batchLiveStateUpdatesWithoutNotify(callback: () => void): boolean {
+    invariant(
+      !this._handlingBatch,
+      'Unexpected nested call to batchLiveStateUpdates.',
+    );
+    this._handlingBatch = true;
+    try {
+      callback();
+    } finally {
+      const shouldPublish = this._liveResolverBatchRecordSource != null;
+      // We lazily create the record source. If one has not been created, there
+      // is nothing to publish.
+      if (shouldPublish) {
+        // $FlowFixMe[incompatible-type]  Null checked
+        this._store.publish(this._liveResolverBatchRecordSource);
+      }
+
+      // Reset batched state.
+      this._liveResolverBatchRecordSource = null;
+      this._handlingBatch = false;
+      return shouldPublish;
+    }
+  }
+
   _setLiveResolverValue(
     resolverRecord: Record,
-    liveValue: LiveState<mixed>,
+    liveValue: LiveState<unknown>,
     field: ReaderRelayResolver | ReaderRelayLiveResolver,
     variables: Variables,
   ): DataIDSet | null {
-    let value: null | mixed = null;
-    let resolverError: null | mixed = null;
+    let value: null | unknown = null;
+    let resolverError: null | unknown = null;
     try {
       value = liveValue.read();
     } catch (e) {
@@ -498,7 +523,7 @@ class LiveResolverCache implements ResolverCache {
 
   _setResolverValue(
     resolverRecord: Record,
-    value: mixed,
+    value: unknown,
     field: ReaderRelayResolver | ReaderRelayLiveResolver,
     variables: Variables,
   ): DataIDSet | null {
@@ -623,13 +648,23 @@ class LiveResolverCache implements ResolverCache {
       );
     } else {
       shallowFreeze(value);
-      // For "classic" resolvers (or if the value is nullish), we are just setting their
-      // value as is.
+
+      // For "classic" resolvers (or if the value is nullish/suspense), we are
+      // set their value...
       RelayModernRecord.setValue(
         resolverRecord,
         RELAY_RESOLVER_VALUE_KEY,
         value,
       );
+
+      // ...and clear the output type record IDs, if any since a resolver must
+      // be an output type resolver with a non-suspended, non-null value to
+      // refernce any output type record ids.
+      RelayModernRecord.setValue(
+        resolverRecord,
+        RELAY_RESOLVER_OUTPUT_TYPE_RECORD_IDS,
+        new Set(),
+      );
     }
 
     return updatedDataIDs;
@@ -639,7 +674,7 @@ class LiveResolverCache implements ResolverCache {
     this._store.__notifyUpdatedSubscribers(updatedDataIDs);
   }
 
-  _getResolverValue(resolverRecord: Record): mixed {
+  _getResolverValue(resolverRecord: Record): unknown {
     return RelayModernRecord.getValue(resolverRecord, RELAY_RESOLVER_VALUE_KEY);
   }
 
@@ -659,9 +694,9 @@ class LiveResolverCache implements ResolverCache {
       const recordID: string = recordsToVisit.pop();
       visited.add(recordID);
 
-      // $FlowFixMe[incompatible-call]
+      // $FlowFixMe[incompatible-type]
       updatedDataIDs.add(recordID);
-      // $FlowFixMe[incompatible-call]
+      // $FlowFixMe[incompatible-type]
       const fragmentSet = this._recordIDToResolverIDs.get(recordID);
       if (fragmentSet == null) {
         continue;
@@ -737,7 +772,7 @@ class LiveResolverCache implements ResolverCache {
   // containing only "weak" records.
   _normalizeOutputTypeValue(
     outputTypeDataID: DataID,
-    value: {+[key: string]: mixed},
+    value: {readonly [key: string]: unknown},
     variables: Variables,
     normalizationInfo: ResolverNormalizationInfo,
     fieldPath: Array<string>,
@@ -788,7 +823,7 @@ class LiveResolverCache implements ResolverCache {
         return source;
       }
       default:
-        (normalizationInfo.kind: empty);
+        normalizationInfo.kind as empty;
         invariant(
           false,
           'LiveResolverCache: Unexpected normalization info kind `%s`.',
@@ -846,7 +881,7 @@ class LiveResolverCache implements ResolverCache {
 function updateCurrentSource(
   currentSource: MutableRecordSource,
   nextSource: RecordSource,
-  prevOutputTypeRecordIDs: ?$ReadOnlySet<DataID>,
+  prevOutputTypeRecordIDs: ?ReadonlySet<DataID>,
 ): DataIDSet {
   const updatedDataIDs = new Set<DataID>();
 
@@ -944,7 +979,7 @@ function markInvalidatedLinkedResolverRecords(
 
 function unsubscribeFromLiveResolverRecordsImpl(
   recordSource: RecordSource,
-  invalidatedDataIDs: $ReadOnlySet<DataID>,
+  invalidatedDataIDs: ReadonlySet<DataID>,
 ): void {
   if (invalidatedDataIDs.size === 0) {
     return;
@@ -999,7 +1034,7 @@ function getConcreteTypename(
   const typename =
     normalizationInfo.concreteType ??
     // $FlowFixMe[prop-missing]
-    (currentValue.__typename: string);
+    (currentValue.__typename as string);
   invariant(
     typename != null,
     'normalizationInfo.concreteType should not be null, or the value returned from the resolver should include a __typename field, ' +
@@ -1010,6 +1045,6 @@ function getConcreteTypename(
 
 module.exports = {
   LiveResolverCache,
-  getUpdatedDataIDs,
   RELAY_RESOLVER_LIVE_STATE_SUBSCRIPTION_KEY,
+  getUpdatedDataIDs,
 };

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

@@ -11,16 +11,16 @@
 
 'use strict';
 
-const LIVE_RESOLVER_SUSPENSE_SENTINEL: mixed = Object.freeze({
+const LIVE_RESOLVER_SUSPENSE_SENTINEL: unknown = Object.freeze({
   __LIVE_RESOLVER_SUSPENSE_SENTINEL: true,
 });
 
 function suspenseSentinel(): empty {
-  // $FlowFixMe[incompatible-return]
+  // $FlowFixMe[incompatible-type]
   return LIVE_RESOLVER_SUSPENSE_SENTINEL;
 }
 
-function isSuspenseSentinel(value: mixed): boolean {
+function isSuspenseSentinel(value: unknown): boolean {
   return value === LIVE_RESOLVER_SUSPENSE_SENTINEL;
 }
 

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

@@ -18,7 +18,7 @@ const RelayModernRecord = require('../RelayModernRecord');
 const {RELAY_RESOLVER_OUTPUT_TYPE_RECORD_IDS} = require('../RelayStoreUtils');
 const invariant = require('invariant');
 
-function getOutputTypeRecordIDs(record: Record): $ReadOnlySet<DataID> | null {
+function getOutputTypeRecordIDs(record: Record): ReadonlySet<DataID> | null {
   const maybeOutputTypeRecordIDs = RelayModernRecord.getValue(
     record,
     RELAY_RESOLVER_OUTPUT_TYPE_RECORD_IDS,

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

@@ -13,9 +13,9 @@
 
 import type {LiveState} from '../RelayStoreTypes';
 
-declare function isLiveStateValue<T, U = LiveState<T>>(v: mixed): v is U;
+declare function isLiveStateValue<T, U = LiveState<T>>(v: unknown): v is U;
 
-function isLiveStateValue(v: mixed) {
+function isLiveStateValue(v: unknown) {
   return (
     v != null &&
     typeof v === 'object' &&

package/store/live-resolvers/resolverDataInjector.d.ts

@@ -0,0 +1,27 @@
+/**
+ * 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.
+ */
+
+import type { GraphQLTaggedNode } from '../../query/GraphQLTag';
+import type { FragmentType } from '../RelayStoreTypes';
+
+/**
+ * This a higher order function that returns a relay resolver that can read the data for
+ * the fragment`.
+ *
+ * - fragment: contains fragment Reader AST with resolver's data dependencies.
+ * - resolverFn: original resolver function that expects a data from the fragment
+ * - (optional) fieldName: individual field that needs to be read out of the fragment.
+ *
+ * This will not call the `resolverFn` if the fragment data for it is null/undefined.
+ * The compiler generates calls to this function, ensuring the correct set of arguments.
+ */
+export function resolverDataInjector(
+    fragment: GraphQLTaggedNode,
+    _resolverFn: unknown,
+    fieldName?: string,
+    isRequiredField?: boolean,
+): (fragmentKey: FragmentType, args: unknown) => unknown;

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

@@ -17,7 +17,7 @@ import type {FragmentType, ResolverContext} from '../RelayStoreTypes';
 const {readFragment} = require('../ResolverFragments');
 const invariant = require('invariant');
 
-type ResolverFn = ($FlowFixMe, ?$FlowFixMe, ResolverContext) => mixed;
+type ResolverFn = ($FlowFixMe, ?$FlowFixMe, ResolverContext) => unknown;
 
 /**
  *
@@ -31,20 +31,23 @@ type ResolverFn = ($FlowFixMe, ?$FlowFixMe, ResolverContext) => mixed;
  * This will not call the `resolverFn` if the fragment data for it is null/undefined.
  * The the compiler generates calls to this function, ensuring the correct set of arguments.
  */
-function resolverDataInjector<TFragmentType: FragmentType, TData: ?{...}>(
+function resolverDataInjector<
+  TFragmentType extends FragmentType,
+  TData extends ?{...},
+>(
   fragment: Fragment<TFragmentType, TData>,
   // Resolvers have their own type assertions, we don't want to confuse users
   // with a type error in their generated code at this point.
   _resolverFn: $FlowFixMe,
   fieldName?: string,
   isRequiredField?: boolean,
-): (fragmentKey: TFragmentType, args: mixed) => mixed {
+): (fragmentKey: TFragmentType, args: unknown) => unknown {
   const resolverFn: ResolverFn = _resolverFn;
   return (
     fragmentKey: TFragmentType,
-    args: mixed,
+    args: unknown,
     resolverContext: ResolverContext,
-  ): mixed => {
+  ): unknown => {
     const data = readFragment(fragment, fragmentKey);
     if (fieldName != null) {
       if (data == null) {

package/store/observeFragmentExperimental.d.ts

@@ -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.
+ */
+
+import type { RelayObservable as Observable } from '../network/RelayObservable';
+import type { GraphQLTaggedNode } from '../query/GraphQLTag';
+import type {ArrayKeyType, ArrayKeyTypeData, Environment as IEnvironment, FragmentState, KeyType, KeyTypeData} from './RelayStoreTypes';
+
+/**
+ * EXPERIMENTAL: This API is experimental and does not yet support all Relay
+ * features. Notably, it does not correctly handle some features of Relay Resolvers.
+ *
+ * Given a fragment and a fragment reference, returns an observable that emits
+ * the state of the fragment over time. The observable will emit the following
+ * values:
+ * - 'ok': The fragment has a value
+ * - 'error': The fragment has an error, this could be due to a network error or
+ *  a field error due to @required(action: THROW) or @throwOnFieldError
+ * - 'loading': The fragment is still in flight and is still expected to resolver.
+ */
+export function observeFragment<TKey extends KeyType>(
+    environment: IEnvironment,
+    fragmentInput: GraphQLTaggedNode,
+    fragmentRef: TKey,
+): Observable<FragmentState<KeyTypeData<TKey>>>;
+
+/**
+ * EXPERIMENTAL: This API is experimental and does not yet support all Relay
+ * features. Notably, it does not correctly handle some features of Relay Resolvers.
+ *
+ * Given a fragment and a fragment reference, returns an observable that emits
+ * the state of the fragment over time. The observable will emit the following
+ * values:
+ * - 'ok': The fragment has a value
+ * - 'error': The fragment has an error, this could be due to a network error or
+ *  a field error due to @required(action: THROW) or @throwOnFieldError
+ * - 'loading': The fragment is still in flight and is still expected to resolver.
+ */
+export function observeFragment<TKey extends ArrayKeyType>(
+    environment: IEnvironment,
+    fragmentInput: GraphQLTaggedNode,
+    fragmentRef: TKey,
+): Observable<FragmentState<ArrayKeyTypeData<TKey>>>;

package/store/observeFragmentExperimental.js.flow

@@ -9,7 +9,11 @@
  * @oncall relay
  */
 
-import type {PluralReaderSelector, RequestDescriptor} from './RelayStoreTypes';
+import type {
+  PluralReaderSelector,
+  ReaderSelector,
+  RequestDescriptor,
+} from './RelayStoreTypes';
 import type {
   Fragment,
   FragmentType,
@@ -41,7 +45,7 @@ export type FragmentState<T> =
   | {state: 'loading'};
 
 export type HasSpread<TFragmentType> = {
-  +$fragmentSpreads: TFragmentType,
+  readonly $fragmentSpreads: TFragmentType,
   ...
 };
 
@@ -59,12 +63,12 @@ export type HasSpread<TFragmentType> = {
  * you might choose to @defer a fragment that you only need to access inside an
  * event handler and then await its value inside the handler if/when it is triggered.
  */
-async function waitForFragmentData<TFragmentType: FragmentType, TData>(
+async function waitForFragmentData<TFragmentType extends FragmentType, TData>(
   environment: IEnvironment,
   fragment: Fragment<TFragmentType, TData>,
   fragmentRef:
     | HasSpread<TFragmentType>
-    | $ReadOnlyArray<HasSpread<TFragmentType>>,
+    | ReadonlyArray<HasSpread<TFragmentType>>,
 ): Promise<TData> {
   let subscription: ?Subscription;
 
@@ -86,18 +90,18 @@ async function waitForFragmentData<TFragmentType: FragmentType, TData>(
     });
     subscription?.unsubscribe();
     return data;
-  } catch (e: mixed) {
+  } catch (e: unknown) {
     subscription?.unsubscribe();
     throw e;
   }
 }
 
-declare function observeFragment<TFragmentType: FragmentType, TData>(
+declare function observeFragment<TFragmentType extends FragmentType, TData>(
   environment: IEnvironment,
   fragment: Fragment<TFragmentType, TData>,
   fragmentRef:
     | HasSpread<TFragmentType>
-    | $ReadOnlyArray<HasSpread<TFragmentType>>,
+    | ReadonlyArray<HasSpread<TFragmentType>>,
 ): Observable<FragmentState<TData>>;
 
 /**
@@ -112,25 +116,28 @@ declare function observeFragment<TFragmentType: FragmentType, TData>(
  *  a field error due to @required(action: THROW) or @throwOnFieldError
  * - 'loading': The fragment is still in flight and is still expected to resolver.
  */
-function observeFragment<TFragmentType: FragmentType, TData>(
+function observeFragment<TFragmentType extends FragmentType, TData>(
   environment: IEnvironment,
   fragment: Fragment<TFragmentType, TData>,
-  fragmentRef: mixed,
-): mixed {
+  fragmentRef: unknown,
+): unknown {
   const fragmentNode = getFragment(fragment);
   const fragmentSelector = getSelector(fragmentNode, fragmentRef);
+
+  invariant(fragmentSelector != null, 'Expected a selector, got null.');
+
   invariant(
-    fragmentNode.metadata?.hasClientEdges == null,
+    fragmentNode.metadata?.hasClientEdges == null ||
+      fragmentSelectorUsesExecTimeResolver(fragmentSelector),
     "Client edges aren't supported yet.",
   );
-  invariant(fragmentSelector != null, 'Expected a selector, got null.');
   switch (fragmentSelector.kind) {
     case 'SingularReaderSelector':
       return observeSingularSelector(environment, fragment, fragmentSelector);
     case 'PluralReaderSelector': {
       return observePluralSelector(
         environment,
-        (fragment: $FlowFixMe),
+        fragment as $FlowFixMe,
         fragmentSelector,
       );
     }
@@ -138,7 +145,29 @@ function observeFragment<TFragmentType: FragmentType, TData>(
   invariant(false, 'Unsupported fragment selector kind');
 }
 
-function observeSingularSelector<TFragmentType: FragmentType, TData>(
+function fragmentSelectorUsesExecTimeResolver(
+  fragmentSelector: ReaderSelector,
+) {
+  switch (fragmentSelector?.kind) {
+    case 'SingularReaderSelector':
+      return (
+        (fragmentSelector.owner.node.operation?.use_exec_time_resolvers ??
+          fragmentSelector.owner.node.operation?.exec_time_resolvers_enabled_provider?.get()) ===
+        true
+      );
+    case 'PluralReaderSelector': {
+      return fragmentSelector.selectors?.every(
+        selector =>
+          (selector.owner.node.operation.use_exec_time_resolvers ??
+            selector.owner.node.operation?.exec_time_resolvers_enabled_provider?.get()) ===
+          true,
+      );
+    }
+  }
+  return false;
+}
+
+function observeSingularSelector<TFragmentType extends FragmentType, TData>(
   environment: IEnvironment,
   fragmentNode: Fragment<TFragmentType, TData>,
   fragmentSelector: SingularReaderSelector,
@@ -171,8 +200,8 @@ function observeSingularSelector<TFragmentType: FragmentType, TData>(
 }
 
 function observePluralSelector<
-  TFragmentType: FragmentType,
-  TData: Array<mixed>,
+  TFragmentType extends FragmentType,
+  TData extends Array<unknown>,
 >(
   environment: IEnvironment,
   fragmentNode: Fragment<TFragmentType, TData>,
@@ -193,7 +222,7 @@ function observePluralSelector<
       ),
     );
 
-    sink.next((mergeFragmentStates(states): $FlowFixMe));
+    sink.next(mergeFragmentStates(states) as $FlowFixMe);
 
     const subscriptions = snapshots.map((snapshot, index) =>
       environment.subscribe(snapshot, latestSnapshot => {
@@ -205,7 +234,7 @@ function observePluralSelector<
         );
         // This doesn't batch updates, so it will notify the subscriber multiple times
         // if a store update impacting multiple items in the list is published.
-        sink.next((mergeFragmentStates(states): $FlowFixMe));
+        sink.next(mergeFragmentStates(states) as $FlowFixMe);
       }),
     );
 
@@ -213,7 +242,7 @@ function observePluralSelector<
   });
 }
 
-function snapshotToFragmentState<TFragmentType: FragmentType, TData>(
+function snapshotToFragmentState<TFragmentType extends FragmentType, TData>(
   environment: IEnvironment,
   fragmentNode: Fragment<TFragmentType, TData>,
   owner: RequestDescriptor,
@@ -266,11 +295,11 @@ function snapshotToFragmentState<TFragmentType: FragmentType, TData>(
 
   invariant(snapshot.data != null, 'Expected data to be non-null.');
 
-  return {state: 'ok', value: (snapshot.data: $FlowFixMe)};
+  return {state: 'ok', value: snapshot.data as $FlowFixMe};
 }
 
 function mergeFragmentStates<T>(
-  states: $ReadOnlyArray<FragmentState<T>>,
+  states: ReadonlyArray<FragmentState<T>>,
 ): FragmentState<Array<T>> {
   const value = [];
   for (const state of states) {

package/store/observeQueryExperimental.d.ts

@@ -0,0 +1,30 @@
+/**
+ * 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.
+ */
+
+import type { RelayObservable as Observable } from '../network/RelayObservable';
+import type { GraphQLTaggedNode } from '../query/GraphQLTag';
+import type { OperationType } from '../util/RelayRuntimeTypes';
+import type {Environment as IEnvironment, FragmentState} from './RelayStoreTypes';
+
+/**
+ * This function returns an observable that can be used to subscribe to the data
+ * contained in a query. It does not return the full response shape, but rather
+ * the contents of the query body minus any fragment spreads.  If you wish to
+ * read the contents of a fragment spread into this query you may pass the
+ * object into which the fragment was spread to `observeFragment`.
+ *
+ * NOTE: `observeQuery` assumes that you have already fetched and retained the
+ * query via some other means, such as `fetchQuery`.
+ *
+ * This feature is still experimental and does not properly handle some resolver
+ * features such as client-to-server edges.
+ */
+export function observeQuery<T extends OperationType>(
+    environment: IEnvironment,
+    gqlQuery: GraphQLTaggedNode,
+    variables: T['variables'],
+): Observable<FragmentState<T['response']>>;

package/store/observeQueryExperimental.js.flow

@@ -32,7 +32,7 @@ const {createOperationDescriptor} = require('./RelayModernOperationDescriptor');
  * This feature is still experimental and does not properly handle some resolver
  * features such as client-to-server edges.
  */
-function observeQuery<TVariables: Variables, TData>(
+function observeQuery<TVariables extends Variables, TData>(
   environment: IEnvironment,
   gqlQuery: Query<TVariables, TData>,
   variables: TVariables,
@@ -43,15 +43,15 @@ function observeQuery<TVariables: Variables, TData>(
   );
 
   const rootFragmentRef: $FlowFixMe = {
-    __id: operation.fragment.dataID,
+    __fragmentOwner: operation.request,
     __fragments: {
       [operation.fragment.node.name]: operation.request.variables,
     },
-    __fragmentOwner: operation.request,
+    __id: operation.fragment.dataID,
   };
 
-  const fragmentNode: Fragment<$FlowFixMe, TData> = (operation.request.node
-    .fragment: $FlowFixMe);
+  const fragmentNode: Fragment<$FlowFixMe, TData> = operation.request.node
+    .fragment as $FlowFixMe;
 
   return observeFragment(environment, fragmentNode, rootFragmentRef);
 }

package/store/readInlineData.d.ts

@@ -0,0 +1,19 @@
+/**
+ * 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.
+ */
+
+import type { GraphQLTaggedNode } from '../query/GraphQLTag';
+import type {KeyType, KeyTypeData} from './RelayStoreTypes';
+
+export function readInlineData<TKey extends KeyType>(
+    fragmentInput: GraphQLTaggedNode,
+    fragmentRef: TKey,
+): KeyTypeData<TKey>;
+
+export function readInlineData<TKey extends KeyType>(
+    fragmentInput: GraphQLTaggedNode,
+    fragmentRef: TKey | null | undefined,
+): KeyTypeData<TKey> | null | undefined;

package/store/readInlineData.js.flow

@@ -20,26 +20,26 @@ const {FRAGMENTS_KEY} = require('./RelayStoreUtils');
 const invariant = require('invariant');
 
 type HasSpread<TFragmentType> = {
-  +$fragmentSpreads: TFragmentType,
+  readonly $fragmentSpreads: TFragmentType,
   ...
 };
 
 /**
  * Reads an @inline data fragment that was spread into the parent fragment.
  */
-declare function readInlineData<TFragmentType: FragmentType, TData>(
+declare function readInlineData<TFragmentType extends FragmentType, TData>(
   fragment: InlineFragment<TFragmentType, TData>,
   key: HasSpread<TFragmentType>,
 ): TData;
-declare function readInlineData<TFragmentType: FragmentType, TData>(
+declare function readInlineData<TFragmentType extends FragmentType, TData>(
   fragment: InlineFragment<TFragmentType, TData>,
   key: ?HasSpread<TFragmentType>,
 ): ?TData;
 
 function readInlineData(
   fragment: GraphQLTaggedNode,
-  fragmentRef: mixed,
-): mixed {
+  fragmentRef: unknown,
+): unknown {
   const inlineDataFragment = getInlineDataFragment(fragment);
   if (fragmentRef == null) {
     return fragmentRef;