relay-runtime 9.0.0 → 10.1.0

package/store/defaultRequiredFieldLogger.js.flow

@@ -0,0 +1,23 @@
+/**
+ * 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
+ */
+
+'use strict';
+
+import type {RequiredFieldLogger} from './RelayStoreTypes';
+
+const defaultRequiredFieldLogger: RequiredFieldLogger = event => {
+  if (__DEV__ && event.kind === 'missing_field.log') {
+    throw new Error(
+      'Relay Environment Configuration Error (dev only): `@required(action: LOG)` requires that the Relay Environment be configured with a `requiredFieldLogger`.',
+    );
+  }
+};
+
+module.exports = defaultRequiredFieldLogger;

package/store/hasOverlappingIDs.js.flow

@@ -0,0 +1,34 @@
+/**
+ * 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 {RecordMap, UpdatedRecords} from './RelayStoreTypes';
+
+const hasOwnProperty = Object.prototype.hasOwnProperty;
+
+function hasOverlappingIDs(
+  seenRecords: RecordMap,
+  updatedRecordIDs: UpdatedRecords,
+): boolean {
+  for (const key in seenRecords) {
+    if (
+      hasOwnProperty.call(seenRecords, key) &&
+      hasOwnProperty.call(updatedRecordIDs, key)
+    ) {
+      return true;
+    }
+  }
+  return false;
+}
+
+module.exports = hasOverlappingIDs;

package/store/isRelayModernEnvironment.js.flow

@@ -0,0 +1,27 @@
+/**
+ * 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';
+
+/**
+ * Determine if a given value is an object that implements the `Environment`
+ * interface defined in `RelayStoreTypes`.
+ *
+ * Use a sigil for detection to avoid a realm-specific instanceof check, and to
+ * aid in module tree-shaking to avoid requiring all of RelayRuntime just to
+ * detect its environment.
+ */
+function isRelayModernEnvironment(environment: mixed): boolean {
+  return Boolean(environment && (environment: any)['@@RelayModernEnvironment']);
+}
+
+module.exports = isRelayModernEnvironment;

package/store/normalizeRelayPayload.js.flow

@@ -0,0 +1,51 @@
+/**
+ * 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';
+
+const RelayModernRecord = require('./RelayModernRecord');
+const RelayRecordSource = require('./RelayRecordSource');
+const RelayResponseNormalizer = require('./RelayResponseNormalizer');
+
+const {ROOT_TYPE} = require('./RelayStoreUtils');
+
+import type {PayloadData, PayloadError} from '../network/RelayNetworkTypes';
+import type {NormalizationOptions} from './RelayResponseNormalizer';
+import type {
+  RelayResponsePayload,
+  NormalizationSelector,
+} from './RelayStoreTypes';
+
+function normalizeRelayPayload(
+  selector: NormalizationSelector,
+  payload: PayloadData,
+  errors: ?Array<PayloadError>,
+  options: NormalizationOptions,
+): RelayResponsePayload {
+  const source = RelayRecordSource.create();
+  source.set(
+    selector.dataID,
+    RelayModernRecord.create(selector.dataID, ROOT_TYPE),
+  );
+  const relayPayload = RelayResponseNormalizer.normalize(
+    source,
+    selector,
+    payload,
+    options,
+  );
+  return {
+    ...relayPayload,
+    errors,
+  };
+}
+
+module.exports = normalizeRelayPayload;

package/store/readInlineData.js.flow

@@ -0,0 +1,75 @@
+/**
+ * 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';
+
+const invariant = require('invariant');
+
+const {getInlineDataFragment} = require('../query/GraphQLTag');
+const {FRAGMENTS_KEY} = require('./RelayStoreUtils');
+
+import type {GraphQLTaggedNode} from '../query/GraphQLTag';
+import type {FragmentReference} from './RelayStoreTypes';
+
+/**
+ * Reads an @inline data fragment that was spread into the parent fragment.
+ */
+
+declare function readInlineData<
+  TRef: FragmentReference,
+  TData,
+  TKey: {
+    +$data?: TData,
+    +$fragmentRefs: TRef,
+    ...
+  },
+>(
+  fragment: GraphQLTaggedNode,
+  fragmentRef: TKey,
+): TData;
+declare function readInlineData<
+  TRef: FragmentReference,
+  TData,
+  TKey: ?{
+    +$data?: TData,
+    +$fragmentRefs: TRef,
+    ...
+  },
+>(
+  fragment: GraphQLTaggedNode,
+  fragmentRef: null | void,
+): ?TData;
+function readInlineData(
+  fragment: GraphQLTaggedNode,
+  fragmentRef: mixed,
+): mixed {
+  const inlineDataFragment = getInlineDataFragment(fragment);
+  if (fragmentRef == null) {
+    return fragmentRef;
+  }
+  invariant(
+    typeof fragmentRef === 'object',
+    'readInlineData(): Expected an object, got `%s`.',
+    typeof fragmentRef,
+  );
+  // $FlowFixMe[incompatible-use]
+  const inlineData = fragmentRef[FRAGMENTS_KEY]?.[inlineDataFragment.name];
+  invariant(
+    inlineData != null,
+    'readInlineData(): Expected fragment `%s` to be spread in the parent ' +
+      'fragment.',
+    inlineDataFragment.name,
+  );
+  return inlineData;
+}
+
+module.exports = readInlineData;

