ts-cache-mongoose 0.0.3 → 0.0.5

package/dist/esm/types/extend/query.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"query.d.ts","sourceRoot":"","sources":["../../../../src/extend/query.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AACxC,OAAO,KAAK,KAAK,MAAM,gBAAgB,CAAA;AAIvC,MAAM,CAAC,OAAO,UAAU,WAAW,CAAE,QAAQ,EAAE,QAAQ,EAAE,KAAK,EAAE,KAAK,GAAG,IAAI,CAwE3E"}

package/dist/esm/types/plugin.d.ts

@@ -8,15 +8,22 @@ declare module 'mongoose' {
         _ttl?: string;
         getCacheTTL: (this: Query<ResultType, DocType, THelpers, RawDocType>) => string | undefined;
         op?: string;
-        _fields?: unknown;
         _path?: unknown;
+        _fields?: unknown;
         _distinct?: unknown;
+        _conditions?: unknown;
+    }
+    interface Aggregate<ResultType> {
+        cache: (this: Aggregate<ResultType>, ttl?: string, customKey?: string) => this;
+        _key?: string;
+        getCacheKey: (this: Aggregate<ResultType>) => string;
+        _ttl?: string;
+        getCacheTTL: (this: Aggregate<ResultType>) => string | undefined;
     }
 }
 declare class CacheMongoose {
     private static instance;
     private cache;
-    private cacheOptions;
     private constructor();
     static init(mongoose: Mongoose, cacheOptions: ICacheOptions): CacheMongoose;
     clear(customKey?: string): Promise<void>;

package/dist/esm/types/plugin.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../../../src/plugin.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AACxC,OAAO,KAAK,aAAa,MAAM,4BAA4B,CAAA;AAG3D,OAAO,QAAQ,UAAU,CAAC;IACxB,UAAU,KAAK,CAAC,UAAU,EAAE,OAAO,EAAE,QAAQ,EAAE,UAAU;QACvD,KAAK,EAAE,CAAC,IAAI,EAAE,KAAK,CAAC,UAAU,EAAE,OAAO,EAAE,QAAQ,EAAE,UAAU,CAAC,EAAE,GAAG,CAAC,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,KAAK,IAAI,CAAA;QACzG,IAAI,CAAC,EAAE,MAAM,CAAA;QACb,WAAW,EAAE,CAAC,IAAI,EAAE,KAAK,CAAC,UAAU,EAAE,OAAO,EAAE,QAAQ,EAAE,UAAU,CAAC,KAAK,MAAM,CAAA;QAC/E,IAAI,CAAC,EAAE,MAAM,CAAA;QACb,WAAW,EAAE,CAAC,IAAI,EAAE,KAAK,CAAC,UAAU,EAAE,OAAO,EAAE,QAAQ,EAAE,UAAU,CAAC,KAAK,MAAM,GAAG,SAAS,CAAA;QAC3F,EAAE,CAAC,EAAE,MAAM,CAAA;QACX,OAAO,CAAC,EAAE,OAAO,CAAA;QACjB,KAAK,CAAC,EAAE,OAAO,CAAA;QACf,SAAS,CAAC,EAAE,OAAO,CAAA;KACpB;CACF;AAED,cAAM,aAAa;IAEjB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAA2B;IAClD,OAAO,CAAC,KAAK,CAAQ;IACrB,OAAO,CAAC,YAAY,CAAgB;IAEpC,OAAO;WAKO,IAAI,CAAE,QAAQ,EAAE,QAAQ,EAAE,YAAY,EAAE,aAAa,GAAG,aAAa;IAiFtE,KAAK,CAAE,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAOzC,KAAK,IAAK,OAAO,CAAC,IAAI,CAAC;CAKrC;AAED,eAAe,aAAa,CAAA"}
+{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../../../src/plugin.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AACxC,OAAO,KAAK,aAAa,MAAM,4BAA4B,CAAA;AAK3D,OAAO,QAAQ,UAAU,CAAC;IACxB,UAAU,KAAK,CAAC,UAAU,EAAE,OAAO,EAAE,QAAQ,EAAE,UAAU;QACvD,KAAK,EAAE,CAAC,IAAI,EAAE,KAAK,CAAC,UAAU,EAAE,OAAO,EAAE,QAAQ,EAAE,UAAU,CAAC,EAAE,GAAG,CAAC,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,KAAK,IAAI,CAAA;QACzG,IAAI,CAAC,EAAE,MAAM,CAAA;QACb,WAAW,EAAE,CAAC,IAAI,EAAE,KAAK,CAAC,UAAU,EAAE,OAAO,EAAE,QAAQ,EAAE,UAAU,CAAC,KAAK,MAAM,CAAA;QAC/E,IAAI,CAAC,EAAE,MAAM,CAAA;QACb,WAAW,EAAE,CAAC,IAAI,EAAE,KAAK,CAAC,UAAU,EAAE,OAAO,EAAE,QAAQ,EAAE,UAAU,CAAC,KAAK,MAAM,GAAG,SAAS,CAAA;QAC3F,EAAE,CAAC,EAAE,MAAM,CAAA;QACX,KAAK,CAAC,EAAE,OAAO,CAAA;QACf,OAAO,CAAC,EAAE,OAAO,CAAA;QACjB,SAAS,CAAC,EAAE,OAAO,CAAA;QACnB,WAAW,CAAC,EAAE,OAAO,CAAA;KACtB;IAED,UAAU,SAAS,CAAC,UAAU;QAC5B,KAAK,EAAE,CAAC,IAAI,EAAE,SAAS,CAAC,UAAU,CAAC,EAAE,GAAG,CAAC,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,KAAK,IAAI,CAAA;QAC9E,IAAI,CAAC,EAAE,MAAM,CAAA;QACb,WAAW,EAAE,CAAC,IAAI,EAAE,SAAS,CAAC,UAAU,CAAC,KAAK,MAAM,CAAA;QACpD,IAAI,CAAC,EAAE,MAAM,CAAA;QACb,WAAW,EAAE,CAAC,IAAI,EAAE,SAAS,CAAC,UAAU,CAAC,KAAK,MAAM,GAAG,SAAS,CAAA;KACjE;CACF;AAED,cAAM,aAAa;IAEjB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAA2B;IAClD,OAAO,CAAC,KAAK,CAAQ;IAErB,OAAO;WAIO,IAAI,CAAE,QAAQ,EAAE,QAAQ,EAAE,YAAY,EAAE,aAAa,GAAG,aAAa;IAetE,KAAK,CAAE,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAQzC,KAAK,IAAK,OAAO,CAAC,IAAI,CAAC;CAGrC;AAED,eAAe,aAAa,CAAA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-cache-mongoose",
-  "version": "0.0.3",
+  "version": "0.0.5",
   "description": "Cache plugin for mongoose",
   "author": "Alex Eagle",
   "license": "MIT",
@@ -73,9 +73,10 @@
     "release": "npm install && npm run lint && npm run build && np"
   },
   "dependencies": {
-    "ioredis": "^5.3.2",
-    "lodash": "^4.17.21",
-    "ms": "^2.1.3"
+    "ioredis": "5.3.2",
+    "lodash": "4.17.21",
+    "ms": "2.1.3",
+    "sort-keys": "4.2.0"
   },
   "devDependencies": {
     "@shelf/jest-mongodb": "4.1.7",

package/src/crypto.ts

@@ -1,27 +1,10 @@
-import _ from 'lodash'
 import { createHash } from 'crypto'
-
-export function sortDeep (data: Record<string, unknown>[] | Record<string, unknown>): unknown {
-  if (_.isObjectLike(data) && _.isArray(data)) {
-    return data.map(sortDeep)
-  }
-
-  if (_.isObjectLike(data) && !_.isArray(data)) {
-    const sortedKeys = _.keys(data).sort((a, b) => a.localeCompare(b))
-    const sortedObj: Record<string, unknown> = {}
-
-    sortedKeys.forEach((key) => {
-      sortedObj[key] = sortDeep(data[key] as Record<string, unknown>[] | Record<string, unknown>)
-    })
-
-    return sortedObj
-  }
-
-  return data
-}
+import sortKeys from 'sort-keys'
 
 export function getKey (data: Record<string, unknown>[] | Record<string, unknown>): string {
-  const sortedObj = sortDeep(data)
-  const sortedStr = JSON.stringify(sortedObj)
-  return createHash('sha256').update(sortedStr).digest('hex')
+  const sortedObj = sortKeys(data, { deep: true })
+  const sortedStr = JSON.stringify(sortedObj, (_key, val: unknown) => {
+    return val instanceof RegExp ? String(val) : val
+  })
+  return createHash('sha1').update(sortedStr).digest('hex')
 }

package/src/extend/aggregate.ts

@@ -0,0 +1,55 @@
+import _ from 'lodash'
+
+import type { Mongoose } from 'mongoose'
+import type Cache from '../cache/Cache'
+
+import { getKey } from '../crypto'
+
+export default function extendQuery (mongoose: Mongoose, cache: Cache): void {
+  // eslint-disable-next-line @typescript-eslint/unbound-method
+  const mongooseExec = mongoose.Aggregate.prototype.exec
+
+  // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+  mongoose.Aggregate.prototype.getCacheKey = function () {
+    return getKey({
+      pipeline: this.pipeline()
+    })
+  }
+
+  // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+  mongoose.Aggregate.prototype.getCacheTTL = function () {
+    return this._ttl
+  }
+
+  // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+  mongoose.Aggregate.prototype.cache = function (ttl?: string, customKey?: string) {
+    this._ttl = ttl
+    this._key = customKey
+    return this
+  }
+
+  // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+  mongoose.Aggregate.prototype.exec = async function () {
+    if (!_.has(this, '_ttl')) {
+      return mongooseExec.apply(this)
+    }
+
+    const key = this.getCacheKey()
+    const ttl = this.getCacheTTL()
+
+    const resultCache = await cache.get(key).catch((err) => {
+      console.error(err)
+    })
+
+    if (resultCache) {
+      return resultCache
+    }
+
+    const result = await mongooseExec.call(this) as Record<string, unknown>[] | Record<string, unknown>
+    cache.set(key, result, ttl).catch((err) => {
+      console.error(err)
+    })
+
+    return result
+  }
+}

