apollo-angular

apollo-angular

Version 10.0.3
Published 1 month ago
394 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<ApolloClientOptions<any>>;

Functions

function gql

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

function provideApollo

provideApollo: <TCacheShape = any>(
    optionsFactory: () => ApolloClientOptions<TCacheShape>,
    flags?: Flags
) => Provider;

function provideNamedApollo

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

Classes

class Apollo

class Apollo extends ApolloBase<any> {}

constructor

constructor(
    ngZone: NgZone,
    apolloOptions?: ApolloClientOptions<any>,
    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: <TCacheShape>(
    options: ApolloClientOptions<TCacheShape>,
    name?: string
) => void;

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

method createDefault

createDefault: <TCacheShape>(options: ApolloClientOptions<TCacheShape>) => void;

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

method createNamed

createNamed: <TCacheShape>(
    name: string,
    options: ApolloClientOptions<TCacheShape>
) => 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<any>;

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

Use a named ApolloClient
Parameter name
client's name

class ApolloBase

class ApolloBase<TCacheShape = any> {}

constructor

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

property client

client: ApolloClient<TCacheShape>;

Get an instance of ApolloClient

property flags

protected readonly flags?: Flags;

property ngZone

protected readonly ngZone: NgZone;

method mutate

mutate: <T, V extends OperationVariables = EmptyObject>(
    options: MutationOptions<T, V>
) => Observable<any>;

method query

query: <T, V extends OperationVariables = EmptyObject>(
    options: QueryOptions<V, T>
) => Observable<ApolloQueryResult<T>>;

subscribe: <T, V extends OperationVariables = EmptyObject>(
    options: SubscriptionOptions<V, T>,
    extra?: ExtraSubscriptionOptions
) => Observable<FetchResult<T>>;

method watchFragment

watchFragment: <
    TFragmentData = unknown,
    TVariables extends OperationVariables = EmptyObject
>(
    options: WatchFragmentOptions<TFragmentData, TVariables>,
    extra?: ExtraSubscriptionOptions
) => Observable<WatchFragmentResult<TFragmentData>>;

method watchQuery

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

class Mutation

abstract class Mutation<T = {}, V 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: (variables?: V, options?: MutationOptionsAlone<T, V>) => Observable<any>;

class Query

abstract class Query<T = {}, V 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: (
    variables?: V,
    options?: QueryOptionsAlone<V, T>
) => Observable<ApolloQueryResult<T>>;

method watch

watch: (variables?: V, options?: WatchQueryOptionsAlone<V, T>) => QueryRef<T, V>;

class QueryRef

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

constructor

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

property options

readonly options: ObservableQuery<TData, TVariables>;

property queryId

readonly queryId: ObservableQuery<TData, TVariables>;

property valueChanges

readonly valueChanges: Observable<ApolloQueryResult<TData>>;

property variables

readonly variables: ObservableQuery<TData, TVariables>;

method fetchMore

fetchMore: <
    TFetchData = TData,
    TFetchVars extends OperationVariables = TVariables
>(
    fetchMoreOptions: any
) => Promise<ApolloQueryResult<MaybeMasked<TFetchData>>>;

method getCurrentResult

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

method getLastError

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

method getLastResult

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

method refetch

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

method resetLastResults

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

method result

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

method setOptions

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

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: 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<T = any, V 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: (
    variables?: V,
    options?: SubscriptionOptionsAlone<V, T>,
    extra?: ExtraSubscriptionOptions
) => Observable<FetchResult<T>>;

Interfaces

interface ExtraSubscriptionOptions

interface ExtraSubscriptionOptions {}

property useZone

useZone?: boolean;

interface MutationOptionsAlone

interface MutationOptionsAlone<TData = EmptyObject, TVariables = any>
    extends Omit<MutationOptions<TData, TVariables>, 'mutation' | 'variables'> {}

interface QueryOptionsAlone

interface QueryOptionsAlone<TVariables = EmptyObject, TData = any>
    extends Omit<CoreQueryOptions<TVariables, TData>, 'query' | 'variables'> {}

interface SubscriptionOptionsAlone

interface SubscriptionOptionsAlone<TVariables = EmptyObject, TData = any>
    extends Omit<
        CoreSubscriptionOptions<TVariables, TData>,
        'query' | 'variables'
    > {}

interface WatchQueryOptions

interface WatchQueryOptions<
    TVariables extends OperationVariables = EmptyObject,
    TData = any
> extends CoreWatchQueryOptions<TVariables, TData> {}

property useInitialLoading

useInitialLoading?: boolean;

Observable starts with { loading: true }. There's a big chance the next major version will enable that by default.
Disabled by default

interface WatchQueryOptionsAlone

interface WatchQueryOptionsAlone<
    TVariables extends OperationVariables = EmptyObject,
    TData = any
> extends Omit<WatchQueryOptions<TVariables, TData>, 'query' | 'variables'> {}

Type Aliases

type Flags

type Flags = {
    /**
     * Observable starts with `{ loading: true }`.
     * There's a big chance the next major version will enable that by default.
     *
     * Disabled by default
     */
    useInitialLoading?: boolean;
    /**
     * Observable starts with `{ loading: true }`.
     *
     * Disabled by default
     */
    useMutationLoading?: boolean;
};

type MutationResult

type MutationResult<TData = any> = FetchResult<TData> & {
    loading?: boolean;
};

type NamedOptions

type NamedOptions = Record<string, ApolloClientOptions<any>>;

type QueryRefFromDocument

type QueryRefFromDocument<T extends TypedDocumentNode> = T extends TypedDocumentNode<
    infer R,
    infer V
>
    ? QueryRef<R, V & 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;

Package Files (10)

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 1 month ago.
Package analyzed in 4399 ms.
Missing or incorrect documentation? Open an issue for this package.

apollo-angular

Install

Overview

Index

Variables

Functions

Classes

Interfaces

Type Aliases

Variables

variable APOLLO_FLAGS

variable APOLLO_NAMED_OPTIONS

variable APOLLO_OPTIONS

Functions

function gql

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 queryId

property valueChanges

property variables

method fetchMore

method getCurrentResult

method getLastError

method getLastResult

method refetch

method resetLastResults

method result

method setOptions

method setVariables

method startPolling

method stopPolling

method subscribeToMore