Add initial implementation for a SerialMultiCache

Author: trevor-scheer

packages/apollo-server-caching/src/SerialMultiCache.ts

@@ -0,0 +1,66 @@
+import {
+  TestableKeyValueCache,
+  KeyValueCacheSetOptions,
+} from './KeyValueCache';
+
+/**
+ * The SerialMultiCache class's purpose is to support a number of cache implementations
+ * with fallback behavior. The order of the provided `caches` argument is important - it
+ * determines the order in which the multicache will look, with the zero index being first
+ * and so on. A good application of this multicache might be, for example, an
+ * `InMemoryCache` followed by a `RedisCache`. Expected behavior of the multicache:
+ *   1. `get()` will look to the first cache, then second, etc. until it finds a result.
+ *       Upon a cache hit, all previous caches that missed will be populated with the
+ *       result.
+ *   2. `set()` will populate all caches with the provided value.
+ *   3. `delete()` will clear the entry from all caches.
+ *   4. `flush()` will call `flush()` on each cache if the function is implemented.
+ *   5. `close()` will call `close()` on each cache if the function is implemented.
+ */
+export class SerialMultiCache<T = string> implements TestableKeyValueCache<T> {
+  constructor(private caches: TestableKeyValueCache<T>[]) {}
+
+  async get(key: string) {
+    let foundIndex = 0;
+    let result: T | undefined;
+    for (const cache of this.caches) {
+      result = await cache.get(key);
+      // cache hit, we don't need to look any further in our array of caches
+      if (typeof result !== 'undefined') break;
+      foundIndex++;
+    }
+
+    // Populate the cache misses with the result
+    if (result) {
+      for (let i = 0; i < foundIndex; i++) {
+        this.caches[i].set(key, result);
+      }
+    }
+
+    return result;
+  }
+
+  async set(key: string, value: T, options?: KeyValueCacheSetOptions) {
+    for (const cache of this.caches) {
+      cache.set(key, value, options);
+    }
+  }
+
+  async delete(key: string) {
+    for (const cache of this.caches) {
+      cache.delete(key);
+    }
+  }
+
+  async flush() {
+    for (const cache of this.caches) {
+      cache.flush?.();
+    }
+  }
+
+  async close() {
+    for (const cache of this.caches) {
+      cache.close?.();
+    }
+  }
+}

packages/apollo-server-caching/src/__tests__/SerialMultiCache.test.ts

@@ -0,0 +1,89 @@
+import { SerialMultiCache } from '../SerialMultiCache';
+import { KeyValueCache } from '../KeyValueCache';
+
+function getMockCache(
+  cache: Record<string, number> = {},
+): KeyValueCache<number> {
+  const get = jest.fn(async (key: string) => cache[key]);
+  const set = jest.fn(async (key: string, value: number) => {
+    cache[key] = value;
+  });
+  const del = jest.fn(async (key: string) => delete cache[key]);
+
+  return { get, set, delete: del };
+}
+
+let multiCache: SerialMultiCache<number>;
+let tier0: KeyValueCache<number>;
+let tier1: KeyValueCache<number>;
+let tier2: KeyValueCache<number>;
+
+beforeEach(() => {
+  tier0 = getMockCache({ zero: 0 });
+  tier1 = getMockCache({ one: 1 });
+  tier2 = getMockCache({ two: 2 });
+
+  multiCache = new SerialMultiCache([tier0, tier1, tier2]);
+});
+
+describe('SerialMultiCache', () => {
+  describe('get', () => {
+    it("returns cached value on first cache hit, doesn't look further (hit tier0)", async () => {
+      const result = await multiCache.get('zero');
+
+      expect(result).toEqual(0);
+      expect(tier0.get).toHaveBeenCalled();
+      expect(tier1.get).not.toHaveBeenCalled();
+    });
+
+    it("returns cached value on first cache hit, doesn't look further (hit tier1)", async () => {
+      const result = await multiCache.get('one');
+
+      // expect a call up the chain until a hit
+      expect(tier0.get).toHaveBeenCalled();
+      expect(tier1.get).toHaveBeenCalled();
+      expect(tier2.get).not.toHaveBeenCalled();
+
+      expect(result).toEqual(1);
+
+      // expect lower tiers to have been populated with the result
+      expect(tier0.set).toHaveBeenCalledWith('one', 1);
+      expect(await tier0.get('one')).toEqual(1);
+    });
+
+    it('returns cached value from tier2 cache and populates tier0 and tier1', async () => {
+      const result = await multiCache.get('two');
+
+      // expect a call up the chain until a hit
+      expect(tier0.get).toHaveBeenCalled();
+      expect(tier1.get).toHaveBeenCalled();
+      expect(tier2.get).toHaveBeenCalled();
+
+      expect(result).toEqual(2);
+
+      // expect lower tiers to have been populated with the result
+      expect(tier0.set).toHaveBeenCalledWith('two', 2);
+      expect(tier1.set).toHaveBeenCalledWith('two', 2);
+      expect(await tier0.get('two')).toEqual(2);
+      expect(await tier1.get('two')).toEqual(2);
+    });
+  });
+
+  it('sets a cached value on all tiers', async () => {
+    multiCache.set('three', 3);
+
+    expect(await tier0.get('three')).toEqual(3);
+    expect(await tier1.get('three')).toEqual(3);
+    expect(await tier2.get('three')).toEqual(3);
+  });
+
+  it('deletes a cached value from all tiers', async () => {
+    // populate all caches with the 'two' entry
+    const result = await multiCache.get('two');
+    expect(result).toEqual(2);
+
+    multiCache.delete('two');
+
+    expect(await multiCache.get('two')).toBeUndefined();
+  });
+});