com.apollographql.apollo.cache.normalized

Interface ApolloStore

All Known Implementing Classes:

NoOpApolloStore, RealApolloStore

public interface ApolloStore

ApolloStore exposes a thread-safe api to access a NormalizedCache. It also maintains a list of ApolloStore.RecordChangeSubscriber that will be notified with changed records. Most clients should have no need to directly interface with an ApolloStore.

Nested Class Summary

Nested Classes

Modifier and Type	Interface and Description
static interface	ApolloStore.RecordChangeSubscriber Listens to changed record keys dispatched via publish(Set).

Field Summary

Fields

Modifier and Type	Field and Description
static ApolloStore	NO_APOLLO_STORE

Method Summary

Modifier and Type	Method and Description
CacheKeyResolver	cacheKeyResolver()
ResponseNormalizer<Record>	cacheResponseNormalizer()
ApolloStoreOperation<java.lang.Boolean>	clearAll() Clear all records from this ApolloStore.
ResponseNormalizer<java.util.Map<java.lang.String,java.lang.Object>>	networkResponseNormalizer()
NormalizedCache	normalizedCache()
void	publish(java.util.Set<java.lang.String> keys)
<D extends com.apollographql.apollo.api.Operation.Data,T,V extends com.apollographql.apollo.api.Operation.Variables> ApolloStoreOperation<T>	read(com.apollographql.apollo.api.Operation<D,T,V> operation) Read GraphQL operation from store.
<D extends com.apollographql.apollo.api.Operation.Data,T,V extends com.apollographql.apollo.api.Operation.Variables> ApolloStoreOperation<com.apollographql.apollo.api.Response<T>>	read(com.apollographql.apollo.api.Operation<D,T,V> operation, com.apollographql.apollo.api.ResponseFieldMapper<D> responseFieldMapper, ResponseNormalizer<Record> responseNormalizer, CacheHeaders cacheHeaders) Read GraphQL operation response from store.
<F extends com.apollographql.apollo.api.GraphqlFragment> ApolloStoreOperation<F>	read(com.apollographql.apollo.api.ResponseFieldMapper<F> fieldMapper, CacheKey cacheKey, com.apollographql.apollo.api.Operation.Variables variables) Read GraphQL fragment from store.
<R> R	readTransaction(Transaction<ReadableStore,R> transaction) Run a operation inside a read-lock.
ApolloStoreOperation<java.lang.Boolean>	remove(CacheKey cacheKey) Remove cache record by the key
ApolloStoreOperation<java.lang.Boolean>	remove(CacheKey cacheKey, boolean cascade) Remove cache record by the key
ApolloStoreOperation<java.lang.Integer>	remove(java.util.List<CacheKey> cacheKeys) Remove cache records by the list of keys
ApolloStoreOperation<java.util.Set<java.lang.String>>	rollbackOptimisticUpdates(java.util.UUID mutationId) Rollback operation data optimistic updates.
ApolloStoreOperation<java.lang.Boolean>	rollbackOptimisticUpdatesAndPublish(java.util.UUID mutationId) Rollback operation data optimistic updates and publish changes of Records which have changed, that will notify any that depends on these Record to re-fetch.
void	subscribe(ApolloStore.RecordChangeSubscriber subscriber)
void	unsubscribe(ApolloStore.RecordChangeSubscriber subscriber)
ApolloStoreOperation<java.util.Set<java.lang.String>>	write(com.apollographql.apollo.api.GraphqlFragment fragment, CacheKey cacheKey, com.apollographql.apollo.api.Operation.Variables variables) Write fragment to the store.
<D extends com.apollographql.apollo.api.Operation.Data,T,V extends com.apollographql.apollo.api.Operation.Variables> ApolloStoreOperation<java.util.Set<java.lang.String>>	write(com.apollographql.apollo.api.Operation<D,T,V> operation, D operationData) Write operation to the store.
ApolloStoreOperation<java.lang.Boolean>	writeAndPublish(com.apollographql.apollo.api.GraphqlFragment fragment, CacheKey cacheKey, com.apollographql.apollo.api.Operation.Variables variables) Write fragment to the store and publish changes of Record which have changed, that will notify any ApolloQueryWatcher that depends on these Record to re-fetch.
<D extends com.apollographql.apollo.api.Operation.Data,T,V extends com.apollographql.apollo.api.Operation.Variables> ApolloStoreOperation<java.lang.Boolean>	writeAndPublish(com.apollographql.apollo.api.Operation<D,T,V> operation, D operationData) Write operation to the store and publish changes of Record which have changed, that will notify any ApolloQueryWatcher that depends on these Record to re-fetch.
<D extends com.apollographql.apollo.api.Operation.Data,T,V extends com.apollographql.apollo.api.Operation.Variables> ApolloStoreOperation<java.util.Set<java.lang.String>>	writeOptimisticUpdates(com.apollographql.apollo.api.Operation<D,T,V> operation, D operationData, java.util.UUID mutationId) Write operation data to the optimistic store.
<D extends com.apollographql.apollo.api.Operation.Data,T,V extends com.apollographql.apollo.api.Operation.Variables> ApolloStoreOperation<java.lang.Boolean>	writeOptimisticUpdatesAndPublish(com.apollographql.apollo.api.Operation<D,T,V> operation, D operationData, java.util.UUID mutationId) Write operation data to the optimistic store and publish changes of Records which have changed, that will notify any that depends on these Record to re-fetch.
<R> R	writeTransaction(Transaction<WriteableStore,R> transaction) Run a operation inside a write-lock.

