chore: merge pull request #53 from gjovs/feature/request-with-cache-adapter

Feat: Add cache request adapter

Author: lucassm02

.vscode/settings.json

@@ -3,6 +3,7 @@
     "acked",
     "agendash",
     "agentkeepalive",
+    "checkperiod",
     "codegen",
     "datora",
     "fastify",

CHANGELOG.md

@@ -5,6 +5,12 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [2.4.0] - 2025-05-08
+
+### Added
+
+- Adds the `CacheRequestAdapter` wrapper of cache functionalities inside request adapter structure and interfaces
+
 ## [2.3.0] - 2025-05-06
 
 ### Added

src/data/protocols/cache/generic-cache-service.ts

@@ -0,0 +1,6 @@
+export interface GenericCacheService {
+  get<T>(...args: unknown[]): Promise<T>;
+  get<T>(...args: unknown[]): T;
+
+  set<T>(...args: unknown[]): T;
+}

src/data/protocols/cache/index.ts

@@ -2,3 +2,4 @@ export * from './get';
 export * from './set';
 export * from './replace';
 export * from './get-cache-key-by-context';
+export * from './generic-cache-service';

src/infra/cache/index.ts

@@ -1 +1,2 @@
 export * from './factory';
+export * from './node-cache';

src/infra/cache/node-cache.ts

@@ -0,0 +1,24 @@
+import NodeCache from 'node-cache';
+
+class NodeCacheSingleton {
+  private static instance: NodeCache;
+  private static readonly DEFAULT_TTL_IN_MINUTES = 60;
+  private static readonly DEFAULT_TTL_IN_SECONDS =
+    NodeCacheSingleton.DEFAULT_TTL_IN_MINUTES * 60;
+  private static readonly DEFAULT_TIME_TO_CHECK_IN_SECONDS = 120;
+
+  private constructor() {}
+
+  public static getInstance(): NodeCache {
+    if (!NodeCacheSingleton.instance) {
+      NodeCacheSingleton.instance = new NodeCache({
+        stdTTL: NodeCacheSingleton.DEFAULT_TTL_IN_SECONDS,
+        checkperiod: NodeCacheSingleton.DEFAULT_TIME_TO_CHECK_IN_SECONDS,
+        useClones: false
+      });
+    }
+    return NodeCacheSingleton.instance;
+  }
+}
+
+export const makeNodeCache = () => NodeCacheSingleton.getInstance();

src/infra/db/mssql/util/knex/extensions/turbo-plugin/turbo-interceptor.ts

@@ -1,17 +1,12 @@
-import { createHash } from 'node:crypto';
 import k, { Knex } from 'knex';
 import NodeCache from 'node-cache';
 
-import { logger } from '@/util';
 import { makeCacheServer } from '@/infra/cache';
+import { generateHashKeyToMemJs, logger } from '@/util';
 
 type Services = 'memjs' | 'node-cache';
 type GenericObject = Record<string, unknown>;
 
-function generateHashKeyToMemJs(value: string): string {
-  return createHash('sha256').update(value).digest('hex');
-}
-
 const cache = new NodeCache({ stdTTL: 100, checkperiod: 120 });
 const memCache = makeCacheServer();
 

src/infra/http/service/adapters/cache-request-adapter.ts

