ts-cache-mongoose 2.1.0 → 2.2.1

package/src/cache/Cache.ts

@@ -1,72 +0,0 @@
-import { ms } from '../ms'
-import { MemoryCacheEngine } from './engine/MemoryCacheEngine'
-import { RedisCacheEngine } from './engine/RedisCacheEngine'
-
-import type { CacheData, CacheEngine, CacheOptions, Duration } from '../types'
-
-export class Cache {
-  readonly #engine!: CacheEngine
-  readonly #defaultTTL: number
-  readonly #debug: boolean
-  readonly #engines = ['memory', 'redis'] as const
-
-  constructor(cacheOptions: CacheOptions) {
-    if (!this.#engines.includes(cacheOptions.engine)) {
-      throw new Error(`Invalid engine name: ${cacheOptions.engine}`)
-    }
-
-    if (cacheOptions.engine === 'redis' && !cacheOptions.engineOptions) {
-      throw new Error(`Engine options are required for ${cacheOptions.engine} engine`)
-    }
-
-    cacheOptions.defaultTTL ??= '1 minute'
-
-    this.#defaultTTL = ms(cacheOptions.defaultTTL)
-
-    if (cacheOptions.engine === 'redis' && cacheOptions.engineOptions) {
-      this.#engine = new RedisCacheEngine(cacheOptions.engineOptions)
-    }
-
-    if (cacheOptions.engine === 'memory') {
-      this.#engine = new MemoryCacheEngine()
-    }
-
-    this.#debug = cacheOptions.debug === true
-  }
-
-  async get(key: string): Promise<CacheData> {
-    const cacheEntry = await this.#engine.get(key)
-    if (this.#debug) {
-      const cacheHit = cacheEntry == null ? 'MISS' : 'HIT'
-      console.log(`[ts-cache-mongoose] GET '${key}' - ${cacheHit}`)
-    }
-    return cacheEntry
-  }
-
-  async set(key: string, value: CacheData, ttl: Duration | null): Promise<void> {
-    const givenTTL = ttl == null ? null : ms(ttl)
-    const actualTTL = givenTTL ?? this.#defaultTTL
-    await this.#engine.set(key, value, actualTTL)
-    if (this.#debug) {
-      console.log(`[ts-cache-mongoose] SET '${key}' - ttl: ${actualTTL.toFixed(0)} ms`)
-    }
-  }
-
-  async del(key: string): Promise<void> {
-    await this.#engine.del(key)
-    if (this.#debug) {
-      console.log(`[ts-cache-mongoose] DEL '${key}'`)
-    }
-  }
-
-  async clear(): Promise<void> {
-    await this.#engine.clear()
-    if (this.#debug) {
-      console.log('[ts-cache-mongoose] CLEAR')
-    }
-  }
-
-  async close(): Promise<void> {
-    return this.#engine.close()
-  }
-}

package/src/cache/engine/MemoryCacheEngine.ts

@@ -1,41 +0,0 @@
-import { ms } from '../../ms'
-
-import type { CacheData, CacheEngine, Duration } from '../../types'
-
-export class MemoryCacheEngine implements CacheEngine {
-  readonly #cache: Map<string, { value: CacheData; expiresAt: number } | undefined>
-
-  constructor() {
-    this.#cache = new Map()
-  }
-
-  get(key: string): CacheData {
-    const item = this.#cache.get(key)
-    if (!item || item.expiresAt < Date.now()) {
-      this.del(key)
-      return undefined
-    }
-    return item.value
-  }
-
-  set(key: string, value: CacheData, ttl?: Duration): void {
-    const givenTTL = ttl == null ? undefined : ms(ttl)
-    const actualTTL = givenTTL ?? Number.POSITIVE_INFINITY
-    this.#cache.set(key, {
-      value,
-      expiresAt: Date.now() + actualTTL,
-    })
-  }
-
-  del(key: string): void {
-    this.#cache.delete(key)
-  }
-
-  clear(): void {
-    this.#cache.clear()
-  }
-
-  close(): void {
-    // do nothing
-  }
-}

package/src/cache/engine/RedisCacheEngine.ts