Field Detail

NO_APOLLO_STORE

static final ApolloStore NO_APOLLO_STORE

Method Detail

subscribe

void subscribe(ApolloStore.RecordChangeSubscriber subscriber)

unsubscribe

void unsubscribe(ApolloStore.RecordChangeSubscriber subscriber)

publish

void publish(java.util.Set<java.lang.String> keys)

Parameters:

keys - A set of keys of Record which have changed.

clearAll

@NotNull
ApolloStoreOperation<java.lang.Boolean> clearAll()

Clear all records from this ApolloStore.

Returns:

to be performed, that will be resolved with true if all records was successfully removed, false otherwise

remove

@NotNull
ApolloStoreOperation<java.lang.Boolean> remove(@NotNull
                                                        CacheKey cacheKey)

Remove cache record by the key

Parameters:

cacheKey - of record to be removed

Returns:

to be performed, that will be resolved with true if record with such key was successfully removed, false otherwise

remove

@NotNull
ApolloStoreOperation<java.lang.Boolean> remove(@NotNull
                                                        CacheKey cacheKey,
                                                        boolean cascade)

Remove cache record by the key

Parameters:

cacheKey - of record to be removed

cascade - defines if remove operation is propagated to the referenced entities

Returns:

to be performed, that will be resolved with true if record with such key was successfully removed, false otherwise

remove

@NotNull
ApolloStoreOperation<java.lang.Integer> remove(@NotNull
                                                        java.util.List<CacheKey> cacheKeys)

Remove cache records by the list of keys

Parameters:

cacheKeys - keys of records to be removed

Returns:

to be performed, that will be resolved with the count of records been removed

networkResponseNormalizer

ResponseNormalizer<java.util.Map<java.lang.String,java.lang.Object>> networkResponseNormalizer()

Returns:

The ResponseNormalizer used to generate normalized records from the network.

cacheResponseNormalizer

ResponseNormalizer<Record> cacheResponseNormalizer()

Returns:

The ResponseNormalizer used to generate normalized records from the cache.

readTransaction

<R> R readTransaction(Transaction<ReadableStore,R> transaction)

Run a operation inside a read-lock. Blocks until read-lock is acquired.

Type Parameters:

R - The result type of this read operation.

Parameters:

transaction - A code block to run once the read lock is acquired.

Returns:

A result from the read operation.

writeTransaction

<R> R writeTransaction(Transaction<WriteableStore,R> transaction)

Run a operation inside a write-lock. Blocks until write-lock is acquired.

Type Parameters:

R - The result type of this write operation.

Parameters:

transaction - A code block to run once the write lock is acquired.

Returns:

