react-relay 16.2.0 → 18.0.0

package/relay-hooks/__flowtests__/EntryPointTypes/ExtractQueryTypes-flowtest.js.flow

@@ -0,0 +1,43 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict-local
+ * @format
+ * @oncall relay
+ */
+
+'use strict';
+
+import type {
+  EnvironmentProviderOptions,
+  ExtractQueryTypes,
+  PreloadedQuery,
+} from '../../EntryPointTypes.flow';
+
+type Query = {
+  +variables: {foo: string, bar: number},
+  +response: mixed,
+  +rawResponse?: {...},
+};
+
+const _good: ExtractQueryTypes<
+  EnvironmentProviderOptions,
+  {root: PreloadedQuery<Query>},
+>['root']['variables'] = {
+  foo: 'bar',
+  bar: 3,
+};
+
+const _bad: ExtractQueryTypes<
+  EnvironmentProviderOptions,
+  {root: PreloadedQuery<Query>},
+  // $FlowExpectedError[prop-missing]
+>['root']['variables'] = {
+  memebers_are_checked: true,
+  // $FlowExpectedError[incompatible-type]
+  foo: 1,
+  bar: 3,
+};

package/relay-hooks/__flowtests__/useBlockingPaginationFragment-flowtest.js.flow

@@ -47,23 +47,32 @@ type ExpectedReturnType<
 // Nullability of returned data type is correct
 // $FlowFixMe[prop-missing]
 // $FlowFixMe[incompatible-cast]
+// $FlowFixMe[incompatible-exact]
+// $FlowFixMe[react-rule-hook]
 (useBlockingPaginationFragment(
   refetchableFragmentInput,
   keyNonNullable,
 ): ExpectedReturnType<QueryVariablesSubset, QueryVariables, NonNullableData>);
 
+// $FlowFixMe[react-rule-hook]
 (useBlockingPaginationFragment(
   refetchableFragmentInput,
   keyNullable,
 ): ExpectedReturnType<QueryVariables, QueryVariables, NullableData>);
 
 // $FlowExpectedError: can't cast nullable to non-nullable
+// $FlowFixMe[react-rule-hook]
+// $FlowFixMe[incompatible-cast]
 (useBlockingPaginationFragment(
   refetchableFragmentInput,
   keyNullable,
 ): ExpectedReturnType<QueryVariables, QueryVariables, NonNullableData>);
 
 // $FlowExpectedError: actual type of returned data is correct
+// $FlowFixMe[react-rule-hook]
+// $FlowFixMe[incompatible-exact]
+// $FlowFixMe[prop-missing]
+// $FlowFixMe[incompatible-cast]
 (useBlockingPaginationFragment(
   refetchableFragmentInput,
   // $FlowExpectedError[incompatible-call]
@@ -71,6 +80,7 @@ type ExpectedReturnType<
 ): ExpectedReturnType<QueryVariables, QueryVariablesSubset, NonNullableData>);
 
 // $FlowExpectedError[incompatible-call] `Example_user$fragmentType` is incompatible with  `FragmentType`
+// $FlowFixMe[react-rule-hook]
 (useBlockingPaginationFragment(
   refetchableFragmentInput,
   // $FlowExpectedError[incompatible-call]
@@ -78,18 +88,28 @@ type ExpectedReturnType<
 ): ExpectedReturnType<QueryVariables, QueryVariables, NullableData>);
 
 // $FlowExpectedError: Key should not be a user provided object
+// $FlowFixMe[react-rule-hook]
+// $FlowFixMe[prop-missing]
+// $FlowFixMe[cannot-resolve-name]
 useBlockingPaginationFragment(fragmentInput, {abc: 123});
 
 // $FlowExpectedError: Key should not be an empty object
+// $FlowFixMe[react-rule-hook]
+// $FlowFixMe[prop-missing]
+// $FlowFixMe[cannot-resolve-name]
 useBlockingPaginationFragment(fragmentInput, {});
 
 // $FlowExpectedError: Key should be the `<name>$key` type from generated flow
+// $FlowFixMe[react-rule-hook]
+// $FlowFixMe[prop-missing]
+// $FlowFixMe[cannot-resolve-name]
 useBlockingPaginationFragment(fragmentInput, fragmentData);
 
 // Refetch function options:
 declare var variables: QueryVariables;
 declare var environment: IEnvironment;
 
