react-relay 21.0.0 → 21.0.1

package/relay-hooks/__flowtests__/utils.js.flow

@@ -32,22 +32,22 @@ declare export var refetchableFragmentInput: RefetchableFragment<
 declare export opaque type Example_user$fragmentType: FragmentType;
 export type Example_user$data = NonNullableData;
 export type Example_user$key = {
-  +$data?: Example_user$data,
-  +$fragmentSpreads: Example_user$fragmentType,
+  readonly $data?: Example_user$data,
+  readonly $fragmentSpreads: Example_user$fragmentType,
   ...
 };
 
 export type NonNullableData = {
-  +id: string,
-  +count: number,
+  readonly id: string,
+  readonly count: number,
 };
 export type NullableData = ?NonNullableData;
 export type NonNullablePluralData = ReadonlyArray<NonNullableData>;
 export type NullablePluralData = ?ReadonlyArray<NonNullableData>;
 
 export type AnotherNonNullableData = {
-  +name: ?string,
-  +friends: ?number,
+  readonly name: ?string,
+  readonly friends: ?number,
 };
 
 declare export var keyNonNullable: Example_user$key;
@@ -59,25 +59,25 @@ declare export var keyNullablePlural: ?ReadonlyArray<Example_user$key>;
 declare export var keyNullable: ?Example_user$key;
 
 declare export var keyAnotherNonNullable: {
-  +$data: AnotherNonNullableData,
-  +$fragmentSpreads: FragmentType,
+  readonly $data: AnotherNonNullableData,
+  readonly $fragmentSpreads: FragmentType,
   ...
 };
 
 declare export var keyAnotherNullable: ?{
-  +$data: AnotherNonNullableData,
-  +$fragmentSpreads: FragmentType,
+  readonly $data: AnotherNonNullableData,
+  readonly $fragmentSpreads: FragmentType,
   ...
 };
 
 declare export var fragmentData: {
-  +$fragmentType: FragmentType,
+  readonly $fragmentType: FragmentType,
   ...
 };
 
 export type QueryOperation = {
-  +variables: QueryVariables,
-  +response: {...},
+  readonly variables: QueryVariables,
+  readonly response: {...},
 };
 
 export type QueryVariables = {

package/relay-hooks/legacy/useBlockingPaginationFragment.js.flow

@@ -31,7 +31,9 @@ type RefetchVariables<TVariables, TKey> =
   // NOTE: This type ensures that the type of the variables is either:
   //   - nullable if the provided ref type is non-nullable
   //   - non-nullable if the provided ref type is nullable, and the caller need to provide the full set of variables
-  [+key: TKey] extends [+key: {+$fragmentSpreads: unknown, ...}]
+  [readonly key: TKey] extends [
+    readonly key: {readonly $fragmentSpreads: unknown, ...},
+  ]
     ? Partial<TVariables>
     : TVariables;
 
@@ -49,7 +51,9 @@ type ReturnType<TVariables, TData, TKey> = {
   // NOTE: This rtpw ensures that the type of the returned data is either:
   //   - nullable if the provided ref type is nullable
   //   - non-nullable if the provided ref type is non-nullable
-  data: [+key: TKey] extends [+key: {+$fragmentSpreads: unknown, ...}]
+  data: [readonly key: TKey] extends [
+    readonly key: {readonly $fragmentSpreads: unknown, ...},
+  ]
     ? TData
     : ?TData,
   loadNext: LoadMoreFn<TVariables>,
@@ -63,7 +67,7 @@ hook useBlockingPaginationFragment<
   TFragmentType extends FragmentType,
   TVariables extends Variables,
   TData,
-  TKey extends ?{+$fragmentSpreads: TFragmentType, ...},
+  TKey extends ?{readonly $fragmentSpreads: TFragmentType, ...},
 >(
   fragmentInput: RefetchableFragment<TFragmentType, TData, TVariables>,
   parentFragmentRef: TKey,
@@ -99,7 +103,7 @@ hook useBlockingPaginationFragment<
       variables: TVariables,
     },
     {
-      +$data: unknown,
+      readonly $data: unknown,
       ...
     },
   >(fragmentNode, parentFragmentRef, componentDisplayName);

package/relay-hooks/legacy/useRefetchableFragmentNode.js.flow

@@ -57,15 +57,15 @@ export type RefetchFn<
 //    /non-null/.
 export type RefetchFnDynamic<
   TQuery extends OperationType,
-  TKey extends ?{+$data?: unknown, ...},
+  TKey extends ?{readonly $data?: unknown, ...},
   TOptions = Options,
-> = [TKey] extends [{+$data?: unknown, ...}]
+> = [TKey] extends [{readonly $data?: unknown, ...}]
   ? RefetchFnInexact<TQuery, TOptions>
   : RefetchFnExact<TQuery, TOptions>;
 
 export type ReturnType<
   TQuery extends OperationType,
-  TKey extends ?{+$data?: unknown, ...},
+  TKey extends ?{readonly $data?: unknown, ...},
   TOptions = Options,
 > = {
   fragmentData: unknown,
@@ -164,7 +164,7 @@ function reducer(state: RefetchState, action: Action): RefetchState {
 
 hook useRefetchableFragmentNode<
   TQuery extends OperationType,
-  TKey extends ?{+$data?: unknown, ...},
+  TKey extends ?{readonly $data?: unknown, ...},
 >(
   fragmentNode: ReaderFragment,
   parentFragmentRef: unknown,

package/relay-hooks/loadEntryPoint.d.ts

@@ -0,0 +1,14 @@
+/**
+ * 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 {EnvironmentProviderOptions, GetEntryPointComponentFromEntryPoint, GetEntryPointParamsFromEntryPoint, IEnvironmentProvider, PreloadedEntryPoint} from '../ReactRelayTypes';
+
+export function loadEntryPoint<TEntryPoint>(
+    environmentProvider: IEnvironmentProvider<EnvironmentProviderOptions>,
+    entryPoint: TEntryPoint,
+    entryPointParams: GetEntryPointParamsFromEntryPoint<TEntryPoint>,
+): PreloadedEntryPoint<GetEntryPointComponentFromEntryPoint<TEntryPoint>>;

package/relay-hooks/loadEntryPoint.js.flow

@@ -25,7 +25,7 @@ const {loadQuery} = require('./loadQuery');
 function loadEntryPoint<
   TEntryPointParams extends {...},
   // $FlowExpectedError[unclear-type] Need any to make it supertype of all PreloadedQuery
-  TPreloadedQueries extends {+[string]: PreloadedQuery<any>},
+  TPreloadedQueries extends {readonly [string]: PreloadedQuery<any>},
   TPreloadedEntryPoints extends {...},
   TRuntimeProps extends {...},
   TExtraProps,

package/relay-hooks/loadQuery.d.ts

@@ -0,0 +1,20 @@
+/**
+ * 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 {EnvironmentProviderOptions, LoadQueryOptions, PreloadedQuery} from '../ReactRelayTypes';
+import {GraphQLTaggedNode, IEnvironment, OperationType, PreloadableConcreteRequest, VariablesOf} from 'relay-runtime';
+
+export function loadQuery<
+    TQuery extends OperationType,
+    TEnvironmentProviderOptions extends EnvironmentProviderOptions = Record<string, unknown>,
+>(
+    environment: IEnvironment,
+    preloadableRequest: GraphQLTaggedNode | PreloadableConcreteRequest<TQuery>,
+    variables: VariablesOf<TQuery>,
+    options?: LoadQueryOptions,
+    environmentProviderOptions?: TEnvironmentProviderOptions,
+): PreloadedQuery<TQuery, TEnvironmentProviderOptions>;

package/relay-hooks/loadQuery.js.flow

@@ -50,7 +50,7 @@ export type QueryType<T> =
         response: D,
         rawResponse?: NonNullable<RR>,
       }
-    : [+t: T] extends [+t: PreloadableConcreteRequest<infer V>]
+    : [readonly t: T] extends [readonly t: PreloadableConcreteRequest<infer V>]
       ? V
       : empty;
 

package/relay-hooks/prepareEntryPoint_DEPRECATED.js.flow

@@ -24,7 +24,7 @@ const preloadQuery = require('./preloadQuery_DEPRECATED');
 function prepareEntryPoint<
   TEntryPointParams extends {...},
   // $FlowExpectedError[unclear-type] Need any to make it supertype of all PreloadedQuery
-  TPreloadedQueries extends {+[string]: PreloadedQuery<any>},
+  TPreloadedQueries extends {readonly [string]: PreloadedQuery<any>},
   TPreloadedEntryPoints extends {...},
   TRuntimeProps extends {...},
   TExtraProps,

package/relay-hooks/readFragmentInternal.js.flow

@@ -157,8 +157,8 @@ function readFragmentInternal(
   queryOptions?: FragmentQueryOptions,
   fragmentKey?: string,
 ): {
-  +data: ?SelectorData | Array<?SelectorData>,
-  +clientEdgeQueries: ?Array<QueryResult>,
+  readonly data: ?SelectorData | Array<?SelectorData>,
+  readonly clientEdgeQueries: ?Array<QueryResult>,
 } {
   const fragmentSelector = getSelector(fragmentNode, fragmentRef);
   const isPlural = fragmentNode?.metadata?.plural === true;

package/relay-hooks/rsc/serverPreloadQuery.js.flow

@@ -17,16 +17,16 @@ const invariant = require('invariant');
 const {createOperationDescriptor, getRequest} = require('relay-runtime');
 
 export type PreloadedQueryResponse<TData> = {
-  +data: TData,
-  +errors?: ReadonlyArray<PayloadError>,
+  readonly data: TData,
+  readonly errors?: ReadonlyArray<PayloadError>,
 };
 
 export type PreloadedQueryRef<TVariables, TData> = {
-  +kind: 'PreloadedQueryRef',
-  +queryId: string,
-  +variables: TVariables,
-  +_response: Promise<PreloadedQueryResponse<TData>>,
-  +fetchedAt: number,
+  readonly kind: 'PreloadedQueryRef',
+  readonly queryId: string,
+  readonly variables: TVariables,
+  readonly _response: Promise<PreloadedQueryResponse<TData>>,
+  readonly fetchedAt: number,
 };
 
 function serverPreloadQuery<TVariables extends Variables, TData>(

package/relay-hooks/rsc/serverReadFragment.js.flow

@@ -16,7 +16,7 @@ import type {Fragment, FragmentType, IEnvironment} from 'relay-runtime';
 const {waitForFragmentData} = require('relay-runtime/experimental');
 
 type HasSpread<TFragmentType> = {
-  +$fragmentSpreads: TFragmentType,
+  readonly $fragmentSpreads: TFragmentType,
   ...
 };
 

package/relay-hooks/useClientQuery.d.ts

@@ -0,0 +1,16 @@
+/**
+ * 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 {GraphQLTaggedNode, OperationType, RenderPolicy, VariablesOf} from 'relay-runtime';
+
+export function useClientQuery<TQuery extends OperationType>(
+    gqlQuery: GraphQLTaggedNode,
+    variables: VariablesOf<TQuery>,
+    options?: {
+        UNSTABLE_renderPolicy?: RenderPolicy | undefined;
+    },
+): TQuery['response'];

package/relay-hooks/useEntryPointLoader.d.ts

@@ -0,0 +1,21 @@
+/**
+ * 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 {EnvironmentProviderOptions, GetEntryPointComponentFromEntryPoint, GetEntryPointParamsFromEntryPoint, IEnvironmentProvider, PreloadedEntryPoint} from '../ReactRelayTypes';
+import { DisposeFn } from 'relay-runtime';
+
+export type UseEntryPointLoaderHookType<TEntryPoint> = [
+    PreloadedEntryPoint<GetEntryPointComponentFromEntryPoint<TEntryPoint>> | null | undefined,
+    (entryPointParams: GetEntryPointParamsFromEntryPoint<TEntryPoint>) => void,
+    DisposeFn,
+];
+
+export function useEntryPointLoader<TEntryPoint>(
+    environmentProvider: IEnvironmentProvider<EnvironmentProviderOptions>,
+    entryPoint: TEntryPoint,
+    // Have opted to not include the TEST_ONLY__initialEntryPointData object here—as is FB internal
+): UseEntryPointLoaderHookType<TEntryPoint>;

package/relay-hooks/useEntryPointLoader.js.flow

@@ -55,7 +55,7 @@ const initialNullEntryPointReferenceState: NullEntryPointReference = {
 hook useLoadEntryPoint<
   TEntryPointParams extends {...},
   // $FlowExpectedError[unclear-type] Need any to make it supertype of all PreloadedQuery
-  TPreloadedQueries extends {+[string]: PreloadedQuery<any>},
+  TPreloadedQueries extends {readonly [string]: PreloadedQuery<any>},
   TPreloadedEntryPoints extends {...},
   TRuntimeProps extends {...},
   TExtraProps,

package/relay-hooks/useFragment.d.ts

@@ -0,0 +1,36 @@
+/**
+ * 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 {ArrayKeyType, ArrayKeyTypeData, KeyType, KeyTypeData} from '../ReactRelayTypes';
+import { GraphQLTaggedNode } from 'relay-runtime';
+
+// NOTE: These declares ensure that the type of the returned data is:
+//   - non-nullable if the provided ref type is non-nullable
+//   - nullable if the provided ref type is nullable
+//   - array of non-nullable if the provided ref type is an array of
+//     non-nullable refs
+//   - array of nullable if the provided ref type is an array of nullable refs
+
+export function useFragment<TKey extends KeyType>(
+    fragmentInput: GraphQLTaggedNode,
+    fragmentRef: TKey,
+): KeyTypeData<TKey>;
+
+export function useFragment<TKey extends KeyType>(
+    fragmentInput: GraphQLTaggedNode,
+    fragmentRef: TKey | null | undefined,
+): KeyTypeData<TKey> | null | undefined;
+
+export function useFragment<TKey extends ArrayKeyType>(
+    fragmentInput: GraphQLTaggedNode,
+    fragmentRef: TKey,
+): ArrayKeyTypeData<TKey>;
+
+export function useFragment<TKey extends ArrayKeyType>(
+    fragmentInput: GraphQLTaggedNode,
+    fragmentRef: TKey | null | undefined,
+): ArrayKeyTypeData<TKey> | null | undefined;

package/relay-hooks/useFragment.js.flow

@@ -19,7 +19,7 @@ const {useDebugValue} = require('react');
 const {getFragment} = require('relay-runtime');
 
 type HasSpread<TFragmentType> = {
-  +$fragmentSpreads: TFragmentType,
+  readonly $fragmentSpreads: TFragmentType,
   ...
 };
 

package/relay-hooks/useIsParentQueryActive.js.flow

@@ -18,7 +18,11 @@ const useStaticFragmentNodeWarning = require('./useStaticFragmentNodeWarning');
 const {getFragment} = require('relay-runtime');
 
 hook useIsParentQueryActive<
-  TKey extends ?{+$data?: unknown, +$fragmentSpreads: FragmentType, ...},
+  TKey extends ?{
+    readonly $data?: unknown,
+    readonly $fragmentSpreads: FragmentType,
+    ...
+  },
 >(
   fragmentInput: GraphQLTaggedNode,
   fragmentRef: TKey,

package/relay-hooks/useLazyLoadQuery.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 {CacheConfig, FetchPolicy, GraphQLTaggedNode, OperationType, RenderPolicy, VariablesOf} from 'relay-runtime';
+
+export function useLazyLoadQuery<TQuery extends OperationType>(
+    gqlQuery: GraphQLTaggedNode,
+    variables: VariablesOf<TQuery>,
+    options?: {
+        fetchKey?: string | number | undefined;
+        fetchPolicy?: FetchPolicy | undefined;
+        networkCacheConfig?: CacheConfig | undefined;
+        UNSTABLE_renderPolicy?: RenderPolicy | undefined;
+    },
+): TQuery['response'];

package/relay-hooks/useLazyLoadQuery.js.flow

@@ -47,19 +47,19 @@ type Options = {
    *      * "network-only": *will* *not* reuse locally cached data, and will *always* send a network request to fetch the query, ignoring any data that might be locally cached in Relay.
    *      * "store-only": *will* *only* reuse locally cached data, and will *never* send a network request to fetch the query. In this case, the responsibility of fetching the query falls to the caller, but this policy could also be used to read and operate on data that is entirely [local](../../guided-tour/updating-data/local-data-updates).
    */
-  +fetchPolicy?: FetchPolicy,
+  readonly fetchPolicy?: FetchPolicy,
   /**
    * A `fetchKey` can be passed to force a re-evaluation of the current query and variables when the component re-renders, even if the variables didn't change, or even if the component isn't remounted (similarly to how passing a different `key` to a React component will cause it to remount). If the `fetchKey` is different from the one used in the previous render, the current query will be re-evaluated against the store, and it might be refetched depending on the current `fetchPolicy` and the state of the cache.
    */
-  +fetchKey?: string | number,
+  readonly fetchKey?: string | number,
   /**
    * Default value: `{force: true}`. Object containing cache config options for the *network layer*. Note that the network layer may contain an *additional* query response cache which will reuse network responses for identical queries. If you want to bypass this cache completely (which is the default behavior), pass `{force: true}` as the value for this option.
    */
-  +networkCacheConfig?: CacheConfig,
+  readonly networkCacheConfig?: CacheConfig,
   /**
    * Undocumented option.
    */
-  +UNSTABLE_renderPolicy?: RenderPolicy,
+  readonly UNSTABLE_renderPolicy?: RenderPolicy,
 };
 
 /**

package/relay-hooks/useLoadMoreFunction.d.ts

@@ -0,0 +1,56 @@
+/**
+ * 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 {
+  ConcreteRequest,
+  Disposable,
+  DisposeFn,
+  GraphQLResponse,
+  Observer,
+  OperationType,
+  ReaderFragment,
+  ReaderPaginationMetadata,
+  VariablesOf,
+} from 'relay-runtime';
+
+export type Direction = 'forward' | 'backward';
+
+export type LoadMoreFn<TQuery extends OperationType> = (
+    count: number,
+    options?: {
+        onComplete?: ((arg: Error | null) => void) | undefined;
+        UNSTABLE_extraVariables?: Partial<VariablesOf<TQuery>> | undefined;
+    },
+) => Disposable;
+
+export interface UseLoadMoreFunctionArgs {
+    direction: Direction;
+    fragmentNode: ReaderFragment;
+    fragmentRef: unknown;
+    fragmentIdentifier: string;
+    fragmentData: unknown;
+    connectionPathInFragmentData: ReadonlyArray<string | number>;
+    identifierField?: string | null | undefined;
+    paginationRequest: ConcreteRequest;
+    paginationMetadata: ReaderPaginationMetadata;
+    componentDisplayName: string;
+    observer: Observer<GraphQLResponse>;
+    onReset: () => void;
+}
+export function useLoadMoreFunction<TQuery extends OperationType>(
+    args: UseLoadMoreFunctionArgs,
+): [LoadMoreFn<TQuery>, boolean, DisposeFn];
+
+export function getConnectionState(
+    direction: Direction,
+    fragmentNode: ReaderFragment,
+    fragmentData: unknown,
+    connectionPathInFragmentData: ReadonlyArray<string | number>,
+): {
+    cursor?: string | null | undefined;
+    hasMore: boolean;
+};

package/relay-hooks/useMutation.d.ts

@@ -0,0 +1,36 @@
+/**
+ * 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 {
+  DeclarativeMutationConfig,
+  Disposable,
+  GraphQLTaggedNode,
+  IEnvironment,
+  MutationConfig,
+  MutationParameters,
+  PayloadError,
+  SelectorStoreUpdater,
+  UploadableMap,
+  VariablesOf,
+} from 'relay-runtime';
+
+export interface UseMutationConfig<TMutation extends MutationParameters> {
+    variables: VariablesOf<TMutation>;
+    updater?: SelectorStoreUpdater<TMutation['response']> | null | undefined;
+    uploadables?: UploadableMap | undefined;
+    optimisticUpdater?: SelectorStoreUpdater<TMutation['response']> | null | undefined;
+    optimisticResponse?: TMutation['rawResponse'] | undefined;
+    configs?: DeclarativeMutationConfig[] | undefined;
+    onError?: ((error: Error) => void | null) | undefined;
+    onCompleted?: ((response: TMutation['response'], errors: PayloadError[] | null) => void | null) | undefined;
+    onUnsubscribe?: (() => void | null) | undefined;
+}
+
+export function useMutation<TMutation extends MutationParameters>(
+    mutation: GraphQLTaggedNode,
+    commitMutationFn?: (environment: IEnvironment, config: MutationConfig<TMutation>) => Disposable,
+): [(config: UseMutationConfig<TMutation>) => Disposable, boolean];

package/relay-hooks/useMutation.js.flow

@@ -40,7 +40,7 @@ export type UseMutationConfig<TMutation extends MutationParameters> = {
   onNext?: ?() => void,
   onUnsubscribe?: ?() => void,
   optimisticResponse?: {
-    +rawResponse?: {...},
+    readonly rawResponse?: {...},
     ...TMutation,
     ...
   }['rawResponse'],

package/relay-hooks/usePaginationFragment.d.ts

@@ -0,0 +1,33 @@
+/**
+ * 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 {KeyType, KeyTypeData, RefetchFnDynamic} from '../ReactRelayTypes';
+import { LoadMoreFn } from './useLoadMoreFunction';
+import {GraphQLTaggedNode, OperationType} from 'relay-runtime';
+
+export interface usePaginationFragmentHookType<
+    TQuery extends OperationType,
+    TKey extends KeyType | null | undefined,
+    TFragmentData,
+> {
+    data: TFragmentData;
+    loadNext: LoadMoreFn<TQuery>;
+    loadPrevious: LoadMoreFn<TQuery>;
+    hasNext: boolean;
+    hasPrevious: boolean;
+    isLoadingNext: boolean;
+    isLoadingPrevious: boolean;
+    refetch: RefetchFnDynamic<TQuery, TKey>;
+}
+export function usePaginationFragment<TQuery extends OperationType, TKey extends KeyType>(
+    fragmentInput: GraphQLTaggedNode,
+    parentFragmentRef: TKey,
+): usePaginationFragmentHookType<TQuery, TKey, KeyTypeData<TKey>>;
+export function usePaginationFragment<TQuery extends OperationType, TKey extends KeyType>(
+    fragmentInput: GraphQLTaggedNode,
+    parentFragmentRef: TKey | null | undefined,
+): usePaginationFragmentHookType<TQuery, TKey | null, KeyTypeData<TKey> | null | undefined>;

package/relay-hooks/usePaginationFragment.js.flow

@@ -34,12 +34,14 @@ const {
 
 type RefetchVariables<
   TVariables,
-  TKey extends ?{+$fragmentSpreads: unknown, ...},
+  TKey extends ?{readonly $fragmentSpreads: unknown, ...},
 > =
   // NOTE: This type ensures that the type of the returned variables is either:
   //   - nullable if the provided ref type is nullable
   //   - non-nullable if the provided ref type is non-nullable
-  [+key: TKey] extends [+key: {+$fragmentSpreads: unknown, ...}]
+  [readonly key: TKey] extends [
+    readonly key: {readonly $fragmentSpreads: unknown, ...},
+  ]
     ? Partial<TVariables>
     : TVariables;
 
@@ -57,7 +59,9 @@ export type ReturnType<TVariables, TData, TKey> = {
   // NOTE: This type ensures that the type of the returned data is either:
   //   - nullable if the provided ref type is nullable
   //   - non-nullable if the provided ref type is non-nullable
-  data: [+key: TKey] extends [+key: {+$fragmentSpreads: unknown, ...}]
+  data: [readonly key: TKey] extends [
+    readonly key: {readonly $fragmentSpreads: unknown, ...},
+  ]
     ? TData
     : ?TData,
   loadNext: LoadMoreFn<TVariables>,
@@ -76,7 +80,7 @@ export type UsePaginationFragmentType = <
   TFragmentType extends FragmentType,
   TVariables extends Variables,
   TData,
-  TKey extends ?{+$fragmentSpreads: TFragmentType, ...},
+  TKey extends ?{readonly $fragmentSpreads: TFragmentType, ...},
 >(
   fragmentInput: RefetchableFragment<TFragmentType, TData, TVariables>,
   parentFragmentRef: TKey,
@@ -86,7 +90,7 @@ hook usePaginationFragment<
   TFragmentType extends FragmentType,
   TVariables extends Variables,
   TData,
-  TKey extends ?{+$fragmentSpreads: TFragmentType, ...},
+  TKey extends ?{readonly $fragmentSpreads: TFragmentType, ...},
 >(
   fragmentInput: RefetchableFragment<TFragmentType, TData, TVariables>,
   parentFragmentRef: TKey,

package/relay-hooks/usePrefetchableForwardPaginationFragment.js.flow

@@ -55,7 +55,9 @@ export type ReturnType<TVariables, TData, TEdgeData, TKey> = {
   // NOTE: This type ensures that the type of the returned data is either:
   //   - nullable if the provided ref type is nullable
   //   - non-nullable if the provided ref type is non-nullable
-  data: [+key: TKey] extends [+key: {+$fragmentSpreads: unknown, ...}]
+  data: [readonly key: TKey] extends [
+    readonly key: {readonly $fragmentSpreads: unknown, ...},
+  ]
     ? TData
     : ?TData,
   loadNext: LoadMoreFn<TVariables>,
@@ -72,7 +74,9 @@ type LoadMoreOptions<TVariables> = {
 
 export type GetExtraVariablesFn<TEdgeData, TData, TVariables, TKey> = ({
   hasNext: boolean,
-  data: [+key: TKey] extends [+key: {+$fragmentSpreads: unknown, ...}]
+  data: [readonly key: TKey] extends [
+    readonly key: {readonly $fragmentSpreads: unknown, ...},
+  ]
     ? TData
     : ?TData,
   getServerEdges: () => TEdgeData,
@@ -83,7 +87,7 @@ hook usePrefetchableForwardPaginationFragment<
   TVariables extends Variables,
   TData,
   TEdgeData,
-  TKey extends ?{+$fragmentSpreads: TFragmentType, ...},
+  TKey extends ?{readonly $fragmentSpreads: TFragmentType, ...},
 >(
   fragmentInput: PrefetchableRefetchableFragment<
     TFragmentType,

package/relay-hooks/usePrefetchableForwardPaginationFragment_EXPERIMENTAL.js.flow

@@ -55,7 +55,9 @@ export type ReturnType<TVariables, TData, TEdgeData, TKey> = {
   // NOTE: This type ensures that the type of the returned data is either:
   //   - nullable if the provided ref type is nullable
   //   - non-nullable if the provided ref type is non-nullable
-  data: [+key: TKey] extends [+key: {+$fragmentSpreads: unknown, ...}]
+  data: [readonly key: TKey] extends [
+    readonly key: {readonly $fragmentSpreads: unknown, ...},
+  ]
     ? TData
     : ?TData,
   loadNext: LoadMoreFn<TVariables>,
@@ -72,7 +74,9 @@ type LoadMoreOptions<TVariables> = {
 
 export type GetExtraVariablesFn<TEdgeData, TData, TVariables, TKey> = ({
   hasNext: boolean,
-  data: [+key: TKey] extends [+key: {+$fragmentSpreads: unknown, ...}]
+  data: [readonly key: TKey] extends [
+    readonly key: {readonly $fragmentSpreads: unknown, ...},
+  ]
     ? TData
     : ?TData,
   getServerEdges: () => TEdgeData,
@@ -83,7 +87,7 @@ hook usePrefetchableForwardPaginationFragment_EXPERIMENTAL<
   TVariables extends Variables,
   TData,
   TEdgeData,
-  TKey extends ?{+$fragmentSpreads: TFragmentType, ...},
+  TKey extends ?{readonly $fragmentSpreads: TFragmentType, ...},
 >(
   fragmentInput: PrefetchableRefetchableFragment<
     TFragmentType,