ts-cache-mongoose 2.0.0 → 2.2.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,20 +0,0 @@
-import type { RedisOptions } from 'ioredis'
-
-export type CacheTTL = number | string
-
-export type CacheData = Record<string, unknown> | Record<string, unknown>[] | unknown[] | number | undefined
-
-export type CacheOptions = {
-  engine: 'memory' | 'redis'
-  engineOptions?: RedisOptions
-  defaultTTL?: CacheTTL
-  debug?: boolean
-}
-
-export interface CacheEngine {
-  get: (key: string) => Promise<CacheData> | CacheData
-  set: (key: string, value: CacheData, ttl?: CacheTTL) => 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
-}

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()
-  })
-})