@apollo/client 4.0.0-alpha.1 → 4.0.0-alpha.11

package/core/QueryManager.d.ts

@@ -2,14 +2,15 @@ import { Trie } from "@wry/trie";
 import type { DocumentNode } from "graphql";
 import { Observable } from "rxjs";
 import type { ApolloCache, Cache } from "@apollo/client/cache";
-import type { ApolloLink, FetchResult } from "@apollo/client/link/core";
+import type { FetchResult } from "@apollo/client/link/core";
 import type { MaybeMasked } from "@apollo/client/masking";
 import { DocumentTransform } from "@apollo/client/utilities";
-import type { DefaultOptions } from "./ApolloClient.js";
+import type { ApolloClient, DefaultOptions } from "./ApolloClient.js";
 import type { LocalState } from "./LocalState.js";
 import { NetworkStatus } from "./networkStatus.js";
 import { ObservableQuery } from "./ObservableQuery.js";
-import type { ApolloQueryResult, DefaultContext, InternalRefetchQueriesInclude, InternalRefetchQueriesMap, InternalRefetchQueriesOptions, MutationUpdaterFunction, OnQueryUpdated, OperationVariables } from "./types.js";
+import { QueryInfo } from "./QueryInfo.js";
+import type { ApolloQueryResult, ClientAwareness, DefaultContext, InternalRefetchQueriesInclude, InternalRefetchQueriesMap, InternalRefetchQueriesOptions, MutateResult, MutationUpdaterFunction, OnQueryUpdated, OperationVariables, QueryResult, SubscribeResult, TypedDocumentNode } from "./types.js";
 import type { ErrorPolicy, MutationFetchPolicy, MutationOptions, QueryOptions, SubscriptionOptions, WatchQueryFetchPolicy, WatchQueryOptions } from "./watchQueryOptions.js";
 interface MutationStoreValue {
     mutation: DocumentNode;
@@ -39,24 +40,22 @@ interface MaskOperationOptions<TData> {
     id: string;
     fetchPolicy?: WatchQueryFetchPolicy;
 }
-interface QueryManagerOptions<TStore> {
-    cache: ApolloCache<TStore>;
-    link: ApolloLink;
+interface QueryManagerOptions {
+    client: ApolloClient;
     defaultOptions: DefaultOptions;
     documentTransform: DocumentTransform | null | undefined;
     queryDeduplication: boolean;
     onBroadcast: undefined | (() => void);
     ssrMode: boolean;
-    clientAwareness: Record<string, string>;
-    localState: LocalState<TStore>;
+    clientAwareness: ClientAwareness;
+    localState: LocalState;
     assumeImmutableResults: boolean;
     defaultContext: Partial<DefaultContext> | undefined;
     dataMasking: boolean;
 }
-export declare class QueryManager<TStore> {
-    cache: ApolloCache<TStore>;
-    link: ApolloLink;
+export declare class QueryManager {
     defaultOptions: DefaultOptions;
+    readonly client: ApolloClient;
     readonly assumeImmutableResults: boolean;
     readonly documentTransform: DocumentTransform;
     readonly ssrMode: boolean;
@@ -65,21 +64,34 @@ export declare class QueryManager<TStore> {
     private queryDeduplication;
     private clientAwareness;
     private localState;
+    /**
+     * Whether to prioritize cache values over network results when
+     * `fetchObservableWithInfo` is called.
+     * This will essentially turn a `"network-only"` or `"cache-and-network"`
+     * fetchPolicy into a `"cache-first"` fetchPolicy, but without influencing
+     * the `fetchPolicy` of the `ObservableQuery`.
+     *
+     * This can e.g. be used to prioritize the cache during the first render after
+     * SSR.
+     */
+    prioritizeCacheValues: boolean;
     private onBroadcast?;
     mutationStore?: {
         [mutationId: string]: MutationStoreValue;
     };
     private queries;
     protected fetchCancelFns: Map<string, (error: any) => any>;
-    constructor(options: QueryManagerOptions<TStore>);
+    constructor(options: QueryManagerOptions);
+    get link(): import("@apollo/client/link/core").ApolloLink;
+    get cache(): ApolloCache;
     /**
      * Call this method to terminate any active query processes, making it safe
      * to dispose of this QueryManager instance.
      */
     stop(): void;
     private cancelPendingFetches;
-    mutate<TData, TVariables extends OperationVariables, TContext extends Record<string, any>, TCache extends ApolloCache<any>>({ mutation, variables, optimisticResponse, updateQueries, refetchQueries, awaitRefetchQueries, update: updateWithProxyFn, onQueryUpdated, fetchPolicy, errorPolicy, keepRootFields, context, }: MutationOptions<TData, TVariables, TContext>): Promise<FetchResult<MaybeMasked<TData>>>;
-    markMutationResult<TData, TVariables, TContext, TCache extends ApolloCache<any>>(mutation: {
+    mutate<TData, TVariables extends OperationVariables, TContext extends Record<string, any>, TCache extends ApolloCache>({ mutation, variables, optimisticResponse, updateQueries, refetchQueries, awaitRefetchQueries, update: updateWithProxyFn, onQueryUpdated, fetchPolicy, errorPolicy, keepRootFields, context, }: MutationOptions<TData, TVariables, TContext>): Promise<MutateResult<MaybeMasked<TData>>>;
+    markMutationResult<TData, TVariables extends OperationVariables, TContext, TCache extends ApolloCache>(mutation: {
         mutationId: string;
         result: FetchResult<TData>;
         document: DocumentNode;
@@ -94,8 +106,8 @@ export declare class QueryManager<TStore> {
         removeOptimistic?: string;
         onQueryUpdated?: OnQueryUpdated<any>;
         keepRootFields?: boolean;
-    }, cache?: ApolloCache<TStore>): Promise<FetchResult<TData>>;
-    markMutationOptimistic<TData, TVariables, TContext, TCache extends ApolloCache<any>>(optimisticResponse: any, mutation: {
+    }, cache?: ApolloCache): Promise<FetchResult<TData>>;
+    markMutationOptimistic<TData, TVariables extends OperationVariables, TContext, TCache extends ApolloCache>(optimisticResponse: any, mutation: {
         mutationId: string;
         document: DocumentNode;
         variables?: TVariables;
@@ -106,13 +118,13 @@ export declare class QueryManager<TStore> {
         update?: MutationUpdaterFunction<TData, TVariables, TContext, TCache>;
         keepRootFields?: boolean;
     }): boolean;
-    fetchQuery<TData, TVars extends OperationVariables>(queryId: string, options: WatchQueryOptions<TVars, TData>, networkStatus?: NetworkStatus): Promise<ApolloQueryResult<TData>>;
+    fetchQuery<TData, TVars extends OperationVariables>(queryId: string, options: WatchQueryOptions<TVars, TData>, networkStatus?: NetworkStatus): Promise<QueryResult<TData>>;
     transform(document: DocumentNode): DocumentNode;
     private transformCache;
     getDocumentInfo(document: DocumentNode): TransformCacheEntry;
-    private getVariables;
+    getVariables<TVariables>(document: DocumentNode, variables?: TVariables): TVariables;
     watchQuery<T, TVariables extends OperationVariables = OperationVariables>(options: WatchQueryOptions<TVariables, T>): ObservableQuery<T, TVariables>;
-    query<TData, TVars extends OperationVariables = OperationVariables>(options: QueryOptions<TVars, TData>, queryId?: string): Promise<ApolloQueryResult<MaybeMasked<TData>>>;
+    query<TData, TVars extends OperationVariables = OperationVariables>(options: QueryOptions<TVars, TData>, queryId?: string): Promise<QueryResult<MaybeMasked<TData>>>;
     private queryIdCounter;
     generateQueryId(): string;
     private requestIdCounter;
@@ -121,28 +133,25 @@ export declare class QueryManager<TStore> {
     generateMutationId(): string;
     clearStore(options?: Cache.ResetOptions): Promise<void>;
     getObservableQueries(include?: InternalRefetchQueriesInclude): Map<string, ObservableQuery<any, OperationVariables>>;
-    reFetchObservableQueries(includeStandby?: boolean): Promise<ApolloQueryResult<any>[]>;
-    setObservableQuery(observableQuery: ObservableQuery<any, any>): void;
-    startGraphQLSubscription<T = any>(options: SubscriptionOptions): Observable<FetchResult<T>>;
-    stopQuery(queryId: string): void;
+    reFetchObservableQueries(includeStandby?: boolean): Promise<QueryResult<any>[]>;
+    startGraphQLSubscription<TData = unknown>(options: SubscriptionOptions): Observable<SubscribeResult<TData>>;
     removeQuery(queryId: string): void;
     broadcastQueries(): void;
-    getLocalState(): LocalState<TStore>;
+    getLocalState(): LocalState;
     protected inFlightLinkObservables: Trie<{
         observable?: Observable<FetchResult<any>>;
     }>;
     private getObservableFromLink;
     private getResultsFromLink;
-    fetchObservableWithInfo<TData, TVars extends OperationVariables>(queryId: string, options: WatchQueryOptions<TVars, TData>, networkStatus?: NetworkStatus, query?: DocumentNode | import("@graphql-typed-document-node/core").TypedDocumentNode<TData, TVars>, emitLoadingState?: boolean): ObservableAndInfo<TData>;
-    refetchQueries<TResult>({ updateCache, include, optimistic, removeOptimistic, onQueryUpdated, }: InternalRefetchQueriesOptions<ApolloCache<TStore>, TResult>): InternalRefetchQueriesMap<TResult>;
+    fetchObservableWithInfo<TData, TVars extends OperationVariables>(queryInfo: QueryInfo, options: WatchQueryOptions<TVars, TData>, networkStatus?: NetworkStatus, query?: DocumentNode | TypedDocumentNode<TData, TVars>, emitLoadingState?: boolean): ObservableAndInfo<TData>;
+    refetchQueries<TResult>({ updateCache, include, optimistic, removeOptimistic, onQueryUpdated, }: InternalRefetchQueriesOptions<ApolloCache, TResult>): InternalRefetchQueriesMap<TResult>;
     private noCacheWarningsByQueryId;
     maskOperation<TData = unknown>(options: MaskOperationOptions<TData>): MaybeMasked<TData>;
     maskFragment<TData = unknown>(options: MaskFragmentOptions<TData>): TData;
     private fetchQueryByPolicy;
-    private getQuery;
-    private prepareContext;
+    getOrCreateQuery(queryId: string): QueryInfo;
 }
-export interface ObservableAndInfo<TData> {
+interface ObservableAndInfo<TData> {
     fromLink: boolean;
     observable: Observable<ApolloQueryResult<TData>>;
 }