Allow record-cache-based sources to define a custom cacheClass

packages/@orbit/indexeddb/src/indexeddb-cache.ts

@@ -30,6 +30,10 @@ export interface IndexedDBCacheSettings extends AsyncRecordCacheSettings {
   namespace?: string;
 }
 
+export interface IndexedDBCacheClass {
+  new (settings: IndexedDBCacheSettings): IndexedDBCache;
+}
+
 /**
  * A cache used to access records in an IndexedDB database.
  *

packages/@orbit/indexeddb/src/indexeddb-source.ts

@@ -30,13 +30,18 @@ import {
   RecordUpdatable,
   UpdateRecordOperation
 } from '@orbit/records';
-import { IndexedDBCache, IndexedDBCacheSettings } from './indexeddb-cache';
+import {
+  IndexedDBCache,
+  IndexedDBCacheClass,
+  IndexedDBCacheSettings
+} from './indexeddb-cache';
 import { supportsIndexedDB } from './lib/indexeddb';
 
 const { assert } = Orbit;
 
 export interface IndexedDBSourceSettings extends RecordSourceSettings {
   namespace?: string;
+  cacheClass?: IndexedDBCacheClass;
   cacheSettings?: Partial<IndexedDBCacheSettings>;
 }
 
@@ -73,7 +78,7 @@ export class IndexedDBSource extends RecordSource {
 
     super(settings);
 
-    let cacheSettings: Partial<IndexedDBCacheSettings> =
+    const cacheSettings: Partial<IndexedDBCacheSettings> =
       settings.cacheSettings ?? {};
     cacheSettings.schema = settings.schema;
     cacheSettings.keyMap = settings.keyMap;
@@ -87,7 +92,9 @@ export class IndexedDBSource extends RecordSource {
     cacheSettings.defaultTransformOptions =
       cacheSettings.defaultTransformOptions ?? settings.defaultTransformOptions;
 
-    this._cache = new IndexedDBCache(cacheSettings as IndexedDBCacheSettings);
+    const cacheClass = settings.cacheClass ?? IndexedDBCache;
+    this._cache = new cacheClass(cacheSettings as IndexedDBCacheSettings);
+
     if (autoActivate) {
       this.activate();
     }

packages/@orbit/indexeddb/test/indexeddb-source-test.ts

@@ -5,6 +5,7 @@ import {
   RecordKeyMap,
   RecordSchema
 } from '@orbit/records';
+import { IndexedDBCache } from '../src';
 import { IndexedDBSource } from '../src/indexeddb-source';
 import { getRecordFromIndexedDB } from './support/indexeddb';
 
@@ -76,6 +77,22 @@ module('IndexedDBSource', function (hooks) {
     );
   });
 
+  test('can be assigned a custom `cacheClass`', function (assert) {
+    class CustomCache extends IndexedDBCache {
+      custom = true;
+    }
+
+    source = new IndexedDBSource({
+      schema,
+      autoActivate: false,
+      cacheClass: CustomCache
+    });
+    assert.ok(
+      (source.cache as CustomCache).custom,
+      'custom cacheClass has been instantiated'
+    );
+  });
+
   test('shares its `transformBuilder` and `queryBuilder` with its cache', function (assert) {
     source = new IndexedDBSource({ schema, keyMap, autoActivate: false });
     assert.strictEqual(

packages/@orbit/local-storage/src/local-storage-cache.ts

@@ -12,6 +12,10 @@ export interface LocalStorageCacheSettings extends SyncRecordCacheSettings {
   namespace?: string;
 }
 
+export interface LocalStorageCacheClass {
+  new (settings: LocalStorageCacheSettings): LocalStorageCache;
+}
+
 /**
  * A cache used to access records in local storage.
  *

packages/@orbit/local-storage/src/local-storage-source.ts

@@ -35,6 +35,7 @@ import {
 import { supportsLocalStorage } from './lib/local-storage';
 import {
   LocalStorageCache,
+  LocalStorageCacheClass,
   LocalStorageCacheSettings
 } from './local-storage-cache';
 
@@ -43,6 +44,7 @@ const { assert } = Orbit;
 export interface LocalStorageSourceSettings extends RecordSourceSettings {
   delimiter?: string;
   namespace?: string;
+  cacheClass?: LocalStorageCacheClass;
   cacheSettings?: Partial<LocalStorageCacheSettings>;
 }
 
@@ -95,9 +97,8 @@ export class LocalStorageSource extends RecordSource {
     cacheSettings.namespace = cacheSettings.namespace ?? settings.namespace;
     cacheSettings.delimiter = cacheSettings.delimiter ?? settings.delimiter;
 
-    this._cache = new LocalStorageCache(
-      cacheSettings as LocalStorageCacheSettings
-    );
+    const cacheClass = settings.cacheClass ?? LocalStorageCache;
+    this._cache = new cacheClass(cacheSettings as LocalStorageCacheSettings);
   }
 
   get cache(): LocalStorageCache {

packages/@orbit/local-storage/test/local-storage-source-test.ts

@@ -7,13 +7,12 @@ import { buildTransform } from '@orbit/data';
 import {
   AddRecordOperation,
   Record,
-  RecordIdentity,
   RecordSchema,
   RecordSource,
-  RecordKeyMap,
-  RecordTransform
+  RecordKeyMap
 } from '@orbit/records';
 import { LocalStorageSource } from '../src/local-storage-source';
+import { LocalStorageCache } from '../src/local-storage-cache';
 
 const { module, test } = QUnit;
 
@@ -70,6 +69,22 @@ module('LocalStorageSource', function (hooks) {
     assert.equal(source.delimiter, '/', 'delimiter is `/` by default');
   });
 
+  test('can be assigned a custom `cacheClass`', function (assert) {
+    class CustomCache extends LocalStorageCache {
+      custom = true;
+    }
+
+    source = new LocalStorageSource({
+      schema,
+      autoActivate: false,
+      cacheClass: CustomCache
+    });
+    assert.ok(
+      (source.cache as CustomCache).custom,
+      'custom cacheClass has been instantiated'
+    );
+  });
+
   test('shares its `transformBuilder` and `queryBuilder` with its cache', function (assert) {
     assert.strictEqual(
       source.cache.transformBuilder,

packages/@orbit/memory/src/memory-cache.ts

@@ -11,6 +11,10 @@ export interface MemoryCacheSettings extends SyncRecordCacheSettings {
   base?: MemoryCache;
 }
 
+export interface MemoryCacheClass {
+  new (settings: MemoryCacheSettings): MemoryCache;
+}
+
 /**
  * A cache used to access records in memory.
  *

packages/@orbit/memory/src/memory-source.ts

@@ -26,10 +26,15 @@ import {
 } from '@orbit/data';
 import { ResponseHints } from '@orbit/data';
 import { Dict } from '@orbit/utils';
-import { MemoryCache, MemoryCacheSettings } from './memory-cache';
+import {
+  MemoryCache,
+  MemoryCacheClass,
+  MemoryCacheSettings
+} from './memory-cache';
 
 export interface MemorySourceSettings extends RecordSourceSettings {
   base?: MemorySource;
+  cacheClass?: MemoryCacheClass;
   cacheSettings?: Partial<MemoryCacheSettings>;
 }
 
@@ -87,7 +92,8 @@ export class MemorySource extends RecordSource {
       cacheSettings.base = this._base.cache;
     }
 
-    this._cache = new MemoryCache(cacheSettings as MemoryCacheSettings);
+    const cacheClass = settings.cacheClass ?? MemoryCache;
+    this._cache = new cacheClass(cacheSettings as MemoryCacheSettings);
   }
 
   get cache(): MemoryCache {

packages/@orbit/memory/test/memory-source-test.ts

@@ -14,6 +14,7 @@ import {
   RecordTransformBuilder
 } from '@orbit/records';
 import { clone } from '@orbit/utils';
+import { MemoryCache } from '../src/memory-cache';
 import { MemorySource } from '../src/memory-source';
 
 const { module, test } = QUnit;
@@ -100,6 +101,22 @@ module('MemorySource', function (hooks) {
     assert.equal(source.cache.processors.length, 2, 'cache has 2 processors');
   });
 
+  test('can be assigned a custom `cacheClass`', function (assert) {
+    class CustomCache extends MemoryCache {
+      custom = true;
+    }
+
+    const source = new MemorySource({
+      schema,
+      autoActivate: false,
+      cacheClass: CustomCache
+    });
+    assert.ok(
+      (source.cache as CustomCache).custom,
+      'custom cacheClass has been instantiated'
+    );
+  });
+
   test('shares its `transformBuilder` and `queryBuilder` with its cache', function (assert) {
     const source = new MemorySource({ schema, keyMap });
     assert.strictEqual(