@@ -1,52 +0,0 @@
-import { EJSON } from 'bson'
-import IORedis from 'ioredis'
-import { ms } from '../../ms'
-import { convertToObject } from '../../version'
-
-import type { Redis, RedisOptions } from 'ioredis'
-import type { CacheData, CacheEngine, Duration } from '../../types'
-
-export class RedisCacheEngine implements CacheEngine {
-  readonly #client: Redis
-
-  constructor(options: RedisOptions) {
-    options.keyPrefix ??= 'cache-mongoose:'
-    this.#client = new IORedis(options)
-  }
-
-  async get(key: string): Promise<CacheData> {
-    try {
-      const value = await this.#client.get(key)
-      if (value === null) {
-        return undefined
-      }
-      return EJSON.parse(value) as CacheData
-    } catch (err) {
-      console.error(err)
-      return undefined
-    }
-  }
-
-  async set(key: string, value: CacheData, ttl?: Duration): Promise<void> {
-    try {
-      const givenTTL = ttl == null ? undefined : ms(ttl)
-      const actualTTL = givenTTL ?? Number.POSITIVE_INFINITY
-      const serializedValue = EJSON.stringify(convertToObject(value))
-      await this.#client.setex(key, Math.ceil(actualTTL / 1000), serializedValue)
-    } catch (err) {
-      console.error(err)
-    }
-  }
-
-  async del(key: string): Promise<void> {
-    await this.#client.del(key)
-  }
-
-  async clear(): Promise<void> {
-    await this.#client.flushdb()
-  }
-
-  async close(): Promise<void> {
-    await this.#client.quit()
-  }
-}

package/src/extend/aggregate.ts

@@ -1,51 +0,0 @@
-import { getKey } from '../key'
-
-import type { Mongoose } from 'mongoose'
-import type { Cache } from '../cache/Cache'
-import type { Duration } from '../types'
-
-export function extendAggregate(mongoose: Mongoose, cache: Cache): void {
-  const mongooseExec = mongoose.Aggregate.prototype.exec
-
-  mongoose.Aggregate.prototype.getCacheKey = function (): string {
-    if (this._key != null) return this._key
-
-    return getKey({
-      pipeline: this.pipeline(),
-    })
-  }
-
-  mongoose.Aggregate.prototype.getDuration = function (): Duration | null {
-    return this._ttl
-  }
-
-  mongoose.Aggregate.prototype.cache = function (ttl?: Duration, customKey?: string) {
-    this._ttl = ttl ?? null
-    this._key = customKey ?? null
-    return this
-  }
-
-  mongoose.Aggregate.prototype.exec = async function (...args: []) {
-    if (!Object.hasOwn(this, '_ttl')) {
-      return mongooseExec.apply(this, args)
-    }
-
-    const key = this.getCacheKey()
-    const ttl = this.getDuration()
-
-    const resultCache = await cache.get(key).catch((err: unknown) => {
-      console.error(err)
-    })
-
-    if (resultCache) {
-      return resultCache
-    }
-
-    const result = (await mongooseExec.call(this)) as Record<string, unknown>[] | Record<string, unknown>
-    await cache.set(key, result, ttl).catch((err: unknown) => {
-      console.error(err)
-    })
-
-    return result
-  }
-}

package/src/extend/query.ts

@@ -1,81 +0,0 @@
-import { getKey } from '../key'
-
-import type { Mongoose } from 'mongoose'
-import type { Cache } from '../cache/Cache'
-import type { Duration } from '../types'
-
-export function extendQuery(mongoose: Mongoose, cache: Cache): void {
-  const mongooseExec = mongoose.Query.prototype.exec
-
-  mongoose.Query.prototype.getCacheKey = function (): string {
-    if (this._key != null) return this._key
-
-    const filter = this.getFilter()
-    const update = this.getUpdate()
-    const options = this.getOptions()
-    const mongooseOptions = this.mongooseOptions()
-
-    return getKey({
-      model: this.model.modelName,
-      op: this.op,
-      filter,
-      update,
-      options,
-      mongooseOptions,
-      _path: this._path,
-      _fields: this._fields,
-      _distinct: this._distinct,
-      _conditions: this._conditions,
-    })
-  }
-
-  mongoose.Query.prototype.getDuration = function (): Duration | null {
-    return this._ttl
-  }
-
-  mongoose.Query.prototype.cache = function (ttl?: Duration, customKey?: string) {
-    this._ttl = ttl ?? null
-    this._key = customKey ?? null
-    return this
-  }
-
-  mongoose.Query.prototype.exec = async function (...args: []) {
-    if (!Object.hasOwn(this, '_ttl')) {
-      return mongooseExec.apply(this, args)
-    }
-
-    const key = this.getCacheKey()
-    const ttl = this.getDuration()
-    const mongooseOptions = this.mongooseOptions()
-
-    const isCount = this.op?.includes('count') ?? false
-    const isDistinct = this.op === 'distinct'
-    const model = this.model.modelName
-
-    const resultCache = await cache.get(key).catch((err: unknown) => {
-      console.error(err)
-    })
-
-    if (resultCache) {
-      if (isCount || isDistinct || mongooseOptions.lean) {
-        return resultCache
-      }
-
-      const modelConstructor = mongoose.model<unknown>(model)
-
-      if (Array.isArray(resultCache)) {
-        return resultCache.map((item) => {
-          return modelConstructor.hydrate(item)
-        })
-      }
-      return modelConstructor.hydrate(resultCache)
-    }
-
-    const result = (await mongooseExec.call(this)) as Record<string, unknown>[] | Record<string, unknown>
-    await cache.set(key, result, ttl).catch((err: unknown) => {
-      console.error(err)
-    })
-
-    return result
-  }
-}

