react-relay 18.2.0 → 19.0.0

package/lib/relay-hooks/useLoadMoreFunction_EXPERIMENTAL.js

@@ -62,6 +62,7 @@ function useLoadMoreFunction_EXPERIMENTAL(args) {
   var _getConnectionState = getConnectionState(direction, fragmentNode, fragmentData, connectionPathInFragmentData),
     cursor = _getConnectionState.cursor,
     hasMore = _getConnectionState.hasMore;
+  var isRequestInvalid = fragmentData == null || isParentQueryActive;
   var isMountedRef = useIsMountedRef();
   var loadMore = useCallback(function (count, options) {
     var onComplete = options === null || options === void 0 ? void 0 : options.onComplete;
@@ -72,7 +73,7 @@ function useLoadMoreFunction_EXPERIMENTAL(args) {
       };
     }
     var fragmentSelector = getSelector(fragmentNode, fragmentRef);
-    if (fetchStatusRef.current.kind === 'fetching' || fragmentData == null || isParentQueryActive) {
+    if (fetchStatusRef.current.kind === 'fetching' || isRequestInvalid) {
       if (fragmentSelector == null) {
         process.env.NODE_ENV !== "production" ? warning(false, 'Relay: Unexpected fetch while using a null fragment ref ' + 'for fragment `%s` in `%s`. When fetching more items, we expect ' + "initial fragment data to be non-null. Please make sure you're " + 'passing a valid fragment ref to `%s` before paginating.', fragmentNode.name, componentDisplayName, componentDisplayName) : void 0;
       }
@@ -124,7 +125,7 @@ function useLoadMoreFunction_EXPERIMENTAL(args) {
     return {
       dispose: function dispose() {}
     };
-  }, [environment, identifierValue, direction, cursor, isParentQueryActive, fragmentData, fragmentNode.name, fragmentRef, componentDisplayName]);
+  }, [environment, identifierValue, direction, cursor, isRequestInvalid, fragmentNode.name, fragmentRef, componentDisplayName]);
   return [loadMore, hasMore, forceDisposeFn];
 }
 module.exports = useLoadMoreFunction_EXPERIMENTAL;

package/lib/relay-hooks/usePaginationFragment.js

@@ -11,6 +11,7 @@ var _require = require('react'),
   useDebugValue = _require.useDebugValue,
   useState = _require.useState;
 var _require2 = require('relay-runtime'),
+  RelayFeatureFlags = _require2.RelayFeatureFlags,
   getFragment = _require2.getFragment,
   getFragmentIdentifier = _require2.getFragmentIdentifier,
   getPaginationMetadata = _require2.getPaginationMetadata;
