apollo-angular

apollo-angular

Version 12.1.0
Published 1 month ago
224 kB
1 dependency
MIT license

Install

npm i apollo-angular

yarn add apollo-angular

pnpm add apollo-angular

Overview

Use your GraphQL data in your Angular app, with the Apollo Client

Index

Variables

variable APOLLO_FLAGS

const APOLLO_FLAGS: InjectionToken<Flags>;

variable APOLLO_NAMED_OPTIONS

const APOLLO_NAMED_OPTIONS: InjectionToken<NamedOptions>;

variable APOLLO_OPTIONS

const APOLLO_OPTIONS: InjectionToken<ApolloClient.Options>;

variable onlyComplete

const onlyComplete: <TData>() => OperatorFunction<
    ObservableQuery.Result<TData>,
    ObservableQuery.Result<TData, 'complete'>
>;

Deprecated
Use onlyCompleteData() instead.

Functions

function gql

gql: <Result, Variables>(
    literals: ReadonlyArray<string> | Readonly<string>,
    ...placeholders: any[]
) => TypedDocumentNode<Result, Variables>;

function onlyCompleteData

onlyCompleteData: <TData>() => OperatorFunction<
    ObservableQuery.Result<TData>,
    ObservableQuery.Result<TData, 'complete'>
>;