package/src/index.ts

@@ -1,68 +0,0 @@
-import { Cache } from './cache/Cache'
-import { extendAggregate } from './extend/aggregate'
-import { extendQuery } from './extend/query'
-
-import type { Mongoose } from 'mongoose'
-import type { CacheOptions, Duration } from './types'
-
-export * from './types'
-
-declare module 'mongoose' {
-  interface Query<ResultType, DocType, THelpers, RawDocType> {
-    cache: (this: Query<ResultType, DocType, THelpers, RawDocType>, ttl?: Duration, customKey?: string) => this
-    _key: string | null
-    getCacheKey: (this: Query<ResultType, DocType, THelpers, RawDocType>) => string
-    _ttl: Duration | null
-    getDuration: (this: Query<ResultType, DocType, THelpers, RawDocType>) => Duration | null
-    op?: string
-    _path?: unknown
-    _fields?: unknown
-    _distinct?: unknown
-    _conditions?: unknown
-  }
-
-  interface Aggregate<ResultType> {
-    cache: (this: Aggregate<ResultType>, ttl?: Duration, customKey?: string) => this
-    _key: string | null
-    getCacheKey: (this: Aggregate<ResultType>) => string
-    _ttl: Duration | null
-    getDuration: (this: Aggregate<ResultType>) => Duration | null
-  }
-}
-
-class CacheMongoose {
-  static #instance: CacheMongoose | undefined
-  private cache!: Cache
-
-  private constructor() {
-    // Private constructor to prevent external instantiation
-  }
-
-  public static init(mongoose: Mongoose, cacheOptions: CacheOptions): CacheMongoose {
-    if (!CacheMongoose.#instance) {
-      CacheMongoose.#instance = new CacheMongoose()
-      CacheMongoose.#instance.cache = new Cache(cacheOptions)
-
-      const cache = CacheMongoose.#instance.cache
-
-      extendQuery(mongoose, cache)
-      extendAggregate(mongoose, cache)
-    }
-
-    return CacheMongoose.#instance
-  }
-
-  public async clear(customKey?: string): Promise<void> {
-    if (customKey == null) {
-      await this.cache.clear()
-    } else {
-      await this.cache.del(customKey)
-    }
-  }
-
-  public async close(): Promise<void> {
-    await this.cache.close()
-  }
-}
-
-export default CacheMongoose

package/src/key.ts

@@ -1,10 +0,0 @@
-import { createHash } from 'node:crypto'
-import { sortKeys } from './sort-keys'
-
-export function getKey(data: Record<string, unknown>[] | Record<string, unknown>): string {
-  const sortedObj = sortKeys(data)
-  const sortedStr = JSON.stringify(sortedObj, (_, val: unknown) => {
-    return val instanceof RegExp ? String(val) : val
-  })
-  return createHash('sha1').update(sortedStr).digest('hex')
-}

package/src/ms.ts

