apollo-cache-persist
![build status](https://travis-ci.org/apollographql/apollo-cache-persist.svg?branch=master)
Simple persistence for all Apollo Client 2.0 cache implementations, including
InMemoryCache
and Hermes
.
Supports web and React Native. See all storage providers.
Basic Usage
To get started, simply pass your Apollo cache and an
underlying storage provider to persistCache
.
By default, the contents of your Apollo cache will be immediately restored
(asynchronously), and will be persisted upon every write to the cache (with a
short debounce interval).
Examples
React Native
import { AsyncStorage } from 'react-native';
import { InMemoryCache } from 'apollo-cache-inmemory';
import { persistCache } from 'apollo-cache-persist';
const cache = new InMemoryCache({...});
persistCache({
cache,
storage: AsyncStorage,
});
Web
import { InMemoryCache } from 'apollo-cache-inmemory';
import { persistCache } from 'apollo-cache-persist';
const cache = new InMemoryCache({...});
persistCache({
cache,
storage: window.localStorage,
});
Additional Options
persistCache
and the constructor for CachePersistor
accept the following
options:
persistCache({
cache: ApolloCache<TSerialized>,
storage: PersistentStorage<TPersisted>,
trigger?: 'write' | 'background' | function | false,
debounce?: number,
key?: string,
serialize?: boolean,
maxSize?: number | false,
debug?: boolean,
});
Advanced Usage
Using CachePersistor
Instead of using persistCache
, you can instantiate a CachePersistor
, which
will give you fine-grained control of persistence.
CachePersistor
accepts the same options as persistCache
and returns an
object with the following methods:
const persistor = new CachePersistor({...});
persistor.restore();
persistor.persist();
persistor.purge();
persistor.pause();
persistor.resume();
persistor.remove();
persistor.getLogs(print);
persistor.getSize();
Custom Triggers
For control over persistence timing, provide a function to the trigger
option.
The custom trigger should accept one argument (a persist
callback function),
and it should return a function that can be called to uninstall the trigger.
The TypeScript signature for this function is as follows:
(persist: () => void) => (() => void)
For example, this custom trigger will persist every 10 seconds:
const trigger = persist => {
const interval = setInterval(persist, 10000);
return () => clearInterval(interval);
};
Storage Providers
The following storage providers work 'out of the box', with no additional
dependencies:
AsyncStorage
on React Nativewindow.localStorage
on webwindow.sessionStorage
on weblocalForage
on web
apollo-cache-persist
uses the same storage provider API as
redux-persist
, so you can also make
use of the providers
listed here,
including:
If you're using React Native and set a maxSize
in excess of 2 MB, you must use
a filesystem-based storage provider, such as
redux-persist-fs-storage
.
AsyncStorage
does not support
individual values in excess of 2 MB on Android.
Common Questions
Why is the 'background' trigger only available for React Native?
Quite simply, because mobile apps are different than web apps.
Mobile apps are rarely terminated before transitioning to the background. This
is helped by the fact that an app is moved to the background whenever the user
returns home, activates the multitasking view, or follows a link to another app.
There's almost always an opportunity to persist.
On web, we could support a 'background' trigger with the
Page Visibility API;
however, data would be lost if the user closed the tab/window directly. Given
this prevalence of this user behavior and the substantially better performance
of the 'write' trigger on web, we've omitted a 'background' trigger on web.
I need to ensure certain data is not persisted. How do I filter my cache?
Unfortunately, this is not yet possible. You can only persist and restore the
cache in its entirety.
This library depends upon the extract
and persist
methods defined upon the
cache interface in Apollo Client 2.0. The payload returned and consumed by these
methods is opaque and differs from cache to cache. As such, we cannot reliably
transform the output.
Alternatives have been recommended in
#2,
including using logic in your UI to filter potentially-outdated information.
Furthermore, the maxSize
option and
methods on CachePersistor
provide facilities to
manage the growth of the cache.
For total control over the cache contents, you can setup a background task to
periodically reset the cache to contain only your app’s most important data. (On
the web, you can use a service worker; on React Native, there’s
react-native-background-task
.)
The background task would start with an empty cache, query the most important
data from your GraphQL API, and then persist. This strategy has the added
benefit of ensuring the cache is loaded with fresh data when your app launches.
Finally, it's worth mentioning that the Apollo community is in the early stages
of designing fine-grained cache controls, including the ability to utilize
directives and metadata to control cache policy on a per-key basis, so the
answer to this question will eventually change.
I've had a breaking schema change. How do I migrate or purge my cache?
For the same reasons given in the preceding answer, it's not possible to migrate
or transform your persisted cache data. However, by using the
methods on CachePersistor
, it's simple to reset the
cache upon changes to the schema.
Simply instantiate a CachePersistor
and only call restore()
if the app's
schema hasn't change. (You'll need to track your schema version yourself.)
Here's an example of how this could look:
import { AsyncStorage } from 'react-native';
import { InMemoryCache } from 'apollo-cache-inmemory';
import { CachePersistor } from 'apollo-cache-persist';
const SCHEMA_VERSION = '3';
const SCHEMA_VERSION_KEY = 'apollo-schema-version';
async function setupApollo() {
const cache = new InMemoryCache({...});
const persistor = new CachePersistor({
cache,
storage: AsyncStorage,
});
const currentVersion = await AsyncStorage.getItem(SCHEMA_VERSION_KEY);
if (currentVersion === SCHEMA_VERSION) {
await persistor.restore();
} else {
await persistor.purge();
await AsyncStorage.setItem(SCHEMA_VERSION_KEY, SCHEMA_VERSION);
}
}
I'm seeing errors on Android.
Specifically, this error:
BaseError: Couldn't read row 0, col 0 from CursorWindow. Make sure the Cursor is initialized correctly before accessing data from it.
This is the result of a 2 MB per key limitation of AsyncStorage
on Android. Set
a smaller maxSize
or switch to a filesystem-based storage provider, such as
redux-persist-fs-storage
.