node-cache - updating readme for NodeCacheStore

Author: jaredwray

packages/node-cache/README.md

@@ -86,8 +86,8 @@ The `NodeCacheStore` is a class that extends the `NodeCache` and adds the abilit
 import {NodeCacheStore} from '@cacheable/node-cache';
 
 const cache = new NodeCacheStore();
-cache.set('foo', 'bar');
-cache.get('foo'); // 'bar'
+await cache.set('foo', 'bar');
+await cache.get('foo'); // 'bar'
 ```
 
 ## NodeCacheStoreOptions
@@ -108,8 +108,8 @@ Note: the `ttl` is now in milliseconds and not seconds like `stdTTL` in `NodeCac
 
 ```javascript
 const cache = new NodeCacheStore({ttl: 60000 }); // 1 minute as it defaults to milliseconds
-cache.set('foo', 'bar', '1h'); // 1 hour
-cache.set('longfoo', 'bar', '1d'); // 1 day
+await cache.set('foo', 'bar', '1h'); // 1 hour
+await cache.set('longfoo', 'bar', '1d'); // 1 day
 ```
 
 ## Node Cache Store API
@@ -161,20 +161,20 @@ cache.on('expired', (key, value) => {
 });
 ```
 
-## `.set(key: string | number, value: any, ttl?: number): boolean`
+## `.set(key: string | number, value: any, ttl?: number): Promise<boolean>`
 
 Set a key value pair with an optional ttl (in seconds). Will return true on success. If the ttl is not set it will default to 0 (no ttl).
 
 ```javascript
-cache.set('foo', 'bar', 10); // true
+await cache.set('foo', 'bar', 10); // true
 ```
 
-## `.mset(data: Array<NodeCacheItem>): boolean`
+## `.mset(data: Array<NodeCacheItem>): Promise<boolean>`
 
 Set multiple key value pairs at once. This will take an array of objects with the key, value, and optional ttl.
 
 ```javascript
-cache.mset([{key: 'foo', value: 'bar', ttl: 10}, {key: 'bar', value: 'baz'}]); // true
+await cache.mset([{key: 'foo', value: 'bar', ttl: 10}, {key: 'bar', value: 'baz'}]); // true
 ```
 
 the `NodeCacheItem` is defined as:
@@ -187,89 +187,89 @@ export type NodeCacheItem = {
 };
 ```
 
-## `.get(key: string | number): any`
+## `.get(key: string | number): Promise<any>`
 
 Get a value from the cache by key. If the key does not exist it will return `undefined`.
 
 ```javascript
 cache.get('foo'); // 'bar'
 ```
 
-## `mget(keys: Array<string | number>): Record<string, unknown>`
+## `mget(keys: Array<string | number>): Promise<Record<string, unknown>>`
 
 Get multiple values from the cache by keys. This will return an object with the keys and values.
 
 ```javascript
 const obj = { my: 'value', my2: 'value2' };
 const obj2 = { special: 'value3', life: 'value4' };
-cache.set('my', obj);
-cache.set('my2', obj2);
-cache.mget(['my', 'my2']); // { my: { my: 'value', my2: 'value2' }, my2: { special: 'value3', life: 'value4' } }
+await cache.set('my', obj);
+await cache.set('my2', obj2);
+await cache.mget(['my', 'my2']); // { my: { my: 'value', my2: 'value2' }, my2: { special: 'value3', life: 'value4' } }
 ```
 
-## `take(key: string | number): any`
+## `take(key: string | number): Promise<T>`
 
 Get a value from the cache by key and delete it. If the key does not exist it will return `undefined`.
 
 ```javascript
-cache.set('foo', 'bar');
-cache.take('foo'); // 'bar'
-cache.get('foo'); // undefined
+await cache.set('foo', 'bar');
+await cache.take('foo'); // 'bar'
+await cache.get('foo'); // undefined
 ```
 
