@tsed/platform-cache 8.25.2 → 8.25.4

package/lib/esm/interceptors/PlatformCacheInterceptor.js

@@ -1,9 +1,7 @@
-import { __decorate, __metadata } from "tslib";
 import { IncomingMessage, ServerResponse } from "node:http";
 import { isClass, isString, nameOf } from "@tsed/core";
-import { Constant, context, DIContext, Inject, Interceptor, runInContext } from "@tsed/di";
+import { constant, context, DIContext, inject, interceptor, logger, runInContext } from "@tsed/di";
 import { deserialize, serialize } from "@tsed/json-mapper";
-import { Logger } from "@tsed/logger";
 import { PlatformCache } from "../services/PlatformCache.js";
 import { getPrefix } from "../utils/getPrefix.js";
 import { isEndpoint } from "../utils/isEndpoint.js";
@@ -20,7 +18,19 @@ const cleanHeaders = (headers, blacklist) => {
 /**
  * @platform
  */
-let PlatformCacheInterceptor = class PlatformCacheInterceptor {
+export class PlatformCacheInterceptor {
+    constructor() {
+        this.cache = inject(PlatformCache);
+        this.prefix = constant("cache.prefix", "");
+        this.blacklist = constant("cache.ignoreHeaders", [
+            "content-length",
+            "x-request-id",
+            "cache-control",
+            "vary",
+            "content-encoding"
+        ]);
+    }
+    static #refreshLocks = new Map();
     intercept(context, next) {
         if (this.cache.disabled()) {
             return next();
@@ -30,14 +40,24 @@ let PlatformCacheInterceptor = class PlatformCacheInterceptor {
         }
         return this.cacheResponse(context, next);
     }
-    async canRefreshInBackground(key, { refreshThreshold, ttl }, next, $ctx) {
-        const inQueue = await this.hasKeyInQueue(key);
-        if (refreshThreshold && !inQueue) {
+    async canRefreshInBackground(key, { refreshThreshold, ttl, cachedTTL }, next, $ctx) {
+        if (!refreshThreshold) {
+            return;
+        }
+        const release = await this.acquireRefreshLock(key);
+        try {
+            const inQueue = await this.hasKeyInQueue(key);
+            const inCooldown = await this.hasRefreshCooldown(key);
+            if (inQueue || inCooldown) {
+                return;
+            }
             await this.addKeyToQueue(key);
             const currentTTL = await this.cache.ttl(key);
-            const calculatedTTL = this.cache.calculateTTL(currentTTL, ttl);
+            const calculatedTTL = cachedTTL ?? (typeof ttl === "number" ? ttl : undefined);
+            const refreshThresholdWithJitter = this.getRefreshThresholdWithJitter(key, refreshThreshold);
             try {
-                if (currentTTL === undefined || currentTTL < calculatedTTL - refreshThreshold) {
+                if (calculatedTTL !== undefined && (currentTTL === undefined || currentTTL < calculatedTTL - refreshThresholdWithJitter)) {
+                    await this.addRefreshCooldown(key, refreshThresholdWithJitter);
                     if ($ctx) {
                         await runInContext($ctx, () => next());
                     }
@@ -50,6 +70,9 @@ let PlatformCacheInterceptor = class PlatformCacheInterceptor {
                 await this.deleteKeyFromQueue(key);
             }
         }
+        finally {
+            release();
+        }
     }
     async cacheMethod(context, next) {
         const { key, type, ttl, collectionType, refreshThreshold, args, canCache, $ctx, byPass } = this.getOptions(context, false);
@@ -60,7 +83,7 @@ let PlatformCacheInterceptor = class PlatformCacheInterceptor {
             if (!canCache || (canCache && canCache(result))) {
                 const calculatedTTL = this.cache.calculateTTL(result, ttl);
                 const data = serialize(result, { type, collectionType });
-                this.cache.setCachedObject(key, data, { args, ttl: calculatedTTL });
+                this.cache.setCachedObject(key, data, { args, ...(calculatedTTL !== undefined && { ttl: calculatedTTL }) });
             }
         };
         const cachedObject = await this.cache.getCachedObject(key);
@@ -71,10 +94,10 @@ let PlatformCacheInterceptor = class PlatformCacheInterceptor {
             }
             return result;
         }
-        this.canRefreshInBackground(key, { refreshThreshold, ttl }, async () => {
+        this.canRefreshInBackground(key, { refreshThreshold, ttl, cachedTTL: cachedObject.ttl }, async () => {
             const result = await next();
             await set(result);
-        }, $ctx).catch((er) => this.logger.error({
+        }, $ctx).catch((er) => logger().error({
             event: "CACHE_ERROR",
             method: "cacheMethod",
             concerned_key: key,
@@ -102,17 +125,19 @@ let PlatformCacheInterceptor = class PlatformCacheInterceptor {
         }
         const result = await next();
         const calculatedTTL = this.cache.calculateTTL(result, ttl);
-        currentCtx.response?.setHeaders({
-            "cache-control": `max-age=${calculatedTTL}`
-        });
+        if (calculatedTTL !== undefined) {
+            currentCtx.response?.setHeaders({
+                "cache-control": `max-age=${calculatedTTL}`
+            });
+        }
         currentCtx.response?.onEnd(() => {
             if (!useCache) {
                 return;
             }
             this.cache.setCachedObject(key, currentCtx.response.getBody(), {
-                ttl: calculatedTTL,
                 args,
-                headers: cleanHeaders(currentCtx.response.getHeaders(), this.blacklist)
+                headers: cleanHeaders(currentCtx.response.getHeaders(), this.blacklist),
+                ...(calculatedTTL !== undefined && { ttl: calculatedTTL })
             });
         });
         return result;
@@ -177,6 +202,41 @@ let PlatformCacheInterceptor = class PlatformCacheInterceptor {
     async deleteKeyFromQueue(key) {
         await this.cache.del(`$$queue:${key}`);
     }
+    async acquireRefreshLock(key) {
+        for (;;) {
+            const lock = PlatformCacheInterceptor.#refreshLocks.get(key);
+            if (!lock) {
+                let releaseFn;
+                const currentLock = new Promise((resolve) => {
+                    releaseFn = resolve;
+                });
+                PlatformCacheInterceptor.#refreshLocks.set(key, currentLock);
+                return () => {
+                    if (PlatformCacheInterceptor.#refreshLocks.get(key) === currentLock) {
+                        PlatformCacheInterceptor.#refreshLocks.delete(key);
+                    }
+                    releaseFn?.();
+                };
+            }
+            await lock;
+        }
+    }
+    getRefreshCooldownKey(key) {
+        return `$$refresh-cooldown:${key}`;
+    }
+    getRefreshThresholdWithJitter(key, refreshThreshold) {
+        const maxJitter = Math.max(1, Math.floor(refreshThreshold * 0.1));
+        const hash = key.split("").reduce((acc, char) => (acc * 31 + char.charCodeAt(0)) | 0, 0);
+        const jitter = Math.abs(hash) % (maxJitter + 1);
+        return Math.max(1, refreshThreshold - jitter);
+    }
+    async hasRefreshCooldown(key) {
+        return !!(await this.cache.get(this.getRefreshCooldownKey(key)));
+    }
+    async addRefreshCooldown(key, refreshThreshold) {
+        const cooldownTTL = Math.max(1, Math.floor(refreshThreshold / 2));
+        await this.cache.set(this.getRefreshCooldownKey(key), true, { ttl: cooldownTTL });
+    }
     sendResponse(cachedObject) {
         const { headers, ttl } = cachedObject;
         const $ctx = context();
@@ -191,31 +251,12 @@ let PlatformCacheInterceptor = class PlatformCacheInterceptor {
                 .setHeaders({
                 ...headers,
                 "x-cached": "true",
-                "cache-control": `max-age=${ttl}`
+                ...(ttl !== undefined && { "cache-control": `max-age=${ttl}` })
             })
                 .body(data);
             return cachedObject.data;
         }
         return cachedObject.data;
     }
-};
-__decorate([
-    Inject(),
-    __metadata("design:type", PlatformCache)
-], PlatformCacheInterceptor.prototype, "cache", void 0);
-__decorate([
-    Inject(),
-    __metadata("design:type", Logger)
-], PlatformCacheInterceptor.prototype, "logger", void 0);
-__decorate([
-    Constant("cache.prefix", ""),
-    __metadata("design:type", String)
-], PlatformCacheInterceptor.prototype, "prefix", void 0);
-__decorate([
-    Constant("cache.ignoreHeaders", ["content-length", "x-request-id", "cache-control", "vary", "content-encoding"]),
-    __metadata("design:type", Array)
-], PlatformCacheInterceptor.prototype, "blacklist", void 0);
-PlatformCacheInterceptor = __decorate([
-    Interceptor()
-], PlatformCacheInterceptor);
-export { PlatformCacheInterceptor };
+}
+interceptor(PlatformCacheInterceptor);

package/lib/esm/services/PlatformCache.js

@@ -1,9 +1,8 @@
-import { __decorate, __metadata } from "tslib";
 import { AsyncLocalStorage } from "node:async_hooks";
 import { isClass, isFunction, isString } from "@tsed/core";
-import { Configuration, Inject, InjectorService, Module } from "@tsed/di";
+import { constant, injectable, logger, ProviderScope, ProviderType } from "@tsed/di";
+import { $asyncEmit } from "@tsed/hooks";
 import { deserialize, serialize } from "@tsed/json-mapper";
-import { Logger } from "@tsed/logger";
 import { getPrefix } from "../utils/getPrefix.js";
 const defaultKeyResolver = (args) => {
     return args.map((arg) => (isClass(arg) ? JSON.stringify(serialize(arg)) : arg)).join(":");
@@ -12,16 +11,16 @@ const storage = new AsyncLocalStorage();
 /**
  * @platform
  */
-let PlatformCache = class PlatformCache {
+export class PlatformCache {
     #cache;
     get cache() {
         return this.#cache;
     }
     async $onInit() {
-        const settings = this.settings.get("cache");
+        const settings = constant("cache");
         if (settings) {
             this.#cache = await this.createCacheManager(settings);
-            await this.injector.emit("$onCreateCacheManager", this.#cache);
+            await $asyncEmit("$onCreateCacheManager", [this.#cache]);
         }
     }
     getKeysOf(target, propertyKey) {
@@ -29,13 +28,13 @@ let PlatformCache = class PlatformCache {
         return this.keys(`${prefix.join(":")}:*`);
     }
     disabled() {
-        return !this.settings.get("cache");
+        return !constant("cache");
     }
     defaultKeyResolver() {
-        return this.settings.get("cache.keyResolver", defaultKeyResolver);
+        return constant("cache.keyResolver", defaultKeyResolver);
     }
     defaultTtl() {
-        return this.settings.get("cache.ttl");
+        return constant("cache.ttl");
     }
     calculateTTL(result, currentTtl) {
         const ttl = currentTtl === undefined ? this.defaultTtl() : currentTtl;
@@ -65,7 +64,7 @@ let PlatformCache = class PlatformCache {
             return await this.get(key);
         }
         catch (er) {
-            this.logger.error({
+            logger().error({
                 event: "CACHE_ERROR",
                 method: "getCachedObject",
                 error: er
@@ -74,15 +73,15 @@ let PlatformCache = class PlatformCache {
     }
     async setCachedObject(key, data, opts) {
         try {
+            const { ttl, ...rest } = opts;
             await this.set(key, {
-                ...opts,
+                ...rest,
+                ...(ttl !== undefined && { ttl }),
                 data: JSON.stringify(data)
-            }, {
-                ttl: opts.ttl
-            });
+            }, ttl !== undefined ? { ttl } : undefined);
         }
         catch (er) {
-            this.logger.error({
+            logger().error({
                 event: "CACHE_ERROR",
                 method: "setCachedObject",
                 error: er
@@ -142,20 +141,5 @@ let PlatformCache = class PlatformCache {
         }
         return store;
     }
-};
-__decorate([
-    Configuration(),
-    __metadata("design:type", Object)
-], PlatformCache.prototype, "settings", void 0);
-__decorate([
-    Inject(),
-    __metadata("design:type", InjectorService)
-], PlatformCache.prototype, "injector", void 0);
-__decorate([
-    Inject(),
-    __metadata("design:type", Logger)
-], PlatformCache.prototype, "logger", void 0);
-PlatformCache = __decorate([
-    Module()
-], PlatformCache);
-export { PlatformCache };
+}
+injectable(PlatformCache).type(ProviderType.MODULE).scope(ProviderScope.SINGLETON);

package/lib/types/interceptors/PlatformCacheInterceptor.d.ts

@@ -1,5 +1,4 @@
 import { type BaseContext, DIContext, InterceptorContext, InterceptorMethods, InterceptorNext } from "@tsed/di";
-import { Logger } from "@tsed/logger";
 import { PlatformCachedObject } from "../interfaces/PlatformCachedObject.js";
 import { PlatformCacheOptions } from "../interfaces/PlatformCacheOptions.js";
 import { PlatformCache } from "../services/PlatformCache.js";
@@ -23,14 +22,15 @@ type Context = DIContext & {
  * @platform
  */
 export declare class PlatformCacheInterceptor implements InterceptorMethods {
+    #private;
     protected cache: PlatformCache;
-    protected logger: Logger;
     protected prefix: string;
     protected blacklist: string[];
     intercept(context: InterceptorContext<any, PlatformCacheOptions>, next: InterceptorNext): unknown;
-    canRefreshInBackground(key: string, { refreshThreshold, ttl }: {
+    canRefreshInBackground(key: string, { refreshThreshold, ttl, cachedTTL }: {
         refreshThreshold?: number;
         ttl: any;
+        cachedTTL?: number;
     }, next: Function, $ctx?: Context): Promise<void>;
     cacheMethod(context: InterceptorContext<any, PlatformCacheOptions>, next: InterceptorNext): Promise<any>;
     cacheResponse(interceptorContext: InterceptorContext<any, PlatformCacheOptions>, next: InterceptorNext): Promise<any>;
@@ -54,6 +54,11 @@ export declare class PlatformCacheInterceptor implements InterceptorMethods {
     protected hasKeyInQueue(key: string): Promise<boolean>;
     protected addKeyToQueue(key: string): Promise<void>;
     protected deleteKeyFromQueue(key: string): Promise<void>;
+    protected acquireRefreshLock(key: string): Promise<() => void>;
+    protected getRefreshCooldownKey(key: string): string;
+    protected getRefreshThresholdWithJitter(key: string, refreshThreshold: number): number;
+    protected hasRefreshCooldown(key: string): Promise<boolean>;
+    protected addRefreshCooldown(key: string, refreshThreshold: number): Promise<void>;
     protected sendResponse(cachedObject: PlatformCachedObject): any;
 }
 export {};

package/lib/types/interfaces/PlatformCachedObject.d.ts

@@ -1,5 +1,5 @@
 export interface PlatformCachedObject {
-    ttl: number;
+    ttl?: number;
     args: any[];
     data: any;
     expires: number;

package/lib/types/services/PlatformCache.d.ts

@@ -1,7 +1,5 @@
 import { Type } from "@tsed/core";
-import { Configuration, InjectorService } from "@tsed/di";
 import { JsonDeserializerOptions } from "@tsed/json-mapper";
-import { Logger } from "@tsed/logger";
 import type { Cache, CachingConfig, MultiCache } from "cache-manager";
 import { PlatformCacheSettings } from "../interfaces/interfaces.js";
 import { PlatformCachedObject } from "../interfaces/PlatformCachedObject.js";
@@ -12,23 +10,20 @@ export type Ttl = number | ((result: any) => number);
  */
 export declare class PlatformCache {
     #private;
-    protected settings: Configuration;
-    protected injector: InjectorService;
-    protected logger: Logger;
     get cache(): CacheManager | undefined;
     $onInit(): Promise<void>;
     getKeysOf(target: Type<any>, propertyKey: string | symbol): Promise<string[]>;
     disabled(): boolean;
     defaultKeyResolver(): (args: any[], ctx?: any) => string;
-    defaultTtl(): Ttl;
-    calculateTTL(result?: any, currentTtl?: Ttl): number;
+    defaultTtl(): Ttl | undefined;
+    calculateTTL(result?: any, currentTtl?: Ttl): number | undefined;
     ttl(key: string): Promise<void> | Promise<number>;
     wrap<T>(key: string, fetch: () => Promise<T>, ttl?: number): Promise<T>;
     get<T>(key: string, options?: JsonDeserializerOptions): Promise<T | undefined>;
     set<T>(key: string, value: any, options?: CachingConfig<T>): Promise<T | undefined>;
     getCachedObject(key: string): Promise<PlatformCachedObject | undefined>;
     setCachedObject(key: string, data: any, opts: {
-        ttl: number;
+        ttl?: number;
     } & Record<string, any>): Promise<void>;
     del(key: string): Promise<void>;
     reset(): Promise<void>;

package/package.json

@@ -2,7 +2,7 @@
   "name": "@tsed/platform-cache",
   "description": "Platform cache module for Ts.ED Framework",
   "type": "module",
-  "version": "8.25.2",
+  "version": "8.25.4",
   "source": "./src/index.ts",
   "main": "./lib/esm/index.js",
   "module": "./lib/esm/index.js",
@@ -28,12 +28,12 @@
     "tslib": "2.7.0"
   },
   "devDependencies": {
-    "@tsed/barrels": "8.25.2",
-    "@tsed/core": "8.25.2",
-    "@tsed/di": "8.25.2",
-    "@tsed/json-mapper": "8.25.2",
-    "@tsed/schema": "8.25.2",
-    "@tsed/typescript": "8.25.2",
+    "@tsed/barrels": "8.25.4",
+    "@tsed/core": "8.25.4",
+    "@tsed/di": "8.25.4",
+    "@tsed/json-mapper": "8.25.4",
+    "@tsed/schema": "8.25.4",
+    "@tsed/typescript": "8.25.4",
     "@types/micromatch": "^4.0.9",
     "eslint": "9.12.0",
     "typescript": "5.9.3",