@@ -110,7 +111,10 @@ function useLoadMore(args) {
     },
     error: function error() {
       return setIsLoadingMore(false);
-    }
+    },
+    unsubscribe: RelayFeatureFlags.ENABLE_USE_PAGINATION_IS_LOADING_FIX ? function () {
+      return setIsLoadingMore(false);
+    } : undefined
   };
   var handleReset = function handleReset() {
     return setIsLoadingMore(false);

package/lib/relay-hooks/usePrefetchableForwardPaginationFragment.js

@@ -0,0 +1,228 @@
+'use strict';
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault")["default"];
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
+var useFragment = require('./useFragment');
+var useLoadMoreFunction = require('./useLoadMoreFunction');
+var useRefetchableFragmentInternal = require('./useRefetchableFragmentInternal');
+var useRelayEnvironment = require('./useRelayEnvironment');
+var useStaticFragmentNodeWarning = require('./useStaticFragmentNodeWarning');
+var invariant = require('invariant');
+var _require = require('react'),
+  useCallback = _require.useCallback,
+  useDebugValue = _require.useDebugValue,
+  useEffect = _require.useEffect,
+  useLayoutEffect = _require.useLayoutEffect,
+  useMemo = _require.useMemo,
+  useRef = _require.useRef,
+  useState = _require.useState;
+var _require2 = require('relay-runtime'),
+  getFragment = _require2.getFragment,
+  getFragmentIdentifier = _require2.getFragmentIdentifier,
+  getPaginationMetadata = _require2.getPaginationMetadata;
+var _require3 = require('relay-runtime'),
+  ConnectionInterface = _require3.ConnectionInterface,
+  RelayFeatureFlags = _require3.RelayFeatureFlags,
+  getSelector = _require3.getSelector,
+  getValueAtPath = _require3.getValueAtPath;
+function usePrefetchableForwardPaginationFragment(fragmentInput, parentFragmentRef, bufferSize, initialSize, prefetchingLoadMoreOptions) {
+  var _fragmentInput$metada, _fragmentInput$metada2;
+  var minimalFetchSize = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : 1;
+  var disablePrefetching = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : false;
+  var fragmentNode = getFragment(fragmentInput);
+  useStaticFragmentNodeWarning(fragmentNode, 'first argument of usePrefetchableForwardPaginationFragment()');
+  var componentDisplayName = 'usePrefetchableForwardPaginationFragment()';
+  var _getPaginationMetadat = getPaginationMetadata(fragmentNode, componentDisplayName),
+    connectionPathInFragmentData = _getPaginationMetadat.connectionPathInFragmentData,
+    paginationRequest = _getPaginationMetadat.paginationRequest,
+    paginationMetadata = _getPaginationMetadat.paginationMetadata;
+  var _useRefetchableFragme = useRefetchableFragmentInternal(fragmentNode, parentFragmentRef, componentDisplayName),
+    fragmentData = _useRefetchableFragme.fragmentData,
+    fragmentRef = _useRefetchableFragme.fragmentRef,
+    refetch = _useRefetchableFragme.refetch;
+  var fragmentIdentifier = getFragmentIdentifier(fragmentNode, fragmentRef);
+  var edgeKeys = useMemo(function () {
+    var connection = getValueAtPath(fragmentData, connectionPathInFragmentData);
+    if (connection == null) {
+      return null;
+    }
+    var _ConnectionInterface$ = ConnectionInterface.get(),
+      EDGES = _ConnectionInterface$.EDGES;
+    return connection[EDGES];
+  }, [connectionPathInFragmentData, fragmentData]);
+  var sourceSize = edgeKeys == null ? -1 : edgeKeys.length;
+  var _useState = useState(initialSize != null ? initialSize : sourceSize),
+    _numInUse = _useState[0],
+    setNumInUse = _useState[1];
+  var numInUse = _numInUse;
+  if (_numInUse === -1 && sourceSize !== -1) {
+    numInUse = initialSize != null ? initialSize : sourceSize;
+    setNumInUse(numInUse);
+  }
+  var environment = useRelayEnvironment();
+  var _useState2 = useState(false),
+    isLoadingMore = _useState2[0],
+    reallySetIsLoadingMore = _useState2[1];
+  var _useState3 = useState(false),
+    isRefetching = _useState3[0],
+    setIsRefetching = _useState3[1];
+  var availableSizeRef = useRef(0);
+  var setIsLoadingMore = useCallback(function (value) {
+    var _environment$getSched;
+    var schedule = (_environment$getSched = environment.getScheduler()) === null || _environment$getSched === void 0 ? void 0 : _environment$getSched.schedule;
+    if (schedule) {
+      schedule(function () {
+        reallySetIsLoadingMore(value);
+      });
+    } else {
+      reallySetIsLoadingMore(value);
+    }
+  }, [environment]);
+  var isLoadingMoreRef = useRef(false);
+  var observer = useMemo(function () {
+    function setIsLoadingFalse() {
+      isLoadingMoreRef.current = false;
+      setIsLoadingMore(false);
+    }
+    return {
+      start: function start() {
+        isLoadingMoreRef.current = true;
+        reallySetIsLoadingMore(true);
+      },
+      complete: setIsLoadingFalse,
+      error: setIsLoadingFalse,
+      unsubscribe: RelayFeatureFlags.ENABLE_USE_PAGINATION_IS_LOADING_FIX ? setIsLoadingFalse : undefined
+    };
+  }, [setIsLoadingMore]);
+  var handleReset = useCallback(function () {
+    if (!isRefetching) {
+      var _environment$getSched2;
+      var schedule = (_environment$getSched2 = environment.getScheduler()) === null || _environment$getSched2 === void 0 ? void 0 : _environment$getSched2.schedule;
+      if (schedule) {
+        schedule(function () {
+          setNumInUse(-1);
+        });
+      } else {
+        setNumInUse(-1);
+      }
+    }
+    isLoadingMoreRef.current = false;
+    setIsLoadingMore(false);
+  }, [environment, isRefetching, setIsLoadingMore]);
+  var _useLoadMoreFunction = useLoadMoreFunction({
+      componentDisplayName: componentDisplayName,
+      connectionPathInFragmentData: connectionPathInFragmentData,
+      direction: 'forward',
+      fragmentData: fragmentData,
+      fragmentIdentifier: fragmentIdentifier,
+      fragmentNode: fragmentNode,
+      fragmentRef: fragmentRef,
+      paginationMetadata: paginationMetadata,
+      paginationRequest: paginationRequest,
+      observer: observer,
+      onReset: handleReset
+    }),
+    loadMore = _useLoadMoreFunction[0],
+    hasNext = _useLoadMoreFunction[1],
+    disposeFetchNext = _useLoadMoreFunction[2];
+  useLayoutEffect(function () {
+    availableSizeRef.current = sourceSize - numInUse;
+  }, [numInUse, sourceSize]);
+  var prefetchingUNSTABLE_extraVariables = prefetchingLoadMoreOptions === null || prefetchingLoadMoreOptions === void 0 ? void 0 : prefetchingLoadMoreOptions.UNSTABLE_extraVariables;
+  var prefetchingOnComplete = prefetchingLoadMoreOptions === null || prefetchingLoadMoreOptions === void 0 ? void 0 : prefetchingLoadMoreOptions.onComplete;
+  var showMore = useCallback(function (numToAdd, options) {
+    if (!isLoadingMoreRef.current || availableSizeRef.current >= 0) {
+      availableSizeRef.current -= numToAdd;
+      setNumInUse(function (lastNumInUse) {
+        return lastNumInUse + numToAdd;
+      });
+      if (!isLoadingMoreRef.current && availableSizeRef.current < 0) {
+        loadMore(Math.max(minimalFetchSize, Math.min(numToAdd, bufferSize - availableSizeRef.current)), options !== null && options !== void 0 ? options : {
+          onComplete: prefetchingOnComplete,
+          UNSTABLE_extraVariables: typeof prefetchingUNSTABLE_extraVariables === 'function' ? prefetchingUNSTABLE_extraVariables({
+            hasNext: hasNext,
+            data: fragmentData,
+            getServerEdges: function getServerEdges() {
+              var selector = getSelector(edgesFragment, edgeKeys);
+              if (selector == null) {
+                return [];
+              }
+              !(selector.kind === 'PluralReaderSelector') ? process.env.NODE_ENV !== "production" ? invariant(false, 'Expected a plural selector') : invariant(false) : void 0;
+              return selector.selectors.map(function (sel) {
+                return environment.lookup(sel).data;
+              });
+            }
+          }) : prefetchingUNSTABLE_extraVariables
+        });
+      }
+    }
+  }, [bufferSize, loadMore, minimalFetchSize, edgeKeys, fragmentData, prefetchingUNSTABLE_extraVariables, prefetchingOnComplete]);
+  var edgesFragment = (_fragmentInput$metada = fragmentInput.metadata) === null || _fragmentInput$metada === void 0 ? void 0 : (_fragmentInput$metada2 = _fragmentInput$metada.refetch) === null || _fragmentInput$metada2 === void 0 ? void 0 : _fragmentInput$metada2.edgesFragment;
+  !(edgesFragment != null) ? process.env.NODE_ENV !== "production" ? invariant(false, 'usePrefetchableForwardPaginationFragment: Expected the edge fragment to be defined, ' + 'please make sure you have added `prefetchable_pagination: true`  to `@connection`') : invariant(false) : void 0;
+  useEffect(function () {
+    if (!isLoadingMoreRef.current && !isLoadingMore && !isRefetching && !disablePrefetching && hasNext && (sourceSize - numInUse < bufferSize || numInUse > sourceSize)) {
+      var onComplete = prefetchingOnComplete;
+      loadMore(Math.max(bufferSize - Math.max(sourceSize - numInUse, 0), numInUse - sourceSize, minimalFetchSize), {
+        onComplete: onComplete,
+        UNSTABLE_extraVariables: typeof prefetchingUNSTABLE_extraVariables === 'function' ? prefetchingUNSTABLE_extraVariables({
+          hasNext: hasNext,
+          data: fragmentData,
+          getServerEdges: function getServerEdges() {
+            var selector = getSelector(edgesFragment, edgeKeys);
+            if (selector == null) {
+              return [];
+            }
+            !(selector.kind === 'PluralReaderSelector') ? process.env.NODE_ENV !== "production" ? invariant(false, 'Expected a plural selector') : invariant(false) : void 0;
+            return selector.selectors.map(function (sel) {
+              return environment.lookup(sel).data;
+            });
+          }
+        }) : prefetchingUNSTABLE_extraVariables
+      });
+    }
+  }, [hasNext, bufferSize, isRefetching, loadMore, numInUse, prefetchingUNSTABLE_extraVariables, prefetchingOnComplete, sourceSize, edgeKeys, isLoadingMore, minimalFetchSize, environment, edgesFragment]);
+  var realNumInUse = Math.min(numInUse, sourceSize);
+  var derivedEdgeKeys = useMemo(function () {
+    var _edgeKeys$slice;
+    return (_edgeKeys$slice = edgeKeys === null || edgeKeys === void 0 ? void 0 : edgeKeys.slice(0, realNumInUse)) !== null && _edgeKeys$slice !== void 0 ? _edgeKeys$slice : [];
+  }, [edgeKeys, realNumInUse]);
+  var edges = useFragment(edgesFragment, derivedEdgeKeys);
+  var refetchPagination = useCallback(function (variables, options) {
+    disposeFetchNext();
+    setIsRefetching(true);
+    return refetch(variables, (0, _objectSpread2["default"])((0, _objectSpread2["default"])({}, options), {}, {
+      onComplete: function onComplete(maybeError) {
+        var _environment$getSched3, _options$onComplete;
+        var schedule = (_environment$getSched3 = environment.getScheduler()) === null || _environment$getSched3 === void 0 ? void 0 : _environment$getSched3.schedule;
+        if (schedule) {
+          schedule(function () {
+            setIsRefetching(false);
+            setNumInUse(-1);
+          });
+        } else {
+          setIsRefetching(false);
+          setNumInUse(-1);
+        }
+        options === null || options === void 0 ? void 0 : (_options$onComplete = options.onComplete) === null || _options$onComplete === void 0 ? void 0 : _options$onComplete.call(options, maybeError);
+      },
+      __environment: undefined
+    }));
+  }, [disposeFetchNext, environment, refetch]);
+  if (process.env.NODE_ENV !== "production") {
+    useDebugValue({
+      fragment: fragmentNode.name,
+      data: fragmentData,
+      hasNext: hasNext,
+      isLoadingNext: isLoadingMore
+    });
+  }
+  return {
+    edges: edges,
+    data: fragmentData,
+    loadNext: showMore,
+    hasNext: hasNext || sourceSize > numInUse,
+    isLoadingNext: isLoadingMore && numInUse > sourceSize,
+    refetch: refetchPagination
+  };
+}
+module.exports = usePrefetchableForwardPaginationFragment;

package/lib/relay-hooks/usePrefetchableForwardPaginationFragment_EXPERIMENTAL.js

@@ -22,6 +22,7 @@ var _require2 = require('relay-runtime'),
   getPaginationMetadata = _require2.getPaginationMetadata;
 var _require3 = require('relay-runtime'),
   ConnectionInterface = _require3.ConnectionInterface,
+  RelayFeatureFlags = _require3.RelayFeatureFlags,
   getSelector = _require3.getSelector,
   getValueAtPath = _require3.getValueAtPath;
 function usePrefetchableForwardPaginationFragment_EXPERIMENTAL(fragmentInput, parentFragmentRef, bufferSize, initialSize, prefetchingLoadMoreOptions) {
@@ -78,19 +79,18 @@ function usePrefetchableForwardPaginationFragment_EXPERIMENTAL(fragmentInput, pa
   }, [environment]);
   var isLoadingMoreRef = useRef(false);
   var observer = useMemo(function () {
+    function setIsLoadingFalse() {
+      isLoadingMoreRef.current = false;
+      setIsLoadingMore(false);
+    }
     return {
       start: function start() {
         isLoadingMoreRef.current = true;
         reallySetIsLoadingMore(true);
       },
-      complete: function complete() {
-        isLoadingMoreRef.current = false;
-        setIsLoadingMore(false);
-      },
-      error: function error() {
-        isLoadingMoreRef.current = false;
-        setIsLoadingMore(false);
-      }
+      complete: setIsLoadingFalse,
+      error: setIsLoadingFalse,
+      unsubscribe: RelayFeatureFlags.ENABLE_USE_PAGINATION_IS_LOADING_FIX ? setIsLoadingFalse : undefined
     };
   }, [setIsLoadingMore]);
   var handleReset = useCallback(function () {

package/lib/relay-hooks/useRefetchableFragmentInternal.js

@@ -55,7 +55,7 @@ function reducer(state, action) {
       }
   }
 }
-function useRefetchableFragmentNode(fragmentNode, parentFragmentRef, componentDisplayName) {
+function useRefetchableFragmentInternal(fragmentNode, parentFragmentRef, componentDisplayName) {
   var parentEnvironment = useRelayEnvironment();
   var _getRefetchMetadata = getRefetchMetadata(fragmentNode, componentDisplayName),
     refetchableRequest = _getRefetchMetadata.refetchableRequest,
@@ -226,7 +226,7 @@ if (process.env.NODE_ENV !== "production") {
       }
     },
     checkSameIDAfterRefetch: function checkSameIDAfterRefetch(previousIDAndTypename, refetchedFragmentRef, fragmentNode, componentDisplayName) {
-      if (previousIDAndTypename == null) {
+      if (previousIDAndTypename == null || refetchedFragmentRef == null) {
         return;
       }
       var _require6 = require('relay-runtime'),
@@ -238,4 +238,4 @@ if (process.env.NODE_ENV !== "production") {
     }
   };
 }
-module.exports = useRefetchableFragmentNode;
+module.exports = useRefetchableFragmentInternal;

package/lib/relay-hooks/useRelayLoggingContext.js

@@ -0,0 +1,9 @@
+'use strict';
+
+var ReactRelayLoggingContext = require('./../ReactRelayLoggingContext');
+var _require = require('react'),
+  useContext = _require.useContext;
+function useRelayLoggingContext() {
+  return useContext(ReactRelayLoggingContext);
+}
+module.exports = useRelayLoggingContext;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "react-relay",
   "description": "A framework for building GraphQL-driven React applications.",
-  "version": "18.2.0",
+  "version": "19.0.0",
   "keywords": [
     "graphql",
     "relay",
@@ -20,10 +20,10 @@
     "fbjs": "^3.0.2",
     "invariant": "^2.2.4",
     "nullthrows": "^1.1.1",
-    "relay-runtime": "18.2.0"
+    "relay-runtime": "19.0.0"
   },
   "peerDependencies": {
-    "react": "^16.9.0 || ^17 || ^18"
+    "react": "^16.9.0 || ^17 || ^18 || ^19"
   },
   "directories": {
     "": "./"

package/relay-hooks/EntryPointContainer.react.js.flow

@@ -22,29 +22,25 @@ const React = require('react');
 const {useContext, useEffect} = require('react');
 const warning = require('warning');
 
-function EntryPointContainer<
+component EntryPointContainer<
   // $FlowFixMe[unsupported-variance-annotation]
-  +TPreloadedQueries: {...},
+  TRuntimeProps: {...},
+  TRenders: React.Node,
   // $FlowFixMe[unsupported-variance-annotation]
-  +TPreloadedNestedEntryPoints: {...},
-  // $FlowFixMe[unsupported-variance-annotation]
-  +TRuntimeProps: {...},
-  // $FlowFixMe[unsupported-variance-annotation]
-  +TExtraProps,
-  // $FlowFixMe[unsupported-variance-annotation]
-  +TEntryPointComponent: EntryPointComponent<
-    TPreloadedQueries,
-    TPreloadedNestedEntryPoints,
+  TEntryPointComponent: EntryPointComponent<
+    // $FlowExpectedErrors[unclear-type] Use any to accept all kinds of EntryPointComponent
+    any,
+    // $FlowExpectedErrors[unclear-type] Use any to accept all kinds of EntryPointComponent
+    any,
     TRuntimeProps,
-    TExtraProps,
+    // $FlowExpectedErrors[unclear-type] Use any to accept all kinds of EntryPointComponent
+    any,
+    TRenders,
   >,
->({
-  entryPointReference,
-  props,
-}: $ReadOnly<{
+>(
   entryPointReference: PreloadedEntryPoint<TEntryPointComponent>,
   props: TRuntimeProps,
-}>): React.MixedElement {
+) renders TRenders {
   warning(
     entryPointReference.isDisposed === false,
     '<EntryPointContainer>: Expected entryPointReference to not be disposed ' +

package/relay-hooks/EntryPointTypes.flow.js.flow

@@ -36,6 +36,7 @@ export type PreloadFetchPolicy =
 export type PreloadOptions = {
   +fetchKey?: string | number,
   +fetchPolicy?: ?PreloadFetchPolicy,
+  +includeIf?: ?boolean,
   +networkCacheConfig?: ?CacheConfig,
 };
 
@@ -178,14 +179,15 @@ export type EntryPointComponent<
   TPreloadedEntryPoints = {},
   TRuntimeProps = {},
   TExtraProps = null,
-> = ComponentType<
-  EntryPointProps<
+  TRenders: React.Node = React.Node,
+> = component(
+  ...EntryPointProps<
     TPreloadedQueries,
     TPreloadedEntryPoints,
     TRuntimeProps,
     TExtraProps,
-  >,
->;
+  >
+) renders TRenders;
 
 // Return type of the `getPreloadProps(...)` of the entry point
 export type PreloadProps<

package/relay-hooks/MatchContainer.js.flow

@@ -95,7 +95,7 @@ export type MatchPointer = {
 
 export type MatchContainerProps<TProps: {...}, TFallback: React.Node> = {
   +fallback?: ?TFallback,
-  +loader: (module: mixed) => React.ComponentType<TProps>,
+  +loader: (module: mixed) => component(...TProps),
   +match: ?MatchPointer | ?TypenameOnlyPointer,
   +props?: TProps,
 };

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

@@ -558,13 +558,10 @@ class FragmentResourceImpl {
   _throwOrLogErrorsInSnapshot(snapshot: SingularOrPluralSnapshot) {
     if (Array.isArray(snapshot)) {
       snapshot.forEach(s => {
-        handlePotentialSnapshotErrors(this._environment, s.errorResponseFields);
+        handlePotentialSnapshotErrors(this._environment, s.fieldErrors);
       });
     } else {
-      handlePotentialSnapshotErrors(
-        this._environment,
-        snapshot.errorResponseFields,
-      );
+      handlePotentialSnapshotErrors(this._environment, snapshot.fieldErrors);
     }
   }
 
@@ -763,7 +760,7 @@ class FragmentResourceImpl {
       missingLiveResolverFields: currentSnapshot.missingLiveResolverFields,
       seenRecords: currentSnapshot.seenRecords,
       selector: currentSnapshot.selector,
-      errorResponseFields: currentSnapshot.errorResponseFields,
+      fieldErrors: currentSnapshot.fieldErrors,
     };
     if (updatedData !== renderData) {
       const result = getFragmentResult(

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

@@ -14,13 +14,7 @@
 import type {LoadMoreFn, UseLoadMoreFunctionArgs} from '../useLoadMoreFunction';
 import type {Options} from './useRefetchableFragmentNode';
 import type {RefetchableFragment} from 'relay-runtime';
-import type {
-  Disposable,
-  FragmentType,
-  GraphQLResponse,
-  Observer,
-  Variables,
-} from 'relay-runtime';
+import type {Disposable, FragmentType, Variables} from 'relay-runtime';
 
 const useLoadMoreFunction = require('../useLoadMoreFunction');
 const useStaticFragmentNodeWarning = require('../useStaticFragmentNodeWarning');
@@ -169,16 +163,7 @@ hook useBlockingPaginationFragment<
 hook useLoadMore<TVariables: Variables>(args: {
   disableStoreUpdates: () => void,
   enableStoreUpdates: () => void,
-  ...$Exact<
-    $Diff<
-      UseLoadMoreFunctionArgs,
-      {
-        observer: Observer<GraphQLResponse>,
-        onReset: () => void,
-        ...
-      },
-    >,
-  >,
+  ...$Exact<Omit<UseLoadMoreFunctionArgs, 'observer' | 'onReset'>>,
 }): [LoadMoreFn<TVariables>, boolean, () => void] {
   const {disableStoreUpdates, enableStoreUpdates, ...loadMoreArgs} = args;
   const [requestPromise, setRequestPromise] = useState<null | Promise<mixed>>(

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

@@ -592,7 +592,7 @@ if (__DEV__) {
       fragmentNode: ReaderFragment,
       componentDisplayName: string,
     ): void {
-      if (previousIDAndTypename == null) {
+      if (previousIDAndTypename == null || refetchedFragmentRef == null) {
         return;
       }
       const {ID_KEY} = require('relay-runtime');

package/relay-hooks/loadEntryPoint.js.flow

@@ -62,6 +62,12 @@ function loadEntryPoint<
       const {environmentProviderOptions, options, parameters, variables} =
         query;
 
+      // $FlowFixMe[prop-missing] Exists for types that wrap EntryPoint
+      if (options?.includeIf === false) {
+        // don't preload this query since the includeIf is false
+        return;
+      }
+
       const environment = environmentProvider.getEnvironment(
         environmentProviderOptions,
       );

package/relay-hooks/loadQuery.js.flow

@@ -28,6 +28,7 @@ import type {
   RequestIdentifier,
   RequestParameters,
 } from 'relay-runtime';
+import type {OperationAvailability} from 'relay-runtime/store/RelayStoreTypes';
 
 const invariant = require('invariant');
 const {
@@ -130,6 +131,7 @@ function loadQuery<
   let didMakeNetworkRequest = false;
   const makeNetworkRequest = (
     params: RequestParameters,
+    checkOperation?: () => OperationAvailability,
   ): Observable<GraphQLResponse> => {
     // N.B. this function is called synchronously or not at all
     // didMakeNetworkRequest is safe to rely on in the returned value
@@ -160,7 +162,16 @@ function loadQuery<
       'raw-network-request-' + getRequestIdentifier(params, variables);
     const observable = fetchQueryDeduped(environment, identifier, () => {
       const network = environment.getNetwork();
-      return network.execute(params, variables, networkCacheConfig);
+      return network.execute(
+        params,
+        variables,
+        networkCacheConfig,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        checkOperation,
+      );
     });
 
     const {unsubscribe} = observable.subscribe({
@@ -247,13 +258,18 @@ function loadQuery<
     // then we do nothing.
     const shouldFetch =
       fetchPolicy !== 'store-or-network' ||
+      // environment.check can trigger store updates through missing field handlers,
+      // short circuiting the check avoids unnecessary updates
       environment.check(operation).status !== 'available';
 
     if (shouldFetch) {
       executeDeduped(operation, () => {
         // N.B. Since we have the operation synchronously available here,
         // we can immediately fetch and execute the operation.
-        const networkObservable = makeNetworkRequest(concreteRequest.params);
+        const networkObservable = makeNetworkRequest(
+          concreteRequest.params,
+          () => environment.check(operation),
+        );
         const executeObservable = executeWithNetworkSource(
           operation,
           networkObservable,

package/relay-hooks/preloadQuery_DEPRECATED.js.flow

@@ -24,6 +24,7 @@ import type {
   GraphQLResponse,
   GraphQLTaggedNode,
   IEnvironment,
+  OperationAvailability,
   OperationType,
   Subscription,
 } from 'relay-runtime';
@@ -167,12 +168,17 @@ function preloadQueryDeduped<TQuery: OperationType>(
   }`;
   const prevQueryEntry = pendingQueries.get(cacheKey);
 
-  const availability =
-    fetchPolicy === STORE_OR_NETWORK_DEFAULT && query != null && query != null
+  function checkOperation(): OperationAvailability {
+    return query != null
       ? environment.check(
           createOperationDescriptor(query, variables, networkCacheConfig),
         )
       : {status: 'missing'};
+  }
+  const availability =
+    fetchPolicy === STORE_OR_NETWORK_DEFAULT
+      ? checkOperation()
+      : {status: 'missing'};
 
   let nextQueryEntry: ?PendingQueryEntry;
   if (availability.status === 'available' && query != null) {
@@ -203,7 +209,16 @@ function preloadQueryDeduped<TQuery: OperationType>(
     }
   } else if (prevQueryEntry == null || prevQueryEntry.kind !== 'network') {
     // Should fetch but we're not already fetching: fetch!
-    const source = network.execute(params, variables, networkCacheConfig, null);
+    const source = network.execute(
+      params,
+      variables,
+      networkCacheConfig,
+      null,
+      undefined,
+      undefined,
+      undefined,
+      checkOperation,
+    );
     const subject = new ReplaySubject<GraphQLResponse>();
     nextQueryEntry = {
       cacheKey,

package/relay-hooks/readFragmentInternal.js.flow

@@ -83,13 +83,10 @@ function handlePotentialSnapshotErrorsForState(
   state: FragmentState,
 ): void {
   if (state.kind === 'singular') {
-    handlePotentialSnapshotErrors(
-      environment,
-      state.snapshot.errorResponseFields,
-    );
+    handlePotentialSnapshotErrors(environment, state.snapshot.fieldErrors);
   } else if (state.kind === 'plural') {
     for (const snapshot of state.snapshots) {
-      handlePotentialSnapshotErrors(environment, snapshot.errorResponseFields);
+      handlePotentialSnapshotErrors(environment, snapshot.fieldErrors);
     }
   }
 }