feature(common) cache module

Author: kamilmysliwiec

packages/common/cache/cache.constants.ts

@@ -0,0 +1,3 @@
+export const CACHE_MANAGER = 'CACHE_MANAGER';
+export const CACHE_MODULE_OPTIONS = 'CACHE_MODULE_OPTIONS';
+export const CACHE_KEY_METADATA = 'cache_module:cache_key';

packages/common/cache/cache.module.ts

@@ -0,0 +1,63 @@
+import { Module } from '../decorators';
+import { DynamicModule, Provider } from '../interfaces';
+import { CACHE_MANAGER, CACHE_MODULE_OPTIONS } from './cache.constants';
+import { createCacheManager } from './cache.providers';
+import {
+  CacheModuleAsyncOptions,
+  CacheModuleOptions,
+  CacheOptionsFactory,
+} from './interfaces/cache-module.interface';
+
+@Module({
+  providers: [createCacheManager()],
+  exports: [CACHE_MANAGER],
+})
+export class CacheModule {
+  static register(options: CacheModuleOptions = {}): DynamicModule {
+    return {
+      module: CacheModule,
+      providers: [{ provide: CACHE_MODULE_OPTIONS, useValue: options }],
+    };
+  }
+
+  static registerAsync(options: CacheModuleAsyncOptions): DynamicModule {
+    return {
+      module: CacheModule,
+      imports: options.imports,
+      providers: this.createAsyncProviders(options),
+    };
+  }
+
+  private static createAsyncProviders(
+    options: CacheModuleAsyncOptions,
+  ): Provider[] {
+    if (options.useExisting || options.useFactory) {
+      return [this.createAsyncOptionsProvider(options)];
+    }
+    return [
+      this.createAsyncOptionsProvider(options),
+      {
+        provide: options.useClass,
+        useClass: options.useClass,
+      },
+    ];
+  }
+
+  private static createAsyncOptionsProvider(
+    options: CacheModuleAsyncOptions,
+  ): Provider {
+    if (options.useFactory) {
+      return {
+        provide: CACHE_MODULE_OPTIONS,
+        useFactory: options.useFactory,
+        inject: options.inject || [],
+      };
+    }
+    return {
+      provide: CACHE_MODULE_OPTIONS,
+      useFactory: async (optionsFactory: CacheOptionsFactory) =>
+        await optionsFactory.createCacheOptions(),
+      inject: [options.useExisting || options.useClass],
+    };
+  }
+}

packages/common/cache/cache.providers.ts

@@ -0,0 +1,20 @@
+import { Provider } from '../interfaces';
+import { loadPackage } from '../utils/load-package.util';
+import { CACHE_MANAGER, CACHE_MODULE_OPTIONS } from './cache.constants';
+import { defaultCacheOptions } from './default-options';
+import { CacheManagerOptions } from './interfaces/cache-manager.interface';
+
+export function createCacheManager(): Provider {
+  return {
+    provide: CACHE_MANAGER,
+    useFactory: (options: CacheManagerOptions) => {
+      const cacheManager = loadPackage('cache-manager', 'CacheModule');
+      const memoryCache = cacheManager.caching({
+        ...defaultCacheOptions,
+        ...((options || {}) as any),
+      });
+      return memoryCache;
+    },
+    inject: [CACHE_MODULE_OPTIONS],
+  };
+}

packages/common/cache/decorators/cache-key.decorator.ts

@@ -0,0 +1,5 @@
+import { ReflectMetadata } from '../../decorators';
+import { CACHE_KEY_METADATA } from '../cache.constants';
+
+export const CacheKey = (key: string) =>
+  ReflectMetadata(CACHE_KEY_METADATA, key);

packages/common/cache/decorators/index.ts

@@ -0,0 +1 @@
+export * from './cache-key.decorator';

packages/common/cache/default-options.ts

@@ -0,0 +1,5 @@
+export const defaultCacheOptions = {
+  ttl: 5,
+  max: 100,
+  store: 'memory',
+};

packages/common/cache/index.ts

@@ -0,0 +1,4 @@
+export * from './cache.module';
+export * from './decorators';
+export * from './interceptors';
+export * from './interfaces';

packages/common/cache/interceptors/cache.interceptor.ts

@@ -0,0 +1,60 @@
+import { Observable, of } from 'rxjs';
+import { tap } from 'rxjs/operators';
+import { Inject, Injectable, Optional } from '../../decorators';
+import {
+  ExecutionContext,
+  HttpServer,
+  NestInterceptor,
+} from '../../interfaces';
+import { CACHE_KEY_METADATA, CACHE_MANAGER } from '../cache.constants';
+
+// NOTE (external)
+// We need to deduplicate them here due to the circular dependency
+// between core and common packages
+const HTTP_SERVER_REF = 'HTTP_SERVER_REF';
+const REFLECTOR = 'Reflector';
+
+@Injectable()
+export class CacheInterceptor implements NestInterceptor {
+  private readonly isHttpApp: boolean;
+
+  constructor(
+    @Optional()
+    @Inject(HTTP_SERVER_REF)
+    private readonly httpServer: HttpServer,
+    @Inject(CACHE_MANAGER) private readonly cacheManager: any,
+    @Inject(REFLECTOR) private readonly reflector,
+  ) {
+    this.isHttpApp = httpServer && !!httpServer.getRequestMethod;
+  }
+
+  async intercept(
+    context: ExecutionContext,
+    call$: Observable<any>,
+  ): Promise<Observable<any>> {
+    const key = this.getCacheKey(context);
+    if (!key) {
+      return call$;
+    }
+    try {
+      const value = await this.cacheManager.get(key);
+      if (value) {
+        return of(value);
+      }
+      return call$.pipe(tap(response => this.cacheManager.set(key, response)));
+    } catch {
+      return call$;
+    }
+  }
+
+  getCacheKey(context: ExecutionContext): string | undefined {
+    if (!this.isHttpApp) {
+      return this.reflector.get(CACHE_KEY_METADATA, context.getHandler());
+    }
+    const request = context.getArgByIndex(0);
+    if (this.httpServer.getRequestMethod(request) !== 'GET') {
+      return undefined;
+    }
+    return this.httpServer.getRequestUrl(context.getArgByIndex(0));
+  }
+}

packages/common/cache/interceptors/index.ts

@@ -0,0 +1 @@
+export * from './cache.interceptor';

packages/common/cache/interfaces/cache-manager.interface.ts

@@ -0,0 +1,20 @@
+export interface LiteralObject {
+  [key: string]: any;
+}
+
+export interface CacheStore {
+  set<T>(key: string, value: T): Promise<void> | void;
+  get<T>(key: string): Promise<void> | void;
+  del(key: string): void | Promise<void>;
+}
+
+export interface CacheStoreFactory {
+  create(args: LiteralObject): CacheStore;
+}
+
+export interface CacheManagerOptions {
+  store?: string | CacheStoreFactory;
+  ttl?: number;
+  max?: number;
+  isCacheableValue?: (value: any) => boolean;
+}