package/subscription/requestSubscription.js.flow

@@ -0,0 +1,103 @@
+/**
+ * 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';
+
+const RelayDeclarativeMutationConfig = require('../mutations/RelayDeclarativeMutationConfig');
+
+const warning = require('warning');
+
+const {getRequest} = require('../query/GraphQLTag');
+const {
+  createOperationDescriptor,
+} = require('../store/RelayModernOperationDescriptor');
+
+import type {DeclarativeMutationConfig} from '../mutations/RelayDeclarativeMutationConfig';
+import type {GraphQLTaggedNode} from '../query/GraphQLTag';
+import type {
+  IEnvironment,
+  SelectorStoreUpdater,
+} from '../store/RelayStoreTypes';
+import type {
+  CacheConfig,
+  Disposable,
+  Variables,
+} from '../util/RelayRuntimeTypes';
+
+export type GraphQLSubscriptionConfig<TSubscriptionPayload> = {|
+  configs?: Array<DeclarativeMutationConfig>,
+  cacheConfig?: CacheConfig,
+  subscription: GraphQLTaggedNode,
+  variables: Variables,
+  onCompleted?: ?() => void,
+  onError?: ?(error: Error) => void,
+  onNext?: ?(response: ?TSubscriptionPayload) => void,
+  updater?: ?SelectorStoreUpdater,
+|};
+
+function requestSubscription<TSubscriptionPayload>(
+  environment: IEnvironment,
+  config: GraphQLSubscriptionConfig<TSubscriptionPayload>,
+): Disposable {
+  const subscription = getRequest(config.subscription);
+  if (subscription.params.operationKind !== 'subscription') {
+    throw new Error('requestSubscription: Must use Subscription operation');
+  }
+  const {
+    configs,
+    onCompleted,
+    onError,
+    onNext,
+    variables,
+    cacheConfig,
+  } = config;
+  const operation = createOperationDescriptor(
+    subscription,
+    variables,
+    cacheConfig,
+  );
+
+  warning(
+    !(config.updater && configs),
+    'requestSubscription: Expected only one of `updater` and `configs` to be provided',
+  );
+
+  const {updater} = configs
+    ? RelayDeclarativeMutationConfig.convert(
+        configs,
+        subscription,
+        null /* optimisticUpdater */,
+        config.updater,
+      )
+    : config;
+
+  const sub = environment
+    .execute({
+      operation,
+      updater,
+    })
+    .map(() => {
+      const data = environment.lookup(operation.fragment).data;
+      // $FlowFixMe[incompatible-cast]
+      return (data: TSubscriptionPayload);
+    })
+    .subscribe({
+      next: onNext,
+      error: onError,
+      complete: onCompleted,
+    });
+  return {
+    dispose: sub.unsubscribe,
+  };
+}
+
+module.exports = requestSubscription;

package/util/JSResourceTypes.flow.js.flow

@@ -0,0 +1,20 @@
+/**
+ * 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.
+ *
+ * @emails oncall+relay
+ * @flow strict
+ * @format
+ */
+
+// flowlint ambiguous-object-type:error
+
+'use strict';
+
+export interface JSResourceReference<+T> {
+  +getModuleId: () => string;
+  +getModuleIfRequired: () => ?T;
+  +load: () => Promise<T>;
+}

package/util/NormalizationNode.js.flow

