relay-runtime 20.1.1 → 21.0.1

package/experimental.d.ts

@@ -0,0 +1,34 @@
+/**
+ * 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 { resolverDataInjector } from './store/live-resolvers/resolverDataInjector';
+export { observeFragment } from './store/observeFragmentExperimental';
+export { observeQuery } from './store/observeQueryExperimental';
+export { waitForFragmentData } from './store/waitForFragmentExperimental';
+
+export type IdOf<_A extends string, Typename extends undefined | string = undefined> = Typename extends undefined
+    ? { id: DataID }
+    : { id: DataID; __typename: Typename };
+
+interface ErrorResult<E> {
+    ok: false;
+    errors: readonly E[];
+}
+
+interface OkayResult<T> {
+    ok: true;
+    value: T;
+}
+
+// The type returned by fields annotated with `@catch`
+export type Result<T, E> = OkayResult<T> | ErrorResult<E>;
+
+export function isValueResult<T = unknown>(input: Result<T, unknown>): input is OkayResult<T>;
+
+export function isErrorResult<E = unknown>(input: Result<unknown, E>): input is ErrorResult<E>;

package/experimental.js

@@ -1,5 +1,5 @@
 /**
- * Relay v20.1.1
+ * Relay v21.0.1
  *
  * Copyright (c) Meta Platforms, Inc. and affiliates.
  *

package/experimental.js.flow

@@ -22,7 +22,7 @@ const {waitForFragmentData} = require('./store/waitForFragmentExperimental');
 // Annotates a strong object return type, where `A` is the GraphQL typename and `Typename` is the
 // `__typename` field for returning an interface
 // eslint-disable-next-line no-unused-vars
-export type IdOf<A: string, Typename: void | string = void> = [
+export type IdOf<A extends string, Typename extends void | string = void> = [
   Typename,
 ] extends [void]
   ? {id: DataID}
@@ -41,37 +41,37 @@ export type IdOf<A: string, Typename: void | string = void> = [
  * can return null or not. If the field is nullable, you can type it as
  * returning `?RelayResolverValue<T>`.
  */
-export type RelayResolverValue<A> = $NonMaybeType<A>;
+export type RelayResolverValue<A> = NonNullable<A>;
 
 type ErrorResult<Error> = {
-  +ok: false,
-  +errors: $ReadOnlyArray<Error>,
+  readonly ok: false,
+  readonly errors: ReadonlyArray<Error>,
 };
 
 type OkayResult<T> = {
-  +ok: true,
-  +value: T,
+  readonly ok: true,
+  readonly value: T,
 };
 
 export type Result<T, Error> = OkayResult<T> | ErrorResult<Error>;
 
