@apollo/client
- Version 3.7.10
- Published
- 4.52 MB
- 13 dependencies
- MIT license
Install
npm i @apollo/client
yarn add @apollo/client
pnpm add @apollo/client
Overview
A fully-featured caching GraphQL client.
Index
Variables
Functions
- checkFetcher()
- createHttpLink()
- createSignalIfSupported()
- defaultDataIdFromObject()
- fromError()
- fromPromise()
- getApolloContext()
- isApolloError()
- isReference()
- makeReference()
- makeVar()
- mergeOptions()
- operationName()
- parseAndCheckHttpResponse()
- parser()
- resetApolloContext()
- rewriteURIForGET()
- selectHttpOptionsAndBody()
- selectHttpOptionsAndBodyInternal()
- selectURI()
- serializeFetchParameter()
- throwServerError()
- toPromise()
- useApolloClient()
- useFragment_experimental()
- useLazyQuery()
- useMutation()
- useQuery()
- useReactiveVar()
- useSubscription()
Classes
ApolloClient
- addResolvers()
- cache
- clearStore()
- defaultOptions
- disableNetworkFetches
- extract()
- getObservableQueries()
- getResolvers()
- link
- mutate()
- onClearStore()
- onResetStore()
- query()
- queryDeduplication
- readFragment()
- readQuery()
- reFetchObservableQueries()
- refetchQueries()
- resetStore()
- restore()
- setLink()
- setLocalStateFragmentMatcher()
- setResolvers()
- stop()
- subscribe()
- typeDefs
- version
- watchQuery()
- writeFragment()
- writeQuery()
Interfaces
Enums
Type Aliases
- ApolloClientOptions
- ApolloQueryResult
- ApolloReducerConfig
- ClientParseError
- CommonOptions
- DiffQueryAgainstStoreOptions
- ErrorPolicy
- ExecutionPatchResult
- FetchPolicy
- FetchResult
- FieldMergeFunction
- FieldPolicy
- FieldReadFunction
- FragmentMatcher
- IdGetter
- InternalRefetchQueriesInclude
- InternalRefetchQueriesMap
- InternalRefetchQueriesResult
- InternalRefetchQueryDescriptor
- LazyQueryExecFunction
- LazyQueryResult
- LazyQueryResultTuple
- MutationFunction
- MutationQueryReducer
- MutationQueryReducersMap
- MutationTuple
- MutationUpdaterFn
- MutationUpdaterFunction
- NextLink
- ObservableQueryFields
- OnQueryUpdated
- OperationVariables
- OptimisticStoreItem
- Path
- PossibleTypesMap
- QueryListener
- QueryTuple
- ReadQueryOptions
- RefetchQueriesFunction
- RefetchQueriesInclude
- RefetchQueriesPromiseResults
- RefetchQueryDescriptor
- RequestHandler
- Resolver
- ServerError
- ServerParseError
- StoreValue
- SubscribeToMoreOptions
- Transaction
- TypePolicies
- TypePolicy
- WatchQueryFetchPolicy
Namespaces
Variables
variable ApolloConsumer
const ApolloConsumer: React.FC<ApolloConsumerProps>;
variable ApolloProvider
const ApolloProvider: React.FC<ApolloProviderProps<any>>;
variable concat
const concat: ( first: ApolloLink | RequestHandler, second: ApolloLink | RequestHandler) => ApolloLink;
variable defaultPrinter
const defaultPrinter: Printer;
variable empty
const empty: () => ApolloLink;
variable execute
const execute: ( link: ApolloLink, operation: GraphQLRequest<Record<string, any>>) => Observable< FetchResult<Record<string, any>, Record<string, any>, Record<string, any>>>;
variable fallbackHttpConfig
const fallbackHttpConfig: { http: HttpQueryOptions; headers: { accept: string; 'content-type': string }; options: { method: string };};
variable from
const from: (links: (ApolloLink | RequestHandler)[]) => ApolloLink;
variable split
const split: ( test: (op: Operation) => boolean, left: ApolloLink | RequestHandler, right?: ApolloLink | RequestHandler) => ApolloLink;
Functions
function checkFetcher
checkFetcher: (fetcher: WindowOrWorkerGlobalScope['fetch'] | undefined) => void;
function createHttpLink
createHttpLink: (linkOptions?: HttpOptions) => ApolloLink;
function createSignalIfSupported
createSignalIfSupported: () => | { controller: boolean; signal: boolean } | { controller: AbortController; signal: AbortSignal };
function defaultDataIdFromObject
defaultDataIdFromObject: ( { __typename, id, _id }: Readonly<StoreObject>, context?: KeyFieldsContext) => string | undefined;
function fromError
fromError: <T>(errorValue: any) => Observable<T>;
function fromPromise
fromPromise: <T>(promise: Promise<T>) => Observable<T>;
function getApolloContext
getApolloContext: () => React.Context<ApolloContextValue>;
function isApolloError
isApolloError: (err: Error) => err is ApolloError;
function isReference
isReference: (obj: any) => obj is Reference;
function makeReference
makeReference: (id: string) => Reference;
function makeVar
makeVar: <T>(value: T) => ReactiveVar<T>;
function mergeOptions
mergeOptions: <TOptions extends Partial<OptionsUnion<any, any, any>>>( defaults: TOptions | Partial<TOptions> | undefined, options: TOptions | Partial<TOptions>) => TOptions;
function operationName
operationName: (type: DocumentType) => string;
function parseAndCheckHttpResponse
parseAndCheckHttpResponse: ( operations: Operation | Operation[]) => (response: Response) => Promise<any>;
function parser
parser: (document: DocumentNode) => IDocumentDefinition;
function resetApolloContext
resetApolloContext: () => React.Context<ApolloContextValue>;
function rewriteURIForGET
rewriteURIForGET: ( chosenURI: string, body: Body) => | { parseError: any; newURI?: undefined } | { newURI: string; parseError?: undefined };
function selectHttpOptionsAndBody
selectHttpOptionsAndBody: ( operation: Operation, fallbackConfig: HttpConfig, ...configs: Array<HttpConfig>) => { options: HttpConfig & Record<string, any>; body: Body };
function selectHttpOptionsAndBodyInternal
selectHttpOptionsAndBodyInternal: ( operation: Operation, printer: Printer, ...configs: HttpConfig[]) => { options: HttpConfig & Record<string, any>; body: Body };
function selectURI
selectURI: ( operation: Operation, fallbackURI?: string | ((operation: Operation) => string)) => any;
function serializeFetchParameter
serializeFetchParameter: (p: any, label: string) => string;
function throwServerError
throwServerError: (response: Response, result: any, message: string) => never;
function toPromise
toPromise: <R>(observable: Observable<R>) => Promise<R>;
function useApolloClient
useApolloClient: (override?: ApolloClient<object>) => ApolloClient<object>;
function useFragment_experimental
useFragment_experimental: <TData = any, TVars = OperationVariables>( options: UseFragmentOptions<TData, TVars>) => UseFragmentResult<TData>;
function useLazyQuery
useLazyQuery: < TData = any, TVariables extends OperationVariables = OperationVariables>( query: DocumentNode | TypedDocumentNode<TData, TVariables>, options?: LazyQueryHookOptions<TData, TVariables>) => LazyQueryResultTuple<TData, TVariables>;
function useMutation
useMutation: < TData = any, TVariables = OperationVariables, TContext = DefaultContext, TCache extends ApolloCache<any> = ApolloCache<any>>( mutation: DocumentNode | TypedDocumentNode<TData, TVariables>, options?: MutationHookOptions<TData, TVariables, TContext, TCache>) => MutationTuple<TData, TVariables, TContext, TCache>;
function useQuery
useQuery: < TData = any, TVariables extends OperationVariables = OperationVariables>( query: DocumentNode | TypedDocumentNode<TData, TVariables>, options?: QueryHookOptions<TData, TVariables>) => QueryResult<TData, TVariables>;
function useReactiveVar
useReactiveVar: <T>(rv: ReactiveVar<T>) => T;
function useSubscription
useSubscription: < TData = any, TVariables extends OperationVariables = OperationVariables>( subscription: DocumentNode | TypedDocumentNode<TData, TVariables>, options?: SubscriptionHookOptions<TData, TVariables>) => SubscriptionResult<TData, any>;
Classes
class ApolloCache
abstract class ApolloCache<TSerialized> implements DataProxy {}
method batch
batch: <U>(options: Cache.BatchOptions<this, U>) => U;
method diff
abstract diff: <T>(query: Cache.DiffOptions) => Cache.DiffResult<T>;
method evict
abstract evict: (options: Cache.EvictOptions) => boolean;
method extract
abstract extract: (optimistic?: boolean) => TSerialized;
method gc
gc: () => string[];
method identify
identify: (object: StoreObject | Reference) => string | undefined;
method modify
modify: (options: Cache.ModifyOptions) => boolean;
method performTransaction
abstract performTransaction: ( transaction: Transaction<TSerialized>, optimisticId?: string | null) => void;
method read
abstract read: <TData = any, TVariables = any>( query: Cache.ReadOptions<TVariables, TData>) => TData | null;
method readFragment
readFragment: <FragmentType, TVariables = any>( options: Cache.ReadFragmentOptions<FragmentType, TVariables>, optimistic?: boolean) => FragmentType | null;
method readQuery
readQuery: <QueryType, TVariables = any>( options: Cache.ReadQueryOptions<QueryType, TVariables>, optimistic?: boolean) => QueryType | null;
method recordOptimisticTransaction
recordOptimisticTransaction: ( transaction: Transaction<TSerialized>, optimisticId: string) => void;
method removeOptimistic
abstract removeOptimistic: (id: string) => void;
method reset
abstract reset: (options?: Cache.ResetOptions) => Promise<void>;
method restore
abstract restore: (serializedState: TSerialized) => ApolloCache<TSerialized>;
method transformDocument
transformDocument: (document: DocumentNode) => DocumentNode;
method transformForLink
transformForLink: (document: DocumentNode) => DocumentNode;
method updateFragment
updateFragment: <TData = any, TVariables = any>( options: Cache.UpdateFragmentOptions<TData, TVariables>, update: (data: TData | null) => TData | null | void) => TData | null;
method updateQuery
updateQuery: <TData = any, TVariables = any>( options: Cache.UpdateQueryOptions<TData, TVariables>, update: (data: TData | null) => TData | null | void) => TData | null;
method watch
abstract watch: <TData = any, TVariables = any>( watch: Cache.WatchOptions<TData, TVariables>) => () => void;
method write
abstract write: <TData = any, TVariables = any>( write: Cache.WriteOptions<TData, TVariables>) => Reference | undefined;
method writeFragment
writeFragment: <TData = any, TVariables = any>({ id, data, fragment, fragmentName, ...options}: Cache.WriteFragmentOptions<TData, TVariables>) => Reference | undefined;
method writeQuery
writeQuery: <TData = any, TVariables = any>({ id, data, ...options}: Cache.WriteQueryOptions<TData, TVariables>) => Reference | undefined;
class ApolloClient
class ApolloClient<TCacheShape> implements DataProxy {}
constructor
constructor(options: ApolloClientOptions<TCacheShape>);
property cache
cache: ApolloCache<TCacheShape>;
property defaultOptions
defaultOptions: DefaultOptions;
property disableNetworkFetches
disableNetworkFetches: boolean;
property link
link: ApolloLink;
property queryDeduplication
queryDeduplication: boolean;
property typeDefs
readonly typeDefs: any;
property version
version: string;
method addResolvers
addResolvers: (resolvers: Resolvers | Resolvers[]) => void;
method clearStore
clearStore: () => Promise<any[]>;
method extract
extract: (optimistic?: boolean) => TCacheShape;
method getObservableQueries
getObservableQueries: ( include?: RefetchQueriesInclude) => Map<string, ObservableQuery<any>>;
method getResolvers
getResolvers: () => Resolvers;
method mutate
mutate: < TData = any, TVariables extends OperationVariables = OperationVariables, TContext extends Record<string, any> = DefaultContext, TCache extends ApolloCache<any> = ApolloCache<any>>( options: MutationOptions<TData, TVariables, TContext>) => Promise<FetchResult<TData>>;
method onClearStore
onClearStore: (cb: () => Promise<any>) => () => void;
method onResetStore
onResetStore: (cb: () => Promise<any>) => () => void;
method query
query: <T = any, TVariables extends OperationVariables = OperationVariables>( options: QueryOptions<TVariables, T>) => Promise<ApolloQueryResult<T>>;
method readFragment
readFragment: <T = any, TVariables = OperationVariables>( options: DataProxy.Fragment<TVariables, T>, optimistic?: boolean) => T | null;
method readQuery
readQuery: <T = any, TVariables = OperationVariables>( options: DataProxy.Query<TVariables, T>, optimistic?: boolean) => T | null;
method reFetchObservableQueries
reFetchObservableQueries: ( includeStandby?: boolean) => Promise<ApolloQueryResult<any>[]>;
method refetchQueries
refetchQueries: < TCache extends ApolloCache<any> = ApolloCache<TCacheShape>, TResult = Promise<ApolloQueryResult<any>>>( options: RefetchQueriesOptions<TCache, TResult>) => RefetchQueriesResult<TResult>;
method resetStore
resetStore: () => Promise<ApolloQueryResult<any>[] | null>;
method restore
restore: (serializedState: TCacheShape) => ApolloCache<TCacheShape>;
method setLink
setLink: (newLink: ApolloLink) => void;
method setLocalStateFragmentMatcher
setLocalStateFragmentMatcher: (fragmentMatcher: FragmentMatcher) => void;
method setResolvers
setResolvers: (resolvers: Resolvers | Resolvers[]) => void;
method stop
stop: () => void;
method subscribe
subscribe: <T = any, TVariables extends OperationVariables = OperationVariables>( options: SubscriptionOptions<TVariables, T>) => Observable<FetchResult<T, Record<string, any>, Record<string, any>>>;
method watchQuery
watchQuery: < T = any, TVariables extends OperationVariables = OperationVariables>( options: WatchQueryOptions<TVariables, T>) => ObservableQuery<T, TVariables>;
method writeFragment
writeFragment: <TData = any, TVariables = OperationVariables>( options: DataProxy.WriteFragmentOptions<TData, TVariables>) => Reference | undefined;
method writeQuery
writeQuery: <TData = any, TVariables = OperationVariables>( options: DataProxy.WriteQueryOptions<TData, TVariables>) => Reference | undefined;
class ApolloError
class ApolloError extends Error {}
constructor
constructor({ graphQLErrors, clientErrors, networkError, errorMessage, extraInfo,}: { graphQLErrors?: ReadonlyArray<GraphQLError>; clientErrors?: ReadonlyArray<Error>; networkError?: Error | ServerParseError | ServerError | null; errorMessage?: string; extraInfo?: any;});
property clientErrors
clientErrors: readonly Error[];
property extraInfo
extraInfo: any;
property graphQLErrors
graphQLErrors: GraphQLErrors;
property message
message: string;
property name
name: string;
property networkError
networkError: Error | ServerParseError | ServerError;
class ApolloLink
class ApolloLink {}
constructor
constructor(request?: RequestHandler);
method concat
static concat: ( first: ApolloLink | RequestHandler, second: ApolloLink | RequestHandler) => ApolloLink;
method empty
static empty: () => ApolloLink;
method execute
static execute: ( link: ApolloLink, operation: GraphQLRequest) => Observable< FetchResult<Record<string, any>, Record<string, any>, Record<string, any>>>;
method from
static from: (links: (ApolloLink | RequestHandler)[]) => ApolloLink;
method onError
protected onError: ( error: any, observer?: Observer< FetchResult< Record<string, any>, Record<string, any>, Record<string, any> > >) => false | void;
method request
request: ( operation: Operation, forward?: NextLink) => Observable<FetchResult> | null;
method setOnError
setOnError: (fn: ApolloLink['onError']) => this;
method split
static split: ( test: (op: Operation) => boolean, left: ApolloLink | RequestHandler, right?: ApolloLink | RequestHandler) => ApolloLink;
class HttpLink
class HttpLink extends ApolloLink {}
constructor
constructor(options?: HttpOptions);
property options
options: HttpOptions;
property requester
requester: RequestHandler;
class InMemoryCache
class InMemoryCache extends ApolloCache<NormalizedCacheObject> {}
constructor
constructor(config?: InMemoryCacheConfig);
property config
protected config: InMemoryCacheConfig;
property makeVar
readonly makeVar: <T>(value: T) => ReactiveVar<T>;
property policies
readonly policies: Policies;
method batch
batch: <TUpdateResult>( options: Cache.BatchOptions<InMemoryCache, TUpdateResult>) => TUpdateResult;
method broadcastWatches
protected broadcastWatches: (options?: BroadcastOptions) => void;
method diff
diff: <TData, TVariables extends OperationVariables = any>( options: Cache.DiffOptions<TData, TVariables>) => Cache.DiffResult<TData>;
method evict
evict: (options: Cache.EvictOptions) => boolean;
method extract
extract: (optimistic?: boolean) => NormalizedCacheObject;
method gc
gc: (options?: { resetResultCache?: boolean; resetResultIdentities?: boolean;}) => string[];
method identify
identify: (object: StoreObject | Reference) => string | undefined;
method modify
modify: (options: Cache.ModifyOptions) => boolean;
method performTransaction
performTransaction: ( update: (cache: InMemoryCache) => any, optimisticId?: string | null) => any;
method read
read: <T>(options: Cache.ReadOptions) => T | null;
method release
release: (rootId: string, optimistic?: boolean) => number;
method removeOptimistic
removeOptimistic: (idToRemove: string) => void;
method reset
reset: (options?: Cache.ResetOptions) => Promise<void>;
method restore
restore: (data: NormalizedCacheObject) => this;
method retain
retain: (rootId: string, optimistic?: boolean) => number;
method transformDocument
transformDocument: (document: DocumentNode) => DocumentNode;
method transformForLink
transformForLink: (document: DocumentNode) => DocumentNode;
method watch
watch: <TData = any, TVariables = any>( watch: Cache.WatchOptions<TData, TVariables>) => () => void;
method write
write: (options: Cache.WriteOptions) => Reference | undefined;
class MissingFieldError
class MissingFieldError extends Error {}
constructor
constructor( message: string, path: MissingTree | (string | number)[], query: DocumentNode, variables?: Record<string, any>);
property message
readonly message: string;
property missing
readonly missing: MissingTree;
property path
readonly path: MissingTree | (string | number)[];
property query
readonly query: DocumentNode;
property variables
readonly variables?: Record<string, any>;
class ObservableQuery
class ObservableQuery< TData = any, TVariables extends OperationVariables = OperationVariables> extends Observable<ApolloQueryResult<TData>> {}
constructor
constructor({ queryManager, queryInfo, options,}: { queryManager: QueryManager<any>; queryInfo: QueryInfo; options: WatchQueryOptions<TVariables, TData>;});
property options
readonly options: WatchQueryOptions<TVariables, TData>;
property query
readonly query: TypedDocumentNode<TData, TVariables>;
property queryId
readonly queryId: string;
property queryName
readonly queryName?: string;
property variables
readonly variables: OperationVariables;
method fetchMore
fetchMore: < TFetchData = TData, TFetchVars extends OperationVariables = TVariables>( fetchMoreOptions: FetchMoreQueryOptions<TFetchVars, TFetchData> & { updateQuery?: ( previousQueryResult: TData, options: { fetchMoreResult: TFetchData; variables: TFetchVars } ) => TData; }) => Promise<ApolloQueryResult<TFetchData>>;
method getCurrentResult
getCurrentResult: (saveAsLastResult?: boolean) => ApolloQueryResult<TData>;
method getLastError
getLastError: (variablesMustMatch?: boolean) => ApolloError | undefined;
method getLastResult
getLastResult: ( variablesMustMatch?: boolean) => ApolloQueryResult<TData> | undefined;
method hasObservers
hasObservers: () => boolean;
method isDifferentFromLastResult
isDifferentFromLastResult: ( newResult: ApolloQueryResult<TData>, variables?: TVariables) => boolean | undefined;
method refetch
refetch: (variables?: Partial<TVariables>) => Promise<ApolloQueryResult<TData>>;
method reobserve
reobserve: ( newOptions?: Partial<WatchQueryOptions<TVariables, TData>>, newNetworkStatus?: NetworkStatus) => Promise<ApolloQueryResult<TData>>;
method resetLastResults
resetLastResults: () => void;
method resetQueryStoreErrors
resetQueryStoreErrors: () => void;
method result
result: () => Promise<ApolloQueryResult<TData>>;
method setOptions
setOptions: ( newOptions: Partial<WatchQueryOptions<TVariables, TData>>) => Promise<ApolloQueryResult<TData>>;
method setVariables
setVariables: ( variables: TVariables) => Promise<ApolloQueryResult<TData> | void>;
method startPolling
startPolling: (pollInterval: number) => void;
method stopPolling
stopPolling: () => void;
method subscribeToMore
subscribeToMore: < TSubscriptionData = TData, TSubscriptionVariables extends OperationVariables = TVariables>( options: SubscribeToMoreOptions< TData, TSubscriptionVariables, TSubscriptionData >) => () => void;
method updateQuery
updateQuery: <TVars extends OperationVariables = TVariables>( mapFn: ( previousQueryResult: TData, options: Pick<WatchQueryOptions<TVars, TData>, 'variables'> ) => TData) => void;
Interfaces
interface ApolloContextValue
interface ApolloContextValue {}
property client
client?: ApolloClient<object>;
property renderPromises
renderPromises?: RenderPromises;
interface BaseMutationOptions
interface BaseMutationOptions< TData = any, TVariables = OperationVariables, TContext = DefaultContext, TCache extends ApolloCache<any> = ApolloCache<any>> extends Omit<MutationOptions<TData, TVariables, TContext, TCache>, 'mutation'> {}
property client
client?: ApolloClient<object>;
property ignoreResults
ignoreResults?: boolean;
property notifyOnNetworkStatusChange
notifyOnNetworkStatusChange?: boolean;
property onCompleted
onCompleted?: (data: TData, clientOptions?: BaseMutationOptions) => void;
property onError
onError?: (error: ApolloError, clientOptions?: BaseMutationOptions) => void;
interface BaseQueryOptions
interface BaseQueryOptions< TVariables extends OperationVariables = OperationVariables> extends Omit<WatchQueryOptions<TVariables>, 'query'> {}
interface BaseSubscriptionOptions
interface BaseSubscriptionOptions< TData = any, TVariables extends OperationVariables = OperationVariables> {}
property client
client?: ApolloClient<object>;
property context
context?: DefaultContext;
property fetchPolicy
fetchPolicy?: FetchPolicy;
property onComplete
onComplete?: () => void;
property onData
onData?: (options: OnDataOptions<TData>) => any;
property onError
onError?: (error: ApolloError) => void;
property onSubscriptionComplete
onSubscriptionComplete?: () => void;
property onSubscriptionData
onSubscriptionData?: (options: OnSubscriptionDataOptions<TData>) => any;
property shouldResubscribe
shouldResubscribe?: | boolean | ((options: BaseSubscriptionOptions<TData, TVariables>) => boolean);
property skip
skip?: boolean;
property variables
variables?: TVariables;
interface Context
interface DefaultContext extends Record<string, any> {}
interface DataProxy
interface DataProxy {}
method readFragment
readFragment: <FragmentType, TVariables = any>( options: DataProxy.ReadFragmentOptions<FragmentType, TVariables>, optimistic?: boolean) => FragmentType | null;
method readQuery
readQuery: <QueryType, TVariables = any>( options: DataProxy.ReadQueryOptions<QueryType, TVariables>, optimistic?: boolean) => QueryType | null;
method writeFragment
writeFragment: <TData = any, TVariables = any>( options: DataProxy.WriteFragmentOptions<TData, TVariables>) => Reference | undefined;
method writeQuery
writeQuery: <TData = any, TVariables = any>( options: DataProxy.WriteQueryOptions<TData, TVariables>) => Reference | undefined;
interface DefaultContext
interface DefaultContext extends Record<string, any> {}
interface DefaultOptions
interface DefaultOptions {}
property mutate
mutate?: Partial<MutationOptions<any, any, any>>;
property query
query?: Partial<QueryOptions<any, any>>;
property watchQuery
watchQuery?: Partial<WatchQueryOptions<any, any>>;
interface ExecutionPatchIncrementalResult
interface ExecutionPatchIncrementalResult< TData = Record<string, any>, TExtensions = Record<string, any>> extends ExecutionPatchResultBase {}
property data
data?: never;
property errors
errors?: never;
property extensions
extensions?: never;
property incremental
incremental?: IncrementalPayload<TData, TExtensions>[];
interface ExecutionPatchInitialResult
interface ExecutionPatchInitialResult< TData = Record<string, any>, TExtensions = Record<string, any>> extends ExecutionPatchResultBase {}
property data
data: TData | null | undefined;
property errors
errors?: ReadonlyArray<GraphQLError>;
property extensions
extensions?: TExtensions;
property incremental
incremental?: never;
interface FetchMoreOptions
interface FetchMoreOptions<TData = any, TVariables = OperationVariables> {}
property updateQuery
updateQuery?: ( previousQueryResult: TData, options: { fetchMoreResult?: TData; variables?: TVariables; }) => TData;
interface FetchMoreQueryOptions
interface FetchMoreQueryOptions<TVariables, TData = any> {}
interface FieldFunctionOptions
interface FieldFunctionOptions< TArgs = Record<string, any>, TVars = Record<string, any>> {}
property args
args: TArgs | null;
property cache
cache: InMemoryCache;
property canRead
canRead: CanReadFunction;
property field
field: FieldNode | null;
property fieldName
fieldName: string;
property isReference
isReference: typeof isReference;
property mergeObjects
mergeObjects: MergeObjectsFunction;
property readField
readField: ReadFieldFunction;
property storage
storage: StorageType;
property storeFieldName
storeFieldName: string;
property toReference
toReference: ToReferenceFunction;
property variables
variables?: TVars;
interface GraphQLRequest
interface GraphQLRequest<TVariables = Record<string, any>> {}
property context
context?: DefaultContext;
property extensions
extensions?: Record<string, any>;
property operationName
operationName?: string;
property query
query: DocumentNode;
property variables
variables?: TVariables;
interface HttpOptions
interface HttpOptions {}
property credentials
credentials?: string;
property fetch
fetch?: WindowOrWorkerGlobalScope['fetch'];
property fetchOptions
fetchOptions?: any;
property headers
headers?: Record<string, string>;
property includeExtensions
includeExtensions?: boolean;
property includeUnusedVariables
includeUnusedVariables?: boolean;
property preserveHeaderCase
preserveHeaderCase?: boolean;
property print
print?: Printer;
property uri
uri?: string | UriFunction;
property useGETForQueries
useGETForQueries?: boolean;
interface IdGetterObj
interface IdGetterObj extends Object {}
property id
id?: string;
interface IDocumentDefinition
interface IDocumentDefinition {}
interface IncrementalPayload
interface IncrementalPayload<TData, TExtensions> {}
property data
data: TData | null;
property errors
errors?: ReadonlyArray<GraphQLError>;
property extensions
extensions?: TExtensions;
property label
label?: string;
property path
path: Path;
interface InMemoryCacheConfig
interface InMemoryCacheConfig extends ApolloReducerConfig {}
property canonizeResults
canonizeResults?: boolean;
property fragments
fragments?: FragmentRegistryAPI;
property possibleTypes
possibleTypes?: PossibleTypesMap;
property resultCacheMaxSize
resultCacheMaxSize?: number;
property resultCaching
resultCaching?: boolean;
property typePolicies
typePolicies?: TypePolicies;
interface InternalRefetchQueriesOptions
interface InternalRefetchQueriesOptions<TCache extends ApolloCache<any>, TResult> extends Omit<RefetchQueriesOptions<TCache, TResult>, 'include'> {}
property include
include?: InternalRefetchQueriesInclude;
property removeOptimistic
removeOptimistic?: string;
interface LazyQueryHookOptions
interface LazyQueryHookOptions< TData = any, TVariables extends OperationVariables = OperationVariables> extends Omit<QueryHookOptions<TData, TVariables>, 'skip'> {}
interface MergeInfo
interface MergeInfo {}
interface MergeTree
interface MergeTree {}
interface MutationDataOptions
interface MutationDataOptions< TData = any, TVariables = OperationVariables, TContext = DefaultContext, TCache extends ApolloCache<any> = ApolloCache<any>> extends BaseMutationOptions<TData, TVariables, TContext, TCache> {}
property mutation
mutation: DocumentNode | TypedDocumentNode<TData, TVariables>;
interface MutationFunctionOptions
interface MutationFunctionOptions< TData = any, TVariables = OperationVariables, TContext = DefaultContext, TCache extends ApolloCache<any> = ApolloCache<any>> extends BaseMutationOptions<TData, TVariables, TContext, TCache> {}
property mutation
mutation?: DocumentNode | TypedDocumentNode<TData, TVariables>;
interface MutationHookOptions
interface MutationHookOptions< TData = any, TVariables = OperationVariables, TContext = DefaultContext, TCache extends ApolloCache<any> = ApolloCache<any>> extends BaseMutationOptions<TData, TVariables, TContext, TCache> {}
property mutation
mutation?: DocumentNode | TypedDocumentNode<TData, TVariables>;
interface MutationOptions
interface MutationOptions< TData = any, TVariables = OperationVariables, TContext = DefaultContext, TCache extends ApolloCache<any> = ApolloCache<any>> extends MutationBaseOptions<TData, TVariables, TContext, TCache> {}
property fetchPolicy
fetchPolicy?: MutationFetchPolicy;
property keepRootFields
keepRootFields?: boolean;
property mutation
mutation: DocumentNode | TypedDocumentNode<TData, TVariables>;
interface MutationResult
interface MutationResult<TData = any> {}
interface NormalizedCache
interface NormalizedCache {}
property canRead
canRead: CanReadFunction;
property getFieldValue
getFieldValue: FieldValueGetter;
property toReference
toReference: ToReferenceFunction;
method clear
clear: () => void;
method delete
delete: (dataId: string, fieldName?: string) => boolean;
method get
get: (dataId: string, fieldName: string) => StoreValue;
method getStorage
getStorage: ( idOrObj: string | StoreObject, ...storeFieldNames: (string | number)[]) => StorageType;
method has
has: (dataId: string) => boolean;
method merge
merge: { (olderId: string, newerObject: StoreObject): void; (olderObject: StoreObject, newerId: string): void;};
method modify
modify: (dataId: string, fields: Modifiers | Modifier<any>) => boolean;
method release
release: (rootId: string) => number;
method replace
replace: (newData: NormalizedCacheObject) => void;
method retain
retain: (rootId: string) => number;
method toObject
toObject: () => NormalizedCacheObject;
interface NormalizedCacheObject
interface NormalizedCacheObject {}
index signature
[dataId: string]: StoreObject | undefined;
interface OnDataOptions
interface OnDataOptions<TData = any> {}
interface OnSubscriptionDataOptions
interface OnSubscriptionDataOptions<TData = any> {}
property client
client: ApolloClient<object>;
property subscriptionData
subscriptionData: SubscriptionResult<TData>;
interface Operation
interface Operation {}
property extensions
extensions: Record<string, any>;
property getContext
getContext: () => DefaultContext;
property operationName
operationName: string;
property query
query: DocumentNode;
property setContext
setContext: (context: DefaultContext) => DefaultContext;
property variables
variables: Record<string, any>;
interface PureQueryOptions
interface QueryOptions<TVariables = OperationVariables, TData = any> {}
property canonizeResults
canonizeResults?: boolean;
property context
context?: DefaultContext;
property errorPolicy
errorPolicy?: ErrorPolicy;
property fetchPolicy
fetchPolicy?: FetchPolicy;
property notifyOnNetworkStatusChange
notifyOnNetworkStatusChange?: boolean;
property partialRefetch
partialRefetch?: boolean;
property pollInterval
pollInterval?: number;
property query
query: DocumentNode | TypedDocumentNode<TData, TVariables>;
property returnPartialData
returnPartialData?: boolean;
property variables
variables?: TVariables;
interface QueryDataOptions
interface QueryDataOptions< TData = any, TVariables extends OperationVariables = OperationVariables> extends QueryFunctionOptions<TData, TVariables> {}
interface QueryFunctionOptions
interface QueryFunctionOptions< TData = any, TVariables extends OperationVariables = OperationVariables> extends BaseQueryOptions<TVariables> {}
property defaultOptions
defaultOptions?: Partial<WatchQueryOptions<TVariables, TData>>;
property onCompleted
onCompleted?: (data: TData) => void;
property onError
onError?: (error: ApolloError) => void;
property skip
skip?: boolean;
interface QueryHookOptions
interface QueryHookOptions< TData = any, TVariables extends OperationVariables = OperationVariables> extends QueryFunctionOptions<TData, TVariables> {}
property query
query?: DocumentNode | TypedDocumentNode<TData, TVariables>;
interface QueryLazyOptions
interface QueryLazyOptions<TVariables> {}
interface QueryOptions
interface QueryOptions<TVariables = OperationVariables, TData = any> {}
property canonizeResults
canonizeResults?: boolean;
property context
context?: DefaultContext;
property errorPolicy
errorPolicy?: ErrorPolicy;
property fetchPolicy
fetchPolicy?: FetchPolicy;
property notifyOnNetworkStatusChange
notifyOnNetworkStatusChange?: boolean;
property partialRefetch
partialRefetch?: boolean;
property pollInterval
pollInterval?: number;
property query
query: DocumentNode | TypedDocumentNode<TData, TVariables>;
property returnPartialData
returnPartialData?: boolean;
property variables
variables?: TVariables;
interface QueryResult
interface QueryResult< TData = any, TVariables extends OperationVariables = OperationVariables> extends ObservableQueryFields<TData, TVariables> {}
property called
called: boolean;
property client
client: ApolloClient<any>;
property data
data: TData | undefined;
property error
error?: ApolloError;
property loading
loading: boolean;
property networkStatus
networkStatus: NetworkStatus;
property observable
observable: ObservableQuery<TData, TVariables>;
property previousData
previousData?: TData;
interface ReactiveVar
interface ReactiveVar<T> {}
method attachCache
attachCache: (cache: ApolloCache<any>) => this;
method forgetCache
forgetCache: (cache: ApolloCache<any>) => boolean;
method onNextChange
onNextChange: (listener: ReactiveListener<T>) => () => void;
call signature
(newValue?: T): T;
interface ReadMergeModifyContext
interface ReadMergeModifyContext {}
interface Reference
interface Reference {}
interface RefetchQueriesOptions
interface RefetchQueriesOptions<TCache extends ApolloCache<any>, TResult> {}
property include
include?: RefetchQueriesInclude;
property onQueryUpdated
onQueryUpdated?: OnQueryUpdated<TResult> | null;
property optimistic
optimistic?: boolean;
property updateCache
updateCache?: (cache: TCache) => void;
interface RefetchQueriesResult
interface RefetchQueriesResult<TResult> extends Promise<RefetchQueriesPromiseResults<TResult>> {}
interface Resolvers
interface Resolvers {}
index signature
[key: string]: { [field: string]: Resolver;};
interface SingleExecutionResult
interface SingleExecutionResult< TData = Record<string, any>, TContext = DefaultContext, TExtensions = Record<string, any>> extends ExecutionResult<TData, TExtensions> {}
interface StoreObject
interface StoreObject {}
index signature
[storeFieldName: string]: StoreValue;
interface SubscriptionCurrentObservable
interface SubscriptionCurrentObservable {}
property query
query?: Observable<any>;
property subscription
subscription?: ObservableSubscription;
interface SubscriptionDataOptions
interface SubscriptionDataOptions< TData = any, TVariables extends OperationVariables = OperationVariables> extends BaseSubscriptionOptions<TData, TVariables> {}
property children
children?: null | ((result: SubscriptionResult<TData>) => JSX.Element | null);
property subscription
subscription: DocumentNode | TypedDocumentNode<TData, TVariables>;
interface SubscriptionHookOptions
interface SubscriptionHookOptions< TData = any, TVariables extends OperationVariables = OperationVariables> extends BaseSubscriptionOptions<TData, TVariables> {}
property subscription
subscription?: DocumentNode | TypedDocumentNode<TData, TVariables>;
interface SubscriptionOptions
interface SubscriptionOptions<TVariables = OperationVariables, TData = any> {}
property context
context?: DefaultContext;
property errorPolicy
errorPolicy?: ErrorPolicy;
property fetchPolicy
fetchPolicy?: FetchPolicy;
property query
query: DocumentNode | TypedDocumentNode<TData, TVariables>;
property variables
variables?: TVariables;
interface SubscriptionResult
interface SubscriptionResult<TData = any, TVariables = any> {}
interface UpdateQueryOptions
interface UpdateQueryOptions<TVariables> {}
property variables
variables?: TVariables;
interface UriFunction
interface UriFunction {}
call signature
(operation: Operation): string;
interface UseFragmentOptions
interface UseFragmentOptions<TData, TVars> extends Omit< Cache.DiffOptions<TData, TVars>, 'id' | 'query' | 'optimistic' | 'previousResult' >, Omit<Cache.ReadFragmentOptions<TData, TVars>, 'id'> {}
property from
from: StoreObject | Reference | string;
property optimistic
optimistic?: boolean;
interface UseFragmentResult
interface UseFragmentResult<TData> {}
interface WatchQueryOptions
interface WatchQueryOptions< TVariables extends OperationVariables = OperationVariables, TData = any> extends Omit<QueryOptions<TVariables, TData>, 'fetchPolicy'> {}
property fetchPolicy
fetchPolicy?: WatchQueryFetchPolicy;
property initialFetchPolicy
initialFetchPolicy?: WatchQueryFetchPolicy;
property nextFetchPolicy
nextFetchPolicy?: | WatchQueryFetchPolicy | (( this: WatchQueryOptions<TVariables, TData>, currentFetchPolicy: WatchQueryFetchPolicy, context: NextFetchPolicyContext<TData, TVariables> ) => WatchQueryFetchPolicy);
property refetchWritePolicy
refetchWritePolicy?: RefetchWritePolicy;
Enums
enum DocumentType
enum DocumentType { Query = 0, Mutation = 1, Subscription = 2,}
enum NetworkStatus
enum NetworkStatus { loading = 1, setVariables = 2, fetchMore = 3, refetch = 4, poll = 6, ready = 7, error = 8,}
Type Aliases
type ApolloClientOptions
type ApolloClientOptions<TCacheShape> = { uri?: string | UriFunction; credentials?: string; headers?: Record<string, string>; link?: ApolloLink; cache: ApolloCache<TCacheShape>; ssrForceFetchDelay?: number; ssrMode?: boolean; connectToDevTools?: boolean; queryDeduplication?: boolean; defaultOptions?: DefaultOptions; assumeImmutableResults?: boolean; resolvers?: Resolvers | Resolvers[]; typeDefs?: string | string[] | DocumentNode | DocumentNode[]; fragmentMatcher?: FragmentMatcher; name?: string; version?: string;};
type ApolloQueryResult
type ApolloQueryResult<T> = { data: T; errors?: ReadonlyArray<GraphQLError>; error?: ApolloError; loading: boolean; networkStatus: NetworkStatus; partial?: boolean;};
type ApolloReducerConfig
type ApolloReducerConfig = { dataIdFromObject?: KeyFieldsFunction; addTypename?: boolean;};
type ClientParseError
type ClientParseError = InvariantError & { parseError: Error;};
type CommonOptions
type CommonOptions<TOptions> = TOptions & { client?: ApolloClient<object>;};
type DiffQueryAgainstStoreOptions
type DiffQueryAgainstStoreOptions = ReadQueryOptions & { returnPartialData?: boolean;};
type ErrorPolicy
type ErrorPolicy = 'none' | 'ignore' | 'all';
type ExecutionPatchResult
type ExecutionPatchResult< TData = Record<string, any>, TExtensions = Record<string, any>> = | ExecutionPatchInitialResult<TData, TExtensions> | ExecutionPatchIncrementalResult<TData, TExtensions>;
type FetchPolicy
type FetchPolicy = | 'cache-first' | 'network-only' | 'cache-only' | 'no-cache' | 'standby';
type FetchResult
type FetchResult< TData = Record<string, any>, TContext = Record<string, any>, TExtensions = Record<string, any>> = | SingleExecutionResult<TData, TContext, TExtensions> | ExecutionPatchResult<TData, TExtensions>;
type FieldMergeFunction
type FieldMergeFunction< TExisting = any, TIncoming = TExisting, TOptions extends FieldFunctionOptions = FieldFunctionOptions> = ( existing: SafeReadonly<TExisting> | undefined, incoming: SafeReadonly<TIncoming>, options: TOptions) => SafeReadonly<TExisting>;
type FieldPolicy
type FieldPolicy< TExisting = any, TIncoming = TExisting, TReadResult = TIncoming, TOptions extends FieldFunctionOptions = FieldFunctionOptions> = { keyArgs?: KeySpecifier | KeyArgsFunction | false; read?: FieldReadFunction<TExisting, TReadResult, TOptions>; merge?: FieldMergeFunction<TExisting, TIncoming, TOptions> | boolean;};
type FieldReadFunction
type FieldReadFunction< TExisting = any, TReadResult = TExisting, TOptions extends FieldFunctionOptions = FieldFunctionOptions> = ( existing: SafeReadonly<TExisting> | undefined, options: TOptions) => TReadResult | undefined;
type FragmentMatcher
type FragmentMatcher = ( rootValue: any, typeCondition: string, context: any) => boolean;
type IdGetter
type IdGetter = (value: IdGetterObj) => string | undefined;
type InternalRefetchQueriesInclude
type InternalRefetchQueriesInclude = | InternalRefetchQueryDescriptor[] | RefetchQueriesIncludeShorthand;
type InternalRefetchQueriesMap
type InternalRefetchQueriesMap<TResult> = Map< ObservableQuery<any>, InternalRefetchQueriesResult<TResult>>;
type InternalRefetchQueriesResult
type InternalRefetchQueriesResult<TResult> = TResult extends boolean ? Promise<ApolloQueryResult<any>> : TResult;
type InternalRefetchQueryDescriptor
type InternalRefetchQueryDescriptor = RefetchQueryDescriptor | QueryOptions;
type LazyQueryExecFunction
type LazyQueryExecFunction<TData, TVariables extends OperationVariables> = ( options?: Partial<LazyQueryHookOptions<TData, TVariables>>) => Promise<QueryResult<TData, TVariables>>;
type LazyQueryResult
type LazyQueryResult<TData, TVariables extends OperationVariables> = QueryResult< TData, TVariables>;
type LazyQueryResultTuple
type LazyQueryResultTuple<TData, TVariables extends OperationVariables> = [ LazyQueryExecFunction<TData, TVariables>, QueryResult<TData, TVariables>];
type MutationFunction
type MutationFunction< TData = any, TVariables = OperationVariables, TContext = DefaultContext, TCache extends ApolloCache<any> = ApolloCache<any>> = ( options?: MutationFunctionOptions<TData, TVariables, TContext, TCache>) => Promise<FetchResult<TData>>;
type MutationQueryReducer
type MutationQueryReducer<T> = ( previousResult: Record<string, any>, options: { mutationResult: FetchResult<T>; queryName: string | undefined; queryVariables: Record<string, any>; }) => Record<string, any>;
type MutationQueryReducersMap
type MutationQueryReducersMap< T = { [key: string]: any; }> = { [queryName: string]: MutationQueryReducer<T>;};
type MutationTuple
type MutationTuple< TData, TVariables, TContext = DefaultContext, TCache extends ApolloCache<any> = ApolloCache<any>> = [ ( options?: MutationFunctionOptions<TData, TVariables, TContext, TCache> ) => Promise<FetchResult<TData>>, MutationResult<TData>];
type MutationUpdaterFn
type MutationUpdaterFn< T = { [key: string]: any; }> = (cache: ApolloCache<T>, mutationResult: FetchResult<T>) => void;
type MutationUpdaterFunction
type MutationUpdaterFunction< TData, TVariables, TContext, TCache extends ApolloCache<any>> = ( cache: TCache, result: Omit<FetchResult<TData>, 'context'>, options: { context?: TContext; variables?: TVariables; }) => void;
type NextLink
type NextLink = (operation: Operation) => Observable<FetchResult>;
type ObservableQueryFields
type ObservableQueryFields<TData, TVariables extends OperationVariables> = Pick< ObservableQuery<TData, TVariables>, | 'startPolling' | 'stopPolling' | 'subscribeToMore' | 'updateQuery' | 'refetch' | 'reobserve' | 'variables' | 'fetchMore'>;
type OnQueryUpdated
type OnQueryUpdated<TResult> = ( observableQuery: ObservableQuery<any>, diff: Cache.DiffResult<any>, lastDiff: Cache.DiffResult<any> | undefined) => boolean | TResult;
type OperationVariables
type OperationVariables = Record<string, any>;
type OptimisticStoreItem
type OptimisticStoreItem = { id: string; data: NormalizedCacheObject; transaction: Transaction<NormalizedCacheObject>;};
type Path
type Path = ReadonlyArray<string | number>;
type PossibleTypesMap
type PossibleTypesMap = { [supertype: string]: string[];};
type QueryListener
type QueryListener = (queryInfo: QueryInfo) => void;
type QueryTuple
type QueryTuple<TData, TVariables extends OperationVariables> = LazyQueryResultTuple< TData, TVariables>;
type ReadQueryOptions
type ReadQueryOptions = { store: NormalizedCache; query: DocumentNode; variables?: Object; previousResult?: any; canonizeResults?: boolean; rootId?: string; config?: ApolloReducerConfig;};
type RefetchQueriesFunction
type RefetchQueriesFunction = (...args: any[]) => InternalRefetchQueriesInclude;
type RefetchQueriesInclude
type RefetchQueriesInclude = | RefetchQueryDescriptor[] | RefetchQueriesIncludeShorthand;
type RefetchQueriesPromiseResults
type RefetchQueriesPromiseResults<TResult> = IsStrictlyAny<TResult> extends true ? any[] : TResult extends boolean ? ApolloQueryResult<any>[] : TResult extends PromiseLike<infer U> ? U[] : TResult[];
type RefetchQueryDescriptor
type RefetchQueryDescriptor = string | DocumentNode;
type RequestHandler
type RequestHandler = ( operation: Operation, forward: NextLink) => Observable<FetchResult> | null;
type Resolver
type Resolver = ( rootValue?: any, args?: any, context?: any, info?: { field: FieldNode; fragmentMap: FragmentMap; }) => any;
type ServerError
type ServerError = Error & { response: Response; result: Record<string, any>; statusCode: number;};
type ServerParseError
type ServerParseError = Error & { response: Response; statusCode: number; bodyText: string;};
type StoreValue
type StoreValue = | number | string | string[] | Reference | Reference[] | null | undefined | void | Object;
type SubscribeToMoreOptions
type SubscribeToMoreOptions< TData = any, TSubscriptionVariables = OperationVariables, TSubscriptionData = TData> = { document: | DocumentNode | TypedDocumentNode<TSubscriptionData, TSubscriptionVariables>; variables?: TSubscriptionVariables; updateQuery?: UpdateQueryFn<TData, TSubscriptionVariables, TSubscriptionData>; onError?: (error: Error) => void; context?: DefaultContext;};
type Transaction
type Transaction<T> = (c: ApolloCache<T>) => void;
type TypePolicies
type TypePolicies = { [__typename: string]: TypePolicy;};
type TypePolicy
type TypePolicy = { keyFields?: KeySpecifier | KeyFieldsFunction | false; merge?: FieldMergeFunction | boolean; queryType?: true; mutationType?: true; subscriptionType?: true; fields?: { [fieldName: string]: FieldPolicy<any> | FieldReadFunction<any>; };};
type WatchQueryFetchPolicy
type WatchQueryFetchPolicy = FetchPolicy | 'cache-and-network';
Namespaces
namespace Cache
namespace Cache {}
interface BatchOptions
interface BatchOptions<TCache extends ApolloCache<any>, TUpdateResult = void> {}
property onWatchUpdated
onWatchUpdated?: ( this: TCache, watch: Cache.WatchOptions, diff: Cache.DiffResult<any>, lastDiff: Cache.DiffResult<any> | undefined) => any;
property optimistic
optimistic?: string | boolean;
property removeOptimistic
removeOptimistic?: string;
method update
update: (cache: TCache) => TUpdateResult;
interface DiffOptions
interface DiffOptions<TData = any, TVariables = any> extends Omit<ReadOptions<TVariables, TData>, 'rootId'> {}
interface EvictOptions
interface EvictOptions {}
interface ModifyOptions
interface ModifyOptions {}
property broadcast
broadcast?: boolean;
property fields
fields: Modifiers | Modifier<any>;
property id
id?: string;
property optimistic
optimistic?: boolean;
interface ReadOptions
interface ReadOptions<TVariables = any, TData = any> extends DataProxy.Query<TVariables, TData> {}
property canonizeResults
canonizeResults?: boolean;
property optimistic
optimistic: boolean;
property previousResult
previousResult?: any;
property returnPartialData
returnPartialData?: boolean;
property rootId
rootId?: string;
interface ResetOptions
interface ResetOptions {}
property discardWatches
discardWatches?: boolean;
interface WatchOptions
interface WatchOptions<TData = any, TVariables = any> extends DiffOptions<TData, TVariables> {}
property callback
callback: WatchCallback<TData>;