react-relay 13.1.1 → 14.1.0

package/relay-hooks/QueryResource.js.flow

@@ -9,8 +9,6 @@
  * @format
  */
 
-// flowlint ambiguous-object-type:error
-
 'use strict';
 
 import type {Cache} from './LRUCache';
@@ -32,7 +30,7 @@ import type {
 const LRUCache = require('./LRUCache');
 const SuspenseResource = require('./SuspenseResource');
 const invariant = require('invariant');
-const {RelayFeatureFlags, isPromise} = require('relay-runtime');
+const {isPromise} = require('relay-runtime');
 const warning = require('warning');
 
 const CACHE_CAPACITY = 1000;
@@ -41,7 +39,7 @@ const DEFAULT_FETCH_POLICY = 'store-or-network';
 export type QueryResource = QueryResourceImpl;
 
 type QueryResourceCache = Cache<QueryResourceCacheEntry>;
-type QueryResourceCacheEntry = {|
+type QueryResourceCacheEntry = {
   +id: number,
   +cacheIdentifier: string,
   +operationAvailability: ?OperationAvailability,
@@ -50,25 +48,23 @@ type QueryResourceCacheEntry = {|
   // from the incremental responses, so later we can choose how to handle errors
   // in the incremental payloads.
   processedPayloadsCount: number,
-  getRetainCount(): number,
-  getNetworkSubscription(): ?Subscription,
   setNetworkSubscription(?Subscription): void,
   getValue(): Error | Promise<void> | QueryResult,
   setValue(Error | Promise<void> | QueryResult): void,
   temporaryRetain(environment: IEnvironment): Disposable,
   permanentRetain(environment: IEnvironment): Disposable,
   releaseTemporaryRetain(): void,
-|};
+};
 export opaque type QueryResult: {
   fragmentNode: ReaderFragment,
   fragmentRef: mixed,
   ...
-} = {|
+} = {
   cacheIdentifier: string,
   fragmentNode: ReaderFragment,
   fragmentRef: mixed,
   operation: OperationDescriptor,
-|};
+};
 
 const WEAKMAP_SUPPORTED = typeof WeakMap === 'function';
 interface IMap<K, V> {
@@ -125,39 +121,6 @@ function createCacheEntry(
   value: Error | Promise<void> | QueryResult,
   networkSubscription: ?Subscription,
   onDispose: QueryResourceCacheEntry => void,
-): QueryResourceCacheEntry {
-  // There should be no behavior difference between createCacheEntry_new and
-  // createCacheEntry_old, and it doesn't directly relate to Client Edges.
-  // It was just a refactoring that was needed for Client Edges but that
-  // is behind the feature flag just in case there is any accidental breakage.
-  if (RelayFeatureFlags.REFACTOR_SUSPENSE_RESOURCE) {
-    return createCacheEntry_new(
-      cacheIdentifier,
-      operation,
-      operationAvailability,
-      value,
-      networkSubscription,
-      onDispose,
-    );
-  } else {
-    return createCacheEntry_old(
-      cacheIdentifier,
-      operation,
-      operationAvailability,
-      value,
-      networkSubscription,
-      onDispose,
-    );
-  }
-}
-
-function createCacheEntry_new(
-  cacheIdentifier: string,
-  operation: OperationDescriptor,
-  operationAvailability: ?OperationAvailability,
-  value: Error | Promise<void> | QueryResult,
-  networkSubscription: ?Subscription,
-  onDispose: QueryResourceCacheEntry => void,
 ): QueryResourceCacheEntry {
   const isLiveQuery = operationIsLiveQuery(operation);
 
@@ -191,12 +154,6 @@ function createCacheEntry_new(
     setValue(val: QueryResult | Promise<void> | Error) {
       currentValue = val;
     },
-    getRetainCount() {
-      return suspenseResource.getRetainCount();
-    },
-    getNetworkSubscription() {
-      return currentNetworkSubscription;
-    },
     setNetworkSubscription(subscription: ?Subscription) {
       if (isLiveQuery && currentNetworkSubscription != null) {
         currentNetworkSubscription.unsubscribe();
@@ -217,153 +174,6 @@ function createCacheEntry_new(
   return cacheEntry;
 }
 
-const DATA_RETENTION_TIMEOUT = 5 * 60 * 1000;
-function createCacheEntry_old(
-  cacheIdentifier: string,
-  operation: OperationDescriptor,
-  operationAvailability: ?OperationAvailability,
-  value: Error | Promise<void> | QueryResult,
-  networkSubscription: ?Subscription,
-  onDispose: QueryResourceCacheEntry => void,
-): QueryResourceCacheEntry {
-  const isLiveQuery = operationIsLiveQuery(operation);
-
-  let currentValue: Error | Promise<void> | QueryResult = value;
-  let retainCount = 0;
-  let retainDisposable: ?Disposable = null;
-  let releaseTemporaryRetain: ?() => void = null;
-  let currentNetworkSubscription: ?Subscription = networkSubscription;
-
-  const retain = (environment: IEnvironment) => {
-    retainCount++;
-    if (retainCount === 1) {
-      retainDisposable = environment.retain(operation);
-    }
-    return {
-      dispose: () => {
-        retainCount = Math.max(0, retainCount - 1);
-        if (retainCount === 0) {
-          invariant(
-            retainDisposable != null,
-            'Relay: Expected disposable to release query to be defined.' +
-              "If you're seeing this, this is likely a bug in Relay.",
-          );
-          retainDisposable.dispose();
-          retainDisposable = null;
-        }
-        onDispose(cacheEntry);
-      },
-    };
-  };
-
-  const cacheEntry = {
-    cacheIdentifier,
-    id: nextID++,
-    processedPayloadsCount: 0,
-    operationAvailability,
-    getValue() {
-      return currentValue;
-    },
-    setValue(val: QueryResult | Promise<void> | Error) {
-      currentValue = val;
-    },
-    getRetainCount() {
-      return retainCount;
-    },
-    getNetworkSubscription() {
-      return currentNetworkSubscription;
-    },
-    setNetworkSubscription(subscription: ?Subscription) {
-      if (isLiveQuery && currentNetworkSubscription != null) {
-        currentNetworkSubscription.unsubscribe();
-      }
-      currentNetworkSubscription = subscription;
-    },
-    temporaryRetain(environment: IEnvironment): Disposable {
-      // NOTE: If we're executing in a server environment, there's no need
-      // to create temporary retains, since the component will never commit.
-      if (environment.isServer()) {
-        return {dispose: () => {}};
-      }
-
-      // NOTE: temporaryRetain is called during the render phase. However,
-      // given that we can't tell if this render will eventually commit or not,
-      // we create a timer to autodispose of this retain in case the associated
-      // component never commits.
-      // If the component /does/ commit, permanentRetain will clear this timeout
-      // and permanently retain the data.
-      const disposable = retain(environment);
-      let releaseQueryTimeout = null;
-      const localReleaseTemporaryRetain = () => {
-        clearTimeout(releaseQueryTimeout);
-        releaseQueryTimeout = null;
-        releaseTemporaryRetain = null;
-        disposable.dispose();
-        // Normally if this entry never commits, the request would've ended by the
-        // time this timeout expires and the temporary retain is released. However,
-        // we need to do this for live queries which remain open indefinitely.
-        if (
-          isLiveQuery &&
-          retainCount <= 0 &&
-          currentNetworkSubscription != null
-        ) {
-          currentNetworkSubscription.unsubscribe();
-        }
-      };
-      releaseQueryTimeout = setTimeout(
-        localReleaseTemporaryRetain,
-        DATA_RETENTION_TIMEOUT,
-      );
-
-      // NOTE: Since temporaryRetain can be called multiple times, we release
-      // the previous temporary retain after we re-establish a new one, since
-      // we only ever need a single temporary retain until the permanent retain is
-      // established.
-      // temporaryRetain may be called multiple times by React during the render
-      // phase, as well as multiple times by other query components that are
-      // rendering the same query/variables.
-      if (releaseTemporaryRetain != null) {
-        releaseTemporaryRetain();
-      }
-      releaseTemporaryRetain = localReleaseTemporaryRetain;
-
-      return {
-        dispose: () => {
-          releaseTemporaryRetain && releaseTemporaryRetain();
-        },
-      };
-    },
-    permanentRetain(environment: IEnvironment): Disposable {
-      const disposable = retain(environment);
-      if (releaseTemporaryRetain != null) {
-        releaseTemporaryRetain();
-        releaseTemporaryRetain = null;
-      }
-
-      return {
-        dispose: () => {
-          disposable.dispose();
-          if (
-            isLiveQuery &&
-            retainCount <= 0 &&
-            currentNetworkSubscription != null
-          ) {
-            currentNetworkSubscription.unsubscribe();
-          }
-        },
-      };
-    },
-    releaseTemporaryRetain() {
-      if (releaseTemporaryRetain != null) {
-        releaseTemporaryRetain();
-        releaseTemporaryRetain = null;
-      }
-    },
-  };
-
-  return cacheEntry;
-}
-
 class QueryResourceImpl {
   _environment: IEnvironment;
   _cache: QueryResourceCache;
@@ -532,15 +342,7 @@ class QueryResourceImpl {
   }
 
   _clearCacheEntry = (cacheEntry: QueryResourceCacheEntry): void => {
-    // The new code does this retainCount <= 0 check within SuspenseResource
-    // before calling _clearCacheEntry, whereas with the old code we do it here.
-    if (RelayFeatureFlags.REFACTOR_SUSPENSE_RESOURCE) {
-      this._cache.delete(cacheEntry.cacheIdentifier);
-    } else {
-      if (cacheEntry.getRetainCount() <= 0) {
-        this._cache.delete(cacheEntry.cacheIdentifier);
-      }
-    }
+    this._cache.delete(cacheEntry.cacheIdentifier);
   };
 
   _getOrCreateCacheEntry(
@@ -588,7 +390,9 @@ class QueryResourceImpl {
 
     let shouldFetch;
     let shouldAllowRender;
-    let resolveNetworkPromise = () => {};
+    // Different definitions for Promise in our repos can cause this variable
+    // to cause errors when synced elsewhere
+    let resolveNetworkPromise: $FlowFixMe = () => {};
     switch (fetchPolicy) {
       case 'store-only': {
         shouldFetch = false;
@@ -632,7 +436,7 @@ class QueryResourceImpl {
 
     if (shouldFetch) {
       const queryResult = getQueryResult(operation, cacheIdentifier);
-      let networkSubscription;
+      let networkSubscription: ?Subscription;
       fetchObservable.subscribe({
         start: subscription => {
           networkSubscription = subscription;
@@ -693,10 +497,9 @@ class QueryResourceImpl {
             // To complete this task we need to have a way of precisely tracking suspendable points
             warning(
               false,
-              'QueryResource: An incremental payload for query `%` returned an error: `%`:`%`.',
+              'QueryResource: An incremental payload for query `%s` returned an error: `%s`.',
               operation.fragment.node.name,
-              error.message,
-              error.stack,
+              String(error.message),
             );
           }
           resolveNetworkPromise();

package/relay-hooks/RelayEnvironmentProvider.js.flow

@@ -9,8 +9,6 @@
  * @format
  */
 
-// flowlint ambiguous-object-type:error
-
 'use strict';
 
 import type {IEnvironment} from 'relay-runtime';
@@ -24,13 +22,13 @@ const ReactRelayContext = require('react-relay/ReactRelayContext');
 
 const {useMemo} = React;
 
-type Props = $ReadOnly<{|
+type Props = $ReadOnly<{
   children: React.Node,
   environment: IEnvironment,
   getEnvironmentForActor?: ?(
     actorIdentifier: ActorIdentifier,
   ) => IActorEnvironment,
-|}>;
+}>;
 
 function RelayEnvironmentProvider(props: Props): React.Node {
   const {children, environment, getEnvironmentForActor} = props;

package/relay-hooks/SuspenseResource.js.flow

@@ -9,8 +9,6 @@
  * @format
  */
 
-// flowlint ambiguous-object-type:error
-
 'use strict';
 
 import type {Disposable, IEnvironment} from 'relay-runtime';

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

@@ -17,15 +17,15 @@ import type {
   EntryPointProps,
 } from '../../EntryPointTypes.flow';
 
-type MyComponentOtherProps = $ReadOnly<{|
+type MyComponentOtherProps = $ReadOnly<{
   foo: string,
-|}>;
+}>;
 
 type MyComponentProps = EntryPointProps<{}, {}, MyComponentOtherProps, {}>;
 
 const MyComponent = (_props: MyComponentProps) => null;
 
-type PreloadParams = $ReadOnly<{||}>;
+type PreloadParams = $ReadOnly<{}>;
 
 type MyComponentEntryPointType = EntryPoint<PreloadParams, typeof MyComponent>;
 

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

@@ -27,9 +27,9 @@ type NestedEntrypointComponentProps = EntryPointProps<{}>;
 const NestedEntrypointComponent = (_props: NestedEntrypointComponentProps) =>
   null;
 
-type NestedEntrypointPreloadParams = $ReadOnly<{|
+type NestedEntrypointPreloadParams = $ReadOnly<{
   subEntrypointPreloadParam: string,
-|}>;
+}>;
 
 type NestedEntryPointType = EntryPoint<
   NestedEntrypointPreloadParams,

package/relay-hooks/__flowtests__/__generated__/useFragmentFlowtest_user.graphql.js.flow

@@ -1,10 +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.
  *
- * @generated SignedSource<<6bdf42be355b40305d9006059aa56d70>>
+ * @generated SignedSource<<8a8e68a3fde4da3f77546ac4952f2635>>
  * @flow
  * @lightSyntaxTransform
  * @nogrep

package/relay-hooks/__flowtests__/__generated__/useFragmentFlowtest_users.graphql.js.flow

@@ -1,10 +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.
  *
- * @generated SignedSource<<22f34b875909574b411e656fc3e592db>>
+ * @generated SignedSource<<0b4a6e76a104111de9ddd4dd9abe667c>>
  * @flow
  * @lightSyntaxTransform
  * @nogrep

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

@@ -9,8 +9,6 @@
  * @format
  */
 
-// flowlint ambiguous-object-type:error
-
 import type {LoadMoreFn} from '../useLoadMoreFunction';
 import type {
   FetchFn,
@@ -36,14 +34,14 @@ type ExpectedReturnType<
   TQuery: OperationType,
   TQueryVariables,
   TFragmentData,
-> = {|
+> = {
   data: TFragmentData,
   loadNext: LoadMoreFn<TQuery>,
   loadPrevious: LoadMoreFn<TQuery>,
   hasNext: boolean,
   hasPrevious: boolean,
   refetch: FetchFn<TQueryVariables>,
-|};
+};
 
 /* eslint-disable react-hooks/rules-of-hooks */
 
@@ -103,8 +101,8 @@ refetch(variables, {
 });
 
 // LoadMore options
-declare var extraVariables: {|nickname: string|};
-declare var invalidVariables: {|foo: string|};
+declare var extraVariables: {nickname: string};
+declare var invalidVariables: {foo: string};
 
 const {loadNext} = useBlockingPaginationFragment<QueryOperation, _>(
   fragmentInput,

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

@@ -9,8 +9,6 @@
  * @format
  */
 
-// flowlint ambiguous-object-type:error
-
 import type {
   useFragmentFlowtest_user$data,
   useFragmentFlowtest_user$key,

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

@@ -9,8 +9,6 @@
  * @format
  */
 
-// flowlint ambiguous-object-type:error
-
 import type {LoadMoreFn} from '../useLoadMoreFunction';
 import type {
   FetchFn,
@@ -36,7 +34,7 @@ type ExpectedReturnType<
   TQuery: OperationType,
   TQueryVariables,
   TFragmentData,
-> = {|
+> = {
   data: TFragmentData,
   loadNext: LoadMoreFn<TQuery>,
   loadPrevious: LoadMoreFn<TQuery>,
@@ -45,7 +43,7 @@ type ExpectedReturnType<
   isLoadingNext: boolean,
   isLoadingPrevious: boolean,
   refetch: FetchFn<TQueryVariables>,
-|};
+};
 
 /* eslint-disable react-hooks/rules-of-hooks */
 
@@ -105,8 +103,8 @@ refetch(variables, {
 });
 
 // LoadMore options
-declare var extraVariables: {|nickname: string|};
-declare var invalidVariables: {|foo: string|};
+declare var extraVariables: {nickname: string};
+declare var invalidVariables: {foo: string};
 
 const {loadNext} = usePaginationFragment<QueryOperation, _>(
   fragmentInput,

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

@@ -9,8 +9,6 @@
  * @format
  */
 
-// flowlint ambiguous-object-type:error
-
 import type {
   FetchFn,
   NonNullableData,

package/relay-hooks/__flowtests__/utils.js.flow

@@ -9,8 +9,6 @@
  * @format
  */
 
-// flowlint ambiguous-object-type:error
-
 'use strict';
 
 import type {Disposable, Fragment, FragmentType} from 'relay-runtime';
@@ -28,18 +26,18 @@ export type Example_user$key = {
   ...
 };
 
-export type NonNullableData = {|
+export type NonNullableData = {
   +id: string,
   +count: number,
-|};
+};
 export type NullableData = ?NonNullableData;
 export type NonNullablePluralData = $ReadOnlyArray<NonNullableData>;
 export type NullablePluralData = ?$ReadOnlyArray<NonNullableData>;
 
-export type AnotherNonNullableData = {|
+export type AnotherNonNullableData = {
   +name: ?string,
   +friends: ?number,
-|};
+};
 
 declare export var keyNonNullable: Example_user$key;
 
@@ -66,16 +64,16 @@ declare export var fragmentData: {
   ...
 };
 
-export type QueryOperation = {|
+export type QueryOperation = {
   +variables: QueryVariables,
   +response: {...},
-|};
+};
 
-export type QueryVariables = {|
+export type QueryVariables = {
   id: string,
   nickname: ?string,
   name: string,
-|};
+};
 
 export type QueryVariablesSubset = {
   id: string,

package/relay-hooks/loadQuery.js.flow

@@ -17,6 +17,7 @@ import type {
   PreloadedQueryInner,
 } from './EntryPointTypes.flow';
 import type {
+  ConcreteRequest,
   GraphQLResponse,
   GraphQLTaggedNode,
   IEnvironment,
@@ -236,7 +237,7 @@ function loadQuery<TQuery: OperationType, TEnvironmentProviderOptions>(
     }));
   };
 
-  const checkAvailabilityAndExecute = concreteRequest => {
+  const checkAvailabilityAndExecute = (concreteRequest: ConcreteRequest) => {
     const operation = createOperationDescriptor(
       concreteRequest,
       variables,

package/relay-hooks/preloadQuery_DEPRECATED.js.flow

@@ -9,8 +9,6 @@
  * @format
  */
 
-// flowlint ambiguous-object-type:error
-
 'use strict';
 
 import type {
@@ -51,7 +49,7 @@ const pendingQueriesByEnvironment = WEAKMAP_SUPPORTED
   : new Map();
 
 type PendingQueryEntry =
-  | $ReadOnly<{|
+  | $ReadOnly<{
       cacheKey: string,
       fetchKey: ?string | ?number,
       fetchPolicy: PreloadFetchPolicy,
@@ -61,8 +59,8 @@ type PendingQueryEntry =
       status: PreloadQueryStatus,
       subject: ReplaySubject<GraphQLResponse>,
       subscription: Subscription,
-    |}>
-  | $ReadOnly<{|
+    }>
+  | $ReadOnly<{
       cacheKey: string,
       fetchKey: ?string | ?number,
       fetchPolicy: PreloadFetchPolicy,
@@ -70,7 +68,7 @@ type PendingQueryEntry =
       id: ?string,
       name: string,
       status: PreloadQueryStatus,
-    |}>;
+    }>;
 
 function preloadQuery<TQuery: OperationType, TEnvironmentProviderOptions>(
   environment: IEnvironment,
@@ -115,20 +113,13 @@ function preloadQuery<TQuery: OperationType, TEnvironmentProviderOptions>(
             if (environment.isServer()) {
               return;
             }
-            if (
-              RelayFeatureFlags.DELAY_CLEANUP_OF_PENDING_PRELOAD_QUERIES ===
-              true
-            ) {
-              setTimeout(() => {
-                // Clear the cache entry after the default timeout
-                // null-check for Flow
-                if (queryEntry != null) {
-                  cleanup(pendingQueries, queryEntry);
-                }
-              }, DEFAULT_PREFETCH_TIMEOUT);
-            } else {
-              cleanup(pendingQueries, queryEntry);
-            }
+            setTimeout(() => {
+              // Clear the cache entry after the default timeout
+              // null-check for Flow
+              if (queryEntry != null) {
+                cleanup(pendingQueries, queryEntry);
+              }
+            }, DEFAULT_PREFETCH_TIMEOUT);
           };
         })
       : null;

package/relay-hooks/prepareEntryPoint_DEPRECATED.js.flow

@@ -9,8 +9,6 @@
  * @format
  */
 
-// flowlint ambiguous-object-type:error
-
 'use strict';
 
 import type {

package/relay-hooks/react-cache/RelayReactCache.js.flow

@@ -0,0 +1,40 @@
+/**
+ * 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
+ * @emails oncall+relay
+ * @format
+ */
+
+'use strict';
+
+const invariant = require('invariant');
+// $FlowFixMe[prop-missing] These exist in experimental builds but aren't in React's types yet.
+const {unstable_getCacheForType, unstable_getCacheSignal} = require('react');
+const {RelayFeatureFlags} = require('relay-runtime');
+
+function getCacheForType<T>(factory: () => T): T {
+  invariant(
+    typeof unstable_getCacheForType === 'function' &&
+      RelayFeatureFlags.USE_REACT_CACHE,
+    'RelayReactCache.getCacheForType should only be called when the USE_REACT_CACHE feature flag is enabled and when on an experimental React build that supports it.',
+  );
+  return unstable_getCacheForType(factory);
+}
+
+function getCacheSignal(): AbortSignal {
+  invariant(
+    typeof unstable_getCacheSignal === 'function' &&
+      RelayFeatureFlags.USE_REACT_CACHE,
+    'RelayReactCache.getCacheSignal should only be called when the USE_REACT_CACHE feature flag is enabled and when on an experimental React build that supports it.',
+  );
+  return unstable_getCacheSignal();
+}
+
+module.exports = {
+  getCacheForType,
+  getCacheSignal,
+};