ttl may be a function, handle appropriately (#38)

Co-authored-by: Peter Vogel <[email protected]>

Author: pvogel1967

src/cache.js

@@ -19,7 +19,8 @@ class Cache {
       throw new Error('storage is required')
     }
 
-    if (options.ttl && (typeof options.ttl !== 'number' || options.ttl < 0 || !Number.isInteger(options.ttl))) {
+    // ttl _may_ be a function to defer the ttl decision until later
+    if (options.ttl && typeof options.ttl === 'number' && (options.ttl < 0 || !Number.isInteger(options.ttl))) {
       throw new Error('ttl must be a positive integer greater than 0')
     }
 
@@ -250,12 +251,14 @@ class Wrapper {
     }
 
     const result = await this.func(args, key)
-
-    if (this.ttl < 1) {
+    const ttl = typeof this.ttl === 'function' ? this.ttl(result) : this.ttl
+    if (ttl === undefined || ttl === null || (typeof ttl !== 'number' || !Number.isInteger(ttl))) {
+      this.onError(new Error('ttl must be an integer'))
+      return result
+    }
+    if (ttl < 1) {
       return result
     }
-
-    const ttl = typeof this.ttl === 'function' ? this.ttl(result) : this.ttl
 
     if (!this.references) {
       let p = this.storage.set(storageKey, result, ttl)

test/cache.test.js

@@ -71,6 +71,92 @@ test('Cache', async (t) => {
     })
   })
 
+  test('should bypass setting value in storage if ttl function returns 0', async (t) => {
+    t.plan(1)
+    const cache = new Cache({ storage: createStorage() })
+    cache[kStorage].set = () => {
+      t.fail('should bypass storage')
+    }
+    cache.define('f', { ttl: (_data) => { return 0 } }, async (k) => {
+      t.equal(k, 'foo')
+
+      return { k }
+    })
+
+    await cache.f('foo')
+  })
+
+  test('should set value in storage if ttl function returns > 0', async (t) => {
+    t.plan(4)
+    const cache = new Cache({ storage: createStorage() })
+    cache[kStorage].set = (key, value, ttl) => {
+      t.equal(key, 'f~foo')
+      t.equal(value.k, 'foo')
+      t.equal(ttl, 1)
+    }
+    cache.define('f', { ttl: (data) => { return 1 } }, async (k) => {
+      t.equal(k, 'foo')
+
+      return { k }
+    })
+
+    await cache.f('foo')
+  })
+
+  test('should call onError and bypass storage if ttl fn returns non-integer', async (t) => {
+    t.plan(2)
+    const cache = new Cache({ storage: createStorage() })
+    cache[kStorage].set = () => {
+      t.fail('should bypass storage')
+    }
+    const onError = (err) => {
+      t.equal(err.message, 'ttl must be an integer')
+    }
+    cache.define('f', { ttl: (data) => { return 3.14 }, onError }, async (k) => {
+      t.equal(k, 'foo')
+
+      return { k }
+    })
+
+    await cache.f('foo')
+  })
+
+  test('should call onError and bypass storage if ttl fn returns undefined', async (t) => {
+    t.plan(2)
+    const cache = new Cache({ storage: createStorage() })
+    cache[kStorage].set = () => {
+      t.fail('should bypass storage')
+    }
+    const onError = (err) => {
+      t.equal(err.message, 'ttl must be an integer')
+    }
+    cache.define('f', { ttl: (data) => { return undefined }, onError }, async (k) => {
+      t.equal(k, 'foo')
+
+      return { k }
+    })
+
+    await cache.f('foo')
+  })
+
+  test('should call onError and bypass storage if ttl fn returns non-number', async (t) => {
+    t.plan(2)
+    const cache = new Cache({ storage: createStorage() })
+    cache[kStorage].set = () => {
+      t.fail('should bypass storage')
+    }
+    const onError = (err) => {
+      t.equal(err.message, 'ttl must be an integer')
+    }
+    cache.define('f', { ttl: (data) => { return '3' }, onError }, async (k) => {
+      t.equal(k, 'foo')
+
+      return { k }
+    })
+
+    await cache.f('foo')
+  })
+
   test('set', async (t) => {
     test('should use storage to set a value', async (t) => {
       t.plan(4)