@tsed/platform-cache 8.0.0 → 8.0.2

package/src/interceptors/PlatformCacheInterceptor.ts

@@ -0,0 +1,235 @@
+import {isClass, isString, nameOf} from "@tsed/core";
+import {BaseContext, Constant, DIContext, Inject, Interceptor, InterceptorContext, InterceptorMethods, InterceptorNext} from "@tsed/di";
+import {deserialize, serialize} from "@tsed/json-mapper";
+import {Logger} from "@tsed/logger";
+import {IncomingMessage, ServerResponse} from "http";
+
+import {PlatformCachedObject} from "../interfaces/PlatformCachedObject.js";
+import {PlatformCacheOptions} from "../interfaces/PlatformCacheOptions.js";
+import {PlatformCache} from "../services/PlatformCache.js";
+import {getPrefix} from "../utils/getPrefix.js";
+import {isEndpoint} from "../utils/isEndpoint.js";
+const cleanHeaders = (headers: Record<string, unknown>, blacklist: string[]) => {
+  return Object.entries(headers)
+    .filter(([key]) => !blacklist.includes(key.toLowerCase()))
+    .reduce((headers, [key, value]) => {
+      return {
+        ...headers,
+        [key]: value
+      };
+    }, {});
+};
+
+/**
+ * @platform
+ */
+@Interceptor()
+export class PlatformCacheInterceptor implements InterceptorMethods {
+  @Inject()
+  protected cache: PlatformCache;
+
+  @Inject()
+  protected logger: Logger;
+
+  @Constant("cache.prefix", "")
+  protected prefix: string;
+
+  @Constant("cache.ignoreHeaders", ["content-length", "x-request-id", "cache-control", "vary", "content-encoding"])
+  protected blacklist: string[];
+
+  intercept(context: InterceptorContext<any, PlatformCacheOptions>, next: InterceptorNext) {
+    if (this.cache.disabled()) {
+      return next();
+    }
+
+    if (!isEndpoint(context.target, context.propertyKey)) {
+      return this.cacheMethod(context, next);
+    }
+
+    return this.cacheResponse(context, next);
+  }
+
+  async canRefreshInBackground(
+    key: string,
+    {
+      refreshThreshold,
+      ttl
+    }: {
+      refreshThreshold?: number;
+      ttl: any;
+    },
+    next: Function
+  ) {
+    const inQueue = await this.hasKeyInQueue(key);
+
+    if (refreshThreshold && !inQueue) {
+      await this.addKeyToQueue(key);
+
+      const currentTTL = await this.cache.ttl(key);
+      const calculatedTTL = this.cache.calculateTTL(currentTTL, ttl);
+
+      if (currentTTL === undefined || currentTTL < calculatedTTL - refreshThreshold) {
+        await next();
+      }
+
+      await this.deleteKeyFromQueue(key);
+    }
+  }
+
+  async cacheMethod(context: InterceptorContext<any, PlatformCacheOptions>, next: InterceptorNext) {
+    const {key, type, ttl, collectionType, refreshThreshold, args, canCache} = this.getOptions(context);
+
+    const set = (result: any) => {
+      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});
+      }
+    };
+
+    const cachedObject = await this.cache.getCachedObject(key);
+
+    if (!cachedObject || this.cache.isForceRefresh()) {
+      const result = await next();
+
+      if (!(!cachedObject && this.cache.isForceRefresh())) {
+        set(result);
+      }
+
+      return result;
+    }
+
+    this.canRefreshInBackground(key, {refreshThreshold, ttl}, async () => {
+      const result = await next();
+
+      await set(result);
+    }).catch((er) =>
+      this.logger.error({
+        event: "CACHE_ERROR",
+        method: "cacheMethod",
+        concerned_key: key,
+        class_name: nameOf(context.target),
+        property_key: context.propertyKey,
+        error_description: er.message,
+        stack: er.stack
+      })
+    );
+
+    const {data} = cachedObject;
+
+    return deserialize(JSON.parse(data), {collectionType, type});
+  }
+
+  async cacheResponse(context: InterceptorContext<any, PlatformCacheOptions>, next: InterceptorNext) {
+    const {request, response} = context.args[context.args.length - 1];
+
+    if (request.method !== "GET") {
+      return next();
+    }
+
+    const {key, ttl, args, $ctx} = this.getOptions(context);
+
+    const cachedObject = await this.cache.getCachedObject(key);
+
+    if (cachedObject && !(request.get("cache-control") === "no-cache")) {
+      return this.sendResponse(cachedObject, $ctx);
+    }
+
+    const result = await next();
+
+    const calculatedTTL = this.cache.calculateTTL(result, ttl);
+
+    $ctx.response.setHeaders({
+      "cache-control": `max-age=${calculatedTTL}`
+    });
+
+    // cache final response with his headers and body
+    response.onEnd(() => {
+      this.cache.setCachedObject(key, response.getBody(), {
+        ttl: calculatedTTL,
+        args,
+        headers: cleanHeaders(response.getHeaders(), this.blacklist)
+      });
+    });
+
+    return result;
+  }
+
+  protected getArgs(context: InterceptorContext<unknown, PlatformCacheOptions>) {
+    return context.args.reduce((args, arg) => {
+      if (arg instanceof DIContext || arg instanceof IncomingMessage || arg instanceof ServerResponse) {
+        return args;
+      }
+
+      if (isClass(arg)) {
+        return args.concat(serialize(arg));
+      }
+
+      return args.concat(arg);
+    }, []);
+  }
+
+  protected getOptions(context: InterceptorContext<any, PlatformCacheOptions>) {
+    const $ctx = context.args[context.args.length - 1];
+
+    const {ttl, type, collectionType, key: k = this.cache.defaultKeyResolver(), refreshThreshold} = context.options || {};
+
+    let {canCache} = context.options || {};
+
+    const args = this.getArgs(context);
+    const keyArgs = isString(k) ? k : k(args, $ctx);
+
+    if (canCache && canCache === "no-nullish") {
+      canCache = (item: any) => ![null, undefined].includes(item);
+    }
+
+    return {
+      key: [...[this.prefix, ...getPrefix(context.target, context.propertyKey)].filter(Boolean), keyArgs].join(":"),
+      refreshThreshold,
+      ttl,
+      type,
+      args,
+      collectionType,
+      keyArgs,
+      canCache,
+      $ctx
+    };
+  }
+
+  protected async hasKeyInQueue(key: string) {
+    return !!(await this.cache.get(`$$queue:${key}`));
+  }
+
+  protected async addKeyToQueue(key: string) {
+    await this.cache.set(`$$queue:${key}`, true, {ttl: 120});
+  }
+
+  protected async deleteKeyFromQueue(key: string) {
+    await this.cache.del(`$$queue:${key}`);
+  }
+
+  protected sendResponse(cachedObject: PlatformCachedObject, $ctx: BaseContext) {
+    const {headers, ttl} = cachedObject;
+    const {request, response} = $ctx;
+
+    const requestEtag = request.get("if-none-match");
+
+    if (requestEtag && headers.etag === requestEtag) {
+      response.status(304).setHeaders(headers).body(undefined);
+
+      return undefined;
+    }
+
+    const data = JSON.parse(cachedObject.data);
+
+    $ctx.response
+      .setHeaders({
+        ...headers,
+        "x-cached": "true",
+        "cache-control": `max-age=${ttl}`
+      })
+      .body(data);
+
+    return data;
+  }
+}

