react-relay 21.0.0 → 21.0.1

package/legacy.d.ts

@@ -0,0 +1,143 @@
+/**
+ * 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 {MappedFragmentProps, RelayPaginationProp, RelayProp, RelayRefetchProp} from './ReactRelayTypes';
+import * as React from 'react';
+import {
+  _FragmentRefs,
+  _RefType,
+  CacheConfig,
+  FetchPolicy,
+  GraphQLTaggedNode,
+  IEnvironment,
+  OperationType,
+  PageInfo,
+  RelayContext,
+  Variables,
+} from 'relay-runtime';
+
+export { FragmentRef, RelayPaginationProp, RelayProp, RelayRefetchProp } from './ReactRelayTypes';
+
+export {
+    DataID,
+    DeclarativeMutationConfig,
+    Disposable,
+    FetchPolicy,
+    GraphQLTaggedNode,
+    // RelayRuntime has two environment exports: one interface, one concrete.
+    IEnvironment as Environment,
+    MutationType,
+    NormalizationSelector,
+    OperationDescriptor,
+    RangeOperation,
+    ReaderSelector,
+    RelayContext,
+    Snapshot,
+    Variables,
+} from 'relay-runtime';
+
+/**
+ * Legacy react-relay exports.
+ * Should prefer using interface defined in ./hooks.js
+ */
+export { ConnectionHandler } from 'relay-runtime';
+export interface QueryRendererProps<TOperation extends OperationType> {
+    environment: IEnvironment;
+    query: GraphQLTaggedNode | null | undefined;
+    render: (renderProps: {
+        error: Error | null;
+        props: TOperation['response'] | null;
+        retry: (() => void) | null;
+    }) => React.ReactNode;
+    variables: TOperation['variables'];
+}
+declare class ReactRelayQueryRenderer<TOperation extends OperationType> extends React.Component<
+    {
+        cacheConfig?: CacheConfig | null | undefined;
+        fetchPolicy?: FetchPolicy | undefined;
+    } & QueryRendererProps<TOperation>
+> {}
+export { ReactRelayQueryRenderer as QueryRenderer };
+
+declare class ReactRelayLocalQueryRenderer<TOperation extends OperationType> extends React.Component<
+    QueryRendererProps<TOperation>
+> {}
+export { ReactRelayLocalQueryRenderer as LocalQueryRenderer };
+
+export { MutationTypes } from 'relay-runtime';
+export { RangeOperations } from 'relay-runtime';
+
+export const ReactRelayContext: React.Context<RelayContext | null>;
+
+export { applyOptimisticMutation } from 'relay-runtime';
+export { commitLocalUpdate } from 'relay-runtime';
+export { commitMutation } from 'relay-runtime';
+
+export type ContainerProps<Props> = MappedFragmentProps<Pick<Props, Exclude<keyof Props, 'relay'>>>;
+export type RelayProps<Props> = ContainerProps<Props>; // TODO: validate this
+export type Container<Props> = React.ComponentType<
+    ContainerProps<Props> & { componentRef?: ((ref: any) => void) | undefined }
+>;
+
+// TODO: validate the bellow three
+export type RelayFragmentContainer<TComponent extends React.ElementType> = React.ComponentType<
+    ContainerProps<React.ComponentPropsWithoutRef<TComponent>>
+>;
+
+export type RelayPaginationContainer<TComponent extends React.ElementType> = React.ComponentType<
+    ContainerProps<React.ComponentPropsWithoutRef<TComponent>>
+>;
+
+export type RelayRefetchContainer<TComponent extends React.ElementType> = React.ComponentType<
+    ContainerProps<React.ComponentPropsWithoutRef<TComponent>>
+>;
+
+type PropsWithoutRelay<C extends keyof React.JSX.IntrinsicElements | React.JSXElementConstructor<any>> =
+    React.JSX.LibraryManagedAttributes<C, Omit<React.ComponentProps<C>, 'relay'>>;
+
+export function createFragmentContainer<
+    C extends React.ComponentType<React.ComponentProps<C> & { relay?: RelayProp | undefined }>,
+>(Component: C, fragmentSpec: Record<string, GraphQLTaggedNode>): Container<PropsWithoutRelay<C>>;
+
+export { fetchQuery_DEPRECATED } from 'relay-runtime';
+
+export { graphql } from 'relay-runtime';
+export { readInlineData } from 'relay-runtime';
+export { requestSubscription } from 'relay-runtime';
+
+export function createPaginationContainer<
+    C extends React.ComponentType<React.ComponentProps<C> & { relay: RelayPaginationProp }>,
+>(
+    Component: C,
+    fragmentSpec: Record<string, GraphQLTaggedNode>,
+    connectionConfig: ConnectionConfig<PropsWithoutRelay<C>>,
+): Container<PropsWithoutRelay<C>>;
+
+export function createRefetchContainer<
+    C extends React.ComponentType<React.ComponentProps<C> & { relay: RelayRefetchProp }>,
+>(
+    Component: C,
+    fragmentSpec: Record<string, GraphQLTaggedNode>,
+    refetchQuery: GraphQLTaggedNode,
+): Container<PropsWithoutRelay<C>>;
+
+export interface ConnectionConfig<Props = object> {
+    direction?: 'backward' | 'forward' | undefined;
+    getConnectionFromProps?: ((props: Props) => ConnectionData | null | undefined) | undefined;
+    getFragmentVariables?: ((prevVars: Variables, totalCount: number) => Variables) | undefined;
+    getVariables: (
+        props: Props,
+        paginationInfo: { count: number; cursor?: string | null | undefined },
+        fragmentVariables: Variables,
+    ) => Variables;
+    query: GraphQLTaggedNode;
+}
+
+interface ConnectionData {
+    edges?: readonly any[] | null | undefined;
+    pageInfo?: Partial<PageInfo> | null | undefined;
+}

