UNPKG

6.21 kBTypeScriptView Raw
1import { DocumentNode } from 'graphql';
2import { ApolloLink, FetchResult } from '../link/core';
3import { Cache, ApolloCache } from '../cache';
4import { Observable, Concast } from '../utilities';
5import { QueryOptions, WatchQueryOptions, SubscriptionOptions, MutationOptions, ErrorPolicy, MutationFetchPolicy } from './watchQueryOptions';
6import { ObservableQuery } from './ObservableQuery';
7import { NetworkStatus } from './networkStatus';
8import { ApolloQueryResult, OperationVariables, MutationUpdaterFunction, OnQueryUpdated, InternalRefetchQueriesInclude, InternalRefetchQueriesOptions, InternalRefetchQueriesMap } from './types';
9import { LocalState } from './LocalState';
10import { QueryStoreValue } from './QueryInfo';
11interface MutationStoreValue {
12 mutation: DocumentNode;
13 variables: Record<string, any>;
14 loading: boolean;
15 error: Error | null;
16}
17type UpdateQueries<TData> = MutationOptions<TData, any, any>["updateQueries"];
18interface TransformCacheEntry {
19 document: DocumentNode;
20 hasClientExports: boolean;
21 hasForcedResolvers: boolean;
22 clientQuery: DocumentNode | null;
23 serverQuery: DocumentNode | null;
24 defaultVars: OperationVariables;
25 asQuery: DocumentNode;
26}
27type DefaultOptions = import("./ApolloClient").DefaultOptions;
28export declare class QueryManager<TStore> {
29 cache: ApolloCache<TStore>;
30 link: ApolloLink;
31 defaultOptions: DefaultOptions;
32 readonly assumeImmutableResults: boolean;
33 readonly ssrMode: boolean;
34 private queryDeduplication;
35 private clientAwareness;
36 private localState;
37 private onBroadcast?;
38 mutationStore?: {
39 [mutationId: string]: MutationStoreValue;
40 };
41 private queries;
42 private fetchCancelFns;
43 constructor({ cache, link, defaultOptions, queryDeduplication, onBroadcast, ssrMode, clientAwareness, localState, assumeImmutableResults, }: {
44 cache: ApolloCache<TStore>;
45 link: ApolloLink;
46 defaultOptions?: DefaultOptions;
47 queryDeduplication?: boolean;
48 onBroadcast?: () => void;
49 ssrMode?: boolean;
50 clientAwareness?: Record<string, string>;
51 localState?: LocalState<TStore>;
52 assumeImmutableResults?: boolean;
53 });
54 stop(): void;
55 private cancelPendingFetches;
56 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<TData>>;
57 markMutationResult<TData, TVariables, TContext, TCache extends ApolloCache<any>>(mutation: {
58 mutationId: string;
59 result: FetchResult<TData>;
60 document: DocumentNode;
61 variables?: TVariables;
62 fetchPolicy?: MutationFetchPolicy;
63 errorPolicy: ErrorPolicy;
64 context?: TContext;
65 updateQueries: UpdateQueries<TData>;
66 update?: MutationUpdaterFunction<TData, TVariables, TContext, TCache>;
67 awaitRefetchQueries?: boolean;
68 refetchQueries?: InternalRefetchQueriesInclude;
69 removeOptimistic?: string;
70 onQueryUpdated?: OnQueryUpdated<any>;
71 keepRootFields?: boolean;
72 }, cache?: ApolloCache<TStore>): Promise<FetchResult<TData>>;
73 markMutationOptimistic<TData, TVariables, TContext, TCache extends ApolloCache<any>>(optimisticResponse: any, mutation: {
74 mutationId: string;
75 document: DocumentNode;
76 variables?: TVariables;
77 fetchPolicy?: MutationFetchPolicy;
78 errorPolicy: ErrorPolicy;
79 context?: TContext;
80 updateQueries: UpdateQueries<TData>;
81 update?: MutationUpdaterFunction<TData, TVariables, TContext, TCache>;
82 keepRootFields?: boolean;
83 }): void;
84 fetchQuery<TData, TVars extends OperationVariables>(queryId: string, options: WatchQueryOptions<TVars, TData>, networkStatus?: NetworkStatus): Promise<ApolloQueryResult<TData>>;
85 getQueryStore(): Record<string, QueryStoreValue>;
86 resetErrors(queryId: string): void;
87 private transformCache;
88 transform(document: DocumentNode): TransformCacheEntry;
89 private getVariables;
90 watchQuery<T, TVariables extends OperationVariables = OperationVariables>(options: WatchQueryOptions<TVariables, T>): ObservableQuery<T, TVariables>;
91 query<TData, TVars extends OperationVariables = OperationVariables>(options: QueryOptions<TVars, TData>, queryId?: string): Promise<ApolloQueryResult<TData>>;
92 private queryIdCounter;
93 generateQueryId(): string;
94 private requestIdCounter;
95 generateRequestId(): number;
96 private mutationIdCounter;
97 generateMutationId(): string;
98 stopQueryInStore(queryId: string): void;
99 private stopQueryInStoreNoBroadcast;
100 clearStore(options?: Cache.ResetOptions): Promise<void>;
101 getObservableQueries(include?: InternalRefetchQueriesInclude): Map<string, ObservableQuery<any, OperationVariables>>;
102 reFetchObservableQueries(includeStandby?: boolean): Promise<ApolloQueryResult<any>[]>;
103 setObservableQuery(observableQuery: ObservableQuery<any, any>): void;
104 startGraphQLSubscription<T = any>({ query, fetchPolicy, errorPolicy, variables, context, }: SubscriptionOptions): Observable<FetchResult<T>>;
105 stopQuery(queryId: string): void;
106 private stopQueryNoBroadcast;
107 removeQuery(queryId: string): void;
108 broadcastQueries(): void;
109 getLocalState(): LocalState<TStore>;
110 private inFlightLinkObservables;
111 private getObservableFromLink;
112 private getResultsFromLink;
113 fetchQueryObservable<TData, TVars extends OperationVariables>(queryId: string, options: WatchQueryOptions<TVars, TData>, networkStatus?: NetworkStatus): Concast<ApolloQueryResult<TData>>;
114 private fetchConcastWithInfo;
115 refetchQueries<TResult>({ updateCache, include, optimistic, removeOptimistic, onQueryUpdated, }: InternalRefetchQueriesOptions<ApolloCache<TStore>, TResult>): InternalRefetchQueriesMap<TResult>;
116 private fetchQueryByPolicy;
117 private getQuery;
118 private prepareContext;
119}
120export {};
121//# sourceMappingURL=QueryManager.d.ts.map
\No newline at end of file