@keyvhq/memoize 1.6.26 → 1.6.28

package/LICENSE.md

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright © 2017 Luke Childs <lukechilds123@gmail.com> (https://lukechilds.co)
+Copyright © 2021 Microlink <hello@microlink.io> (https://microlink.io)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/README.md

@@ -11,20 +11,21 @@ npm install --save @keyvhq/memoize
 ## Usage
 
 ```js
-const memoize = require('@keyvhq/memoize');
+const memoize = require('@keyvhq/memoize')
 
-const memoizedRequest = memoize(request);
+const memoizedRequest = memoize(request)
 
-memoizedRequest('http://example.com').then(resp => { /* from request */ });
-memoizedRequest('http://example.com').then(resp => { /* from cache */ });
+memoizedRequest('http://example.com').then(res => { /* from request */ })
+memoizedRequest('http://example.com').then(res => { /* from cache */ })
 ```
 
-You can pass a [keyv](https://github.com/microlinkhq/keyv) instance or options to be used as argument.
+You can pass a [keyv](https://github.com/microlinkhq/keyv) instance or options to be used as argument:
 
 ```js
-memoize(request, { store: new Map() });
-memoize(request, 'redis://user:pass@localhost:6379');
-memoize(request, new Keyv());
+const memoize = require('@keyvhq/memoize')
+const Keyv = require('@keyvhq/core')
+
+memoize(request, { store: new Keyv({ namespace: 'ssr' }) })
 ```
 
 ### Defining the key
@@ -34,14 +35,14 @@ By default the first argument of your function call is used as cache key.
 You can pass a function to define how key will be defined. The key function will be called with the same arguments as the function.
 
 ```js
-const sum = (n1, n2) => n1 + n2;
+const sum = (n1, n2) => n1 + n2
 
 const memoized = memoize(sum, new Keyv(), {
   key: (n1, n2) => `${n1}+${n2}`
-});
+})
 
 // cached as { '1+2': 3 }
-memoized(1, 2); 
+memoized(1, 2)
 ```
 
 The library uses flood protection internally based on the result of the key. 
@@ -53,10 +54,10 @@ This means you can make as many requests as you want simultaneously while being
 Set `ttl` to a `number` for a static TTL value.
 
 ```js
-const memoizedRequest = memoize(request, new Keyv(), { ttl: 60000 });
+const memoizedRequest = memoize(request, new Keyv(), { ttl: 60000 })
 
 // cached for 60 seconds
-memoizedRequest('http://example.com');
+memoizedRequest('http://example.com')
 ```
 
 Set `ttl` to a `function` for a dynamic TTL value.
@@ -64,10 +65,10 @@ Set `ttl` to a `function` for a dynamic TTL value.
 ```js
 const memoizedRequest = memoize(request, new Keyv(), {
   ttl: (res) => res.statusCode === 200 ? 60000 : 0
-});
+})
 
 // cached for 60 seconds only if response was 200 OK
-memoizedRequest('http://example.com'); 
+memoizedRequest('http://example.com')
 ```
 
 ### Stale support
@@ -77,19 +78,19 @@ Set `staleTtl` to any `number` of milliseconds.
 If the `ttl` of a requested resource is below this staleness threshold we will still return the stale value but meanwhile asynchronously refresh the value.
 
 ```js
-const memoizedRequest = memoize(request, new Keyv(), { 
+const memoizedRequest = memoize(request, new Keyv(), {
   ttl: 60000,
   staleTtl: 10000
-});
+})
 
 // cached for 60 seconds
-memoizedRequest('http://example.com'); 
+memoizedRequest('http://example.com')
 
 // … 55 seconds later
 // Our cache will expire in 5 seconds.
 // This is below the staleness threshold of 10 seconds.
 // returns cached result + refresh cache on background
-memoizedRequest('http://example.com'); 
+memoizedRequest('http://example.com')
 ```
 
 When the `staleTtl` option is set we won't delete expired items either. The same logic as above applies.
@@ -123,13 +124,13 @@ It defines how the get will be obtained.
 The signature of the function should be a `String` to be used as key associated with the cache copy:
 
 ```js
-key: ({req}) => req.url
+key: ({ req }) => req.url
 ```
 
 Just in case you need a more granular control, you can return an `Array`, where the second value determines the expiration behavior:
 
 ```js
-key: ({req}) => [req.url, req.query.forceExpiration]
+key: ({ req }) => [req.url, req.query.forceExpiration]
 ```
 
 ##### objectMode

package/package.json

@@ -2,7 +2,7 @@
   "name": "@keyvhq/memoize",
   "description": "Memoize any function using Keyv as storage backend.",
   "homepage": "https://keyv.js.org",
-  "version": "1.6.26",
+  "version": "1.6.28",
   "main": "src/index.js",
   "author": {
     "email": "hello@microlink.io",
@@ -46,5 +46,6 @@
   "license": "MIT",
   "publishConfig": {
     "access": "public"
-  }
+  },
+  "gitHead": "69f95c41789d2a7fb83fbcc80e120e9f2a15274c"
 }