package/src/interfaces/PlatformCacheOptions.ts

@@ -0,0 +1,27 @@
+import {MetadataTypes} from "@tsed/core";
+import {BaseContext} from "@tsed/di";
+
+import type {Ttl} from "../services/PlatformCache.js";
+
+export interface PlatformCacheOptions extends MetadataTypes {
+  /**
+   * key expiration ttl in seconds.
+   */
+  ttl?: Ttl;
+  /**
+   * By default, the key is generated from the method name and the arguments passed to the method.
+   */
+  prefix?: string;
+  /**
+   * Algorithm used to generate the key. By default, the key is generated from the method name and the arguments passed to the method.
+   */
+  key?: string | ((args: any[], ctx?: BaseContext) => string);
+  /**
+   * threshold to refresh the cache.
+   */
+  refreshThreshold?: number;
+  /**
+   * The function determine if the result must be cached or not.
+   */
+  canCache?: ((item: any) => boolean) | "no-nullish";
+}

package/src/interfaces/PlatformCachedObject.ts

@@ -0,0 +1,7 @@
+export interface PlatformCachedObject {
+  ttl: number;
+  args: any[];
+  data: any;
+  expires: number;
+  headers: Record<string, number | string | string[]>;
+}

package/src/interfaces/interfaces.ts

