refactor: rewrite, use memcached-elasticache & drop Node 8

- [x] chore: drop Node 8 support. Min required version is [email protected]
- [x] refactor(deps): remove `lodash` and `bluebird`
- [x] refactor(cache): rewrite `Cache` with ES6 class syntax
- [x] refactor: `cache.set` no longer returns a value
- [x] refactor: make inofficial cache api private
- [x] fix: handle functions or promises as `cache.set` values as described in README.md
- [x] fix: remove deprecation message, that warned when backend `name` was not a string. It will throw a type error now.
- [x] deps: use `memcached-elasticache` instead of `memcached`
- [x] chore(deps): upgrade dependencies
- [x] test: add additional test to increase test coverage
- [x] docs(README): update API section

### BREAKING CHANGES:
#### General
- Dropped Node 8.x. Use Node 10.13 or higher.
- Uses `memcached-elasticache` with AWS support instead of `memcached`. See https://github.com/jkehres/memcached-elasticache#readme
- API functions no longer support callbacks.
- API functions use native Promises instead of `Bluebird`.
- `cached()` needs to be called with a string argument as name. If the `name` argument is undefined, it will fallback to `"default"`.

#### `Cache`
- `Cache.setBackend()` no longer returns the created backend.
- `Cache.getWrapped()` is removed.
- Cache backend APIs need to be promise based.
- Cache private function have been renamed.
- The following function are now private:
  - `Cache.applyPrefix`
  - `Cache.end`
  - `Cache.prepareOptions`
  - `Cache.setBackend`

#### `cache`
- `cache.set()`, `cache.get()`, `cache.getOrElse()`, `cache.unset()` no longer support the callback argument. Use them as promise.
- `cache.set()` no longer returns a value.
- `cache.set(key, value)` accepts functions and promises as value.

#### Backends
- Any client passed with the memcached backend options has to be an instance of `Memcached`.
- Backend setters no longer return a value.
- backend `addType()` does not return backend class anymore.

Author: Andreas Richter

.gitignore

@@ -4,3 +4,4 @@ npm-debug.log
 /tmp
 *.log
 /target
+/coverage

.travis.yml

@@ -1,15 +1,14 @@
 language: node_js
 node_js:
-  - 8
   - 10
   - 12
+  - 14
+  - 16
 deploy:
   - provider: script
     script: npx nlm release
-    skip_cleanup: true
+    cleanup: false
     'on':
       branch: master
-      node: 12
+      node_js: 16
 services: memcached
-before_install:
-  - npm i -g npm@^6

README.md

@@ -1,6 +1,7 @@
 # cached
 
