relay-runtime 20.1.1 → 21.0.1

package/util/NormalizationNode.js.flow

@@ -20,15 +20,17 @@ import type {JSResourceReference} from 'JSResourceReference';
  * request results.
  */
 export type NormalizationOperation = {
-  +kind: 'Operation',
-  +name: string,
-  +argumentDefinitions: $ReadOnlyArray<NormalizationLocalArgumentDefinition>,
-  +selections: $ReadOnlyArray<NormalizationSelection>,
-  +clientAbstractTypes?: {
-    +[string]: $ReadOnlyArray<string>,
+  readonly kind: 'Operation',
+  readonly name: string,
+  readonly argumentDefinitions: ReadonlyArray<NormalizationLocalArgumentDefinition>,
+  readonly selections: ReadonlyArray<NormalizationSelection>,
+  readonly clientAbstractTypes?: {
+    readonly [string]: ReadonlyArray<string>,
   },
-  +use_exec_time_resolvers?: boolean,
-  +exec_time_resolvers_enabled_provider?: ProvidedVariableType,
+  readonly has_server_to_client_resolvers?: boolean,
+  readonly use_exec_time_resolvers?: boolean,
+  readonly exec_time_resolvers_enabled_provider?: ProvidedVariableType,
+  readonly use_experimental_provider?: ProvidedVariableType,
 };
 
 export type NormalizationHandle =
@@ -36,29 +38,29 @@ export type NormalizationHandle =
   | NormalizationLinkedHandle;
 
 export type NormalizationLinkedHandle = {
-  +kind: 'LinkedHandle',
-  +alias?: ?string,
-  +name: string,
-  +args?: ?$ReadOnlyArray<NormalizationArgument>,
-  +handle: string,
-  +key: string,
+  readonly kind: 'LinkedHandle',
+  readonly alias?: ?string,
+  readonly name: string,
+  readonly args?: ?ReadonlyArray<NormalizationArgument>,
+  readonly handle: string,
+  readonly key: string,
   // NOTE: this property is optional because it's expected to be rarely used
-  +dynamicKey?: ?NormalizationArgument,
-  +filters?: ?$ReadOnlyArray<string>,
-  +handleArgs?: $ReadOnlyArray<NormalizationArgument>,
+  readonly dynamicKey?: ?NormalizationArgument,
+  readonly filters?: ?ReadonlyArray<string>,
+  readonly handleArgs?: ReadonlyArray<NormalizationArgument>,
 };
 
 export type NormalizationScalarHandle = {
-  +kind: 'ScalarHandle',
-  +alias?: ?string,
-  +name: string,
-  +args?: ?$ReadOnlyArray<NormalizationArgument>,
-  +handle: string,
-  +key: string,
+  readonly kind: 'ScalarHandle',
+  readonly alias?: ?string,
+  readonly name: string,
+  readonly args?: ?ReadonlyArray<NormalizationArgument>,
+  readonly handle: string,
+  readonly key: string,
   // NOTE: this property is optional because it's expected to be rarely used
-  +dynamicKey?: ?NormalizationArgument,
-  +filters?: ?$ReadOnlyArray<string>,
-  +handleArgs?: $ReadOnlyArray<NormalizationArgument>,
+  readonly dynamicKey?: ?NormalizationArgument,
+  readonly filters?: ?ReadonlyArray<string>,
+  readonly handleArgs?: ReadonlyArray<NormalizationArgument>,
 };
 
 export type NormalizationArgument =
@@ -68,15 +70,15 @@ export type NormalizationArgument =
   | NormalizationVariableArgument;
 
 export type NormalizationCondition = {
-  +kind: 'Condition',
-  +passingValue: boolean,
-  +condition: string,
-  +selections: $ReadOnlyArray<NormalizationSelection>,
+  readonly kind: 'Condition',
+  readonly passingValue: boolean,
+  readonly condition: string,
+  readonly selections: ReadonlyArray<NormalizationSelection>,
 };
 
 export type NormalizationClientExtension = {
-  +kind: 'ClientExtension',
-  +selections: $ReadOnlyArray<NormalizationSelection>,
+  readonly kind: 'ClientExtension',
+  readonly selections: ReadonlyArray<NormalizationSelection>,
 };
 
 export type NormalizationField =
@@ -86,67 +88,67 @@ export type NormalizationField =
   | NormalizationLinkedField;
 
 export type NormalizationInlineFragment = {
-  +kind: 'InlineFragment',
-  +selections: $ReadOnlyArray<NormalizationSelection>,
-  +type: string,
-  +abstractKey?: ?string,
+  readonly kind: 'InlineFragment',
+  readonly selections: ReadonlyArray<NormalizationSelection>,
+  readonly type: string,
+  readonly abstractKey?: ?string,
 };
 
 export type NormalizationFragmentSpread = {
-  +kind: 'FragmentSpread',
-  +fragment: NormalizationSplitOperation,
-  +args?: ?$ReadOnlyArray<NormalizationArgument>,
+  readonly kind: 'FragmentSpread',
+  readonly fragment: NormalizationSplitOperation,
+  readonly args?: ?ReadonlyArray<NormalizationArgument>,
 };
 
 export type NormalizationLinkedField = {
-  +kind: 'LinkedField',
-  +alias?: ?string,
-  +name: string,
-  +storageKey?: ?string,
-  +args?: ?$ReadOnlyArray<NormalizationArgument>,
-  +concreteType?: ?string,
-  +plural: boolean,
-  +selections: $ReadOnlyArray<NormalizationSelection>,
+  readonly kind: 'LinkedField',
+  readonly alias?: ?string,
+  readonly name: string,
+  readonly storageKey?: ?string,
+  readonly args?: ?ReadonlyArray<NormalizationArgument>,
+  readonly concreteType?: ?string,
+  readonly plural: boolean,
+  readonly selections: ReadonlyArray<NormalizationSelection>,
 };
 
 export type NormalizationActorChange = {
-  +kind: 'ActorChange',
-  +linkedField: NormalizationLinkedField,
+  readonly kind: 'ActorChange',
+  readonly linkedField: NormalizationLinkedField,
 };
 
 export type NormalizationModuleImport = {
-  +args?: ?$ReadOnlyArray<NormalizationArgument>,
-  +kind: 'ModuleImport',
-  +documentName: string,
-  +fragmentPropName: string,
-  +fragmentName: string,
-  +componentModuleProvider?: () =>
-    | mixed
-    | Promise<mixed>
-    | JSResourceReference<mixed>,
-  +operationModuleProvider?: () =>
+  readonly args?: ?ReadonlyArray<NormalizationArgument>,
+  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 type NormalizationListValueArgument = {
-  +kind: 'ListValue',
-  +name: string,
-  +items: $ReadOnlyArray<NormalizationArgument | null>,
+  readonly kind: 'ListValue',
+  readonly name: string,
+  readonly items: ReadonlyArray<NormalizationArgument | null>,
 };
 
 export type NormalizationLiteralArgument = {
-  +kind: 'Literal',
-  +name: string,
-  +type?: ?string,
-  +value: mixed,
+  readonly kind: 'Literal',
+  readonly name: string,
+  readonly type?: ?string,
+  readonly value: unknown,
 };
 
 export type NormalizationLocalArgumentDefinition = {
-  +kind: 'LocalArgument',
-  +name: string,
-  +defaultValue: mixed,
+  readonly kind: 'LocalArgument',
+  readonly name: string,
+  readonly defaultValue: unknown,
 };
 
 export type NormalizationNode =
@@ -160,70 +162,72 @@ export type NormalizationNode =
   | NormalizationStream;
 
 export type NormalizationScalarField = {
-  +kind: 'ScalarField',
-  +alias?: ?string,
-  +name: string,
-  +args?: ?$ReadOnlyArray<NormalizationArgument>,
-  +storageKey?: ?string,
+  readonly kind: 'ScalarField',
+  readonly alias?: ?string,
+  readonly name: string,
+  readonly args?: ?ReadonlyArray<NormalizationArgument>,
+  readonly storageKey?: ?string,
 };
 
 export type ResolverReference = {
-  +fieldType: string,
-  +resolverFunctionName: string,
+  readonly fieldType: string,
+  readonly resolverFunctionName: string,
 };
 
 export type ResolverInfo = {
-  +resolverFunction: ResolverFunction,
-  +rootFragment?: ?NormalizationSplitOperation,
+  readonly resolverFunction: ResolverFunction,
+  readonly rootFragment?: ?NormalizationSplitOperation,
 };
 
 type ResolverData =
-  | {+resolverModule?: ResolverModule}
-  | {+resolverReference?: ResolverReference}
-  | {+resolverInfo?: ResolverInfo};
+  | {readonly resolverModule?: ResolverModule}
+  | {readonly resolverReference?: ResolverReference}
+  | {readonly resolverInfo?: ResolverInfo};
 
 export type NormalizationResolverField = {
-  +kind: 'RelayResolver',
-  +name: string,
-  +args?: ?$ReadOnlyArray<NormalizationArgument>,
-  +fragment?: ?NormalizationInlineFragment,
-  +storageKey?: ?string,
-  +isOutputType: boolean,
+  readonly kind: 'RelayResolver',
+  readonly name: string,
+  readonly args?: ?ReadonlyArray<NormalizationArgument>,
+  readonly fragment?: ?NormalizationInlineFragment,
+  readonly storageKey?: ?string,
+  readonly isOutputType: boolean,
   ...ResolverData,
 };
 
 export type NormalizationLiveResolverField = {
-  +kind: 'RelayLiveResolver',
-  +name: string,
-  +args?: ?$ReadOnlyArray<NormalizationArgument>,
-  +fragment?: ?NormalizationInlineFragment,
-  +storageKey?: ?string,
-  +isOutputType: boolean,
+  readonly kind: 'RelayLiveResolver',
+  readonly name: string,
+  readonly args?: ?ReadonlyArray<NormalizationArgument>,
+  readonly fragment?: ?NormalizationInlineFragment,
+  readonly storageKey?: ?string,
+  readonly isOutputType: boolean,
   ...ResolverData,
 };
 
 export type NormalizationModelResolvers = {
   [string]: {
-    +resolverModule: ResolverModule,
+    readonly resolverModule: ResolverModule,
   },
 };
 
 export type NormalizationClientEdgeToClientObject = {
-  +kind: 'ClientEdgeToClientObject',
-  +linkedField: NormalizationLinkedField,
-  +backingField: NormalizationResolverField | NormalizationLiveResolverField,
-  +modelResolvers?: NormalizationModelResolvers | null,
+  readonly kind: 'ClientEdgeToClientObject',
+  readonly linkedField: NormalizationLinkedField,
+  readonly backingField:
+    | NormalizationResolverField
+    | NormalizationLiveResolverField,
+  readonly modelResolvers?: NormalizationModelResolvers | null,
 };
 
 export type NormalizationClientComponent = {
-  +args?: ?$ReadOnlyArray<NormalizationArgument>,
-  +kind: 'ClientComponent',
-  +fragment: NormalizationNode,
+  readonly args?: ?ReadonlyArray<NormalizationArgument>,
+  readonly kind: 'ClientComponent',
+  readonly fragment: NormalizationNode,
 };
 
 export type NormalizationTypeDiscriminator = {
-  +kind: 'TypeDiscriminator',
-  +abstractKey: string,
+  readonly kind: 'TypeDiscriminator',
+  readonly abstractKey: string,
 };
 
 export type NormalizationSelection =
@@ -242,38 +246,38 @@ export type NormalizationSelection =
   | NormalizationTypeDiscriminator;
 
 export type NormalizationSplitOperation = {
-  +argumentDefinitions?: $ReadOnlyArray<NormalizationLocalArgumentDefinition>,
-  +kind: 'SplitOperation',
-  +name: string,
-  +metadata?: ?{+[key: string]: mixed, ...},
-  +selections: $ReadOnlyArray<NormalizationSelection>,
+  readonly argumentDefinitions?: ReadonlyArray<NormalizationLocalArgumentDefinition>,
+  readonly kind: 'SplitOperation',
+  readonly name: string,
+  readonly metadata?: ?{readonly [key: string]: unknown, ...},
+  readonly selections: ReadonlyArray<NormalizationSelection>,
 };
 
 export type NormalizationStream = {
-  +if: string | null,
-  +kind: 'Stream',
-  +label: string,
-  +selections: $ReadOnlyArray<NormalizationSelection>,
+  readonly if: string | null,
+  readonly kind: 'Stream',
+  readonly label: string,
+  readonly selections: ReadonlyArray<NormalizationSelection>,
 };
 
 export type NormalizationDefer = {
-  +if: string | null,
-  +kind: 'Defer',
-  +label: string,
-  +selections: $ReadOnlyArray<NormalizationSelection>,
+  readonly if: string | null,
+  readonly kind: 'Defer',
+  readonly label: string,
+  readonly selections: ReadonlyArray<NormalizationSelection>,
 };
 
 export type NormalizationVariableArgument = {
-  +kind: 'Variable',
-  +name: string,
-  +type?: ?string,
-  +variableName: string,
+  readonly kind: 'Variable',
+  readonly name: string,
+  readonly type?: ?string,
+  readonly variableName: string,
 };
 
 export type NormalizationObjectValueArgument = {
-  +kind: 'ObjectValue',
-  +name: string,
-  +fields: $ReadOnlyArray<NormalizationArgument>,
+  readonly kind: 'ObjectValue',
+  readonly name: string,
+  readonly fields: ReadonlyArray<NormalizationArgument>,
 };
 
 export type NormalizationSelectableNode =

package/util/ReaderNode.d.ts

@@ -0,0 +1,264 @@
+/**
+ * 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 { ConnectionMetadata } from '../handlers/connection/ConnectionHandler';
+import type { ConcreteRequest } from './RelayConcreteNode';
+
+export interface ReaderFragmentSpread {
+    readonly kind: 'FragmentSpread';
+    readonly name: string;
+    readonly args?: readonly ReaderArgument[] | null | undefined;
+}
+
+export interface ReaderInlineDataFragmentSpread {
+    readonly kind: 'InlineDataFragmentSpread';
+    readonly name: string;
+    readonly selections: readonly ReaderSelection[];
+}
+
+export interface ReaderLinkedField {
+    readonly kind: 'LinkedField';
+    readonly alias?: string | null | undefined;
+    readonly name: string;
+    readonly storageKey?: string | null | undefined;
+    readonly args?: readonly ReaderArgument[] | null | undefined;
+    readonly concreteType?: string | null | undefined;
+    readonly plural: boolean;
+    readonly selections: readonly ReaderSelection[];
+}
+
+export interface ReaderFragment {
+    readonly kind: 'Fragment';
+    readonly name: string;
+    readonly type: string;
+    readonly abstractKey?: string | null | undefined;
+    readonly metadata?:
+        | {
+            readonly connection?: readonly ConnectionMetadata[];
+            readonly mask?: boolean;
+            readonly plural?: boolean;
+            readonly refetch?: ReaderRefetchMetadata;
+        }
+        | null
+        | undefined;
+    readonly argumentDefinitions: readonly ReaderArgumentDefinition[];
+    readonly selections: readonly ReaderSelection[];
+}
+
+// Marker type for a @refetchable fragment
+export interface ReaderRefetchableFragment extends ReaderFragment {
+    readonly metadata: {
+        readonly connection?: [ConnectionMetadata];
+        readonly refetch: ReaderRefetchMetadata;
+    };
+}
+
+// Marker Type for a @refetchable fragment with a single use of @connection
+export interface ReaderPaginationFragment extends ReaderFragment {
+    readonly metadata: {
+        readonly connection: [ConnectionMetadata];
+        readonly refetch: ReaderRefetchMetadata & {
+            connection: ReaderPaginationMetadata;
+        };
+    };
+}
+
+export interface RefetchableIdentifierInfo {
+    readonly identifierField: string;
+    readonly identifierQueryVariableName: string;
+}
+
+export interface ReaderRefetchMetadata {
+    readonly connection?: ReaderPaginationMetadata | null | undefined;
+    readonly operation: string | ConcreteRequest;
+    readonly fragmentPathInResult: string[];
+    readonly identifierInfo?: RefetchableIdentifierInfo | null | undefined;
+}
+
+// Stricter form of ConnectionMetadata
+export interface ReaderPaginationMetadata {
+    readonly backward: {
+        readonly count: string;
+        readonly cursor: string;
+    } | null;
+    readonly forward: {
+        readonly count: string;
+        readonly cursor: string;
+    } | null;
+    readonly path: readonly string[];
+}
+
+export interface ReaderInlineDataFragment {
+    readonly kind: 'InlineDataFragment';
+    readonly name: string;
+}
+
+export type ReaderArgument =
+    | ReaderListValueArgument
+    | ReaderLiteralArgument
+    | ReaderObjectValueArgument
+    | ReaderVariableArgument;
+
+export type ReaderArgumentDefinition = ReaderLocalArgument | ReaderRootArgument;
+
+export interface ReaderCondition {
+    readonly kind: 'Condition';
+    readonly passingValue: boolean;
+    readonly condition: string;
+    readonly selections: readonly ReaderSelection[];
+}
+
+export interface ReaderClientExtension {
+    readonly kind: 'ClientExtension';
+    readonly selections: readonly ReaderSelection[];
+}
+
+export type ReaderField = ReaderScalarField | ReaderLinkedField | ReaderRelayResolver;
+
+export interface ReaderRootArgument {
+    readonly kind: 'RootArgument';
+    readonly name: string;
+}
+
+export interface ReaderInlineFragment {
+    readonly kind: 'InlineFragment';
+    readonly selections: readonly ReaderSelection[];
+    readonly type: string;
+    readonly abstractKey?: string | null | undefined;
+}
+
+export interface ReaderLinkedField {
+    readonly kind: 'LinkedField';
+    readonly alias?: string | null | undefined;
+    readonly name: string;
+    readonly storageKey?: string | null | undefined;
+    readonly args?: readonly ReaderArgument[] | null | undefined;
+    readonly concreteType?: string | null | undefined;
+    readonly plural: boolean;
+    readonly selections: readonly ReaderSelection[];
+}
+
+export interface ReaderActorChange {
+    readonly kind: 'ActorChange';
+    readonly alias?: string | null | undefined;
+    readonly name: string;
+    readonly storageKey?: string | null | undefined;
+    readonly args?: readonly ReaderArgument[] | null | undefined;
+    readonly fragmentSpread: ReaderFragmentSpread;
+}
+
+export interface ReaderModuleImport {
+    readonly args?: readonly ReaderArgument[] | null | undefined;
+    readonly kind: 'ModuleImport';
+    readonly documentName: string;
+    readonly fragmentPropName: string;
+    readonly fragmentName: string;
+}
+
+export interface ReaderListValueArgument {
+    readonly kind: 'ListValue';
+    readonly name: string;
+    readonly items: ReadonlyArray<ReaderArgument | null>;
+}
+
+export interface ReaderLiteralArgument {
+    readonly kind: 'Literal';
+    readonly name: string;
+    readonly type?: string | null | undefined;
+    readonly value: any;
+}
+
+export interface ReaderLocalArgument {
+    readonly kind: 'LocalArgument';
+    readonly name: string;
+    readonly defaultValue: any;
+}
+
+export interface ReaderObjectValueArgument {
+    readonly kind: 'ObjectValue';
+    readonly name: string;
+    readonly fields: readonly ReaderArgument[];
+}
+
+export type ReaderNode = ReaderCondition | ReaderLinkedField | ReaderFragment | ReaderInlineFragment;
+
+export interface ReaderScalarField {
+    readonly kind: 'ScalarField';
+    readonly alias?: string | null | undefined;
+    readonly name: string;
+    readonly args?: readonly ReaderArgument[] | null | undefined;
+    readonly storageKey?: string | null | undefined;
+}
+
+export interface ReaderFlightField {
+    readonly kind: 'FlightField';
+    readonly alias?: string | null | undefined;
+    readonly name: string;
+    readonly args?: readonly ReaderArgument[] | null | undefined;
+    readonly storageKey: string | null | undefined;
+}
+
+export interface ReaderDefer {
+    readonly kind: 'Defer';
+    readonly selections: readonly ReaderSelection[];
+}
+
+export interface ReaderStream {
+    readonly kind: 'Stream';
+    readonly selections: readonly ReaderSelection[];
+}
+
+export type RequiredFieldAction = 'NONE' | 'LOG' | 'THROW';
+
+export interface ReaderRequiredField {
+    readonly kind: 'RequiredField';
+    readonly field: ReaderField;
+    readonly action: RequiredFieldAction;
+    readonly path: string;
+}
+
+export interface ReaderRelayResolver {
+    readonly kind: 'RelayResolver';
+    readonly alias?: string | null | undefined;
+    readonly name: string;
+    readonly fragment: ReaderFragmentSpread;
+    readonly resolverModule: (rootKey: {
+        readonly $data?: any;
+        readonly $fragmentSpreads: any;
+        readonly $fragmentRefs: any;
+    }) => any;
+}
+
+export interface ReaderClientEdge {
+    readonly kind: 'ClientEdge';
+    readonly linkedField: ReaderLinkedField;
+    readonly operation: ConcreteRequest;
+    readonly backingField: ReaderRelayResolver | ReaderClientExtension;
+}
+
+export type ReaderSelection =
+    | ReaderCondition
+    | ReaderClientEdge
+    | ReaderClientExtension
+    | ReaderDefer
+    | ReaderField
+    | ReaderActorChange
+    | ReaderFlightField
+    | ReaderFragmentSpread
+    | ReaderInlineDataFragmentSpread
+    | ReaderInlineFragment
+    | ReaderModuleImport
+    | ReaderStream
+    | ReaderRequiredField
+    | ReaderRelayResolver;
+
+export interface ReaderVariableArgument {
+    readonly kind: 'Variable';
+    readonly name: string;
+    readonly type?: string | null | undefined;
+    readonly variableName: string;
+}