feat(persistor): add an optional persistence mapper function to allow…

… cache filtration

src/Persistor.ts

@@ -2,7 +2,7 @@ import Log from './Log';
 import Storage from './Storage';
 import Cache from './Cache';
 
-import { ApolloPersistOptions } from './types';
+import { ApolloPersistOptions, PersistenceMapperFunction } from './types';
 
 export interface PersistorConfig<T> {
   log: Log<T>;
@@ -16,26 +16,38 @@ export default class Persistor<T> {
   storage: Storage<T>;
   maxSize?: number;
   paused: boolean;
+  persistenceMapper?: PersistenceMapperFunction;
 
   constructor(
     { log, cache, storage }: PersistorConfig<T>,
     options: ApolloPersistOptions<T>,
   ) {
-    const { maxSize = 1024 * 1024 } = options;
+    const {
+      maxSize = 1024 * 1024,
+      persistenceMapper,
+    } = options;
 
     this.log = log;
     this.cache = cache;
     this.storage = storage;
     this.paused = false;
 
+    if (persistenceMapper) {
+      this.persistenceMapper = persistenceMapper;
+    }
+
     if (maxSize) {
       this.maxSize = maxSize;
     }
   }
 
   async persist(): Promise<void> {
     try {
-      const data = this.cache.extract();
+      let data = this.cache.extract();
+
+      if (!this.paused && this.persistenceMapper) {
+        data = await this.persistenceMapper(data);
+      }
 
       if (
         this.maxSize != null &&

src/types/index.ts

@@ -8,6 +8,8 @@ export type TriggerUninstallFunction = () => void;
 
 export type TriggerFunction = (persist: () => void) => TriggerUninstallFunction;
 
+export type PersistenceMapperFunction = (data: any) => Promise<any>;
+
 export type PersistedData<T> = T | string | null;
 
 export interface PersistentStorage<T> {
@@ -24,5 +26,6 @@ export interface ApolloPersistOptions<TSerialized> {
   key?: string;
   serialize?: boolean;
   maxSize?: number | false;
+  persistenceMapper?: PersistenceMapperFunction;
   debug?: boolean;
 }