package/src/extend/query.ts

@@ -0,0 +1,80 @@
+import _ from 'lodash'
+
+import type { Mongoose } from 'mongoose'
+import type Cache from '../cache/Cache'
+
+import { getKey } from '../crypto'
+
+export default function extendQuery (mongoose: Mongoose, cache: Cache): void {
+  // eslint-disable-next-line @typescript-eslint/unbound-method
+  const mongooseExec = mongoose.Query.prototype.exec
+
+  // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+  mongoose.Query.prototype.getCacheKey = function () {
+    if (this._key) return this._key
+
+    const filter = this.getFilter()
+    const update = this.getUpdate()
+    const options = this.getOptions()
+    const mongooseOptions = this.mongooseOptions()
+
+    const data: Record<string, unknown> = {
+      model: this.model.modelName,
+      op: this.op,
+      filter,
+      update,
+      options,
+      mongooseOptions,
+      _path: this._path,
+      _fields: this._fields,
+      _distinct: this._distinct,
+      _conditions: this._conditions
+    }
+
+    return getKey(data)
+  }
+
+  // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+  mongoose.Query.prototype.getCacheTTL = function () {
+    return this._ttl
+  }
+
+  // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+  mongoose.Query.prototype.cache = function (ttl?: string, customKey?: string) {
+    this._ttl = ttl
+    this._key = customKey
+    return this
+  }
+
+  // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+  mongoose.Query.prototype.exec = async function () {
+    if (!_.has(this, '_ttl')) {
+      return mongooseExec.apply(this)
+    }
+
+    const key = this.getCacheKey()
+    const ttl = this.getCacheTTL()
+
+    const model = this.model.modelName
+
+    const resultCache = await cache.get(key).catch((err) => {
+      console.error(err)
+    })
+
+    if (resultCache) {
+      const constructor = mongoose.model(model)
+      if (_.isArray(resultCache)) {
+        return resultCache.map((item) => constructor.hydrate(item) as Record<string, unknown>)
+      } else {
+        return constructor.hydrate(resultCache) as Record<string, unknown>
+      }
+    }
+
+    const result = await mongooseExec.call(this) as Record<string, unknown>[] | Record<string, unknown>
+    cache.set(key, result, ttl).catch((err) => {
+      console.error(err)
+    })
+
+    return result
+  }
+}