+// $FlowFixMe[react-rule-hook]
 const {refetch} = useBlockingPaginationFragment(
   refetchableFragmentInput,
   keyNonNullable,
@@ -108,6 +128,7 @@ refetch(variables, {
 declare var extraVariables: {nickname: string};
 declare var invalidVariables: {foo: string};
 
+// $FlowFixMe[react-rule-hook]
 const {loadNext} = useBlockingPaginationFragment(
   refetchableFragmentInput,
   keyNonNullable,

package/relay-hooks/__flowtests__/usePaginationFragment-flowtest.js.flow

@@ -49,29 +49,40 @@ type ExpectedReturnType<
 // Nullability of returned data type is correct
 // $FlowFixMe[prop-missing]
 // $FlowFixMe[incompatible-cast]
+// $FlowFixMe[incompatible-exact]
+// $FlowFixMe[react-rule-hook]
 (usePaginationFragment(
   refetchableFragmentInput,
   keyNonNullable,
 ): ExpectedReturnType<QueryVariablesSubset, QueryVariables, NonNullableData>);
 
+// $FlowFixMe[react-rule-hook]
 (usePaginationFragment(
   refetchableFragmentInput,
   keyNullable,
 ): ExpectedReturnType<QueryVariables, QueryVariables, NullableData>);
 
 // $FlowExpectedError: can't cast nullable to non-nullable
+// $FlowFixMe[react-rule-hook]
+// $FlowFixMe[incompatible-cast]
 (usePaginationFragment(
   refetchableFragmentInput,
   keyNullable,
 ): ExpectedReturnType<QueryVariables, QueryVariables, NonNullableData>);
 
 // $FlowExpectedError: actual type of returned data is correct
+// $FlowFixMe[react-rule-hook]
+// $FlowFixMe[incompatible-exact]
+// $FlowFixMe[prop-missing]
+// $FlowFixMe[incompatible-cast]
 (usePaginationFragment(
   refetchableFragmentInput,
   // $FlowFixMe[incompatible-call]
   keyAnotherNonNullable,
 ): ExpectedReturnType<QueryVariables, QueryVariablesSubset, NonNullableData>);
 // $FlowExpectedError
+// $FlowFixMe[react-rule-hook]
+// $FlowFixMe[incompatible-cast]
 (usePaginationFragment(
   refetchableFragmentInput,
   // $FlowFixMe[incompatible-call]
@@ -79,18 +90,25 @@ type ExpectedReturnType<
 ): ExpectedReturnType<QueryVariables, QueryVariables, NonNullableData>);
 
 // $FlowExpectedError: Key should not be a user provided object
+// $FlowFixMe[react-rule-hook]
+// $FlowFixMe[prop-missing]
 usePaginationFragment(refetchableFragmentInput, {abc: 123});
 
 // $FlowExpectedError: Key should not be an empty object
+// $FlowFixMe[react-rule-hook]
+// $FlowFixMe[prop-missing]
 usePaginationFragment(refetchableFragmentInput, {});
 
 // $FlowExpectedError: Key should be the `<name>$key` type from generated flow
+// $FlowFixMe[react-rule-hook]
+// $FlowFixMe[prop-missing]
 usePaginationFragment(refetchableFragmentInput, fragmentData);
 
 // Refetch function options:
 declare var variables: QueryVariables;
 declare var environment: IEnvironment;
 
+// $FlowFixMe[react-rule-hook]
 const {refetch} = usePaginationFragment(
   refetchableFragmentInput,
   keyNonNullable,
@@ -109,6 +127,7 @@ refetch(variables, {
 declare var extraVariables: {nickname: string};
 declare var invalidVariables: {foo: string};
 
+// $FlowFixMe[react-rule-hook]
 const {loadNext} = usePaginationFragment(
   refetchableFragmentInput,
   keyNonNullable,

package/relay-hooks/__flowtests__/useRefetchableFragment-flowtest.js.flow

@@ -33,53 +33,75 @@ import {
 // Nullability of returned data type is correct
 // $FlowFixMe[prop-missing]
 // $FlowFixMe[incompatible-cast]
+// $FlowFixMe[incompatible-exact]
+// $FlowFixMe[react-rule-hook]
 (useRefetchableFragment(refetchableFragmentInput, keyNonNullable): [
   NonNullableData,
   FetchFn<QueryVariablesSubset>,
 ]);
 
+// $FlowFixMe[react-rule-hook]
 (useRefetchableFragment(refetchableFragmentInput, keyNullable): [
   NullableData,
   FetchFn<QueryVariables>,
 ]);
 
 // $FlowExpectedError: can't cast nullable to non-nullable
+// $FlowFixMe[react-rule-hook]
+// $FlowFixMe[incompatible-cast]
 (useRefetchableFragment(refetchableFragmentInput, keyNullable): [
   NonNullableData,
   FetchFn<QueryVariables>,
 ]);
 
 // $FlowExpectedError: refetch requires exact type if key is nullable
+// $FlowFixMe[react-rule-hook]
+// $FlowFixMe[incompatible-exact]
+// $FlowFixMe[prop-missing]
 (useRefetchableFragment(refetchableFragmentInput, keyNullable): [
   NullableData,
   FetchFn<QueryVariablesSubset>,
 ]);
 
 // $FlowExpectedError: actual type of returned data is correct
+// $FlowFixMe[react-rule-hook]
+// $FlowFixMe[incompatible-call]
+// $FlowFixMe[incompatible-exact]
+// $FlowFixMe[prop-missing]
+// $FlowFixMe[incompatible-cast]
 (useRefetchableFragment(refetchableFragmentInput, keyAnotherNonNullable): [
   NonNullableData,
   FetchFn<QueryVariablesSubset>,
 ]);
 
 // $FlowExpectedError - incompatible key types
+// $FlowFixMe[react-rule-hook]
+// $FlowFixMe[incompatible-call]
 (useRefetchableFragment(refetchableFragmentInput, keyAnotherNullable): [
   NullableData,
   FetchFn<QueryVariables>,
 ]);
 
 // $FlowExpectedError: Key should not be a user provided object
+// $FlowFixMe[react-rule-hook]
+// $FlowFixMe[prop-missing]
 useRefetchableFragment(refetchableFragmentInput, {abc: 123});
 
 // $FlowExpectedError: Key should not be an empty object
+// $FlowFixMe[react-rule-hook]
+// $FlowFixMe[prop-missing]
 useRefetchableFragment(refetchableFragmentInput, {});
 
 // $FlowExpectedError: Key should be the `<name>$key` type from generated flow
+// $FlowFixMe[react-rule-hook]
+// $FlowFixMe[prop-missing]
 useRefetchableFragment(refetchableFragmentInput, fragmentData);
 
 // Refetch function options:
 declare var variables: QueryVariables;
 declare var environment: IEnvironment;
 
+// $FlowFixMe[react-rule-hook]
 const [, refetch] = useRefetchableFragment(
   refetchableFragmentInput,
   keyNonNullable,

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

@@ -206,11 +206,9 @@ class FragmentResourceImpl {
   constructor(environment: IEnvironment) {
     this._environment = environment;
     this._cache = LRUCache.create(CACHE_CAPACITY);
-    if (RelayFeatureFlags.ENABLE_CLIENT_EDGES) {
-      this._clientEdgeQueryResultsCache = new ClientEdgeQueryResultsCache(
-        environment,
-      );
-    }
+    this._clientEdgeQueryResultsCache = new ClientEdgeQueryResultsCache(
+      environment,
+    );
   }
 
   /**
@@ -397,7 +395,6 @@ class FragmentResourceImpl {
     // First, initiate a query for any client edges that were missing data:
     let clientEdgeRequests: ?Array<RequestDescriptor> = null;
     if (
-      RelayFeatureFlags.ENABLE_CLIENT_EDGES &&
       fragmentNode.metadata?.hasClientEdges === true &&
       hasMissingClientEdges(snapshot)
     ) {
@@ -432,7 +429,7 @@ class FragmentResourceImpl {
       );
     }
     let clientEdgePromises: Array<Promise<void>> = [];
-    if (RelayFeatureFlags.ENABLE_CLIENT_EDGES && clientEdgeRequests) {
+    if (clientEdgeRequests) {
       clientEdgePromises = clientEdgeRequests
         .map(request => getPromiseForActiveRequest(this._environment, request))
         .filter(Boolean);
@@ -567,6 +564,7 @@ class FragmentResourceImpl {
           s.missingRequiredFields,
           s.relayResolverErrors,
           s.errorResponseFields,
+          s.selector.node.metadata?.throwOnFieldError ?? false,
         );
       });
     } else {
@@ -575,6 +573,7 @@ class FragmentResourceImpl {
         snapshot.missingRequiredFields,
         snapshot.relayResolverErrors,
         snapshot.errorResponseFields,
+        snapshot.selector.node.metadata?.throwOnFieldError ?? false,
       );
     }
   }
@@ -672,15 +671,13 @@ class FragmentResourceImpl {
       );
     }
 
-    if (RelayFeatureFlags.ENABLE_CLIENT_EDGES) {
-      const clientEdgeQueryResults =
-        this._clientEdgeQueryResultsCache?.get(cacheKey) ?? undefined;
-      if (clientEdgeQueryResults?.length) {
-        const queryResource = getQueryResourceForEnvironment(this._environment);
-        clientEdgeQueryResults.forEach(queryResult => {
-          disposables.push(queryResource.retain(queryResult));
-        });
-      }
+    const clientEdgeQueryResults =
+      this._clientEdgeQueryResultsCache?.get(cacheKey) ?? undefined;
+    if (clientEdgeQueryResults?.length) {
+      const queryResource = getQueryResourceForEnvironment(this._environment);
+      clientEdgeQueryResults.forEach(queryResult => {
+        disposables.push(queryResource.retain(queryResult));
+      });
     }
 
     return {

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

@@ -65,7 +65,7 @@ type ReturnType<TVariables, TData, TKey> = {
   refetch: RefetchFn<TVariables, TKey>,
 };
 
-function useBlockingPaginationFragment<
+hook useBlockingPaginationFragment<
   TFragmentType: FragmentType,
   TVariables: Variables,
   TData,
@@ -166,7 +166,7 @@ function useBlockingPaginationFragment<
   };
 }
 
-function useLoadMore<TVariables: Variables>(args: {
+hook useLoadMore<TVariables: Variables>(args: {
   disableStoreUpdates: () => void,
   enableStoreUpdates: () => void,
   ...$Exact<

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

@@ -26,7 +26,7 @@ type ReturnType<TFragmentData: mixed> = {
   enableStoreUpdates: () => void,
 };
 
-function useFragmentNode<TFragmentData: mixed>(
+hook useFragmentNode<TFragmentData: mixed>(
   fragmentNode: ReaderFragment,
   fragmentRef: mixed,
   componentDisplayName: string,

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

@@ -162,7 +162,7 @@ function reducer(state: RefetchState, action: Action): RefetchState {
   }
 }
 
-function useRefetchableFragmentNode<
+hook useRefetchableFragmentNode<
   TQuery: OperationType,
   TKey: ?{+$data?: mixed, ...},
 >(
@@ -367,7 +367,7 @@ function useRefetchableFragmentNode<
   };
 }
 
-function useRefetchFunction<TQuery: OperationType>(
+hook useRefetchFunction<TQuery: OperationType>(
   componentDisplayName: string,
   dispatch: (
     | {

package/relay-hooks/loadEntryPoint.js.flow

@@ -17,13 +17,15 @@ import type {
   EnvironmentProviderOptions,
   IEnvironmentProvider,
   PreloadedEntryPoint,
+  PreloadedQuery,
 } from './EntryPointTypes.flow';
 
 const {loadQuery} = require('./loadQuery');
 
 function loadEntryPoint<
   TEntryPointParams: {...},
-  TPreloadedQueries: {...},
+  // $FlowExpectedError[unclear-type] Need any to make it supertype of all PreloadedQuery
+  TPreloadedQueries: {+[string]: PreloadedQuery<any>},
   TPreloadedEntryPoints: {...},
   TRuntimeProps: {...},
   TExtraProps,
@@ -53,8 +55,12 @@ function loadEntryPoint<
   if (queries != null) {
     const queriesPropNames = Object.keys(queries);
     queriesPropNames.forEach(queryPropName => {
+      const query = queries[queryPropName];
+      if (query == null) {
+        return;
+      }
       const {environmentProviderOptions, options, parameters, variables} =
-        queries[queryPropName];
+        query;
 
       const environment = environmentProvider.getEnvironment(
         environmentProviderOptions,
@@ -86,11 +92,11 @@ function loadEntryPoint<
         entryPointDescription;
       preloadedEntryPoints[entryPointPropName] = loadEntryPoint<
         _,
-        {...},
+        {},
         {...},
         {...},
         mixed,
-        EntryPointComponent<{...}, {...}, {...}, mixed>,
+        EntryPointComponent<{}, {...}, {...}, mixed>,
         _,
       >(environmentProvider, nestedEntryPoint, nestedParams);
     });

package/relay-hooks/loadQuery.js.flow

@@ -30,7 +30,6 @@ import type {
 } from 'relay-runtime';
 
 const invariant = require('invariant');
-const React = require('react');
 const {
   __internal: {fetchQueryDeduped},
   Observable,
@@ -41,29 +40,19 @@ const {
   getRequest,
   getRequestIdentifier,
 } = require('relay-runtime');
-const warning = require('warning');
 
-let RenderDispatcher = null;
 let fetchKey = 100001;
 
-function useTrackLoadQueryInRender() {
-  if (RenderDispatcher === null) {
-    // Flow does not know of React internals (rightly so), but we need to
-    // ensure here that this function isn't called inside render.
-    RenderDispatcher =
-      // $FlowFixMe[prop-missing]
-      React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED
-        ?.ReactCurrentDispatcher?.current;
-  }
-}
-
-type QueryType<T> = T extends Query<infer V, infer D, infer RR>
-  ? {
-      variables: V,
-      response: D,
-      rawResponse?: $NonMaybeType<RR>,
-    } // $FlowFixMe[deprecated-type]
-  : $Call<<T>(PreloadableConcreteRequest<T>) => T, T>;
+type QueryType<T> =
+  T extends Query<infer V, infer D, infer RR>
+    ? {
+        variables: V,
+        response: D,
+        rawResponse?: $NonMaybeType<RR>,
+      }
+    : [+t: T] extends [+t: PreloadableConcreteRequest<infer V>]
+      ? V
+      : empty;
 
 declare function loadQuery<
   T,
@@ -86,17 +75,6 @@ function loadQuery<
   options?: ?LoadQueryOptions,
   environmentProviderOptions?: ?TEnvironmentProviderOptions,
 ): PreloadedQueryInner<TQuery, TEnvironmentProviderOptions> {
-  // This code ensures that we don't call loadQuery during render.
-  const CurrentDispatcher =
-    // $FlowFixMe[prop-missing]
-    React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED
-      ?.ReactCurrentDispatcher?.current;
-  warning(
-    RenderDispatcher == null || CurrentDispatcher !== RenderDispatcher,
-    'Relay: `%s` should not be called inside a React render function.',
-    options?.__nameForWarning ?? 'loadQuery',
-  );
-
   // Every time you call loadQuery, we will generate a new fetchKey.
   // This will ensure that every query reference that is created and
   // passed to usePreloadedQuery is independently evaluated,
@@ -406,5 +384,4 @@ function loadQuery<
 
 module.exports = {
   loadQuery,
-  useTrackLoadQueryInRender,
 };

package/relay-hooks/prepareEntryPoint_DEPRECATED.js.flow

@@ -16,13 +16,15 @@ import type {
   EntryPointComponent,
   EnvironmentProviderOptions,
   IEnvironmentProvider,
+  PreloadedQuery,
 } from './EntryPointTypes.flow';
 
 const preloadQuery = require('./preloadQuery_DEPRECATED');
 
 function prepareEntryPoint<
   TEntryPointParams: {...},
-  TPreloadedQueries: {...},
+  // $FlowExpectedError[unclear-type] Need any to make it supertype of all PreloadedQuery
+  TPreloadedQueries: {+[string]: PreloadedQuery<any>},
   TPreloadedEntryPoints: {...},
   TRuntimeProps: {...},
   TExtraProps,
@@ -59,6 +61,7 @@ function prepareEntryPoint<
         environmentProviderOptions,
       );
 
+      // $FlowFixMe[incompatible-type]
       preloadedQueries[queryPropName] = preloadQuery<OperationType, mixed>(
         environment,
         parameters,

package/relay-hooks/{experimental/readFragmentInternal_EXPERIMENTAL.js.flow → readFragmentInternal.js.flow}

@@ -11,7 +11,7 @@
 
 'use strict';
 
-import type {QueryResult} from '../QueryResource';
+import type {QueryResult} from './QueryResource';
 import type {
   CacheConfig,
   FetchPolicy,
@@ -23,7 +23,7 @@ import type {
 } from 'relay-runtime';
 import type {MissingClientEdgeRequestInfo} from 'relay-runtime/store/RelayStoreTypes';
 
-const {getQueryResourceForEnvironment} = require('../QueryResource');
+const {getQueryResourceForEnvironment} = require('./QueryResource');
 const invariant = require('invariant');
 const {
   __internal: {fetchQuery: fetchQueryInternal},
@@ -88,6 +88,7 @@ function handlePotentialSnapshotErrorsForState(
       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) {
@@ -96,6 +97,7 @@ function handlePotentialSnapshotErrorsForState(
         snapshot.missingRequiredFields,
         snapshot.relayResolverErrors,
         snapshot.errorResponseFields,
+        snapshot.selector.node.metadata?.throwOnFieldError ?? false,
       );
     }
   }
@@ -159,7 +161,7 @@ function getFragmentState(
 }
 
 // fragmentNode cannot change during the lifetime of the component, though fragmentRef may change.
-function readFragmentInternal_EXPERIMENTAL(
+function readFragmentInternal(
   environment: IEnvironment,
   fragmentNode: ReaderFragment,
   fragmentRef: mixed,
@@ -297,4 +299,4 @@ function readFragmentInternal_EXPERIMENTAL(
   return {data, clientEdgeQueries};
 }
 
-module.exports = readFragmentInternal_EXPERIMENTAL;
+module.exports = readFragmentInternal;

package/relay-hooks/useClientQuery.js.flow

@@ -20,7 +20,7 @@ const useLazyLoadQuery = require('./useLazyLoadQuery');
  * These queries are consist of queries for client-only data,
  * schematized via local schema extensions and/or Relay resolvers.
  */
-function useClientQuery<TVariables: Variables, TData, TRawResponse>(
+hook useClientQuery<TVariables: Variables, TData, TRawResponse>(
   gqlQuery: ClientQuery<TVariables, TData, TRawResponse>,
   variables: TVariables,
   options?: {

package/relay-hooks/useEntryPointLoader.js.flow

@@ -17,10 +17,10 @@ import type {
   EnvironmentProviderOptions,
   IEnvironmentProvider,
   PreloadedEntryPoint,
+  PreloadedQuery,
 } from './EntryPointTypes.flow';
 
 const loadEntryPoint = require('./loadEntryPoint');
-const {useTrackLoadQueryInRender} = require('./loadQuery');
 const useIsMountedRef = require('./useIsMountedRef');
 const {useCallback, useEffect, useRef, useState} = require('react');
 
@@ -50,9 +50,10 @@ type NullEntryPointReference = {
 };
 const initialNullEntryPointReferenceState = {kind: 'NullEntryPointReference'};
 
-function useLoadEntryPoint<
+hook useLoadEntryPoint<
   TEntryPointParams: {...},
-  TPreloadedQueries: {...},
+  // $FlowExpectedError[unclear-type] Need any to make it supertype of all PreloadedQuery
+  TPreloadedQueries: {+[string]: PreloadedQuery<any>},
   TPreloadedEntryPoints: {...},
   TRuntimeProps: {...},
   TExtraProps,
@@ -102,8 +103,6 @@ function useLoadEntryPoint<
    * entry point references.
    */
 
-  useTrackLoadQueryInRender();
-
   const initialEntryPointReferenceInternal =
     options?.TEST_ONLY__initialEntryPointData?.entryPointReference ??
     initialNullEntryPointReferenceState;

package/relay-hooks/useFetchTrackingRef.js.flow

@@ -28,7 +28,7 @@ const {useCallback, useEffect} = require('react');
  * The additional functions returned by this Hook can be used to mutate
  * the ref.
  */
-function useFetchTrackingRef(): {
+hook useFetchTrackingRef(): {
   isFetchingRef: {current: ?boolean, ...},
   startFetch: Subscription => void,
   disposeFetch: () => void,