ts-cache-mongoose 2.0.0 → 2.2.0

package/dist/nest/index.cjs

@@ -3,14 +3,17 @@
 var common = require('@nestjs/common');
 var mongoose = require('mongoose');
 var index = require('../index.cjs');
+require('node:v8');
 require('bson');
 require('ioredis');
 require('node:crypto');
 
 const CACHE_OPTIONS = Symbol("CACHE_OPTIONS");
 class CacheService {
+  logger = new common.Logger(CacheService.name);
+  options;
+  cacheMongoose;
   constructor(options) {
-    this.logger = new common.Logger(CacheService.name);
     this.options = options;
   }
   get instance() {

package/dist/nest/index.mjs

@@ -1,14 +1,17 @@
 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.logger = new Logger(CacheService.name);
     this.options = options;
   }
   get instance() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-cache-mongoose",
-  "version": "2.0.0",
+  "version": "2.2.0",
   "description": "Cache plugin for mongoose Queries and Aggregate (in-memory, redis)",
   "author": "ilovepixelart",
   "license": "MIT",
@@ -12,9 +12,6 @@
     "url": "https://github.com/ilovepixelart/ts-cache-mongoose/issues"
   },
   "homepage": "https://github.com/ilovepixelart/ts-cache-mongoose#readme",
-  "directories": {
-    "examples": "examples"
-  },
   "keywords": [
     "backend",
     "mongo",
@@ -35,15 +32,10 @@
     "aggregate"
   ],
   "engines": {
-    "node": ">=16"
+    "node": ">=20"
   },
   "files": [
-    "dist",
-    "src",
-    "tests",
-    "tsconfig.json",
-    "vite.config.mts",
-    "biome.json"
+    "dist"
   ],
   "type": "module",
   "exports": {
@@ -78,37 +70,44 @@
   "main": "./dist/index.cjs",
   "module": "./dist/index.mjs",
   "types": "./dist/index.d.cts",
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
   "scripts": {
-    "prepare": "simple-git-hooks",
     "biome": "npx @biomejs/biome check",
     "biome:fix": "npx @biomejs/biome check --write .",
     "test": "vitest run --coverage",
     "test:open": "vitest run --coverage && open-cli coverage/lcov-report/index.html",
     "clean": "rm -rf ./dist",
     "type:check": "tsc --noEmit",
+    "type:check:tests": "tsc --noEmit -p tests/tsconfig.json",
     "build": "pkgroll --clean-dist",
-    "release": "npm install && npm run biome && npm run type:check && npm run build && np --no-publish"
+    "release": "npm install && npm run biome && npm run type:check && npm run type:check:tests && npm run build && np --no-publish"
   },
   "dependencies": {
     "ioredis": "5.10.0"
   },
   "devDependencies": {
-    "@biomejs/biome": "2.4.7",
-    "@nestjs/common": "11.1.16",
-    "@types/node": "25.5.0",
-    "@vitest/coverage-v8": "4.1.0",
+    "@biomejs/biome": "2.4.11",
+    "@nestjs/common": "11.1.18",
+    "@nestjs/core": "11.1.18",
+    "@nestjs/testing": "11.1.18",
+    "@types/node": "25.6.0",
+    "@vitest/coverage-v8": "4.1.4",
     "bson": "7.2.0",
+    "fast-check": "4.6.0",
     "mongodb-memory-server": "11.0.1",
-    "mongoose": "9.3.0",
-    "np": "11.0.2",
-    "open-cli": "8.0.0",
+    "mongoose": "9.4.1",
+    "np": "11.0.3",
+    "open-cli": "9.0.0",
     "pkgroll": "2.27.0",
     "simple-git-hooks": "2.13.1",
     "typescript": "5.9.3",
-    "vitest": "4.1.0"
+    "vitest": "4.1.4"
   },
   "peerDependencies": {
-    "@nestjs/common": ">=9.0.0",
+    "@nestjs/common": ">=9.0.0 < 12",
     "bson": ">=4.7.2 < 8",
     "mongoose": ">=6.6.0 < 10"
   },
@@ -125,7 +124,6 @@
     "publish": false
   },
   "overrides": {
-    "tmp": "0.2.5",
-    "file-type": "21.3.2"
+    "tmp": "0.2.5"
   }
 }

package/biome.json