@@ -0,0 +1,213 @@
+/**
+ * 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 {ConcreteRequest} from './RelayConcreteNode';
+
+/**
+ * Represents a single operation used to processing and normalize runtime
+ * request results.
+ */
+export type NormalizationOperation = {|
+  +kind: 'Operation',
+  +name: string,
+  +argumentDefinitions: $ReadOnlyArray<NormalizationLocalArgumentDefinition>,
+  +selections: $ReadOnlyArray<NormalizationSelection>,
+|};
+
+export type NormalizationHandle =
+  | NormalizationScalarHandle
+  | NormalizationLinkedHandle;
+
+export type NormalizationLinkedHandle = {|
+  +kind: 'LinkedHandle',
+  +alias: ?string,
+  +name: string,
+  +args: ?$ReadOnlyArray<NormalizationArgument>,
+  +handle: string,
+  +key: string,
+  // NOTE: this property is optional because it's expected to be rarely used
+  +dynamicKey?: ?NormalizationArgument,
+  +filters: ?$ReadOnlyArray<string>,
+  +handleArgs?: $ReadOnlyArray<NormalizationArgument>,
+|};
+
+export type NormalizationScalarHandle = {|
+  +kind: 'ScalarHandle',
+  +alias: ?string,
+  +name: string,
+  +args: ?$ReadOnlyArray<NormalizationArgument>,
+  +handle: string,
+  +key: string,
+  // NOTE: this property is optional because it's expected to be rarely used
+  +dynamicKey?: ?NormalizationArgument,
+  +filters: ?$ReadOnlyArray<string>,
+  +handleArgs?: $ReadOnlyArray<NormalizationArgument>,
+|};
+
+export type NormalizationArgument =
+  | NormalizationListValueArgument
+  | NormalizationLiteralArgument
+  | NormalizationObjectValueArgument
+  | NormalizationVariableArgument;
+
+export type NormalizationCondition = {|
+  +kind: 'Condition',
+  +passingValue: boolean,
+  +condition: string,
+  +selections: $ReadOnlyArray<NormalizationSelection>,
+|};
+
+export type NormalizationClientExtension = {|
+  +kind: 'ClientExtension',
+  +selections: $ReadOnlyArray<NormalizationSelection>,
+|};
+
+export type NormalizationField =
+  | NormalizationFlightField
+  | NormalizationScalarField
+  | NormalizationLinkedField;
+
+export type NormalizationInlineFragment = {|
+  +kind: 'InlineFragment',
+  +selections: $ReadOnlyArray<NormalizationSelection>,
+  +type: string,
+  +abstractKey: ?string,
+|};
+
+export type NormalizationLinkedField = {|
+  +kind: 'LinkedField',
+  +alias: ?string,
+  +name: string,
+  +storageKey: ?string,
+  +args: ?$ReadOnlyArray<NormalizationArgument>,
+  +concreteType: ?string,
+  +plural: boolean,
+  +selections: $ReadOnlyArray<NormalizationSelection>,
+|};
+
+export type NormalizationModuleImport = {|
+  +kind: 'ModuleImport',
+  +documentName: string,
+  +fragmentPropName: string,
+  +fragmentName: string,
+|};
+
+export type NormalizationListValueArgument = {|
+  +kind: 'ListValue',
+  +name: string,
+  +items: $ReadOnlyArray<NormalizationArgument | null>,
+|};
+
+export type NormalizationLiteralArgument = {|
+  +kind: 'Literal',
+  +name: string,
+  +type?: ?string,
+  +value: mixed,
+|};
+
+export type NormalizationLocalArgumentDefinition = {|
+  +kind: 'LocalArgument',
+  +name: string,
+  +defaultValue: mixed,
+|};
+
+export type NormalizationNode =
+  | NormalizationClientExtension
+  | NormalizationCondition
+  | NormalizationDefer
+  | NormalizationInlineFragment
+  | NormalizationLinkedField
+  | NormalizationOperation
+  | NormalizationSplitOperation
+  | NormalizationStream;
+
+export type NormalizationScalarField = {|
+  +kind: 'ScalarField',
+  +alias: ?string,
+  +name: string,
+  +args: ?$ReadOnlyArray<NormalizationArgument>,
+  +storageKey: ?string,
+|};
+
+export type NormalizationFlightField = {|
+  +kind: 'FlightField',
+  +alias: ?string,
+  +name: string,
+  +args: ?$ReadOnlyArray<NormalizationArgument>,
+  +storageKey: ?string,
+|};
+
+export type NormalizationTypeDiscriminator = {|
+  +kind: 'TypeDiscriminator',
+  +abstractKey: string,
+|};
+
+export type NormalizationSelection =
+  | NormalizationCondition
+  | NormalizationClientExtension
+  | NormalizationDefer
+  | NormalizationField
+  | NormalizationFlightField
+  | NormalizationHandle
+  | NormalizationInlineFragment
+  | NormalizationModuleImport
+  | NormalizationStream
+  | NormalizationTypeDiscriminator;
+
+export type NormalizationSplitOperation = {|
+  +kind: 'SplitOperation',
+  +name: string,
+  +metadata: ?{+[key: string]: mixed, ...},
+  +selections: $ReadOnlyArray<NormalizationSelection>,
+|};
+
+export type NormalizationStream = {|
+  +if: string | null,
+  +kind: 'Stream',
+  +label: string,
+  +useCustomizedBatch: string | null,
+  +metadata: ?{+[key: string]: mixed, ...},
+  +selections: $ReadOnlyArray<NormalizationSelection>,
+|};
+
+export type NormalizationDefer = {|
+  +if: string | null,
+  +kind: 'Defer',
+  +label: string,
+  +selections: $ReadOnlyArray<NormalizationSelection>,
+|};
+
+export type NormalizationVariableArgument = {|
+  +kind: 'Variable',
+  +name: string,
+  +type?: ?string,
+  +variableName: string,
+|};
+
+export type NormalizationObjectValueArgument = {|
+  +kind: 'ObjectValue',
+  +name: string,
+  +fields: $ReadOnlyArray<NormalizationArgument>,
+|};
+
+export type NormalizationSelectableNode =
+  | NormalizationDefer
+  | NormalizationLinkedField
+  | NormalizationOperation
+  | NormalizationSplitOperation
+  | NormalizationStream;
+
+export type NormalizationRootNode =
+  | ConcreteRequest
+  | NormalizationSplitOperation;