ts-cache-mongoose 0.0.1

package/src/plugin.ts

@@ -0,0 +1,122 @@
+import _ from 'lodash'
+import ms from 'ms'
+import Cache from './cache/Cache'
+
+import type { Mongoose } from 'mongoose'
+import type ICacheMongooseOptions from './interfaces/ICacheMongooseOptions'
+import { getKey } from './crypto'
+
+declare module 'mongoose' {
+  interface Query<ResultType, DocType, THelpers, RawDocType> {
+    cache: (this: Query<ResultType, DocType, THelpers, RawDocType>, ttl?: string) => this
+    _key?: string
+    getCacheKey: (this: Query<ResultType, DocType, THelpers, RawDocType>) => string
+    _ttl: number
+    getCacheTTL: (this: Query<ResultType, DocType, THelpers, RawDocType>) => number
+    op?: string
+    _fields?: unknown
+    _path?: unknown
+    _distinct?: unknown
+  }
+}
+
+class CacheMongoose {
+  // eslint-disable-next-line no-use-before-define
+  private static instance: CacheMongoose | undefined
+  private cache!: Cache
+
+  private constructor () {
+    // Private constructor to prevent external instantiation
+  }
+
+  // eslint-disable-next-line sonarjs/cognitive-complexity
+  public static init (mongoose: Mongoose, cacheMongooseOptions: ICacheMongooseOptions): 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(cacheMongooseOptions.engine, cacheMongooseOptions.defaultTTL = '1 minute')
+
+      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 = ms(ttl ?? '1 minute')
+        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)
+        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
+      }
+    }
+
+    return this.instance
+  }
+
+  public async clearCache (customKey: string): Promise<void> {
+    if (!customKey) {
+      await this.cache.clear()
+      return
+    }
+    await this.cache.del(customKey)
+  }
+}
+
+export default CacheMongoose

package/tests/cache.test.ts

@@ -0,0 +1,51 @@
+import mongoose, { model } from 'mongoose'
+import CacheMongoose from '../src/plugin'
+
+import type ICacheOptions from '../src/interfaces/ICacheMongooseOptions'
+
+import UserSchema from './schemas/UserSchema'
+
+const cacheOptions: ICacheOptions = {
+  engine: 'memory'
+}
+
+describe('CacheMongoose', () => {
+  const uri = `${globalThis.__MONGO_URI__}${globalThis.__MONGO_DB_NAME__}`
+
+  const User = model('User', UserSchema)
+
+  beforeAll(async () => {
+    await mongoose.connect(uri)
+  })
+
+  afterAll(async () => {
+    await mongoose.connection.close()
+  })
+
+  beforeEach(async () => {
+    await mongoose.connection.collection('users').deleteMany({})
+  })
+
+  it('should be defined', async () => {
+    const cache = CacheMongoose.init(mongoose, cacheOptions)
+    expect(cache).toBeDefined()
+
+    const user = await User.create({
+      name: 'John Doe',
+      role: 'admin'
+    })
+
+    const cachedUser1 = await User.findById(user._id).cache().lean()
+    console.log(cachedUser1)
+
+    await User.updateOne({ _id: user._id }, { name: 'John Doe 2' })
+
+    const cachedUser2 = await User.findById(user._id).cache()
+    console.log(cachedUser2)
+
+    expect(cachedUser1).not.toBeNull()
+    expect(cachedUser2).not.toBeNull()
+    expect(cachedUser1?._id).toEqual(cachedUser2?._id)
+    expect(cachedUser1?.name).toEqual(cachedUser2?.name)
+  })
+})

package/tests/crypto.test.ts

@@ -0,0 +1,60 @@
+import { getKey } from '../src/crypto'
+
+describe('generateHash()', () => {
+  const data1 = {
+    foo: 42,
+    bar: {
+      baz: [3, 2, 1],
+      qux: 'hello',
+      wow: {
+        word: 'world',
+        hey: {
+          waldo: true,
+          fred: null,
+          missing: undefined
+        }
+      }
+    }
+  }
+
+  const data2 = {
+    bar: {
+      baz: [1, 2, 3],
+      wow: {
+        hey: {
+          fred: null,
+          missing: undefined,
+          waldo: true
+        },
+        word: 'world'
+      },
+      qux: 'hello'
+    },
+    foo: 42
+  }
+
+  const data3 = {
+    bar: {
+      qux: 'hello',
+      baz: [3, 2, 1],
+      wow: {
+        hey: {
+          fred: null,
+          waldo: true,
+          missing: undefined
+        },
+        word: 'world'
+      }
+    },
+    foo: 42
+  }
+
+  it('should generate hash keys for objects with different key orders', () => {
+    const hash1 = getKey(data1)
+    const hash2 = getKey(data2)
+    const hash3 = getKey(data3)
+
+    expect(hash1).not.toEqual(hash2)
+    expect(hash1).toEqual(hash3)
+  })
+})

package/tests/interfaces/IUser.ts

@@ -0,0 +1,8 @@
+interface IUser {
+  name: string
+  role: string
+  createdAt?: Date
+  updatedAt?: Date
+}
+
+export default IUser

package/tests/schemas/UserSchema.ts

@@ -0,0 +1,16 @@
+import { Schema } from 'mongoose'
+
+import type IUser from '../interfaces/IUser'
+
+const UserSchema = new Schema<IUser>({
+  name: {
+    type: String,
+    required: true
+  },
+  role: {
+    type: String,
+    required: true
+  }
+}, { timestamps: true })
+
+export default UserSchema

package/tsconfig.json

@@ -0,0 +1,44 @@
+{
+  "compilerOptions": {
+    "target": "es2021",
+    "lib": [
+      "es2021"
+    ],
+    "module": "commonjs",
+    "moduleResolution": "node",
+    "outDir": "dist",
+    "strict": true,
+    "strictBindCallApply": true,
+    "strictFunctionTypes": true,
+    "strictNullChecks": true, 
+    "strictPropertyInitialization": true,    
+    "noEmitOnError": true,
+    "noFallthroughCasesInSwitch": true,
+    "noImplicitAny": true,
+    "noImplicitOverride": true,
+    "noImplicitUseStrict": false,
+    "noImplicitReturns": true,
+    "noImplicitThis": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "allowSyntheticDefaultImports": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "forceConsistentCasingInFileNames": true,
+    "esModuleInterop": true,
+    "importHelpers": true,
+    "removeComments": true
+  },
+  "include": [
+    "src/**/*"
+  ],
+  "exclude": [
+    "dist",
+    "tools",
+    "node_modules"
+  ],
+  "ts-node": {
+    "swc": true
+  }
+}