Add a generic parameter so TS users can use serialize: false

.vscode/tasks.json

@@ -1,8 +1,26 @@
 {
-  "version": "0.1.0",
+  "version": "2.0.0",
   "command": "tsc",
-  "isShellCommand": true,
   "args": ["-w", "-p", ".", "--noEmit"],
   "isBackground": true,
-  "problemMatcher": "$tsc-watch"
+  "problemMatcher": "$tsc-watch",
+  "tasks": [
+    {
+      "label": "tsc",
+      "type": "shell",
+      "command": "tsc",
+      "args": [
+        "-w",
+        "-p",
+        ".",
+        "--noEmit"
+      ],
+      "isBackground": true,
+      "problemMatcher": "$tsc-watch",
+      "group": {
+        "_id": "build",
+        "isDefault": false
+      }
+    }
+  ]
 }

src/Cache.ts

@@ -1,11 +1,11 @@
 import { ApolloCache } from '@apollo/client/core';
 import { ApolloPersistOptions, PersistedData } from './types';
 
-export default class Cache<T> {
+export default class CacheLog<T, U extends boolean = true> {
   cache: ApolloCache<T>;
   serialize: boolean;
 
-  constructor(options: ApolloPersistOptions<T>) {
+  constructor(options: ApolloPersistOptions<T, U>) {
     const { cache, serialize = true } = options;
 
     this.cache = cache;

src/CachePersistor.ts

@@ -6,14 +6,14 @@ import Trigger from './Trigger';
 
 import { ApolloPersistOptions, LogLine } from './types';
 
-export default class CachePersistor<T> {
+export default class CachePersistor<T, U extends boolean = true> {
   log: Log<T>;
   cache: Cache<T>;
   storage: Storage<T>;
   persistor: Persistor<T>;
   trigger: Trigger<T>;
 
-  constructor(options: ApolloPersistOptions<T>) {
+  constructor(options: ApolloPersistOptions<T, U>) {
     if (!options.cache) {
       throw new Error(
         'In order to persist your Apollo Cache, you need to pass in a cache. ' +

src/Log.ts

@@ -1,13 +1,13 @@
 import { ApolloPersistOptions, LogLevel, LogLine } from './types';
 
-export default class Log<T> {
+export default class Log<T, U extends boolean = true> {
   debug: boolean;
   lines: Array<LogLine>;
 
   static buffer = 30;
   static prefix = '[apollo-cache-persist]';
 
-  constructor(options: ApolloPersistOptions<T>) {
+  constructor(options: ApolloPersistOptions<T, U>) {
     const { debug = false } = options;
 
     this.debug = debug;

src/Persistor.ts

@@ -10,7 +10,7 @@ export interface PersistorConfig<T> {
   storage: Storage<T>;
 }
 
-export default class Persistor<T> {
+export default class Persistor<T, U extends boolean = true> {
   log: Log<T>;
   cache: Cache<T>;
   storage: Storage<T>;
@@ -20,7 +20,7 @@ export default class Persistor<T> {
 
   constructor(
     { log, cache, storage }: PersistorConfig<T>,
-    options: ApolloPersistOptions<T>,
+    options: ApolloPersistOptions<T, U>,
   ) {
     const {
       maxSize = 1024 * 1024,

src/Storage.ts

@@ -4,11 +4,11 @@ import {
   PersistedData,
 } from './types';
 
-export default class Storage<T> {
+export default class Storage<T, U extends boolean = true> {
   storage: PersistentStorage<PersistedData<T>>;
   key: string;
 
-  constructor(options: ApolloPersistOptions<T>) {
+  constructor(options: ApolloPersistOptions<T, U>) {
     const { storage, key = 'apollo-cache-persist' } = options;
 
     this.storage = storage;

src/Trigger.ts

@@ -10,7 +10,7 @@ export interface TriggerConfig<T> {
   persistor: Persistor<T>;
 }
 
-export default class Trigger<T> {
+export default class Trigger<T, U extends boolean = true> {
   debounce: number;
   persistor: Persistor<T>;
   paused: boolean;
@@ -21,7 +21,7 @@ export default class Trigger<T> {
 
   constructor(
     { log, persistor }: TriggerConfig<T>,
-    options: ApolloPersistOptions<T>
+    options: ApolloPersistOptions<T, U>
   ) {
     const { defaultDebounce } = Trigger;
     const { cache, debounce, trigger = 'write' } = options;

src/persistCacheSync.ts

@@ -5,22 +5,22 @@ import Storage from './Storage';
 
 /**
  * Add cache to persist engine using synchronous API
- * 
+ *
  * @see SynchronousCachePersistor for advanced use cases
  * @param options options for persist engine
  */
-export const persistCacheSync = <T>(options: ApolloPersistOptions<T>) => {
+export const persistCacheSync = <T, U extends boolean = true>(options: ApolloPersistOptions<T, U>) => {
   const cachePersistor = new SynchronousCachePersistor(options);
   cachePersistor.restoreSync();
 };
 
 /**
  * Persistor engine that is going to use synchronous api
  */
-export class SynchronousCachePersistor<T> extends CachePersistor<T> {
+export class SynchronousCachePersistor<T, U extends boolean = true> extends CachePersistor<T, U> {
   persistor: SynchronousPersistor<T>;
 
-  constructor(options: ApolloPersistOptions<T>) {
+  constructor(options: ApolloPersistOptions<T, U>) {
     super(options);
 
     this.storage = new SynchronousStorage(options);
@@ -35,12 +35,12 @@ export class SynchronousCachePersistor<T> extends CachePersistor<T> {
   }
 }
 
-export class SynchronousPersistor<T> extends Persistor<T> {
-  storage: SynchronousStorage<T>;
+export class SynchronousPersistor<T, U extends boolean = true> extends Persistor<T, U> {
+  storage: SynchronousStorage<T, U>;
 
   constructor(
     { log, cache, storage }: PersistorConfig<T>,
-    options: ApolloPersistOptions<T>,
+    options: ApolloPersistOptions<T, U>,
   ) {
     super({ log, cache, storage }, options);
   }
@@ -50,8 +50,8 @@ export class SynchronousPersistor<T> extends Persistor<T> {
   }
 }
 
-export class SynchronousStorage<T> extends Storage<T> {
-  constructor(options: ApolloPersistOptions<T>) {
+export class SynchronousStorage<T, U extends boolean = true> extends Storage<T, U> {
+  constructor(options: ApolloPersistOptions<T, U>) {
     super(options);
   }