@@ -0,0 +1,34 @@
+import type {BaseContext} from "@tsed/di";
+import type {Cache, CachingConfig, Store} from "cache-manager";
+import type {FactoryStore} from "cache-manager/dist/caching.js";
+
+import type {CacheManager} from "../services/PlatformCache.js";
+
+export type PlatformCacheSettings<Config extends Record<string, any> = any, S extends Store = any> = CachingConfig<Config> & {
+  caches?: Cache[];
+  store?: "memory" | Store | FactoryStore<S, Config>;
+  max?: number;
+  keyResolver?: (args: any[], ctx: BaseContext) => string;
+  prefix?: string;
+  /**
+   * List of headers to ignore when caching the response. Default: ["content-length", "x-request-id", "cache-control", "vary", "content-encoding"]
+   */
+  ignoreHeaders?: string[];
+  /**
+   * You may pass in any other arguments these will be passed on to the `create` method of your store,
+   * otherwise they will be ignored.
+   */
+  [key: string]: any;
+};
+
+declare global {
+  namespace TsED {
+    interface Configuration {
+      cache?: PlatformCacheSettings | false;
+    }
+  }
+}
+
+export interface OnCreateCacheManager {
+  $onCreateCacheManager(cache: CacheManager): void | Promise<void>;
+}

package/src/services/PlatformCache.spec.ts

