relay-runtime 9.0.0 → 10.1.0

package/util/ReaderNode.js.flow

@@ -0,0 +1,227 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict-local
+ * @format
+ */
+
+// flowlint ambiguous-object-type:error
+
+'use strict';
+
+import type {ConnectionMetadata} from '../handlers/connection/ConnectionHandler';
+import type {ConcreteRequest} from './RelayConcreteNode';
+
+export type ReaderFragmentSpread = {|
+  +kind: 'FragmentSpread',
+  +name: string,
+  +args: ?$ReadOnlyArray<ReaderArgument>,
+|};
+
+export type ReaderInlineDataFragmentSpread = {|
+  +kind: 'InlineDataFragmentSpread',
+  +name: string,
+  +selections: $ReadOnlyArray<ReaderSelection>,
+|};
+
+export type ReaderFragment = {|
+  +kind: 'Fragment',
+  +name: string,
+  +type: string,
+  +abstractKey: ?string,
+  +metadata: ?{|
+    +connection?: $ReadOnlyArray<ConnectionMetadata>,
+    +mask?: boolean,
+    +plural?: boolean,
+    +refetch?: ReaderRefetchMetadata,
+  |},
+  +argumentDefinitions: $ReadOnlyArray<ReaderArgumentDefinition>,
+  +selections: $ReadOnlyArray<ReaderSelection>,
+|};
+
+// Marker type for a @refetchable fragment
+export type ReaderRefetchableFragment = {|
+  ...ReaderFragment,
+  +metadata: {|
+    +connection?: [ConnectionMetadata],
+    +refetch: ReaderRefetchMetadata,
+  |},
+|};
+
+// Marker Type for a @refetchable fragment with a single use of @connection
+export type ReaderPaginationFragment = {|
+  ...ReaderFragment,
+  +metadata: {|
+    +connection: [ConnectionMetadata],
+    +refetch: {|
+      ...ReaderRefetchMetadata,
+      connection: ReaderPaginationMetadata,
+    |},
+  |},
+|};
+
+export type ReaderRefetchMetadata = {|
+  +connection: ?ReaderPaginationMetadata,
+  +operation: string | ConcreteRequest,
+  +fragmentPathInResult: Array<string>,
+  +identifierField?: ?string,
+|};
+
+// Stricter form of ConnectionMetadata
+export type ReaderPaginationMetadata = {|
+  +backward: {|
+    +count: string,
+    +cursor: string,
+  |} | null,
+  +forward: {|
+    +count: string,
+    +cursor: string,
+  |} | null,
+  +path: $ReadOnlyArray<string>,
+|};
+
+export type ReaderInlineDataFragment = {|
+  +kind: 'InlineDataFragment',
+  +name: string,
+|};
+
+export type ReaderArgument =
+  | ReaderListValueArgument
+  | ReaderLiteralArgument
+  | ReaderObjectValueArgument
+  | ReaderVariableArgument;
+
+export type ReaderArgumentDefinition = ReaderLocalArgument | ReaderRootArgument;
+
+export type ReaderCondition = {|
+  +kind: 'Condition',
+  +passingValue: boolean,
+  +condition: string,
+  +selections: $ReadOnlyArray<ReaderSelection>,
+|};
+
+export type ReaderClientExtension = {|
+  +kind: 'ClientExtension',
+  +selections: $ReadOnlyArray<ReaderSelection>,
+|};
+
+export type ReaderField = ReaderScalarField | ReaderLinkedField;
+
+export type ReaderRootArgument = {|
+  +kind: 'RootArgument',
+  +name: string,
+|};
+
+export type ReaderInlineFragment = {|
+  +kind: 'InlineFragment',
+  +selections: $ReadOnlyArray<ReaderSelection>,
+  +type: string,
+  +abstractKey: ?string,
+|};
+
+export type ReaderLinkedField = {|
+  +kind: 'LinkedField',
+  +alias: ?string,
+  +name: string,
+  +storageKey: ?string,
+  +args: ?$ReadOnlyArray<ReaderArgument>,
+  +concreteType: ?string,
+  +plural: boolean,
+  +selections: $ReadOnlyArray<ReaderSelection>,
+|};
+
+export type ReaderModuleImport = {|
+  +kind: 'ModuleImport',
+  +documentName: string,
+  +fragmentPropName: string,
+  +fragmentName: string,
+|};
+
+export type ReaderListValueArgument = {|
+  +kind: 'ListValue',
+  +name: string,
+  +items: $ReadOnlyArray<ReaderArgument | null>,
+|};
+
+export type ReaderLiteralArgument = {|
+  +kind: 'Literal',
+  +name: string,
+  +type?: ?string,
+  +value: mixed,
+|};
+
+export type ReaderLocalArgument = {|
+  +kind: 'LocalArgument',
+  +name: string,
+  +defaultValue: mixed,
+|};
+
+export type ReaderObjectValueArgument = {|
+  +kind: 'ObjectValue',
+  +name: string,
+  +fields: $ReadOnlyArray<ReaderArgument>,
+|};
+
+export type ReaderNode =
+  | ReaderCondition
+  | ReaderLinkedField
+  | ReaderFragment
+  | ReaderInlineFragment;
+
+export type ReaderScalarField = {|
+  +kind: 'ScalarField',
+  +alias: ?string,
+  +name: string,
+  +args: ?$ReadOnlyArray<ReaderArgument>,
+  +storageKey: ?string,
+|};
+
+export type ReaderFlightField = {|
+  +kind: 'FlightField',
+  +alias: ?string,
+  +name: string,
+  +args: ?$ReadOnlyArray<ReaderArgument>,
+  +storageKey: ?string,
+|};
+
+export type ReaderDefer = {|
+  +kind: 'Defer',
+  +selections: $ReadOnlyArray<ReaderSelection>,
+|};
+
+export type ReaderStream = {|
+  +kind: 'Stream',
+  +selections: $ReadOnlyArray<ReaderSelection>,
+|};
+
+export type RequiredFieldAction = 'NONE' | 'LOG' | 'THROW';
+
+export type ReaderRequiredField = {|
+  +kind: 'RequiredField',
+  +field: ReaderField,
+  +action: RequiredFieldAction,
+  +path: string,
+|};
+
+export type ReaderSelection =
+  | ReaderCondition
+  | ReaderClientExtension
+  | ReaderDefer
+  | ReaderField
+  | ReaderFlightField
+  | ReaderFragmentSpread
+  | ReaderInlineDataFragmentSpread
+  | ReaderInlineFragment
+  | ReaderModuleImport
+  | ReaderStream
+  | ReaderRequiredField;
+
+export type ReaderVariableArgument = {|
+  +kind: 'Variable',
+  +name: string,
+  +type?: ?string,
+  +variableName: string,
+|};

