react-relay 21.0.0 → 21.0.1

package/relay-hooks/usePreloadedQuery.d.ts

@@ -0,0 +1,17 @@
+/**
+ * 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.
+ */
+
+import { PreloadedQuery } from '../ReactRelayTypes';
+import {GraphQLTaggedNode, OperationType, RenderPolicy} from 'relay-runtime';
+
+export function usePreloadedQuery<TQuery extends OperationType>(
+    gqlQuery: GraphQLTaggedNode,
+    preloadedQuery: PreloadedQuery<TQuery>,
+    options?: {
+        UNSTABLE_renderPolicy?: RenderPolicy | undefined;
+    },
+): TQuery['response'];

package/relay-hooks/useQueryLoader.d.ts

@@ -0,0 +1,33 @@
+/**
+ * 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.
+ */
+
+import {LoadQueryOptions, PreloadedQuery} from '../ReactRelayTypes';
+import {
+  DisposeFn,
+  GraphQLTaggedNode,
+  IEnvironment,
+  OperationType,
+  PreloadableConcreteRequest,
+  VariablesOf,
+} from 'relay-runtime';
+
+export type useQueryLoaderHookType<TQuery extends OperationType> = [
+    PreloadedQuery<TQuery> | null | undefined,
+    (variables: VariablesOf<TQuery>, options?: UseQueryLoaderLoadQueryOptions) => void,
+    DisposeFn,
+];
+
+export type UseQueryLoaderLoadQueryOptions =
+    & LoadQueryOptions
+    & Readonly<{
+        __environment?: IEnvironment | null | undefined;
+    }>;
+
+export function useQueryLoader<TQuery extends OperationType>(
+    preloadableRequest: GraphQLTaggedNode | PreloadableConcreteRequest<TQuery>,
+    initialQueryReference?: PreloadedQuery<TQuery> | null,
+): useQueryLoaderHookType<TQuery>;

package/relay-hooks/useQueryLoader.js.flow

