relay-runtime 20.1.1 → 21.0.1

package/util/RelayError.d.ts

@@ -0,0 +1,13 @@
+/**
+ * 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.
+ */
+
+declare const RelayError: {
+    create(name: string, messageFormat: string, ...messageParams: Array<string | number | boolean>): Error;
+    createWarning(name: string, messageFormat: string, ...messageParams: Array<string | number | boolean>): Error;
+};
+
+export default RelayError;

package/util/RelayError.js.flow

@@ -25,12 +25,15 @@ function createError(
     String(messageParams[index++]),
   );
   const err = new Error(message);
+  // messageParams[2] is the operation name
+  const operation = messageParams[2] ?? null;
   // $FlowFixMe[unsafe-object-assign]
-  const error = Object.assign((err: any), {
+  const error = Object.assign(err as any, {
     name,
     messageFormat,
     messageParams,
     type,
+    operation,
     taalOpcodes: [2, 2], // skip frame (code=2) twice
   });
   // In V8, Error objects keep the closure scope chain alive until the

package/util/RelayFeatureFlags.d.ts

@@ -0,0 +1,40 @@
+/**
+ * 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 { Disposable } from './RelayRuntimeTypes';
+
+export interface FeatureFlags {
+    ENABLE_VARIABLE_CONNECTION_KEY: boolean;
+    ENABLE_RELAY_RESOLVERS: boolean;
+    ENABLE_GETFRAGMENTIDENTIFIER_OPTIMIZATION: boolean;
+    ENABLE_FRIENDLY_QUERY_NAME_GQL_URL: boolean;
+    ENABLE_DO_NOT_WRAP_LIVE_QUERY: boolean;
+    ENABLE_NOTIFY_SUBSCRIPTION: boolean;
+    BATCH_ASYNC_MODULE_UPDATES_FN: null | undefined | ((callback: () => void) => Disposable);
+    ENABLE_CONTAINERS_SUBSCRIBE_ON_COMMIT: boolean;
+    MAX_DATA_ID_LENGTH: number | null | undefined;
+    STRING_INTERN_LEVEL: number;
+    LOG_MISSING_RECORDS_IN_PROD: boolean;
+    ENABLE_RELAY_OPERATION_TRACKER_SUSPENSE: boolean;
+    ENABLE_UI_CONTEXT_ON_RELAY_LOGGER: boolean;
+    ENABLE_NONCOMPLIANT_ERROR_HANDLING_ON_LISTS: boolean;
+    ENABLE_LOOSE_SUBSCRIPTION_ATTRIBUTION: boolean;
+    ENABLE_OPERATION_TRACKER_OPTIMISTIC_UPDATES: boolean;
+    PROCESS_OPTIMISTIC_UPDATE_BEFORE_SUBSCRIPTION: boolean;
+    MARK_RESOLVER_VALUES_AS_CLEAN_AFTER_FRAGMENT_REREAD: boolean;
+    ENABLE_CYLE_DETECTION_IN_VARIABLES: boolean;
+    ENABLE_ACTIVITY_COMPATIBILITY: boolean;
+    ENABLE_READ_TIME_RESOLVER_STORAGE_KEY_PREFIX: boolean;
+    ENABLE_USE_PAGINATION_IS_LOADING_FIX: boolean;
+    ENABLE_STORE_ID_COLLISION_LOGGING: boolean;
+    DISALLOW_NESTED_UPDATES: boolean;
+    ENABLE_TYPENAME_PREFIXED_DATA_ID: boolean;
+    CHECK_ALL_FRAGMENTS_FOR_MISSING_CLIENT_EDGES: boolean;
+    ENABLE_READER_FRAGMENTS_LOGGING: boolean;
+}
+
+export const RelayFeatureFlags: FeatureFlags;

package/util/RelayFeatureFlags.js.flow

@@ -80,6 +80,22 @@ export type FeatureFlags = {
   //
   // See https://github.com/facebook/relay/issues/4882
   CHECK_ALL_FRAGMENTS_FOR_MISSING_CLIENT_EDGES: boolean,
+
+  // When enabled, records created for Relay Resolvers will be filtered out
+  // from the store when serializing to JSON.
+  FILTER_OUT_RELAY_RESOLVER_RECORDS: boolean,
+
+  // Reduce the work on store.notify
+  OPTIMIZE_NOTIFY: boolean,
+
+  // Enable per-field subscription granularity on specific records (e.g. client:root).
+  // When enabled, subscriptions reading a field-granular record are only notified
+  // when the specific fields they read have changed, rather than on any change
+  // to the record.
+  ENABLE_FIELD_GRANULAR_NOTIFICATIONS: boolean,
+
+  // Enable logging for reader reading fragment spreads and fragments. Useful for logging unused fragments.
+  ENABLE_READER_FRAGMENTS_LOGGING: boolean,
 };
 
 const RelayFeatureFlags: FeatureFlags = {
@@ -102,13 +118,17 @@ const RelayFeatureFlags: FeatureFlags = {
   PROCESS_OPTIMISTIC_UPDATE_BEFORE_SUBSCRIPTION: false,
   MARK_RESOLVER_VALUES_AS_CLEAN_AFTER_FRAGMENT_REREAD: false,
   ENABLE_CYLE_DETECTION_IN_VARIABLES: false,
-  ENABLE_ACTIVITY_COMPATIBILITY: false,
+  ENABLE_ACTIVITY_COMPATIBILITY: true,
   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,
+  FILTER_OUT_RELAY_RESOLVER_RECORDS: false,
+  OPTIMIZE_NOTIFY: false,
+  ENABLE_FIELD_GRANULAR_NOTIFICATIONS: false,
+  ENABLE_READER_FRAGMENTS_LOGGING: false,
 };
 
 module.exports = RelayFeatureFlags;

package/util/RelayProfiler.d.ts

@@ -0,0 +1,121 @@
+/**
+ * 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.
+ */
+
+export type Handler = (name: string, callback: () => void) => void;
+export type ProfileHandler = (name: string, state?: any) => (error?: Error) => void;
+
+/**
+ * Instruments methods to allow profiling various parts of Relay. Profiling code
+ * in Relay consists of three steps:
+ *
+ *  - Instrument the function to be profiled.
+ *  - Attach handlers to the instrumented function.
+ *  - Run the code which triggers the handlers.
+ *
+ * Handlers attached to instrumented methods are called with an instrumentation
+ * name and a callback that must be synchronously executed:
+ *
+ *   instrumentedMethod.attachHandler(function(name, callback) {
+ *     const start = performance.now();
+ *     callback();
+ *     console.log('Duration', performance.now() - start);
+ *   });
+ *
+ * Handlers for profiles are callbacks that return a stop method:
+ *
+ *   RelayProfiler.attachProfileHandler('profileName', (name, state) => {
+ *     const start = performance.now();
+ *     return function stop(name, state) {
+ *       console.log(`Duration (${name})`, performance.now() - start);
+ *     }
+ *   });
+ *
+ * In order to reduce the impact on performance in production, instrumented
+ * methods and profilers with names that begin with `@` will only be measured
+ * if `__DEV__` is true. This should be used for very hot functions.
+ */
+
+export const RelayProfiler: {
+    /**
+     * Instruments methods on a class or object. This re-assigns the method in
+     * order to preserve function names in stack traces (which are detected by
+     * modern debuggers via heuristics). Example usage:
+     *
+     *   const RelayStore = { primeCache: function() {...} };
+     *   RelayProfiler.instrumentMethods(RelayStore, {
+     *     primeCache: 'RelayStore.primeCache'
+     *   });
+     *
+     *   RelayStore.primeCache.attachHandler(...);
+     *
+     * As a result, the methods will be replaced by wrappers that provide the
+     * `attachHandler` and `detachHandler` methods.
+     */
+    instrumentMethods(object: () => void | object, names: { [key: string]: string }): void;
+
+    /**
+     * Wraps the supplied function with one that provides the `attachHandler` and
+     * `detachHandler` methods. Example usage:
+     *
+     *   const printRelayQuery =
+     *     RelayProfiler.instrument('printRelayQuery', printRelayQuery);
+     *
+     *   printRelayQuery.attachHandler(...);
+     *
+     * NOTE: The instrumentation assumes that no handlers are attached or detached
+     * in the course of executing another handler.
+     */
+    instrument<T extends () => void>(name: string, originalFunction: T): T;
+
+    /**
+     * Attaches a handler to all methods instrumented with the supplied name.
+     *
+     *   function createRenderer() {
+     *     return RelayProfiler.instrument('render', function() {...});
+     *   }
+     *   const renderA = createRenderer();
+     *   const renderB = createRenderer();
+     *
+     *   // Only profiles `renderA`.
+     *   renderA.attachHandler(...);
+     *
+     *   // Profiles both `renderA` and `renderB`.
+     *   RelayProfiler.attachAggregateHandler('render', ...);
+     */
+    attachAggregateHandler(name: string, handler: Handler): void;
+
+    /**
+     * Detaches a handler attached via `attachAggregateHandler`.
+     */
+    detachAggregateHandler(name: string, handler: Handler): void;
+
+    /**
+     * Instruments profiling for arbitrarily asynchronous code by a name.
+     *
+     *   const timerProfiler = RelayProfiler.profile('timeout');
+     *   setTimeout(function() {
+     *     timerProfiler.stop();
+     *   }, 1000);
+     *
+     *   RelayProfiler.attachProfileHandler('timeout', ...);
+     *
+     * Arbitrary state can also be passed into `profile` as a second argument. The
+     * attached profile handlers will receive this as the second argument.
+     */
+    profile(name: string, state?: any): { stop: (error?: Error) => void };
+
+    /**
+     * Attaches a handler to profiles with the supplied name. You can also
+     * attach to the special name '*' which is a catch all.
+     */
+    attachProfileHandler(name: string, handler: ProfileHandler): void;
+
+    /**
+     * Detaches a handler attached via `attachProfileHandler`.
+     */
+    detachProfileHandler(name: string, handler: ProfileHandler): void;
+};

package/util/RelayProfiler.js.flow

@@ -18,7 +18,7 @@ const profileHandlersByName: {
   [name: EventName]: Array<ProfileHandler>,
 } = {};
 
-const defaultProfiler = {
+const defaultProfiler: {stop: (error?: Error) => void, ...} = {
   stop() {},
 };
 

package/util/RelayReplaySubject.d.ts

@@ -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.
+ */
+
+import type {Observer, Sink, Subscription} from '../network/RelayObservable';
+
+export type Event<T> = { kind: 'next'; data: T } | { kind: 'error'; error: Error } | { kind: 'complete' };
+
+/**
+ * An implementation of a `ReplaySubject` for Relay Observables.
+ *
+ * Records events provided and synchronously plays them back to new subscribers,
+ * as well as forwarding new asynchronous events.
+ */
+export class RelayReplaySubject<T> {
+    complete(): void;
+    error(error: Error): void;
+    next(data: T): void;
+    subscribe(observer: Observer<T> | Sink<T>): Subscription;
+    unsubscribe(): void;
+    getObserverCount(): number;
+}

package/util/RelayReplaySubject.js.flow

@@ -64,7 +64,7 @@ class RelayReplaySubject<T> {
             sink.next(event.data);
             break;
           default:
-            (event.kind: empty);
+            event.kind as empty;
             invariant(
               false,
               'RelayReplaySubject: Unknown event kind `%s`.',
@@ -96,8 +96,8 @@ class RelayReplaySubject<T> {
     }
     this._complete = true;
     this._events.push({
-      kind: 'error',
       error,
+      kind: 'error',
     });
     this._sinks.forEach(sink => sink.error(error));
   }
@@ -107,8 +107,8 @@ class RelayReplaySubject<T> {
       return;
     }
     this._events.push({
-      kind: 'next',
       data,
+      kind: 'next',
     });
     this._sinks.forEach(sink => sink.next(data));
   }

package/util/RelayRuntimeTypes.d.ts

@@ -0,0 +1,59 @@
+/**
+ * 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.
+ */
+
+/**
+ * Represents any resource that must be explicitly disposed of. The most common
+ * use-case is as a return value for subscriptions, where calling `dispose()`
+ * would cancel the subscription.
+ */
+export interface Disposable {
+    dispose: DisposeFn;
+}
+
+export type DataID = string;
+
+export interface Variables {
+    [name: string]: any;
+}
+
+export interface OperationType {
+    readonly variables: Variables;
+    readonly response: unknown;
+    readonly rawResponse?: unknown | undefined;
+}
+
+export type VariablesOf<TQuery extends OperationType> = TQuery['variables'];
+
+export type DisposeFn = () => void;
+
+/**
+ * Settings for how a query response may be cached.
+ *
+ * - `force`: causes a query to be issued unconditionally, irrespective of the
+ *   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
+ * - `metadata`: user-supplied metadata.
+ * - `transactionId`: a user-supplied value, intended for use as a unique id for
+ *   a given instance of executing an operation.
+ */
+export interface CacheConfig {
+    force?: boolean | null | undefined;
+    poll?: number | null | undefined;
+    liveConfigId?: string | null | undefined;
+    metadata?: { [key: string]: unknown } | undefined;
+    transactionId?: string | null | undefined;
+}
+
+/**
+ * Experimental
+ */
+export type FetchQueryFetchPolicy = 'store-or-network' | 'network-only';
+export type FetchPolicy = FetchQueryFetchPolicy | 'store-and-network' | 'store-only';
+export type RenderPolicy = 'full' | 'partial';

package/util/RelayRuntimeTypes.js.flow

@@ -32,19 +32,19 @@ export type Disposable = interface {dispose(): void};
 export type DataID = string;
 
 // Variables
-export type Variables = {+[string]: $FlowFixMe};
+export type Variables = {readonly [string]: $FlowFixMe};
 
 /**
  * Generated operation flow types are subtypes of this.
  */
 export type OperationType = {
   // TODO(T33395812) Make this an open object type
-  +variables: Variables,
-  +response: mixed,
-  +rawResponse?: {...},
+  readonly variables: Variables,
+  readonly response: unknown,
+  readonly rawResponse?: {...},
 };
 
-export type VariablesOf<T: OperationType> = T['variables'];
+export type VariablesOf<T extends OperationType> = T['variables'];
 
 /**
  * Settings for how a query response may be cached.
@@ -62,14 +62,17 @@ export type VariablesOf<T: OperationType> = T['variables'];
  *   a given instance of executing an operation.
  */
 export type CacheConfig = {
-  +force?: ?boolean,
-  +poll?: ?number,
-  +liveConfigId?: ?string,
-  +onSubscribe?: () => void,
-  +onResume?: (pauseTimeMs: number) => void,
-  +onPause?: (mqttConnectionIsOk: boolean, internetIsOk: boolean) => void,
-  +metadata?: {+[key: string]: mixed, ...},
-  +transactionId?: ?string,
+  readonly force?: ?boolean,
+  readonly poll?: ?number,
+  readonly liveConfigId?: ?string,
+  readonly onSubscribe?: () => void,
+  readonly onResume?: (pauseTimeMs: number) => void,
+  readonly onPause?: (
+    mqttConnectionIsOk: boolean,
+    internetIsOk: boolean,
+  ) => void,
+  readonly metadata?: {readonly [key: string]: unknown, ...},
+  readonly transactionId?: ?string,
 };
 
 export type FetchQueryFetchPolicy = 'store-or-network' | 'network-only';
@@ -86,8 +89,8 @@ export type RenderPolicy = 'full' | 'partial';
  * Return type of graphql tag literals for all operations.
  */
 declare export opaque type Operation<
-  -TVariables: Variables,
-  +TData,
+  in TVariables extends Variables,
+  out TData,
   TRawResponse,
 >: ConcreteRequest;
 
@@ -95,8 +98,8 @@ declare export opaque type Operation<
  * Return type of graphql tag literals for updatable queries.
  */
 declare export opaque type UpdatableQuery<
-  -TVariables: Variables,
-  +TData,
+  in TVariables extends Variables,
+  out TData,
 >: ConcreteUpdatableQuery;
 
 /**
@@ -104,15 +107,15 @@ declare export opaque type UpdatableQuery<
  */
 declare export opaque type UpdatableFragment<
   TFragmentType,
-  +TData,
+  out TData,
 >: ReaderFragment;
 
 /**
  * Return type of graphql tag literals for queries.
  */
 declare export opaque type Query<
-  -TVariables: Variables,
-  +TData,
+  in TVariables extends Variables,
+  out TData,
   TRawResponse = void,
 >: Operation<TVariables, TData, TRawResponse>;
 
@@ -120,8 +123,8 @@ declare export opaque type Query<
  * Return type of graphql tag literals for client-only queries.
  */
 declare export opaque type ClientQuery<
-  -TVariables: Variables,
-  +TData,
+  in TVariables extends Variables,
+  out TData,
   TRawResponse = void,
 >: ClientRequest;
 
@@ -129,8 +132,8 @@ declare export opaque type ClientQuery<
  * Return type of graphql tag literals for mutations.
  */
 declare export opaque type Mutation<
-  -TVariables: Variables,
-  +TData,
+  in TVariables extends Variables,
+  out TData,
   TRawResponse = {...},
 >: Operation<TVariables, TData, TRawResponse>;
 
@@ -141,8 +144,8 @@ declare export opaque type Mutation<
  *       `RelayObservable`'s `Subscription` type.
  */
 declare export opaque type GraphQLSubscription<
-  -TVariables: Variables,
-  +TData,
+  in TVariables extends Variables,
+  out TData,
   TRawResponse = void,
 >: Operation<TVariables, TData, TRawResponse>;
 
@@ -151,22 +154,22 @@ declare export opaque type GraphQLSubscription<
  */
 declare export opaque type InlineFragment<
   TFragmentType,
-  +TData,
+  out TData,
 >: ReaderInlineDataFragment;
 
 /**
  * Return type of graphql tag literals for fragments, except `@inline`
  * fragments.
  */
-declare export opaque type Fragment<TFragmentType, +TData>: ReaderFragment;
+declare export opaque type Fragment<TFragmentType, out TData>: ReaderFragment;
 
 /**
  * Return type of graphql tag literals for `@refetchable` fragments.
  */
 declare export opaque type RefetchableFragment<
   TFragmentType,
-  +TData,
-  TVariables: Variables,
+  out TData,
+  TVariables extends Variables,
 >: Fragment<TFragmentType, TData>;
 
 /**
@@ -175,7 +178,7 @@ declare export opaque type RefetchableFragment<
  */
 declare export opaque type PrefetchableRefetchableFragment<
   TFragmentType,
-  +TData,
-  +TEdgeData,
-  TVariables: Variables,
+  out TData,
+  out TEdgeData,
+  TVariables extends Variables,
 >: Fragment<TFragmentType, TData>;

package/util/createPayloadFor3DField.d.ts

@@ -0,0 +1,17 @@
+/**
+ * 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 {JSResourceReference, NormalizationSplitOperation} from './NormalizationNode';
+
+export type Local3DPayload<_DocumentName extends string, Response extends Record<string, unknown>> = Response;
+
+export default function createPayloadFor3DField<DocumentName extends string, Response extends Record<string, unknown>>(
+    name: DocumentName,
+    operation: JSResourceReference<NormalizationSplitOperation>,
+    component: JSResourceReference<unknown>,
+    response: Response,
+): Local3DPayload<DocumentName, Response>;

package/util/createPayloadFor3DField.js.flow

@@ -21,15 +21,19 @@ const {
 
 export opaque type Local3DPayload<
   // eslint-disable-next-line no-unused-vars
-  +DocumentName: string,
-  +Response: {...},
+  out DocumentName extends string,
+  out Response extends {...},
 > = Response;
 
-// $FlowFixMe[unsupported-variance-annotation]
-function createPayloadFor3DField<+DocumentName: string, +Response: {...}>(
+function createPayloadFor3DField<
+  // $FlowFixMe[unsupported-variance-annotation]
+  out DocumentName extends string,
+  // $FlowFixMe[unsupported-variance-annotation]
+  out Response extends {...},
+>(
   name: DocumentName,
   operation: JSResourceReference<NormalizationSplitOperation>,
-  component: JSResourceReference<mixed>,
+  component: JSResourceReference<unknown>,
   response: Response,
 ): Local3DPayload<DocumentName, Response> {
   const data = {

package/util/deepFreeze.d.ts

@@ -0,0 +1,8 @@
+/**
+ * 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.
+ */
+
+export default function deepFreeze<T extends object>(value: T): T;

package/util/deepFreeze.js.flow

@@ -17,7 +17,7 @@
  * For convenience, and for consistency with the behavior of `Object.freeze`,
  * returns the now-frozen original object.
  */
-function deepFreeze<T: {...}>(object: T): T {
+function deepFreeze<T extends {...}>(object: T): T {
   if (!shouldBeFrozen(object)) {
     return object;
   }
@@ -35,7 +35,7 @@ function deepFreeze<T: {...}>(object: T): T {
   return object;
 }
 
-function shouldBeFrozen(value: mixed): boolean {
+function shouldBeFrozen(value: unknown): boolean {
   // Only freeze plain JS arrays and objects
   return (
     value != null &&

package/util/getFragmentIdentifier.d.ts

@@ -0,0 +1,10 @@
+/**
+ * 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 { ReaderFragment } from './ReaderNode';
+
+export default function getFragmentIdentifier(fragmentNode: ReaderFragment, fragmentRef: any): string;

package/util/getFragmentIdentifier.js.flow

@@ -25,7 +25,7 @@ const {intern} = require('./StringInterner');
 
 function getFragmentIdentifier(
   fragmentNode: ReaderFragment,
-  fragmentRef: mixed,
+  fragmentRef: unknown,
 ): string {
   const selector = getSelector(fragmentNode, fragmentRef);
   const fragmentOwnerIdentifier =

package/util/getPaginationMetadata.d.ts

@@ -0,0 +1,20 @@
+/**
+ * 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 {ReaderFragment, ReaderPaginationMetadata} from './ReaderNode';
+import { ConcreteRequest } from './RelayConcreteNode';
+
+export default function getPaginationMetadata(
+    fragmentNode: ReaderFragment,
+    componentDisplayName: string,
+): {
+    connectionPathInFragmentData: ReadonlyArray<string | number>;
+    identifierField: string | null | undefined;
+    paginationRequest: ConcreteRequest;
+    paginationMetadata: ReaderPaginationMetadata;
+    stream: boolean;
+};

package/util/getPaginationMetadata.js.flow

@@ -21,7 +21,7 @@ function getPaginationMetadata(
   fragmentNode: ReaderFragment,
   componentDisplayName: string,
 ): {
-  connectionPathInFragmentData: $ReadOnlyArray<string | number>,
+  connectionPathInFragmentData: ReadonlyArray<string | number>,
   identifierField: ?string,
   paginationRequest: ConcreteRequest,
   paginationMetadata: ReaderPaginationMetadata,

package/util/getPaginationVariables.d.ts

@@ -0,0 +1,20 @@
+/**
+ * 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 { ReaderPaginationMetadata } from './ReaderNode';
+import { Variables } from './RelayRuntimeTypes';
+
+export type Direction = 'forward' | 'backward';
+
+export default function getPaginationVariables(
+    direction: Direction,
+    count: number,
+    cursor: string | null | undefined,
+    baseVariables: Variables,
+    extraVariables: Variables,
+    paginationMetadata: ReaderPaginationMetadata,
+): { [key: string]: any };