ts-cache-mongoose 1.7.7 → 2.1.0

package/src/ms.ts

@@ -0,0 +1,66 @@
+const s = 1000
+const m = s * 60
+const h = m * 60
+const d = h * 24
+const w = d * 7
+const y = d * 365.25
+const mo = y / 12
+
+export const UNITS = {
+  milliseconds: 1,
+  millisecond: 1,
+  msecs: 1,
+  msec: 1,
+  ms: 1,
+  seconds: s,
+  second: s,
+  secs: s,
+  sec: s,
+  s,
+  minutes: m,
+  minute: m,
+  mins: m,
+  min: m,
+  m,
+  hours: h,
+  hour: h,
+  hrs: h,
+  hr: h,
+  h,
+  days: d,
+  day: d,
+  d,
+  weeks: w,
+  week: w,
+  w,
+  months: mo,
+  month: mo,
+  mo,
+  years: y,
+  year: y,
+  yrs: y,
+  yr: y,
+  y,
+} as const satisfies Record<string, number>
+
+export type Unit = keyof typeof UNITS
+
+export type Duration = number | `${number}` | `${number}${Unit}` | `${number} ${Unit}`
+
+const unitPattern = Object.keys(UNITS)
+  .sort((a, b) => b.length - a.length)
+  .join('|')
+
+const RE = new RegExp(String.raw`^(-?(?:\d+)?\.?\d+)\s*(${unitPattern})?$`, 'i')
+
+export const ms = (val: Duration): number => {
+  const str = String(val)
+  if (str.length > 100) return Number.NaN
+
+  const match = RE.exec(str)
+  if (!match) return Number.NaN
+
+  const n = Number.parseFloat(match[1] ?? '')
+  const type = (match[2] ?? 'ms').toLowerCase()
+  return n * (UNITS[type as Unit] ?? 0)
+}

package/src/nest/cache.module.ts