A result from the write operation.

normalizedCache

NormalizedCache normalizedCache()

Returns:

The NormalizedCache which backs this ApolloStore.

cacheKeyResolver

CacheKeyResolver cacheKeyResolver()

Returns:

the CacheKeyResolver used for resolving field cache keys

read

@NotNull
<D extends com.apollographql.apollo.api.Operation.Data,T,V extends com.apollographql.apollo.api.Operation.Variables> ApolloStoreOperation<T> read(@NotNull
                                                                                                                                                           com.apollographql.apollo.api.Operation<D,T,V> operation)

Read GraphQL operation from store.

Type Parameters:

D - type of GraphQL operation data

T - type operation cached data will be wrapped with

V - type of operation variables

Parameters:

operation - to be read

Returns:

to be performed, that will be resolved with cached data for specified operation

read

@NotNull
<D extends com.apollographql.apollo.api.Operation.Data,T,V extends com.apollographql.apollo.api.Operation.Variables> ApolloStoreOperation<com.apollographql.apollo.api.Response<T>> read(@NotNull
                                                                                                                                                                                                  com.apollographql.apollo.api.Operation<D,T,V> operation,
                                                                                                                                                                                                  @NotNull
                                                                                                                                                                                                  com.apollographql.apollo.api.ResponseFieldMapper<D> responseFieldMapper,
                                                                                                                                                                                                  @NotNull
                                                                                                                                                                                                  ResponseNormalizer<Record> responseNormalizer,
                                                                                                                                                                                                  @NotNull
                                                                                                                                                                                                  CacheHeaders cacheHeaders)

Read GraphQL operation response from store.

Type Parameters:

D - type of GraphQL operation data

T - type operation cached data will be wrapped with

V - type of operation variables

Parameters:

operation - response of which should be read

responseFieldMapper - ResponseFieldMapper to be used for field mapping

responseNormalizer - ResponseNormalizer to be used when reading cached response

cacheHeaders - CacheHeaders to be used when reading cached response

Returns:

to be performed, that will be resolved with cached response for specified operation

read

@NotNull
<F extends com.apollographql.apollo.api.GraphqlFragment> ApolloStoreOperation<F> read(@NotNull
                                                                                               com.apollographql.apollo.api.ResponseFieldMapper<F> fieldMapper,
                                                                                               @NotNull
                                                                                               CacheKey cacheKey,
                                                                                               @NotNull
                                                                                               com.apollographql.apollo.api.Operation.Variables variables)

Read GraphQL fragment from store.

Type Parameters:

F - type of fragment to be read

Parameters:

fieldMapper - ResponseFieldMapper to be used for field mapping

cacheKey - CacheKey to be used to find cache record for the fragment

variables - Operation.Variables required for fragment arguments resolving

Returns:

to be performed, that will be resolved with cached fragment data

write

@NotNull
<D extends com.apollographql.apollo.api.Operation.Data,T,V extends com.apollographql.apollo.api.Operation.Variables> ApolloStoreOperation<java.util.Set<java.lang.String>> write(@NotNull
                                                                                                                                                                                          com.apollographql.apollo.api.Operation<D,T,V> operation,
                                                                                                                                                                                          @NotNull
                                                                                                                                                                                          D operationData)

Write operation to the store.

Type Parameters:

D - type of GraphQL operation data

T - type operation cached data will be wrapped with

V - type of operation variables

Parameters:

operation - Operation response data of which should be written to the store

operationData - Operation.Data operation response data to be written to the store

Returns:

to be performed, that will be resolved with set of keys of Record which have changed

writeAndPublish

@NotNull
<D extends com.apollographql.apollo.api.Operation.Data,T,V extends com.apollographql.apollo.api.Operation.Variables> ApolloStoreOperation<java.lang.Boolean> writeAndPublish(@NotNull
                                                                                                                                                                                      com.apollographql.apollo.api.Operation<D,T,V> operation,
                                                                                                                                                                                      @NotNull
                                                                                                                                                                                      D operationData)

Write operation to the store and publish changes of Record which have changed, that will notify any ApolloQueryWatcher that depends on these Record to re-fetch.