@@ -37,7 +37,7 @@ export type LoaderFn<TQuery extends OperationType> = (
 
 export type UseQueryLoaderLoadQueryOptions = Readonly<{
   ...LoadQueryOptions,
-  +__environment?: ?IEnvironment,
+  readonly __environment?: ?IEnvironment,
 }>;
 
 // NullQueryReference needs to implement referential equality,

package/relay-hooks/useRefetchableFragment.d.ts

@@ -0,0 +1,23 @@
+/**
+ * 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.
+ */
+
+import {KeyType, KeyTypeData, RefetchFnDynamic} from '../ReactRelayTypes';
+import {GraphQLTaggedNode, OperationType} from 'relay-runtime';
+
+export type useRefetchableFragmentHookType<
+    TQuery extends OperationType,
+    TKey extends KeyType | null | undefined,
+    TFragmentData,
+> = [TFragmentData, RefetchFnDynamic<TQuery, TKey>];
+export function useRefetchableFragment<TQuery extends OperationType, TKey extends KeyType>(
+    fragmentInput: GraphQLTaggedNode,
+    fragmentRef: TKey,
+): useRefetchableFragmentHookType<TQuery, TKey, KeyTypeData<TKey>>;
+export function useRefetchableFragment<TQuery extends OperationType, TKey extends KeyType>(
+    fragmentInput: GraphQLTaggedNode,
+    fragmentRef: TKey | null | undefined,
+): useRefetchableFragmentHookType<TQuery, TKey, KeyTypeData<TKey> | null | undefined>;

package/relay-hooks/useRefetchableFragment.js.flow

@@ -26,12 +26,14 @@ const {getFragment} = require('relay-runtime');
 
 type RefetchVariables<
   TVariables,
-  TKey extends ?{+$fragmentSpreads: unknown, ...},
+  TKey extends ?{readonly $fragmentSpreads: unknown, ...},
 > =
   // 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: unknown, ...}]
+  [readonly key: TKey] extends [
+    readonly key: {readonly $fragmentSpreads: unknown, ...},
+  ]
     ? Partial<TVariables>
     : TVariables;
 
@@ -48,12 +50,14 @@ export type RefetchFn<TVariables, TKey, TOptions = Options> = RefetchFnBase<
 export type ReturnType<
   TVariables,
   TData,
-  TKey extends ?{+$fragmentSpreads: unknown, ...},
+  TKey extends ?{readonly $fragmentSpreads: unknown, ...},
 > = [
   // 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
-  [+key: TKey] extends [+key: {+$fragmentSpreads: unknown, ...}]
+  [readonly key: TKey] extends [
+    readonly key: {readonly $fragmentSpreads: unknown, ...},
+  ]
     ? TData
     : ?TData,
   RefetchFn<TVariables, TKey>,
@@ -63,7 +67,7 @@ export type UseRefetchableFragmentType = <
   TFragmentType extends FragmentType,
   TVariables extends Variables,
   TData,
-  TKey extends ?{+$fragmentSpreads: TFragmentType, ...},
+  TKey extends ?{readonly $fragmentSpreads: TFragmentType, ...},
 >(
   fragment: RefetchableFragment<TFragmentType, TData, TVariables>,
   key: TKey,
@@ -73,7 +77,7 @@ hook useRefetchableFragment<
   TFragmentType extends FragmentType,
   TVariables extends Variables,
   TData,
-  TKey extends ?{+$fragmentSpreads: TFragmentType, ...},
+  TKey extends ?{readonly $fragmentSpreads: TFragmentType, ...},
 >(
   fragmentInput: RefetchableFragment<TFragmentType, TData, TVariables>,
   fragmentRef: TKey,

package/relay-hooks/useRefetchableFragmentInternal.js.flow

@@ -57,15 +57,15 @@ export type RefetchFn<
 //    /non-null/.
 export type RefetchFnDynamic<
   TQuery extends OperationType,
-  TKey extends ?{+$data?: unknown, ...},
+  TKey extends ?{readonly $data?: unknown, ...},
   TOptions = Options,
-> = [TKey] extends [{+$data?: unknown, ...}]
+> = [TKey] extends [{readonly $data?: unknown, ...}]
   ? RefetchFnInexact<TQuery, TOptions>
   : RefetchFnExact<TQuery, TOptions>;
 
 export type ReturnType<
   TQuery extends OperationType,
-  TKey extends ?{+$data?: unknown, ...},
+  TKey extends ?{readonly $data?: unknown, ...},
   TOptions = Options,
 > = {
   fragmentData: unknown,
@@ -162,7 +162,7 @@ function reducer(state: RefetchState, action: Action): RefetchState {
 
 hook useRefetchableFragmentInternal<
   TQuery extends OperationType,
-  TKey extends ?{+$data?: unknown, ...},
+  TKey extends ?{readonly $data?: unknown, ...},
 >(
   fragmentNode: ReaderFragment,
   parentFragmentRef: unknown,

package/relay-hooks/useRelayEnvironment.d.ts

@@ -0,0 +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.
+ */
+
+import { Environment } from 'relay-runtime';
+
+export function useRelayEnvironment(): Environment;

package/relay-hooks/useSubscribeToInvalidationState.d.ts

@@ -0,0 +1,19 @@
+/**
+ * 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.
+ */
+
+import {DataID, Disposable} from 'relay-runtime';
+
+/**
+ * This hook subscribes a callback to the invalidation state of the given data
+ * ids.
+ * Any time the invalidation state of the given data ids changes, the provided
+ * callback will be called.
+ * If new ids or a new callback are provided, the subscription will be
+ * re-established and the previous one will be disposed.
+ * The subscription will automatically be disposed on unmount
+ */
+export function useSubscribeToInvalidationState(dataIDs: readonly DataID[], callback: () => void): Disposable;

package/relay-hooks/useSubscription.d.ts

@@ -0,0 +1,14 @@
+/**
+ * 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.
+ */
+
+import {GraphQLSubscriptionConfig, OperationType, requestSubscription} from 'relay-runtime';
+
+export function useSubscription<TSubscriptionPayload extends OperationType>(
+    // The actual subtype of OperationType is required to allow for type inference inside GraphQLSubscriptionConfig.s
+    config: GraphQLSubscriptionConfig<TSubscriptionPayload>,
+    requestSubscriptionFn?: typeof requestSubscription,
+): void;

package/rsc-client_EXPERIMENTAL.d.ts

@@ -0,0 +1,17 @@
+/**
+ * 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.
+ */
+
+import { PreloadedQueryRef } from './rsc_EXPERIMENTAL';
+import {GraphQLTaggedNode, OperationType} from 'relay-runtime';
+
+export function useQueryFromServer<T extends OperationType>(
+    query: GraphQLTaggedNode,
+    queryRef: PreloadedQueryRef<T['variables'], T['response']>,
+    options?: { staleThresholdMs?: number },
+): T['response'];
+
+export { PreloadedQueryRef };

package/rsc-client_EXPERIMENTAL.js

@@ -1,5 +1,5 @@
 /**
- * Relay v21.0.0
+ * Relay v21.0.1
  *
  * Copyright (c) Meta Platforms, Inc. and affiliates.
  *

package/rsc_EXPERIMENTAL.d.ts

@@ -0,0 +1,48 @@
+/**
+ * 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.
+ */
+
+import {ArrayKeyType, ArrayKeyTypeData, KeyType, KeyTypeData} from './ReactRelayTypes';
+import {GraphQLTaggedNode, IEnvironment, OperationType} from 'relay-runtime';
+
+export interface PreloadedQueryResponse<TData> {
+    readonly data: TData;
+    readonly errors?: ReadonlyArray<{ readonly message: string }>;
+}
+
+export interface PreloadedQueryRef<TVariables, TData> {
+    readonly kind: 'PreloadedQueryRef';
+    readonly queryId: string;
+    readonly variables: TVariables;
+    readonly _response: Promise<PreloadedQueryResponse<TData>>;
+    readonly fetchedAt: number;
+}
+
+export interface ServerEnvironment {
+    readonly getEnvironment: () => IEnvironment;
+    readonly serverFetchQuery: <T extends OperationType>(
+        query: GraphQLTaggedNode,
+        variables: T['variables'],
+    ) => Promise<T['response']>;
+    readonly serverPreloadQuery: <T extends OperationType>(
+        query: GraphQLTaggedNode,
+        variables: T['variables'],
+    ) => PreloadedQueryRef<T['variables'], T['response']>;
+    readonly serverReadFragment: {
+        <TKey extends KeyType>(
+            fragment: GraphQLTaggedNode,
+            fragmentRef: TKey,
+        ): Promise<KeyTypeData<TKey>>;
+        <TKey extends ArrayKeyType>(
+            fragment: GraphQLTaggedNode,
+            fragmentRef: TKey,
+        ): Promise<ArrayKeyTypeData<TKey>>;
+    };
+}
+
+export function createServerEnvironment(
+    create: () => IEnvironment,
+): ServerEnvironment;

package/rsc_EXPERIMENTAL.js

@@ -1,5 +1,5 @@
 /**
- * Relay v21.0.0
+ * Relay v21.0.1
  *
  * Copyright (c) Meta Platforms, Inc. and affiliates.
  *

package/rsc_EXPERIMENTAL.js.flow

@@ -28,19 +28,19 @@ const React = require('react');
 
 export type {PreloadedQueryRef};
 
-type HasSpread<TFragmentType> = {+$fragmentSpreads: TFragmentType, ...};
+type HasSpread<TFragmentType> = {readonly $fragmentSpreads: TFragmentType, ...};
 
 export type ServerEnvironment = {
-  +getEnvironment: () => IEnvironment,
-  +serverFetchQuery: <TVariables extends Variables, TData>(
+  readonly getEnvironment: () => IEnvironment,
+  readonly serverFetchQuery: <TVariables extends Variables, TData>(
     query: Query<TVariables, TData>,
     variables: TVariables,
   ) => Promise<TData>,
-  +serverPreloadQuery: <TVariables extends Variables, TData>(
+  readonly serverPreloadQuery: <TVariables extends Variables, TData>(
     query: Query<TVariables, TData>,
     variables: TVariables,
   ) => PreloadedQueryRef<TVariables, TData>,
-  +serverReadFragment: <TFragmentType extends FragmentType, TData>(
+  readonly serverReadFragment: <TFragmentType extends FragmentType, TData>(
     fragment: Fragment<TFragmentType, TData>,
     fragmentRef:
       | HasSpread<TFragmentType>