package/legacy.js

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

package/package.json

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

package/relay-hooks/EntryPointContainer.react.d.ts

@@ -0,0 +1,22 @@
+/**
+ * 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 {EntryPointComponent, PreloadedEntryPoint} from '../ReactRelayTypes';
+import { ReactElement } from 'react';
+
+type GetComponentFromPreloadedEntryPoint<T> = T extends PreloadedEntryPoint<infer C> ? C : never;
+type GetRuntimePropsFromComponent<T> = T extends EntryPointComponent<any, any, infer R, any> ? R : never;
+
+export function EntryPointContainer<TPreloadedEntryPoint extends PreloadedEntryPoint<any>>({
+    entryPointReference,
+    props,
+}: Readonly<{
+    entryPointReference: TPreloadedEntryPoint;
+    props: GetRuntimePropsFromComponent<GetComponentFromPreloadedEntryPoint<TPreloadedEntryPoint>>;
+}>): ReactElement;
+
+export {};

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

@@ -34,21 +34,21 @@ export type PreloadFetchPolicy =
   | 'network-only';
 
 export type PreloadOptions = {
-  +fetchKey?: string | number,
-  +fetchPolicy?: ?PreloadFetchPolicy,
-  +includeIf?: ?boolean,
-  +enableForOfflineCacheJob?: ?boolean,
-  +prefetchExpiryInHours?: ?number,
-  +networkCacheConfig?: ?CacheConfig,
+  readonly fetchKey?: string | number,
+  readonly fetchPolicy?: ?PreloadFetchPolicy,
+  readonly includeIf?: ?boolean,
+  readonly enableForOfflineCacheJob?: ?boolean,
+  readonly prefetchExpiryInHours?: ?number,
+  readonly networkCacheConfig?: ?CacheConfig,
 };
 
 export type LoadQueryOptions = {
-  +fetchPolicy?: ?FetchPolicy,
-  +networkCacheConfig?: ?CacheConfig,
-  +__nameForWarning?: ?string,
+  readonly fetchPolicy?: ?FetchPolicy,
+  readonly networkCacheConfig?: ?CacheConfig,
+  readonly __nameForWarning?: ?string,
 };
 
-export type PreloadableConcreteRequest<+TQuery extends OperationType> = {
+export type PreloadableConcreteRequest<out TQuery extends OperationType> = {
   kind: 'PreloadableConcreteRequest',
   params: RequestParameters,
   // Note: the phantom type parameter here helps ensures that the
@@ -56,63 +56,63 @@ export type PreloadableConcreteRequest<+TQuery extends OperationType> = {
   // We also need to add usage of this generic here,
   // becuase not using the generic in the definition makes it
   // unconstrained in the call to a function that accepts PreloadableConcreteRequest<T>
-  +__phantom__?: ?TQuery,
+  readonly __phantom__?: ?TQuery,
 };
 
-export type EnvironmentProviderOptions = {+[string]: unknown, ...};
+export type EnvironmentProviderOptions = {readonly [string]: unknown, ...};
 
 export type PreloadedQuery<
-  +TQuery extends OperationType,
+  out TQuery extends OperationType,
   TEnvironmentProviderOptions = EnvironmentProviderOptions,
 > =
   | PreloadedQueryInner_DEPRECATED<TQuery, TEnvironmentProviderOptions>
   | PreloadedQueryInner<TQuery, TEnvironmentProviderOptions>;
 
 export type PreloadedQueryInner_DEPRECATED<
-  +TQuery extends OperationType,
+  out TQuery extends OperationType,
   TEnvironmentProviderOptions = EnvironmentProviderOptions,
 > = {
-  +kind: 'PreloadedQuery_DEPRECATED',
-  +environment: IEnvironment,
-  +environmentProviderOptions: ?TEnvironmentProviderOptions,
-  +fetchKey: ?string | ?number,
-  +fetchPolicy: FetchPolicy,
-  +networkCacheConfig?: ?CacheConfig,
-  +id: ?string,
-  +name: string,
-  +source: ?Observable<GraphQLResponse>,
-  +variables: TQuery['variables'],
-  +status: PreloadQueryStatus,
+  readonly kind: 'PreloadedQuery_DEPRECATED',
+  readonly environment: IEnvironment,
+  readonly environmentProviderOptions: ?TEnvironmentProviderOptions,
+  readonly fetchKey: ?string | ?number,
+  readonly fetchPolicy: FetchPolicy,
+  readonly networkCacheConfig?: ?CacheConfig,
+  readonly id: ?string,
+  readonly name: string,
+  readonly source: ?Observable<GraphQLResponse>,
+  readonly variables: TQuery['variables'],
+  readonly status: PreloadQueryStatus,
 };
 
 export type PreloadedQueryInner<
-  +TQuery extends OperationType,
+  out TQuery extends OperationType,
   TEnvironmentProviderOptions = EnvironmentProviderOptions,
 > = {
   // Releases query data and cancels network request if still in flight
-  +dispose: () => void,
+  readonly dispose: () => void,
   // Releases query data
-  +releaseQuery: () => void,
+  readonly releaseQuery: () => void,
   // Cancels network request if still in flight
-  +cancelNetworkRequest: () => void,
-  +environment: IEnvironment,
-  +environmentProviderOptions: ?TEnvironmentProviderOptions,
-  +fetchKey: string | number,
-  +fetchPolicy: FetchPolicy,
-  +id: ?string,
-  +isDisposed: boolean,
-  +networkError: ?Error,
-  +name: string,
-  +networkCacheConfig: ?CacheConfig,
-  +source: ?Observable<GraphQLResponse>,
-  +kind: 'PreloadedQuery',
-  +variables: TQuery['variables'],
+  readonly cancelNetworkRequest: () => void,
+  readonly environment: IEnvironment,
+  readonly environmentProviderOptions: ?TEnvironmentProviderOptions,
+  readonly fetchKey: string | number,
+  readonly fetchPolicy: FetchPolicy,
+  readonly id: ?string,
+  readonly isDisposed: boolean,
+  readonly networkError: ?Error,
+  readonly name: string,
+  readonly networkCacheConfig: ?CacheConfig,
+  readonly source: ?Observable<GraphQLResponse>,
+  readonly kind: 'PreloadedQuery',
+  readonly variables: TQuery['variables'],
 };
 
 export type PreloadQueryStatus = {
-  +cacheConfig: ?CacheConfig,
-  +source: 'cache' | 'network',
-  +fetchTime: ?number,
+  readonly cacheConfig: ?CacheConfig,
+  readonly source: 'cache' | 'network',
+  readonly fetchTime: ?number,
 };
 
 /**
@@ -129,9 +129,9 @@ the preloaders (routeParams, query variables)
 TEntryPointComponent -  the root components
 */
 export type EntryPoint<