-A simple caching library, inspired by the [Play cache API](http://www.playframework.com/documentation/2.2.x/ScalaCache) and biased towards [showing stale data instead of dog piling](http://highscalability.com/strategy-break-memcache-dog-pile).
+A simple caching library, inspired by the [Play cache API](http://www.playframework.com/documentation/2.2.x/ScalaCache) 
+and biased towards [showing stale data instead of dog piling](http://highscalability.com/strategy-break-memcache-dog-pile).
 The interface only exposes very limited functionality, there's no multi-get or deletion of cached data.
 The library is designed to support different caching backends, though right now only memcached is implemented.
 
@@ -17,99 +18,97 @@ More detailed API docs are in the next section.
 ### Getting and setting
 
 ```js
-cached = require('cached');
+const cached = require('cached');
 
-kittens = cached('kittens');
+const kittens = cached('kittens');
 
-// Set a key using a plain value
-kittens.set('my.key', 'Hello World');
+async function cacheKittens() {
 
-// Set a key using a lazily created promise (or value)
-kittens.set('my.key', function() {
-  return cache.get('other.key');
-});
-
-// Set a key using a callback-style function
-kittens.set('my.key', cached.deferred(function(done) {
-  done(null, 'Hello World');
-}));
-
-kittens.getOrElse('my.key', function() {
-  // This will store "Hello World" for key "my.key" if
-  // "my.key" was not found
-  return 'Hello World';
-}).then(function(data) {
-  console.log(data);
-});
-
-kittens.get('my.key', function(err, data) {
-  // Handle it the callback way
-});
-
-// Handle it the promise way
-kittens.get('my.key').then(
-  function(data) {
-    console.log(data);
-  },
-  function(err) {
-    throw err;
-  }
-);
+  // Set a key using a plain value
+  await kittens.set('my.key', 'Hello World');
+  
+  // Set a key using a lazily created promise
+  await kittens.set('my.key', () => {
+    return cache.get('other.key');
+  });
+  
+  // Set a key using a value)
+  await kittens.set('my.key', 'kitty');
+  
+  // Set a key using a callback-style function
+  await kittens.set('my.key', cached.deferred(done => {
+    done(null, 'Hello World');
+  }));
+  
+  const data = await kittens.getOrElse('my.key', () => {
+    // This will store "Hello World" for key "my.key" if
+    // "my.key" was not found
+    return 'Hello World';
+  });
+  
+  // Handle it the promise way
+  const data2 = await kittens.get('my.key').catch(err => {
+      throw err;
+    }
+  );
+}
 ```
 
 ## Supported backends
 
 ### Memcached
 
-A thin wrapper around [memcached](https://github.com/3rd-Eden/node-memcached).
-You can either provide a readily configured client or a combination of hosts and additional options.
+A thin wrapper around [memcached-elasticache](https://github.com/jkehres/memcached-elasticache).
+You can either provide a readily configured client, or a combination of hosts and additional options.
 Without any additional options it will default to a local memcached on `11211`.
 
 #### Custom client instance
 
 ```js
-var Memcached = require('memcached');
+const Memcached = require('memcached-elasticache');
 
 cached('myStuff', { backend: {
   type: 'memcached',
-  client: new Memcached('192.168.0.102:11212', { poolSize: 15 })
+  client: new Memcached('192.168.0.102:11212', { poolSize: 15 }),
 }});
 ```
 
-#### Let cached create the instance
+#### Let `cached` create the instance
 
 This will create the same cache as above.
 
 ```js
 cached('myStuff', { backend: {
   type: 'memcached',
   hosts: '192.168.0.102:11212',
-  poolSize: 15
+  poolSize: 15,
 }});
 ```
 
 ### Memory
 
 Stores all the data in an in-memory object. 
-*__Caveat:__ `get()` will return a reference to the stored value. Mutating the returned value will affect the value in the cache.*
+*__Caveat:__ `get()` will return a reference to the stored value. Mutating the returned value will affect the 
+value in the cache.*
 
 #### Example
 
 ```js
 cached('myStuff', { backend: {
-  type: 'memory'
+  type: 'memory',
 }});
 ```
 
 ### Noop
 
-Doesn't store data at all. All `set` operations succeed and `get` operations behave as if the value were not found in the cache.
+Doesn't store data at all. All `set` operations succeed and `get` operations behave as if the value were not 
+found in the cache.
 
 #### Examples
 
 ```js
 cached('myStuff', { backend: {
-  type: 'noop'
+  type: 'noop',
 }});
 ```
 
@@ -124,14 +123,18 @@ cached('myStuff');
 
 Creates a new named cache or returns a previously initialized cache.
 
-* **name:** (required) A meaningful name for what is in the cache. This will also be used as a key-prefix. If the name is `"cars"`, all keys will be prefixed with `"cars:"`
+* **name:** (required) A meaningful name for what is in the cache. This will also be used as a key-prefix. If the 
+  name is `"cars"`, all keys will be prefixed with `"cars:"`
 * **options:** (optional)
-  * **backend:** An object that has at least a `type` property. If no backend is configured, the cache will run in "noop"-mode, not caching anything. All other properties are forwarded to the backend, see [using different backends](#supported-backends) for which backend types exist and what options they support.
+  * **backend:** An object that has at least a `type` property. If no backend is configured, the cache will run in 
+    "noop"-mode, not caching anything. All other properties are forwarded to the backend, see 
+    [using different backends](#supported-backends) for which backend types exist and what options they support.
   * **defaults:** Defaults to apply for all cache operations. See `Cache.setDefaults`
 
 ### cached.createCache(options) -> Cache
 
-This allows you to circumvent the global named caches. The options are the same as above, just `name` is also part of the `options` object when using this function.
+This allows you to circumvent the global named caches. The options are the same as above, just `name` is also part 
+of the `options` object when using this function.
 
 ### cached.dropNamedCache(name: string) -> cached
 
@@ -143,67 +146,116 @@ Drop all named caches.
 
 ### cached.deferred(fn) -> () -> Promise
 
-Convert a node-style function that takes a callback as its first parameter into a parameterless function that generates a promise.
-In other words: this is what you'd want to wrap your node-style functions in when using them as value arguments to `set` or `getOrElse`.
-
-#### Example:
+Convert a node-style function that takes a callback as its first parameter into a parameterless function that 
+generates a promise. In other words: this is what you'd want to wrap your node-style functions in when using them 
+as value arguments to `set` or `getOrElse`.
 
+**Example:**
 ```js
-var f = cached.deferred(function(cb) {
-  var req = require('http').get(myUrl, function(res) {
+const http = require('http');
+
+const cache = cached('myStuff');
+const f = cached.deferred(cb => {
+  const req = http.get(myUrl, res => {
     cb(null, res.statusCode);
   });
   req.once('error', cb);
 });
+
 // f can now be called and the return value will be a promise
 f().then(function(statusCode) { console.log(statusCode); });
+
 // More importantly it can be passed into cache.set
-cached('myStuff').set('someKey', f);
+await cache.set('someKey', f);
 ```
 
 ### Cache.setDefaults(defaults) -> Cache.defaults
 
 Extends the current defaults with the provided defaults.
 The two important ones are `freshFor` and `expire`:
 
-* `expire` is the time in seconds after which a value should be deleted from the cache (or whatever expiring natively means for the backend). Usually you'd want this to be `0` (never expire).
-* `freshFor` is the time in seconds after which a value should be replaced. Replacing the value is done in the background and while the new value is generated (e.g. data is fetched from some service) the stale value is returned. Think of `freshFor` as a smarter `expire`.
+* `expire` is the time in seconds after which a value should be deleted from the cache 
+  (or whatever expiring natively means for the backend). Usually you'd want this to be `0` (never expire).
+* `freshFor` is the time in seconds after which a value should be replaced. Replacing the value is done in 
+  the background and while the new value is generated (e.g. data is fetched from some service) the stale 
+  value is returned. Think of `freshFor` as a smarter `expire`.
 * `timeout` is the maximum time in milliseconds to wait for cache operations to complete.
   Configuring a timeout ensures that all `get`, `set`, and `unset` operations fail fast.
-  Otherwise there will be situations where one of the cache hosts goes down and reads hang for minutes while the memcached client retries to establish a connection.
+  Otherwise, there will be situations where one of the cache hosts goes down and reads hang for minutes while 
+  the memcached client retries to establish a connection.
   It's **highly** recommended to set a timeout.
-  If `timeout` is left `undefined`, no timeout will be set and the operations will only fail once the underlying client, e.g. [`memcached`](https://github.com/3rd-Eden/memcached), gave up.
+  If `timeout` is left `undefined`, no timeout will be set, and the operations will only fail once the 
+  underlying client, e.g. [`memcached`](https://github.com/3rd-Eden/memcached), gave up.
+  
+### Cache.get(key) -> Promise\<value\>
+
+Cache retrieve operation. `key` has to be a string.
+Cache misses are generally treated the same as retrieving `null`, errors should only be caused by transport 
+errors and connection problems.
+If you want to cache `null`/`undefined` (e.g. 404 responses), you may want to wrap it or choose a different 
+value, like `false`, to represent this condition.
+
+**Example:**
+```js
+await cache.get('foo');
+```
 
-### Cache.set(key, value, opts, cb) -> Promise[Value]
+### Cache.getOrElse(key, value, opts) -> Promise\<value\>
+
+This is the function you'd want to use most of the time.
+It takes the same arguments as `set` but it will check the cache first.
+If a value is already cached, it will return it directly (respond as fast as possible).
+If the value is marked as stale (generated `n` seconds ago with `n > freshFor`), it will replace the value 
+in the cache. When multiple `getOrElse` calls concurrently encounter the same stale value, it will only replace 
+the value once. This is done on a per-instance level, so if you create many cache instances reading and writing 
+the same keys, you are asking for trouble. If you don't, the worst case is every process in your system fetching 
+the value at once. Which should be a smaller number than the number of concurrent requests in most cases.
+
+**Examples:**
+```js
+// with a value
+const res = await cache.getOrElse('foo', 'bar');
+
+// with a function returning a value
+const res = await cache.getOrElse('foo', () => { return 'bar' });
+
+// with a function returning a promise
+const res = await cache.getOrElse('foo', () => { return Promise.resolve('bar') });
+
+// with a promise function
+const res = await cache.getOrElse('foo', async () => { return 'bar' });
+```
+
+### Cache.set(key, value, opts) -> Promise\<void\>
 
 Cache store operation. `key` has to be a string, for possible `opts` see `Cache.setDefaults`.
 The value can be any of the following:
 
-a. Anything that can be converted to JSON
-b. A Promise of (a)
-c. A function returning (a) or (b)
+a) Anything that can be converted to JSON<br>
+b) A Promise of (a)<br>
+c) A function returning (a) or (b)<br>
 
-The callback will be called with the resolved value, following node conventions (error, value).
+**Examples:**
+```js
+// with a value
+await cache.set('foo', 'bar');
 
-### Cache.get(key, cb) -> Promise[Value]
+// with a function returning a value
+await cache.set('foo', () => { return 'bar' });
 
-Cache retrieve operation.
-`key` has to be a string.
-Cache misses are generally treated the same as retrieving `null`, errors should only be caused by transport errors and connection problems.
-If you want to cache `null`/`undefined` (e.g. 404 responses), you may want to wrap it or choose a different value, like `false`, to represent this condition.
+// with a function returning a promise
+await cache.set('foo', () => { return Promise.resolve('bar') });
 
-### Cache.getOrElse(key, value, opts, cb) -> Promise[Value]
-
-This is the function you'd want to use most of the time.
-It takes the same arguments as `set` but it will check the cache first.
-If a value is already cached, it will return it directly (respond as fast as possible).
-If the value is marked as stale (generated `n` seconds ago with `n > freshFor`), it will replace the value in the cache.
-When multiple `getOrElse` calls concurrently encounter the same stale value, it will only replace the value once.
-This is done on a per-instance level, so if you create many cache instances reading and writing the same keys, you are asking for trouble.
-If you don't, the worst case is every process in your system fetching the value at once.
-Which should be a smaller number than the number of concurrent requests in most cases.
+// with a promise function
+await cache.set('foo', async () => { return 'bar' });
+```
 
-### Cache.unset(key, cb) -> Promise
+### Cache.unset(key) -> Promise\<void\>
 
 Cache delete operation.
 `key` has to be a string.
+
+**Example:**
+```js
+await cache.unset('foo');
+```