relay-runtime 20.1.1 → 21.0.1

package/store/waitForFragmentExperimental.d.ts

@@ -0,0 +1,49 @@
+/**
+ * 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 type { GraphQLTaggedNode } from '../query/GraphQLTag';
+import type {ArrayKeyType, ArrayKeyTypeData, Environment as IEnvironment, KeyType, KeyTypeData} from './RelayStoreTypes';
+
+/**
+ * EXPERIMENTAL: This API is experimental and does not yet support all Relay
+ * features. Notably, it does not correctly handle some features of Relay Resolvers.
+ *
+ * Given a fragment and a fragment reference, returns a promise that resolves
+ * once the fragment data is available, or rejects if the fragment has an error.
+ * Errors include both network errors and field errors due to @required(action:
+ * THROW) or @throwOnFieldError.
+
+ * This API is intended for use when consuming data outside of a UI framework, or
+ * when you need to imperatively access data inside an event handler. For example,
+ * you might choose to @defer a fragment that you only need to access inside an
+ * event handler and then await its value inside the handler if/when it is triggered.
+ */
+export function waitForFragmentData<TKey extends KeyType>(
+    environment: IEnvironment,
+    fragmentInput: GraphQLTaggedNode,
+    fragmentRef: TKey,
+): Promise<KeyTypeData<TKey>>;
+
+/**
+ * EXPERIMENTAL: This API is experimental and does not yet support all Relay
+ * features. Notably, it does not correctly handle some features of Relay Resolvers.
+ *
+ * Given a fragment and a fragment reference, returns a promise that resolves
+ * once the fragment data is available, or rejects if the fragment has an error.
+ * Errors include both network errors and field errors due to @required(action:
+ * THROW) or @throwOnFieldError.
+
+ * This API is intended for use when consuming data outside of a UI framework, or
+ * when you need to imperatively access data inside an event handler. For example,
+ * you might choose to @defer a fragment that you only need to access inside an
+ * event handler and then await its value inside the handler if/when it is triggered.
+ */
+export function waitForFragmentData<TKey extends ArrayKeyType>(
+    environment: IEnvironment,
+    fragmentInput: GraphQLTaggedNode,
+    fragmentRef: TKey,
+): Promise<ArrayKeyTypeData<TKey>>;

package/store/waitForFragmentExperimental.js.flow

@@ -33,12 +33,12 @@ const {observeFragment} = require('./observeFragmentExperimental');
  * you might choose to @defer a fragment that you only need to access inside an
  * event handler and then await its value inside the handler if/when it is triggered.
  */
-async function waitForFragmentData<TFragmentType: FragmentType, TData>(
+async function waitForFragmentData<TFragmentType extends FragmentType, TData>(
   environment: IEnvironment,
   fragment: Fragment<TFragmentType, TData>,
   fragmentRef:
     | HasSpread<TFragmentType>
-    | $ReadOnlyArray<HasSpread<TFragmentType>>,
+    | ReadonlyArray<HasSpread<TFragmentType>>,
 ): Promise<TData> {
   let subscription: ?Subscription;
 
@@ -60,7 +60,7 @@ async function waitForFragmentData<TFragmentType: FragmentType, TData>(
     });
     subscription?.unsubscribe();
     return data;
-  } catch (e: mixed) {
+  } catch (e: unknown) {
     subscription?.unsubscribe();
     throw e;
   }

package/subscription/requestSubscription.d.ts

@@ -0,0 +1,27 @@
+/**
+ * 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 { DeclarativeMutationConfig } from '../mutations/RelayDeclarativeMutationConfig';
+import { GraphQLTaggedNode } from '../query/GraphQLTag';
+import {Environment, SelectorStoreUpdater} from '../store/RelayStoreTypes';
+import {CacheConfig, Disposable, OperationType} from '../util/RelayRuntimeTypes';
+
+export interface GraphQLSubscriptionConfig<TSubscription extends OperationType> {
+    cacheConfig?: CacheConfig | undefined;
+    configs?: readonly DeclarativeMutationConfig[] | undefined;
+    subscription: GraphQLTaggedNode;
+    variables: TSubscription['variables'];
+    onCompleted?: (() => void) | undefined;
+    onError?: ((error: Error) => void) | undefined;
+    onNext?: ((response: TSubscription['response'] | null | undefined) => void) | undefined;
+    updater?: SelectorStoreUpdater<TSubscription['response']> | undefined;
+}
+
+export function requestSubscription<TSubscription extends OperationType = OperationType>(
+    environment: Environment,
+    config: GraphQLSubscriptionConfig<TSubscription>,
+): Disposable;

package/subscription/requestSubscription.js.flow

@@ -32,9 +32,9 @@ const {createReaderSelector} = require('../store/RelayModernSelector');
 const warning = require('warning');
 
 export type SubscriptionParameters = {
-  +response: {...},
-  +variables: {...},
-  +rawResponse?: {...},
+  readonly response: {...},
+  readonly variables: {...},
+  readonly rawResponse?: {...},
 };
 
 /**
@@ -42,18 +42,18 @@ export type SubscriptionParameters = {
  * type information.
  */
 export type GraphQLSubscriptionConfig<TVariables, TData, TRawResponse> =