-function isValueResult<T = mixed>(
+function isValueResult<T = unknown>(
   input: Result<T, Error>,
 ): input is OkayResult<T> {
   return input.ok === (true as const);
 }
 
-function isErrorResult<T = mixed>(
+function isErrorResult<T = unknown>(
   input: Result<T, Error>,
 ): input is ErrorResult<Error> {
   return input.ok === (false as const);
 }
 
 module.exports = {
-  resolverDataInjector,
-  isValueResult,
   isErrorResult,
-  observeQuery,
+  isValueResult,
   observeFragment,
+  observeQuery,
+  resolverDataInjector,
   waitForFragmentData,
 };

package/handlers/RelayDefaultHandlerProvider.d.ts

@@ -0,0 +1,12 @@
+/**
+ * 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 { Handler } from '../store/RelayStoreTypes';
+
+export type HandlerProvider = (handle: string) => Handler | undefined;
+
+export default function RelayDefaultHandlerProvider(handle: string): Handler;

package/handlers/connection/ConnectionHandler.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 {
+  HandleFieldPayload,
+  ReadOnlyRecordProxy,
+  RecordProxy,
+  RecordSourceProxy,
+} from '../../store/RelayStoreTypes';
+import {DataID, Variables} from '../../util/RelayRuntimeTypes';
+
+export interface ConnectionMetadata {
+    path: readonly string[] | null | undefined;
+    direction: string | null | undefined; // 'forward' | 'backward' | 'bidirectional' | null | undefined;
+    cursor: string | null | undefined;
+    count: string | null | undefined;
+    stream?: boolean | undefined;
+}
+
+export function buildConnectionEdge(
+    store: RecordSourceProxy,
+    connection: RecordProxy,
+    edge: RecordProxy | null | undefined,
+): RecordProxy | null | undefined;
+
+export function createEdge(
+    store: RecordSourceProxy,
+    record: RecordProxy,
+    node: RecordProxy,
+    edgeType: string,
+): RecordProxy;
+
+export function deleteNode(record: RecordProxy, nodeID: DataID): void;
+
+export function getConnection(
+    record: ReadOnlyRecordProxy,
+    key: string,
+    filters?: Variables | null,
+): RecordProxy | null | undefined;
+
+export function getConnectionID(recordID: DataID, key: string, filters?: Variables | null): DataID;
+
+export function insertEdgeAfter(record: RecordProxy, newEdge: RecordProxy, cursor?: string | null): void;
+
+export function insertEdgeBefore(record: RecordProxy, newEdge: RecordProxy, cursor?: string | null): void;
+
+export function update(store: RecordSourceProxy, payload: HandleFieldPayload): void;

package/handlers/connection/ConnectionHandler.js.flow

@@ -166,7 +166,7 @@ function update(store: RecordSourceProxy, payload: HandleFieldPayload): void {
         //         end cursor from the server matches the end cursor from the
         //         client then we're just filling out the rest of this page.
         if (isAddingEdgesAfterCurrentPage || isFillingOutCurrentPage) {
-          const nodeIDs = new Set<mixed>();
+          const nodeIDs = new Set<unknown>();
           mergeEdges(prevEdges, nextEdges, nodeIDs);
           mergeEdges(serverEdges, nextEdges, nodeIDs);
         } else {
@@ -185,7 +185,7 @@ function update(store: RecordSourceProxy, payload: HandleFieldPayload): void {
           clientPageInfo &&
           args.before === clientPageInfo.getValue(START_CURSOR)
         ) {
-          const nodeIDs = new Set<mixed>();
+          const nodeIDs = new Set<unknown>();
           mergeEdges(serverEdges, nextEdges, nodeIDs);
           mergeEdges(prevEdges, nextEdges, nodeIDs);
         } else {
@@ -380,7 +380,7 @@ function insertEdgeAfter(
   if (cursor == null) {
     nextEdges = edges.concat(newEdge);
   } else {
-    nextEdges = ([]: Array<?RecordProxy>);
+    nextEdges = [] as Array<?RecordProxy>;
     let foundCursor = false;
     for (let ii = 0; ii < edges.length; ii++) {
       const edge = edges[ii];
@@ -484,7 +484,7 @@ function insertEdgeBefore(
   if (cursor == null) {
     nextEdges = [newEdge].concat(edges);
   } else {
-    nextEdges = ([]: Array<?RecordProxy>);
+    nextEdges = [] as Array<?RecordProxy>;
     let foundCursor = false;
     for (let ii = 0; ii < edges.length; ii++) {
       const edge = edges[ii];
@@ -584,7 +584,7 @@ function buildConnectionEdge(
 function mergeEdges(
   sourceEdges: Array<?RecordProxy>,
   targetEdges: Array<?RecordProxy>,
-  nodeIDs: Set<mixed>,
+  nodeIDs: Set<unknown>,
 ): void {
   const {NODE} = ConnectionInterface.get();
 

package/handlers/connection/ConnectionInterface.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 { DataID } from '../../util/RelayRuntimeTypes';
+
+export interface EdgeRecord extends Record<string, unknown> {
+    cursor: unknown;
+    node: Record<DataID, unknown>;
+}
+
+export interface PageInfo {
+    endCursor: string | null | undefined;
+    hasNextPage: boolean;
+    hasPreviousPage: boolean;
+    startCursor: string | null | undefined;
+}
+
+interface ConnectionConfig {
+    CURSOR: string;
+    EDGES: string;
+    END_CURSOR: string;
+    HAS_NEXT_PAGE: string;
+    HAS_PREV_PAGE: string;
+    NODE: string;
+    PAGE_INFO: string;
+    PAGE_INFO_TYPE: string;
+    START_CURSOR: string;
+}
+
+declare const ConnectionInterface: {
+    get(): ConnectionConfig;
+
+    inject(newConfig: ConnectionConfig): void;
+};
+
+export default ConnectionInterface;

package/handlers/connection/ConnectionInterface.js.flow

@@ -16,7 +16,7 @@ import type {Record} from '../../store/RelayStoreTypes';
 type Call = {name: string, ...};
 
 export type EdgeRecord = Record & {
-  cursor: mixed,
+  cursor: unknown,
   node: Record,
   ...
 };

package/handlers/connection/MutationHandlers.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 { Handler } from '../../store/RelayStoreTypes';
+
+export const MutationHandlers: {
+    DeleteRecordHandler: Handler;
+    DeleteEdgeHandler: Handler;
+    AppendEdgeHandler: Handler;
+    PrependEdgeHandler: Handler;
+    AppendNodeHandler: Handler;
+    PrependNodeHandler: Handler;
+};

package/index.d.ts

@@ -0,0 +1,274 @@
+/**
+ * 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 * as ConnectionHandler from './handlers/connection/ConnectionHandler';
+import ConnectionInterface from './handlers/connection/ConnectionInterface';
+// Extensions
+import RelayDefaultHandlerProvider from './handlers/RelayDefaultHandlerProvider';
+import QueryResponseCache from './network/RelayQueryResponseCache';
+import * as fetchQueryInternal from './query/fetchQueryInternal';
+import * as RelayResolverFragments from './store/ResolverFragments';
+import withProvidedVariables from './util/withProvidedVariables';
+
+export { ConnectionInterface };
+export { ConnectionMetadata } from './handlers/connection/ConnectionHandler';
+export { EdgeRecord, PageInfo } from './handlers/connection/ConnectionInterface';
+export { OptimisticMutationConfig } from './mutations/applyOptimisticMutation';
+export { MutationConfig, MutationParameters } from './mutations/commitMutation';
+export {
+    DeclarativeMutationConfig,
+    MutationTypes,
+    RangeBehaviors,
+    RangeOperations,
+} from './mutations/RelayDeclarativeMutationConfig';
+export {
+    MutationTypes as MutationType,
+    RangeOperations as RangeOperation,
+} from './mutations/RelayDeclarativeMutationConfig';
+export {
+    ExecuteFunction,
+    FetchFunction,
+    GraphQLResponse,
+    GraphQLResponseWithData,
+    GraphQLResponseWithoutData,
+    GraphQLSingularResponse,
+    LogRequestInfoFunction,
+    Network as INetwork,
+    PayloadData,
+    PayloadError,
+    ReactFlightPayloadData,
+    ReactFlightPayloadQuery,
+    ReactFlightServerTree,
+    SubscribeFunction,
+    Uploadable,
+    UploadableMap,
+} from './network/RelayNetworkTypes';
+export { ObservableFromValue, Observer, Subscribable, Subscription } from './network/RelayObservable';
+export {
+    getFragment,
+    getInlineDataFragment,
+    getNode,
+    getPaginationFragment,
+    getRefetchableFragment,
+    getRequest,
+    graphql,
+    GraphQLTaggedNode,
+    isFragment,
+    isInlineDataFragment,
+    isRequest,
+} from './query/GraphQLTag';
+export { generateClientID, generateUniqueClientID, isClientID } from './store/ClientID';
+export { TaskScheduler } from './store/OperationExecutor';
+export { RecordState } from './store/RelayRecordState';
+export {
+    Environment as IEnvironment,
+    FragmentMap,
+    FragmentPointer,
+    FragmentSpecResolver,
+    FragmentType,
+    /** @deprecated use FragmentType instead of FragmentReference */
+    FragmentType as FragmentReference,
+    HandleFieldPayload,
+    HasUpdatableSpread,
+    InvalidationState,
+    LiveState,
+    LogEvent,
+    LogFunction,
+    MissingFieldHandler,
+    ModuleImportPointer,
+    MutableRecordSource,
+    NormalizationSelector,
+    OperationAvailability,
+    OperationDescriptor,
+    OperationLoader,
+    OperationTracker,
+    OptimisticResponseConfig,
+    OptimisticUpdate,
+    OptimisticUpdateFunction,
+    PluralReaderSelector,
+    Props,
+    PublishQueue,
+    ReactFlightClientResponse,
+    ReactFlightPayloadDeserializer,
+    ReaderSelector,
+    ReadOnlyRecordProxy,
+    RecordProxy,
+    RecordSourceProxy,
+    RecordSourceSelectorProxy,
+    RelayContext,
+    RelayFieldLogger,
+    RequestDescriptor,
+    SelectorData,
+    SelectorStoreUpdater,
+    SingularReaderSelector,
+    Snapshot,
+    StoreUpdater,
+    suspenseSentinel,
+    UpdatableFragmentData,
+    UpdatableQueryData,
+} from './store/RelayStoreTypes';
+export { GraphQLSubscriptionConfig } from './subscription/requestSubscription';
+export {
+    NormalizationArgument,
+    NormalizationDefer,
+    NormalizationField,
+    NormalizationFlightField,
+    NormalizationLinkedField,
+    NormalizationLinkedHandle,
+    NormalizationLocalArgumentDefinition,
+    NormalizationModuleImport,
+    NormalizationOperation,
+    NormalizationRootNode,
+    NormalizationScalarField,
+    NormalizationSelection,
+    NormalizationSplitOperation,
+    NormalizationStream,
+    NormalizationTypeDiscriminator,
+} from './util/NormalizationNode';
+export {
+    ReaderArgument,
+    ReaderArgumentDefinition,
+    ReaderCondition,
+    ReaderField,
+    ReaderFlightField,
+    ReaderFragment,
+    ReaderInlineDataFragment,
+    ReaderInlineDataFragmentSpread,
+    ReaderInlineFragment,
+    ReaderLinkedField,
+    ReaderModuleImport,
+    ReaderPaginationMetadata,
+    ReaderRefetchableFragment,
+    ReaderRefetchMetadata,
+    ReaderRequiredField,
+    ReaderScalarField,
+    ReaderSelection,
+    RequiredFieldAction,
+} from './util/ReaderNode';
+export {
+    ConcreteRequest,
+    ConcreteUpdatableQuery,
+    GeneratedNode,
+    PreloadableConcreteRequest,
+    RequestParameters,
+} from './util/RelayConcreteNode';
+export { RelayReplaySubject as ReplaySubject } from './util/RelayReplaySubject';
+export * from './util/RelayRuntimeTypes';
+// Core API
+export { RelayNetwork as Network } from './network/RelayNetwork';
+export { RelayObservable as Observable } from './network/RelayObservable';
+export { default as Environment, EnvironmentConfig } from './store/RelayModernEnvironment';
+export { QueryResponseCache };
+export { RelayModernRecord as Record } from './store/RelayModernRecord';
+export { default as Store } from './store/RelayModernStore';
+export { RelayRecordSource as RecordSource } from './store/RelayRecordSource';
+export { type IdOf, isErrorResult, isValueResult, type Result } from './experimental';
+export { createFragmentSpecResolver } from './store/createFragmentSpecResolver';
+export { readInlineData } from './store/readInlineData';
+export { createOperationDescriptor, createRequestDescriptor } from './store/RelayModernOperationDescriptor';
+export {
+    areEqualSelectors,
+    createNormalizationSelector,
+    createReaderSelector,
+    getDataIDsFromFragment,
+    getDataIDsFromObject,
+    getPluralSelector,
+    getSelector,
+    getSelectorsFromObject,
+    getSingularSelector,
+    getVariablesFromFragment,
+    getVariablesFromObject,
+    getVariablesFromPluralFragment,
+    getVariablesFromSingularFragment,
+} from './store/RelayModernSelector';
+export {
+    FRAGMENT_OWNER_KEY,
+    FRAGMENTS_KEY,
+    getModuleComponentKey,
+    getModuleOperationKey,
+    getStorageKey,
+    ID_KEY,
+    REF_KEY,
+    REFS_KEY,
+    ROOT_ID,
+    ROOT_TYPE,
+    TYPENAME_KEY,
+} from './store/RelayStoreUtils';
+export { readFragment } from './store/ResolverFragments';
+export { RelayDefaultHandlerProvider as DefaultHandlerProvider };
+export declare function getDefaultMissingFieldHandlers(): import('./store/RelayStoreTypes').MissingFieldHandler[];
+export { ConnectionHandler };
+export { MutationHandlers } from './handlers/connection/MutationHandlers';
+export { VIEWER_ID, VIEWER_TYPE } from './store/ViewerPattern';
+// Helpers (can be implemented via the above API)
+export { applyOptimisticMutation } from './mutations/applyOptimisticMutation';
+export { commitLocalUpdate } from './mutations/commitLocalUpdate';
+export { commitMutation } from './mutations/commitMutation';
+export { fetchQuery } from './query/fetchQuery';
+export { fetchQuery_DEPRECATED } from './query/fetchQuery_DEPRECATED';
+export { isRelayModernEnvironment } from './store/isRelayModernEnvironment';
+export { requestSubscription } from './subscription/requestSubscription';
+// Utilities
+export { default as createPayloadFor3DField } from './util/createPayloadFor3DField';
+export { default as getFragmentIdentifier } from './util/getFragmentIdentifier';
+export { default as getPaginationMetadata } from './util/getPaginationMetadata';
+export { default as getPaginationVariables } from './util/getPaginationVariables';
+export { Direction } from './util/getPaginationVariables';
+export { default as getRefetchMetadata } from './util/getRefetchMetadata';
+export { default as getRelayHandleKey } from './util/getRelayHandleKey';
+export { default as getRequestIdentifier } from './util/getRequestIdentifier';
+export { default as getValueAtPath } from './util/getValueAtPath';
+export { default as handlePotentialSnapshotErrors } from './util/handlePotentialSnapshotErrors';
+export declare const PreloadableQueryRegistry: {
+    set(key: string, value: import('./util/RelayConcreteNode').ConcreteRequest): void;
+    get(key: string): import('./util/RelayConcreteNode').ConcreteRequest | null | undefined;
+    onLoad(key: string, callback: (concreteRequest: import('./util/RelayConcreteNode').ConcreteRequest) => void): import('./util/RelayRuntimeTypes').Disposable;
+    clear(): void;
+};
+export { RelayProfiler } from './util/RelayProfiler';
+// INTERNAL-ONLY
+export { RelayConcreteNode } from './util/RelayConcreteNode';
+export { default as RelayError } from './util/RelayError';
+export { RelayFeatureFlags } from './util/RelayFeatureFlags';
+export const DEFAULT_HANDLE_KEY = '';
+export { default as deepFreeze } from './util/deepFreeze';
+export { default as getPendingOperationsForFragment } from './util/getPendingOperationsForFragment';
+export { default as isPromise } from './util/isPromise';
+export { default as isScalarAndEqual } from './util/isScalarAndEqual';
+export { default as recycleNodesInto } from './util/recycleNodesInto';
+export { default as stableCopy } from './util/stableCopy';
+
+interface Internal {
+    fetchQuery: typeof fetchQueryInternal.fetchQuery;
+    fetchQueryDeduped: typeof fetchQueryInternal.fetchQueryDeduped;
+    getPromiseForActiveRequest: typeof fetchQueryInternal.getPromiseForActiveRequest;
+    getObservableForActiveRequest: typeof fetchQueryInternal.getObservableForActiveRequest;
+    ResolverFragments: typeof RelayResolverFragments;
+    withProvidedVariables: typeof withProvidedVariables;
+}
+
+export const __internal: Internal;
+
+/**
+ * relay-compiler-language-typescript support for fragment references
+ */
+
+export interface _RefType<Ref extends string> {
+    ' $fragmentType': Ref;
+}
+
+export interface _FragmentRefs<Refs extends string> {
+    ' $fragmentSpreads': FragmentRefs<Refs>;
+}
+
+// This is used in the actual artifacts to define the various fragment references a container holds.
+export type FragmentRefs<Refs extends string> = {
+    [ref in Refs]: true;
+};
+
+// This is a utility type for converting from a data type to a fragment reference that will resolve to that data type.
+export type FragmentRef<Fragment> = Fragment extends _RefType<infer U> ? _FragmentRefs<U> : never;

package/index.js

@@ -1,5 +1,5 @@
 /**
- * Relay v20.1.1
+ * Relay v21.0.1
  *
  * Copyright (c) Meta Platforms, Inc. and affiliates.
  *