relay-runtime 21.0.0 → 21.0.1

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;

package/util/NormalizationNode.js.flow

@@ -20,17 +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>,
   },
-  +has_server_to_client_resolvers?: boolean,
-  +use_exec_time_resolvers?: boolean,
-  +exec_time_resolvers_enabled_provider?: ProvidedVariableType,
-  +use_experimental_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 =
@@ -38,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 =
@@ -70,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 =
@@ -88,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?: () =>
+  readonly args?: ?ReadonlyArray<NormalizationArgument>,
+  readonly kind: 'ModuleImport',
+  readonly documentName: string,
+  readonly fragmentPropName: string,
+  readonly fragmentName: string,
+  readonly componentModuleProvider?: () =>
     | unknown
     | Promise<unknown>
     | JSResourceReference<unknown>,
-  +operationModuleProvider?: () =>
+  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: unknown,
+  readonly kind: 'Literal',
+  readonly name: string,
+  readonly type?: ?string,
+  readonly value: unknown,
 };
 
 export type NormalizationLocalArgumentDefinition = {
-  +kind: 'LocalArgument',
-  +name: string,
-  +defaultValue: unknown,
+  readonly kind: 'LocalArgument',
+  readonly name: string,
+  readonly defaultValue: unknown,
 };
 
 export type NormalizationNode =
@@ -162,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 =
@@ -244,38 +246,38 @@ export type NormalizationSelection =
   | NormalizationTypeDiscriminator;
 
 export type NormalizationSplitOperation = {
-  +argumentDefinitions?: ReadonlyArray<NormalizationLocalArgumentDefinition>,
-  +kind: 'SplitOperation',
-  +name: string,
-  +metadata?: ?{+[key: string]: unknown, ...},
-  +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 =