relay-runtime 12.0.0 → 13.0.0-rc.0

package/store/RelayStoreSubscriptions.js.flow

@@ -12,18 +12,11 @@
 
 'use strict';
 
-const RelayFeatureFlags = require('../util/RelayFeatureFlags');
-const RelayReader = require('./RelayReader');
-
-const deepFreeze = require('../util/deepFreeze');
-const hasOverlappingIDs = require('./hasOverlappingIDs');
-const recycleNodesInto = require('../util/recycleNodesInto');
-
 import type {Disposable} from '../util/RelayRuntimeTypes';
 import type {
+  DataIDSet,
   LogFunction,
   OperationDescriptor,
-  DataIDSet,
   RecordSource,
   RequestDescriptor,
   Snapshot,
@@ -31,6 +24,12 @@ import type {
 } from './RelayStoreTypes';
 import type {ResolverCache} from './ResolverCache';
 
+const deepFreeze = require('../util/deepFreeze');
+const recycleNodesInto = require('../util/recycleNodesInto');
+const RelayFeatureFlags = require('../util/RelayFeatureFlags');
+const hasOverlappingIDs = require('./hasOverlappingIDs');
+const RelayReader = require('./RelayReader');
+
 type Subscription = {|
   callback: (snapshot: Snapshot) => void,
   snapshot: Snapshot,
@@ -102,6 +101,7 @@ class RelayStoreSubscriptions implements StoreSubscriptions {
         subscription.snapshot = {
           data: subscription.snapshot.data,
           isMissingData: backup.isMissingData,
+          missingClientEdges: backup.missingClientEdges,
           seenRecords: backup.seenRecords,
           selector: backup.selector,
           missingRequiredFields: backup.missingRequiredFields,
@@ -163,6 +163,7 @@ class RelayStoreSubscriptions implements StoreSubscriptions {
     nextSnapshot = ({
       data: nextData,
       isMissingData: nextSnapshot.isMissingData,
+      missingClientEdges: nextSnapshot.missingClientEdges,
       seenRecords: nextSnapshot.seenRecords,
       selector: nextSnapshot.selector,
       missingRequiredFields: nextSnapshot.missingRequiredFields,

package/store/RelayStoreTypes.js.flow

@@ -21,19 +21,21 @@ import type {
   INetwork,
   PayloadData,
   PayloadError,
-  ReactFlightServerTree,
   ReactFlightServerError,
+  ReactFlightServerTree,
   UploadableMap,
 } from '../network/RelayNetworkTypes';
 import type RelayObservable from '../network/RelayObservable';
+import type {GraphQLTaggedNode} from '../query/GraphQLTag';
+import type {RequestIdentifier} from '../util/getRequestIdentifier';
 import type {
+  NormalizationArgument,
   NormalizationLinkedField,
   NormalizationRootNode,
   NormalizationScalarField,
   NormalizationSelectableNode,
-  NormalizationArgument,
 } from '../util/NormalizationNode';
-import type {ReaderFragment} from '../util/ReaderNode';
+import type {ReaderClientEdge, ReaderFragment} from '../util/ReaderNode';
 import type {
   ConcreteRequest,
   RequestParameters,
@@ -42,17 +44,23 @@ import type {
   CacheConfig,
   DataID,
   Disposable,
+  OperationType,
   RenderPolicy,
   Variables,
 } from '../util/RelayRuntimeTypes';
-import type {RequestIdentifier} from '../util/getRequestIdentifier';
 import type {InvalidationState} from './RelayModernStore';
 import type RelayOperationTracker from './RelayOperationTracker';
 import type {RecordState} from './RelayRecordState';
 
-export opaque type FragmentReference = empty;
+export opaque type FragmentType = empty;
 export type OperationTracker = RelayOperationTracker;
 
+export type MutationParameters = {|
+  +response: {...},
+  +variables: interface {},
+  +rawResponse?: {...},
+|};
+
 /*
  * An individual cached graph object.
  */
@@ -74,6 +82,7 @@ export type SingularReaderSelector = {|
   +kind: 'SingularReaderSelector',
   +dataID: DataID,
   +isWithinUnmatchedTypeRefinement: boolean,
+  +clientEdgeTraversalPath: ClientEdgeTraversalPath | null,
   +node: ReaderFragment,
   +owner: RequestDescriptor,
   +variables: Variables,
@@ -112,12 +121,26 @@ export type MissingRequiredFields =
   | {|action: 'THROW', field: MissingRequiredField|}
   | {|action: 'LOG', fields: Array<MissingRequiredField>|};
 
+export type ClientEdgeTraversalInfo = {|
+  +readerClientEdge: ReaderClientEdge,
+  +clientEdgeDestinationID: DataID,
+|};
+
+export type ClientEdgeTraversalPath =
+  $ReadOnlyArray<ClientEdgeTraversalInfo | null>;
+
+export type MissingClientEdgeRequestInfo = {|
+  +request: ConcreteRequest,
+  +clientEdgeDestinationID: DataID,
+|};
+
 /**
  * A representation of a selector and its results at a particular point in time.
  */
 export type Snapshot = {|
   +data: ?SelectorData,
   +isMissingData: boolean,
+  +missingClientEdges: null | $ReadOnlyArray<MissingClientEdgeRequestInfo>,
   +seenRecords: DataIDSet,
   +selector: SingularReaderSelector,
   +missingRequiredFields: ?MissingRequiredFields,
@@ -442,6 +465,10 @@ export interface RecordSourceProxy {
   get(dataID: DataID): ?RecordProxy;
   getRoot(): RecordProxy;
   invalidateStore(): void;
+  readUpdatableQuery_EXPERIMENTAL<TQuery: OperationType>(
+    query: GraphQLTaggedNode,
+    variables: TQuery['variables'],
+  ): TQuery['response'];
 }
 
 export interface ReadOnlyRecordSourceProxy {
@@ -667,7 +694,9 @@ export interface IEnvironment {
    * Apply an optimistic mutation response and/or updater. The mutation can be
    * reverted by calling `dispose()` on the returned value.
    */
-  applyMutation(optimisticConfig: OptimisticResponseConfig): Disposable;
+  applyMutation<TMutation: MutationParameters>(
+    optimisticConfig: OptimisticResponseConfig<TMutation>,
+  ): Disposable;
 
   /**
    * Commit an updater to the environment. This mutation cannot be reverted and
@@ -716,15 +745,27 @@ export interface IEnvironment {
    * responses may be returned (via `next`) over time followed by either
    * the request completing (`completed`) or an error (`error`).
    *
+   * Note: Observables are lazy, so calling this method will do nothing until
+   * the result is subscribed to: environment.execute({...}).subscribe({...}).
+   */
+  execute(config: {|
+    operation: OperationDescriptor,
+  |}): RelayObservable<GraphQLResponse>;
+
+  /**
+   * Send a subscription to the server with Observer semantics: one or more
+   * responses may be returned (via `next`) over time followed by either
+   * the request completing (`completed`) or an error (`error`).
+   *
    * Networks/servers that support subscriptions may choose to hold the
    * subscription open indefinitely such that `complete` is not called.
    *
    * Note: Observables are lazy, so calling this method will do nothing until
-   * the result is subscribed to: environment.execute({...}).subscribe({...}).
+   * the result is subscribed to: environment.executeSubscription({...}).subscribe({...}).
    */
-  execute(config: {|
+  executeSubscription<TMutation: MutationParameters>(config: {|
     operation: OperationDescriptor,
-    updater?: ?SelectorStoreUpdater,
+    updater?: ?SelectorStoreUpdater<TMutation['response']>,
   |}): RelayObservable<GraphQLResponse>;
 
   /**
@@ -737,8 +778,8 @@ export interface IEnvironment {
    * the result is subscribed to:
    * environment.executeMutation({...}).subscribe({...}).
    */
-  executeMutation(
-    config: ExecuteMutationConfig,
+  executeMutation<TMutation: MutationParameters>(
+    config: ExecuteMutationConfig<TMutation>,
   ): RelayObservable<GraphQLResponse>;
 
   /**
@@ -785,7 +826,7 @@ export interface IEnvironment {
 export type ModuleImportPointer = {
   +__fragmentPropName: ?string,
   +__module_component: mixed,
-  +$fragmentRefs: mixed,
+  +$fragmentSpreads: mixed,
   ...
 };
 
@@ -954,35 +995,33 @@ export type StoreUpdater = (store: RecordSourceProxy) => void;
  * order to easily access the root fields of a query/mutation as well as a
  * second argument of the response object of the mutation.
  */
-export type SelectorStoreUpdater = (
+export type SelectorStoreUpdater<-TMutationResponse> = (
   store: RecordSourceSelectorProxy,
-  // Actually SelectorData, but mixed is inconvenient to access deeply in
-  // product code.
-  data: $FlowFixMe,
+  data: ?TMutationResponse,
 ) => void;
 
 /**
  * A set of configs that can be used to apply an optimistic update into the
  * store.
  */
-export type OptimisticUpdate =
+export type OptimisticUpdate<TMutation: MutationParameters> =
   | OptimisticUpdateFunction
-  | OptimisticUpdateRelayPayload;
+  | OptimisticUpdateRelayPayload<TMutation>;
 
 export type OptimisticUpdateFunction = {|
   +storeUpdater: StoreUpdater,
 |};
 
-export type OptimisticUpdateRelayPayload = {|
+export type OptimisticUpdateRelayPayload<TMutation: MutationParameters> = {|
   +operation: OperationDescriptor,
   +payload: RelayResponsePayload,
-  +updater: ?SelectorStoreUpdater,
+  +updater: ?SelectorStoreUpdater<TMutation['response']>,
 |};
 
-export type OptimisticResponseConfig = {|
+export type OptimisticResponseConfig<TMutation: MutationParameters> = {|
   +operation: OperationDescriptor,
   +response: ?PayloadData,
-  +updater: ?SelectorStoreUpdater,
+  +updater: ?SelectorStoreUpdater<TMutation['response']>,
 |};
 
 /**
@@ -1050,11 +1089,11 @@ export type RelayResponsePayload = {|
 /**
  * Configuration on the executeMutation(...).
  */
-export type ExecuteMutationConfig = {|
+export type ExecuteMutationConfig<TMutation: MutationParameters> = {|
   operation: OperationDescriptor,
-  optimisticUpdater?: ?SelectorStoreUpdater,
+  optimisticUpdater?: ?SelectorStoreUpdater<TMutation['response']>,
   optimisticResponse?: ?Object,
-  updater?: ?SelectorStoreUpdater,
+  updater?: ?SelectorStoreUpdater<TMutation['response']>,
   uploadables?: ?UploadableMap,
 |};
 
@@ -1065,12 +1104,16 @@ export interface PublishQueue {
   /**
    * Schedule applying an optimistic updates on the next `run()`.
    */
-  applyUpdate(updater: OptimisticUpdate): void;
+  applyUpdate<TMutation: MutationParameters>(
+    updater: OptimisticUpdate<TMutation>,
+  ): void;
 
   /**
    * Schedule reverting an optimistic updates on the next `run()`.
    */
-  revertUpdate(updater: OptimisticUpdate): void;
+  revertUpdate<TMutation: MutationParameters>(
+    updater: OptimisticUpdate<TMutation>,
+  ): void;
 
   /**
    * Schedule a revert of all optimistic updates on the next `run()`.
@@ -1080,10 +1123,10 @@ export interface PublishQueue {
   /**
    * Schedule applying a payload to the store on the next `run()`.
    */
-  commitPayload(
+  commitPayload<TMutation: MutationParameters>(
     operation: OperationDescriptor,
     payload: RelayResponsePayload,
-    updater?: ?SelectorStoreUpdater,
+    updater?: ?SelectorStoreUpdater<TMutation['response']>,
   ): void;
 
   /**

package/store/RelayStoreUtils.js.flow

@@ -12,24 +12,23 @@
 
 'use strict';
 
-const RelayConcreteNode = require('../util/RelayConcreteNode');
-
-const getRelayHandleKey = require('../util/getRelayHandleKey');
-const invariant = require('invariant');
-const stableCopy = require('../util/stableCopy');
-
 import type {
-  NormalizationHandle,
   NormalizationArgument,
   NormalizationField,
+  NormalizationHandle,
 } from '../util/NormalizationNode';
 import type {
+  ReaderActorChange,
   ReaderArgument,
   ReaderField,
-  ReaderActorChange,
 } from '../util/ReaderNode';
 import type {Variables} from '../util/RelayRuntimeTypes';
 
+const getRelayHandleKey = require('../util/getRelayHandleKey');
+const RelayConcreteNode = require('../util/RelayConcreteNode');
+const stableCopy = require('../util/stableCopy');
+const invariant = require('invariant');
+
 export type Arguments = interface {+[string]: mixed};
 
 const {VARIABLE, LITERAL, OBJECT_VALUE, LIST_VALUE} = RelayConcreteNode;
@@ -187,7 +186,6 @@ function getStableVariableValue(name: string, variables: Variables): mixed {
     'getVariableValue(): Undefined variable `%s`.',
     name,
   );
-  // $FlowFixMe[cannot-write]
   return stableCopy(variables[name]);
 }
 
@@ -204,6 +202,7 @@ function getModuleOperationKey(documentName: string): string {
  */
 const RelayStoreUtils = {
   ACTOR_IDENTIFIER_KEY: '__actorIdentifier',
+  CLIENT_EDGE_TRAVERSAL_PATH: '__clientEdgeTraversalPath',
   FRAGMENTS_KEY: '__fragments',
   FRAGMENT_OWNER_KEY: '__fragmentOwner',
   FRAGMENT_PROP_NAME_KEY: '__fragmentPropName',

package/store/ResolverCache.js.flow

@@ -12,27 +12,25 @@
 
 'use strict';
 
-const RelayModernRecord = require('./RelayModernRecord');
+import type {ReaderRelayResolver} from '../util/ReaderNode';
+import type {DataID, Variables} from '../util/RelayRuntimeTypes';
+import type {
+  MutableRecordSource,
+  Record,
+  SingularReaderSelector,
+} from './RelayStoreTypes';
 
 const recycleNodesInto = require('../util/recycleNodesInto');
-const warning = require('warning');
-
 const {generateClientID} = require('./ClientID');
+const RelayModernRecord = require('./RelayModernRecord');
 const {
-  RELAY_RESOLVER_VALUE_KEY,
-  RELAY_RESOLVER_INVALIDATION_KEY,
   RELAY_RESOLVER_INPUTS_KEY,
+  RELAY_RESOLVER_INVALIDATION_KEY,
   RELAY_RESOLVER_READER_SELECTOR_KEY,
+  RELAY_RESOLVER_VALUE_KEY,
   getStorageKey,
 } = require('./RelayStoreUtils');
-
-import type {ReaderRelayResolver} from '../util/ReaderNode';
-import type {DataID, Variables} from '../util/RelayRuntimeTypes';
-import type {
-  MutableRecordSource,
-  Record,
-  SingularReaderSelector,
-} from './RelayStoreTypes';
+const warning = require('warning');
 
 type ResolverID = string;
 
@@ -73,7 +71,11 @@ class NoopResolverCache implements ResolverCache {
   invalidateDataIDs(updatedDataIDs: Set<DataID>): void {}
 }
 
-function addDependencyEdge(edges, from, to): void {
+function addDependencyEdge(
+  edges: Map<ResolverID, Set<DataID>> | Map<DataID, Set<ResolverID>>,
+  from: ResolverID | DataID,
+  to: ResolverID | DataID,
+): void {
   let set = edges.get(from);
   if (!set) {
     set = new Set();

package/store/ResolverFragments.js.flow

@@ -12,26 +12,19 @@
 
 'use strict';
 
-const invariant = require('invariant');
+import type {GraphQLTaggedNode} from '../query/GraphQLTag';
+import type {FragmentType, SingularReaderSelector} from './RelayStoreTypes';
 
 const {getFragment} = require('../query/GraphQLTag');
 const {getSelector} = require('./RelayModernSelector');
-
-import type {GraphQLTaggedNode} from '../query/GraphQLTag';
-import type {
-  FragmentReference,
-  SingularReaderSelector,
-} from './RelayStoreTypes';
+const invariant = require('invariant');
 
 // When we call the user-supplied resolver function, it will in turn call
 // `readFragment`, but that's a global function -- it needs information
 // about what resolver is being executed, which is supplied by putting the
 // info on this stack before we call the resolver function.
 type ResolverContext = {|
-  getDataForResolverFragment: (
-    SingularReaderSelector,
-    FragmentReference,
-  ) => mixed,
+  getDataForResolverFragment: (SingularReaderSelector, FragmentType) => mixed,
 |};
 const contextStack: Array<ResolverContext> = [];
 
@@ -54,17 +47,17 @@ function withResolverContext<T>(context: ResolverContext, cb: () => T): T {
 //   - array of nullable if the privoided ref type is an array of nullable refs
 
 declare function readFragment<
-  TKey: {+$data?: mixed, +$fragmentRefs: FragmentReference, ...},
+  TKey: {+$data?: mixed, +$fragmentSpreads: FragmentType, ...},
 >(
   fragmentInput: GraphQLTaggedNode,
-  fragmentRef: TKey,
+  fragmentKey: TKey,
 ): $Call<<TFragmentData>({+$data?: TFragmentData, ...}) => TFragmentData, TKey>;
 
 declare function readFragment<
-  TKey: ?{+$data?: mixed, +$fragmentRefs: FragmentReference, ...},
+  TKey: ?{+$data?: mixed, +$fragmentSpreads: FragmentType, ...},
 >(
   fragmentInput: GraphQLTaggedNode,
-  fragmentRef: TKey,
+  fragmentKey: TKey,
 ): $Call<
   <TFragmentData>(?{+$data?: TFragmentData, ...}) => ?TFragmentData,
   TKey,
@@ -73,12 +66,12 @@ declare function readFragment<
 declare function readFragment<
   TKey: $ReadOnlyArray<{
     +$data?: mixed,
-    +$fragmentRefs: FragmentReference,
+    +$fragmentSpreads: FragmentType,
     ...
   }>,
 >(
   fragmentInput: GraphQLTaggedNode,
-  fragmentRef: TKey,
+  fragmentKey: TKey,
 ): $Call<
   <TFragmentData>(
     $ReadOnlyArray<{+$data?: TFragmentData, ...}>,
@@ -89,12 +82,12 @@ declare function readFragment<
 declare function readFragment<
   TKey: ?$ReadOnlyArray<{
     +$data?: mixed,
-    +$fragmentRefs: FragmentReference,
+    +$fragmentSpreads: FragmentType,
     ...
   }>,
 >(
   fragmentInput: GraphQLTaggedNode,
-  fragmentRef: TKey,
+  fragmentKey: TKey,
 ): $Call<
   <TFragmentData>(
     ?$ReadOnlyArray<{+$data?: TFragmentData, ...}>,
@@ -104,7 +97,7 @@ declare function readFragment<
 
 function readFragment(
   fragmentInput: GraphQLTaggedNode,
-  fragmentRef: FragmentReference,
+  fragmentKey: FragmentType,
 ): mixed {
   if (!contextStack.length) {
     throw new Error(
@@ -113,7 +106,7 @@ function readFragment(
   }
   const context = contextStack[contextStack.length - 1];
   const fragmentNode = getFragment(fragmentInput);
-  const fragmentSelector = getSelector(fragmentNode, fragmentRef);
+  const fragmentSelector = getSelector(fragmentNode, fragmentKey);
   invariant(
     fragmentSelector != null,
     `Expected a selector for the fragment of the resolver ${fragmentNode.name}, but got null.`,
@@ -122,7 +115,7 @@ function readFragment(
     fragmentSelector.kind === 'SingularReaderSelector',
     `Expected a singular reader selector for the fragment of the resolver ${fragmentNode.name}, but it was plural.`,
   );
-  return context.getDataForResolverFragment(fragmentSelector, fragmentRef);
+  return context.getDataForResolverFragment(fragmentSelector, fragmentKey);
 }
 
 module.exports = {readFragment, withResolverContext};

package/store/StoreInspector.js.flow

@@ -56,7 +56,7 @@ if (__DEV__) {
     const keyStyle = {style: 'rgb(136, 19, 145)'};
     const nullStyle = {style: 'color: #777'};
 
-    const reference = (object, config) => {
+    const reference = (object, config: void) => {
       return object == null
         ? ['span', nullStyle, 'undefined']
         : ['object', {object, config}];
@@ -100,7 +100,7 @@ if (__DEV__) {
         }
         return renderRecordHeader(obj);
       },
-      hasBody(obj) {
+      hasBody(obj: $FlowFixMe) {
         return true;
       },
       body(obj) {

package/store/TypeID.js.flow

@@ -4,7 +4,7 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @flow strict
+ * @flow strict-local
  * @format
  */
 

package/store/ViewerPattern.js.flow

@@ -12,11 +12,11 @@
 
 'use strict';
 
+import type {DataID} from '../util/RelayRuntimeTypes';
+
 const {generateClientID} = require('./ClientID');
 const {ROOT_ID} = require('./RelayStoreUtils');
 
-import type {DataID} from 'relay-runtime/util/RelayRuntimeTypes';
-
 const VIEWER_ID: DataID = generateClientID(ROOT_ID, 'viewer');
 const VIEWER_TYPE = 'Viewer';
 

package/store/cloneRelayHandleSourceField.js.flow

@@ -12,12 +12,6 @@
 
 'use strict';
 
-const areEqual = require('areEqual');
-const invariant = require('invariant');
-
-const {LINKED_FIELD} = require('../util/RelayConcreteNode');
-const {getHandleStorageKey} = require('./RelayStoreUtils');
-
 import type {
   NormalizationLinkedField,
   NormalizationSelection,
@@ -25,6 +19,11 @@ import type {
 import type {NormalizationLinkedHandle} from '../util/NormalizationNode';
 import type {Variables} from '../util/RelayRuntimeTypes';
 
+const {LINKED_FIELD} = require('../util/RelayConcreteNode');
+const {getHandleStorageKey} = require('./RelayStoreUtils');
+const areEqual = require('areEqual');
+const invariant = require('invariant');
+
 /**
  * @private
  *

package/store/cloneRelayScalarHandleSourceField.js.flow

@@ -12,12 +12,6 @@
 
 'use strict';
 
-const areEqual = require('areEqual');
-const invariant = require('invariant');
-
-const {SCALAR_FIELD} = require('../util/RelayConcreteNode');
-const {getHandleStorageKey} = require('./RelayStoreUtils');
-
 import type {
   NormalizationScalarField,
   NormalizationSelection,
@@ -25,6 +19,11 @@ import type {
 import type {NormalizationScalarHandle} from '../util/NormalizationNode';
 import type {Variables} from '../util/RelayRuntimeTypes';
 
+const {SCALAR_FIELD} = require('../util/RelayConcreteNode');
+const {getHandleStorageKey} = require('./RelayStoreUtils');
+const areEqual = require('areEqual');
+const invariant = require('invariant');
+
 /**
  * @private
  *

package/store/createFragmentSpecResolver.js.flow

@@ -12,10 +12,6 @@
 
 'use strict';
 
-const RelayModernFragmentSpecResolver = require('./RelayModernFragmentSpecResolver');
-
-const warning = require('warning');
-
 import type {
   FragmentMap,
   FragmentSpecResolver,
@@ -23,6 +19,9 @@ import type {
   RelayContext,
 } from './RelayStoreTypes';
 
+const RelayModernFragmentSpecResolver = require('./RelayModernFragmentSpecResolver');
+const warning = require('warning');
+
 function createFragmentSpecResolver(
   context: RelayContext,
   containerName: string,

package/store/createRelayContext.js.flow

@@ -12,11 +12,11 @@
 
 'use strict';
 
-const invariant = require('invariant');
-
 import type {RelayContext} from './RelayStoreTypes.js';
 import typeof {createContext} from 'react';
 
+const invariant = require('invariant');
+
 // Ideally, we'd just import the type of the react module, but this causes Flow
 // problems.
 type React = {

package/store/normalizeRelayPayload.js.flow

@@ -12,19 +12,18 @@
 
 '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,
+  RelayResponsePayload,
 } from './RelayStoreTypes';
 
+const RelayModernRecord = require('./RelayModernRecord');
+const RelayRecordSource = require('./RelayRecordSource');
+const RelayResponseNormalizer = require('./RelayResponseNormalizer');
+const {ROOT_TYPE} = require('./RelayStoreUtils');
+
 function normalizeRelayPayload(
   selector: NormalizationSelector,
   payload: PayloadData,