@@ -1,66 +0,0 @@
-const s = 1000
-const m = s * 60
-const h = m * 60
-const d = h * 24
-const w = d * 7
-const y = d * 365.25
-const mo = y / 12
-
-export const UNITS = {
-  milliseconds: 1,
-  millisecond: 1,
-  msecs: 1,
-  msec: 1,
-  ms: 1,
-  seconds: s,
-  second: s,
-  secs: s,
-  sec: s,
-  s,
-  minutes: m,
-  minute: m,
-  mins: m,
-  min: m,
-  m,
-  hours: h,
-  hour: h,
-  hrs: h,
-  hr: h,
-  h,
-  days: d,
-  day: d,
-  d,
-  weeks: w,
-  week: w,
-  w,
-  months: mo,
-  month: mo,
-  mo,
-  years: y,
-  year: y,
-  yrs: y,
-  yr: y,
-  y,
-} as const satisfies Record<string, number>
-
-export type Unit = keyof typeof UNITS
-
-export type Duration = number | `${number}` | `${number}${Unit}` | `${number} ${Unit}`
-
-const unitPattern = Object.keys(UNITS)
-  .sort((a, b) => b.length - a.length)
-  .join('|')
-
-const RE = new RegExp(String.raw`^(-?(?:\d+)?\.?\d+)\s*(${unitPattern})?$`, 'i')
-
-export const ms = (val: Duration): number => {
-  const str = String(val)
-  if (str.length > 100) return Number.NaN
-
-  const match = RE.exec(str)
-  if (!match) return Number.NaN
-
-  const n = Number.parseFloat(match[1] ?? '')
-  const type = (match[2] ?? 'ms').toLowerCase()
-  return n * (UNITS[type as Unit] ?? 0)
-}

package/src/nest/cache.module.ts

@@ -1,79 +0,0 @@
-/** biome-ignore-all lint/complexity/noStaticOnlyClass: nest */
-import { Module } from '@nestjs/common'
-import { CACHE_OPTIONS, CacheService } from './cache.service'
-
-import type { DynamicModule, Provider } from '@nestjs/common'
-import type { CacheModuleAsyncOptions, CacheModuleOptions, CacheOptionsFactory } from './interfaces'
-
-@Module({})
-export class CacheModule {
-  static forRoot(options: CacheModuleOptions & { isGlobal?: boolean }): DynamicModule {
-    return {
-      module: CacheModule,
-      global: options.isGlobal ?? false,
-      providers: [
-        { provide: CACHE_OPTIONS, useValue: options },
-        {
-          provide: CacheService,
-          useFactory: (opts: CacheModuleOptions) => new CacheService(opts),
-          inject: [CACHE_OPTIONS],
-        },
-      ],
-      exports: [CacheService],
-    }
-  }
-
-  static forRootAsync(options: CacheModuleAsyncOptions): DynamicModule {
-    const asyncProviders = CacheModule.createAsyncProviders(options)
-
-    return {
-      module: CacheModule,
-      global: options.isGlobal ?? false,
-      imports: options.imports ?? [],
-      providers: [
-        ...asyncProviders,
-        {
-          provide: CacheService,
-          useFactory: (opts: CacheModuleOptions) => new CacheService(opts),
-          inject: [CACHE_OPTIONS],
-        },
-      ],
-      exports: [CacheService],
-    }
-  }
-
-  private static createAsyncProviders(options: CacheModuleAsyncOptions): Provider[] {
-    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: CacheOptionsFactory) => factory.createCacheOptions(),
-          inject: [options.useClass],
-        },
-      ]
-    }
-
-    if (options.useExisting) {
-      return [
-        {
-          provide: CACHE_OPTIONS,
-          useFactory: (factory: CacheOptionsFactory) => factory.createCacheOptions(),
-          inject: [options.useExisting],
-        },
-      ]
-    }
-
-    return []
-  }
-}

package/src/nest/cache.service.ts

@@ -1,37 +0,0 @@
-import { Logger } from '@nestjs/common'
-import mongoose from 'mongoose'
-import CacheMongoose from '../index'
-
-import type { OnApplicationBootstrap, OnApplicationShutdown } from '@nestjs/common'
-import type { CacheModuleOptions } from './interfaces'
-
-export const CACHE_OPTIONS = Symbol('CACHE_OPTIONS')
-
-export class CacheService implements OnApplicationBootstrap, OnApplicationShutdown {
-  private readonly logger = new Logger(CacheService.name)
-  private readonly options: CacheModuleOptions
-  private cacheMongoose!: CacheMongoose
-
-  constructor(options: CacheModuleOptions) {
-    this.options = options
-  }
-
-  get instance(): CacheMongoose {
-    return this.cacheMongoose
-  }
-
-  async onApplicationBootstrap(): Promise<void> {
-    this.cacheMongoose = CacheMongoose.init(mongoose, this.options)
-    this.logger.log(`Cache initialized with ${this.options.engine} engine`)
-  }
-
-  async onApplicationShutdown(): Promise<void> {
-    if (this.cacheMongoose) {
-      await this.cacheMongoose.close()
-    }
-  }
-
-  async clear(customKey?: string): Promise<void> {
-    await this.cacheMongoose.clear(customKey)
-  }
-}

