ts-cache-mongoose/dist/nest/index.mjs

Cache plugin for mongoose Queries and Aggregate (in-memory, redis)

import { Logger, Module } from '@nestjs/common';
import mongoose from 'mongoose';
import CacheMongoose from '../index.mjs';
import 'node:v8';
import 'bson';
import 'ioredis';
import 'node:crypto';

const CACHE_OPTIONS = Symbol("CACHE_OPTIONS");
class CacheService {
  logger = new Logger(CacheService.name);
  options;
  cacheMongoose;
  constructor(options) {
    this.options = options;
  }
  get instance() {
    return this.cacheMongoose;
  }
  async onApplicationBootstrap() {
    this.cacheMongoose = CacheMongoose.init(mongoose, this.options);
    this.logger.log(`Cache initialized with ${this.options.engine} engine`);
  }
  async onApplicationShutdown() {
    if (this.cacheMongoose) {
      await this.cacheMongoose.close();
    }
  }
  async clear(customKey) {
    await this.cacheMongoose.clear(customKey);
  }
}

var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __decorateClass = (decorators, target, key, kind) => {
  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
  for (var i = decorators.length - 1, decorator; i >= 0; i--)
    if (decorator = decorators[i])
      result = (decorator(result)) || result;
  return result;
};
let CacheModule = class {
  static forRoot(options) {
    return {
      module: CacheModule,
      global: options.isGlobal ?? false,
      providers: [
        { provide: CACHE_OPTIONS, useValue: options },
        {
          provide: CacheService,
          useFactory: (opts) => new CacheService(opts),
          inject: [CACHE_OPTIONS]
        }
      ],
      exports: [CacheService]
    };
  }
  static forRootAsync(options) {
    const asyncProviders = CacheModule.createAsyncProviders(options);
    return {
      module: CacheModule,
      global: options.isGlobal ?? false,
      imports: options.imports ?? [],
      providers: [
        ...asyncProviders,
        {
          provide: CacheService,
          useFactory: (opts) => new CacheService(opts),
          inject: [CACHE_OPTIONS]
        }
      ],
      exports: [CacheService]
    };
  }
  static createAsyncProviders(options) {
    if (options.useFactory) {
      return [
        {
          provide: CACHE_OPTIONS,
          useFactory: options.useFactory,
          inject: options.inject ?? []
        }
      ];
    }
    if (options.useClass) {
      return [
        { provide: options.useClass, useClass: options.useClass },
        {
          provide: CACHE_OPTIONS,
          useFactory: (factory) => factory.createCacheOptions(),
          inject: [options.useClass]
        }
      ];
    }
    if (options.useExisting) {
      return [
        {
          provide: CACHE_OPTIONS,
          useFactory: (factory) => factory.createCacheOptions(),
          inject: [options.useExisting]
        }
      ];
    }
    return [];
  }
};
CacheModule = __decorateClass([
  Module({})
], CacheModule);

export { CACHE_OPTIONS, CacheModule, CacheService };