ts-cache-mongoose 2.1.0 → 2.2.1

package/tests/cache-debug.test.ts

@@ -1,73 +0,0 @@
-import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, vi } from 'vitest'
-
-import mongoose from 'mongoose'
-import CacheMongoose from '../src/index'
-import { UserModel } from './models/User'
-import { server } from './mongo/server'
-
-describe('cache-debug', async () => {
-  const instance = server('cache-debug')
-  let cache: CacheMongoose
-
-  beforeAll(async () => {
-    cache = CacheMongoose.init(mongoose, {
-      engine: 'memory',
-      debug: true,
-    })
-
-    await instance.create()
-  })
-
-  afterAll(async () => {
-    await cache.clear()
-    await cache.close()
-    await instance.destroy()
-  })
-
-  beforeEach(async () => {
-    vi.spyOn(global.console, 'log')
-    await mongoose.connection.collection('users').deleteMany({})
-  })
-
-  afterEach(async () => {
-    vi.restoreAllMocks()
-  })
-
-  describe('debug scenarios', () => {
-    it('should create a use and and query it two time first is cache miss second is hit, also clear by key and global', async () => {
-      const user = await UserModel.create({
-        name: 'John Doe',
-        role: 'admin',
-      })
-
-      const key = 'key'
-      const ttl = '1 second'
-      const cacheMissRegExp = /\[ts-cache-mongoose\] GET '.*?' - MISS/
-      const cacheHitRegExp = /\[ts-cache-mongoose\] GET '.*?' - HIT/
-      const cacheSetRegExp = /\[ts-cache-mongoose\] SET '.*?' - ttl: \d+ ms/
-      const cacheClearRegExp = /\[ts-cache-mongoose\] CLEAR/
-      const cacheDelRegExp = /\[ts-cache-mongoose\] DEL '.*?'/
-
-      const userCacheMiss = await UserModel.findById(user._id).cache(ttl, key).exec()
-      expect(console.log).toHaveBeenCalledWith(expect.stringMatching(cacheMissRegExp))
-      expect(userCacheMiss).not.toBeNull()
-      expect(userCacheMiss?._id.toString()).toBe(user._id.toString())
-      expect(userCacheMiss?.name).toEqual(user.name)
-      expect(userCacheMiss?.role).toEqual(user.role)
-
-      const userCacheHit = await UserModel.findById(user._id).cache(ttl, key).exec()
-      expect(console.log).toHaveBeenCalledWith(expect.stringMatching(cacheSetRegExp))
-      expect(console.log).toHaveBeenCalledWith(expect.stringMatching(cacheHitRegExp))
-      expect(userCacheHit).not.toBeNull()
-      expect(userCacheHit?._id.toString()).toBe(user._id.toString())
-      expect(userCacheHit?.name).toEqual(user.name)
-      expect(userCacheHit?.role).toEqual(user.role)
-
-      await cache.clear(key)
-      expect(console.log).toHaveBeenCalledWith(expect.stringMatching(cacheDelRegExp))
-
-      await cache.clear()
-      expect(console.log).toHaveBeenCalledWith(expect.stringMatching(cacheClearRegExp))
-    })
-  })
-})

package/tests/cache-memory.test.ts