-  -TEntryPointParams,
+  in TEntryPointParams,
   // $FlowExpectedError[unclear-type] accepts any root component
-  +TEntryPointComponent extends EntryPointComponent<any, any, any, any, any>,
+  out TEntryPointComponent extends EntryPointComponent<any, any, any, any, any>,
 > = Readonly<{
   getPreloadProps: (
     entryPointParams: TEntryPointParams,
@@ -178,7 +178,7 @@ export type EntryPointComponent<
   TPreloadedEntryPoints = {},
   TRuntimeProps = {},
   TExtraProps = null,
-  +TRenders extends React.Node = React.Node,
+  out TRenders extends React.Node = React.Node,
 > = component(
   ...EntryPointProps<
     TPreloadedQueries,
@@ -191,7 +191,7 @@ export type EntryPointComponent<
 // Return type of the `getPreloadProps(...)` of the entry point
 export type PreloadProps<
   // $FlowExpectedError[unclear-type] Need any to make it supertype of all PreloadedQuery
-  TPreloadedQueries extends {+[string]: ?PreloadedQuery<any>},
+  TPreloadedQueries extends {readonly [string]: ?PreloadedQuery<any>},
   TPreloadedEntryPoints extends {...},
   TExtraProps = null,
   TEnvironmentProviderOptions = EnvironmentProviderOptions,
@@ -215,7 +215,7 @@ export type PreloadedEntryPoint<TEntryPointComponent> = Readonly<{
 }>;
 
 export type EntryPointElementConfig<
-  +TEntryPoint extends EntryPoint<
+  out TEntryPoint extends EntryPoint<
     // $FlowExpectedError[unclear-type] Need any to make it supertype of all InternalEntryPointRepresentation
     any,
     // $FlowExpectedError[unclear-type] Need any to make it supertype of all InternalEntryPointRepresentation
@@ -230,7 +230,7 @@ export type EntryPointElementConfig<
     : empty;
 
 export type ThinQueryParams<
-  +TQuery extends OperationType,
+  out TQuery extends OperationType,
   TEnvironmentProviderOptions,
 > = Readonly<{
   environmentProviderOptions?: ?TEnvironmentProviderOptions,
@@ -254,17 +254,21 @@ export type ExtractQueryTypeHelper<TEnvironmentProviderOptions> = <TQuery>(
 // We need to match both cases without using distributive conditional types,
 // because PreloadedQuery's TQuery parameter is almost phantom, and breaking
 // up the union type would cause us to lose track of TQuery.
-type ExtractThinQueryParams<T, TEnvironmentProviderOptions> = [+t: T] extends [
+type ExtractThinQueryParams<T, TEnvironmentProviderOptions> = [
+  readonly t: T,
+] extends [
   // $FlowFixMe[incompatible-type]
-  +t: PreloadedQuery<infer TQuery extends OperationType>,
+  readonly t: PreloadedQuery<infer TQuery extends OperationType>,
 ]
   ? ThinQueryParams<TQuery, TEnvironmentProviderOptions>
-  : [+t: T] extends [
-        +t: PreloadedQuery<infer TQuery extends OperationType> | void,
+  : [readonly t: T] extends [
+        readonly t: PreloadedQuery<infer TQuery extends OperationType> | void,
       ]
     ? ThinQueryParams<TQuery, TEnvironmentProviderOptions> | void
-    : [+t: T] extends [
-          +t: PreloadedQuery<infer TQuery extends OperationType> | null | void,
+    : [readonly t: T] extends [
+          readonly t: PreloadedQuery<
+            infer TQuery extends OperationType,
+          > | null | void,
         ]
       ? ThinQueryParams<TQuery, TEnvironmentProviderOptions> | null | void
       : empty;
@@ -272,7 +276,7 @@ type ExtractThinQueryParams<T, TEnvironmentProviderOptions> = [+t: T] extends [
 export type ExtractQueryTypes<
   TEnvironmentProviderOptions,
   // $FlowExpectedError[unclear-type] Need any to make it supertype of all PreloadedQuery
-  PreloadedQueries extends {+[string]: ?PreloadedQuery<any>} | void,
+  PreloadedQueries extends {readonly [string]: ?PreloadedQuery<any>} | void,
 > = {
   [K in keyof PreloadedQueries]: ExtractThinQueryParams<
     PreloadedQueries[K],
@@ -281,7 +285,7 @@ export type ExtractQueryTypes<
 };
 
 // $FlowFixMe[unclear-type]: we don't care about the props
-export type RootComponentRenders<+C extends component(...any)> =
+export type RootComponentRenders<out C extends component(...any)> =
   // $FlowFixMe[unclear-type]: we don't care about the props
   C extends component(...any) renders infer R extends React.Node ? R : empty;
 

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

@@ -64,7 +64,7 @@ function stableStringify(value: unknown): string {
 function prepareEntryPoint<
   TEntryPointParams extends {...},
   // $FlowExpectedError[unclear-type] Need any to make it supertype of all PreloadedQuery
-  TPreloadedQueries extends {+[string]: PreloadedQuery<any>},
+  TPreloadedQueries extends {readonly [string]: PreloadedQuery<any>},
   TPreloadedEntryPoints extends {...},
   TRuntimeProps extends {...},
   TExtraProps,
@@ -157,7 +157,7 @@ function prepareEntryPoint<
 function LazyLoadEntryPointContainer_DEPRECATED<
   TEntryPointParams extends {...},
   // $FlowExpectedError[unclear-type] Need any to make it supertype of all PreloadedQuery
-  TPreloadedQueries extends {+[string]: PreloadedQuery<any>},
+  TPreloadedQueries extends {readonly [string]: PreloadedQuery<any>},
   TPreloadedEntryPoints extends {...},
   TRuntimeProps extends {...},
   TExtraProps,

package/relay-hooks/MatchContainer.d.ts

@@ -0,0 +1,95 @@
+/**
+ * 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 {ComponentType, ElementType, ReactNode} from 'react';
+
+/**
+ * Renders the results of a data-driven dependency fetched with the `@match`
+ * directive. The `@match` directive can be used to specify a mapping of
+ * result types to the containers used to render those types. The result
+ * value is an opaque object that described which component was selected
+ * and a reference to its data. Use <MatchContainer/> to render these
+ * values.
+ *
+ * ## Example
+ *
+ * For example, consider a piece of media content that might be text or
+ * an image, where for clients that don't support images the application
+ * should fall back to rendering the image caption as text. @match can be
+ * used to dynamically select whether to render a given media item as
+ * an image or text (on the server) and then fetch the corresponding
+ * React component and its data dependencies (information about the
+ * image or about the text).
+ *
+ * ```
+ * // Media.react.js
+ *
+ * // Define a React component that uses <MatchContainer /> to render the
+ * // results of a @module selection
+ * function Media(props) {
+ *   const {media, ...restProps} = props;
+ *
+ *   const loader = moduleReference => {
+ *      // given the data returned by your server for the @module directive,
+ *      // return the React component (or throw a Suspense promise if
+ *      // it is loading asynchronously).
+ *      todo_returnModuleOrThrowPromise(moduleReference);
+ *   };
+ *   return <MatchContainer
+ *     loader={loader}
+ *     match={media.mediaAttachment}
+ *     props={restProps}
+ *   />;
+ * }
+ *
+ * module.exports = createSuspenseFragmentContainer(
+ *   Media,
+ *   {
+ *     media: graphql`
+ *       fragment Media_media on Media {
+ *         # ...
+ *         mediaAttachment @match {
+ *            ...ImageContainer_image @module(name: "ImageContainer.react")
+ *            ...TextContainer_text @module(name: "TextContainer.react")
+ *         }
+ *       }
+ *     `
+ *   },
+ * );
+ * ```
+ *
+ * ## API
+ *
+ * MatchContainer accepts the following props:
+ * - `match`: The results (an opaque object) of a `@match` field.
+ * - `props`: Props that should be passed through to the dynamically
+ *   selected component. Note that any of the components listed in
+ *   `@module()` could be selected, so all components should accept
+ *   the value passed here.
+ * - `loader`: A function to load a module given a reference (whatever
+ *   your server returns for the `js(moduleName: String)` field).
+ */
+
+type TypenameOnlyPointer = Readonly<{ __typename: string }>;
+export type MatchPointer = Readonly<{
+    __fragmentPropName?: string | null | undefined;
+    __module_component?: unknown | undefined;
+    ' $fragmentSpreads': unknown;
+}>;
+
+export type MatchContainerProps<TProps = Record<string, unknown>, TFallback = ReactNode> = Readonly<{
+    fallback?: TFallback | null | undefined;
+    loader: (module: unknown) => ComponentType<TProps>;
+    match?: MatchPointer | TypenameOnlyPointer | null | undefined;
+    props?: TProps | undefined;
+}>;
+
+export function MatchContainer<TProps = Record<string, unknown>, TFallback = ReactNode>(
+    props: MatchContainerProps<TProps, TFallback>,
+): ElementType<TProps> | TFallback | null;
+
+export {};

package/relay-hooks/MatchContainer.js.flow

@@ -85,11 +85,11 @@ const {useMemo} = React;
 
 // Note: this type is intentionally non-exact, it is expected that the
 // object may contain sibling fields.
-type TypenameOnlyPointer = {+__typename: string};
+type TypenameOnlyPointer = {readonly __typename: string};
 export type MatchPointer = {
-  +__fragmentPropName?: ?string,
-  +__module_component?: unknown,
-  +$fragmentSpreads: unknown,
+  readonly __fragmentPropName?: ?string,
+  readonly __module_component?: unknown,
+  readonly $fragmentSpreads: unknown,
   ...
 };
 
@@ -97,10 +97,10 @@ export type MatchContainerProps<
   TProps extends {...},
   TFallback extends React.Node,
 > = {
-  +fallback?: ?TFallback,
-  +loader: (module: unknown) => component(...TProps),
-  +match: ?MatchPointer | ?TypenameOnlyPointer,
-  +props?: TProps,
+  readonly fallback?: ?TFallback,
+  readonly loader: (module: unknown) => component(...TProps),
+  readonly match: ?MatchPointer | ?TypenameOnlyPointer,
+  readonly props?: TProps,
 };
 
 function MatchContainer<

package/relay-hooks/ProfilerContext.d.ts

@@ -0,0 +1,18 @@
+/**
+ * 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.
+ */
+
+// This contextual profiler can be used to wrap a react sub-tree. It will bind
+// the RelayProfiler during the render phase of these components. Allows
+// collecting metrics for a specific part of your application.
+
+import { Context } from 'react';
+
+export interface ProfilerContextType {
+    wrapPrepareQueryResource: <T>(cb: () => T) => T;
+}
+
+export const ProfilerContext: Context<ProfilerContextType>;

package/relay-hooks/QueryResource.js.flow

@@ -41,9 +41,9 @@ export type QueryResource = QueryResourceImpl;
 
 type QueryResourceCache = Cache<QueryResourceCacheEntry>;
 type QueryResourceCacheEntry = {
-  +id: number,
-  +cacheIdentifier: string,
-  +operationAvailability: ?OperationAvailability,
+  readonly id: number,
+  readonly cacheIdentifier: string,
+  readonly operationAvailability: ?OperationAvailability,
   // The number of received payloads for the operation.
   // We want to differentiate the initial graphql response for the operation
   // from the incremental responses, so later we can choose how to handle errors

package/relay-hooks/RelayEnvironmentProvider.d.ts

@@ -0,0 +1,16 @@
+/**
+ * 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 {ProviderProps, ReactElement, ReactNode} from 'react';
+import {IEnvironment, RelayContext} from 'relay-runtime';
+
+export interface Props {
+    children: ReactNode;
+    environment: IEnvironment;
+}
+
+export function RelayEnvironmentProvider(props: Props): ReactElement<ProviderProps<RelayContext>>;

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

@@ -20,9 +20,9 @@ import type {
 import type {OperationType} from 'relay-runtime';
 
 type Query = {
-  +variables: {foo: string, bar: number},
-  +response: unknown,
-  +rawResponse?: {...},
+  readonly variables: {foo: string, bar: number},
+  readonly response: unknown,
+  readonly rawResponse?: {...},
 };
 
 const _good: ExtractQueryTypes<