react-relay 16.1.0 → 17.0.0

package/relay-hooks/{experimental/useFragmentInternal_EXPERIMENTAL.js.flow → useFragmentInternal.js.flow}

@@ -11,7 +11,7 @@
 
 'use strict';
 
-import type {QueryResult} from '../QueryResource';
+import type {QueryResult} from './QueryResource';
 import type {
   CacheConfig,
   FetchPolicy,
@@ -26,12 +26,12 @@ import type {
   MissingLiveResolverField,
 } from 'relay-runtime/store/RelayStoreTypes';
 
-const {getQueryResourceForEnvironment} = require('../QueryResource');
-const useRelayEnvironment = require('../useRelayEnvironment');
+const {getQueryResourceForEnvironment} = require('./QueryResource');
+const useRelayEnvironment = require('./useRelayEnvironment');
 const invariant = require('invariant');
 const {useDebugValue, useEffect, useMemo, useRef, useState} = require('react');
 const {
-  __internal: {fetchQuery: fetchQueryInternal},
+  __internal: {fetchQuery: fetchQueryInternal, getPromiseForActiveRequest},
   RelayFeatureFlags,
   areEqualSelectors,
   createOperationDescriptor,
@@ -117,6 +117,8 @@ function handlePotentialSnapshotErrorsForState(
       environment,
       state.snapshot.missingRequiredFields,
       state.snapshot.relayResolverErrors,
+      state.snapshot.errorResponseFields,
+      state.snapshot.selector.node.metadata?.throwOnFieldError ?? false,
     );
   } else if (state.kind === 'plural') {
     for (const snapshot of state.snapshots) {
@@ -124,6 +126,8 @@ function handlePotentialSnapshotErrorsForState(
         environment,
         snapshot.missingRequiredFields,
         snapshot.relayResolverErrors,
+        snapshot.errorResponseFields,
+        snapshot.selector.node.metadata?.throwOnFieldError ?? false,
       );
     }
   }
@@ -162,6 +166,7 @@ function handleMissedUpdates(
       selector: currentSnapshot.selector,
       missingRequiredFields: currentSnapshot.missingRequiredFields,
       relayResolverErrors: currentSnapshot.relayResolverErrors,
+      errorResponseFields: currentSnapshot.errorResponseFields,
     };
     return [
       updatedData !== state.snapshot.data,
@@ -187,6 +192,7 @@ function handleMissedUpdates(
         selector: currentSnapshot.selector,
         missingRequiredFields: currentSnapshot.missingRequiredFields,
         relayResolverErrors: currentSnapshot.relayResolverErrors,
+        errorResponseFields: currentSnapshot.errorResponseFields,
       };
       if (updatedData !== snapshot.data) {
         didMissUpdates = true;
@@ -214,7 +220,7 @@ function handleMissingClientEdge(
   parentFragmentRef: mixed,
   missingClientEdgeRequestInfo: MissingClientEdgeRequestInfo,
   queryOptions?: FragmentQueryOptions,
-): QueryResult {
+): [QueryResult, ?Promise<mixed>] {
   const originalVariables = getVariablesFromFragment(
     parentFragmentNode,
     parentFragmentRef,
@@ -233,17 +239,23 @@ function handleMissingClientEdge(
   // according to the component mount/suspense cycle; QueryResource
   // already handles this by itself.
   const QueryResource = getQueryResourceForEnvironment(environment);
-  return QueryResource.prepare(
+  const queryResult = QueryResource.prepare(
     queryOperationDescriptor,
     fetchQueryInternal(environment, queryOperationDescriptor),
     queryOptions?.fetchPolicy,
   );
+
+  return [
+    queryResult,
+    getPromiseForActiveRequest(environment, queryOperationDescriptor.request),
+  ];
 }
 
 function subscribeToSnapshot(
   environment: IEnvironment,
   state: FragmentState,
   setState: StateUpdaterFunction<FragmentState>,
+  hasPendingStateChanges: {current: boolean},
 ): () => void {
   if (state.kind === 'bailout') {
     return () => {};
@@ -264,11 +276,14 @@ function subscribeToSnapshot(
               name: 'useFragment.subscription.missedUpdates',
               hasDataChanges: dataChanged,
             });
+            hasPendingStateChanges.current = dataChanged;
             return dataChanged ? nextState : prevState;
           } else {
             return prevState;
           }
         }
+
+        hasPendingStateChanges.current = true;
         return {
           kind: 'singular',
           snapshot: latestSnapshot,
@@ -297,6 +312,8 @@ function subscribeToSnapshot(
                 name: 'useFragment.subscription.missedUpdates',
                 hasDataChanges: dataChanged,
               });
+              hasPendingStateChanges.current =
+                hasPendingStateChanges.current || dataChanged;
               return dataChanged ? nextState : prevState;
             } else {
               return prevState;
@@ -304,6 +321,7 @@ function subscribeToSnapshot(
           }
           const updated = [...prevState.snapshots];
           updated[index] = latestSnapshot;
+          hasPendingStateChanges.current = true;
           return {
             kind: 'plural',
             snapshots: updated,
@@ -344,7 +362,7 @@ function getFragmentState(
 }
 
 // fragmentNode cannot change during the lifetime of the component, though fragmentRef may change.
-function useFragmentInternal_EXPERIMENTAL(
+hook useFragmentInternal(
   fragmentNode: ReaderFragment,
   fragmentRef: mixed,
   hookDisplayName: string,
@@ -450,29 +468,38 @@ function useFragmentInternal_EXPERIMENTAL(
     // a static (constant) property of the fragment. In practice, this effect will
     // always or never run for a given invocation of this hook.
     // eslint-disable-next-line react-hooks/rules-of-hooks
-    const clientEdgeQueries = useMemo(() => {
+    // $FlowFixMe[react-rule-hook]
+    const [clientEdgeQueries, activeRequestPromises] = useMemo(() => {
       const missingClientEdges = getMissingClientEdges(state);
       // eslint-disable-next-line no-shadow
       let clientEdgeQueries;
+      const activeRequestPromises = [];
       if (missingClientEdges?.length) {
         clientEdgeQueries = ([]: Array<QueryResult>);
         for (const edge of missingClientEdges) {
-          clientEdgeQueries.push(
-            handleMissingClientEdge(
-              environment,
-              fragmentNode,
-              fragmentRef,
-              edge,
-              queryOptions,
-            ),
+          const [queryResult, requestPromise] = handleMissingClientEdge(
+            environment,
+            fragmentNode,
+            fragmentRef,
+            edge,
+            queryOptions,
           );
+          clientEdgeQueries.push(queryResult);
+          if (requestPromise != null) {
+            activeRequestPromises.push(requestPromise);
+          }
         }
       }
-      return clientEdgeQueries;
+      return [clientEdgeQueries, activeRequestPromises];
     }, [state, environment, fragmentNode, fragmentRef, queryOptions]);
 
+    if (activeRequestPromises.length) {
+      throw Promise.all(activeRequestPromises);
+    }
+
     // See above note
     // eslint-disable-next-line react-hooks/rules-of-hooks
+    // $FlowFixMe[react-rule-hook]
     useEffect(() => {
       const QueryResource = getQueryResourceForEnvironment(environment);
       if (clientEdgeQueries?.length) {
@@ -505,7 +532,10 @@ function useFragmentInternal_EXPERIMENTAL(
     // We only suspend when the component is first trying to mount or changing
     // selectors, not if data becomes missing later:
     if (
+      RelayFeatureFlags.ENABLE_RELAY_OPERATION_TRACKER_SUSPENSE ||
+      environment !== previousEnvironment ||
       !committedFragmentSelectorRef.current ||
+      // $FlowFixMe[react-rule-unsafe-ref]
       !areEqualSelectors(committedFragmentSelectorRef.current, fragmentSelector)
     ) {
       invariant(fragmentSelector != null, 'refinement, see invariants above');
@@ -528,6 +558,8 @@ function useFragmentInternal_EXPERIMENTAL(
   // they're missing even though we are out of options for possibly fetching them:
   handlePotentialSnapshotErrorsForState(environment, state);
 
+  const hasPendingStateChanges = useRef<boolean>(false);
+
   useEffect(() => {
     // Check for updates since the state was rendered
     let currentState = subscribedState;
@@ -546,9 +578,27 @@ function useFragmentInternal_EXPERIMENTAL(
       }
       currentState = updatedState;
     }
-    return subscribeToSnapshot(environment, currentState, setState);
+    return subscribeToSnapshot(
+      environment,
+      currentState,
+      setState,
+      hasPendingStateChanges,
+    );
   }, [environment, subscribedState]);
 
+  if (hasPendingStateChanges.current) {
+    const updates = handleMissedUpdates(environment, state);
+    if (updates != null) {
+      const [hasStateUpdates, updatedState] = updates;
+      if (hasStateUpdates) {
+        setState(updatedState);
+        state = updatedState;
+      }
+    }
+    // $FlowFixMe[react-rule-unsafe-ref]
+    hasPendingStateChanges.current = false;
+  }
+
   let data: ?SelectorData | Array<?SelectorData>;
   if (isPlural) {
     // Plural fragments require allocating an array of the snapshot data values,
@@ -558,6 +608,7 @@ function useFragmentInternal_EXPERIMENTAL(
     // for a particular useFragment invocation site
     const fragmentRefIsNullish = fragmentRef == null; // for less sensitive memoization
     // eslint-disable-next-line react-hooks/rules-of-hooks
+    // $FlowFixMe[react-rule-hook]
     data = useMemo(() => {
       if (state.kind === 'bailout') {
         // Bailout state can happen if the fragmentRef is a plural array that is empty or has no
@@ -608,10 +659,11 @@ function useFragmentInternal_EXPERIMENTAL(
 
   if (__DEV__) {
     // eslint-disable-next-line react-hooks/rules-of-hooks
+    // $FlowFixMe[react-rule-hook]
     useDebugValue({fragment: fragmentNode.name, data});
   }
 
   return data;
 }
 
-module.exports = useFragmentInternal_EXPERIMENTAL;
+module.exports = useFragmentInternal;

package/relay-hooks/useIsMountedRef.js.flow

@@ -13,7 +13,7 @@
 
 const {useEffect, useRef} = require('react');
 
-function useIsMountedRef(): {current: boolean} {
+hook useIsMountedRef(): {current: boolean} {
   const isMountedRef = useRef(true);
 
   useEffect(() => {

package/relay-hooks/useIsOperationNodeActive.js.flow

@@ -23,7 +23,7 @@ const {
 
 const {useEffect, useState, useMemo} = React;
 
-function useIsOperationNodeActive(
+hook useIsOperationNodeActive(
   fragmentNode: ReaderFragment,
   fragmentRef: mixed,
 ): boolean {

package/relay-hooks/useIsParentQueryActive.js.flow

@@ -17,9 +17,12 @@ const useIsOperationNodeActive = require('./useIsOperationNodeActive');
 const useStaticFragmentNodeWarning = require('./useStaticFragmentNodeWarning');
 const {getFragment} = require('relay-runtime');
 
-function useIsParentQueryActive<
+hook useIsParentQueryActive<
   TKey: ?{+$data?: mixed, +$fragmentSpreads: FragmentType, ...},
->(fragmentInput: GraphQLTaggedNode, fragmentRef: TKey): boolean {
+>(
+  fragmentInput: GraphQLTaggedNode,
+  fragmentRef: TKey,
+): boolean {
   const fragmentNode = getFragment(fragmentInput);
   useStaticFragmentNodeWarning(
     fragmentNode,

package/relay-hooks/useLazyLoadQuery.js.flow

@@ -30,7 +30,7 @@ const {
 // This separate type export is only needed as long as we are injecting
 // a separate hooks implementation in ./HooksImplementation -- it can
 // be removed after we stop doing that.
-export type UseLazyLoadQueryHookType = <TVariables: Variables, TData>(
+export type UseLazyLoadQueryHookType = hook <TVariables: Variables, TData>(
   gqlQuery: Query<TVariables, TData>,
   variables: TVariables,
   options?: {
@@ -41,7 +41,7 @@ export type UseLazyLoadQueryHookType = <TVariables: Variables, TData>(
   },
 ) => TData;
 
-function useLazyLoadQuery<TVariables: Variables, TData>(
+hook useLazyLoadQuery<TVariables: Variables, TData>(
   gqlQuery: Query<TVariables, TData>,
   variables: TVariables,
   options?: {
@@ -75,4 +75,5 @@ function useLazyLoadQuery<TVariables: Variables, TData>(
   return data;
 }
 
+// $FlowFixMe[react-rule-hook-incompatible]
 module.exports = (useLazyLoadQuery: UseLazyLoadQueryHookType);

package/relay-hooks/useLazyLoadQueryNode.js.flow

@@ -19,22 +19,20 @@ import type {
   OperationType,
   RenderPolicy,
 } from 'relay-runtime';
-import type {ReaderFragment} from 'relay-runtime/util/ReaderNode';
 
-const HooksImplementation = require('./HooksImplementation');
 const ProfilerContext = require('./ProfilerContext');
 const {
   getQueryCacheIdentifier,
   getQueryResourceForEnvironment,
 } = require('./QueryResource');
 const useFetchTrackingRef = require('./useFetchTrackingRef');
-const useFragmentNode = require('./useFragmentNode');
+const useFragmentInternal = require('./useFragmentInternal');
 const useRelayEnvironment = require('./useRelayEnvironment');
 const React = require('react');
 
 const {useContext, useEffect, useState, useRef} = React;
 
-function useLazyLoadQueryNode<TQuery: OperationType>({
+hook useLazyLoadQueryNode<TQuery: OperationType>({
   query,
   componentDisplayName,
   fetchObservable,
@@ -127,7 +125,7 @@ function useLazyLoadQueryNode<TQuery: OperationType>({
   });
 
   const {fragmentNode, fragmentRef} = preparedQueryResult;
-  const data = useFragmentNodeImpl(
+  const data = useFragmentInternal(
     fragmentNode,
     fragmentRef,
     componentDisplayName,
@@ -135,18 +133,4 @@ function useLazyLoadQueryNode<TQuery: OperationType>({
   return data;
 }
 
-function useFragmentNodeImpl(
-  fragment: ReaderFragment,
-  key: mixed,
-  componentDisplayName: string,
-): mixed {
-  const impl = HooksImplementation.get();
-  if (impl && impl.useFragment__internal) {
-    return impl.useFragment__internal(fragment, key, componentDisplayName);
-  } else {
-    const {data} = useFragmentNode<mixed>(fragment, key, componentDisplayName);
-    return data;
-  }
-}
-
 module.exports = useLazyLoadQueryNode;

package/relay-hooks/useLoadMoreFunction.js.flow

@@ -61,7 +61,7 @@ export type UseLoadMoreFunctionArgs = {
   onReset: () => void,
 };
 
-function useLoadMoreFunction<TVariables: Variables>(
+hook useLoadMoreFunction<TVariables: Variables>(
   args: UseLoadMoreFunctionArgs,
 ): [LoadMoreFn<TVariables>, boolean, () => void] {
   const {

package/relay-hooks/useMemoOperationDescriptor.js.flow

@@ -24,7 +24,7 @@ const {createOperationDescriptor, getRequest} = require('relay-runtime');
 
 const {useMemo} = React;
 
-function useMemoOperationDescriptor(
+hook useMemoOperationDescriptor(
   gqlQuery: GraphQLTaggedNode,
   variables: Variables,
   cacheConfig?: ?CacheConfig,

package/relay-hooks/useMemoVariables.js.flow

@@ -21,7 +21,7 @@ const {useState} = require('react');
  * This is useful when a `variables` object is used as a value in a depencency
  * array as it might often be constructed during render.
  */
-function useMemoVariables<TVariables: Variables | null>(
+hook useMemoVariables<TVariables: Variables | null>(
   variables: TVariables,
 ): TVariables {
   const [mirroredVariables, setMirroredVariables] = useState(variables);

package/relay-hooks/useMutation.js.flow

@@ -64,7 +64,7 @@ type UseMutationConfigInternal<TVariables, TData, TRawResponse> = {
   variables: TVariables,
 };
 
-function useMutation<TVariables: Variables, TData, TRawResponse = {...}>(
+hook useMutation<TVariables: Variables, TData, TRawResponse = {...}>(
   mutation: Mutation<TVariables, TData, TRawResponse>,
   commitMutationFn?: (
     environment: IEnvironment,

package/relay-hooks/usePaginationFragment.js.flow

@@ -12,9 +12,9 @@
 'use strict';
 
 import type {LoadMoreFn, UseLoadMoreFunctionArgs} from './useLoadMoreFunction';
-import type {RefetchFn} from './useRefetchableFragment';
-import type {Options} from './useRefetchableFragmentNode';
+import type {Options} from './useRefetchableFragmentInternal';
 import type {
+  Disposable,
   FragmentType,
   GraphQLResponse,
   Observer,
@@ -22,9 +22,9 @@ import type {
   Variables,
 } from 'relay-runtime';
 
-const HooksImplementation = require('./HooksImplementation');
 const useLoadMoreFunction = require('./useLoadMoreFunction');
-const useRefetchableFragmentNode = require('./useRefetchableFragmentNode');
+const useRefetchableFragmentInternal = require('./useRefetchableFragmentInternal');
+const useRelayEnvironment = require('./useRelayEnvironment');
 const useStaticFragmentNodeWarning = require('./useStaticFragmentNodeWarning');
 const {useCallback, useDebugValue, useState} = require('react');
 const {
@@ -33,6 +33,40 @@ const {
   getPaginationMetadata,
 } = require('relay-runtime');
 
+type RefetchVariables<TVariables, TKey: ?{+$fragmentSpreads: mixed, ...}> =
+  // 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, ...}]
+    ? Partial<TVariables>
+    : TVariables;
+
+type RefetchFnBase<TVars, TOptions> = (
+  vars: TVars,
+  options?: TOptions,
+) => Disposable;
+
+type RefetchFn<TVariables, TKey, TOptions = Options> = RefetchFnBase<
+  RefetchVariables<TVariables, TKey>,
+  TOptions,
+>;
+
+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: mixed, ...}]
+    ? TData
+    : ?TData,
+  loadNext: LoadMoreFn<TVariables>,
+  loadPrevious: LoadMoreFn<TVariables>,
+  hasNext: boolean,
+  hasPrevious: boolean,
+  isLoadingNext: boolean,
+  isLoadingPrevious: boolean,
+  refetch: RefetchFn<TVariables, TKey>,
+};
+
 // This separate type export is only needed as long as we are injecting
 // a separate hooks implementation in ./HooksImplementation -- it can
 // be removed after we stop doing that.
@@ -46,7 +80,7 @@ export type UsePaginationFragmentType = <
   parentFragmentRef: TKey,
 ) => ReturnType<TVariables, TData, TKey>;
 
-function usePaginationFragment_LEGACY<
+hook usePaginationFragment<
   TFragmentType: FragmentType,
   TVariables: Variables,
   TData,
@@ -65,9 +99,9 @@ function usePaginationFragment_LEGACY<
   const {connectionPathInFragmentData, paginationRequest, paginationMetadata} =
     getPaginationMetadata(fragmentNode, componentDisplayName);
 
-  const {fragmentData, fragmentRef, refetch} = useRefetchableFragmentNode<
-    $FlowFixMe,
-    $FlowFixMe,
+  const {fragmentData, fragmentRef, refetch} = useRefetchableFragmentInternal<
+    {variables: TVariables, response: TData},
+    {data?: TData},
   >(fragmentNode, parentFragmentRef, componentDisplayName);
   const fragmentIdentifier = getFragmentIdentifier(fragmentNode, fragmentRef);
 
@@ -99,7 +133,7 @@ function usePaginationFragment_LEGACY<
       paginationRequest,
     });
 
-  const refetchPagination: RefetchFn<TVariables, TKey> = useCallback(
+  const refetchPagination = useCallback(
     (variables: TVariables, options: void | Options) => {
       disposeFetchNext();
       disposeFetchPrevious();
@@ -110,6 +144,7 @@ function usePaginationFragment_LEGACY<
 
   if (__DEV__) {
     // eslint-disable-next-line react-hooks/rules-of-hooks
+    // $FlowFixMe[react-rule-hook]
     useDebugValue({
       fragment: fragmentNode.name,
       data: fragmentData,
@@ -120,7 +155,8 @@ function usePaginationFragment_LEGACY<
     });
   }
   return {
-    data: (fragmentData: $FlowFixMe),
+    // $FlowFixMe[incompatible-return]
+    data: fragmentData,
     loadNext,
     loadPrevious,
     hasNext,
@@ -131,7 +167,7 @@ function usePaginationFragment_LEGACY<
   };
 }
 
-function useLoadMore<TVariables: Variables>(
+hook useLoadMore<TVariables: Variables>(
   args: $Diff<
     UseLoadMoreFunctionArgs,
     {
@@ -141,7 +177,21 @@ function useLoadMore<TVariables: Variables>(
     },
   >,
 ): [LoadMoreFn<TVariables>, boolean, boolean, () => void] {
-  const [isLoadingMore, setIsLoadingMore] = useState(false);
+  const environment = useRelayEnvironment();
+  const [isLoadingMore, reallySetIsLoadingMore] = useState(false);
+  // Schedule this update since it must be observed by components at the same
+  // batch as when hasNext changes. hasNext is read from the store and store
+  // updates are scheduled, so this must be scheduled too.
+  const setIsLoadingMore = (value: boolean) => {
+    const schedule = environment.getScheduler()?.schedule;
+    if (schedule) {
+      schedule(() => {
+        reallySetIsLoadingMore(value);
+      });
+    } else {
+      reallySetIsLoadingMore(value);
+    }
+  };
   const observer = {
     start: () => setIsLoadingMore(true),
     complete: () => setIsLoadingMore(false),
@@ -156,42 +206,4 @@ function useLoadMore<TVariables: Variables>(
   return [loadMore, hasMore, isLoadingMore, disposeFetch];
 }
 
-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: mixed, ...}]
-    ? TData
-    : ?TData,
-  loadNext: LoadMoreFn<TVariables>,
-  loadPrevious: LoadMoreFn<TVariables>,
-  hasNext: boolean,
-  hasPrevious: boolean,
-  isLoadingNext: boolean,
-  isLoadingPrevious: boolean,
-  refetch: RefetchFn<TVariables, TKey>,
-};
-
-function usePaginationFragment<
-  TFragmentType: FragmentType,
-  TVariables: Variables,
-  TData,
-  TKey: ?{+$fragmentSpreads: TFragmentType, ...},
->(
-  fragmentInput: RefetchableFragment<TFragmentType, TData, TVariables>,
-  parentFragmentRef: TKey,
-): ReturnType<TVariables, TData, TKey> {
-  const impl = HooksImplementation.get();
-  if (impl) {
-    // $FlowExpectedError[incompatible-return] Flow cannot prove that two conditional type satisfy each other
-    return impl.usePaginationFragment<TFragmentType, TVariables, TData, TKey>(
-      fragmentInput,
-      parentFragmentRef,
-    );
-  } else {
-    // eslint-disable-next-line react-hooks/rules-of-hooks
-    return usePaginationFragment_LEGACY(fragmentInput, parentFragmentRef);
-  }
-}
-
 module.exports = usePaginationFragment;

package/relay-hooks/usePreloadedQuery.js.flow

@@ -52,7 +52,7 @@ type PreloadedQuery<
       TEnvironmentProviderOptions,
     >;
 
-function usePreloadedQuery<
+hook usePreloadedQuery<
   TVariables: Variables,
   TData,
   TRawResponse: ?{...} = void,
@@ -164,6 +164,7 @@ function usePreloadedQuery<
 
   if (__DEV__) {
     // eslint-disable-next-line react-hooks/rules-of-hooks
+    // $FlowFixMe[react-rule-hook]
     useDebugValue({
       query: preloadedQuery.name,
       variables: preloadedQuery.variables,

package/relay-hooks/useQueryLoader.js.flow

@@ -108,11 +108,7 @@ declare function useQueryLoader<TQuery: OperationType>(
   initialQueryReference?: ?PreloadedQuery<TQuery>,
 ): UseQueryLoaderHookReturnType<TQuery['variables'], TQuery['response']>;
 
-function useQueryLoader<
-  TVariables: Variables,
-  TData,
-  TRawResponse: ?{...} = void,
->(
+hook useQueryLoader<TVariables: Variables, TData, TRawResponse: ?{...} = void>(
   preloadableRequest: Query<TVariables, TData, TRawResponse>,
   initialQueryReference?: ?PreloadedQuery<{
     response: TData,
@@ -172,6 +168,7 @@ function useQueryLoader<
     // necessary here
     // TODO(T78446637): Handle disposal of managed query references in
     // components that were never mounted after rendering
+    // $FlowFixMe[react-rule-unsafe-ref]
     undisposedQueryReferencesRef.current.add(initialQueryReferenceInternal);
     setPreviousInitialQueryReference(initialQueryReferenceInternal);
     setQueryReference(initialQueryReferenceInternal);