Filter emitted results to only receive results that are complete (result.dataState === 'complete').
This is a small wrapper around rxjs filter() for convenience only.
If you use this, you should probably combine it with [notifyOnNetworkStatusChange](https://www.apollographql.com/docs/react/data/queries#queryhookoptions-interface-notifyonnetworkstatuschange). This tells @apollo/client to not emit the first partial result, so apollo-angular does not need to filter it out. The overall behavior is identical, but it saves some CPU cycles.
So something like this:
apollo .watchQuery({ query: myQuery, notifyOnNetworkStatusChange: false, // Adding this will save CPU cycles }) .valueChanges .pipe(onlyCompleteData()) .subscribe(result => { // Do something with complete result });

function onlyCompleteFragment

onlyCompleteFragment: <TData>() => OperatorFunction<
    ApolloClient.WatchFragmentResult<TData>,
    any
>;

Same as onlyCompleteData() but for Apollo.watchFragment().

function provideApollo

provideApollo: (
    optionsFactory: () => ApolloClient.Options,
    flags?: Flags
) => Provider;

function provideNamedApollo

provideNamedApollo: (
    optionsFactory: () => NamedOptions,
    flags?: Flags
) => Provider;

Classes

class Apollo

class Apollo extends ApolloBase {}

constructor

constructor(
    ngZone: NgZone,
    apolloOptions?: ApolloClient.Options,
    apolloNamedOptions?: NamedOptions,
    flags?: Flags
);

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<
    Apollo,
    [null, { optional: true }, { optional: true }, { optional: true }]
>;

property ɵprov

static ɵprov: i0.ɵɵInjectableDeclaration<Apollo>;

method create

create: (options: ApolloClient.Options, name?: string) => void;

Create an instance of ApolloClient
Parameter options
Options required to create ApolloClient
Parameter name
client's name

method createDefault

createDefault: (options: ApolloClient.Options) => void;

Create a default ApolloClient, same as apollo.create(options)
Parameter options
ApolloClient's options

method createNamed

createNamed: (name: string, options: ApolloClient.Options) => void;

Create a named ApolloClient, same as apollo.create(options, name)
Parameter name
client's name
Parameter options
ApolloClient's options

method default

default: () => ApolloBase;

Use a default ApolloClient

method removeClient

removeClient: (name?: string) => void;

Remember to clean up the store before removing a client
Parameter name
client's name

method use

use: (name: string) => ApolloBase;

Use a named ApolloClient
Parameter name
client's name

class ApolloBase

class ApolloBase {}

constructor

constructor(ngZone: NgZone, flags?: Flags, _client?: ApolloClient);

property client

client: ApolloClient;

Get an instance of ApolloClient

property flags

protected readonly flags?: Flags;

property ngZone

protected readonly ngZone: NgZone;

method mutate

mutate: <TData, TVariables extends OperationVariables = EmptyObject>(
    options: Apollo.MutateOptions<TData, TVariables>
) => Observable<any>;

method query

query: <TData, TVariables extends OperationVariables = EmptyObject>(
    options: ApolloClient.QueryOptions<TData, TVariables>
) => Observable<ApolloClient.QueryResult<TData>>;

subscribe: <TData, TVariables extends OperationVariables = EmptyObject>(
    options: Apollo.SubscribeOptions<TData, TVariables>
) => Observable<ApolloClient.SubscribeResult<TData>>;

method watchFragment

watchFragment: <
    TFragmentData = unknown,
    TVariables extends OperationVariables = EmptyObject
>(
    options: Apollo.WatchFragmentOptions<TFragmentData, TVariables>
) => Observable<ApolloClient.WatchFragmentResult<TData>>;

method watchQuery

watchQuery: <TData, TVariables extends OperationVariables = EmptyObject>(
    options: ApolloClient.WatchQueryOptions<TData, TVariables>
) => QueryRef<TData, TVariables>;

class Mutation

abstract class Mutation<
    TData = unknown,
    TVariables extends OperationVariables = EmptyObject
> {}

constructor

constructor(apollo: Apollo);

property apollo

protected readonly apollo: Apollo;

property client

client: string;

property document

abstract readonly document: any;

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<Mutation<any, any>, never>;

property ɵprov

static ɵprov: i0.ɵɵInjectableDeclaration<Mutation<any, any>>;

method mutate

mutate: (
    ...[options]: {} extends TVariables
        ? [options?: Mutation.MutateOptions<TData, TVariables>]
        : [options: Mutation.MutateOptions<TData, TVariables>]
) => Observable<any>;

class Query

abstract class Query<
    TData = unknown,
    TVariables extends OperationVariables = EmptyObject
> {}

constructor

constructor(apollo: Apollo);

property apollo

protected readonly apollo: Apollo;

property client

client: string;

property document

abstract readonly document: any;

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<Query<any, any>, never>;

property ɵprov

static ɵprov: i0.ɵɵInjectableDeclaration<Query<any, any>>;

method fetch

fetch: (
    ...[options]: {} extends TVariables
        ? [options?: Query.FetchOptions<TData, TVariables>]
        : [options: Query.FetchOptions<TData, TVariables>]
) => Observable<ApolloClient.QueryResult<TData>>;

method watch

watch: (
    ...[options]: {} extends TVariables
        ? [options?: Query.WatchOptions<TData, TVariables>]
        : [options: Query.WatchOptions<TData, TVariables>]
) => QueryRef<TData, TVariables>;

class QueryRef

class QueryRef<TData, TVariables extends OperationVariables = EmptyObject> {}

constructor

constructor(obsQuery: ObservableQuery<TData, TVariables>, ngZone: NgZone);

property options

readonly options: ObservableQuery<TData, TVariables>;

property valueChanges

readonly valueChanges: Observable<ObservableQuery.Result<TData>>;

property variables

readonly variables: ObservableQuery<TData, TVariables>;

method fetchMore

fetchMore: <
    TFetchData = TData,
    TFetchVars extends OperationVariables = TVariables
>(
    fetchMoreOptions: ObservableQuery.FetchMoreOptions<
        TData,
        TVariables,
        TFetchData,
        TFetchVars
    >
) => Promise<ApolloClient.QueryResult<MaybeMasked<TFetchData>>>;

method getCurrentResult

getCurrentResult: () => ReturnType<
    ObservableQuery<TData, TVariables>['getCurrentResult']
>;

method refetch

refetch: (
    variables?: Parameters<ObservableQuery<TData, TVariables>['refetch']>[0]
) => ReturnType<ObservableQuery<TData, TVariables>['refetch']>;

method reobserve

reobserve: (
    options: ObservableQuery.Options<TData, TVariables>
) => ReturnType<ObservableQuery<TData, TVariables>['reobserve']>;

method setVariables

setVariables: (
    variables: Parameters<ObservableQuery<TData, TVariables>['setVariables']>[0]
) => ReturnType<ObservableQuery<TData, TVariables>['setVariables']>;

method startPolling

startPolling: (
    pollInterval: Parameters<
        ObservableQuery<TData, TVariables>['startPolling']
    >[0]
) => ReturnType<ObservableQuery<TData, TVariables>['startPolling']>;

method stopPolling

stopPolling: () => ReturnType<ObservableQuery<TData, TVariables>['stopPolling']>;

method subscribeToMore

subscribeToMore: <
    TSubscriptionData = TData,
    TSubscriptionVariables extends OperationVariables = TVariables
>(
    options: ObservableQuery.SubscribeToMoreOptions<
        TData,
        TSubscriptionVariables,
        TSubscriptionData,
        TVariables
    >
) => ReturnType<ObservableQuery<TData, TVariables>['subscribeToMore']>;

method updateQuery

updateQuery: (
    mapFn: Parameters<ObservableQuery<TData, TVariables>['updateQuery']>[0]
) => ReturnType<ObservableQuery<TData, TVariables>['updateQuery']>;

class Subscription

abstract class Subscription<
    TData = unknown,
    TVariables extends OperationVariables = EmptyObject
> {}

constructor

constructor(apollo: Apollo);

property apollo

protected readonly apollo: Apollo;

property client

client: string;

property document

abstract readonly document: any;

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<Subscription<any, any>, never>;

property ɵprov

static ɵprov: i0.ɵɵInjectableDeclaration<Subscription<any, any>>;

subscribe: (
    ...[options]: {} extends TVariables
        ? [options?: Subscription.SubscribeOptions<TData, TVariables>]
        : [options: Subscription.SubscribeOptions<TData, TVariables>]
) => Observable<ApolloClient.SubscribeResult<TData>>;

Type Aliases

type Flags

type Flags = {
    /**
     * Observable starts with `{ loading: true }`.
     *
     * Disabled by default
     */
    useMutationLoading?: boolean;
};

type NamedOptions

type NamedOptions = Record<string, ApolloClient.Options>;

type QueryRefFromDocument

type QueryRefFromDocument<T extends TypedDocumentNode> = T extends TypedDocumentNode<
    infer TData,
    infer TVariables
>
    ? QueryRef<TData, TVariables & OperationVariables>
    : never;

type ResultOf

type ResultOf<T extends TypedDocumentNode> = T extends TypedDocumentNode<infer R>
    ? R
    : never;

type VariablesOf

type VariablesOf<T extends TypedDocumentNode> = T extends TypedDocumentNode<
    any,
    infer V
>
    ? V
    : never;

Namespaces

namespace Apollo

namespace Apollo {}

interface WatchFragmentOptions

interface WatchFragmentOptions<
    TData = unknown,
    TVariables extends OperationVariables = EmptyObject
> extends ApolloClient.WatchFragmentOptions<TData, TVariables> {}

property useZone

useZone?: boolean;

type MutateOptions

type MutateOptions<
    TData = unknown,
    TVariables extends OperationVariables = EmptyObject
> = ApolloClient.MutateOptions<TData, TVariables> & {
    /**
     * Observable starts with `{ loading: true }`.
     *
     * Disabled by default
     */
    useMutationLoading?: boolean;
};

type MutateResult

type MutateResult<TData = unknown> = ApolloClient.MutateResult<TData> & {
    loading?: boolean;
};

type QueryOptions

type QueryOptions<
    TData = unknown,
    TVariables extends OperationVariables = EmptyObject
> = ApolloClient.QueryOptions<TData, TVariables>;

type QueryResult

type QueryResult<TData = unknown> = ApolloClient.QueryResult<TData>;

type SubscribeOptions

type SubscribeOptions<
    TData = unknown,
    TVariables extends OperationVariables = EmptyObject
> = ApolloClient.SubscribeOptions<TData, TVariables> & {
    useZone?: boolean;
};

type SubscribeResult

type SubscribeResult<TData = unknown> = ApolloClient.SubscribeResult<TData>;

type WatchFragmentResult

type WatchFragmentResult<TData = unknown> = ApolloClient.WatchFragmentResult<TData>;

type WatchQueryOptions

type WatchQueryOptions<
    TData = unknown,
    TVariables extends OperationVariables = EmptyObject
> = ApolloClient.WatchQueryOptions<TData, TVariables>;

namespace Mutation

namespace Mutation {}

type MutateOptions

type MutateOptions<
    TData = unknown,
    TVariables extends OperationVariables = EmptyObject
> = Omit<Apollo.MutateOptions<TData, TVariables>, 'mutation'>;

namespace Query

namespace Query {}

type FetchOptions

type FetchOptions<
    TData = unknown,
    TVariables extends OperationVariables = EmptyObject
> = Omit<Apollo.QueryOptions<TData, TVariables>, 'query'>;

type WatchOptions

type WatchOptions<
    TData = unknown,
    TVariables extends OperationVariables = EmptyObject
> = Omit<Apollo.WatchQueryOptions<TData, TVariables>, 'query'>;

namespace Subscription

namespace Subscription {}

type SubscribeOptions

type SubscribeOptions<
    TData = unknown,
    TVariables extends OperationVariables = EmptyObject
> = Omit<Apollo.SubscribeOptions<TData, TVariables>, 'query'>;

Package Files (11)

Dependencies (1)

tslib

Dev Dependencies (0)

No dev dependencies.

Peer Dependencies (4)

Badge

To add a badge like this oneto your package's README, use the codes available below.

You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/apollo-angular.

Markdown

[![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/apollo-angular)

HTML

<a href="https://www.jsdocs.io/package/apollo-angular"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>

Updated 30 days ago.
Package analyzed in 4443 ms.
Missing or incorrect documentation? Open an issue for this package.

apollo-angular

Install

Overview

Index

Variables

Functions

Classes

Type Aliases

Namespaces

Variables

variable APOLLO_FLAGS

variable APOLLO_NAMED_OPTIONS

variable APOLLO_OPTIONS

variable onlyComplete

Deprecated

Functions

function gql

function onlyCompleteData

function onlyCompleteFragment

function provideApollo

function provideNamedApollo

Classes

class Apollo

constructor

property ɵfac

property ɵprov

method create

Parameter options

Parameter name

method createDefault

Parameter options

method createNamed

Parameter name

Parameter options

method default

method removeClient

Parameter name

method use

Parameter name

class ApolloBase

constructor

property client

property flags

property ngZone

method mutate

method query

method subscribe

method watchFragment

method watchQuery

class Mutation

constructor

property apollo

property client

property document

property ɵfac

property ɵprov

method mutate

class Query

constructor

property apollo

property client

property document

property ɵfac

property ɵprov

method fetch

method watch

class QueryRef

constructor

property options

property valueChanges

property variables

method fetchMore

method getCurrentResult

method refetch

method reobserve

method setVariables

method startPolling

method stopPolling

method subscribeToMore

method updateQuery