package/src/plugin.ts

@@ -1,9 +1,10 @@
-import _ from 'lodash'
 import Cache from './cache/Cache'
 
 import type { Mongoose } from 'mongoose'
 import type ICacheOptions from './interfaces/ICacheOptions'
-import { getKey } from './crypto'
+
+import extendQuery from './extend/query'
+import extendAggregate from './extend/aggregate'
 
 declare module 'mongoose' {
   interface Query<ResultType, DocType, THelpers, RawDocType> {
@@ -13,9 +14,18 @@ declare module 'mongoose' {
     _ttl?: string
     getCacheTTL: (this: Query<ResultType, DocType, THelpers, RawDocType>) => string | undefined
     op?: string
-    _fields?: unknown
     _path?: unknown
+    _fields?: unknown
     _distinct?: unknown
+    _conditions?: unknown
+  }
+
+  interface Aggregate<ResultType> {
+    cache: (this: Aggregate<ResultType>, ttl?: string, customKey?: string) => this
+    _key?: string
+    getCacheKey: (this: Aggregate<ResultType>) => string
+    _ttl?: string
+    getCacheTTL: (this: Aggregate<ResultType>) => string | undefined
   }
 }
 
@@ -23,105 +33,36 @@ class CacheMongoose {
   // eslint-disable-next-line no-use-before-define
   private static instance: CacheMongoose | undefined
   private cache!: Cache
-  private cacheOptions!: ICacheOptions
 
   private constructor () {
     // Private constructor to prevent external instantiation
   }
 
-  // eslint-disable-next-line sonarjs/cognitive-complexity
   public static init (mongoose: Mongoose, cacheOptions: ICacheOptions): CacheMongoose {
     if (typeof mongoose.Model.hydrate !== 'function') throw new Error('Cache is only compatible with versions of mongoose that implement the `model.hydrate` method')
     if (!this.instance) {
       this.instance = new CacheMongoose()
       this.instance.cache = new Cache(cacheOptions)
-      this.instance.cacheOptions = cacheOptions
 
       const cache = this.instance.cache
 
-      // eslint-disable-next-line @typescript-eslint/unbound-method
-      const mongooseExec = mongoose.Query.prototype.exec
-
-      // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
-      mongoose.Query.prototype.getCacheKey = function () {
-        if (this._key) return this._key
-
-        const filter = this.getFilter()
-        const update = this.getUpdate()
-        const options = this.getOptions()
-
-        const data: Record<string, unknown> = {
-          model: this.model.modelName,
-          op: this.op,
-          filter,
-          update,
-          skip: options.skip,
-          limit: options.limit,
-          sort: options.sort,
-          _fields: this._fields,
-          _path: this._path,
-          _distinct: this._distinct
-        }
-
-        return getKey(data)
-      }
-
-      // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
-      mongoose.Query.prototype.getCacheTTL = function () {
-        return this._ttl
-      }
-
-      // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
-      mongoose.Query.prototype.cache = function (ttl?: string, customKey?: string) {
-        this._ttl = ttl
-        this._key = customKey
-        return this
-      }
-
-      // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
-      mongoose.Query.prototype.exec = async function () {
-        if (!this._ttl) {
-          return mongooseExec.apply(this)
-        }
-
-        const key = this.getCacheKey()
-        const ttl = this.getCacheTTL()
-
-        const model = this.model.modelName
-
-        const resultCache = await cache.get(key)
-        if (resultCache) {
-          const constructor = mongoose.model(model)
-          if (_.isArray(resultCache)) {
-            return resultCache.map((item) => constructor.hydrate(item) as Record<string, unknown>)
-          } else {
-            return constructor.hydrate(resultCache) as Record<string, unknown>
-          }
-        }
-
-        const result = await mongooseExec.call(this) as Record<string, unknown>[] | Record<string, unknown>
-        cache.set(key, result, ttl).catch((err) => {
-          console.error(err)
-        })
-
-        return result
-      }
+      extendQuery(mongoose, cache)
+      extendAggregate(mongoose, cache)
     }
 
     return this.instance
   }
 
   public async clear (customKey?: string): Promise<void> {
-    if (!customKey) {
-      return this.cache.clear()
+    if (customKey) {
+      await this.cache.del(customKey)
+    } else {
+      await this.cache.clear()
     }
-    return this.cache.del(customKey)
   }
 
   public async close (): Promise<void> {
-    if (this.cacheOptions.engine === 'redis') {
-      await this.cache.close()
-    }
+    await this.cache.close()
   }
 }
 

package/tests/cache-memory.test.ts

@@ -0,0 +1,118 @@
+import mongoose, { model } from 'mongoose'
+import CacheMongoose from '../src/plugin'
+
+import UserSchema from './schemas/UserSchema'
+
+describe('CacheMongoose', () => {
+  const uri = `${globalThis.__MONGO_URI__}${globalThis.__MONGO_DB_NAME__}`
+  const User = model('User', UserSchema)
+
+  const cache = CacheMongoose.init(mongoose, {
+    engine: 'memory'
+  })
+
+  beforeAll(async () => {
+    await mongoose.connect(uri)
+  })
+
+  afterAll(async () => {
+    await mongoose.connection.close()
+    await cache.close()
+  })
+
+  beforeEach(async () => {
+    await mongoose.connection.collection('users').deleteMany({})
+  })
+
+  describe('memory scenarios', () => {
+    it('should use memory cache', async () => {
+      const user = await User.create({
+        name: 'John Doe',
+        role: 'admin'
+      })
+
+      const user1 = await User.findById(user._id).cache()
+      await User.findOneAndUpdate({ _id: user._id }, { name: 'John Doe 2' })
+      const user2 = await User.findById(user._id).cache()
+
+      expect(user1).not.toBeNull()
+      expect(user2).not.toBeNull()
+      expect(user1?._id).toEqual(user2?._id)
+      expect(user1?.name).toEqual(user2?.name)
+    })
+
+    it('should not use cache', async () => {
+      const user = await User.create({
+        name: 'John Doe',
+        role: 'admin'
+      })
+
+      const cache1 = await User.findById(user._id).cache().exec()
+      await User.findByIdAndUpdate(user._id, { name: 'John Doe 2' })
+      await cache.clear()
+      const cache2 = await User.findById(user._id).cache().exec()
+
+      expect(cache1).not.toBeNull()
+      expect(cache2).not.toBeNull()
+      expect(cache1?._id).toEqual(cache2?._id)
+      expect(cache1?.name).not.toEqual(cache2?.name)
+    })
+
+    it('should use memory cache with custom key', async () => {
+      const user = await User.create({
+        name: 'John Doe',
+        role: 'admin'
+      })
+
+      const cache1 = await User.findById(user._id).cache('1 minute', 'test-custom-key').exec()
+      await User.findOneAndUpdate({ _id: user._id }, { name: 'John Doe 2' })
+      const cache2 = await User.findById(user._id).cache('1 minute', 'test-custom-key').exec()
+
+      expect(cache1).not.toBeNull()
+      expect(cache2).not.toBeNull()
+      expect(cache1?._id).toEqual(cache2?._id)
+      expect(cache1?.name).toEqual(cache2?.name)
+    })
+
+    it('should use memory cache and clear custom key', async () => {
+      const user = await User.create({
+        name: 'John Doe',
+        role: 'admin'
+      })
+
+      const cache1 = await User.findById(user._id).cache('1 minute', 'test-custom-key-second').exec()
+      await User.updateOne({ _id: user._id }, { name: 'John Doe 2' })
+      await cache.clear('test-custom-key-second')
+      const cache2 = await User.findById(user._id).cache('1 minute', 'test-custom-key-second').exec()
+
+      expect(cache1).not.toBeNull()
+      expect(cache2).not.toBeNull()
+      expect(cache1?._id).toEqual(cache2?._id)
+      expect(cache1?.name).not.toEqual(cache2?.name)
+    })
+
+    it('should use memory cache and aggregate', async () => {
+      await User.create([
+        { name: 'John', role: 'admin' },
+        { name: 'Bob', role: 'admin' },
+        { name: 'Alice', role: 'user' }
+      ])
+
+      const cache1 = await User.aggregate([
+        { $match: { role: 'admin' } },
+        { $group: { _id: '$role', count: { $sum: 1 } } }
+      ]).cache()
+
+      await User.create({ name: 'Mark', role: 'admin' })
+
+      const cache2 = await User.aggregate([
+        { $match: { role: 'admin' } },
+        { $group: { _id: '$role', count: { $sum: 1 } } }
+      ]).cache()
+
+      expect(cache1).not.toBeNull()
+      expect(cache2).not.toBeNull()
+      expect(cache1?.[0].count).toEqual(cache2?.[0].count)
+    })
+  })
+})

package/tests/{cache.test.ts → cache-redis.test.ts}

@@ -1,21 +1,28 @@
 import mongoose, { model } from 'mongoose'
 import CacheMongoose from '../src/plugin'
 
-import type ICacheOptions from '../src/interfaces/ICacheOptions'
-
 import UserSchema from './schemas/UserSchema'
 
-describe('CacheMongoose', () => {
+describe('cache redis', () => {
   const uri = `${globalThis.__MONGO_URI__}${globalThis.__MONGO_DB_NAME__}`
-
   const User = model('User', UserSchema)
 
+  const cache = CacheMongoose.init(mongoose, {
+    engine: 'redis',
+    engineOptions: {
+      host: 'localhost',
+      port: 6379
+    },
+    defaultTTL: '6 minutes'
+  })
+
   beforeAll(async () => {
     await mongoose.connect(uri)
   })
 
   afterAll(async () => {
     await mongoose.connection.close()
+    await cache.close()
   })
 
   beforeEach(async () => {
@@ -23,12 +30,6 @@ describe('CacheMongoose', () => {
   })
 
   describe('memory scenarios', () => {
-    const cacheOptions: ICacheOptions = {
-      engine: 'memory'
-    }
-
-    const cache = CacheMongoose.init(mongoose, cacheOptions)
-
     it('should use memory cache', async () => {
       const user = await User.create({
         name: 'John Doe',
@@ -36,23 +37,23 @@ describe('CacheMongoose', () => {
       })
 
       const user1 = await User.findById(user._id).cache()
-      await User.updateOne({ _id: user._id }, { name: 'John Doe 2' })
+      await User.findOneAndUpdate({ _id: user._id }, { name: 'John Doe 2' })
       const user2 = await User.findById(user._id).cache()
 
       expect(user1).not.toBeNull()
       expect(user2).not.toBeNull()
       expect(user1?._id).toEqual(user2?._id)
-      expect(user1?.name).not.toEqual(user2?.name)
+      expect(user1?.name).toEqual(user2?.name)
     })
 
-    it('should not use memory cache', async () => {
+    it('should not use cache', async () => {
       const user = await User.create({
         name: 'John Doe',
         role: 'admin'
       })
 
       const cache1 = await User.findById(user._id).cache().exec()
-      await User.updateOne({ _id: user._id }, { name: 'John Doe 2' })
+      await User.findByIdAndUpdate(user._id, { name: 'John Doe 2' })
       await cache.clear()
       const cache2 = await User.findById(user._id).cache().exec()
 
@@ -69,7 +70,7 @@ describe('CacheMongoose', () => {
       })
 
       const cache1 = await User.findById(user._id).cache('1 minute', 'test-custom-key').exec()
-      await User.updateOne({ _id: user._id }, { name: 'John Doe 2' })
+      await User.findOneAndUpdate({ _id: user._id }, { name: 'John Doe 2' })
       const cache2 = await User.findById(user._id).cache('1 minute', 'test-custom-key').exec()
 
       expect(cache1).not.toBeNull()
@@ -97,16 +98,6 @@ describe('CacheMongoose', () => {
   })
 
   it('should use redis cache', async () => {
-    const cacheOptions: ICacheOptions = {
-      engine: 'redis',
-      engineOptions: {
-        host: 'localhost',
-        port: 6379
-      },
-      defaultTTL: '6 minutes'
-    }
-
-    const cache = CacheMongoose.init(mongoose, cacheOptions)
     expect(cache).toBeDefined()
 
     const user = await User.create({
@@ -121,7 +112,7 @@ describe('CacheMongoose', () => {
     expect(cache1).not.toBeNull()
     expect(cache2).not.toBeNull()
     expect(cache1?._id).toEqual(cache2?._id)
-    expect(cache1?.name).not.toEqual(cache2?.name)
+    expect(cache1?.name).toEqual(cache2?.name)
 
     await User.create([
       {
@@ -141,8 +132,30 @@ describe('CacheMongoose', () => {
     expect(cache3).not.toBeNull()
     expect(cache4).not.toBeNull()
     expect(cache3?.length).toEqual(cache4?.length)
-    expect(cache3?.[0].name).not.toEqual(cache4?.[0].name)
+    expect(cache3?.[0].name).toEqual(cache4?.[0].name)
+  })
+
+  it('should use redis cache and aggregate', async () => {
+    await User.create([
+      { name: 'John', role: 'admin' },
+      { name: 'Bob', role: 'admin' },
+      { name: 'Alice', role: 'user' }
+    ])
 
-    cache.close()
+    const cache1 = await User.aggregate([
+      { $match: { role: 'admin' } },
+      { $group: { _id: '$role', count: { $sum: 1 } } }
+    ]).cache('1 minute')
+
+    await User.create({ name: 'Mark', role: 'admin' })
+
+    const cache2 = await User.aggregate([
+      { $match: { role: 'admin' } },
+      { $group: { _id: '$role', count: { $sum: 1 } } }
+    ]).cache('1 minute')
+
+    expect(cache1).not.toBeNull()
+    expect(cache2).not.toBeNull()
+    expect(cache1?.[0].count).toEqual(cache2?.[0].count)
   })
 })