feat: price in memory caching

libs/pricing/src/pricing.module.ts

@@ -1,11 +1,19 @@
+import { CacheModule } from "@nestjs/cache-manager";
 import { Module } from "@nestjs/common";
 
 import { LoggerModule } from "@zkchainhub/shared";
+import { TOKEN_CACHE_TTL_IN_SEC } from "@zkchainhub/shared/constants/";
 
 import { CoingeckoService } from "./services";
 
 @Module({
-    imports: [LoggerModule],
+    imports: [
+        LoggerModule,
+        CacheModule.register({
+            store: "memory",
+            ttl: TOKEN_CACHE_TTL_IN_SEC,
+        }),
+    ],
     providers: [CoingeckoService],
     exports: [CoingeckoService],
 })

libs/pricing/src/services/coingecko.service.spec.ts

@@ -1,6 +1,8 @@
+import { createMock } from "@golevelup/ts-jest";
+import { Cache, CACHE_MANAGER } from "@nestjs/cache-manager";
 import { Logger } from "@nestjs/common";
 import { Test, TestingModule } from "@nestjs/testing";
-import { AxiosError, AxiosInstance } from "axios";
+import { AxiosInstance } from "axios";
 import MockAdapter from "axios-mock-adapter";
 import { WINSTON_MODULE_PROVIDER } from "nest-winston";
 
