@apollo/client
Version:
A fully-featured caching GraphQL client.
90 lines (89 loc) • 5.04 kB
TypeScript
import type { DocumentNode, FormattedExecutionResult } from "graphql";
import type { Cache } from "@apollo/client/cache";
import type { Incremental } from "@apollo/client/incremental";
import type { ApolloLink } from "@apollo/client/link";
import type { Unmasked } from "@apollo/client/masking";
import type { ExtensionsWithStreamInfo } from "@apollo/client/utilities/internal";
import type { ApolloClient } from "./ApolloClient.js";
import { NetworkStatus } from "./networkStatus.js";
import type { ObservableQuery } from "./ObservableQuery.js";
import type { QueryManager } from "./QueryManager.js";
import type { DataValue, DefaultContext, InternalRefetchQueriesInclude, MutationUpdaterFunction, NormalizedExecutionResult, OnQueryUpdated, OperationVariables, TypedDocumentNode } from "./types.js";
import type { ErrorPolicy, WatchQueryFetchPolicy } from "./watchQueryOptions.js";
type UpdateQueries<TData> = ApolloClient.MutateOptions<TData, any, any>["updateQueries"];
export declare const enum CacheWriteBehavior {
FORBID = 0,
OVERWRITE = 1,
MERGE = 2
}
interface LastWrite {
result: FormattedExecutionResult<any, ExtensionsWithStreamInfo>;
variables: ApolloClient.WatchQueryOptions["variables"];
dmCount: number | undefined;
hasNext: boolean;
}
interface OperationInfo<TData, TVariables extends OperationVariables, AllowedCacheWriteBehavior = CacheWriteBehavior> {
document: DocumentNode | TypedDocumentNode<TData, TVariables>;
variables: TVariables;
errorPolicy: ErrorPolicy;
cacheWriteBehavior: AllowedCacheWriteBehavior;
returnPartialData?: boolean | undefined;
}
interface MarkQueryResult<TData, TExtensions> extends FormattedExecutionResult<TData, TExtensions> {
dataState: "empty" | "partial" | "streaming" | "complete";
}
export declare class QueryInfo<TData, TVariables extends OperationVariables = OperationVariables, TCache extends Cache.Implementation = Cache.Implementation> {
private cache;
private queryManager;
readonly id: string;
private readonly observableQuery?;
private incremental?;
constructor(queryManager: QueryManager, observableQuery?: ObservableQuery<any, any>);
/**
* @internal
* Tracks the last result written to the cache so that `shouldWrite` can skip
* an identical write. Since a `QueryInfo` only ever represents a single
* network request, this is shared by all `QueryInfo` instances of an
* `ObservableQuery`. A standalone `QueryInfo` keeps a local version.
*
* A network result that was explicitly asked for always takes precedence over
* what is already cached, so `ObservableQuery.refetch` and polling clear this
* value before starting their request.
*
* @deprecated This is an internal API and should not be used directly. This can be removed or changed at any time.
*/
_lastWrite?: LastWrite;
private get lastWrite();
private set lastWrite(value);
resetLastWrite(): void;
private shouldWrite;
get hasNext(): boolean;
get incrementalHandler(): Incremental.Handler<Record<string, unknown>>;
private maybeHandleIncrementalResult;
markQueryResult(incoming: ApolloLink.Result<TData>, { document: query, variables, errorPolicy, cacheWriteBehavior, returnPartialData, fetchPolicy, networkStatus, prunePendingDeferFragments: prune, }: OperationInfo<TData, TVariables> & {
fetchPolicy: WatchQueryFetchPolicy;
networkStatus: NetworkStatus;
prunePendingDeferFragments: boolean;
}): MarkQueryResult<DataValue.Complete<TData> | DataValue.Streaming<TData>, ExtensionsWithStreamInfo>;
private getIncrementalInfo;
private getDiff;
markMutationResult(incoming: ApolloLink.Result<TData>, mutation: OperationInfo<TData, TVariables, CacheWriteBehavior.FORBID | CacheWriteBehavior.MERGE> & {
context?: DefaultContext;
updateQueries: UpdateQueries<TData>;
update?: MutationUpdaterFunction<TData, TVariables, TCache>;
awaitRefetchQueries?: boolean;
refetchQueries?: ((result: NormalizedExecutionResult<Unmasked<TData>>) => InternalRefetchQueriesInclude) | InternalRefetchQueriesInclude;
removeOptimistic?: string;
onQueryUpdated?: OnQueryUpdated<any>;
keepRootFields?: boolean;
}, cache?: TCache): Promise<FormattedExecutionResult<DataValue.Complete<TData> | DataValue.Streaming<TData>, ExtensionsWithStreamInfo>>;
markMutationOptimistic(optimisticResponse: any, mutation: OperationInfo<TData, TVariables, CacheWriteBehavior.FORBID | CacheWriteBehavior.MERGE> & {
context?: DefaultContext;
updateQueries: UpdateQueries<TData>;
update?: MutationUpdaterFunction<TData, TVariables, TCache>;
keepRootFields?: boolean;
}): boolean;
markSubscriptionResult(result: FormattedExecutionResult<TData>, { document, variables, errorPolicy, cacheWriteBehavior, }: OperationInfo<TData, TVariables, CacheWriteBehavior.FORBID | CacheWriteBehavior.MERGE>): void;
}
export {};
//# sourceMappingURL=QueryInfo.d.ts.map