-## `del(key: string | number | Array<string | number>): number`
+## `del(key: string | number | Array<string | number>): Promise<number>`
 
 Delete a key from the cache. Will return the number of deleted entries and never fail. You can also pass in an array of keys to delete multiple keys. All examples assume that you have initialized the cache like `const cache = new NodeCache();`.
 
 ```javascript
-cache.del('foo'); // true
+await cache.del('foo'); // true
 ```
 
 passing in an array of keys:
 
 ```javascript
-cache.del(['foo', 'bar']); // true
+await cache.del(['foo', 'bar']); // true
 ```
 
-## `.mdel(keys: Array<string | number>): number`
+## `.mdel(keys: Array<string | number>): Promise<number>`
 
 Delete multiple keys from the cache. Will return the number of deleted entries and never fail.
 
 ```javascript
-cache.mdel(['foo', 'bar']); // true
+await cache.mdel(['foo', 'bar']); // true
 ```
 
-## `.ttl(key: string | number, ttl?: number): boolean`
+## `.ttl(key: string | number, ttl?: number): Promise<boolean>`
 
 Redefine the ttl of a key. Returns true if the key has been found and changed. Otherwise returns false. If the ttl-argument isn't passed the default-TTL will be used.
 
 ```javascript
-cache.ttl('foo', 10); // true
+await cache.ttl('foo', 10); // true
 ```
 
-## `getTtl(key: string | number): number | undefined`
+## `getTtl(key: string | number): Promise<number | undefined>`
 
 Get the ttl expiration from `Date.now()` of a key. If the key does not exist it will return `undefined`.
 
 ```javascript
-cache.getTtl('foo'); // 1725993344859
+await cache.getTtl('foo'); // 1725993344859
 ```
 
-## `has(key: string | number): boolean`
+## `has(key: string | number): Promise<boolean>`
 
 Check if a key exists in the cache.
 
 ```javascript
-cache.set('foo', 'bar');
-cache.has('foo'); // true
+await cache.set('foo', 'bar');
+await cache.has('foo'); // true
 ```
 
-## `keys(): Array<string>`
+## `keys(): Promise<Array<string>>`
 
 Get all keys from the cache.
 
 ```javascript
-cache.keys(); // ['foo', 'bar']
+await cache.keys(); // ['foo', 'bar']
 ```
 
 ## `getStats(): NodeCacheStats`
@@ -286,7 +286,7 @@ Flush the cache. Will remove all keys and reset the stats.
 
 ```javascript
 cache.flushAll();
-cache.keys(); // []
+await cache.keys(); // []
 cache.getStats(); // {hits: 0, misses: 0, keys: 0, ksize: 0, vsize: 0}
 ```
 
@@ -295,18 +295,10 @@ cache.getStats(); // {hits: 0, misses: 0, keys: 0, ksize: 0, vsize: 0}
 Flush the stats. Will reset the stats but keep the keys.
 
 ```javascript
-cache.set('foo', 'bar');
+await cache.set('foo', 'bar');
 cache.flushStats();
 cache.getStats(); // {hits: 0, misses: 0, keys: 0, ksize: 0, vsize: 0}
-cache.keys(); // ['foo']
-```
-
-## `close(): void`
-
-this will stop the interval that is running for the `checkperiod` and `deleteOnExpire` options.
-
-```javascript
-cache.close();
+await cache.keys(); // ['foo']
 ```
 
 ## `on(event: string, callback: Function): void`

packages/node-cache/src/store.ts

@@ -239,7 +239,7 @@ export class NodeCacheStore extends Hookified {
 	/**
 	 * Check if a key exists in the cache. If it does exist it will get the value and delete the item from the cache.
 	 * @param {string | number} key
-	 * @returns {any | undefined}
+	 * @returns {T | undefined}
 	 */
 	public async take<T>(key: string | number): Promise<T | undefined> {
 		return this._cache.take<T>(key.toString());