@@ -1,217 +0,0 @@
-import { afterAll, beforeAll, beforeEach, describe, expect, it } from 'vitest'
-
-import mongoose from 'mongoose'
-import CacheMongoose from '../src/index'
-import { UserModel } from './models/User'
-import { server } from './mongo/server'
-
-describe('cache-memory', async () => {
-  const instance = server('cache-memory')
-  let cache: CacheMongoose
-
-  beforeAll(async () => {
-    cache = CacheMongoose.init(mongoose, {
-      engine: 'memory',
-    })
-
-    await instance.create()
-  })
-
-  afterAll(async () => {
-    await cache.clear()
-    await cache.close()
-    await instance.destroy()
-  })
-
-  beforeEach(async () => {
-    await mongoose.connection.collection('users').deleteMany({})
-  })
-
-  describe('memory scenarios', () => {
-    it('should use memory cache', async () => {
-      const user = await UserModel.create({
-        name: 'John Doe',
-        role: 'admin',
-      })
-
-      const user1 = await UserModel.findById(user._id).cache().exec()
-      await UserModel.findOneAndUpdate({ _id: user._id }, { name: 'John Doe 2' }).exec()
-      const user2 = await UserModel.findById(user._id).cache().exec()
-
-      expect(user1).not.toBeNull()
-      expect(user2).not.toBeNull()
-      expect(user1?._id.toString()).toBe(user2?._id.toString())
-      expect(user1?.name).toEqual(user2?.name)
-    })
-
-    it('should not use cache', async () => {
-      const user = await UserModel.create({
-        name: 'John Doe',
-        role: 'admin',
-      })
-
-      const cache1 = await UserModel.findById(user._id).cache().exec()
-      await UserModel.findByIdAndUpdate(user._id, { name: 'John Doe 2' }).exec()
-      await cache.clear()
-      const cache2 = await UserModel.findById(user._id).cache().exec()
-
-      expect(cache1).not.toBeNull()
-      expect(cache2).not.toBeNull()
-      expect(cache1?._id.toString()).toBe(cache2?._id.toString())
-      expect(cache1?.name).not.toEqual(cache2?.name)
-    })
-
-    it('should use memory cache with custom key', async () => {
-      const user = await UserModel.create({
-        name: 'John Doe',
-        role: 'admin',
-      })
-
-      const cache1 = await UserModel.findById(user._id).cache('1 minute', 'test-custom-key').exec()
-      await UserModel.findOneAndUpdate({ _id: user._id }, { name: 'John Doe 2' }).exec()
-      const cache2 = await UserModel.findById(user._id).cache('1 minute', 'test-custom-key').exec()
-
-      expect(cache1).not.toBeNull()
-      expect(cache2).not.toBeNull()
-      expect(cache1?._id.toString()).toBe(cache2?._id.toString())
-      expect(cache1?.name).toEqual(cache2?.name)
-    })
-
-    it('should use memory cache and clear custom key', async () => {
-      const user = await UserModel.create({
-        name: 'John Doe',
-        role: 'admin',
-      })
-
-      const cache1 = await UserModel.findById(user._id).cache('1 minute', 'test-custom-key-second').exec()
-      await UserModel.updateOne({ _id: user._id }, { name: 'John Doe 2' }).exec()
-      await cache.clear('test-custom-key-second')
-      const cache2 = await UserModel.findById(user._id).cache('1 minute', 'test-custom-key-second').exec()
-
-      expect(cache1).not.toBeNull()
-      expect(cache2).not.toBeNull()
-      expect(cache1?._id.toString()).toBe(cache2?._id.toString())
-      expect(cache1?.name).not.toEqual(cache2?.name)
-    })
-
-    it('should use memory cache and custom key with an empty string', async () => {
-      const user = await UserModel.create({
-        name: 'John Doe',
-        role: 'admin',
-      })
-
-      const cache1 = await UserModel.findById(user._id).cache('1 minute', '').exec()
-      await UserModel.updateOne({ _id: user._id }, { name: 'John Doe 2' }).exec()
-      const cache2 = await UserModel.findById(user._id).cache('1 minute', '').exec()
-
-      expect(cache1).not.toBeNull()
-      expect(cache2).not.toBeNull()
-      expect(cache1?._id.toString()).toBe(cache2?._id.toString())
-      expect(cache1?.name).toEqual(cache2?.name)
-
-      await cache.clear('')
-      const cache3 = await UserModel.findById(user._id).cache('1 minute', '').exec()
-      expect(cache3).not.toBeNull()
-      expect(cache2?._id.toString()).toBe(cache3?._id.toString())
-      expect(cache2?.name).not.toEqual(cache3?.name)
-    })
-
-    it('should use memory cache and aggregate', async () => {
-      await UserModel.create([
-        { name: 'John', role: 'admin' },
-        { name: 'Bob', role: 'admin' },
-        { name: 'Alice', role: 'user' },
-      ])
-
-      const cache1 = await UserModel.aggregate([{ $match: { role: 'admin' } }, { $group: { _id: '$role', count: { $sum: 1 } } }])
-        .cache()
-        .exec()
-
-      await UserModel.create({ name: 'Mark', role: 'admin' })
-
-      const cache2 = await UserModel.aggregate([{ $match: { role: 'admin' } }, { $group: { _id: '$role', count: { $sum: 1 } } }])
-        .cache()
-        .exec()
-
-      expect(cache1).not.toBeNull()
-      expect(cache2).not.toBeNull()
-      expect(cache1?.[0].count).toEqual(cache2?.[0].count)
-    })
-  })
-
-  describe('memory scenarios with ttl', () => {
-    const users = [
-      { name: 'John', age: 30, role: 'admin' },
-      { name: 'Alice', age: 25, role: 'user' },
-      { name: 'Bob', age: 35, role: 'user' },
-    ]
-
-    beforeEach(async () => {
-      // Delete all users before each test
-      await UserModel.deleteMany().exec()
-
-      // Create new users
-      await UserModel.create(users)
-    })
-
-    it('findById', async () => {
-      const john = await UserModel.create({ name: 'John', age: 30, role: 'admin' })
-      const user = await UserModel.findById(john._id).cache('1 minute').exec()
-      const cachedUser = await UserModel.findById(john._id).cache('1 minute').exec()
-
-      expect(user?._id.toString()).toBe(cachedUser?._id.toString())
-      expect(user?.name).toEqual(cachedUser?.name)
-      expect(user?.createdAt).toEqual(cachedUser?.createdAt)
-      expect(user?.updatedAt).toEqual(cachedUser?.updatedAt)
-    })
-
-    it('findOne', async () => {
-      const user = await UserModel.findOne({ name: 'John', age: 30, role: 'admin' }).cache('1 minute').exec()
-      await UserModel.create({ name: 'Steve', age: 30, role: 'admin' })
-      const cachedUser = await UserModel.findOne({
-        name: 'John',
-        age: 30,
-        role: 'admin',
-      })
-        .cache('1 minute')
-        .exec()
-
-      expect(user?._id.toString()).toBe(cachedUser?._id.toString())
-      expect(user?.name).toEqual(cachedUser?.name)
-      expect(user?.createdAt).toEqual(cachedUser?.createdAt)
-      expect(user?.updatedAt).toEqual(cachedUser?.updatedAt)
-    })
-
-    it('find', async () => {
-      const users = await UserModel.find({ age: { $gte: 30 } })
-        .cache('1 minute')
-        .exec()
-      await UserModel.create({ name: 'Steve', age: 30, role: 'admin' })
-      const cachedUsers = await UserModel.find({ age: { $gte: 30 } })
-        .cache('1 minute')
-        .exec()
-
-      expect(users).toHaveLength(cachedUsers.length)
-    })
-
-    it('count', async () => {
-      const count = await UserModel.countDocuments({ age: { $gte: 30 } })
-        .cache('1 minute')
-        .exec()
-      await UserModel.create({ name: 'Steve', age: 30, role: 'admin' })
-      const cachedCount = await UserModel.countDocuments({ age: { $gte: 30 } })
-        .cache('1 minute')
-        .exec()
-
-      expect(count).toEqual(cachedCount)
-    })
-
-    it('distinct', async () => {
-      const emails = await UserModel.distinct('name').cache('1 minute').exec()
-      await UserModel.create({ name: 'Steve', age: 30, role: 'admin' })
-      const cachedEmails = await UserModel.distinct('name').cache('1 minute').exec()
-
-      expect(emails).toEqual(cachedEmails)
-    })
-  })
-})

