@apollo/client

@apollo/client

Version 3.8.4
Published 7 days ago
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

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;

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>
> {}

property errors

errors?: ReadonlyArray<Error | string>;

property payload

payload: SingleExecutionResult | ExecutionPatchResult | null;

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'> {}

property client

client?: ApolloClient<any>;

property context

context?: DefaultContext;

property ssr

ssr?: boolean;

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> {}

property context

context?: DefaultContext;

property query

query?: DocumentNode | TypedDocumentNode<TData, TVariables>;

property variables

variables?: Partial<TVariables>;

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 {}

property name

name: string;

property type

type: DocumentType;

property variables

variables: ReadonlyArray<VariableDefinitionNode>;

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 {}

property field

field: FieldNode;

property merge

merge: FieldMergeFunction;

property typename

typename: string | undefined;

interface MergeTree

interface MergeTree {}

property info

info?: MergeInfo;

property map

map: Map<string | number, 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> {}

property called

called: boolean;

property client

client: ApolloClient<object>;

property data

data?: TData | null;

property error

error?: ApolloError;

property loading

loading: boolean;

method reset

reset: () => void;

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> {}

property client

client: ApolloClient<object>;

property data

data: SubscriptionResult<TData>;

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> {}

property children

children?: (result: QueryResult<TData, TVariables>) => ReactNode;

property query

query: DocumentNode | TypedDocumentNode<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> {}

property context

context?: DefaultContext;

property variables

variables?: 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 {}

property store

store: NormalizedCache;

property variables

variables?: Record<string, any>;

property varString

varString?: string;

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>> {}

property queries

queries: ObservableQuery<any>[];

property results

results: InternalRefetchQueriesResult<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> {}

property context

context?: TContext;

property data

data?: TData | null;

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> {}

property data

data?: TData;

property error

error?: ApolloError;

property loading

loading: boolean;

property variables

variables?: TVariables;

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,
}

member Mutation

Mutation = 1

member Query

Query = 0

member Subscription

Subscription = 2

enum NetworkStatus

enum NetworkStatus {
    loading = 1,
    setVariables = 2,
    fetchMore = 3,
    refetch = 4,
    poll = 6,
    ready = 7,
    error = 8,
}

member error

error = 8

member fetchMore

fetchMore = 3

member loading

loading = 1

member poll

poll = 6

member ready

ready = 7

member refetch

refetch = 4

member setVariables

setVariables = 2

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>;

@apollo/client

Install

Overview

Index

Variables

Functions

Classes

Interfaces

Enums

Type Aliases

Namespaces

Variables

variable ApolloConsumer

variable ApolloProvider

variable concat

variable defaultPrinter

variable empty

variable execute

variable fallbackHttpConfig

variable from

variable resetApolloContext

variable skipToken

variable split

Functions

function checkFetcher

function createHttpLink

function createSignalIfSupported

function defaultDataIdFromObject

function fromError

function fromPromise

function getApolloContext

function isApolloError

function isNetworkRequestSettled

function isReference

function makeReference

function makeVar

function mergeOptions

function operationName

function parseAndCheckHttpResponse

function parser

function rewriteURIForGET

function selectHttpOptionsAndBody

function selectHttpOptionsAndBodyInternal

function selectURI

function serializeFetchParameter

function throwServerError

function toPromise

function useApolloClient

function useBackgroundQuery

function useFragment

function useLazyQuery

function useMutation

function useQuery

function useReactiveVar

function useReadQuery

function useSubscription

function useSuspenseQuery

Classes

class ApolloCache

property assumeImmutableResults

method batch

method diff

method evict

method extract

method gc

method identify

method modify

method performTransaction

method read

method readFragment

method readQuery

method recordOptimisticTransaction

method removeOptimistic

method reset

method restore

method transformDocument

method transformForLink

method updateFragment

method updateQuery

method watch