Type Parameters:

D - type of GraphQL operation data

T - type operation cached data will be wrapped with

V - type of operation variables

Parameters:

operation - Operation response data of which should be written to the store

operationData - Operation.Data operation response data to be written to the store

Returns:

to be performed

write

@NotNull
ApolloStoreOperation<java.util.Set<java.lang.String>> write(@NotNull
                                                                     com.apollographql.apollo.api.GraphqlFragment fragment,
                                                                     @NotNull
                                                                     CacheKey cacheKey,
                                                                     @NotNull
                                                                     com.apollographql.apollo.api.Operation.Variables variables)

Write fragment to the store.

Parameters:

fragment - data to be written to the store

cacheKey - CacheKey to be used as root record key

{@link - Operation.Variables} required for fragment arguments resolving

Returns:

to be performed, that will be resolved with set of keys of Record which have changed

writeAndPublish

@NotNull
ApolloStoreOperation<java.lang.Boolean> writeAndPublish(@NotNull
                                                                 com.apollographql.apollo.api.GraphqlFragment fragment,
                                                                 @NotNull
                                                                 CacheKey cacheKey,
                                                                 @NotNull
                                                                 com.apollographql.apollo.api.Operation.Variables variables)

Write fragment to the store and publish changes of Record which have changed, that will notify any ApolloQueryWatcher that depends on these Record to re-fetch.

Parameters:

fragment - data to be written to the store

cacheKey - CacheKey to be used as root record key

{@link - Operation.Variables} required for fragment arguments resolving

Returns:

to be performed

writeOptimisticUpdates

@NotNull
<D extends com.apollographql.apollo.api.Operation.Data,T,V extends com.apollographql.apollo.api.Operation.Variables> ApolloStoreOperation<java.util.Set<java.lang.String>> writeOptimisticUpdates(@NotNull
                                                                                                                                                                                                           com.apollographql.apollo.api.Operation<D,T,V> operation,
                                                                                                                                                                                                           @NotNull
                                                                                                                                                                                                           D operationData,
                                                                                                                                                                                                           @NotNull
                                                                                                                                                                                                           java.util.UUID mutationId)

Write operation data to the optimistic store.

Parameters:

operation - Operation response data of which should be written to the store

operationData - Operation.Data operation response data to be written to the store

mutationId - mutation unique identifier

Returns:

to be performed, that will be resolved with set of keys of Record which have changed

writeOptimisticUpdatesAndPublish

@NotNull
<D extends com.apollographql.apollo.api.Operation.Data,T,V extends com.apollographql.apollo.api.Operation.Variables> ApolloStoreOperation<java.lang.Boolean> writeOptimisticUpdatesAndPublish(@NotNull
                                                                                                                                                                                                       com.apollographql.apollo.api.Operation<D,T,V> operation,
                                                                                                                                                                                                       @NotNull
                                                                                                                                                                                                       D operationData,
                                                                                                                                                                                                       @NotNull
                                                                                                                                                                                                       java.util.UUID mutationId)

Write operation data to the optimistic store and publish changes of Records which have changed, that will notify any that depends on these Record to re-fetch.

Parameters:

operation - Operation response data of which should be written to the store

operationData - Operation.Data operation response data to be written to the store

mutationId - mutation unique identifier

Returns:

to be performed

rollbackOptimisticUpdates

@NotNull
ApolloStoreOperation<java.util.Set<java.lang.String>> rollbackOptimisticUpdates(@NotNull
                                                                                         java.util.UUID mutationId)

Rollback operation data optimistic updates.

Parameters:

mutationId - mutation unique identifier

Returns:

to be performed

rollbackOptimisticUpdatesAndPublish

@NotNull
ApolloStoreOperation<java.lang.Boolean> rollbackOptimisticUpdatesAndPublish(@NotNull
                                                                                     java.util.UUID mutationId)

Rollback operation data optimistic updates and publish changes of Records which have changed, that will notify any that depends on these Record to re-fetch.

Parameters:

mutationId - mutation unique identifier

Returns:

to be performed, that will be resolved with set of keys of Record which have changed