@apollo/client
- Version 3.8.4
- Published
- 5.27 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()
- isNetworkRequestSettled()
- isReference()
- makeReference()
- makeVar()
- mergeOptions()
- operationName()
- parseAndCheckHttpResponse()
- parser()
- rewriteURIForGET()
- selectHttpOptionsAndBody()
- selectHttpOptionsAndBodyInternal()
- selectURI()
- serializeFetchParameter()
- throwServerError()
- toPromise()
- useApolloClient()
- useBackgroundQuery()
- useFragment()
- useLazyQuery()
- useMutation()
- useQuery()
- useReactiveVar()
- useReadQuery()
- useSubscription()
- useSuspenseQuery()
Classes
ApolloClient
- addResolvers()
- cache
- clearStore()
- defaultOptions
- disableNetworkFetches
- documentTransform
- 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()
ObservableQuery
- fetchMore()
- getCurrentResult()
- getLastError()
- getLastResult()
- hasObservers()
- isDifferentFromLastResult()
- options
- query
- queryId
- queryName
- refetch()
- reobserve()
- reobserveAsConcast()
- resetLastResults()
- resetQueryStoreErrors()
- resubscribeAfterError()
- result()
- setOptions()
- setVariables()
- silentSetOptions()
- startPolling()
- stopPolling()
- subscribeToMore()
- updateQuery()
- variables
Interfaces
Enums
Type Aliases
- ApolloClientOptions
- ApolloQueryResult
- ApolloReducerConfig
- BackgroundQueryHookFetchPolicy
- ClientParseError
- CommonOptions
- DiffQueryAgainstStoreOptions
- DocumentTransformCacheKey
- ErrorPolicy
- ExecutionPatchResult
- FetchPolicy
- FetchResult
- FieldMergeFunction
- FieldPolicy
- FieldReadFunction
- FragmentMatcher
- IdGetter
- InternalRefetchQueriesInclude
- InternalRefetchQueriesMap
- InternalRefetchQueriesResult
- InternalRefetchQueryDescriptor
- LazyQueryExecFunction
- LazyQueryResult
- LazyQueryResultTuple
- MethodKeys
- MutationFunction
- MutationQueryReducer
- MutationQueryReducersMap
- MutationTuple
- MutationUpdaterFn
- MutationUpdaterFunction
- NextLink
- NoInfer
- ObservableQueryFields
- OnQueryUpdated
- OperationVariables
- OptimisticStoreItem
- Path
- PossibleTypesMap
- QueryListener
- QueryTuple
- ReadQueryOptions
- RefetchQueriesFunction
- RefetchQueriesInclude
- RefetchQueriesPromiseResults
- RefetchQueryDescriptor
- RequestHandler
- Resolver
- ServerError
- ServerParseError
- SkipToken
- StoreValue
- SubscribeToMoreOptions
- SuspenseQueryHookFetchPolicy
- Transaction
- TypePolicies
- TypePolicy
- UseBackgroundQueryResult
- UseFragmentResult
- 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 resetApolloContext
const resetApolloContext: () => React.Context<ApolloContextValue>;
variable skipToken
const skipToken: Symbol;
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 isNetworkRequestSettled
isNetworkRequestSettled: (networkStatus?: NetworkStatus) => boolean;
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: < TDefaultOptions extends Partial<OptionsUnion<any, any, any>>, TOptions extends TDefaultOptions>( defaults: TDefaultOptions | Partial<TDefaultOptions> | undefined, options: TOptions | Partial<TOptions>) => TOptions & TDefaultOptions;
function operationName
operationName: (type: DocumentType) => string;
function parseAndCheckHttpResponse
parseAndCheckHttpResponse: ( operations: Operation | Operation[]) => (response: Response) => Promise<any>;
function parser
parser: (document: DocumentNode) => IDocumentDefinition;
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 useBackgroundQuery
useBackgroundQuery: { < TData, TVariables extends OperationVariables, TOptions extends Omit< BackgroundQueryHookOptions<TData, OperationVariables>, 'variables' > >( query: DocumentNode | TypedDocumentNode<TData, TVariables>, options?: BackgroundQueryHookOptionsNoInfer<TData, TVariables> & TOptions ): [ ( | QueryReference< TOptions['errorPolicy'] extends 'ignore' | 'all' ? TOptions['returnPartialData'] extends true ? DeepPartial<TData> | undefined : TData | undefined : TOptions['returnPartialData'] extends true ? DeepPartial<TData> : TData > | (TOptions['skip'] extends boolean ? undefined : never) ), UseBackgroundQueryResult<TData, TVariables> ]; <TData = unknown, TVariables extends OperationVariables = OperationVariables>( query: any, options: BackgroundQueryHookOptionsNoInfer<TData, TVariables> & { returnPartialData: true; errorPolicy: 'all' | 'ignore'; } ): [ QueryReference<DeepPartial<TData>>, UseBackgroundQueryResult<TData, TVariables> ]; <TData = unknown, TVariables extends OperationVariables = OperationVariables>( query: any, options: BackgroundQueryHookOptionsNoInfer<TData, TVariables> & { errorPolicy: 'all' | 'ignore'; } ): [QueryReference<TData>, UseBackgroundQueryResult<TData, TVariables>]; <TData = unknown, TVariables extends OperationVariables = OperationVariables>( query: any, options: BackgroundQueryHookOptionsNoInfer<TData, TVariables> & { skip: boolean; returnPartialData: true; } ): [ QueryReference<DeepPartial<TData>>, UseBackgroundQueryResult<TData, TVariables> ]; <TData = unknown, TVariables extends OperationVariables = OperationVariables>( query: any, options: BackgroundQueryHookOptionsNoInfer<TData, TVariables> & { returnPartialData: true; } ): [ QueryReference<DeepPartial<TData>>, UseBackgroundQueryResult<TData, TVariables> ]; <TData = unknown, TVariables extends OperationVariables = OperationVariables>( query: any, options: BackgroundQueryHookOptionsNoInfer<TData, TVariables> & { skip: boolean; } ): [QueryReference<TData>, UseBackgroundQueryResult<TData, TVariables>]; <TData = unknown, TVariables extends OperationVariables = OperationVariables>( query: any, options?: BackgroundQueryHookOptionsNoInfer<TData, TVariables> ): [QueryReference<TData>, UseBackgroundQueryResult<TData, TVariables>]; <TData = unknown, TVariables extends OperationVariables = OperationVariables>( query: any, options: typeof skipToken ): [undefined, UseBackgroundQueryResult<TData, TVariables>]; <TData = unknown, TVariables extends OperationVariables = OperationVariables>( query: any, options: | typeof skipToken | (BackgroundQueryHookOptionsNoInfer<TData, TVariables> & { returnPartialData: true; }) ): [ QueryReference<DeepPartial<TData>>, UseBackgroundQueryResult<TData, TVariables> ]; <TData = unknown, TVariables extends OperationVariables = OperationVariables>( query: any, options?: | typeof skipToken | BackgroundQueryHookOptionsNoInfer<TData, TVariables> ): [QueryReference<TData>, UseBackgroundQueryResult<TData, TVariables>];};
function useFragment
useFragment: <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<NoInfer<TData>, NoInfer<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< NoInfer<TData>, NoInfer<TVariables>, TContext, TCache >) => MutationTuple<TData, TVariables, TContext, TCache>;
function useQuery
useQuery: < TData = any, TVariables extends OperationVariables = OperationVariables>( query: DocumentNode | TypedDocumentNode<TData, TVariables>, options?: QueryHookOptions<NoInfer<TData>, NoInfer<TVariables>>) => QueryResult<TData, TVariables>;
function useReactiveVar
useReactiveVar: <T>(rv: ReactiveVar<T>) => T;
function useReadQuery
useReadQuery: <TData>(queryRef: QueryReference<TData>) => { data: TData; networkStatus: import('../../index.js').NetworkStatus; error: import('../../index.js').ApolloError | undefined;};
function useSubscription
useSubscription: < TData = any, TVariables extends OperationVariables = OperationVariables>( subscription: DocumentNode | TypedDocumentNode<TData, TVariables>, options?: SubscriptionHookOptions<NoInfer<TData>, NoInfer<TVariables>>) => SubscriptionResult<TData, TVariables>;
function useSuspenseQuery
useSuspenseQuery: { < TData, TVariables extends OperationVariables, TOptions extends Omit< SuspenseQueryHookOptions<TData, OperationVariables>, 'variables' > >( query: DocumentNode | TypedDocumentNode<TData, TVariables>, options?: SuspenseQueryHookOptions<NoInfer<TData>, NoInfer<TVariables>> & TOptions ): UseSuspenseQueryResult< TOptions['errorPolicy'] extends 'ignore' | 'all' ? TOptions['returnPartialData'] extends true ? DeepPartial<TData> | undefined : TData | undefined : TOptions['returnPartialData'] extends true ? TOptions['skip'] extends boolean ? DeepPartial<TData> | undefined : DeepPartial<TData> : TOptions['skip'] extends boolean ? TData | undefined : TData, TVariables >; <TData = unknown, TVariables extends OperationVariables = OperationVariables>( query: any, options: SuspenseQueryHookOptions<NoInfer<TData>, NoInfer<TVariables>> & { returnPartialData: true; errorPolicy: 'all' | 'ignore'; } ): UseSuspenseQueryResult<DeepPartial<TData>, TVariables>; <TData = unknown, TVariables extends OperationVariables = OperationVariables>( query: any, options: SuspenseQueryHookOptions<NoInfer<TData>, NoInfer<TVariables>> & { errorPolicy: 'all' | 'ignore'; } ): UseSuspenseQueryResult<TData, TVariables>; <TData = unknown, TVariables extends OperationVariables = OperationVariables>( query: any, options: SuspenseQueryHookOptions<NoInfer<TData>, NoInfer<TVariables>> & { skip: boolean; returnPartialData: true; } ): UseSuspenseQueryResult<DeepPartial<TData>, TVariables>; <TData = unknown, TVariables extends OperationVariables = OperationVariables>( query: any, options: SuspenseQueryHookOptions<NoInfer<TData>, NoInfer<TVariables>> & { returnPartialData: true; } ): UseSuspenseQueryResult<DeepPartial<TData>, TVariables>; <TData = unknown, TVariables extends OperationVariables = OperationVariables>( query: any, options: SuspenseQueryHookOptions<NoInfer<TData>, NoInfer<TVariables>> & { skip: boolean; } ): UseSuspenseQueryResult<TData, TVariables>; <TData = unknown, TVariables extends OperationVariables = OperationVariables>( query: any, options?: SuspenseQueryHookOptions<NoInfer<TData>, NoInfer<TVariables>> ): UseSuspenseQueryResult<TData, TVariables>; <TData = unknown, TVariables extends OperationVariables = OperationVariables>( query: any, options: | typeof skipToken | (SuspenseQueryHookOptions<NoInfer<TData>, NoInfer<TVariables>> & { returnPartialData: true; }) ): UseSuspenseQueryResult<DeepPartial<TData>, TVariables>; <TData = unknown, TVariables extends OperationVariables = OperationVariables>( query: any, options?: | typeof skipToken | SuspenseQueryHookOptions<NoInfer<TData>, NoInfer<TVariables>> ): UseSuspenseQueryResult<TData, TVariables>;};
Classes
class ApolloCache
abstract class ApolloCache<TSerialized> implements DataProxy {}
property assumeImmutableResults
readonly assumeImmutableResults: boolean;
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: <Entity extends Record<string, any> = Record<string, any>>( options: Cache.ModifyOptions<Entity>) => 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 documentTransform
readonly documentTransform: DocumentTransform;
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, protocolErrors, clientErrors, networkError, errorMessage, extraInfo,}: ApolloErrorOptions);
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;
property protocolErrors
protocolErrors: readonly { message: string; extensions?: GraphQLErrorExtensions[];}[];
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 DocumentTransform
class DocumentTransform {}
constructor
constructor(transform: TransformFn, options?: DocumentTransformOptions);
method concat
concat: (otherTransform: DocumentTransform) => DocumentTransform;
method getStableCacheEntry
getStableCacheEntry: ( document: DocumentNode) => | { key: DocumentTransformCacheKey; value?: DocumentNode | undefined } | undefined;
method identity
static identity: () => DocumentTransform;
method split
static split: ( predicate: (document: DocumentNode) => boolean, left: DocumentTransform, right?: DocumentTransform) => DocumentTransform;
method transformDocument
transformDocument: (document: DocumentNode) => DocumentNode;
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 assumeImmutableResults
readonly assumeImmutableResults: boolean;
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: <Entity extends Record<string, any> = Record<string, any>>( options: Cache.ModifyOptions<Entity>) => 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 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 reobserveAsConcast
reobserveAsConcast: ( newOptions?: Partial<WatchQueryOptions<TVariables, TData>>, newNetworkStatus?: NetworkStatus) => Concast<ApolloQueryResult<TData>>;
method resetLastResults
resetLastResults: () => void;
method resetQueryStoreErrors
resetQueryStoreErrors: () => void;
method resubscribeAfterError
resubscribeAfterError: { ( onNext: (value: ApolloQueryResult<TData>) => void, onError?: (error: any) => void, onComplete?: () => void ): ObservableSubscription; (observer: Observer<ApolloQueryResult<TData>>): ObservableSubscription;};
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 silentSetOptions
silentSetOptions: ( newOptions: Partial<WatchQueryOptions<TVariables, 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;
class SuspenseCache
class SuspenseCache extends RealSuspenseCache {}
constructor
constructor();
Interfaces
interface ApolloContextValue
interface ApolloContextValue {}
property client
client?: ApolloClient<object>;
property renderPromises
renderPromises?: RenderPromises;
interface ApolloPayloadResult
interface ApolloPayloadResult< TData = Record<string, any>, TExtensions = Record<string, any>> {}
interface BackgroundQueryHookOptions
interface BackgroundQueryHookOptions< TData = unknown, TVariables extends OperationVariables = OperationVariables> extends Pick< QueryHookOptions<TData, TVariables>, | 'client' | 'variables' | 'errorPolicy' | 'context' | 'canonizeResults' | 'returnPartialData' | 'refetchWritePolicy' > {}
property fetchPolicy
fetchPolicy?: BackgroundQueryHookFetchPolicy;
property queryKey
queryKey?: string | number | any[];
property skip
skip?: boolean;
property suspenseCache
suspenseCache?: SuspenseCache;
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 DefaultOptions
interface DefaultOptions {}
property react
react?: { suspense?: Readonly<SuspenseCacheOptions>;};
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 LazyQueryHookExecOptions
interface LazyQueryHookExecOptions< TData = any, TVariables extends OperationVariables = OperationVariables> extends LazyQueryHookOptions<TData, TVariables> {}
property query
query?: DocumentNode | TypedDocumentNode<TData, TVariables>;
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> {}
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: <Entity extends Record<string, any>>( dataId: string, fields: Modifiers<Entity> | AllFieldsModifier<Entity>) => 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> {}
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 QueryReference
interface QueryReference<TData = unknown> {}
property [QUERY_REFERENCE_SYMBOL]
[QUERY_REFERENCE_SYMBOL]: InternalQueryReference<TData>;
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> {}
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 SuspenseQueryHookOptions
interface SuspenseQueryHookOptions< TData = unknown, TVariables extends OperationVariables = OperationVariables> extends Pick< QueryHookOptions<TData, TVariables>, | 'client' | 'variables' | 'errorPolicy' | 'context' | 'canonizeResults' | 'returnPartialData' | 'refetchWritePolicy' > {}
property fetchPolicy
fetchPolicy?: SuspenseQueryHookFetchPolicy;
property queryKey
queryKey?: string | number | any[];
property skip
skip?: boolean;
property suspenseCache
suspenseCache?: SuspenseCache;
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<NoInfer<TData>, NoInfer<TVars>>, 'id' | 'query' | 'optimistic' | 'previousResult' | 'returnPartialData' >, Omit< Cache.ReadFragmentOptions<TData, TVars>, 'id' | 'variables' | 'returnPartialData' > {}
property from
from: StoreObject | Reference | string;
property optimistic
optimistic?: boolean;
interface UseSuspenseQueryResult
interface UseSuspenseQueryResult< TData = unknown, TVariables extends OperationVariables = OperationVariables> {}
property client
client: ApolloClient<any>;
property data
data: TData;
property error
error: ApolloError | undefined;
property fetchMore
fetchMore: FetchMoreFunction<TData, TVariables>;
property networkStatus
networkStatus: NetworkStatus;
property refetch
refetch: RefetchFunction<TData, TVariables>;
property subscribeToMore
subscribeToMore: SubscribeToMoreFunction<TData, TVariables>;
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; documentTransform?: DocumentTransform;};
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 BackgroundQueryHookFetchPolicy
type BackgroundQueryHookFetchPolicy = Extract< WatchQueryFetchPolicy, 'cache-first' | 'network-only' | 'no-cache' | 'cache-and-network'>;
type ClientParseError
type ClientParseError = InvariantError & { parseError: Error;};
type CommonOptions
type CommonOptions<TOptions> = TOptions & { client?: ApolloClient<object>;};
type DiffQueryAgainstStoreOptions
type DiffQueryAgainstStoreOptions = ReadQueryOptions & { returnPartialData?: boolean;};
type DocumentTransformCacheKey
type DocumentTransformCacheKey = ReadonlyArray<unknown>;
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>;