react-relay 20.1.1 → 21.0.1

package/relay-hooks/useQueryLoader.js.flow

@@ -30,14 +30,14 @@ const useRelayEnvironment = require('./useRelayEnvironment');
 const {useCallback, useEffect, useRef, useState} = require('react');
 const {RelayFeatureFlags, getRequest} = require('relay-runtime');
 
-export type LoaderFn<TQuery: OperationType> = (
+export type LoaderFn<TQuery extends OperationType> = (
   variables: TQuery['variables'],
   options?: UseQueryLoaderLoadQueryOptions,
 ) => void;
 
-export type UseQueryLoaderLoadQueryOptions = $ReadOnly<{
+export type UseQueryLoaderLoadQueryOptions = Readonly<{
   ...LoadQueryOptions,
-  +__environment?: ?IEnvironment,
+  readonly __environment?: ?IEnvironment,
 }>;
 
 // NullQueryReference needs to implement referential equality,
@@ -51,13 +51,13 @@ const initialNullQueryReferenceState: NullQueryReference = {
 };
 
 function requestIsLiveQuery<
-  TVariables: Variables,
+  TVariables extends Variables,
   TData,
-  TRawResponse: ?{...} = void,
-  TQuery: OperationType = {
+  TRawResponse extends ?{...} = void,
+  TQuery extends OperationType = {
     response: TData,
     variables: TVariables,
-    rawResponse?: $NonMaybeType<TRawResponse>,
+    rawResponse?: NonNullable<TRawResponse>,
   },
 >(
   preloadableRequest:
@@ -72,51 +72,55 @@ function requestIsLiveQuery<
 }
 
 export type UseQueryLoaderHookReturnType<
-  TVariables: Variables,
+  TVariables extends Variables,
   TData,
-  TRawResponse: ?{...} = void,
+  TRawResponse extends ?{...} = void,
 > = [
   ?PreloadedQuery<{
     response: TData,
     variables: TVariables,
-    rawResponse?: $NonMaybeType<TRawResponse>,
+    rawResponse?: NonNullable<TRawResponse>,
   }>,
   (variables: TVariables, options?: UseQueryLoaderLoadQueryOptions) => void,
   () => void,
 ];
 
 declare function useQueryLoader<
-  TVariables: Variables,
+  TVariables extends Variables,
   TData,
-  TRawResponse: ?{...} = void,
+  TRawResponse extends ?{...} = void,
 >(
   preloadableRequest: Query<TVariables, TData, TRawResponse>,
 ): UseQueryLoaderHookReturnType<TVariables, TData>;
 
 declare function useQueryLoader<
-  TVariables: Variables,
+  TVariables extends Variables,
   TData,
-  TRawResponse: ?{...} = void,
+  TRawResponse extends ?{...} = void,
 >(
   preloadableRequest: Query<TVariables, TData, TRawResponse>,
   initialQueryReference: ?PreloadedQuery<{
     response: TData,
     variables: TVariables,
-    rawResponse?: $NonMaybeType<TRawResponse>,
+    rawResponse?: NonNullable<TRawResponse>,
   }>,
 ): UseQueryLoaderHookReturnType<TVariables, TData>;
 
-declare function useQueryLoader<TQuery: OperationType>(
+declare function useQueryLoader<TQuery extends OperationType>(
   preloadableRequest: PreloadableConcreteRequest<TQuery>,
   initialQueryReference?: ?PreloadedQuery<TQuery>,
 ): UseQueryLoaderHookReturnType<TQuery['variables'], TQuery['response']>;
 
-hook useQueryLoader<TVariables: Variables, TData, TRawResponse: ?{...} = void>(
+hook useQueryLoader<
+  TVariables extends Variables,
+  TData,
+  TRawResponse extends ?{...} = void,
+>(
   preloadableRequest: Query<TVariables, TData, TRawResponse>,
   initialQueryReference?: ?PreloadedQuery<{
     response: TData,
     variables: TVariables,
-    rawResponse?: $NonMaybeType<TRawResponse>,
+    rawResponse?: NonNullable<TRawResponse>,
   }>,
 ): UseQueryLoaderHookReturnType<TVariables, TData> {
   if (RelayFeatureFlags.ENABLE_ACTIVITY_COMPATIBILITY) {
@@ -133,21 +137,21 @@ hook useQueryLoader<TVariables: Variables, TData, TRawResponse: ?{...} = void>(
 }
 
 hook useQueryLoader_CURRENT<
-  TVariables: Variables,
+  TVariables extends Variables,
   TData,
-  TRawResponse: ?{...} = void,
+  TRawResponse extends ?{...} = void,
 >(
   preloadableRequest: Query<TVariables, TData, TRawResponse>,
   initialQueryReference?: ?PreloadedQuery<{
     response: TData,
     variables: TVariables,
-    rawResponse?: $NonMaybeType<TRawResponse>,
+    rawResponse?: NonNullable<TRawResponse>,
   }>,
 ): UseQueryLoaderHookReturnType<TVariables, TData> {
   type QueryType = {
     response: TData,
     variables: TVariables,
-    rawResponse?: $NonMaybeType<TRawResponse>,
+    rawResponse?: NonNullable<TRawResponse>,
   };
 
   /**
@@ -213,9 +217,9 @@ hook useQueryLoader_CURRENT<
       const mergedOptions: ?UseQueryLoaderLoadQueryOptions =
         options != null && options.hasOwnProperty('__environment')
           ? {
+              __nameForWarning: options.__nameForWarning,
               fetchPolicy: options.fetchPolicy,
               networkCacheConfig: options.networkCacheConfig,
-              __nameForWarning: options.__nameForWarning,
             }
           : options;
       if (isMountedRef.current) {
@@ -223,7 +227,7 @@ hook useQueryLoader_CURRENT<
           options?.__environment ?? environment,
           preloadableRequest,
           variables,
-          (mergedOptions: $FlowFixMe),
+          mergedOptions as $FlowFixMe,
         );
         undisposedQueryReferencesRef.current.add(updatedQueryReference);
         setQueryReference(updatedQueryReference);

package/relay-hooks/useQueryLoader_EXPERIMENTAL.js.flow

@@ -40,13 +40,13 @@ const initialNullQueryReferenceState: NullQueryReference = {
 };
 
 function requestIsLiveQuery<
-  TVariables: Variables,
+  TVariables extends Variables,
   TData,
-  TRawResponse: ?{...} = void,
-  TQuery: OperationType = {
+  TRawResponse extends ?{...} = void,
+  TQuery extends OperationType = {
     response: TData,
     variables: TVariables,
-    rawResponse?: $NonMaybeType<TRawResponse>,
+    rawResponse?: NonNullable<TRawResponse>,
   },
 >(
   preloadableRequest:
@@ -63,21 +63,21 @@ function requestIsLiveQuery<
 const CLEANUP_TIMEOUT = 1000 * 60 * 5; // 5 minutes;
 
 hook useQueryLoader_EXPERIMENTAL<
-  TVariables: Variables,
+  TVariables extends Variables,
   TData,
-  TRawResponse: ?{...} = void,
+  TRawResponse extends ?{...} = void,
 >(
   preloadableRequest: Query<TVariables, TData, TRawResponse>,
   initialQueryReference?: ?PreloadedQuery<{
     response: TData,
     variables: TVariables,
-    rawResponse?: $NonMaybeType<TRawResponse>,
+    rawResponse?: NonNullable<TRawResponse>,
   }>,
 ): UseQueryLoaderHookReturnType<TVariables, TData> {
   type QueryType = {
     response: TData,
     variables: TVariables,
-    rawResponse?: $NonMaybeType<TRawResponse>,
+    rawResponse?: NonNullable<TRawResponse>,
   };
 
   /**
@@ -151,16 +151,16 @@ hook useQueryLoader_EXPERIMENTAL<
       const mergedOptions: ?UseQueryLoaderLoadQueryOptions =
         options != null && options.hasOwnProperty('__environment')
           ? {
+              __nameForWarning: options.__nameForWarning,
               fetchPolicy: options.fetchPolicy,
               networkCacheConfig: options.networkCacheConfig,
-              __nameForWarning: options.__nameForWarning,
             }
           : options;
       const updatedQueryReference = loadQuery(
         options?.__environment ?? environment,
         preloadableRequest,
         variables,
-        (mergedOptions: $FlowFixMe),
+        mergedOptions as $FlowFixMe,
       );
       undisposedQueryReferencesRef.current?.add(updatedQueryReference);
       setQueryReference(updatedQueryReference);

package/relay-hooks/useRefetchableFragment.d.ts

@@ -0,0 +1,23 @@
+/**
+ * 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 {GraphQLTaggedNode, OperationType} from 'relay-runtime';
+
+export type useRefetchableFragmentHookType<
+    TQuery extends OperationType,
+    TKey extends KeyType | null | undefined,
+    TFragmentData,
+> = [TFragmentData, RefetchFnDynamic<TQuery, TKey>];
+export function useRefetchableFragment<TQuery extends OperationType, TKey extends KeyType>(
+    fragmentInput: GraphQLTaggedNode,
+    fragmentRef: TKey,
+): useRefetchableFragmentHookType<TQuery, TKey, KeyTypeData<TKey>>;
+export function useRefetchableFragment<TQuery extends OperationType, TKey extends KeyType>(
+    fragmentInput: GraphQLTaggedNode,
+    fragmentRef: TKey | null | undefined,
+): useRefetchableFragmentHookType<TQuery, TKey, KeyTypeData<TKey> | null | undefined>;

package/relay-hooks/useRefetchableFragment.js.flow

@@ -24,11 +24,16 @@ const useStaticFragmentNodeWarning = require('./useStaticFragmentNodeWarning');
 const {useDebugValue} = require('react');
 const {getFragment} = require('relay-runtime');
 
-type RefetchVariables<TVariables, TKey: ?{+$fragmentSpreads: mixed, ...}> =
+type RefetchVariables<
+  TVariables,
+  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: mixed, ...}]
+  [readonly key: TKey] extends [
+    readonly key: {readonly $fragmentSpreads: unknown, ...},
+  ]
     ? Partial<TVariables>
     : TVariables;
 
@@ -45,30 +50,34 @@ export type RefetchFn<TVariables, TKey, TOptions = Options> = RefetchFnBase<
 export type ReturnType<
   TVariables,
   TData,
-  TKey: ?{+$fragmentSpreads: mixed, ...},
+  TKey extends ?{readonly $fragmentSpreads: unknown, ...},
 > = [
   // 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
-  [+key: TKey] extends [+key: {+$fragmentSpreads: mixed, ...}] ? TData : ?TData,
+  [readonly key: TKey] extends [
+    readonly key: {readonly $fragmentSpreads: unknown, ...},
+  ]
+    ? TData
+    : ?TData,
   RefetchFn<TVariables, TKey>,
 ];
 
 export type UseRefetchableFragmentType = <
-  TFragmentType: FragmentType,
-  TVariables: Variables,
+  TFragmentType extends FragmentType,
+  TVariables extends Variables,
   TData,
-  TKey: ?{+$fragmentSpreads: TFragmentType, ...},
+  TKey extends ?{readonly $fragmentSpreads: TFragmentType, ...},
 >(
   fragment: RefetchableFragment<TFragmentType, TData, TVariables>,
   key: TKey,
 ) => ReturnType<TVariables, TData, TKey>;
 
 hook useRefetchableFragment<
-  TFragmentType: FragmentType,
-  TVariables: Variables,
+  TFragmentType extends FragmentType,
+  TVariables extends Variables,
   TData,
-  TKey: ?{+$fragmentSpreads: TFragmentType, ...},
+  TKey extends ?{readonly $fragmentSpreads: TFragmentType, ...},
 >(
   fragmentInput: RefetchableFragment<TFragmentType, TData, TVariables>,
   fragmentRef: TKey,
@@ -88,7 +97,7 @@ hook useRefetchableFragment<
     // $FlowFixMe[react-rule-hook-conditional]
     useDebugValue({fragment: fragmentNode.name, data: fragmentData});
   }
-  // $FlowFixMe[incompatible-return]
+  // $FlowFixMe[incompatible-type]
   // $FlowFixMe[prop-missing]
   return [fragmentData, refetch];
 }

package/relay-hooks/useRefetchableFragmentInternal.js.flow

@@ -46,7 +46,7 @@ const {
 const warning = require('warning');
 
 export type RefetchFn<
-  TQuery: OperationType,
+  TQuery extends OperationType,
   TOptions = Options,
 > = RefetchFnExact<TQuery, TOptions>;
 
@@ -56,20 +56,20 @@ export type RefetchFn<
 //  - Or, expects /a subset/ of the query variables if the provided key type is
 //    /non-null/.
 export type RefetchFnDynamic<
-  TQuery: OperationType,
-  TKey: ?{+$data?: mixed, ...},
+  TQuery extends OperationType,
+  TKey extends ?{readonly $data?: unknown, ...},
   TOptions = Options,
-> = [TKey] extends [{+$data?: mixed, ...}]
+> = [TKey] extends [{readonly $data?: unknown, ...}]
   ? RefetchFnInexact<TQuery, TOptions>
   : RefetchFnExact<TQuery, TOptions>;
 
 export type ReturnType<
-  TQuery: OperationType,
-  TKey: ?{+$data?: mixed, ...},
+  TQuery extends OperationType,
+  TKey extends ?{readonly $data?: unknown, ...},
   TOptions = Options,
 > = {
-  fragmentData: mixed,
-  fragmentRef: mixed,
+  fragmentData: unknown,
+  fragmentRef: unknown,
   refetch: RefetchFnDynamic<TQuery, TKey, TOptions>,
 };
 
@@ -89,14 +89,14 @@ type RefetchFnBase<TVars, TOptions> = (
   options?: TOptions,
 ) => Disposable;
 
-type RefetchFnExact<TQuery: OperationType, TOptions = Options> = RefetchFnBase<
-  VariablesOf<TQuery>,
-  TOptions,
->;
+type RefetchFnExact<
+  TQuery extends OperationType,
+  TOptions = Options,
+> = RefetchFnBase<VariablesOf<TQuery>, TOptions>;
 type RefetchFnInexact<
-  TQuery: OperationType,
+  TQuery extends OperationType,
   TOptions = Options,
-> = RefetchFnBase<$ReadOnly<Partial<VariablesOf<TQuery>>>, TOptions>;
+> = RefetchFnBase<Readonly<Partial<VariablesOf<TQuery>>>, TOptions>;
 
 type Action =
   | {
@@ -154,18 +154,18 @@ function reducer(state: RefetchState, action: Action): RefetchState {
       };
     }
     default: {
-      (action.type: empty);
+      action.type as empty;
       throw new Error('useRefetchableFragmentNode: Unexpected action type');
     }
   }
 }
 
 hook useRefetchableFragmentInternal<
-  TQuery: OperationType,
-  TKey: ?{+$data?: mixed, ...},
+  TQuery extends OperationType,
+  TKey extends ?{readonly $data?: unknown, ...},
 >(
   fragmentNode: ReaderFragment,
-  parentFragmentRef: mixed,
+  parentFragmentRef: unknown,
   componentDisplayName: string,
 ): ReturnType<TQuery, TKey, InternalOptions> {
   const parentEnvironment = useRelayEnvironment();
@@ -184,7 +184,7 @@ hook useRefetchableFragmentInternal<
     refetchEnvironment: null,
     refetchQuery: null,
     renderPolicy: undefined,
-  });
+  } as RefetchState);
   const {
     fetchPolicy,
     mirroredEnvironment,
@@ -206,14 +206,14 @@ hook useRefetchableFragmentInternal<
     TQuery['variables'],
     TQuery['response'],
     TQuery['rawResponse'],
-  >((refetchableRequest: $FlowFixMe));
+  >(refetchableRequest as $FlowFixMe);
 
   let fragmentRef = parentFragmentRef;
   if (shouldReset) {
     dispatch({
-      type: 'reset',
       environment,
       fragmentIdentifier,
+      type: 'reset',
     });
     disposeQuery();
   } else if (refetchQuery != null && queryRef != null) {
@@ -268,7 +268,6 @@ hook useRefetchableFragmentInternal<
         fetchPolicy,
         renderPolicy,
         {
-          error: handleQueryCompleted,
           complete: () => {
             // Validate that the type of the object we got back matches the type
             // of the object already in the store
@@ -282,6 +281,7 @@ hook useRefetchableFragmentInternal<
             }
             handleQueryCompleted();
           },
+          error: handleQueryCompleted,
         },
         queryRef.fetchKey,
         profilerContext,
@@ -350,12 +350,12 @@ hook useRefetchableFragmentInternal<
   return {
     fragmentData,
     fragmentRef,
-    // $FlowFixMe[incompatible-return] RefetchFn not compatible with RefetchFnDynamic
+    // $FlowFixMe[incompatible-type] RefetchFn not compatible with RefetchFnDynamic
     refetch,
   };
 }
 
-hook useRefetchFunction<TQuery: OperationType>(
+hook useRefetchFunction<TQuery extends OperationType>(
   componentDisplayName: string,
   dispatch: (
     | {
@@ -373,13 +373,13 @@ hook useRefetchFunction<TQuery: OperationType>(
       },
   ) => void,
   disposeQuery: () => void,
-  fragmentData: mixed,
+  fragmentData: unknown,
   fragmentIdentifier: string,
   fragmentNode: ReaderFragment,
-  fragmentRefPathInResponse: $ReadOnlyArray<string | number>,
+  fragmentRefPathInResponse: ReadonlyArray<string | number>,
   identifierInfo: ?RefetchableIdentifierInfo,
   loadQuery: LoaderFn<TQuery>,
-  parentFragmentRef: mixed,
+  parentFragmentRef: unknown,
   refetchableRequest: ConcreteRequest,
 ): RefetchFn<TQuery, InternalOptions> {
   const isMountedRef = useIsMountedRef();
@@ -446,7 +446,7 @@ hook useRefetchFunction<TQuery: OperationType>(
       // We fill in any variables not passed by the call to `refetch()` with the
       // variables from the original parent fragment owner.
       const refetchVariables: VariablesOf<TQuery> = {
-        ...(parentVariables: $FlowFixMe),
+        ...(parentVariables as $FlowFixMe),
         ...fragmentVariables,
         ...providedRefetchVariables,
       };
@@ -471,7 +471,7 @@ hook useRefetchFunction<TQuery: OperationType>(
             identifierValue,
           );
         }
-        (refetchVariables: $FlowFixMe)[
+        (refetchVariables as $FlowFixMe)[
           identifierInfo.identifierQueryVariableName
         ] = identifierValue;
       }
@@ -492,18 +492,18 @@ hook useRefetchFunction<TQuery: OperationType>(
       // so that they have been filtered out to include only the
       // variables actually declared in the query.
       loadQuery(refetchQuery.request.variables, {
-        fetchPolicy,
         __environment: refetchEnvironment,
         __nameForWarning: 'refetch',
+        fetchPolicy,
       });
 
       dispatch({
-        type: 'refetch',
         fetchPolicy,
         onComplete,
         refetchEnvironment,
         refetchQuery,
         renderPolicy,
+        type: 'refetch',
       });
       return {dispose: disposeQuery};
     },
@@ -521,33 +521,32 @@ hook useRefetchFunction<TQuery: OperationType>(
 let debugFunctions;
 if (__DEV__) {
   debugFunctions = {
-    getInitialIDAndType(
-      memoRefetchVariables: ?Variables,
-      fragmentRefPathInResponse: $ReadOnlyArray<string | number>,
-      identifierQueryVariableName: ?string,
-      environment: IEnvironment,
-    ): ?DebugIDandTypename {
-      const {Record} = require('relay-runtime');
-      const id = memoRefetchVariables?.[identifierQueryVariableName ?? 'id'];
-      if (
-        fragmentRefPathInResponse.length !== 1 ||
-        fragmentRefPathInResponse[0] !== 'node' ||
-        id == null
-      ) {
-        return null;
+    checkSameIDAfterRefetch(
+      previousIDAndTypename: ?DebugIDandTypename,
+      refetchedFragmentRef: unknown,
+      fragmentNode: ReaderFragment,
+      componentDisplayName: string,
+    ): void {
+      if (previousIDAndTypename == null || refetchedFragmentRef == null) {
+        return;
       }
-      const recordSource = environment.getStore().getSource();
-      const record = recordSource.get(id);
-      const typename = record == null ? null : Record.getType(record);
-      if (typename == null) {
-        return null;
+      const {ID_KEY} = require('relay-runtime');
+      // $FlowExpectedError[incompatible-use]
+      const resultID = refetchedFragmentRef[ID_KEY];
+      if (resultID != null && resultID !== previousIDAndTypename.id) {
+        warning(
+          false,
+          'Relay: Call to `refetch` returned a different id, expected ' +
+            '`%s`, got `%s`, on `%s` in `%s`. ' +
+            'Please make sure the server correctly implements ' +
+            'unique id requirement.',
+          resultID,
+          previousIDAndTypename.id,
+          fragmentNode.name,
+          componentDisplayName,
+        );
       }
-      return {
-        id,
-        typename,
-      };
     },
-
     checkSameTypeAfterRefetch(
       previousIDAndType: ?DebugIDandTypename,
       environment: IEnvironment,
@@ -575,32 +574,31 @@ if (__DEV__) {
         );
       }
     },
-
-    checkSameIDAfterRefetch(
-      previousIDAndTypename: ?DebugIDandTypename,
-      refetchedFragmentRef: mixed,
-      fragmentNode: ReaderFragment,
-      componentDisplayName: string,
-    ): void {
-      if (previousIDAndTypename == null || refetchedFragmentRef == null) {
-        return;
+    getInitialIDAndType(
+      memoRefetchVariables: ?Variables,
+      fragmentRefPathInResponse: ReadonlyArray<string | number>,
+      identifierQueryVariableName: ?string,
+      environment: IEnvironment,
+    ): ?DebugIDandTypename {
+      const {Record} = require('relay-runtime');
+      const id = memoRefetchVariables?.[identifierQueryVariableName ?? 'id'];
+      if (
+        fragmentRefPathInResponse.length !== 1 ||
+        fragmentRefPathInResponse[0] !== 'node' ||
+        id == null
+      ) {
+        return null;
       }
-      const {ID_KEY} = require('relay-runtime');
-      // $FlowExpectedError[incompatible-use]
-      const resultID = refetchedFragmentRef[ID_KEY];
-      if (resultID != null && resultID !== previousIDAndTypename.id) {
-        warning(
-          false,
-          'Relay: Call to `refetch` returned a different id, expected ' +
-            '`%s`, got `%s`, on `%s` in `%s`. ' +
-            'Please make sure the server correctly implements ' +
-            'unique id requirement.',
-          resultID,
-          previousIDAndTypename.id,
-          fragmentNode.name,
-          componentDisplayName,
-        );
+      const recordSource = environment.getStore().getSource();
+      const record = recordSource.get(id);
+      const typename = record == null ? null : Record.getType(record);
+      if (typename == null) {
+        return null;
       }
+      return {
+        id,
+        typename,
+      };
     },
   };
 }

package/relay-hooks/useRelayEnvironment.d.ts

@@ -0,0 +1,10 @@
+/**
+ * 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 { Environment } from 'relay-runtime';
+
+export function useRelayEnvironment(): Environment;

package/relay-hooks/useRelayLoggingContext.js.flow

@@ -14,7 +14,7 @@
 const ReactRelayLoggingContext = require('./../ReactRelayLoggingContext');
 const {useContext} = require('react');
 
-hook useRelayLoggingContext(): mixed | void {
+hook useRelayLoggingContext(): unknown | void {
   return useContext(ReactRelayLoggingContext);
 }
 

package/relay-hooks/useSubscribeToInvalidationState.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 {DataID, Disposable} from 'relay-runtime';
+
+/**
+ * This hook subscribes a callback to the invalidation state of the given data
+ * ids.
+ * Any time the invalidation state of the given data ids changes, the provided
+ * callback will be called.
+ * If new ids or a new callback are provided, the subscription will be
+ * re-established and the previous one will be disposed.
+ * The subscription will automatically be disposed on unmount
+ */
+export function useSubscribeToInvalidationState(dataIDs: readonly DataID[], callback: () => void): Disposable;

package/relay-hooks/useSubscribeToInvalidationState.js.flow

@@ -26,7 +26,7 @@ const {useEffect, useRef} = require('react');
  * The subscription will automatically be disposed on unmount
  */
 hook useSubscribeToInvalidationState(
-  dataIDs: $ReadOnlyArray<DataID>,
+  dataIDs: ReadonlyArray<DataID>,
   callback: () => void,
 ): Disposable {
   const environment = useRelayEnvironment();

package/relay-hooks/useSubscription.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 {GraphQLSubscriptionConfig, OperationType, requestSubscription} from 'relay-runtime';
+
+export function useSubscription<TSubscriptionPayload extends OperationType>(
+    // The actual subtype of OperationType is required to allow for type inference inside GraphQLSubscriptionConfig.s
+    config: GraphQLSubscriptionConfig<TSubscriptionPayload>,
+    requestSubscriptionFn?: typeof requestSubscription,
+): void;