react-relay 17.0.0 → 18.1.0

package/relay-hooks/getConnectionState.js.flow

@@ -0,0 +1,97 @@
+/**
+ * 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 {Direction, ReaderFragment} from 'relay-runtime';
+
+const invariant = require('invariant');
+const {ConnectionInterface, getValueAtPath} = require('relay-runtime');
+
+function getConnectionState(
+  direction: Direction,
+  fragmentNode: ReaderFragment,
+  fragmentData: mixed,
+  connectionPathInFragmentData: $ReadOnlyArray<string | number>,
+): {
+  cursor: ?string,
+  hasMore: boolean,
+} {
+  const {
+    EDGES,
+    PAGE_INFO,
+    HAS_NEXT_PAGE,
+    HAS_PREV_PAGE,
+    END_CURSOR,
+    START_CURSOR,
+  } = ConnectionInterface.get();
+  const connection = getValueAtPath(fragmentData, connectionPathInFragmentData);
+  if (connection == null) {
+    return {cursor: null, hasMore: false};
+  }
+
+  invariant(
+    typeof connection === 'object',
+    'Relay: Expected connection in fragment `%s` to have been `null`, or ' +
+      'a plain object with %s and %s properties. Instead got `%s`.',
+    fragmentNode.name,
+    EDGES,
+    PAGE_INFO,
+    connection,
+  );
+
+  const edges = connection[EDGES];
+  const pageInfo = connection[PAGE_INFO];
+  if (edges == null || pageInfo == null) {
+    return {cursor: null, hasMore: false};
+  }
+
+  invariant(
+    Array.isArray(edges),
+    'Relay: Expected connection in fragment `%s` to have a plural `%s` field. ' +
+      'Instead got `%s`.',
+    fragmentNode.name,
+    EDGES,
+    edges,
+  );
+  invariant(
+    typeof pageInfo === 'object',
+    'Relay: Expected connection in fragment `%s` to have a `%s` field. ' +
+      'Instead got `%s`.',
+    fragmentNode.name,
+    PAGE_INFO,
+    pageInfo,
+  );
+
+  const cursor =
+    direction === 'forward'
+      ? pageInfo[END_CURSOR] ?? null
+      : pageInfo[START_CURSOR] ?? null;
+  invariant(
+    cursor === null || typeof cursor === 'string',
+    'Relay: Expected page info for connection in fragment `%s` to have a ' +
+      'valid `%s`. Instead got `%s`.',
+    fragmentNode.name,
+    START_CURSOR,
+    cursor,
+  );
+
+  let hasMore;
+  if (direction === 'forward') {
+    hasMore = cursor != null && pageInfo[HAS_NEXT_PAGE] === true;
+  } else {
+    hasMore = cursor != null && pageInfo[HAS_PREV_PAGE] === true;
+  }
+
+  return {cursor, hasMore};
+}
+
+module.exports = getConnectionState;

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

@@ -452,7 +452,7 @@ class FragmentResourceImpl {
       missingLiveResolverFields(snapshot)?.map(({liveStateID}) => {
         const store = environment.getStore();
 
-        // $FlowFixMe[prop-missing] This is expected to be a LiveResolverStore
+        // $FlowFixMe[prop-missing] This is expected to be a RelayModernStore
         return store.getLiveResolverPromise(liveStateID);
       }) ?? [];
 
@@ -559,21 +559,12 @@ class FragmentResourceImpl {
   _throwOrLogErrorsInSnapshot(snapshot: SingularOrPluralSnapshot) {
     if (Array.isArray(snapshot)) {
       snapshot.forEach(s => {
-        handlePotentialSnapshotErrors(
-          this._environment,
-          s.missingRequiredFields,
-          s.relayResolverErrors,
-          s.errorResponseFields,
-          s.selector.node.metadata?.throwOnFieldError ?? false,
-        );
+        handlePotentialSnapshotErrors(this._environment, s.errorResponseFields);
       });
     } else {
       handlePotentialSnapshotErrors(
         this._environment,
-        snapshot.missingRequiredFields,
-        snapshot.relayResolverErrors,
         snapshot.errorResponseFields,
-        snapshot.selector.node.metadata?.throwOnFieldError ?? false,
       );
     }
   }
@@ -773,8 +764,6 @@ class FragmentResourceImpl {
       missingLiveResolverFields: currentSnapshot.missingLiveResolverFields,
       seenRecords: currentSnapshot.seenRecords,
       selector: currentSnapshot.selector,
-      missingRequiredFields: currentSnapshot.missingRequiredFields,
-      relayResolverErrors: currentSnapshot.relayResolverErrors,
       errorResponseFields: currentSnapshot.errorResponseFields,
     };
     if (updatedData !== renderData) {

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,30 +40,19 @@ const {
   getRequest,
   getRequestIdentifier,
 } = require('relay-runtime');
-const warning = require('warning');
 
-let RenderDispatcher = null;
 let fetchKey = 100001;
 
-hook 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>;
+      }
+    : [+t: T] extends [+t: PreloadableConcreteRequest<infer V>]
+      ? V
+      : empty;
 
 declare function loadQuery<
   T,
@@ -87,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,
@@ -407,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/readFragmentInternal.js.flow

@@ -85,20 +85,11 @@ function handlePotentialSnapshotErrorsForState(
   if (state.kind === 'singular') {
     handlePotentialSnapshotErrors(
       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) {
-      handlePotentialSnapshotErrors(
-        environment,
-        snapshot.missingRequiredFields,
-        snapshot.relayResolverErrors,
-        snapshot.errorResponseFields,
-        snapshot.selector.node.metadata?.throwOnFieldError ?? false,
-      );
+      handlePotentialSnapshotErrors(environment, snapshot.errorResponseFields);
     }
   }
 }

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');
 
@@ -52,7 +52,8 @@ const initialNullEntryPointReferenceState = {kind: 'NullEntryPointReference'};
 
 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 @@ hook useLoadEntryPoint<
    * entry point references.
    */
 
-  useTrackLoadQueryInRender();
-
   const initialEntryPointReferenceInternal =
     options?.TEST_ONLY__initialEntryPointData?.entryPointReference ??
     initialNullEntryPointReferenceState;

package/relay-hooks/useFragment.js.flow

@@ -13,7 +13,6 @@
 
 import type {Fragment, FragmentType, GraphQLTaggedNode} from 'relay-runtime';
 
-const {useTrackLoadQueryInRender} = require('./loadQuery');
 const useFragmentInternal = require('./useFragmentInternal');
 const useStaticFragmentNodeWarning = require('./useStaticFragmentNodeWarning');
 const {useDebugValue} = require('react');
@@ -49,10 +48,6 @@ declare hook useFragment<TFragmentType: FragmentType, TData>(
 ): ?TData;
 
 hook useFragment(fragment: GraphQLTaggedNode, key: mixed): mixed {
-  // We need to use this hook in order to be able to track if
-  // loadQuery was called during render
-  useTrackLoadQueryInRender();
-
   const fragmentNode = getFragment(fragment);
   useStaticFragmentNodeWarning(fragmentNode, 'first argument of useFragment()');
   const data = useFragmentInternal(fragmentNode, key, 'useFragment()');