@@ -0,0 +1,363 @@
+import {PlatformTest} from "@tsed/platform-http/testing";
+import {caching as cacheManager, multiCaching} from "cache-manager";
+
+import {UseCache} from "../decorators/useCache.js";
+import {getPrefix} from "../utils/getPrefix.js";
+import {PlatformCache} from "./PlatformCache.js";
+
+function createCacheFixture() {
+  const map = new Map();
+  return {
+    get: vi.fn().mockImplementation((key) => {
+      return Promise.resolve(map.get(key));
+    }),
+    set: vi.fn().mockImplementation((key, value) => {
+      return Promise.resolve(map.set(key, value));
+    }),
+    wrap: vi.fn().mockImplementation((key, fn) => {
+      return fn();
+    }),
+    reset: vi.fn().mockImplementation(() => {
+      map.clear();
+    }),
+    del: vi.fn().mockImplementation((key) => {
+      map.delete(key);
+    }),
+
+    store: {
+      keys: vi.fn().mockImplementation(() => {
+        return [...map.keys()];
+      }),
+      ttl: vi.fn()
+    }
+  };
+}
+
+vi.mock("cache-manager");
+
+describe("PlatformCache", () => {
+  describe("with legacy single cache", () => {
+    let caching: ReturnType<typeof createCacheFixture>;
+
+    beforeEach(async () => {
+      caching = createCacheFixture();
+
+      vi.mocked(cacheManager).mockReturnValue(caching as any);
+
+      await PlatformTest.create({
+        cache: {
+          store: {create: () => caching},
+          ttl: 300
+        }
+      });
+    });
+
+    afterEach(() => {
+      return PlatformTest.reset();
+    });
+
+    it("should create single cache", async () => {
+      const cacheManager = PlatformTest.get<PlatformCache>(PlatformCache);
+
+      expect(cacheManager.disabled()).toEqual(false);
+
+      await cacheManager.set("key", "value");
+      await cacheManager.set("key2", "value2");
+      expect(await cacheManager.get("key")).toBe("value");
+      expect(await cacheManager.get("key2")).toBe("value2");
+
+      await cacheManager.del("key2");
+
+      expect(await cacheManager.get("key2")).toBeUndefined();
+
+      await cacheManager.reset();
+
+      expect(await cacheManager.get("key")).toBeUndefined();
+
+      const result = await cacheManager.wrap("key", () => {
+        return Promise.resolve("valuePromised");
+      });
+
+      expect(result).toBe("valuePromised");
+    });
+  });
+  describe("with single cache", () => {
+    let caching: ReturnType<typeof createCacheFixture>;
+
+    beforeEach(async () => {
+      caching = createCacheFixture();
+
+      vi.mocked(cacheManager).mockReturnValue(caching as any);
+
+      await PlatformTest.create({
+        cache: {
+          store: "memory",
+          ttl: 300
+        }
+      });
+    });
+
+    afterEach(() => {
+      return PlatformTest.reset();
+    });
+
+    it("should create single cache", async () => {
+      const cacheManager = PlatformTest.get<PlatformCache>(PlatformCache);
+
+      expect(cacheManager.disabled()).toEqual(false);
+
+      await cacheManager.set("key", "value");
+      await cacheManager.set("key2", "value2");
+      expect(await cacheManager.get("key")).toBe("value");
+      expect(await cacheManager.get("key2")).toBe("value2");
+
+      await cacheManager.del("key2");
+
+      expect(await cacheManager.get("key2")).toBeUndefined();
+
+      await cacheManager.reset();
+
+      expect(await cacheManager.get("key")).toBeUndefined();
+
+      const result = await cacheManager.wrap("key", () => {
+        return Promise.resolve("valuePromised");
+      });
+
+      expect(result).toBe("valuePromised");
+    });
+
+    it("should return the calculated calculateTTL", () => {
+      const cacheManager = PlatformTest.get<PlatformCache>(PlatformCache);
+
+      expect(cacheManager.calculateTTL({}, 400)).toBe(400);
+      expect(cacheManager.calculateTTL({}, () => 200)).toBe(200);
+      expect(cacheManager.calculateTTL({})).toBe(300);
+      expect(cacheManager.calculateTTL()).toBe(300);
+    });
+
+    it("should get matching keys", async () => {
+      const cacheManager = PlatformTest.get<PlatformCache>(PlatformCache);
+
+      await cacheManager.set("key", "value");
+      await cacheManager.set("key2", "value2");
+
+      const keys1 = await cacheManager.getMatchingKeys("key*");
+      const keys2 = await cacheManager.getMatchingKeys("key2");
+
+      expect(keys1).toEqual(["key", "key2"]);
+      expect(keys2).toEqual(["key2"]);
+    });
+    it("should get keys of a given class/method", async () => {
+      const cacheManager = PlatformTest.get<PlatformCache>(PlatformCache);
+
+      class Test {
+        @UseCache({
+          prefix: "TEST"
+        })
+        async test() {}
+      }
+
+      const prefix = getPrefix(Test, "test");
+
+      await cacheManager.set(prefix + ":arg", "value");
+      await cacheManager.set(prefix + ":arg2", "value2");
+
+      const keys = await cacheManager.getKeysOf(Test, "test");
+
+      expect(keys).toEqual(["TEST:arg", "TEST:arg2"]);
+    });
+
+    it("should delete matching keys (native)", async () => {
+      const cacheManager = PlatformTest.get<PlatformCache>(PlatformCache);
+
+      await cacheManager.set("key", "value");
+      await cacheManager.set("key2", "value2");
+
+      const keys1 = await cacheManager.keys("key*");
+      const keys2 = await cacheManager.deleteKeys("key*");
+
+      expect(keys1).toEqual(["key", "key2"]);
+      expect(keys2).toEqual(["key", "key2"]);
+    });
+
+    it("should delete matching keys", async () => {
+      const cacheManager = PlatformTest.get<PlatformCache>(PlatformCache);
+
+      await cacheManager.set("key", "value");
+      await cacheManager.set("key2", "value2");
+
+      const keys1 = await cacheManager.getMatchingKeys("key*");
+      const keys2 = await cacheManager.deleteMatchingKeys("key*");
+
+      expect(keys1).toEqual(["key", "key2"]);
+      expect(keys2).toEqual(["key", "key2"]);
+    });
+
+    describe("defaultKeyResolver()", () => {
+      it("return the default key resolver from settings", () => {
+        const cacheManager = PlatformTest.get<PlatformCache>(PlatformCache);
+        const keyResolver = cacheManager.defaultKeyResolver();
+
+        const value = keyResolver(["test"], {});
+        expect(value).toEqual("test");
+
+        const value2 = keyResolver([{test: "test"}], {});
+        expect(value2).toEqual('{"test":"test"}');
+      });
+    });
+
+    describe("ttl()", () => {
+      it("return calculateTTL of the given key", async () => {
+        const cacheManager: any = PlatformTest.get<PlatformCache>(PlatformCache);
+
+        cacheManager.cache.store.ttl.mockReturnValue(10);
+
+        const result = await cacheManager.ttl("test");
+        expect(result).toEqual(10);
+      });
+
+      it("return undefined when store isn't defined", async () => {
+        const cacheManager: any = PlatformTest.get<PlatformCache>(PlatformCache);
+
+        delete cacheManager.cache.store.ttl;
+
+        const result = await cacheManager.ttl("test");
+        expect(result).toEqual(undefined);
+      });
+    });
+    describe("getCachedObject()", () => {
+      it("should get key from cache", async () => {
+        const cacheManager = PlatformTest.get<PlatformCache>(PlatformCache);
+
+        await cacheManager.setCachedObject("key", {data: "data"}, {ttl: 10});
+        const result = await cacheManager.getCachedObject("key");
+
+        expect(result).toEqual({
+          data: '{"data":"data"}',
+          ttl: 10
+        });
+      });
+      it("should catch and log error", async () => {
+        const cacheManager: any = PlatformTest.get<PlatformCache>(PlatformCache);
+
+        vi.spyOn(cacheManager, "get").mockRejectedValue(new Error("message"));
+        vi.spyOn(cacheManager.logger, "error");
+
+        await cacheManager.getCachedObject("key");
+
+        expect(cacheManager.get).toHaveBeenCalledWith("key");
+        expect(cacheManager.logger.error).toHaveBeenCalledWith({
+          error: new Error("message"),
+          event: "CACHE_ERROR",
+          method: "getCachedObject"
+        });
+      });
+    });
+    describe("setCachedObject()", () => {
+      it("should catch and log error", async () => {
+        const cacheManager: any = PlatformTest.get<PlatformCache>(PlatformCache);
+
+        vi.spyOn(cacheManager, "set").mockRejectedValue(new Error("message"));
+        vi.spyOn(cacheManager.logger, "error");
+
+        await cacheManager.setCachedObject("key", {data: "data"}, {ttl: 10});
+
+        expect(cacheManager.set).toHaveBeenCalledWith("key", {data: '{"data":"data"}', ttl: 10}, {ttl: 10});
+        expect(cacheManager.logger.error).toHaveBeenCalledWith({
+          error: new Error("message"),
+          event: "CACHE_ERROR",
+          method: "setCachedObject"
+        });
+      });
+    });
+    describe("refresh()", () => {
+      it("should set the call context with forceRefresh to true", async () => {
+        const cacheManager = PlatformTest.get<PlatformCache>(PlatformCache);
+
+        expect(cacheManager.isForceRefresh()).toEqual(false);
+
+        await cacheManager.refresh(() => {
+          expect(cacheManager.isForceRefresh()).toEqual(true);
+        });
+
+        expect(cacheManager.isForceRefresh()).toEqual(false);
+      });
+    });
+  });
+  describe("with multiple cache", () => {
+    let caching: ReturnType<typeof createCacheFixture>;
+    beforeEach(() => {
+      caching = createCacheFixture();
+
+      vi.mocked(multiCaching).mockReturnValue(caching as any);
+
+      return PlatformTest.create({
+        cache: {
+          caches: [{}, {}] as any[],
+          ttl: 300
+        }
+      });
+    });
+    afterEach(() => {
+      return PlatformTest.reset();
+    });
+
+    it("should create multiple cache", async () => {
+      const cacheManager = PlatformTest.get<PlatformCache>(PlatformCache);
+
+      await cacheManager.set("key", "value");
+      await cacheManager.set("key2", "value2");
+      expect(await cacheManager.get("key")).toBe("value");
+      expect(await cacheManager.get("key2")).toBe("value2");
+      expect(await cacheManager.keys()).toEqual(["key", "key2"]);
+
+      await cacheManager.del("key2");
+
+      expect(await cacheManager.get("key2")).toBeUndefined();
+
+      await cacheManager.reset();
+
+      expect(await cacheManager.get("key")).toBeUndefined();
+
+      const result = await cacheManager.wrap("key", () => {
+        return Promise.resolve("valuePromised");
+      });
+
+      expect(result).toBe("valuePromised");
+    });
+  });
+  describe("with disabled cache", () => {
+    beforeEach(() =>
+      PlatformTest.create({
+        cache: false
+      })
+    );
+    afterEach(() => PlatformTest.reset());
+
+    it("should mock methods", async () => {
+      const cacheManager = PlatformTest.get<PlatformCache>(PlatformCache);
+
+      expect(cacheManager.disabled()).toEqual(true);
+
+      await cacheManager.set("key", "value");
+      await cacheManager.set("key2", "value2");
+      expect(await cacheManager.get("key")).toBeUndefined();
+      expect(await cacheManager.get("key2")).toBeUndefined();
+
+      await cacheManager.del("key2");
+
+      expect(await cacheManager.get("key2")).toBeUndefined();
+
+      await cacheManager.reset();
+
+      expect(await cacheManager.get("key")).toBeUndefined();
+      expect(await cacheManager.keys()).toEqual([]);
+
+      const result = await cacheManager.wrap("key", () => {
+        return Promise.resolve("valuePromised");
+      });
+
+      expect(result).toBe("valuePromised");
+    });
+  });
+});