package/util/RelayConcreteNode.js.flow

@@ -0,0 +1,99 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict-local
+ * @format
+ */
+
+// flowlint ambiguous-object-type:error
+
+'use strict';
+
+import type {
+  NormalizationOperation,
+  NormalizationSplitOperation,
+} from './NormalizationNode';
+import type {ReaderFragment, ReaderInlineDataFragment} from './ReaderNode';
+
+/**
+ * Represents a common GraphQL request that can be executed, an `operation`
+ * containing information to normalize the results, and a `fragment` derived
+ * from that operation to read the response data (masking data from child
+ * fragments).
+ */
+export type ConcreteRequest = {|
+  +kind: 'Request',
+  +fragment: ReaderFragment,
+  +operation: NormalizationOperation,
+  +params: RequestParameters,
+|};
+
+export type NormalizationRootNode =
+  | ConcreteRequest
+  | NormalizationSplitOperation;
+
+/**
+ * Contains the parameters required for executing a GraphQL request.
+ * The operation can either be provided as a persisted `id` or `text`. If given
+ * in `text` format, a `cacheID` as a hash of the text should be set to be used
+ * for local caching.
+ */
+export type RequestParameters =
+  | {|
+      +id: string,
+      +text: null,
+      // common fields
+      +name: string,
+      +operationKind: 'mutation' | 'query' | 'subscription',
+      +metadata: {[key: string]: mixed, ...},
+    |}
+  | {|
+      +cacheID: string,
+      +id: null,
+      +text: string,
+      // common fields
+      +name: string,
+      +operationKind: 'mutation' | 'query' | 'subscription',
+      +metadata: {[key: string]: mixed, ...},
+    |};
+
+export type GeneratedNode =
+  | ConcreteRequest
+  | ReaderFragment
+  | ReaderInlineDataFragment
+  | NormalizationSplitOperation;
+
+const RelayConcreteNode = {
+  CONDITION: 'Condition',
+  CLIENT_EXTENSION: 'ClientExtension',
+  DEFER: 'Defer',
+  CONNECTION: 'Connection',
+  FLIGHT_FIELD: 'FlightField',
+  FRAGMENT: 'Fragment',
+  FRAGMENT_SPREAD: 'FragmentSpread',
+  INLINE_DATA_FRAGMENT_SPREAD: 'InlineDataFragmentSpread',
+  INLINE_DATA_FRAGMENT: 'InlineDataFragment',
+  INLINE_FRAGMENT: 'InlineFragment',
+  LINKED_FIELD: 'LinkedField',
+  LINKED_HANDLE: 'LinkedHandle',
+  LITERAL: 'Literal',
+  LIST_VALUE: 'ListValue',
+  LOCAL_ARGUMENT: 'LocalArgument',
+  MODULE_IMPORT: 'ModuleImport',
+  REQUIRED_FIELD: 'RequiredField',
+  OBJECT_VALUE: 'ObjectValue',
+  OPERATION: 'Operation',
+  REQUEST: 'Request',
+  ROOT_ARGUMENT: 'RootArgument',
+  SCALAR_FIELD: 'ScalarField',
+  SCALAR_HANDLE: 'ScalarHandle',
+  SPLIT_OPERATION: 'SplitOperation',
+  STREAM: 'Stream',
+  TYPE_DISCRIMINATOR: 'TypeDiscriminator',
+  VARIABLE: 'Variable',
+};
+
+module.exports = RelayConcreteNode;

