relay-runtime 21.0.0 → 21.0.1

package/network/RelayNetworkTypes.d.ts

@@ -0,0 +1,145 @@
+/**
+ * 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 { RequestParameters } from '../util/RelayConcreteNode';
+import {CacheConfig, Disposable, Variables} from '../util/RelayRuntimeTypes';
+import {ObservableFromValue, RelayObservable} from './RelayObservable';
+
+/**
+ * An interface for fetching the data for one or more (possibly interdependent)
+ * queries.
+ */
+export interface Network {
+    execute: ExecuteFunction;
+}
+export type LogRequestInfoFunction = (arg: any) => void;
+
+export interface PayloadData {
+    [key: string]: any;
+}
+
+export interface PayloadError {
+    message: string;
+    locations?:
+        | Array<{
+            line: number;
+            column: number;
+        }>
+        | undefined;
+    path?: Array<string | number>;
+    severity?: 'CRITICAL' | 'ERROR' | 'WARNING' | undefined; // Not officially part of the spec, but used at Facebook
+}
+
+export interface PayloadExtensions {
+    [key: string]: any;
+}
+
+/**
+ * The shape of a GraphQL response as dictated by the
+ * [spec](https://graphql.github.io/graphql-spec/June2018/#sec-Response-Format)
+ */
+export interface GraphQLResponseWithData {
+    data: PayloadData;
+    errors?: PayloadError[] | undefined;
+    extensions?: PayloadExtensions | undefined;
+    label?: string | undefined;
+    path?: Array<string | number> | undefined;
+}
+export interface GraphQLResponseWithoutData {
+    data?: PayloadData | undefined;
+    errors: PayloadError[];
+    extensions?: PayloadExtensions | undefined;
+    label?: string | undefined;
+    path?: Array<string | number> | undefined;
+}
+export interface GraphQLResponseWithExtensionsOnly {
+    // Per https://spec.graphql.org/June2018/#sec-Errors
+    // > If the data entry in the response is not present, the errors entry
+    // > in the response must not be empty. It must contain at least one error
+    // This means a payload has to have either a data key or an errors key:
+    // but the spec leaves room for the combination of data: null plus extensions
+    // since `data: null` is a *required* output if there was an error during
+    // execution, but the inverse is not described in the sepc: `data: null`
+    // does not necessarily indicate that there was an error.
+    data: null;
+    extensions: PayloadExtensions;
+}
+
+export type GraphQLSingularResponse =
+    | GraphQLResponseWithData
+    | GraphQLResponseWithExtensionsOnly
+    | GraphQLResponseWithoutData;
+
+export type GraphQLResponse = GraphQLSingularResponse | readonly GraphQLSingularResponse[];
+
+/**
+ * A function that returns an Observable representing the response of executing
+ * a GraphQL operation.
+ */
+export type ExecuteFunction = (
+    request: RequestParameters,
+    variables: Variables,
+    cacheConfig: CacheConfig,
+    uploadables?: UploadableMap | null,
+) => RelayObservable<GraphQLResponse>;
+
+/**
+ * A function that executes a GraphQL operation with request/response semantics.
+ *
+ * May return an Observable or Promise of a plain GraphQL server response, or
+ * a composed ExecutePayload object supporting additional metadata.
+ */
+export type FetchFunction = (
+    request: RequestParameters,
+    variables: Variables,
+    cacheConfig: CacheConfig,
+    uploadables?: UploadableMap | null,
+) => ObservableFromValue<GraphQLResponse>;
+
+export interface LegacyObserver<T> {
+    onCompleted?: (() => void) | undefined;
+    onError?: ((error: Error) => void) | undefined;
+    onNext?: ((data: T) => void) | undefined;
+}
+
+/**
+ * A function that executes a GraphQL subscription operation, returning zero or
+ * more raw server responses over time.
+ */
+export type SubscribeFunction = (
+    request: RequestParameters,
+    variables: Variables,
+    cacheConfig: CacheConfig,
+    observer?: LegacyObserver<GraphQLResponse>,
+) => RelayObservable<GraphQLResponse> | Disposable;
+
+export type Uploadable = File | Blob;
+export interface UploadableMap {
+    [key: string]: Uploadable;
+}
+
+/**
+ * React Flight tree created on the server.
+ */
+export type ReactFlightServerTree = any;
+export interface ReactFlightPayloadQuery {
+    readonly id: any;
+    readonly module: any;
+    readonly response: GraphQLSingularResponse;
+    readonly variables: Variables;
+}
+/**
+ * Data that is returned by a Flight compliant GraphQL server.
+ *
+ * - tree: an array of values that will be iterated and fed into
+ *     ReactFlightDOMRelayClient.
+ * - queries: an array of queries that the server preloaded for the client.
+ */
+export interface ReactFlightPayloadData {
+    readonly tree: ReactFlightServerTree[];
+    readonly queries: ReactFlightPayloadQuery[];
+}

