relay-runtime 18.2.0 → 20.0.0

package/store/createRelayContext.js.flow

@@ -12,6 +12,7 @@
 'use strict';
 
 import type {RelayContext} from './RelayStoreTypes.js';
+import type {Context} from 'react';
 import typeof {createContext} from 'react';
 
 const invariant = require('invariant');
@@ -24,10 +25,10 @@ type React = $ReadOnly<{
   ...
 }>;
 
-let relayContext: ?React$Context<RelayContext | null>;
+let relayContext: ?Context<RelayContext | null>;
 let firstReact: ?React;
 
-function createRelayContext(react: React): React$Context<RelayContext | null> {
+function createRelayContext(react: React): Context<RelayContext | null> {
   if (!relayContext) {
     relayContext = react.createContext(null);
     if (__DEV__) {

package/store/createRelayLoggingContext.js.flow

@@ -0,0 +1,46 @@
+/**
+ * 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.
+ *
+ * @flow strict-local
+ * @format
+ * @oncall relay
+ */
+
+'use strict';
+
+import type {Context} from 'react';
+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 = $ReadOnly<{
+  createContext: createContext<mixed | null>,
+  version: string,
+  ...
+}>;
+
+let relayLoggingContext: ?Context<mixed | null>;
+let firstReact: ?React;
+
+function createRelayLoggingContext(react: React): Context<mixed | null> {
+  if (!relayLoggingContext) {
+    relayLoggingContext = react.createContext(null);
+    if (__DEV__) {
+      relayLoggingContext.displayName = 'RelayLoggingContext';
+    }
+    firstReact = react;
+  }
+  invariant(
+    react === firstReact,
+    '[createRelayLoggingContext]: You are passing a different instance of React',
+    react.version,
+  );
+  return relayLoggingContext;
+}
+
+module.exports = createRelayLoggingContext;

package/store/generateTypenamePrefixedDataID.js.flow

@@ -0,0 +1,25 @@
+/**
+ * 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.
+ *
+ * @flow strict-local
+ * @format
+ * @oncall relay
+ */
+
+'use strict';
+
+import type {DataID} from 'relay-runtime/util/RelayRuntimeTypes';
+
+const TYPENAME_PREFIX = '__type:';
+
+function generateTypenamePrefixedDataID(
+  typeName: string,
+  dataID: DataID,
+): DataID {
+  return `${TYPENAME_PREFIX}${typeName}:${dataID}`;
+}
+
+module.exports = {generateTypenamePrefixedDataID};

package/store/live-resolvers/LiveResolverCache.js.flow

@@ -48,6 +48,7 @@ const {
   RELAY_RESOLVER_OUTPUT_TYPE_RECORD_IDS,
   RELAY_RESOLVER_SNAPSHOT_KEY,
   RELAY_RESOLVER_VALUE_KEY,
+  getReadTimeResolverStorageKey,
   getStorageKey,
 } = require('../RelayStoreUtils');
 const getOutputTypeRecordIDs = require('./getOutputTypeRecordIDs');
@@ -129,7 +130,7 @@ class LiveResolverCache implements ResolverCache {
     // resolvers on this parent record.
     const record = expectRecord(recordSource, recordID);
 
-    const storageKey = getStorageKey(field, variables);
+    const storageKey = getReadTimeResolverStorageKey(field, variables);
     let linkedID = RelayModernRecord.getLinkedRecordID(record, storageKey);
     let linkedRecord = linkedID == null ? null : recordSource.get(linkedID);
 
@@ -753,7 +754,8 @@ class LiveResolverCache implements ResolverCache {
           outputTypeDataID,
           variables,
         );
-
+        // LiveResolverCache is only used by read time resolvers, so this flag should be hardcoded as false.
+        const useExecTimeResolvers = false;
         const normalizationOptions =
           this._store.__getNormalizationOptions(fieldPath);
         // The resulted `source` is the normalized version of the
@@ -761,6 +763,7 @@ class LiveResolverCache implements ResolverCache {
         // All records in the `source` should have IDs that
         // is "prefix-ed" with the parent resolver record `ID`
         // and they don't expect to have a "strong" identifier.
+
         return normalize(
           source,
           selector,
@@ -770,6 +773,8 @@ class LiveResolverCache implements ResolverCache {
           // $FlowFixMe[incompatible-variance]
           value,
           normalizationOptions,
+          undefined,
+          useExecTimeResolvers,
         ).source;
       }
       // For weak models we have a simpler case. We simply need to update a

package/store/live-resolvers/resolverDataInjector.js.flow

@@ -12,12 +12,12 @@
 'use strict';
 
 import type {Fragment} from '../../util/RelayRuntimeTypes';
-import type {FragmentType} from '../RelayStoreTypes';
+import type {FragmentType, ResolverContext} from '../RelayStoreTypes';
 
 const {readFragment} = require('../ResolverFragments');
 const invariant = require('invariant');
 
-type ResolverFn = ($FlowFixMe, ?$FlowFixMe) => mixed;
+type ResolverFn = ($FlowFixMe, ?$FlowFixMe, ResolverContext) => mixed;
 
 /**
  *
@@ -40,7 +40,11 @@ function resolverDataInjector<TFragmentType: FragmentType, TData: ?{...}>(
   isRequiredField?: boolean,
 ): (fragmentKey: TFragmentType, args: mixed) => mixed {
   const resolverFn: ResolverFn = _resolverFn;
-  return (fragmentKey: TFragmentType, args: mixed): mixed => {
+  return (
+    fragmentKey: TFragmentType,
+    args: mixed,
+    resolverContext: ResolverContext,
+  ): mixed => {
     const data = readFragment(fragment, fragmentKey);
     if (fieldName != null) {
       if (data == null) {
@@ -52,7 +56,7 @@ function resolverDataInjector<TFragmentType: FragmentType, TData: ?{...}>(
             fragment.name,
           );
         } else {
-          return resolverFn(null, args);
+          return resolverFn(null, args, resolverContext); // TODO: This statement does not seem to be covered by a test?
         }
       }
 
@@ -70,7 +74,7 @@ function resolverDataInjector<TFragmentType: FragmentType, TData: ?{...}>(
         }
 
         // $FlowFixMe[invalid-computed-prop]
-        return resolverFn(data[fieldName], args);
+        return resolverFn(data[fieldName], args, resolverContext);
       } else {
         // If both `data` and `fieldName` is available, we expect the
         // `fieldName` field in the `data` object.
@@ -83,7 +87,7 @@ function resolverDataInjector<TFragmentType: FragmentType, TData: ?{...}>(
       }
     } else {
       // By default we will pass the full set of the fragment data to the resolver
-      return resolverFn(data, args);
+      return resolverFn(null, args, resolverContext); // TODO: This statement does not seem to be covered by a test?
     }
   };
 }

package/store/normalizeResponse.js.flow

@@ -27,6 +27,7 @@ function normalizeResponse(
   selector: NormalizationSelector,
   typeName: string,
   options: NormalizationOptions,
+  useExecTimeResolvers: boolean,
 ): RelayResponsePayload {
   const {data, errors} = response;
   const source = RelayRecordSource.create();
@@ -38,6 +39,7 @@ function normalizeResponse(
     data,
     options,
     errors,
+    useExecTimeResolvers,
   );
   return {
     ...relayPayload,

package/store/observeFragmentExperimental.js.flow

@@ -9,7 +9,7 @@
  * @oncall relay
  */
 
-import type {RequestDescriptor} from './RelayStoreTypes';
+import type {PluralReaderSelector, RequestDescriptor} from './RelayStoreTypes';
 import type {
   Fragment,
   FragmentType,
@@ -20,8 +20,8 @@ import type {
 } from 'relay-runtime';
 
 const Observable = require('../network/RelayObservable');
+const {getObservableForActiveRequest} = require('../query/fetchQueryInternal');
 const {getFragment} = require('../query/GraphQLTag');
-const getPendingOperationsForFragment = require('../util/getPendingOperationsForFragment');
 const {
   handlePotentialSnapshotErrors,
 } = require('../util/handlePotentialSnapshotErrors');
@@ -47,8 +47,7 @@ export type HasSpread<TFragmentType> = {
 
 /**
  * EXPERIMENTAL: This API is experimental and does not yet support all Relay
- * features. Notably, it does not correectly handle plural fragments or some
- * features of Relay Resolvers.
+ * features. Notably, it does not correctly handle some features of Relay Resolvers.
  *
  * Given a fragment and a fragment reference, returns a promise that resolves
  * once the fragment data is available, or rejects if the fragment has an error.
@@ -63,7 +62,9 @@ export type HasSpread<TFragmentType> = {
 async function waitForFragmentData<TFragmentType: FragmentType, TData>(
   environment: IEnvironment,
   fragment: Fragment<TFragmentType, TData>,
-  fragmentRef: HasSpread<TFragmentType>,
+  fragmentRef:
+    | HasSpread<TFragmentType>
+    | $ReadOnlyArray<HasSpread<TFragmentType>>,
 ): Promise<TData> {
   let subscription: ?Subscription;
 
@@ -94,13 +95,14 @@ async function waitForFragmentData<TFragmentType: FragmentType, TData>(
 declare function observeFragment<TFragmentType: FragmentType, TData>(
   environment: IEnvironment,
   fragment: Fragment<TFragmentType, TData>,
-  fragmentRef: HasSpread<TFragmentType>,
+  fragmentRef:
+    | HasSpread<TFragmentType>
+    | $ReadOnlyArray<HasSpread<TFragmentType>>,
 ): Observable<FragmentState<TData>>;
 
 /**
  * EXPERIMENTAL: This API is experimental and does not yet support all Relay
- * features. Notably, it does not correectly handle plural fragments or some
- * features of Relay Resolvers.
+ * features. Notably, it does not correctly handle some features of Relay Resolvers.
  *
  * Given a fragment and a fragment reference, returns an observable that emits
  * the state of the fragment over time. The observable will emit the following
@@ -114,7 +116,7 @@ function observeFragment<TFragmentType: FragmentType, TData>(
   environment: IEnvironment,
   fragment: Fragment<TFragmentType, TData>,
   fragmentRef: mixed,
-): Observable<FragmentState<TData>> {
+): mixed {
   const fragmentNode = getFragment(fragment);
   const fragmentSelector = getSelector(fragmentNode, fragmentRef);
   invariant(
@@ -124,24 +126,19 @@ function observeFragment<TFragmentType: FragmentType, TData>(
   invariant(fragmentSelector != null, 'Expected a selector, got null.');
   switch (fragmentSelector.kind) {
     case 'SingularReaderSelector':
-      return observeSelector(environment, fragment, fragmentSelector);
+      return observeSingularSelector(environment, fragment, fragmentSelector);
     case 'PluralReaderSelector': {
-      // TODO: We could use something like this RXJS's combineLatest to create
-      // an observable for each selector and merge them.
-      // https://github.com/ReactiveX/rxjs/blob/master/packages/rxjs/src/internal/observable/combineLatest.ts
-      //
-      // Note that this problem is a bit tricky because Relay currently only
-      // lets you subscribe at a singular fragment granularity. This makes it
-      // hard to batch updates such that when a store update causes multiple
-      // fragments to change, we can only publish a single update to the
-      // fragment owner.
-      invariant(false, 'Plural fragments are not supported');
+      return observePluralSelector(
+        environment,
+        (fragment: $FlowFixMe),
+        fragmentSelector,
+      );
     }
   }
   invariant(false, 'Unsupported fragment selector kind');
 }
 
-function observeSelector<TFragmentType: FragmentType, TData>(
+function observeSingularSelector<TFragmentType: FragmentType, TData>(
   environment: IEnvironment,
   fragmentNode: Fragment<TFragmentType, TData>,
   fragmentSelector: SingularReaderSelector,
@@ -173,6 +170,49 @@ function observeSelector<TFragmentType: FragmentType, TData>(
   });
 }
 
+function observePluralSelector<
+  TFragmentType: FragmentType,
+  TData: Array<mixed>,
+>(
+  environment: IEnvironment,
+  fragmentNode: Fragment<TFragmentType, TData>,
+  fragmentSelector: PluralReaderSelector,
+): Observable<FragmentState<TData>> {
+  const snapshots = fragmentSelector.selectors.map(selector =>
+    environment.lookup(selector),
+  );
+
+  return Observable.create(sink => {
+    // This array is mutable since each subscription updates the array in place.
+    const states = snapshots.map((snapshot, index) =>
+      snapshotToFragmentState(
+        environment,
+        fragmentNode,
+        fragmentSelector.selectors[index].owner,
+        snapshot,
+      ),
+    );
+
+    sink.next((mergeFragmentStates(states): $FlowFixMe));
+
+    const subscriptions = snapshots.map((snapshot, index) =>
+      environment.subscribe(snapshot, latestSnapshot => {
+        states[index] = snapshotToFragmentState(
+          environment,
+          fragmentNode,
+          fragmentSelector.selectors[index].owner,
+          latestSnapshot,
+        );
+        // This doesn't batch updates, so it will notify the subscriber multiple times
+        // if a store update impacting multiple items in the list is published.
+        sink.next((mergeFragmentStates(states): $FlowFixMe));
+      }),
+    );
+
+    return () => subscriptions.forEach(subscription => subscription.dispose());
+  });
+}
+
 function snapshotToFragmentState<TFragmentType: FragmentType, TData>(
   environment: IEnvironment,
   fragmentNode: Fragment<TFragmentType, TData>,
@@ -201,18 +241,18 @@ function snapshotToFragmentState<TFragmentType: FragmentType, TData>(
   }
 
   if (snapshot.isMissingData) {
-    const pendingOperations = getPendingOperationsForFragment(
-      environment,
-      fragmentNode,
-      owner,
-    );
-    if (pendingOperations != null) {
+    if (
+      getObservableForActiveRequest(environment, owner) != null ||
+      environment
+        .getOperationTracker()
+        .getPendingOperationsAffectingOwner(owner) != null
+    ) {
       return {state: 'loading'};
     }
   }
 
   try {
-    handlePotentialSnapshotErrors(environment, snapshot.errorResponseFields);
+    handlePotentialSnapshotErrors(environment, snapshot.fieldErrors);
   } catch (error) {
     return {error, state: 'error'};
   }
@@ -229,6 +269,20 @@ function snapshotToFragmentState<TFragmentType: FragmentType, TData>(
   return {state: 'ok', value: (snapshot.data: $FlowFixMe)};
 }
 
+function mergeFragmentStates<T>(
+  states: $ReadOnlyArray<FragmentState<T>>,
+): FragmentState<Array<T>> {
+  const value = [];
+  for (const state of states) {
+    if (state.state === 'ok') {
+      value.push(state.value);
+    } else {
+      return state;
+    }
+  }
+  return {state: 'ok', value};
+}
+
 module.exports = {
   observeFragment,
   waitForFragmentData,

package/store/observeQueryExperimental.js.flow

@@ -0,0 +1,61 @@
+/**
+ * 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.
+ *
+ * @flow strict-local
+ * @format
+ * @oncall relay
+ */
+
+'use strict';
+
+import type RelayObservable from '../network/RelayObservable';
+import type {FragmentState} from './observeFragmentExperimental';
+import type {OperationDescriptor} from './RelayStoreTypes';
+import type {Fragment, IEnvironment, Query, Variables} from 'relay-runtime';
+
+const {observeFragment} = require('./observeFragmentExperimental');
+const {createOperationDescriptor} = require('./RelayModernOperationDescriptor');
+
+/**
+ * This function returns an observable that can be used to subscribe to the data
+ * contained in a query. It does not return the full response shape, but rather
+ * the contents of the query body minus any fragment spreads.  If you wish to
+ * read the contents of a fragment spread into this query you may pass the
+ * object into which the fragment was spread to `observeFragment`.
+ *
+ * NOTE: `observeQuery` assumes that you have already fetched and retained the
+ * query via some other means, such as `fetchQuery`.
+ *
+ * This feature is still experimental and does not properly handle some resolver
+ * features such as client-to-server edges.
+ */
+function observeQuery<TVariables: Variables, TData>(
+  environment: IEnvironment,
+  gqlQuery: Query<TVariables, TData>,
+  variables: TVariables,
+): RelayObservable<FragmentState<TData>> {
+  const operation: OperationDescriptor = createOperationDescriptor(
+    gqlQuery,
+    variables,
+  );
+
+  const rootFragmentRef: $FlowFixMe = {
+    __id: operation.fragment.dataID,
+    __fragments: {
+      [operation.fragment.node.name]: operation.request.variables,
+    },
+    __fragmentOwner: operation.request,
+  };
+
+  const fragmentNode: Fragment<$FlowFixMe, TData> = (operation.request.node
+    .fragment: $FlowFixMe);
+
+  return observeFragment(environment, fragmentNode, rootFragmentRef);
+}
+
+module.exports = {
+  observeQuery,
+};

package/store/waitForFragmentExperimental.js.flow

@@ -21,8 +21,7 @@ const {observeFragment} = require('./observeFragmentExperimental');
 
 /**
  * EXPERIMENTAL: This API is experimental and does not yet support all Relay
- * features. Notably, it does not correectly handle plural fragments or some
- * features of Relay Resolvers.
+ * features. Notably, it does not correctly handle some features of Relay Resolvers.
  *
  * Given a fragment and a fragment reference, returns a promise that resolves
  * once the fragment data is available, or rejects if the fragment has an error.
@@ -37,7 +36,9 @@ const {observeFragment} = require('./observeFragmentExperimental');
 async function waitForFragmentData<TFragmentType: FragmentType, TData>(
   environment: IEnvironment,
   fragment: Fragment<TFragmentType, TData>,
-  fragmentRef: HasSpread<TFragmentType>,
+  fragmentRef:
+    | HasSpread<TFragmentType>
+    | $ReadOnlyArray<HasSpread<TFragmentType>>,
 ): Promise<TData> {
   let subscription: ?Subscription;
 

package/util/NormalizationNode.js.flow

@@ -12,7 +12,7 @@
 'use strict';
 
 import type {ResolverFunction, ResolverModule} from './ReaderNode';
-import type {ConcreteRequest} from './RelayConcreteNode';
+import type {ConcreteRequest, ProvidedVariableType} from './RelayConcreteNode';
 import type {JSResourceReference} from 'JSResourceReference';
 
 /**
@@ -28,6 +28,7 @@ export type NormalizationOperation = {
     +[string]: $ReadOnlyArray<string>,
   },
   +use_exec_time_resolvers?: boolean,
+  +exec_time_resolvers_enabled_provider?: ProvidedVariableType,
 };
 
 export type NormalizationHandle =

package/util/RelayConcreteNode.js.flow

@@ -39,6 +39,8 @@ export type NormalizationRootNode =
   | ConcreteRequest
   | NormalizationSplitOperation;
 
+export type ProvidedVariableType = {get(): mixed};
+
 export type ProvidedVariablesType = {+[key: string]: {get(): mixed}};
 
 /**

package/util/RelayError.js.flow

@@ -25,6 +25,7 @@ function createError(
     String(messageParams[index++]),
   );
   const err = new Error(message);
+  // $FlowFixMe[unsafe-object-assign]
   const error = Object.assign((err: any), {
     name,
     messageFormat,

package/util/RelayFeatureFlags.js.flow

@@ -26,6 +26,7 @@ export type FeatureFlags = {
   STRING_INTERN_LEVEL: number,
   LOG_MISSING_RECORDS_IN_PROD: boolean,
   ENABLE_RELAY_OPERATION_TRACKER_SUSPENSE: boolean,
+  ENABLE_UI_CONTEXT_ON_RELAY_LOGGER: boolean,
 
   // Some GraphQL servers are noncompliant with the GraphQL specification and
   // return an empty list instead of null when there is a field error on a list.
@@ -58,6 +59,27 @@ export type FeatureFlags = {
   // Adds a prefix to the storage key of read time resolvers. This is used to
   // disambiguate the same resolver being used at both read time and exec time.
   ENABLE_READ_TIME_RESOLVER_STORAGE_KEY_PREFIX: boolean,
+
+  // Enable the fix for usePaginationFragment stucking in loading state
+  ENABLE_USE_PAGINATION_IS_LOADING_FIX: boolean,
+
+  // Enable logging an ID collision in the Relay store
+  ENABLE_STORE_ID_COLLISION_LOGGING: boolean,
+
+  // Throw on nested store updates
+  DISALLOW_NESTED_UPDATES: boolean,
+
+  // Enable prefixing of DataID in the store with __typename
+  ENABLE_TYPENAME_PREFIXED_DATA_ID: boolean,
+
+  // Relay previously had a bug where it would fail to check for missing client
+  // edge to server data in fragments nested within client edge Relay Resolver
+  // fields. This feature flag fixes the behavior but comes with a perf cost.
+  // This flag is here to allow us to gradually rollout the fix and track the perf
+  // impact.
+  //
+  // See https://github.com/facebook/relay/issues/4882
+  CHECK_ALL_FRAGMENTS_FOR_MISSING_CLIENT_EDGES: boolean,
 };
 
 const RelayFeatureFlags: FeatureFlags = {
@@ -72,6 +94,7 @@ const RelayFeatureFlags: FeatureFlags = {
   MAX_DATA_ID_LENGTH: null,
   STRING_INTERN_LEVEL: 0,
   LOG_MISSING_RECORDS_IN_PROD: false,
+  ENABLE_STORE_ID_COLLISION_LOGGING: false,
   ENABLE_NONCOMPLIANT_ERROR_HANDLING_ON_LISTS: false,
   ENABLE_LOOSE_SUBSCRIPTION_ATTRIBUTION: false,
   ENABLE_OPERATION_TRACKER_OPTIMISTIC_UPDATES: false,
@@ -81,6 +104,11 @@ const RelayFeatureFlags: FeatureFlags = {
   ENABLE_CYLE_DETECTION_IN_VARIABLES: false,
   ENABLE_ACTIVITY_COMPATIBILITY: false,
   ENABLE_READ_TIME_RESOLVER_STORAGE_KEY_PREFIX: true,
+  ENABLE_USE_PAGINATION_IS_LOADING_FIX: false,
+  DISALLOW_NESTED_UPDATES: false,
+  ENABLE_TYPENAME_PREFIXED_DATA_ID: false,
+  ENABLE_UI_CONTEXT_ON_RELAY_LOGGER: false,
+  CHECK_ALL_FRAGMENTS_FOR_MISSING_CLIENT_EDGES: false,
 };
 
 module.exports = RelayFeatureFlags;

package/util/RelayRuntimeTypes.js.flow

@@ -53,9 +53,10 @@ export type VariablesOf<T: OperationType> = T['variables'];
  *   state of any configured response cache.
  * - `poll`: causes a query to live update by polling at the specified interval
  *   in milliseconds. (This value will be passed to setTimeout.)
- * - `liveConfigId`: causes a query to live update by calling GraphQLLiveQuery,
- *   it represents a configuration of gateway when doing live query
- * - `onSubscribe`: Not in use.
+ * - `liveConfigId`: Makes a query live by sending through RTI stack.
+ * - `onSubscribe`: Callback to be called when a live query stream is started.
+ * - `onPause`: Callback to be called when a live query stream is paused, e.g. due to a network disconnection.
+ * - `onResume`: Callback to be called when a live query stream is resumed, e.g. from a network disconnection.
  * - `metadata`: user-supplied metadata.
  * - `transactionId`: a user-supplied value, intended for use as a unique id for
  *   a given instance of executing an operation.
@@ -65,6 +66,8 @@ export type CacheConfig = {
   poll?: ?number,
   liveConfigId?: ?string,
   onSubscribe?: () => void,
+  onResume?: (pauseTimeMs: number) => void,
+  onPause?: (mqttConnectionIsOk: boolean, internetIsOk: boolean) => void,
   metadata?: {[key: string]: mixed, ...},
   transactionId?: ?string,
 };

package/util/getPaginationVariables.js.flow

@@ -56,6 +56,7 @@ function getPaginationVariables(
       ...baseVariables,
       ...extraVariables,
       [backwardMetadata.cursor]: cursor,
+      // $FlowFixMe[incompatible-type]
       [backwardMetadata.count]: count,
     };
     if (forwardMetadata && forwardMetadata.cursor) {
@@ -92,6 +93,7 @@ function getPaginationVariables(
     ...baseVariables,
     ...extraVariables,
     [forwardMetadata.cursor]: cursor,
+    // $FlowFixMe[incompatible-type]
     [forwardMetadata.count]: count,
   };
   if (backwardMetadata && backwardMetadata.cursor) {