@@ -1,47 +0,0 @@
-{
-  "$schema": "https://biomejs.dev/schemas/2.4.7/schema.json",
-  "vcs": { "enabled": false, "clientKind": "git", "useIgnoreFile": false },
-  "files": {
-    "ignoreUnknown": false,
-    "includes": ["src/**/*.ts", "tests/**/*.ts"]
-  },
-  "formatter": { "enabled": true, "indentStyle": "space", "indentWidth": 2 },
-  "assist": {
-    "actions": {
-      "source": {
-        "organizeImports": {
-          "level": "on",
-          "options": {
-            "groups": [
-              "vitest",
-              ":BLANK_LINE:",
-              ":NODE:",
-              { "type": false },
-              ":BLANK_LINE:"
-            ]
-          }
-        }
-      }
-    }
-  },
-  "linter": {
-    "enabled": true,
-    "rules": {
-      "recommended": true
-    }
-  },
-  "javascript": {
-    "formatter": {
-      "trailingCommas": "all",
-      "quoteStyle": "single",
-      "semicolons": "asNeeded",
-      "lineWidth": 320
-    },
-    "globals": ["Atomics", "SharedArrayBuffer"]
-  },
-  "json": {
-    "formatter": {
-      "trailingCommas": "none"
-    }
-  }
-}

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, CacheTTL } 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 = typeof cacheOptions.defaultTTL === 'string' ? ms(cacheOptions.defaultTTL) : 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: CacheTTL | null): Promise<void> {
-    const givenTTL = typeof ttl === 'string' ? ms(ttl) : 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, CacheTTL } 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?: CacheTTL): void {
-    const givenTTL = typeof ttl === 'string' ? ms(ttl) : 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, CacheTTL } 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?: CacheTTL): Promise<void> {
-    try {
-      const givenTTL = typeof ttl === 'string' ? ms(ttl) : 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,52 +0,0 @@
-import { getKey } from '../key'
-
-import type { Mongoose } from 'mongoose'
-import type { Cache } from '../cache/Cache'
-import type { CacheTTL } 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.getCacheTTL = function (): CacheTTL | null {
-    return this._ttl
-  }
-
-  mongoose.Aggregate.prototype.cache = function (ttl?: CacheTTL, customKey?: string) {
-    this._ttl = ttl ?? null
-    this._key = customKey ?? null
-    return this
-  }
-
-  mongoose.Aggregate.prototype.exec = async function (...args: []) {
-    // biome-ignore lint/suspicious/noPrototypeBuiltins: to support node 16
-    if (!Object.prototype.hasOwnProperty.call(this, '_ttl')) {
-      return mongooseExec.apply(this, args)
-    }
-
-    const key = this.getCacheKey()
-    const ttl = this.getCacheTTL()
-
-    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,82 +0,0 @@
-import { getKey } from '../key'
-
-import type { Mongoose } from 'mongoose'
-import type { Cache } from '../cache/Cache'
-import type { CacheTTL } 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.getCacheTTL = function (): CacheTTL | null {
-    return this._ttl
-  }
-
-  mongoose.Query.prototype.cache = function (ttl?: CacheTTL, customKey?: string) {
-    this._ttl = ttl ?? null
-    this._key = customKey ?? null
-    return this
-  }
-
-  mongoose.Query.prototype.exec = async function (...args: []) {
-    // biome-ignore lint/suspicious/noPrototypeBuiltins: to support node 16
-    if (!Object.prototype.hasOwnProperty.call(this, '_ttl')) {
-      return mongooseExec.apply(this, args)
-    }
-
-    const key = this.getCacheKey()
-    const ttl = this.getCacheTTL()
-    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, CacheTTL } from './types'
-
-export * from './types'
-
-declare module 'mongoose' {
-  interface Query<ResultType, DocType, THelpers, RawDocType> {
-    cache: (this: Query<ResultType, DocType, THelpers, RawDocType>, ttl?: CacheTTL, customKey?: string) => this
-    _key: string | null
-    getCacheKey: (this: Query<ResultType, DocType, THelpers, RawDocType>) => string
-    _ttl: CacheTTL | null
-    getCacheTTL: (this: Query<ResultType, DocType, THelpers, RawDocType>) => CacheTTL | null
-    op?: string
-    _path?: unknown
-    _fields?: unknown
-    _distinct?: unknown
-    _conditions?: unknown
-  }
-
-  interface Aggregate<ResultType> {
-    cache: (this: Aggregate<ResultType>, ttl?: CacheTTL, customKey?: string) => this
-    _key: string | null
-    getCacheKey: (this: Aggregate<ResultType>) => string
-    _ttl: CacheTTL | null
-    getCacheTTL: (this: Aggregate<ResultType>) => CacheTTL | 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,55 +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
-
-// NOSONAR — regex from ms package, intentionally covers all time unit aliases
-const RE = /^(-?(?:\d+)?\.?\d+)\s*(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i
-
-const UNITS: Record<string, number> = {
-  years: y,
-  year: y,
-  yrs: y,
-  yr: y,
-  y,
-  weeks: w,
-  week: w,
-  w,
-  days: d,
-  day: d,
-  d,
-  hours: h,
-  hour: h,
-  hrs: h,
-  hr: h,
-  h,
-  minutes: m,
-  minute: m,
-  mins: m,
-  min: m,
-  m,
-  seconds: s,
-  second: s,
-  secs: s,
-  sec: s,
-  s,
-  milliseconds: 1,
-  millisecond: 1,
-  msecs: 1,
-  msec: 1,
-  ms: 1,
-}
-
-export const ms = (val: string): number => {
-  const str = String(val)
-  if (str.length > 100) return 0
-
-  const match = RE.exec(str)
-  if (!match) return 0
-
-  const n = Number.parseFloat(match[1] ?? '')
-  const type = (match[2] ?? 'ms').toLowerCase()
-  return n * (UNITS[type] ?? 0)
-}