package/tests/cache-options.test.ts

@@ -1,83 +0,0 @@
-import { describe, expect, it, vi } from 'vitest'
-
-import { Cache } from '../src/cache/Cache'
-
-import type { CacheOptions } from '../src/types'
-
-describe('Cache class tests', () => {
-  it('should create a new instance of Cache', () => {
-    const cacheOptions: CacheOptions = {
-      engine: 'memory',
-    }
-
-    const cache = new Cache(cacheOptions)
-    expect(cache).toBeInstanceOf(Cache)
-    expect(cache).toHaveProperty('get')
-    expect(cache).toHaveProperty('set')
-    expect(cache).toHaveProperty('del')
-    expect(cache).toHaveProperty('clear')
-    expect(cache).toHaveProperty('close')
-  })
-
-  it('should throw an error if the cache engine is not supported', () => {
-    const cacheOptions: CacheOptions = {
-      // @ts-expect-error Testing invalid engine name
-      engine: 'not-supported',
-    }
-
-    expect(() => new Cache(cacheOptions)).toThrow(`Invalid engine name: ${cacheOptions.engine}`)
-  })
-
-  it('should throw an error if the cache engine is redis and no engine options are provided', () => {
-    const cacheOptions: CacheOptions = {
-      engine: 'redis',
-    }
-
-    expect(() => new Cache(cacheOptions)).toThrow(`Engine options are required for ${cacheOptions.engine} engine`)
-  })
-
-  it('should create a new instance of Cache with redis engine', async () => {
-    const cacheOptions: CacheOptions = {
-      engine: 'redis',
-      engineOptions: {
-        host: 'localhost',
-        port: 6379,
-      },
-      defaultTTL: '10 minutes',
-    }
-
-    const cache = new Cache(cacheOptions)
-    expect(cache).toBeInstanceOf(Cache)
-    expect(cache).toHaveProperty('get')
-    expect(cache).toHaveProperty('set')
-    expect(cache).toHaveProperty('del')
-    expect(cache).toHaveProperty('clear')
-    expect(cache).toHaveProperty('close')
-
-    await cache.set('bob', { test: 'bob' }, null)
-    await cache.set('john', { test: 'john' }, '1 minute')
-
-    const value = await cache.get('bob')
-    expect(value).toEqual({ test: 'bob' })
-
-    await cache.del('bob')
-    const clearBob = await cache.get('bob')
-    expect(clearBob).toBeUndefined()
-
-    const john = await cache.get('john')
-    expect(john).toEqual({ test: 'john' })
-
-    await cache.clear()
-    const clearJohn = await cache.get('john')
-    expect(clearJohn).toBeUndefined()
-
-    const mockSet = vi.fn()
-    cache.set = mockSet
-
-    await cache.set('bob', { test: 'bob' }, null)
-    expect(mockSet).toHaveBeenCalled()
-    expect(mockSet).toHaveBeenCalledWith('bob', { test: 'bob' }, null)
-
-    await cache.close()
-  })
-})