relay-runtime 0.0.0-main-ff9b2fed → 0.0.0-main-2b59edeb

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 v0.0.0-main-ff9b2fed
+ * Relay v0.0.0-main-2b59edeb
  *
  * Copyright (c) Meta Platforms, Inc. and affiliates.
  *

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/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/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 v0.0.0-main-ff9b2fed
+ * Relay v0.0.0-main-2b59edeb
  *
  * Copyright (c) Meta Platforms, Inc. and affiliates.
  *

package/multi-actor-environment/ActorIdentifier.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.
+ */
+
+/**
+ * A unique identifier of the current actor.
+ */
+export type ActorIdentifier = string;
+
+export function assertInternalActorIdentifier(actorIdentifier: ActorIdentifier): void;
+
+export function getActorIdentifier(actorID: string): ActorIdentifier;
+
+export function getDefaultActorIdentifier(): ActorIdentifier;

package/multi-actor-environment/MultiActorEnvironment.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 { HandlerProvider } from '../handlers/RelayDefaultHandlerProvider';
+import { MutationParameters } from '../mutations/commitMutation';
+import {GraphQLResponse, Network, PayloadData} from '../network/RelayNetworkTypes';
+import { RelayObservable as Observable } from '../network/RelayObservable';
+import { TaskScheduler } from '../store/OperationExecutor';
+import { GetDataID } from '../store/RelayResponseNormalizer';
+import {
+  ExecuteMutationConfig,
+  LogFunction,
+  MissingFieldHandler,
+  OperationAvailability,
+  OperationDescriptor,
+  OperationLoader,
+  OptimisticResponseConfig,
+  OptimisticUpdateFunction,
+  RelayFieldLogger,
+  SelectorStoreUpdater,
+  SingularReaderSelector,
+  Snapshot,
+  Store,
+  StoreUpdater,
+} from '../store/RelayStoreTypes';
+import {Disposable, RenderPolicy} from '../util/RelayRuntimeTypes';
+import { ActorIdentifier } from './ActorIdentifier';
+import {
+  ActorEnvironment,
+  MultiActorEnvironment as IMultiActorEnvironment,
+  MultiActorStoreUpdater,
+} from './MultiActorEnvironmentTypes';
+
+export type MultiActorEnvironmentConfig = Readonly<{
+    createConfigNameForActor?: ((actorIdentifier: ActorIdentifier) => string) | null;
+    createNetworkForActor: (actorIdentifier: ActorIdentifier) => Network;
+    createStoreForActor?: ((actorIdentifier: ActorIdentifier) => Store) | null;
+    defaultRenderPolicy?: RenderPolicy | null;
+    getDataID?: GetDataID;
+    handlerProvider?: HandlerProvider;
+    isServer?: boolean | null;
+    logFn?: LogFunction | null;
+    missingFieldHandlers?: readonly MissingFieldHandler[] | null;
+    operationLoader?: OperationLoader | null;
+    relayFieldLogger?: RelayFieldLogger | null;
+    scheduler?: TaskScheduler | null;
+    shouldProcessClientComponents?: boolean | null;
+    treatMissingFieldsAsNull?: boolean;
+}>;
+
+export class MultiActorEnvironment implements IMultiActorEnvironment {
+    constructor(config: MultiActorEnvironmentConfig);
+
+    forActor(actorIdentifier: string): ActorEnvironment;
+
+    check(actorEnvironment: ActorEnvironment, operation: OperationDescriptor): OperationAvailability;
+
+    subscribe(
+        actorEnvironment: ActorEnvironment,
+        snapshot: Snapshot,
+        callback: (snapshot: Snapshot) => void,
+    ): Disposable;
+
+    retain(actorEnvironment: ActorEnvironment, operation: OperationDescriptor): Disposable;
+
+    applyUpdate(actorEnvironment: ActorEnvironment, optimisticUpdate: OptimisticUpdateFunction): Disposable;
+
+    revertUpdate(actorEnvironment: ActorEnvironment, update: OptimisticUpdateFunction): void;
+
+    replaceUpdate(
+        actorEnvironment: ActorEnvironment,
+        update: OptimisticUpdateFunction,
+        replacement: OptimisticUpdateFunction,
+    ): void;
+
+    applyMutation(
+        actorEnvironment: ActorEnvironment,
+        optimisticConfig: OptimisticResponseConfig<MutationParameters>,
+    ): Disposable;
+
+    commitUpdate(actorEnvironment: ActorEnvironment, updater: StoreUpdater): void;
+
+    commitMultiActorUpdate(updater: MultiActorStoreUpdater): void;
+
+    commitPayload(
+        actorEnvironment: ActorEnvironment,
+        operationDescriptor: OperationDescriptor,
+        payload: PayloadData,
+    ): void;
+
+    lookup(actorEnvironment: ActorEnvironment, selector: SingularReaderSelector): Snapshot;
+
+    execute(
+        actorEnvironment: ActorEnvironment,
+        config: { operation: OperationDescriptor },
+    ): Observable<GraphQLResponse>;
+
+    executeSubscription(
+        actorEnvironment: ActorEnvironment,
+        config: {
+            operation: OperationDescriptor;
+            updater?: SelectorStoreUpdater<MutationParameters['response']> | null | undefined;
+        },
+    ): Observable<GraphQLResponse>;
+
+    executeMutation(
+        actorEnvironment: ActorEnvironment,
+        config: ExecuteMutationConfig<MutationParameters>,
+    ): Observable<GraphQLResponse>;
+
+    executeWithSource(
+        actorEnvironment: ActorEnvironment,
+        arg: { operation: OperationDescriptor; source: Observable<GraphQLResponse> },
+    ): Observable<GraphQLResponse>;
+
+    isRequestActive(actorEnvironment: ActorEnvironment, requestIdentifier: string): boolean;
+
+    isServer(): boolean;
+}