package/util/RelayDefaultHandleKey.js.flow

@@ -0,0 +1,17 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict
+ * @format
+ */
+
+// flowlint ambiguous-object-type:error
+
+'use strict';
+
+module.exports = {
+  DEFAULT_HANDLE_KEY: '',
+};

package/util/RelayError.js.flow

@@ -0,0 +1,62 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow
+ * @format
+ */
+
+// flowlint ambiguous-object-type:error
+
+'use strict';
+
+/**
+ * @private
+ */
+function createError(
+  type: 'fatal' | 'error' | 'warn' | 'info',
+  name: string,
+  messageFormat: string,
+  ...messageParams: Array<string | number | boolean>
+): Error {
+  let index = 0;
+  const message = messageFormat.replace(/%s/g, () =>
+    String(messageParams[index++]),
+  );
+  const err = new Error(message);
+  const error = Object.assign((err: any), {
+    name,
+    messageFormat,
+    messageParams,
+    type,
+    taalOpcodes: [2, 2], // skip frame (code=2) twice
+  });
+  // In V8, Error objects keep the closure scope chain alive until the
+  // err.stack property is accessed.
+  if (error.stack === undefined) {
+    // IE sets the stack only if error is thrown
+    try {
+      throw error;
+    } catch {}
+  }
+  return error;
+}
+
+module.exports = {
+  create(
+    name: string,
+    messageFormat: string,
+    ...messageParams: Array<string | number | boolean>
+  ): Error {
+    return createError('error', name, messageFormat, ...messageParams);
+  },
+  createWarning(
+    name: string,
+    messageFormat: string,
+    ...messageParams: Array<string | number | boolean>
+  ): Error {
+    return createError('warn', name, messageFormat, ...messageParams);
+  },
+};

package/util/RelayFeatureFlags.js.flow

@@ -0,0 +1,37 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict
+ * @format
+ */
+
+// flowlint ambiguous-object-type:error
+
+'use strict';
+
+type FeatureFlags = {|
+  ENABLE_VARIABLE_CONNECTION_KEY: boolean,
+  ENABLE_PARTIAL_RENDERING_DEFAULT: boolean,
+  ENABLE_RELAY_CONTAINERS_SUSPENSE: boolean,
+  ENABLE_PRECISE_TYPE_REFINEMENT: boolean,
+  ENABLE_REACT_FLIGHT_COMPONENT_FIELD: boolean,
+  ENABLE_REQUIRED_DIRECTIVES: boolean | string,
+  ENABLE_GETFRAGMENTIDENTIFIER_OPTIMIZATION: boolean,
+  ENABLE_FRIENDLY_QUERY_NAME_GQL_URL: boolean,
+|};
+
+const RelayFeatureFlags: FeatureFlags = {
+  ENABLE_VARIABLE_CONNECTION_KEY: false,
+  ENABLE_PARTIAL_RENDERING_DEFAULT: false,
+  ENABLE_RELAY_CONTAINERS_SUSPENSE: false,
+  ENABLE_PRECISE_TYPE_REFINEMENT: false,
+  ENABLE_REACT_FLIGHT_COMPONENT_FIELD: false,
+  ENABLE_REQUIRED_DIRECTIVES: false,
+  ENABLE_GETFRAGMENTIDENTIFIER_OPTIMIZATION: false,
+  ENABLE_FRIENDLY_QUERY_NAME_GQL_URL: false,
+};
+
+module.exports = RelayFeatureFlags;