-  $ReadOnly<{
+  Readonly<{
     configs?: Array<DeclarativeMutationConfig>,
     cacheConfig?: CacheConfig,
     subscription: GraphQLSubscription<TVariables, TData, TRawResponse>,
-    variables: TVariables,
+    variables: NoInfer<TVariables>,
     onCompleted?: ?() => void,
     onError?: ?(error: Error) => void,
     onNext?: ?(response: ?TData) => void,
     updater?: ?SelectorStoreUpdater<TData>,
   }>;
 
-function requestSubscription<TVariables: Variables, TData, TRawResponse>(
+function requestSubscription<TVariables extends Variables, TData, TRawResponse>(
   environment: IEnvironment,
   config: GraphQLSubscriptionConfig<TVariables, TData, TRawResponse>,
 ): Disposable {
@@ -89,6 +89,8 @@ function requestSubscription<TVariables: Variables, TData, TRawResponse>(
       updater,
     })
     .subscribe({
+      complete: onCompleted,
+      error: onError,
       next: responses => {
         if (onNext != null) {
           let selector = operation.fragment;
@@ -107,12 +109,10 @@ function requestSubscription<TVariables: Variables, TData, TRawResponse>(
             );
           }
           const data = environment.lookup(selector).data;
-          // $FlowFixMe[incompatible-cast]
-          onNext((data: TData));
+          // $FlowFixMe[incompatible-type]
+          onNext(data as TData);
         }
       },
-      error: onError,
-      complete: onCompleted,
     });
   return {
     dispose: sub.unsubscribe,

package/util/JSResourceTypes.flow.js.flow

@@ -11,8 +11,8 @@
 
 'use strict';
 
-export interface JSResourceReference<+T> {
-  +getModuleId: () => string;
-  +getModuleIfRequired: () => ?T;
-  +load: () => Promise<T>;
+export interface JSResourceReference<out T> {
+  readonly getModuleId: () => string;
+  readonly getModuleIfRequired: () => ?T;
+  readonly load: () => Promise<T>;
 }

package/util/NormalizationNode.d.ts

@@ -0,0 +1,235 @@
+/**
+ * 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 type {ConcreteRequest, ProvidedVariableType} from './RelayConcreteNode';
+
+export interface JSResourceReference<TModule> {
+    getModuleId(): string;
+    getModuleIfRequired(): TModule | null | undefined;
+    load(): Promise<TModule>;
+}
+
+/**
+ * Represents a single operation used to processing and normalize runtime
+ * request results.
+ */
+export interface NormalizationOperation {
+    readonly kind: 'Operation';
+    readonly name: string;
+    readonly argumentDefinitions: readonly NormalizationLocalArgumentDefinition[];
+    readonly selections: readonly NormalizationSelection[];
+    readonly clientAbstractTypes?: {
+        readonly [key: string]: readonly string[];
+    };
+    readonly use_exec_time_resolvers?: boolean;
+    readonly exec_time_resolvers_enabled_provider?: ProvidedVariableType;
+}
+
+export type NormalizationHandle = NormalizationScalarHandle | NormalizationLinkedHandle;
+
+export interface NormalizationLinkedHandle {
+    readonly kind: 'LinkedHandle';
+    readonly alias?: string | null | undefined;
+    readonly name: string;
+    readonly args?: readonly NormalizationArgument[] | null | undefined;
+    readonly handle: string;
+    readonly key: string;
+    // NOTE: this property is optional because it's expected to be rarely used
+    readonly dynamicKey?: NormalizationArgument | null | undefined;
+    readonly filters?: readonly string[] | null | undefined;
+    readonly handleArgs?: readonly NormalizationArgument[];
+}
+
+export interface NormalizationScalarHandle {
+    readonly kind: 'ScalarHandle';
+    readonly alias?: string | null | undefined;
+    readonly name: string;
+    readonly args?: readonly NormalizationArgument[] | null | undefined;
+    readonly handle: string;
+    readonly key: string;
+    // NOTE: this property is optional because it's expected to be rarely used
+    readonly dynamicKey?: NormalizationArgument | null | undefined;
+    readonly filters?: readonly string[] | null | undefined;
+    readonly handleArgs?: readonly NormalizationArgument[];
+}
+
+export type NormalizationArgument =
+    | NormalizationListValueArgument
+    | NormalizationLiteralArgument
+    | NormalizationObjectValueArgument
+    | NormalizationVariableArgument;
+
+export interface NormalizationCondition {
+    readonly kind: 'Condition';
+    readonly passingValue: boolean;
+    readonly condition: string;
+    readonly selections: readonly NormalizationSelection[];
+}
+
+export interface NormalizationClientExtension {
+    readonly kind: 'ClientExtension';
+    readonly selections: readonly NormalizationSelection[];
+}
+
+export type NormalizationField = NormalizationFlightField | NormalizationScalarField | NormalizationLinkedField;
+
+export interface NormalizationInlineFragment {
+    readonly kind: 'InlineFragment';
+    readonly selections: readonly NormalizationSelection[];
+    readonly type: string;
+    readonly abstractKey?: string | null | undefined;
+}
+
+export interface NormalizationFragmentSpread {
+    readonly kind: 'FragmentSpread';
+    readonly fragment: NormalizationSplitOperation;
+    readonly args?: readonly NormalizationArgument[] | null | undefined;
+}
+
+export interface NormalizationLinkedField {
+    readonly kind: 'LinkedField';
+    readonly alias?: string | null | undefined;
+    readonly name: string;
+    readonly storageKey?: string | null | undefined;
+    readonly args?: readonly NormalizationArgument[] | null | undefined;
+    readonly concreteType?: string | null | undefined;
+    readonly plural: boolean;
+    readonly selections: readonly NormalizationSelection[];
+}
+
+export interface NormalizationActorChange {
+    readonly kind: 'ActorChange';
+    readonly linkedField: NormalizationLinkedField;
+}
+
+export interface NormalizationModuleImport {
+    readonly args?: readonly NormalizationArgument[] | null | undefined;
+    readonly kind: 'ModuleImport';
+    readonly documentName: string;
+    readonly fragmentPropName: string;
+    readonly fragmentName: string;
+    readonly componentModuleProvider?: () => unknown | Promise<unknown> | JSResourceReference<unknown>;
+    readonly operationModuleProvider?: () =>
+        | NormalizationRootNode
+        | Promise<NormalizationRootNode>
+        | JSResourceReference<NormalizationRootNode>;
+}
+
+export interface NormalizationListValueArgument {
+    readonly kind: 'ListValue';
+    readonly name: string;
+    readonly items: ReadonlyArray<NormalizationArgument | null>;
+}
+
+export interface NormalizationLiteralArgument {
+    readonly kind: 'Literal';
+    readonly name: string;
+    readonly type?: string | null | undefined;
+    readonly value: any;
+}
+
+export interface NormalizationLocalArgumentDefinition {
+    readonly kind: 'LocalArgument';
+    readonly name: string;
+    readonly defaultValue: any;
+}
+
+export type NormalizationNode =
+    | NormalizationClientExtension
+    | NormalizationCondition
+    | NormalizationDefer
+    | NormalizationInlineFragment
+    | NormalizationLinkedField
+    | NormalizationOperation
+    | NormalizationSplitOperation
+    | NormalizationStream;
+
+export interface NormalizationScalarField {
+    readonly kind: 'ScalarField';
+    readonly alias?: string | null | undefined;
+    readonly name: string;
+    readonly args?: readonly NormalizationArgument[] | null | undefined;
+    readonly storageKey?: string | null | undefined;
+}
+
+export interface NormalizationFlightField {
+    readonly kind: 'FlightField';
+    readonly alias?: string | null | undefined;
+    readonly name: string;
+    readonly args?: readonly NormalizationArgument[] | null | undefined;
+    readonly storageKey: string | null | undefined;
+}
+
+export interface NormalizationClientComponent {
+    readonly args?: readonly NormalizationArgument[] | null | undefined;
+    readonly kind: 'ClientComponent';
+    readonly fragment: NormalizationNode;
+}
+
+export interface NormalizationTypeDiscriminator {
+    readonly kind: 'TypeDiscriminator';
+    readonly abstractKey: string;
+}
+
+export type NormalizationSelection =
+    | NormalizationCondition
+    | NormalizationClientComponent
+    | NormalizationClientExtension
+    | NormalizationDefer
+    | NormalizationField
+    | NormalizationFlightField
+    | NormalizationFragmentSpread
+    | NormalizationHandle
+    | NormalizationInlineFragment
+    | NormalizationModuleImport
+    | NormalizationStream
+    | NormalizationActorChange
+    | NormalizationTypeDiscriminator;
+
+export interface NormalizationSplitOperation {
+    readonly argumentDefinitions?: readonly NormalizationLocalArgumentDefinition[];
+    readonly kind: 'SplitOperation';
+    readonly name: string;
+    readonly metadata: { readonly [key: string]: unknown } | null | undefined;
+    readonly selections: readonly NormalizationSelection[];
+}
+
+export interface NormalizationStream {
+    readonly if: string | null;
+    readonly kind: 'Stream';
+    readonly label: string;
+    readonly selections: readonly NormalizationSelection[];
+}
+
+export interface NormalizationDefer {
+    readonly if: string | null;
+    readonly kind: 'Defer';
+    readonly label: string;
+    readonly selections: readonly NormalizationSelection[];
+}
+
+export interface NormalizationVariableArgument {
+    readonly kind: 'Variable';
+    readonly name: string;
+    readonly type?: string | null | undefined;
+    readonly variableName: string;
+}
+
+export interface NormalizationObjectValueArgument {
+    readonly kind: 'ObjectValue';
+    readonly name: string;
+    readonly fields: readonly NormalizationArgument[];
+}
+
+export type NormalizationSelectableNode =
+    | NormalizationDefer
+    | NormalizationLinkedField
+    | NormalizationOperation
+    | NormalizationSplitOperation
+    | NormalizationStream;
+
+export type NormalizationRootNode = ConcreteRequest | NormalizationSplitOperation;