@boredland/node-ts-cache 5.0.1 → 5.1.0

package/README.md

@@ -1,14 +1,15 @@
-# boredland/node-ts-cache
+# @boredland/node-ts-cache
 
 [![CI](https://github.com/boredland/node-ts-cache/actions/workflows/ci.yml/badge.svg)](https://github.com/boredland/node-ts-cache/actions/workflows/ci.yml)
 [![The MIT License](https://img.shields.io/npm/l/node-ts-cache.svg)](http://opensource.org/licenses/MIT)
+[![Coverage Status](https://coveralls.io/repos/github/boredland/node-ts-cache/badge.svg?branch=main)](https://coveralls.io/github/boredland/node-ts-cache?branch=main)
 
 Simple and extensible caching module supporting decorators.
 
 ## Install
 
 ```bash
-yarn add boredland/node-ts-cache
+yarn add @boredland/node-ts-cache
 ```
 
 _Note: The underlying storage layer must be installed separately._

package/dist/cache-container/cache-container-types.d.ts

@@ -9,7 +9,7 @@ export declare type CachedItem<T = any> = {
 export declare type CachingOptions = {
     /** (Default: 60) Number of seconds to expire the cachte item */
     ttl: number;
-    /** (Default: true) If true, expired cache entries will be deleted on touch. If false, entries will be deleted after the given ttl. */
+    /** (Default: true) If true, expired cache entries will be deleted on touch and returned anyway. If false, entries will be deleted after the given ttl. */
     isLazy: boolean;
     /** (Default: false) If true, cache entry has no expiration. */
     isCachedForever: boolean;

package/dist/cache-container/cache-container.d.ts

@@ -3,7 +3,13 @@ import type { CachingOptions } from "./cache-container-types";
 export declare class CacheContainer {
     private storage;
     constructor(storage: IStorage);
-    getItem<T>(key: string): Promise<T | undefined>;
+    getItem<T>(key: string): Promise<{
+        content: T;
+        meta: {
+            expired: boolean;
+            createdAt: number;
+        };
+    } | undefined>;
     setItem(key: string, content: any, options: Partial<CachingOptions>): Promise<void>;
     clear(): Promise<void>;
     private isItemExpired;

package/dist/cache-container/cache-container.js

@@ -14,11 +14,20 @@ class CacheContainer {
     }
     async getItem(key) {
         const item = await this.storage.getItem(key);
-        if (item?.meta?.ttl && this.isItemExpired(item)) {
+        if (!item)
+            return;
+        const result = {
+            content: item.content,
+            meta: {
+                createdAt: item.meta.createdAt,
+                expired: this.isItemExpired(item)
+            }
+        };
+        if (result.meta.expired)
             await this.unsetKey(key);
+        if (result.meta.expired && !item.meta.isLazy)
             return undefined;
-        }
-        return item ? item.content : undefined;
+        return result;
     }
     async setItem(key, content, options) {
         const finalOptions = {
@@ -32,12 +41,6 @@ class CacheContainer {
             isLazy: finalOptions.isLazy,
             ttl: finalOptions.isCachedForever ? Infinity : finalOptions.ttl * 1000
         };
-        if (!finalOptions.isCachedForever && !finalOptions.isLazy) {
-            setTimeout(() => {
-                this.unsetKey(key);
-                debug(`Expired key ${key} removed from cache`);
-            }, meta.ttl);
-        }
         await this.storage.setItem(key, { meta, content });
     }
     async clear() {

package/dist/decorator/cache-decorator.js

@@ -46,7 +46,7 @@ function Cache(container, options) {
                     const entry = await container.getItem(cacheKey);
                     if (entry) {
                         debug(`Cache HIT ${cacheKey}`);
-                        return entry;
+                        return entry.content;
                     }
                     debug(`Cache MISS ${cacheKey}`);
                     const methodResult = await runOriginalMethod();

package/dist/withCache.d.ts

@@ -4,6 +4,8 @@ declare type WithCacheOptions<Parameters> = Partial<Omit<CachingOptions, 'calcul
     prefix?: string;
     /** an optional function to calculate a key based on the parameters of the wrapped function */
     calculateKey?: (input: Parameters) => string;
+    /** an optional function that is called when a lazy item has expired and thus got removed  */
+    afterExpired?: () => Promise<void>;
 };
 /**
  * wrapped function factory

package/dist/withCache.js

@@ -20,7 +20,10 @@ const withCacheFactory = (container) => {
             const key = `${operation.name}:${prefix}:${calculateKey ? calculateKey(parameters) : JSON.stringify(parameters)}`;
             const cachedResponse = await container.getItem(key);
             if (cachedResponse) {
-                return cachedResponse;
+                if (cachedResponse.meta.expired && options.afterExpired) {
+                    await options.afterExpired();
+                }
+                return cachedResponse.content;
             }
             const result = await operation(...parameters);
             await container.setItem(key, result, rest);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@boredland/node-ts-cache",
   "description": "Simple and extensible caching module supporting decorators",
-  "version": "5.0.1",
+  "version": "5.1.0",
   "private": false,
   "main": "dist/index.js",
   "types": "dist/index.d.ts",