relay-runtime 20.1.1 → 21.0.1

package/mutations/RelayRecordSourceProxy.js.flow

@@ -53,14 +53,14 @@ class RelayRecordSourceProxy implements RecordSourceProxy {
   _getDataID: GetDataID;
   _invalidatedStore: boolean;
   _idsMarkedForInvalidation: DataIDSet;
-  _missingFieldHandlers: $ReadOnlyArray<MissingFieldHandler>;
+  _missingFieldHandlers: ReadonlyArray<MissingFieldHandler>;
   _log: LogFunction;
 
   constructor(
     mutator: RelayRecordSourceMutator,
     getDataID: GetDataID,
     handlerProvider?: ?HandlerProvider,
-    missingFieldHandlers: $ReadOnlyArray<MissingFieldHandler>,
+    missingFieldHandlers: ReadonlyArray<MissingFieldHandler>,
     log: ?LogFunction,
   ) {
     this.__mutator = mutator;
@@ -176,7 +176,7 @@ class RelayRecordSourceProxy implements RecordSourceProxy {
     return this._idsMarkedForInvalidation;
   }
 
-  readUpdatableQuery<TVariables: Variables, TData>(
+  readUpdatableQuery<TVariables extends Variables, TData>(
     query: UpdatableQuery<TVariables, TData>,
     variables: TVariables,
   ): UpdatableData<TData> {
@@ -188,7 +188,7 @@ class RelayRecordSourceProxy implements RecordSourceProxy {
     );
   }
 
-  readUpdatableFragment<TFragmentType: FragmentType, TData>(
+  readUpdatableFragment<TFragmentType extends FragmentType, TData>(
     fragment: UpdatableFragment<TFragmentType, TData>,
     fragmentReference: HasUpdatableSpread<TFragmentType>,
   ): UpdatableData<TData> {

package/mutations/RelayRecordSourceSelectorProxy.js.flow

@@ -21,7 +21,7 @@ import type {
   SingularReaderSelector,
   UpdatableData,
 } from '../store/RelayStoreTypes';
-import type {ReaderLinkedField} from '../util/ReaderNode';
+import type {ReaderLinkedField, ReaderSelection} from '../util/ReaderNode';
 import type {
   DataID,
   UpdatableFragment,
@@ -47,13 +47,13 @@ class RelayRecordSourceSelectorProxy implements RecordSourceSelectorProxy {
   __mutator: RelayRecordSourceMutator;
   __recordSource: RecordSourceProxy;
   _readSelector: SingularReaderSelector;
-  _missingFieldHandlers: $ReadOnlyArray<MissingFieldHandler>;
+  _missingFieldHandlers: ReadonlyArray<MissingFieldHandler>;
 
   constructor(
     mutator: RelayRecordSourceMutator,
     recordSource: RecordSourceProxy,
     readSelector: SingularReaderSelector,
-    missingFieldHandlers: $ReadOnlyArray<MissingFieldHandler>,
+    missingFieldHandlers: ReadonlyArray<MissingFieldHandler>,
   ) {
     this.__mutator = mutator;
     this.__recordSource = recordSource;
@@ -90,7 +90,7 @@ class RelayRecordSourceSelectorProxy implements RecordSourceSelectorProxy {
     fieldName: string,
     plural: boolean,
   ): ReaderLinkedField {
-    let field = selector.node.selections.find(
+    let field: ReaderSelection | void = selector.node.selections.find(
       selection =>
         (selection.kind === 'LinkedField' && selection.name === fieldName) ||
         (selection.kind === 'RequiredField' &&
@@ -132,7 +132,7 @@ class RelayRecordSourceSelectorProxy implements RecordSourceSelectorProxy {
     this.__recordSource.invalidateStore();
   }
 
-  readUpdatableQuery<TVariables: Variables, TData>(
+  readUpdatableQuery<TVariables extends Variables, TData>(
     query: UpdatableQuery<TVariables, TData>,
     variables: TVariables,
   ): UpdatableData<TData> {
@@ -144,7 +144,7 @@ class RelayRecordSourceSelectorProxy implements RecordSourceSelectorProxy {
     );
   }
 
-  readUpdatableFragment<TFragmentType: FragmentType, TData>(
+  readUpdatableFragment<TFragmentType extends FragmentType, TData>(
     fragment: UpdatableFragment<TFragmentType, TData>,
     fragmentReference: HasUpdatableSpread<TFragmentType>,
   ): UpdatableData<TData> {

package/mutations/applyOptimisticMutation.d.ts

@@ -0,0 +1,25 @@
+/**
+ * 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 { GraphQLTaggedNode } from '../query/GraphQLTag';
+import {Environment, SelectorStoreUpdater} from '../store/RelayStoreTypes';
+import {Disposable, Variables} from '../util/RelayRuntimeTypes';
+import { DeclarativeMutationConfig } from './RelayDeclarativeMutationConfig';
+
+export interface OptimisticMutationConfig {
+    configs?: readonly DeclarativeMutationConfig[] | null | undefined;
+    mutation: GraphQLTaggedNode;
+    variables: Variables;
+    optimisticUpdater?: SelectorStoreUpdater | null | undefined;
+    optimisticResponse?: object | undefined;
+}
+
+/**
+ * Higher-level helper function to execute a mutation against a specific
+ * environment.
+ */
+export function applyOptimisticMutation(environment: Environment, config: OptimisticMutationConfig): Disposable;

package/mutations/applyOptimisticMutation.js.flow

@@ -28,7 +28,7 @@ const {
 const RelayDeclarativeMutationConfig = require('./RelayDeclarativeMutationConfig');
 const invariant = require('invariant');
 
-export type OptimisticMutationConfig<TMutation: MutationParameters> = {
+export type OptimisticMutationConfig<TMutation extends MutationParameters> = {
   configs?: ?Array<DeclarativeMutationConfig>,
   mutation: GraphQLTaggedNode,
   variables: Variables,
@@ -40,7 +40,7 @@ export type OptimisticMutationConfig<TMutation: MutationParameters> = {
  * Higher-level helper function to execute a mutation against a specific
  * environment.
  */
-function applyOptimisticMutation<TMutation: MutationParameters>(
+function applyOptimisticMutation<TMutation extends MutationParameters>(
   environment: IEnvironment,
   config: OptimisticMutationConfig<TMutation>,
 ): Disposable {

package/mutations/commitLocalUpdate.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, SelectorStoreUpdater} from '../store/RelayStoreTypes';
+
+export function commitLocalUpdate(environment: Environment, updater: SelectorStoreUpdater): void;

package/mutations/commitMutation.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 {PayloadError, UploadableMap} from '../network/RelayNetworkTypes';
+import { GraphQLTaggedNode } from '../query/GraphQLTag';
+import {Environment, SelectorStoreUpdater} from '../store/RelayStoreTypes';
+import {CacheConfig, Disposable} from '../util/RelayRuntimeTypes';
+import { DeclarativeMutationConfig } from './RelayDeclarativeMutationConfig';
+
+export interface MutationParameters {
+    readonly response: Record<string, unknown>;
+    readonly variables: Record<string, unknown>;
+    readonly rawResponse?: Record<string, unknown> | undefined;
+}
+
+export interface MutationConfig<TOperation extends MutationParameters> {
+    configs?: DeclarativeMutationConfig[] | undefined;
+    cacheConfig?: CacheConfig | undefined;
+    mutation: GraphQLTaggedNode;
+    onError?: ((error: Error) => void) | null | undefined;
+    onCompleted?:
+        | ((response: TOperation['response'], errors: readonly PayloadError[] | null | undefined) => void)
+        | null
+        | undefined;
+    onUnsubscribe?: (() => void | null | undefined) | undefined;
+    /**
+     * An object whose type matches the raw response type of the mutation. Make sure you decorate
+     * your mutation with `@raw_response_type` if you are using this field.
+     */
+    optimisticResponse?: (TOperation['rawResponse'] extends Record<string, unknown> ? TOperation['rawResponse'] : never) | undefined;
+    optimisticUpdater?: SelectorStoreUpdater<TOperation['response']> | null | undefined;
+    updater?: SelectorStoreUpdater<TOperation['response']> | null | undefined;
+    uploadables?: UploadableMap | null | undefined;
+    variables: TOperation['variables'];
+}
+
+/**
+ * Higher-level helper function to execute a mutation against a specific
+ * environment.
+ */
+export function commitMutation<TOperation extends MutationParameters = MutationParameters>(
+    environment: Environment,
+    config: MutationConfig<TOperation>,
+): Disposable;

package/mutations/commitMutation.js.flow

@@ -37,7 +37,7 @@ const validateMutation = require('./validateMutation');
 const invariant = require('invariant');
 const warning = require('warning');
 
-export type MutationConfig<TMutation: MutationParameters> = $ReadOnly<{
+export type MutationConfig<TMutation extends MutationParameters> = Readonly<{
   cacheConfig?: CacheConfig,
   configs?: Array<DeclarativeMutationConfig>,
   mutation: GraphQLTaggedNode,
@@ -49,7 +49,7 @@ export type MutationConfig<TMutation: MutationParameters> = $ReadOnly<{
   onNext?: ?() => void,
   onUnsubscribe?: ?() => void,
   optimisticResponse?: {
-    +rawResponse?: {...},
+    readonly rawResponse?: {...},
     ...TMutation,
     ...
   }['rawResponse'],
@@ -59,7 +59,7 @@ export type MutationConfig<TMutation: MutationParameters> = $ReadOnly<{
   variables: TMutation['variables'],
 }>;
 
-export type CommitMutationConfig<TVariables, TData, TRawResponse> = $ReadOnly<{
+export type CommitMutationConfig<TVariables, TData, TRawResponse> = Readonly<{
   cacheConfig?: CacheConfig,
   configs?: Array<DeclarativeMutationConfig>,
   mutation: Mutation<TVariables, TData, TRawResponse>,
@@ -78,7 +78,11 @@ export type CommitMutationConfig<TVariables, TData, TRawResponse> = $ReadOnly<{
  * Higher-level helper function to execute a mutation against a specific
  * environment.
  */
-function commitMutation<TVariables: Variables, TData, TRawResponse = {...}>(
+function commitMutation<
+  TVariables extends Variables,
+  TData,
+  TRawResponse = {...},
+>(
   environment: IEnvironment,
   config: CommitMutationConfig<TVariables, TData, TRawResponse>,
 ): Disposable {
@@ -122,7 +126,7 @@ function commitMutation<TVariables: Variables, TData, TRawResponse = {...}>(
   if (configs) {
     ({optimisticUpdater, updater} = RelayDeclarativeMutationConfig.convert<{
       variables: TVariables,
-      /* $FlowFixMe[incompatible-call] error exposed when improving flow typing
+      /* $FlowFixMe[incompatible-type] error exposed when improving flow typing
        * of commitMutation */
       response: TData,
     }>(configs, mutation, optimisticUpdater, updater));
@@ -131,7 +135,7 @@ function commitMutation<TVariables: Variables, TData, TRawResponse = {...}>(
   const subscription = environment
     .executeMutation<{
       variables: TVariables,
-      /* $FlowFixMe[incompatible-call] error exposed when improving flow typing
+      /* $FlowFixMe[incompatible-type] error exposed when improving flow typing
        * of commitMutation */
       response: TData,
     }>({
@@ -142,6 +146,17 @@ function commitMutation<TVariables: Variables, TData, TRawResponse = {...}>(
       uploadables,
     })
     .subscribe({
+      complete: () => {
+        const {onCompleted} = config;
+        if (onCompleted) {
+          const snapshot = environment.lookup(operation.fragment);
+          onCompleted(
+            snapshot.data as $FlowFixMe,
+            errors.length !== 0 ? errors : null,
+          );
+        }
+      },
+      error: onError,
       next: payload => {
         if (Array.isArray(payload)) {
           payload.forEach(item => {
@@ -156,17 +171,6 @@ function commitMutation<TVariables: Variables, TData, TRawResponse = {...}>(
         }
         config.onNext?.();
       },
-      complete: () => {
-        const {onCompleted} = config;
-        if (onCompleted) {
-          const snapshot = environment.lookup(operation.fragment);
-          onCompleted(
-            (snapshot.data: $FlowFixMe),
-            errors.length !== 0 ? errors : null,
-          );
-        }
-      },
-      error: onError,
       unsubscribe: onUnsubscribe,
     });
   return {dispose: subscription.unsubscribe};

package/mutations/createUpdatableProxy.js.flow

@@ -27,12 +27,12 @@ const {getArgumentValues} = require('../store/RelayStoreUtils');
 
 const nonUpdatableKeys = ['id', '__id', '__typename', 'js'];
 
-function createUpdatableProxy<TData: {...}>(
+function createUpdatableProxy<TData extends {...}>(
   updatableProxyRootRecord: RecordProxy,
   variables: Variables,
-  selections: $ReadOnlyArray<ReaderSelection>,
+  selections: ReadonlyArray<ReaderSelection>,
   recordSourceProxy: RecordSourceProxy,
-  missingFieldHandlers: $ReadOnlyArray<MissingFieldHandler>,
+  missingFieldHandlers: ReadonlyArray<MissingFieldHandler>,
 ): TData {
   const mutableUpdatableProxy = {};
   updateProxyFromSelections(
@@ -49,16 +49,16 @@ function createUpdatableProxy<TData: {...}>(
   // unless ReaderSelection carries more type information, we will never be able
   // to flowtype mutableUpdatableProxy without a type assertion.
   // $FlowFixMe[unclear-type]
-  return ((mutableUpdatableProxy: any): TData);
+  return mutableUpdatableProxy as any as TData;
 }
 
 function updateProxyFromSelections<TData>(
   mutableUpdatableProxy: TData,
   updatableProxyRootRecord: RecordProxy,
   variables: Variables,
-  selections: $ReadOnlyArray<ReaderSelection>,
+  selections: ReadonlyArray<ReaderSelection>,
   recordSourceProxy: RecordSourceProxy,
-  missingFieldHandlers: $ReadOnlyArray<MissingFieldHandler>,
+  missingFieldHandlers: ReadonlyArray<MissingFieldHandler>,
 ): void {
   for (const selection of selections) {
     switch (selection.kind) {
@@ -108,7 +108,7 @@ function updateProxyFromSelections<TData>(
       case 'ScalarField':
         const scalarFieldName = selection.alias ?? selection.name;
         Object.defineProperty(mutableUpdatableProxy, scalarFieldName, {
-          get: function () {
+          get() {
             const newVariables = getArgumentValues(
               selection.args ?? [],
               variables,
@@ -191,7 +191,7 @@ function updateProxyFromSelections<TData>(
           'Encountered an unexpected ReaderSelection variant in RelayRecordSourceProxy. This indicates a bug in Relay.',
         );
       default:
-        (selection.kind: empty);
+        selection.kind as empty;
         throw new Error(
           'Encountered an unexpected ReaderSelection variant in RelayRecordSourceProxy. This indicates a bug in Relay.',
         );
@@ -205,7 +205,7 @@ function createSetterForPluralLinkedField(
   updatableProxyRootRecord: RecordProxy,
   recordSourceProxy: RecordSourceProxy,
 ) {
-  return function set(newValue: $ReadOnlyArray<{__id: string, ...}>) {
+  return function set(newValue: ReadonlyArray<{__id: string, ...}>) {
     const newVariables = getArgumentValues(selection.args ?? [], variables);
     if (newValue == null) {
       throw new Error(
@@ -276,7 +276,7 @@ function createGetterForPluralLinkedField(
   variables: Variables,
   updatableProxyRootRecord: RecordProxy,
   recordSourceProxy: RecordSourceProxy,
-  missingFieldHandlers: $ReadOnlyArray<MissingFieldHandler>,
+  missingFieldHandlers: ReadonlyArray<MissingFieldHandler>,
 ): () => $FlowFixMe {
   return function () {
     const newVariables = getArgumentValues(selection.args ?? [], variables);
@@ -296,7 +296,7 @@ function createGetterForPluralLinkedField(
     }
 
     if (linkedRecords != null) {
-      return (linkedRecords.map(linkedRecord => {
+      return linkedRecords.map(linkedRecord => {
         if (linkedRecord != null) {
           const updatableProxy = {};
           updateProxyFromSelections(
@@ -313,12 +313,12 @@ function createGetterForPluralLinkedField(
           // Flow incorrect assumes that the return value for the get method must match
           // the set parameter.
           // $FlowFixMe[unclear-type] Typed by the generated updatable query flow type
-          return (updatableProxy: any);
+          return updatableProxy as any;
         } else {
           return linkedRecord;
         }
         // $FlowFixMe[unclear-type] Typed by the generated updatable query flow type
-      }): any);
+      }) as any;
     } else {
       return linkedRecords;
     }
@@ -330,7 +330,7 @@ function createGetterForSingularLinkedField(
   variables: Variables,
   updatableProxyRootRecord: RecordProxy,
   recordSourceProxy: RecordSourceProxy,
-  missingFieldHandlers: $ReadOnlyArray<MissingFieldHandler>,
+  missingFieldHandlers: ReadonlyArray<MissingFieldHandler>,
 ): () => ?$FlowFixMe {
   return function () {
     const newVariables = getArgumentValues(selection.args ?? [], variables);
@@ -364,7 +364,7 @@ function createGetterForSingularLinkedField(
       // Flow incorrect assumes that the return value for the get method must match
       // the set parameter.
       // $FlowFixMe[unclear-type] Typed by the generated updatable query flow type
-      return (updatableProxy: any);
+      return updatableProxy as any;
     } else {
       return linkedRecord;
     }
@@ -376,7 +376,7 @@ function getLinkedRecordUsingMissingFieldHandlers(
   newVariables: Variables,
   updatableProxyRootRecord: RecordProxy,
   recordSourceProxy: RecordSourceProxy,
-  missingFieldHandlers: $ReadOnlyArray<MissingFieldHandler>,
+  missingFieldHandlers: ReadonlyArray<MissingFieldHandler>,
 ): ?RecordProxy {
   for (const handler of missingFieldHandlers) {
     if (handler.kind === 'linked') {
@@ -398,7 +398,7 @@ function getPluralLinkedRecordUsingMissingFieldHandlers(
   newVariables: Variables,
   updatableProxyRootRecord: RecordProxy,
   recordSourceProxy: RecordSourceProxy,
-  missingFieldHandlers: $ReadOnlyArray<MissingFieldHandler>,
+  missingFieldHandlers: ReadonlyArray<MissingFieldHandler>,
 ): ?Array<?RecordProxy> {
   for (const handler of missingFieldHandlers) {
     if (handler.kind === 'pluralLinked') {
@@ -424,8 +424,8 @@ function getScalarUsingMissingFieldHandlers(
   newVariables: Variables,
   updatableProxyRootRecord: RecordProxy,
   recordSourceProxy: RecordSourceProxy,
-  missingFieldHandlers: $ReadOnlyArray<MissingFieldHandler>,
-): mixed {
+  missingFieldHandlers: ReadonlyArray<MissingFieldHandler>,
+): unknown {
   for (const handler of missingFieldHandlers) {
     if (handler.kind === 'scalar') {
       const value = handler.handle(

package/mutations/readUpdatableFragment.js.flow

@@ -27,11 +27,11 @@ const {createUpdatableProxy} = require('./createUpdatableProxy');
 const invariant = require('invariant');
 
 // Note: plural fragment references are currently not supported
-function readUpdatableFragment<TFragmentType: FragmentType, TData>(
+function readUpdatableFragment<TFragmentType extends FragmentType, TData>(
   fragment: UpdatableFragment<TFragmentType, TData>,
   fragmentReference: HasUpdatableSpread<TFragmentType>,
   proxy: RecordSourceProxy,
-  missingFieldHandlers: $ReadOnlyArray<MissingFieldHandler>,
+  missingFieldHandlers: ReadonlyArray<MissingFieldHandler>,
 ): UpdatableData<TData> {
   const updatableFragment = getFragment(fragment);
   const fragmentVariables = getVariablesFromFragment(
@@ -48,7 +48,7 @@ function readUpdatableFragment<TFragmentType: FragmentType, TData>(
   );
 
   return {
-    // $FlowFixMe[incompatible-call]
+    // $FlowFixMe[incompatible-type]
     updatableData: createUpdatableProxy<TData>(
       fragmentRoot,
       fragmentVariables,

package/mutations/readUpdatableQuery.js.flow

@@ -21,16 +21,16 @@ import type {UpdatableQuery, Variables} from '../util/RelayRuntimeTypes';
 const {getUpdatableQuery} = require('../query/GraphQLTag');
 const {createUpdatableProxy} = require('./createUpdatableProxy');
 
-function readUpdatableQuery<TVariables: Variables, TData>(
+function readUpdatableQuery<TVariables extends Variables, TData>(
   query: UpdatableQuery<TVariables, TData>,
   variables: TVariables,
   proxy: RecordSourceProxy,
-  missingFieldHandlers: $ReadOnlyArray<MissingFieldHandler>,
+  missingFieldHandlers: ReadonlyArray<MissingFieldHandler>,
 ): UpdatableData<TData> {
   const updatableQuery = getUpdatableQuery(query);
 
   return {
-    // $FlowFixMe[incompatible-call]
+    // $FlowFixMe[incompatible-type]
     updatableData: createUpdatableProxy<TData>(
       proxy.getRoot(),
       variables,

package/mutations/validateMutation.js.flow

@@ -62,12 +62,12 @@ if (__DEV__) {
   ) => {
     const operationName = mutation.operation.name;
     const context: ValidationContext = {
-      path: 'ROOT',
-      visitedPaths: new Set(),
-      variables: variables || {},
-      missingDiff: {},
       extraDiff: {},
+      missingDiff: {},
       moduleImportPaths: new Set(),
+      path: 'ROOT',
+      variables: variables || {},
+      visitedPaths: new Set(),
     };
     validateSelections(
       optimisticResponse,
@@ -91,7 +91,7 @@ if (__DEV__) {
 
   const validateSelections = (
     optimisticResponse: Object,
-    selections: $ReadOnlyArray<NormalizationSelection>,
+    selections: ReadonlyArray<NormalizationSelection>,
     context: ValidationContext,
   ) => {
     selections.forEach(selection =>
@@ -156,7 +156,7 @@ if (__DEV__) {
         return;
       }
       default:
-        (selection: empty);
+        selection as empty;
         return;
     }
   };
@@ -261,4 +261,4 @@ if (__DEV__) {
   };
 }
 
-module.exports = (validateMutation: (Object, ConcreteRequest, ?Object) => void);
+module.exports = validateMutation as (Object, ConcreteRequest, ?Object) => void;

package/network/RelayNetwork.d.ts

@@ -0,0 +1,12 @@
+/**
+ * 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 {FetchFunction, Network, SubscribeFunction} from './RelayNetworkTypes';
+
+export const RelayNetwork: {
+    create(fetchFn: FetchFunction, subscribeFn?: SubscribeFunction): Network;
+};

package/network/RelayNetworkTypes.d.ts

@@ -0,0 +1,145 @@
+/**
+ * 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 { RequestParameters } from '../util/RelayConcreteNode';
+import {CacheConfig, Disposable, Variables} from '../util/RelayRuntimeTypes';
+import {ObservableFromValue, RelayObservable} from './RelayObservable';
+
+/**
+ * An interface for fetching the data for one or more (possibly interdependent)
+ * queries.
+ */
+export interface Network {
+    execute: ExecuteFunction;
+}
+export type LogRequestInfoFunction = (arg: any) => void;
+
+export interface PayloadData {
+    [key: string]: any;
+}
+
+export interface PayloadError {
+    message: string;
+    locations?:
+        | Array<{
+            line: number;
+            column: number;
+        }>
+        | undefined;
+    path?: Array<string | number>;
+    severity?: 'CRITICAL' | 'ERROR' | 'WARNING' | undefined; // Not officially part of the spec, but used at Facebook
+}
+
+export interface PayloadExtensions {
+    [key: string]: any;
+}
+
+/**
+ * The shape of a GraphQL response as dictated by the
+ * [spec](https://graphql.github.io/graphql-spec/June2018/#sec-Response-Format)
+ */
+export interface GraphQLResponseWithData {
+    data: PayloadData;
+    errors?: PayloadError[] | undefined;
+    extensions?: PayloadExtensions | undefined;
+    label?: string | undefined;
+    path?: Array<string | number> | undefined;
+}
+export interface GraphQLResponseWithoutData {
+    data?: PayloadData | undefined;
+    errors: PayloadError[];
+    extensions?: PayloadExtensions | undefined;
+    label?: string | undefined;
+    path?: Array<string | number> | undefined;
+}
+export interface GraphQLResponseWithExtensionsOnly {
+    // Per https://spec.graphql.org/June2018/#sec-Errors
+    // > If the data entry in the response is not present, the errors entry
+    // > in the response must not be empty. It must contain at least one error
+    // This means a payload has to have either a data key or an errors key:
+    // but the spec leaves room for the combination of data: null plus extensions
+    // since `data: null` is a *required* output if there was an error during
+    // execution, but the inverse is not described in the sepc: `data: null`
+    // does not necessarily indicate that there was an error.
+    data: null;
+    extensions: PayloadExtensions;
+}
+
+export type GraphQLSingularResponse =
+    | GraphQLResponseWithData
+    | GraphQLResponseWithExtensionsOnly
+    | GraphQLResponseWithoutData;
+
+export type GraphQLResponse = GraphQLSingularResponse | readonly GraphQLSingularResponse[];
+
+/**
+ * A function that returns an Observable representing the response of executing
+ * a GraphQL operation.
+ */
+export type ExecuteFunction = (
+    request: RequestParameters,
+    variables: Variables,
+    cacheConfig: CacheConfig,
+    uploadables?: UploadableMap | null,
+) => RelayObservable<GraphQLResponse>;
+
+/**
+ * A function that executes a GraphQL operation with request/response semantics.
+ *
+ * May return an Observable or Promise of a plain GraphQL server response, or
+ * a composed ExecutePayload object supporting additional metadata.
+ */
+export type FetchFunction = (
+    request: RequestParameters,
+    variables: Variables,
+    cacheConfig: CacheConfig,
+    uploadables?: UploadableMap | null,
+) => ObservableFromValue<GraphQLResponse>;
+
+export interface LegacyObserver<T> {
+    onCompleted?: (() => void) | undefined;
+    onError?: ((error: Error) => void) | undefined;
+    onNext?: ((data: T) => void) | undefined;
+}
+
+/**
+ * A function that executes a GraphQL subscription operation, returning zero or
+ * more raw server responses over time.
+ */
+export type SubscribeFunction = (
+    request: RequestParameters,
+    variables: Variables,
+    cacheConfig: CacheConfig,
+    observer?: LegacyObserver<GraphQLResponse>,
+) => RelayObservable<GraphQLResponse> | Disposable;
+
+export type Uploadable = File | Blob;
+export interface UploadableMap {
+    [key: string]: Uploadable;
+}
+
+/**
+ * React Flight tree created on the server.
+ */
+export type ReactFlightServerTree = any;
+export interface ReactFlightPayloadQuery {
+    readonly id: any;
+    readonly module: any;
+    readonly response: GraphQLSingularResponse;
+    readonly variables: Variables;
+}
+/**
+ * Data that is returned by a Flight compliant GraphQL server.
+ *
+ * - tree: an array of values that will be iterated and fed into
+ *     ReactFlightDOMRelayClient.
+ * - queries: an array of queries that the server preloaded for the client.
+ */
+export interface ReactFlightPayloadData {
+    readonly tree: ReactFlightServerTree[];
+    readonly queries: ReactFlightPayloadQuery[];
+}