relay-runtime 21.0.0 → 21.0.1

package/store/DataChecker.js.flow

@@ -46,8 +46,8 @@ const {TYPE_SCHEMA_TYPE, generateTypeID} = require('./TypeID');
 const invariant = require('invariant');
 
 export type Availability = {
-  +status: 'available' | 'missing',
-  +mostRecentlyInvalidatedAt: ?number,
+  readonly status: 'available' | 'missing',
+  readonly mostRecentlyInvalidatedAt: ?number,
 };
 
 const {getModuleOperationKey, getStorageKey, getArgumentValues} =
@@ -118,12 +118,14 @@ class DataChecker {
   _useExecTimeResolvers: boolean;
   _variables: Variables;
   _shouldProcessClientComponents: ?boolean;
-  +_getSourceForActor: (actorIdentifier: ActorIdentifier) => RecordSource;
-  +_getTargetForActor: (
+  readonly _getSourceForActor: (
+    actorIdentifier: ActorIdentifier,
+  ) => RecordSource;
+  readonly _getTargetForActor: (
     actorIdentifier: ActorIdentifier,
   ) => MutableRecordSource;
-  +_getDataID: GetDataID;
-  +_mutatorRecordSourceProxyCache: Map<
+  readonly _getDataID: GetDataID;
+  readonly _mutatorRecordSourceProxyCache: Map<
     ActorIdentifier,
     [RelayRecordSourceMutator, RelayRecordSourceProxy],
   >;

package/store/NormalizationEngine.js.flow

@@ -62,7 +62,10 @@ export type NormalizationResult = Readonly<{
 }>;
 
 type Config = Readonly<{
-  getDataID?: (fieldValue: {+[string]: unknown}, typeName: string) => unknown,
+  getDataID?: (
+    fieldValue: {readonly [string]: unknown},
+    typeName: string,
+  ) => unknown,
   normalizeResponse: NormalizeResponseFunction,
   operation: NormalizationOperation,
   operationLoader?: ?OperationLoader,

package/store/OperationExecutor.d.ts

@@ -0,0 +1,51 @@
+/**
+ * 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 { GraphQLResponse } from '../network/RelayNetworkTypes';
+import {RelayObservable, Sink} from '../network/RelayObservable';
+import { GetDataID } from './RelayResponseNormalizer';
+import {
+  OperationDescriptor,
+  OperationLoader,
+  OperationTracker,
+  OptimisticResponseConfig,
+  PublishQueue,
+  ReactFlightPayloadDeserializer,
+  SelectorStoreUpdater,
+  Store,
+} from './RelayStoreTypes';
+
+export type ActiveState = 'active' | 'inactive';
+
+export interface ExecuteConfig {
+    readonly getDataID: GetDataID;
+    readonly treatMissingFieldsAsNull: boolean;
+    readonly operation: OperationDescriptor;
+    readonly operationExecutions: Map<string, ActiveState>;
+    readonly operationLoader: OperationLoader | null | undefined;
+    readonly operationTracker?: OperationTracker | null | undefined;
+    readonly optimisticConfig: OptimisticResponseConfig | null | undefined;
+    readonly publishQueue: PublishQueue;
+    readonly reactFlightPayloadDeserializer?: ReactFlightPayloadDeserializer | null | undefined;
+    readonly scheduler?: TaskScheduler | null | undefined;
+    readonly sink: Sink<GraphQLResponse>;
+    readonly source: RelayObservable<GraphQLResponse>;
+    readonly store: Store;
+    readonly updater?: SelectorStoreUpdater | null | undefined;
+    readonly isClientPayload?: boolean | undefined;
+}
+
+export interface TaskScheduler {
+    cancel: (id: string) => void;
+    schedule: (fn: () => void) => string;
+}
+
+export interface Executor {
+    cancel: () => void;
+}
+
+export function execute(config: ExecuteConfig): Executor;

package/store/OperationExecutor.js.flow

@@ -77,25 +77,25 @@ const warning = require('warning');
 type NetworkResponse = GraphQLResponse | RelayResponsePayload;
 
 export type ExecuteConfig<TMutation extends MutationParameters> = {
-  +actorIdentifier: ActorIdentifier,
-  +getDataID: GetDataID,
-  +getPublishQueue: (actorIdentifier: ActorIdentifier) => PublishQueue,
-  +getStore: (actorIdentifier: ActorIdentifier) => Store,
-  +normalizeResponse: NormalizeResponseFunction,
-  +isClientPayload?: boolean,
-  +operation: OperationDescriptor,
-  +operationExecutions: Map<string, ActiveState>,
-  +operationLoader: ?OperationLoader,
-  +operationTracker: OperationTracker,
-  +optimisticConfig: ?OptimisticResponseConfig<TMutation>,
-  +scheduler?: ?TaskScheduler,
-  +shouldProcessClientComponents?: ?boolean,
-  +sink: Sink<GraphQLResponse>,
-  +source: RelayObservable<NetworkResponse>,
-  +treatMissingFieldsAsNull: boolean,
-  +deferDeduplicatedFields: boolean,
-  +updater?: ?SelectorStoreUpdater<TMutation['response']>,
-  +log: LogFunction,
+  readonly actorIdentifier: ActorIdentifier,
+  readonly getDataID: GetDataID,
+  readonly getPublishQueue: (actorIdentifier: ActorIdentifier) => PublishQueue,
+  readonly getStore: (actorIdentifier: ActorIdentifier) => Store,
+  readonly normalizeResponse: NormalizeResponseFunction,
+  readonly isClientPayload?: boolean,
+  readonly operation: OperationDescriptor,
+  readonly operationExecutions: Map<string, ActiveState>,
+  readonly operationLoader: ?OperationLoader,
+  readonly operationTracker: OperationTracker,
+  readonly optimisticConfig: ?OptimisticResponseConfig<TMutation>,
+  readonly scheduler?: ?TaskScheduler,
+  readonly shouldProcessClientComponents?: ?boolean,
+  readonly sink: Sink<GraphQLResponse>,
+  readonly source: RelayObservable<NetworkResponse>,
+  readonly treatMissingFieldsAsNull: boolean,
+  readonly deferDeduplicatedFields: boolean,
+  readonly updater?: ?SelectorStoreUpdater<TMutation['response']>,
+  readonly log: LogFunction,
 };
 
 export type ActiveState = 'active' | 'inactive';
@@ -104,12 +104,12 @@ type Label = string;
 type PathKey = string;
 type IncrementalResults =
   | {
-      +kind: 'placeholder',
-      +placeholder: IncrementalDataPlaceholder,
+      readonly kind: 'placeholder',
+      readonly placeholder: IncrementalDataPlaceholder,
     }
   | {
-      +kind: 'response',
-      +responses: Array<IncrementalGraphQLResponse>,
+      readonly kind: 'response',
+      readonly responses: Array<IncrementalGraphQLResponse>,
     };
 
 type IncrementalGraphQLResponse = {
@@ -147,24 +147,27 @@ class Executor<TMutation extends MutationParameters> {
   _optimisticUpdates: null | Array<OptimisticUpdate<TMutation>>;
   _useExecTimeResolvers: boolean;
   _pendingModulePayloadsCount: number;
-  +_getPublishQueue: (actorIdentifier: ActorIdentifier) => PublishQueue;
+  readonly _getPublishQueue: (actorIdentifier: ActorIdentifier) => PublishQueue;
   _shouldProcessClientComponents: ?boolean;
   _scheduler: ?TaskScheduler;
   _sink: Sink<GraphQLResponse>;
   _source: Map<
     string,
-    {+record: Record, +fieldPayloads: Array<HandleFieldPayload>},
+    {
+      readonly record: Record,
+      readonly fieldPayloads: Array<HandleFieldPayload>,
+    },
   >;
   _state: 'started' | 'loading_incremental' | 'loading_final' | 'completed';
-  +_getStore: (actorIdentifier: ActorIdentifier) => Store;
+  readonly _getStore: (actorIdentifier: ActorIdentifier) => Store;
   _subscriptions: Map<number, Subscription>;
   _updater: ?SelectorStoreUpdater<TMutation['response']>;
   _asyncStoreUpdateDisposable: ?Disposable;
   _completeFns: Array<() => void>;
-  +_retainDisposables: Map<ActorIdentifier, Disposable>;
-  +_isClientPayload: boolean;
-  +_isSubscriptionOperation: boolean;
-  +_seenActors: Set<ActorIdentifier>;
+  readonly _retainDisposables: Map<ActorIdentifier, Disposable>;
+  readonly _isClientPayload: boolean;
+  readonly _isSubscriptionOperation: boolean;
+  readonly _seenActors: Set<ActorIdentifier>;
   _normalizeResponse: NormalizeResponseFunction;
   _execTimeResolverResponseComplete: boolean;
   _isClientQuery: boolean;

package/store/RelayModernEnvironment.d.ts

@@ -0,0 +1,97 @@
+/**
+ * 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 { GetDataID } from './RelayResponseNormalizer';
+
+import { HandlerProvider } from '../handlers/RelayDefaultHandlerProvider';
+import {GraphQLResponse, Network, PayloadData, UploadableMap} from '../network/RelayNetworkTypes';
+import { RelayObservable } from '../network/RelayObservable';
+import {Disposable, RenderPolicy} from '../util/RelayRuntimeTypes';
+import { TaskScheduler } from './OperationExecutor';
+import { RelayOperationTracker } from './RelayOperationTracker';
+import {
+  Environment,
+  LogFunction,
+  MissingFieldHandler,
+  OperationAvailability,
+  OperationDescriptor,
+  OperationLoader,
+  OperationTracker,
+  OptimisticResponseConfig,
+  OptimisticUpdateFunction,
+  RelayFieldLogger,
+  SelectorStoreUpdater,
+  SingularReaderSelector,
+  Snapshot,
+  Store,
+  StoreUpdater,
+} from './RelayStoreTypes';
+
+export interface EnvironmentConfig {
+    readonly configName?: string | undefined;
+    readonly handlerProvider?: HandlerProvider | null | undefined;
+    readonly treatMissingFieldsAsNull?: boolean | undefined;
+    readonly log?: LogFunction | null | undefined;
+    readonly operationLoader?: OperationLoader | null | undefined;
+    readonly network: Network;
+    readonly scheduler?: TaskScheduler | null | undefined;
+    readonly store?: Store;
+    readonly missingFieldHandlers?: readonly MissingFieldHandler[] | null | undefined;
+    readonly operationTracker?: OperationTracker | null | undefined;
+    readonly getDataID?: GetDataID | null | undefined;
+    readonly UNSTABLE_defaultRenderPolicy?: RenderPolicy | null | undefined;
+    readonly options?: unknown | undefined;
+    readonly isServer?: boolean | undefined;
+    readonly relayFieldLogger?: RelayFieldLogger | null | undefined;
+    readonly shouldProcessClientComponents?: boolean | null | undefined;
+}
+
+export default class RelayModernEnvironment implements Environment {
+    options: unknown;
+    configName: string | null | undefined;
+    relayFieldLogger: RelayFieldLogger;
+    constructor(config: EnvironmentConfig);
+    getStore(): Store;
+    getNetwork(): Network;
+    getOperationTracker(): RelayOperationTracker;
+    isRequestActive(requestIdentifier: string): boolean;
+    applyUpdate(optimisticUpdate: OptimisticUpdateFunction): Disposable;
+    revertUpdate(update: OptimisticUpdateFunction): void;
+    replaceUpdate(update: OptimisticUpdateFunction, newUpdate: OptimisticUpdateFunction): void;
+    applyMutation(optimisticConfig: OptimisticResponseConfig): Disposable;
+    check(operation: OperationDescriptor): OperationAvailability;
+    commitPayload(operationDescriptor: OperationDescriptor, payload: PayloadData): void;
+    commitUpdate(updater: StoreUpdater): void;
+    lookup(readSelector: SingularReaderSelector): Snapshot;
+    subscribe(snapshot: Snapshot, callback: (snapshot: Snapshot) => void): Disposable;
+    retain(operation: OperationDescriptor): Disposable;
+    isServer(): boolean;
+    execute(data: {
+        operation: OperationDescriptor;
+        updater?: SelectorStoreUpdater | null | undefined;
+    }): RelayObservable<GraphQLResponse>;
+    executeMutation({
+        operation,
+        optimisticResponse,
+        optimisticUpdater,
+        updater,
+        uploadables,
+    }: {
+        operation: OperationDescriptor;
+        optimisticUpdater?: SelectorStoreUpdater | null | undefined;
+        optimisticResponse?: { [key: string]: any } | null | undefined;
+        updater?: SelectorStoreUpdater | null | undefined;
+        uploadables?: UploadableMap | null | undefined;
+    }): RelayObservable<GraphQLResponse>;
+    executeWithSource({
+        operation,
+        source,
+    }: {
+        operation: OperationDescriptor;
+        source: RelayObservable<GraphQLResponse>;
+    }): RelayObservable<GraphQLResponse>;
+}

package/store/RelayModernEnvironment.js.flow

@@ -64,29 +64,29 @@ const RelayRecordSource = require('./RelayRecordSource');
 const invariant = require('invariant');
 
 export type EnvironmentConfig = {
-  +configName?: string,
-  +handlerProvider?: ?HandlerProvider,
-  +treatMissingFieldsAsNull?: boolean,
-  +deferDeduplicatedFields?: boolean,
-  +log?: ?LogFunction,
-  +operationLoader?: ?OperationLoader,
-  +network: INetwork,
-  +normalizeResponse?: ?NormalizeResponseFunction,
-  +scheduler?: ?TaskScheduler,
-  +store?: Store,
-  +missingFieldHandlers?: ?ReadonlyArray<MissingFieldHandler>,
-  +operationTracker?: ?OperationTracker,
-  +getDataID?: ?GetDataID,
-  +UNSTABLE_defaultRenderPolicy?: ?RenderPolicy,
-  +options?: unknown,
-  +isServer?: boolean,
-  +relayFieldLogger?: ?RelayFieldLogger,
-  +shouldProcessClientComponents?: ?boolean,
+  readonly configName?: string,
+  readonly handlerProvider?: ?HandlerProvider,
+  readonly treatMissingFieldsAsNull?: boolean,
+  readonly deferDeduplicatedFields?: boolean,
+  readonly log?: ?LogFunction,
+  readonly operationLoader?: ?OperationLoader,
+  readonly network: INetwork,
+  readonly normalizeResponse?: ?NormalizeResponseFunction,
+  readonly scheduler?: ?TaskScheduler,
+  readonly store?: Store,
+  readonly missingFieldHandlers?: ?ReadonlyArray<MissingFieldHandler>,
+  readonly operationTracker?: ?OperationTracker,
+  readonly getDataID?: ?GetDataID,
+  readonly UNSTABLE_defaultRenderPolicy?: ?RenderPolicy,
+  readonly options?: unknown,
+  readonly isServer?: boolean,
+  readonly relayFieldLogger?: ?RelayFieldLogger,
+  readonly shouldProcessClientComponents?: ?boolean,
 };
 
 class RelayModernEnvironment implements IEnvironment {
   __log: LogFunction;
-  +_defaultRenderPolicy: RenderPolicy;
+  readonly _defaultRenderPolicy: RenderPolicy;
   _operationLoader: ?OperationLoader;
   _shouldProcessClientComponents: ?boolean;
   _network: INetwork;
@@ -100,8 +100,8 @@ class RelayModernEnvironment implements IEnvironment {
   _treatMissingFieldsAsNull: boolean;
   _deferDeduplicatedFields: boolean;
   _operationExecutions: Map<string, ActiveState>;
-  +options: unknown;
-  +_isServer: boolean;
+  readonly options: unknown;
+  readonly _isServer: boolean;
   relayFieldLogger: RelayFieldLogger;
   _normalizeResponse: NormalizeResponseFunction;
 

package/store/RelayModernOperationDescriptor.d.ts

@@ -0,0 +1,28 @@
+/**
+ * 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 { ConcreteRequest } from '../util/RelayConcreteNode';
+import {CacheConfig, DataID, Variables} from '../util/RelayRuntimeTypes';
+import {OperationDescriptor, RequestDescriptor} from './RelayStoreTypes';
+/**
+ * Creates an instance of the `OperationDescriptor` type defined in
+ * `RelayStoreTypes` given an operation and some variables. The input variables
+ * are filtered to exclude variables that do not match defined arguments on the
+ * operation, and default values are populated for null values.
+ */
+export function createOperationDescriptor(
+    request: ConcreteRequest,
+    variables: Variables,
+    cacheConfig?: CacheConfig | null,
+    dataID?: DataID,
+): OperationDescriptor;
+
+export function createRequestDescriptor(
+    request: ConcreteRequest,
+    variables: Variables,
+    cacheConfig?: CacheConfig | null,
+): RequestDescriptor;

package/store/RelayModernRecord.d.ts

@@ -0,0 +1,92 @@
+/**
+ * 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 { DataID } from '../util/RelayRuntimeTypes';
+import { Record } from './RelayStoreTypes';
+
+export class RelayModernRecord {
+    /**
+     * Clone a record.
+     */
+    clone(record: Record): Record;
+
+    /**
+     * Copies all fields from `source` to `sink`, excluding `__id` and `__typename`.
+     *
+     * NOTE: This function does not treat `id` specially. To preserve the id,
+     * manually reset it after calling this function. Also note that values are
+     * copied by reference and not value; callers should ensure that values are
+     * copied on write.
+     */
+    copyFields(source: Record, sink: Record): void;
+
+    /**
+     * Create a new record.
+     */
+    create(dataID: DataID, typeName: string): Record;
+
+    /**
+     * Get the record's `id` if available or the client-generated identifier.
+     */
+    getDataID(record: Record): DataID;
+
+    /**
+     * Get the concrete type of the record.
+     */
+    getType(record: Record): string;
+
+    /**
+     * Get a scalar (non-link) field value.
+     */
+    getValue(record: Record, storageKey: string): unknown;
+
+    /**
+     * Get the value of a field as a reference to another record. Throws if the
+     * field has a different type.
+     */
+    getLinkedRecordID(record: Record, storageKey: string): DataID | null;
+
+    /**
+     * Get the value of a field as a list of references to other records. Throws if
+     * the field has a different type.
+     */
+    getLinkedRecordIDs(record: Record, storageKey: string): DataID[] | null;
+
+    /**
+     * Compares the fields of a previous and new record, returning either the
+     * previous record if all fields are equal or a new record (with merged fields)
+     * if any fields have changed.
+     */
+    update(prevRecord: Record, nextRecord: Record): Record;
+
+    /**
+     * Returns a new record with the contents of the given records. Fields in the
+     * second record will overwrite identical fields in the first record.
+     */
+    merge(record1: Record, record2: Record): Record;
+
+    /**
+     * Prevent modifications to the record. Attempts to call `set*` functions on a
+     * frozen record will fatal at runtime.
+     */
+    freeze(record: Record): void;
+
+    /**
+     * Set the value of a storageKey to a scalar.
+     */
+    setValue(record: Record, storageKey: string, value: any): void;
+
+    /**
+     * Set the value of a field to a reference to another record.
+     */
+    setLinkedRecordID(record: Record, storageKey: string, linkedID: DataID): void;
+
+    /**
+     * Set the value of a field to a list of references other records.
+     */
+    setLinkedRecordIDs(record: Record, storageKey: string, linkedIDs: DataID[] | null): void;
+}

package/store/RelayModernSelector.d.ts

@@ -0,0 +1,123 @@
+/**
+ * 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 { NormalizationSelectableNode } from '../util/NormalizationNode';
+import { ReaderFragment } from '../util/ReaderNode';
+import {DataID, Variables} from '../util/RelayRuntimeTypes';
+import {
+  NormalizationSelector,
+  PluralReaderSelector,
+  ReaderSelector,
+  RequestDescriptor,
+  SingularReaderSelector,
+} from './RelayStoreTypes';
+
+/**
+ * Given the result `item` from a parent that fetched `fragment`, creates a
+ * selector that can be used to read the results of that fragment for that item.
+ *
+ * Example:
+ *
+ * Given two fragments as follows:
+ *
+ * ```
+ * fragment Parent on User {
+ *   id
+ *   ...Child
+ * }
+ * fragment Child on User {
+ *   name
+ * }
+ * ```
+ *
+ * And given some object `parent` that is the results of `Parent` for id "4",
+ * the results of `Child` can be accessed by first getting a selector and then
+ * using that selector to `lookup()` the results against the environment:
+ *
+ * ```
+ * const childSelector = getSingularSelector(queryVariables, Child, parent);
+ * const childData = environment.lookup(childSelector).data;
+ * ```
+ */
+export function getSingularSelector(fragment: ReaderFragment, item: unknown): SingularReaderSelector;
+
+/**
+ * Given the result `items` from a parent that fetched `fragment`, creates a
+ * selector that can be used to read the results of that fragment on those
+ * items. This is similar to `getSingularSelector` but for "plural" fragments that
+ * expect an array of results and therefore return an array of selectors.
+ */
+export function getPluralSelector(fragment: ReaderFragment, items: unknown[]): PluralReaderSelector;
+
+export function getSelector(fragment: ReaderFragment, item: unknown | unknown[]): ReaderSelector;
+
+/**
+ * Given a mapping of keys -> results and a mapping of keys -> fragments,
+ * extracts the selectors for those fragments from the results.
+ *
+ * The canonical use-case for this function is ReactRelayFragmentContainer, which
+ * uses this function to convert (props, fragments) into selectors so that it
+ * can read the results to pass to the inner component.
+ */
+export function getSelectorsFromObject(
+    fragments: { [key: string]: ReaderFragment },
+    object: { [key: string]: any },
+): { [key: string]: ReaderSelector };
+
+/**
+ * Given a mapping of keys -> results and a mapping of keys -> fragments,
+ * extracts a mapping of keys -> id(s) of the results.
+ *
+ * Similar to `getSelectorsFromObject()`, this function can be useful in
+ * determining the "identity" of the props passed to a component.
+ */
+export function getDataIDsFromObject(
+    fragments: { [key: string]: ReaderFragment },
+    object: { [key: string]: any },
+): { [key: string]: DataID | DataID[] };
+
+export function getDataIDsFromFragment(fragment: ReaderFragment, item: unknown | unknown[]): DataID | DataID[];
+
+/**
+ * Given a mapping of keys -> results and a mapping of keys -> fragments,
+ * extracts the merged variables that would be in scope for those
+ * fragments/results.
+ *
+ * This can be useful in determing what varaibles were used to fetch the data
+ * for a Relay container, for example.
+ */
+export function getVariablesFromObject(
+    fragments: { [key: string]: ReaderFragment },
+    object: { [key: string]: any },
+): Variables;
+
+export function getVariablesFromFragment(fragment: ReaderFragment, item: unknown | unknown[]): Variables;
+
+export function getVariablesFromSingularFragment(fragment: ReaderFragment, item: unknown): Variables;
+
+export function getVariablesFromPluralFragment(fragment: ReaderFragment, items: unknown[]): Variables;
+
+/**
+ * Determine if two selectors are equal (represent the same selection). Note
+ * that this function returns `false` when the two queries/fragments are
+ * different objects, even if they select the same fields.
+ */
+export function areEqualSelectors(thisSelector: SingularReaderSelector, thatSelector: SingularReaderSelector): boolean;
+
+export function createReaderSelector(
+    fragment: ReaderFragment,
+    dataID: DataID,
+    variables: Variables,
+    request: RequestDescriptor,
+    isWithinUnmatchedTypeRefinement?: boolean, // default: `false`
+): SingularReaderSelector;
+
+export function createNormalizationSelector(
+    node: NormalizationSelectableNode,
+    dataID: DataID,
+    variables: Variables,
+): NormalizationSelector;

package/store/RelayModernStore.d.ts

@@ -0,0 +1,57 @@
+/**
+ * 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 {DataID, Disposable} from '../util/RelayRuntimeTypes';
+import {
+  CheckOptions,
+  LogFunction,
+  MutableRecordSource,
+  OperationAvailability,
+  OperationDescriptor,
+  OperationLoader,
+  RecordSource,
+  RequestDescriptor,
+  ResolverContext,
+  Scheduler,
+  SingularReaderSelector,
+  Snapshot,
+  Store,
+} from './RelayStoreTypes';
+
+export interface InvalidationState {
+    dataIDs: readonly DataID[];
+    invalidations: Map<DataID, number | undefined | null>;
+}
+
+export default class RelayModernStore implements Store {
+    constructor(
+        source: MutableRecordSource,
+        options?: {
+            gcScheduler?: Scheduler | null | undefined;
+            log?: LogFunction | null | undefined;
+            operationLoader?: OperationLoader | null | undefined;
+            gcReleaseBufferSize?: number | null | undefined;
+            queryCacheExpirationTime?: number | null | undefined;
+            resolverContext?: ResolverContext;
+        },
+    );
+    getSource(): RecordSource;
+    check(operation: OperationDescriptor, options?: CheckOptions): OperationAvailability;
+    retain(operation: OperationDescriptor): Disposable;
+    lookup(selector: SingularReaderSelector): Snapshot;
+    notify(sourceOperation?: OperationDescriptor, invalidateStore?: boolean): readonly RequestDescriptor[];
+    publish(source: RecordSource, idsMarkedForInvalidation?: Set<DataID>): void;
+    subscribe(snapshot: Snapshot, callback: (snapshot: Snapshot) => void): Disposable;
+    holdGC(): Disposable;
+    lookupInvalidationState(dataIDs: readonly DataID[]): InvalidationState;
+    checkInvalidationState(previousInvalidationState: InvalidationState): boolean;
+    subscribeToInvalidationState(invalidationState: InvalidationState, callback: () => void): Disposable;
+    toJSON(): unknown;
+    snapshot(): void;
+    restore(): void;
+    scheduleGC(): void;
+}

package/store/RelayOperationTracker.d.ts

@@ -0,0 +1,29 @@
+/**
+ * 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 { RequestDescriptor } from './RelayStoreTypes';
+
+export class RelayOperationTracker {
+    /**
+     * Update the map of current processing operations with the set of
+     * affected owners and notify subscribers
+     */
+    update(pendingOperation: RequestDescriptor, affectedOwners: Set<RequestDescriptor>): void;
+
+    /**
+     * Once pending operation is completed we need to remove it
+     * from all tracking maps
+     */
+    complete(pendingOperation: RequestDescriptor): void;
+
+    _resolveOwnerResolvers(owner: RequestDescriptor): void;
+
+    getPendingOperationsAffectingOwner(owner: RequestDescriptor): {
+        promise: Promise<void>;
+        pendingOperations: readonly RequestDescriptor[];
+    } | null;
+}