@@ -0,0 +1,123 @@
+import type { GenericCacheService } from '@/data/protocols/cache';
+import type { Data, HttpClient, HttpResponse } from '@/data/protocols/http';
+import { generateHashKeyToMemJs, logger } from '@/util';
+
+type Services = 'memjs' | 'node-cache';
+
+const DEFAULT_CACHE_SERVICE: Services = 'node-cache';
+const DEFAULT_TTL_IN_MINUTES = 60;
+
+const MAX_RESULT_SIZE = 1024 * 1024 * 1; // ~ 1 MB
+
+export class CachedRequestAdapter implements HttpClient {
+  constructor(
+    private readonly httpClient: HttpClient,
+    private readonly cacheService: GenericCacheService,
+    private readonly options: {
+      cacheService?: Services;
+      headersFields?: string[];
+      ttl?: number;
+    } = {}
+  ) {}
+
+  async request(data: Data): Promise<HttpResponse> {
+    const key = this.generateCacheKey(data);
+    const cachedResponse = await this.getCachedResponse(key);
+
+    if (cachedResponse && Object.keys(cachedResponse).length > 1)
+      return cachedResponse;
+
+    const response = await this.httpClient.request(data);
+
+    setImmediate(() => {
+      this.saveToCache(key, response).catch((error) => {
+        logger.log({
+          message: `Cache save error: ${error.message}`,
+          level: 'warn'
+        });
+      });
+    });
+
+    return response;
+  }
+
+  private generateCacheKey(data: Data): string {
+    const method = data.method?.toUpperCase() || '';
+    const { url } = data;
+    const headers = this.getRelevantHeaders(data.headers);
+    const body = this.normalizeBody(data.body);
+
+    const keyObject = { method, url, headers, body };
+    return generateHashKeyToMemJs(JSON.stringify(keyObject));
+  }
+
+  private getRelevantHeaders(
+    headers?: Record<string, unknown>
+  ): Record<string, string> {
+    if (!headers || !this.options.headersFields?.length) return {};
+
+    const relevantHeaders: Record<string, string> = {};
+
+    for (let i = 0; i < this.options.headersFields.length; i++) {
+      const field = this.options.headersFields[i];
+      if (headers[field] !== undefined) {
+        relevantHeaders[field] = String(headers[field]);
+      }
+    }
+
+    return relevantHeaders;
+  }
+
+  private normalizeBody(body: unknown): unknown {
+    if (typeof body !== 'object' || body === null || body === undefined)
+      return body;
+    return JSON.parse(JSON.stringify(body));
+  }
+
+  private async getCachedResponse(
+    key: string
+  ): Promise<HttpResponse | undefined> {
+    try {
+      if (this.getCacheService() === 'node-cache') {
+        return this.cacheService.get(key);
+      }
+      const buffer = await this.cacheService.get(key);
+      return buffer ? JSON.parse(buffer.toString()) : undefined;
+    } catch (error) {
+      logger.log({
+        message: `Cache read error: ${error.message}`,
+        level: 'warn'
+      });
+      return undefined;
+    }
+  }
+
+  private async saveToCache(
+    key: string,
+    response: HttpResponse
+  ): Promise<void> {
+    const responseString = JSON.stringify(response);
+
+    if (Buffer.byteLength(responseString) > MAX_RESULT_SIZE) {
+      return;
+    }
+
+    if (this.getCacheService() === 'node-cache') {
+      this.cacheService.set(key, response, this.getTtl());
+    } else {
+      await this.cacheService.set({
+        key,
+        value: responseString,
+        ttl: this.getTtl()
+      });
+    }
+  }
+
+  private getCacheService(): Services {
+    return this.options.cacheService || DEFAULT_CACHE_SERVICE;
+  }
+
+  private getTtl(): number {
+    return this.options.ttl || DEFAULT_TTL_IN_MINUTES;
+  }
+}

src/infra/http/service/adapters/index.ts

@@ -1,2 +1,3 @@
 export * from './form-data-request-adapter';
 export * from './request-adapter';
+export * from './cache-request-adapter';

src/util/cache.ts

@@ -1,3 +1,5 @@
+import { createHash } from 'node:crypto';
+
 import { ALLOWED_CONTEXT, CacheContexts } from '@/data/protocols/cache';
 
 import { name } from '../../package.json';
@@ -18,3 +20,7 @@ export function getCacheKeyByContext(context: CacheContexts, meta?: string) {
   const metaValue = meta ? `.${meta}` : '';
   return `${applicationName}.${context}${metaValue}`;
 }
+
+export function generateHashKeyToMemJs(value: string): string {
+  return createHash('sha256').update(value).digest('hex');
+}