@@ -0,0 +1,79 @@
+/** 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

@@ -0,0 +1,37 @@
+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

@@ -0,0 +1,4 @@
+export { CacheModule } from './cache.module'
+export { CACHE_OPTIONS, CacheService } from './cache.service'
+
+export type { CacheModuleAsyncOptions, CacheModuleOptions, CacheOptionsFactory } from './interfaces'

package/src/nest/interfaces.ts

@@ -0,0 +1,17 @@
+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

@@ -0,0 +1,38 @@
+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 +1,20 @@
 import type { RedisOptions } from 'ioredis'
-import type { StringValue } from 'ms'
+import type { Duration } from './ms'
 
-export type CacheTTL = number | StringValue
+export type { Duration } from './ms'
 
 export type CacheData = Record<string, unknown> | Record<string, unknown>[] | unknown[] | number | undefined
 
 export type CacheOptions = {
   engine: 'memory' | 'redis'
   engineOptions?: RedisOptions
-  defaultTTL?: CacheTTL
+  defaultTTL?: Duration
   debug?: boolean
 }
 
 export interface CacheEngine {
   get: (key: string) => Promise<CacheData> | CacheData
-  set: (key: string, value: CacheData, ttl?: CacheTTL) => Promise<void> | void
+  set: (key: string, value: CacheData, ttl?: Duration) => Promise<void> | void
   del: (key: string) => Promise<void> | void
   clear: () => Promise<void> | void
   close: () => Promise<void> | void

package/src/version.ts

@@ -1,9 +1,8 @@
 import mongoose from 'mongoose'
-import { satisfies } from 'semver'
 
 import type { CacheData } from './types'
 
-export const isMongooseLessThan7 = satisfies(mongoose.version, '<7')
+export const isMongooseLessThan7 = Number.parseInt(mongoose.version, 10) < 7
 
 export const convertToObject = <T>(value: (T & { toObject?: () => CacheData }) | undefined): CacheData => {
   if (isMongooseLessThan7) {

package/tests/ms.test.ts

@@ -0,0 +1,113 @@
+import { describe, expect, it } from 'vitest'
+
+import { ms, UNITS } from '../src/ms'
+
+const { s, m, h, d, w, mo, y } = UNITS
+
+describe('ms', () => {
+  it('should parse milliseconds', () => {
+    expect(ms('100ms')).toBe(100)
+    expect(ms('500 milliseconds')).toBe(500)
+    expect(ms('1 millisecond')).toBe(1)
+    expect(ms('200 msec')).toBe(200)
+    expect(ms('300 msecs')).toBe(300)
+  })
+
+  it('should parse seconds', () => {
+    expect(ms('1s')).toBe(s)
+    expect(ms('5 seconds')).toBe(5 * s)
+    expect(ms('30 sec')).toBe(30 * s)
+    expect(ms('1 second')).toBe(s)
+    expect(ms('2 secs')).toBe(2 * s)
+  })
+
+  it('should parse minutes', () => {
+    expect(ms('1m')).toBe(m)
+    expect(ms('5 minutes')).toBe(5 * m)
+    expect(ms('1 minute')).toBe(m)
+    expect(ms('2 min')).toBe(2 * m)
+    expect(ms('3 mins')).toBe(3 * m)
+  })
+
+  it('should parse hours', () => {
+    expect(ms('1h')).toBe(h)
+    expect(ms('2 hours')).toBe(2 * h)
+    expect(ms('1 hour')).toBe(h)
+    expect(ms('3 hr')).toBe(3 * h)
+    expect(ms('4 hrs')).toBe(4 * h)
+  })
+
+  it('should parse days', () => {
+    expect(ms('1d')).toBe(d)
+    expect(ms('2 days')).toBe(2 * d)
+    expect(ms('1 day')).toBe(d)
+  })
+
+  it('should parse weeks', () => {
+    expect(ms('1w')).toBe(w)
+    expect(ms('2 weeks')).toBe(2 * w)
+    expect(ms('1 week')).toBe(w)
+  })
+
+  it('should parse months', () => {
+    expect(ms('1mo')).toBe(mo)
+    expect(ms('1 month')).toBe(mo)
+    expect(ms('2 months')).toBe(2 * mo)
+    expect(ms('6mo')).toBe(6 * mo)
+    expect(ms('0.5mo')).toBe(0.5 * mo)
+  })
+
+  it('should parse years', () => {
+    expect(ms('1y')).toBe(y)
+    expect(ms('1 year')).toBe(y)
+    expect(ms('2 yrs')).toBe(2 * y)
+    expect(ms('1 yr')).toBe(y)
+  })
+
+  it('should parse decimal values', () => {
+    expect(ms('1.5h')).toBe(1.5 * h)
+    expect(ms('0.5d')).toBe(0.5 * d)
+    expect(ms('.5s')).toBe(0.5 * s)
+  })
+
+  it('should parse negative values', () => {
+    expect(ms('-1s')).toBe(-s)
+    expect(ms('-3m')).toBe(-3 * m)
+  })
+
+  it('should default to milliseconds without unit', () => {
+    expect(ms('100')).toBe(100)
+    expect(ms('0')).toBe(0)
+  })
+
+  it('should be case insensitive', () => {
+    // @ts-expect-error runtime check
+    expect(ms('1S')).toBe(s)
+    // @ts-expect-error runtime check
+    expect(ms('1M')).toBe(m)
+    // @ts-expect-error runtime check
+    expect(ms('1H')).toBe(h)
+  })
+
+  it('should return NaN for invalid strings', () => {
+    // @ts-expect-error testing invalid input
+    expect(ms('invalid')).toBeNaN()
+    // @ts-expect-error testing invalid input
+    expect(ms('')).toBeNaN()
+    // @ts-expect-error testing invalid input
+    expect(ms('abc123')).toBeNaN()
+  })
+
+  it('should return NaN for strings longer than 100 characters', () => {
+    // @ts-expect-error testing invalid input
+    expect(ms('a'.repeat(101))).toBeNaN()
+  })
+
+  it('should handle whitespace between number and unit', () => {
+    expect(ms('1 s')).toBe(s)
+    expect(ms('5  minutes')).toBe(5 * m)
+    expect(ms('1 mo')).toBe(mo)
+    expect(ms('1 week')).toBe(w)
+    expect(ms('1 year')).toBe(y)
+  })
+})

package/tests/nest.test.ts

@@ -0,0 +1,158 @@
+import { describe, expect, it, vi } from 'vitest'
+
+import { CacheModule } from '../src/nest/cache.module'
+import { CACHE_OPTIONS, CacheService } from '../src/nest/cache.service'
+
+vi.mock('@nestjs/common', () => {
+  const LoggerMock = class {
+    log = vi.fn()
+  }
+  return {
+    Module: () => () => {},
+    Logger: LoggerMock,
+  }
+})
+
+vi.mock('../src/index', () => ({
+  default: {
+    init: vi.fn().mockReturnValue({
+      clear: vi.fn(),
+      close: vi.fn(),
+    }),
+  },
+}))
+
+const defaultOptions = { engine: 'memory' as const, defaultTTL: '60 seconds' }
+
+describe('CacheModule', () => {
+  describe('forRoot', () => {
+    it('should return a dynamic module with providers', () => {
+      const result = CacheModule.forRoot(defaultOptions)
+      expect(result.module).toBe(CacheModule)
+      expect(result.providers).toBeDefined()
+      expect(result.exports).toContain(CacheService)
+    })
+
+    it('should set global to false by default', () => {
+      const result = CacheModule.forRoot(defaultOptions)
+      expect(result.global).toBe(false)
+    })
+
+    it('should set global when isGlobal is true', () => {
+      const result = CacheModule.forRoot({ ...defaultOptions, isGlobal: true })
+      expect(result.global).toBe(true)
+    })
+
+    it('should provide CACHE_OPTIONS with useValue', () => {
+      const result = CacheModule.forRoot(defaultOptions)
+      const optionsProvider = (result.providers as { provide: symbol; useValue: unknown }[]).find((p) => p.provide === CACHE_OPTIONS)
+      expect(optionsProvider).toBeDefined()
+      expect(optionsProvider?.useValue).toEqual(defaultOptions)
+    })
+  })
+
+  describe('forRootAsync', () => {
+    it('should return a dynamic module with useFactory', () => {
+      const result = CacheModule.forRootAsync({
+        useFactory: () => defaultOptions,
+      })
+      expect(result.module).toBe(CacheModule)
+      expect(result.providers).toBeDefined()
+      expect(result.exports).toContain(CacheService)
+    })
+
+    it('should support useClass', () => {
+      class TestFactory {
+        createCacheOptions() {
+          return defaultOptions
+        }
+      }
+      const result = CacheModule.forRootAsync({ useClass: TestFactory })
+      expect(result.providers).toBeDefined()
+      expect(result.providers?.length).toBeGreaterThan(1)
+    })
+
+    it('should support useExisting', () => {
+      class TestFactory {
+        createCacheOptions() {
+          return defaultOptions
+        }
+      }
+      const result = CacheModule.forRootAsync({ useExisting: TestFactory })
+      expect(result.providers).toBeDefined()
+    })
+
+    it('should return empty providers when no factory method', () => {
+      const result = CacheModule.forRootAsync({})
+      const providers = result.providers as unknown[]
+      const serviceProvider = providers.find((p) => typeof p === 'object' && p !== null && 'provide' in p && (p as { provide: unknown }).provide === CacheService)
+      expect(serviceProvider).toBeDefined()
+    })
+
+    it('should pass imports through', () => {
+      const result = CacheModule.forRootAsync({
+        imports: [],
+        useFactory: () => defaultOptions,
+      })
+      expect(result.imports).toEqual([])
+    })
+
+    it('should set global when isGlobal is true', () => {
+      const result = CacheModule.forRootAsync({
+        isGlobal: true,
+        useFactory: () => defaultOptions,
+      })
+      expect(result.global).toBe(true)
+    })
+  })
+})
+
+describe('CacheService', () => {
+  it('should store options', () => {
+    const service = new CacheService(defaultOptions)
+    expect(service).toBeDefined()
+  })
+
+  it('should initialize cache on bootstrap', async () => {
+    const service = new CacheService(defaultOptions)
+    await service.onApplicationBootstrap()
+    expect(service.instance).toBeDefined()
+  })
+
+  it('should close cache on shutdown', async () => {
+    const service = new CacheService(defaultOptions)
+    await service.onApplicationBootstrap()
+    const closeSpy = vi.spyOn(service.instance, 'close')
+    await service.onApplicationShutdown()
+    expect(closeSpy).toHaveBeenCalled()
+  })
+
+  it('should not throw on shutdown when not initialized', async () => {
+    const service = new CacheService(defaultOptions)
+    await expect(service.onApplicationShutdown()).resolves.not.toThrow()
+  })
+
+  it('should clear cache with custom key', async () => {
+    const service = new CacheService(defaultOptions)
+    await service.onApplicationBootstrap()
+    const clearSpy = vi.spyOn(service.instance, 'clear')
+    await service.clear('test-key')
+    expect(clearSpy).toHaveBeenCalledWith('test-key')
+  })
+
+  it('should clear all cache without key', async () => {
+    const service = new CacheService(defaultOptions)
+    await service.onApplicationBootstrap()
+    const clearSpy = vi.spyOn(service.instance, 'clear')
+    await service.clear()
+    expect(clearSpy).toHaveBeenCalledWith(undefined)
+  })
+
+  it('should expose instance getter', async () => {
+    const service = new CacheService(defaultOptions)
+    await service.onApplicationBootstrap()
+    expect(service.instance).toBeDefined()
+    expect(service.instance.clear).toBeDefined()
+    expect(service.instance.close).toBeDefined()
+  })
+})

package/tests/sort-keys.test.ts

@@ -0,0 +1,80 @@
+import { describe, expect, it } from 'vitest'
+
+import { sortKeys } from '../src/sort-keys'
+
+describe('sortKeys', () => {
+  it('should sort object keys alphabetically', () => {
+    expect(sortKeys({ c: 1, a: 2, b: 3 })).toEqual({ a: 2, b: 3, c: 1 })
+  })
+
+  it('should sort nested objects deeply', () => {
+    expect(sortKeys({ b: { d: 1, c: 2 }, a: 1 })).toEqual({ a: 1, b: { c: 2, d: 1 } })
+  })
+
+  it('should sort arrays of objects', () => {
+    const input = [
+      { b: 1, a: 2 },
+      { d: 3, c: 4 },
+    ]
+    const expected = [
+      { a: 2, b: 1 },
+      { c: 4, d: 3 },
+    ]
+    expect(sortKeys(input)).toEqual(expected)
+  })
+
+  it('should handle nested arrays', () => {
+    const input = { items: [{ z: 1, a: 2 }] }
+    expect(sortKeys(input)).toEqual({ items: [{ a: 2, z: 1 }] })
+  })
+
+  it('should handle nested arrays of arrays', () => {
+    const input = { data: [[{ b: 1, a: 2 }]] }
+    expect(sortKeys(input)).toEqual({ data: [[{ a: 2, b: 1 }]] })
+  })
+
+  it('should preserve non-object values in arrays', () => {
+    const input = { items: [1, 'string', true, null] }
+    expect(sortKeys(input)).toEqual({ items: [1, 'string', true, null] })
+  })
+
+  it('should handle empty objects', () => {
+    expect(sortKeys({})).toEqual({})
+  })
+
+  it('should handle empty arrays', () => {
+    expect(sortKeys([])).toEqual([])
+  })
+
+  it('should handle deeply nested structures', () => {
+    const input = { c: { b: { a: { z: 1, y: 2 } } } }
+    expect(sortKeys(input)).toEqual({ c: { b: { a: { y: 2, z: 1 } } } })
+  })
+
+  it('should not modify non-plain objects', () => {
+    const date = new Date()
+    const input = { b: date, a: 1 }
+    const result = sortKeys(input) as Record<string, unknown>
+    expect(result.a).toBe(1)
+    expect(result.b).toBe(date)
+  })
+
+  it('should handle circular references without infinite loop', () => {
+    const obj: Record<string, unknown> = { a: 1 }
+    obj.self = obj
+    const result = sortKeys(obj)
+    expect(result).toBeDefined()
+  })
+
+  it('should produce deterministic output regardless of input order', () => {
+    const a = sortKeys({ z: 1, a: 2, m: 3 })
+    const b = sortKeys({ a: 2, m: 3, z: 1 })
+    expect(JSON.stringify(a)).toBe(JSON.stringify(b))
+  })
+
+  it('should handle top-level array input', () => {
+    const input = [{ b: 1, a: 2 }] as Record<string, unknown>[]
+    const result = sortKeys(input)
+    expect(result).toEqual([{ a: 2, b: 1 }])
+  })
+})

package/tsconfig.json

@@ -1,8 +1,8 @@
 {
   "include": ["src"],
   "compilerOptions": {
-    "target": "ES2021",
-    "lib": ["ES2021"],
+    "target": "ES2022",
+    "lib": ["ES2022"],
     "types": ["node"],
     "module": "Preserve",
     "moduleResolution": "bundler",
@@ -15,9 +15,9 @@
     "declaration": true,
     "declarationMap": true,
     "esModuleInterop": true,
+    "experimentalDecorators": true,
     "exactOptionalPropertyTypes": true,
     "forceConsistentCasingInFileNames": true,
-    "importHelpers": true,
     "isolatedModules": true,
     "noEmitOnError": true,
     "noFallthroughCasesInSwitch": true,