Implement disk cache

Author: Vadorequest

.gitignore

@@ -144,3 +144,6 @@ src/svg/*.tsx
 _site
 .sass-cache
 .jekyll-metadata
+
+# Tmp files (cache, etc.)
+*.cache

src/utils/memoization/cache.test.ts

@@ -1,19 +1,20 @@
 import cache from '../memoization/cache';
-import { reset as cacheReset } from '../memoization/inMemoryCacheStorage';
+import { reset as inDiskCacheReset } from '../memoization/inFileCacheStorage';
+import { reset as inMemoryCacheReset } from '../memoization/inMemoryCacheStorage';
 import waitFor from '../timers/waitFor';
 import { StorageOptions } from './cacheStorage';
 
 describe(`utils/memoization/cache.ts`, () => {
   beforeEach(() => {
     // Silent console log (used by logger.debug)
-    // @ts-ignore-error
-    global.console = { debug: jest.fn(), log: jest.fn() };
+    // @ts-ignore
+    global.console = global.muteConsole();
   });
 
   describe(`cache`, () => {
     describe(`should not fetch multiple times in a row but rely on the cache instead`, () => {
-      beforeEach(() => {
-        cacheReset();
+      afterEach(() => {
+        inMemoryCacheReset();
       });
       const expectationResult = { key: 'value' };
 
@@ -62,47 +63,39 @@ describe(`utils/memoization/cache.ts`, () => {
       });
 
       describe(`when using file storage (on disk)`, () => {
-        const storageOptions: StorageOptions = { storage: { type: 'disk', options: { filename: '.test-cache1' } } };
+        const storageOptions: StorageOptions = { storage: { type: 'disk', options: { filename: 'test-cache1.cache' } } };
+        const key = 'key';
 
         test(`when using the default TTL`, async () => {
-          const cacheHitsBefore = require('../memoization/inMemoryCacheStorage').cacheHits;
-          const cacheMissBefore = require('../memoization/inMemoryCacheStorage').cacheMiss;
-          expect(await cache('key', async () => {
+          expect(await cache(key, async () => {
             await waitFor(1);
             return expectationResult;
           }, storageOptions)).toEqual(expectationResult);
-          expect(await cache('key', async () => {
+          expect(await cache(key, async () => {
             await waitFor(1);
             return Promise.resolve(expectationResult);
           }, storageOptions)).toEqual(expectationResult);
 
-          const cacheHitsAfter = require('../memoization/inMemoryCacheStorage').cacheHits;
-          const cacheMissAfter = require('../memoization/inMemoryCacheStorage').cacheMiss;
-          expect(cacheHitsAfter).toBeGreaterThan(cacheHitsBefore);
-          expect(cacheMissAfter).toEqual(cacheMissBefore + 1); // Cache should have been missed only for the first call
+          await inDiskCacheReset(key, storageOptions);
         });
 
         describe(`should fetch multiple times and miss the cache`, () => {
           const expectationResult = { key2: 'value2' };
+          const key = 'key2';
 
           test(`when using TTL of 1 second and waiting more than 1 second between calls`, async () => {
-            const cacheHitsBefore = require('../memoization/inMemoryCacheStorage').cacheHits;
-            const cacheMissBefore = require('../memoization/inMemoryCacheStorage').cacheMiss;
             await waitFor(1001);
-            expect(await cache('key2', async () => {
+            expect(await cache(key, async () => {
               await waitFor(1);
               return Promise.resolve(expectationResult);
             }, storageOptions)).toEqual(expectationResult);
             await waitFor(1001);
-            expect(await cache('key2', async () => {
+            expect(await cache(key, async () => {
               await waitFor(1);
               return Promise.resolve(expectationResult);
             }, storageOptions)).toEqual(expectationResult);
 
-            const cacheHitsAfter = require('../memoization/inMemoryCacheStorage').cacheHits;
-            const cacheMissAfter = require('../memoization/inMemoryCacheStorage').cacheMiss;
-            expect(cacheHitsAfter).toEqual(cacheHitsBefore + 1);
-            expect(cacheMissAfter).toBeGreaterThan(cacheMissBefore);
+            await inDiskCacheReset(key, storageOptions);
           });
         });
       });

src/utils/memoization/cacheStorage.ts

@@ -11,7 +11,7 @@ export type CachedItem<T = any> = {
 export type StorageOptions<Options extends {} = {}> = Options;
 export type Get<T = any, Options extends StorageOptions = {}> = <T>(key: string, options?: Options) => Promise<CachedItem<T>>;
 export type Set<T = any, Options extends StorageOptions = {}> = <T>(key: string, item: T, options?: Options) => Promise<T>;
-export type Reset<> = () => Promise<void>;
+export type Reset<Options extends StorageOptions = {}> = (string?, options?: Options) => Promise<void>;
 export type Cache<T = any> = {
   [key: string]: CachedItem<T>;
 }

src/utils/memoization/inFileCacheStorage.ts

@@ -1,30 +1,32 @@
 import path from 'path';
-import { readFile, writeFile } from '../node/fs-utils';
-import {
-  CachedItem,
-  CacheHits,
-  CacheMiss,
-  CacheStorage as GenericCacheStorage,
-  Get,
-  Reset,
-  Set,
-  StorageOptions as GenericStorageOptions,
-} from './cacheStorage';
+import { deleteFile, readFile, writeFile } from '../node/fs-utils';
+import { CachedItem, CacheStorage as GenericCacheStorage, Get, Reset, Set, StorageOptions as GenericStorageOptions } from './cacheStorage';
 
 type StorageOptions = GenericStorageOptions<{ filename: string }>;
 type CacheStorage = GenericCacheStorage<any, StorageOptions>;
 
-export let cacheHits: CacheHits = 0;
-export let cacheMiss: CacheMiss = 0;
+const PREFIX = '.nrn';
 
 export const get: Get = async <T>(key: string, options: StorageOptions): Promise<CachedItem<T>> => {
   const { filename } = options;
-  const content = await readFile(path.resolve(filename + '-' + key), 'utf8');
+  let content;
+
+  try {
+    content = await readFile(path.resolve(PREFIX + '-' + key + '-' + filename), 'utf8');
+  } catch (e) {
+    // File doesn't exist (normal when cache has never been written)
+  }
+
+  let cachedItem: CachedItem;
+
   console.log('content', content);
-  const cachedItem: CachedItem = JSON.parse(content);
+  try {
+    cachedItem = JSON.parse(content);
+    console.log('cachedItem', cachedItem);
 
-  if (typeof cachedItem !== 'undefined') {
-    ++cacheHits;
+  } catch (e) {
+    console.error(e);
+    // TODO sentry
   }
 
   return cachedItem;
@@ -37,18 +39,19 @@ export const set: Set = async <T>(key: string, item: T, options: StorageOptions)
     value: item,
   };
 
-  ++cacheMiss;
-
-  await writeFile(filename + '-' + key, JSON.stringify(cachedItem), 'utf8');
+  await writeFile(path.resolve(PREFIX + '-' + key + '-' + filename), JSON.stringify(cachedItem), 'utf8');
 
   return item;
 };
 
-export const reset: Reset = (): Promise<void> => {
-  cacheHits = 0;
-  cacheMiss = 0;
-  // TODO
+export const reset: Reset = async (key, options: StorageOptions): Promise<void> => {
+  const { filename } = options;
 
+  try {
+    await deleteFile(PREFIX + '-' + key + '-' + filename);
+  } catch (e) {
+    // File doesn't exist (normal when cache has never been written)
+  }
   return;
 };
 

src/utils/node/fs-utils.ts

@@ -3,3 +3,4 @@ import { promisify } from 'util';
 
 export const readFile = promisify(fs.readFile);
 export const writeFile = promisify(fs.writeFile);
+export const deleteFile = promisify(fs.unlink);