package/src/nest/index.ts

@@ -1,4 +0,0 @@
-export { CacheModule } from './cache.module'
-export { CACHE_OPTIONS, CacheService } from './cache.service'
-
-export type { CacheModuleAsyncOptions, CacheModuleOptions, CacheOptionsFactory } from './interfaces'

package/src/nest/interfaces.ts

@@ -1,17 +0,0 @@
-import type { InjectionToken, ModuleMetadata, OptionalFactoryDependency, Type } from '@nestjs/common'
-import type { CacheOptions } from '../types'
-
-export type CacheModuleOptions = CacheOptions
-
-export interface CacheOptionsFactory {
-  createCacheOptions(): CacheModuleOptions | Promise<CacheModuleOptions>
-}
-
-export interface CacheModuleAsyncOptions extends Pick<ModuleMetadata, 'imports'> {
-  isGlobal?: boolean
-  inject?: (InjectionToken | OptionalFactoryDependency)[]
-  useClass?: Type<CacheOptionsFactory>
-  useExisting?: Type<CacheOptionsFactory>
-  // biome-ignore lint/suspicious/noExplicitAny: NestJS convention for factory args
-  useFactory?: (...args: any[]) => CacheModuleOptions | Promise<CacheModuleOptions>
-}

package/src/sort-keys.ts

@@ -1,38 +0,0 @@
-const isPlainObject = (value: unknown): value is Record<string, unknown> => {
-  if (typeof value !== 'object' || value === null) return false
-  const proto = Object.getPrototypeOf(value) as unknown
-  return proto === Object.prototype || proto === null
-}
-
-export const sortKeys = (input: Record<string, unknown> | Record<string, unknown>[]): Record<string, unknown> | Record<string, unknown>[] => {
-  const seen = new WeakSet<object>()
-
-  const sortObject = (obj: Record<string, unknown>): Record<string, unknown> => {
-    if (seen.has(obj)) return obj
-    seen.add(obj)
-
-    const sorted: Record<string, unknown> = {}
-    for (const key of Object.keys(obj).sort((a, b) => a.localeCompare(b))) {
-      const value = obj[key]
-      if (Array.isArray(value)) {
-        sorted[key] = sortArray(value)
-      } else if (isPlainObject(value)) {
-        sorted[key] = sortObject(value)
-      } else {
-        sorted[key] = value
-      }
-    }
-    return sorted
-  }
-
-  const sortArray = (arr: unknown[]): unknown[] => {
-    return arr.map((item) => {
-      if (Array.isArray(item)) return sortArray(item)
-      if (isPlainObject(item)) return sortObject(item)
-      return item
-    })
-  }
-
-  if (Array.isArray(input)) return sortArray(input) as Record<string, unknown>[]
-  return sortObject(input)
-}

package/src/types.ts

@@ -1,21 +0,0 @@
-import type { RedisOptions } from 'ioredis'
-import type { Duration } from './ms'
-
-export type { Duration } from './ms'
-
-export type CacheData = Record<string, unknown> | Record<string, unknown>[] | unknown[] | number | undefined
-
-export type CacheOptions = {
-  engine: 'memory' | 'redis'
-  engineOptions?: RedisOptions
-  defaultTTL?: Duration
-  debug?: boolean
-}
-
-export interface CacheEngine {
-  get: (key: string) => Promise<CacheData> | CacheData
-  set: (key: string, value: CacheData, ttl?: Duration) => Promise<void> | void
-  del: (key: string) => Promise<void> | void
-  clear: () => Promise<void> | void
-  close: () => Promise<void> | void
-}

package/src/version.ts

@@ -1,18 +0,0 @@
-import mongoose from 'mongoose'
-
-import type { CacheData } from './types'
-
-export const isMongooseLessThan7 = Number.parseInt(mongoose.version, 10) < 7
-
-export const convertToObject = <T>(value: (T & { toObject?: () => CacheData }) | undefined): CacheData => {
-  if (isMongooseLessThan7) {
-    if (value != null && typeof value === 'object' && !Array.isArray(value) && value.toObject) {
-      return value.toObject()
-    }
-    if (Array.isArray(value)) {
-      return value.map((doc) => convertToObject(doc))
-    }
-  }
-
-  return value
-}