@boredland/node-ts-cache 5.0.1 → 6.0.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._
@@ -17,9 +18,10 @@ _Note: The underlying storage layer must be installed separately._
 
 | Storage                                                               | Install                                         |
 |-----------------------------------------------------------------------|-------------------------------------------------|
-| [memory](https://www.npmjs.com/package/boredland/node-ts-cache-storage-memory)| ```yarn add @boredland/node-ts-cache-storage-memory```|
-| [node-fs](https://www.npmjs.com/package/boredland/node-ts-cache-storage-node-fs)| ```yarn add @boredland/node-ts-cache-storage-node-fs```|
-| [ioredis](https://www.npmjs.com/package/boredland/node-ts-cache-storage-ioredis)| ```yarn add @boredland/node-ts-cache-storage-ioredis```|
+| [memory](https://www.npmjs.com/package/@boredland/node-ts-cache-storage-memory)| ```yarn add @boredland/node-ts-cache-storage-memory```|
+| [node-fs](https://www.npmjs.com/package/@boredland/node-ts-cache-storage-node-fs)| ```yarn add @boredland/node-ts-cache-storage-node-fs```|
+| [ioredis](https://www.npmjs.com/package/@boredland/node-ts-cache-storage-ioredis)| ```yarn add @boredland/node-ts-cache-storage-ioredis```|
+| [postgres](https://www.npmjs.com/package/@boredland/node-ts-cache-storage-pg)| ```yarn add @boredland/node-ts-cache-storage-pg```|
 
 ## Usage
 
@@ -70,7 +72,7 @@ const myCache = new CacheContainer(new MemoryStorage())
 
 class MyService {
     public async getUsers(): Promise<string[]> {
-        const cachedUsers = await myCache.getItem<string[]>("users")
+        const { content: cachedUsers } = await myCache.getItem<string[]>("users")
 
         if (cachedUsers) {
             return cachedUsers

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

@@ -2,14 +2,14 @@ export declare type CachedItem<T = any> = {
     content: T;
     meta: {
         createdAt: number;
-        ttl: number;
+        ttl: number | null;
         isLazy: boolean;
     };
 };
 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

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

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

@@ -14,30 +14,33 @@ 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 = {
             ttl: DEFAULT_TTL_SECONDS,
             isLazy: true,
             isCachedForever: false,
-            ...options
+            ...options,
         };
         const meta = {
             createdAt: Date.now(),
             isLazy: finalOptions.isLazy,
-            ttl: finalOptions.isCachedForever ? Infinity : finalOptions.ttl * 1000
+            ttl: finalOptions.isCachedForever ? null : 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() {
@@ -45,12 +48,12 @@ class CacheContainer {
         debug("Cleared cache");
     }
     isItemExpired(item) {
-        if (item.meta.ttl === Infinity)
+        if (item.meta.ttl === null)
             return false;
         return Date.now() > item.meta.createdAt + item.meta.ttl;
     }
     async unsetKey(key) {
-        await this.storage.setItem(key, undefined);
+        await this.storage.removeItem(key);
     }
 }
 exports.CacheContainer = CacheContainer;

package/dist/decorator/cache-decorator.js

@@ -10,7 +10,9 @@ const jsonCalculateKey = (data) => {
     return `${data.className}:${data.methodName}:${JSON.stringify(data.args)}`;
 };
 function Cache(container, options) {
-    return function (target, methodName, descriptor) {
+    return function (target, methodName, 
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    descriptor) {
         const originalMethod = descriptor.value;
         const className = target.constructor.name;
         descriptor.value = async function (...args) {
@@ -18,21 +20,14 @@ function Cache(container, options) {
             const keyOptions = {
                 args,
                 methodName: methodName,
-                className
+                className,
             };
             const cacheKey = options.calculateKey
                 ? options.calculateKey(keyOptions)
                 : jsonCalculateKey(keyOptions);
-            const runOriginalMethod = async () => {
+            const runOriginalMethod = () => {
                 const methodCall = originalMethod.apply(this, args);
-                const isAsync = methodCall?.constructor?.name === "AsyncFunction" ||
-                    methodCall?.constructor?.name === "Promise";
-                if (isAsync) {
-                    return await methodCall;
-                }
-                else {
-                    return methodCall;
-                }
+                return methodCall;
             };
             if (!target.__node_ts_cache_method_run_queue) {
                 target.__node_ts_cache_method_run_queue = {};
@@ -46,7 +41,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();
@@ -54,8 +49,8 @@ function Cache(container, options) {
                     return methodResult;
                 }
                 finally {
-                    target.__node_ts_cache_method_run_queue[cacheKey] =
-                        undefined;
+                    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                    target.__node_ts_cache_method_run_queue[cacheKey] = undefined;
                 }
             })();
             return target.__node_ts_cache_method_run_queue[cacheKey];

package/dist/storage/storage-types.d.ts

@@ -1,6 +1,7 @@
 import type { CachedItem } from "../cache-container";
-export interface IStorage {
+export interface Storage {
     getItem(key: string): Promise<CachedItem | undefined>;
-    setItem(key: string, content: CachedItem | undefined): Promise<void>;
+    setItem(key: string, content: CachedItem): Promise<void>;
+    removeItem(key: string): Promise<void>;
     clear(): Promise<void>;
 }

package/dist/withCache.d.ts

@@ -1,9 +1,11 @@
 import type { CacheContainer, CachingOptions } from "./cache-container";
-declare type WithCacheOptions<Parameters> = Partial<Omit<CachingOptions, 'calculateKey'>> & {
+declare type WithCacheOptions<Parameters> = Partial<Omit<CachingOptions, "calculateKey">> & {
     /** an optional prefix to prepend to the key */
     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

@@ -15,12 +15,15 @@ const withCacheFactory = (container) => {
      */
     const withCache = (operation, options = {}) => {
         return async (...parameters) => {
-            let { prefix, calculateKey, ...rest } = options;
-            prefix = prefix ?? 'default';
+            const { calculateKey, ...rest } = options;
+            const prefix = options.prefix ?? "default";
             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": "6.0.0",
   "private": false,
   "main": "dist/index.js",
   "types": "dist/index.d.ts",