@@ -20,6 +22,7 @@ describe("CoingeckoService", () => {
     let service: CoingeckoService;
     let axios: AxiosInstance;
     let mockAxios: MockAdapter;
+    let cache: Cache;
     const apiKey = "COINGECKO_API_KEY";
     const apiBaseUrl = "https://api.coingecko.com/api/v3/";
 
@@ -29,21 +32,31 @@ describe("CoingeckoService", () => {
                 CoingeckoService,
                 {
                     provide: CoingeckoService,
-                    useFactory: (logger: Logger) => {
-                        return new CoingeckoService(apiKey, apiBaseUrl, logger);
+                    useFactory: (logger: Logger, cache: Cache) => {
+                        return new CoingeckoService(apiKey, apiBaseUrl, logger, cache);
                     },
-                    inject: [WINSTON_MODULE_PROVIDER],
+                    inject: [WINSTON_MODULE_PROVIDER, CACHE_MANAGER],
                 },
                 {
                     provide: WINSTON_MODULE_PROVIDER,
                     useValue: mockLogger,
                 },
+                {
+                    provide: CACHE_MANAGER,
+                    useValue: createMock<Cache>({
+                        store: createMock<Cache["store"]>({
+                            mget: jest.fn(),
+                            mset: jest.fn(),
+                        }),
+                    }),
+                },
             ],
         }).compile();
 
         service = module.get<CoingeckoService>(CoingeckoService);
         axios = service["axios"];
         mockAxios = new MockAdapter(axios);
+        cache = module.get<Cache>(CACHE_MANAGER);
     });
 
     afterEach(() => {
@@ -67,14 +80,15 @@ describe("CoingeckoService", () => {
     });
 
     describe("getTokenPrices", () => {
-        it("return token prices", async () => {
+        it("all token prices are fetched from Coingecko", async () => {
             const tokenIds = ["token1", "token2"];
             const currency = "usd";
             const expectedResponse: TokenPrices = {
                 token1: { usd: 1.23 },
                 token2: { usd: 4.56 },
             };
 
+            jest.spyOn(cache.store, "mget").mockResolvedValueOnce([null, null]);
             jest.spyOn(axios, "get").mockResolvedValueOnce({
                 data: expectedResponse,
             });
@@ -92,12 +106,18 @@ describe("CoingeckoService", () => {
                     precision: service["DECIMALS_PRECISION"].toString(),
                 },
             });
+            expect(cache.store.mget).toHaveBeenCalledWith("token1.usd", "token2.usd");
+            expect(cache.store.mset).toHaveBeenCalledWith([
+                ["token1.usd", 1.23],
+                ["token2.usd", 4.56],
+            ]);
         });
 
         it("throw ApiNotAvailable when Coingecko returns a 500 family exception", async () => {
             const tokenIds = ["token1", "token2"];
             const currency = "usd";
 
+            jest.spyOn(cache.store, "mget").mockResolvedValueOnce([null, null]);
             mockAxios.onGet().replyOnce(503, {
                 data: {},
                 status: 503,
@@ -113,6 +133,7 @@ describe("CoingeckoService", () => {
             const tokenIds = ["token1", "token2"];
             const currency = "usd";
 
+            jest.spyOn(cache.store, "mget").mockResolvedValueOnce([null, null]);
             mockAxios.onGet().replyOnce(429, {
                 data: {},
                 status: 429,
@@ -128,10 +149,7 @@ describe("CoingeckoService", () => {
             const tokenIds = ["invalidTokenId", "token2"];
             const currency = "usd";
 
-            jest.spyOn(axios, "get").mockRejectedValueOnce(
-                new AxiosError("Invalid token ID", "400"),
-            );
-
+            jest.spyOn(cache.store, "mget").mockResolvedValueOnce([null, null]);
             mockAxios.onGet().replyOnce(400, {
                 data: {
                     message: "Invalid token ID",

libs/pricing/src/services/coingecko.service.ts

@@ -1,3 +1,4 @@
+import { Cache, CACHE_MANAGER } from "@nestjs/cache-manager";
 import { Inject, Injectable, LoggerService } from "@nestjs/common";
 import axios, { AxiosInstance, isAxiosError } from "axios";
 import { WINSTON_MODULE_NEST_PROVIDER } from "nest-winston";
@@ -24,6 +25,7 @@ export class CoingeckoService implements IPricingService {
         private readonly apiKey: string,
         private readonly apiBaseUrl: string = "https://api.coingecko.com/api/v3/",
         @Inject(WINSTON_MODULE_NEST_PROVIDER) private readonly logger: LoggerService,
+        @Inject(CACHE_MANAGER) private readonly cacheManager: Cache,
     ) {
         this.axios = axios.create({
             baseURL: apiBaseUrl,
@@ -50,6 +52,62 @@ export class CoingeckoService implements IPricingService {
     ): Promise<Record<string, number>> {
         const { currency } = config;
 
+        const cacheKeys = tokenIds.map((tokenId) => this.formatTokenCacheKey(tokenId, currency));
+        const cachedTokenPrices = await this.getTokenPricesFromCache(cacheKeys);
+        const cachedMap = cachedTokenPrices.reduce(
+            (result, price, index) => {
+                if (price !== null) result[tokenIds.at(index) as string] = price;
+                return result;
+            },
+            {} as Record<string, number>,
+        );
+
+        const missingTokenIds = tokenIds.filter((_, index) => !cachedTokenPrices[index]);
+        const missingTokenPrices = await this.fetchTokenPrices(missingTokenIds, currency);
+
+        await this.saveTokenPricesToCache(missingTokenPrices, currency);
+
+        return { ...cachedMap, ...missingTokenPrices };
+    }
+
+    private formatTokenCacheKey(tokenId: string, currency: string) {
+        return `${tokenId}.${currency}`;
+    }
+
+    /**
+     * Retrieves multiple token prices from the cache at once.
+     * @param keys - An array of cache keys.
+     * @returns A promise that resolves to an array of token prices (number or null).
+     */
+    private async getTokenPricesFromCache(keys: string[]): Promise<(number | null)[]> {
+        return this.cacheManager.store.mget(...keys) as Promise<(number | null)[]>;
+    }
+
+    /**
+     * Saves multiple token prices to the cache at once.
+     *
+     * @param prices - The token prices to be saved.
+     * @param currency - The currency in which the prices are denominated.
+     */
+    private async saveTokenPricesToCache(prices: Record<string, number>, currency: string) {
+        if (Object.keys(prices).length === 0) return;
+
+        this.cacheManager.store.mset(
+            Object.entries(prices).map(([key, value]) => [
+                this.formatTokenCacheKey(key, currency),
+                value,
+            ]),
+        );
+    }
+
+    private async fetchTokenPrices(
+        tokenIds: string[],
+        currency: string,
+    ): Promise<Record<string, number>> {
+        if (tokenIds.length === 0) {
+            return {};
+        }
+
         return this.axios
             .get<TokenPrices>("simple/price", {
                 params: {

libs/shared/src/constants/index.ts

@@ -0,0 +1 @@
+export const TOKEN_CACHE_TTL_IN_SEC = 60;

package.json

@@ -24,6 +24,7 @@
     },
     "dependencies": {
         "@nestjs/axios": "3.0.2",
+        "@nestjs/cache-manager": "2.2.2",
         "@nestjs/common": "10.0.0",
         "@nestjs/core": "10.0.0",
         "@nestjs/platform-express": "10.0.0",
@@ -32,6 +33,7 @@
         "axios": "1.7.2",
         "axios-mock-adapter": "1.22.0",
         "nest-winston": "1.9.7",
+        "cache-manager": "5.7.4",
         "reflect-metadata": "0.1.13",
         "rxjs": "7.8.1",
         "viem": "2.17.5",