package/network/RelayNetworkTypes.js.flow

@@ -21,12 +21,12 @@ import type RelayObservable, {ObservableFromValue} from './RelayObservable';
  * queries.
  */
 export interface INetwork {
-  +execute: ExecuteFunction;
+  readonly execute: ExecuteFunction;
 }
 
 export type LogRequestInfoFunction = unknown => void;
 
-export type PayloadData = {+[key: string]: unknown};
+export type PayloadData = {readonly [key: string]: unknown};
 
 export type PayloadError = interface {
   message: string,
@@ -47,19 +47,19 @@ export type PayloadExtensions = {[key: string]: unknown, ...};
  * [spec](https://spec.graphql.org/June2018/#sec-Response-Format).
  */
 export type GraphQLResponseWithData = {
-  +data: PayloadData,
-  +errors?: Array<PayloadError>,
-  +extensions?: PayloadExtensions,
-  +label?: string,
-  +path?: Array<string | number>,
+  readonly data: PayloadData,
+  readonly errors?: Array<PayloadError>,
+  readonly extensions?: PayloadExtensions,
+  readonly label?: string,
+  readonly path?: Array<string | number>,
 };
 
 export type GraphQLResponseWithoutData = {
-  +data?: ?PayloadData,
-  +errors: Array<PayloadError>,
-  +extensions?: PayloadExtensions,
-  +label?: string,
-  +path?: Array<string | number>,
+  readonly data?: ?PayloadData,
+  readonly errors: Array<PayloadError>,
+  readonly extensions?: PayloadExtensions,
+  readonly label?: string,
+  readonly path?: Array<string | number>,
 };
 
 export type GraphQLResponseWithExtensionsOnly = {
@@ -71,8 +71,8 @@ export type GraphQLResponseWithExtensionsOnly = {
   // since `data: null` is a *required* output if there was an error during
   // execution, but the inverse is not described in the sepc: `data: null`
   // does not necessarily indicate that there was an error.
-  +data: null,
-  +extensions: PayloadExtensions,
+  readonly data: null,
+  readonly extensions: PayloadExtensions,
 };
 
 export type GraphQLSingularResponse =
@@ -134,4 +134,4 @@ export type SubscribeFunction = (
 ) => RelayObservable<GraphQLResponse>;
 
 export type Uploadable = File | Blob;
-export type UploadableMap = {+[key: string]: Uploadable};
+export type UploadableMap = {readonly [key: string]: Uploadable};

package/network/RelayObservable.d.ts

@@ -0,0 +1,197 @@
+/**
+ * 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.
+ */
+
+/**
+ * A Subscription object is returned from .subscribe(), which can be
+ * unsubscribed or checked to see if the resulting subscription has closed.
+ */
+export interface Subscription {
+    unsubscribe(): void;
+    readonly closed: boolean;
+}
+
+/**
+ * An Observer is an object of optional callback functions provided to
+ * .subscribe(). Each callback function is invoked when that event occurs.
+ */
+export interface Observer<T> {
+    readonly start?: ((subscription: Subscription) => void) | undefined;
+    readonly next?: ((value: T) => void) | undefined;
+    readonly error?: ((error: Error) => void) | undefined;
+    readonly complete?: (() => void) | undefined;
+    readonly unsubscribe?: ((subscription: Subscription) => void) | undefined;
+}
+
+/**
+ * A Sink is an object of methods provided by Observable during construction.
+ * The methods are to be called to trigger each event. It also contains a closed
+ * field to see if the resulting subscription has closed.
+ */
+export interface Sink<T> {
+    next(value: T): void;
+    error(error: Error, isUncaughtThrownError?: boolean): void;
+    complete(): void;
+    readonly closed: boolean;
+}
+
+/**
+ * A Source is the required argument when constructing a new Observable. Similar
+ * to a Promise constructor, this is a function which is invoked with a Sink,
+ * and may return either a cleanup function or a Subscription instance (for use
+ * when composing Observables).
+ */
+export type Source<T> = (sink: Sink<T>) => void | Subscription | (() => unknown);
+
+/**
+ * A Subscribable is an interface describing any object which can be subscribed.
+ *
+ * Note: A sink may be passed directly to .subscribe() as its observer,
+ * allowing for easily composing Subscribables.
+ */
+export interface Subscribable<T> {
+    subscribe(observer: Observer<T> | Sink<T>): Subscription;
+}
+
+export type ObservableFromValue<T> = Subscribable<T> | Promise<T> | T;
+
+/**
+ * Limited implementation of ESObservable, providing the limited set of behavior
+ * Relay networking requires.
+ *
+ * Observables retain the benefit of callbacks which can be called
+ * synchronously, avoiding any UI jitter, while providing a compositional API,
+ * which simplifies logic and prevents mishandling of errors compared to
+ * the direct use of callback functions.
+ *
+ * ESObservable: https://github.com/tc39/proposal-observable
+ */
+export class RelayObservable<T> implements Subscribable<T> {
+    // Use RelayObservable.create(source);
+    private constructor(source: never);
+
+    static create<V>(source: Source<V>): RelayObservable<V>;
+
+    /**
+     * When an emitted error event is not handled by an Observer, it is reported
+     * to the host environment (what the ESObservable spec refers to as
+     * "HostReportErrors()").
+     *
+     * The default implementation in development rethrows thrown errors, and
+     * logs emitted error events to the console, while in production does nothing
+     * (swallowing unhandled errors).
+     *
+     * Called during application initialization, this method allows
+     * application-specific handling of unhandled errors. Allowing, for example,
+     * integration with error logging or developer tools.
+     *
+     * A second parameter `isUncaughtThrownError` is true when the unhandled error
+     * was thrown within an Observer handler, and false when the unhandled error
+     * was an unhandled emitted event.
+     *
+     *  - Uncaught thrown errors typically represent avoidable errors thrown from
+     *    application code, which should be handled with a try/catch block, and
+     *    usually have useful stack traces.
+     *
+     *  - Unhandled emitted event errors typically represent unavoidable events in
+     *    application flow such as network failure, and may not have useful
+     *    stack traces.
+     */
+    static onUnhandledError(callback: (error: Error, isUncaughtThrownError: boolean) => void): void;
+
+    /**
+     * Accepts various kinds of data sources, and always returns a RelayObservable
+     * useful for accepting the result of a user-provided FetchFunction.
+     */
+    static from<V>(obj: ObservableFromValue<V>): RelayObservable<V>;
+
+    /**
+     * Similar to promise.catch(), observable.catch() handles error events, and
+     * provides an alternative observable to use in it's place.
+     *
+     * If the catch handler throws a new error, it will appear as an error event
+     * on the resulting Observable.
+     */
+    catch<U>(fn: (error: Error) => RelayObservable<U>): RelayObservable<T | U>;
+
+    /**
+     * Returns a new Observable which first yields values from this Observable,
+     * then yields values from the next Observable. This is useful for chaining
+     * together Observables of finite length.
+     */
+    concat<U>(next: RelayObservable<U>): RelayObservable<T | U>;
+
+    /**
+     * Returns a new Observable which returns the same values as this one, but
+     * modified so that the provided Observer is called to perform a side-effects
+     * for all events emitted by the source.
+     *
+     * Any errors that are thrown in the side-effect Observer are unhandled, and
+     * do not affect the source Observable or its Observer.
+     *
+     * This is useful for when debugging your Observables or performing other
+     * side-effects such as logging or performance monitoring.
+     */
+    do(observer: Observer<T>): RelayObservable<T>;
+
+    /**
+     * Returns a new Observable which returns the same values as this one, but
+     * modified so that the finally callback is performed after completion,
+     * whether normal or due to error or unsubscription.
+     *
+     * This is useful for cleanup such as resource finalization.
+     */
+    finally(fn: () => unknown): RelayObservable<T>;
+
+    /**
+     * Returns a new Observable which is identical to this one, unless this
+     * Observable completes before yielding any values, in which case the new
+     * Observable will yield the values from the alternate Observable.
+     *
+     * If this Observable does yield values, the alternate is never subscribed to.
+     *
+     * This is useful for scenarios where values may come from multiple sources
+     * which should be tried in order, i.e. from a cache before a network.
+     */
+    ifEmpty<U>(alternate: RelayObservable<U>): RelayObservable<T | U>;
+
+    /**
+     * Observable's primary API: returns an unsubscribable Subscription to the
+     * source of this Observable.
+     *
+     * Note: A sink may be passed directly to .subscribe() as its observer,
+     * allowing for easily composing Observables.
+     */
+    subscribe(observer: Observer<T> | Sink<T>): Subscription;
+
+    /**
+     * Returns a new Observerable where each value has been transformed by
+     * the mapping function.
+     */
+    map<U>(fn: (value: T) => U): RelayObservable<U>;
+
+    /**
+     * Returns a new Observable where each value is replaced with a new Observable
+     * by the mapping function, the results of which returned as a single
+     * merged Observable.
+     */
+    mergeMap<U>(fn: (value: T) => ObservableFromValue<U>): RelayObservable<U>;
+
+    /**
+     * Returns a new Observable which first mirrors this Observable, then when it
+     * completes, waits for `pollInterval` milliseconds before re-subscribing to
+     * this Observable again, looping in this manner until unsubscribed.
+     *
+     * The returned Observable never completes.
+     */
+    poll(pollInterval: number): RelayObservable<T>;
+
+    /**
+     * Returns a Promise which resolves when this Observable yields a first value
+     * or when it completes with no value.
+     */
+    toPromise(): Promise<T | undefined>;
+}

package/network/RelayObservable.js.flow

@@ -18,14 +18,14 @@ const isPromise = require('../util/isPromise');
  * unsubscribed or checked to see if the resulting subscription has closed.
  */
 export type Subscription = {
-  +unsubscribe: () => void,
-  +closed: boolean,
+  readonly unsubscribe: () => void,
+  readonly closed: boolean,
 };
 
 type SubscriptionFn = {
   (): unknown,
-  +unsubscribe?: void,
-  +closed?: void,
+  readonly unsubscribe?: void,
+  readonly closed?: void,
   ...
 };
 
@@ -33,12 +33,12 @@ type SubscriptionFn = {
  * An Observer is an object of optional callback functions provided to
  * .subscribe(). Each callback function is invoked when that event occurs.
  */
-export type Observer<-T> = {
-  +start?: ?(Subscription) => unknown,
-  +next?: ?(T) => unknown,
-  +error?: ?(Error) => unknown,
-  +complete?: ?() => unknown,
-  +unsubscribe?: ?(Subscription) => unknown,
+export type Observer<in T> = {
+  readonly start?: ?(Subscription) => unknown,
+  readonly next?: ?(T) => unknown,
+  readonly error?: ?(Error) => unknown,
+  readonly complete?: ?() => unknown,
+  readonly unsubscribe?: ?(Subscription) => unknown,
 };
 
 /**
@@ -46,11 +46,11 @@ export type Observer<-T> = {
  * The methods are to be called to trigger each event. It also contains a closed
  * field to see if the resulting subscription has closed.
  */
-export type Sink<-T> = {
-  +next: T => void,
-  +error: (Error, isUncaughtThrownError?: boolean) => void,
-  +complete: () => void,
-  +closed: boolean,
+export type Sink<in T> = {
+  readonly next: T => void,
+  readonly error: (Error, isUncaughtThrownError?: boolean) => void,
+  readonly complete: () => void,
+  readonly closed: boolean,
 };
 
 /**
@@ -59,7 +59,7 @@ export type Sink<-T> = {
  * and may return either a cleanup function or a Subscription instance (for use
  * when composing Observables).
  */
-export type Source<+T> = (Sink<T>) => void | Subscription | SubscriptionFn;
+export type Source<out T> = (Sink<T>) => void | Subscription | SubscriptionFn;
 
 /**
  * A Subscribable is an interface describing any object which can be subscribed.
@@ -67,11 +67,11 @@ export type Source<+T> = (Sink<T>) => void | Subscription | SubscriptionFn;
  * Note: A sink may be passed directly to .subscribe() as its observer,
  * allowing for easily composing Subscribables.
  */
-export interface Subscribable<+T> {
+export interface Subscribable<out T> {
   subscribe(observer: Observer<T> | Sink<T>): Subscription;
 }
 
-export type ObservableFromValue<+T> = Subscribable<T> | Promise<T> | T;
+export type ObservableFromValue<out T> = Subscribable<T> | Promise<T> | T;
 
 let hostReportError:
   | ((Error, isUncaughtThrownError: boolean) => unknown)
@@ -88,8 +88,8 @@ let hostReportError:
  *
  * ESObservable: https://github.com/tc39/proposal-observable
  */
-class RelayObservable<+T> implements Subscribable<T> {
-  +_source: Source<T>;
+class RelayObservable<out T> implements Subscribable<T> {
+  readonly _source: Source<T>;
 
   static create<V>(source: Source<V>): RelayObservable<V> {
     return new RelayObservable(source as any);
@@ -491,7 +491,7 @@ function subscribe<T>(
   // Subscription objects below, however not all flow environments we expect
   // Relay to be used within will support property getters, and many minifier
   // tools still do not support ES5 syntax. Instead, we can use defineProperty.
-  const withClosed: <O>(obj: O) => {...O, +closed: boolean} = (obj =>
+  const withClosed: <O>(obj: O) => {...O, readonly closed: boolean} = (obj =>
     Object.defineProperty(obj, 'closed', {get: () => closed} as any)) as any;
 
   function doCleanup() {

package/network/RelayQueryResponseCache.d.ts

@@ -0,0 +1,16 @@
+/**
+ * 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 { Variables } from '../util/RelayRuntimeTypes';
+
+export default class RelayQueryResponseCache {
+    constructor(config: { size: number; ttl: number });
+    clear(): void;
+    get(queryID: string, variables: Variables): GraphQLResponse | null;
+    set(queryID: string, variables: Variables, payload: GraphQLResponse): void;
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "relay-runtime",
   "description": "A core runtime for building GraphQL-driven applications.",
-  "version": "21.0.0",
+  "version": "21.0.1",
   "keywords": [
     "graphql",
     "relay"

package/query/GraphQLTag.d.ts

@@ -0,0 +1,45 @@
+/**
+ * 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,
+  ReaderInlineDataFragment,
+  ReaderPaginationFragment,
+  ReaderRefetchableFragment,
+} from '../util/ReaderNode';
+import { ConcreteRequest } from '../util/RelayConcreteNode';
+
+// The type of a graphql`...` tagged template expression.
+export type GraphQLTaggedNode =
+    | ReaderFragment
+    | ConcreteRequest
+    | ReaderInlineDataFragment
+    | (() => ReaderFragment | ConcreteRequest | ReaderInlineDataFragment);
+
+/**
+ * Runtime function to correspond to the `graphql` tagged template function.
+ * All calls to this function should be transformed by the plugin.
+ */
+export function graphql(strings: unknown): GraphQLTaggedNode;
+
+export function getNode(taggedNode: unknown): unknown;
+
+export function isFragment(node: GraphQLTaggedNode): boolean;
+
+export function isRequest(node: GraphQLTaggedNode): boolean;
+
+export function isInlineDataFragment(node: GraphQLTaggedNode): boolean;
+
+export function getFragment(taggedNode: GraphQLTaggedNode): ReaderFragment;
+
+export function getPaginationFragment(taggedNode: GraphQLTaggedNode): ReaderPaginationFragment | null;
+
+export function getRefetchableFragment(taggedNode: GraphQLTaggedNode): ReaderRefetchableFragment | null;
+
+export function getRequest(taggedNode: GraphQLTaggedNode): ConcreteRequest;
+
+export function getInlineDataFragment(taggedNode: GraphQLTaggedNode): ReaderInlineDataFragment;

package/query/fetchQuery.d.ts

@@ -0,0 +1,21 @@
+/**
+ * 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 { RelayObservable } from '../network/RelayObservable';
+import { Environment } from '../store/RelayStoreTypes';
+import {CacheConfig, FetchQueryFetchPolicy, OperationType} from '../util/RelayRuntimeTypes';
+import { GraphQLTaggedNode } from './GraphQLTag';
+
+export function fetchQuery<T extends OperationType>(
+    environment: Environment,
+    taggedNode: GraphQLTaggedNode,
+    variables: T['variables'],
+    cacheConfig?: {
+        networkCacheConfig?: CacheConfig | null | undefined;
+        fetchPolicy?: FetchQueryFetchPolicy | null | undefined;
+    } | null,
+): RelayObservable<T['response']>;

package/query/fetchQueryInternal.d.ts

@@ -0,0 +1,26 @@
+/**
+ * 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 as Observable } from '../network/RelayObservable';
+import {Environment, OperationDescriptor, RequestDescriptor} from '../store/RelayStoreTypes';
+import { RequestIdentifier } from '../util/getRequestIdentifier';
+
+export function fetchQuery(environment: Environment, operation: OperationDescriptor): Observable<GraphQLResponse>;
+
+export function fetchQueryDeduped(
+    environment: Environment,
+    identifier: RequestIdentifier,
+    fetchFn: () => Observable<GraphQLResponse>,
+): Observable<GraphQLResponse>;
+
+export function getPromiseForActiveRequest(environment: Environment, request: RequestDescriptor): Promise<void> | null;
+
+export function getObservableForActiveRequest(
+    environment: Environment,
+    request: RequestDescriptor,
+): Observable<void> | null;

package/query/fetchQueryInternal.js.flow

@@ -25,10 +25,10 @@ const RelayReplaySubject = require('../util/RelayReplaySubject');
 const invariant = require('invariant');
 
 type RequestCacheEntry = {
-  +identifier: RequestIdentifier,
-  +subject: RelayReplaySubject<GraphQLResponse>,
-  +subjectForInFlightStatus: RelayReplaySubject<GraphQLResponse>,
-  +subscription: Subscription,
+  readonly identifier: RequestIdentifier,
+  readonly subject: RelayReplaySubject<GraphQLResponse>,
+  readonly subjectForInFlightStatus: RelayReplaySubject<GraphQLResponse>,
+  readonly subscription: Subscription,
   promise: ?Promise<void>,
 };
 

package/query/fetchQuery_DEPRECATED.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 { Environment } from '../store/RelayStoreTypes';
+import {CacheConfig, OperationType} from '../util/RelayRuntimeTypes';
+import { GraphQLTaggedNode } from './GraphQLTag';
+
+export function fetchQuery_DEPRECATED<T extends OperationType>(
+    environment: Environment,
+    taggedNode: GraphQLTaggedNode,
+    variables: T['variables'],
+    cacheConfig?: CacheConfig | null,
+): Promise<T['response']>;

package/store/ClientID.d.ts

@@ -0,0 +1,14 @@
+/**
+ * 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';
+
+export function generateClientID(id: DataID, storageKey: string, index?: number): DataID;
+
+export function isClientID(id: DataID): boolean;
+
+export function generateUniqueClientID(): DataID;