ts-cache-mongoose 2.0.0 → 2.2.0

package/tests/mongo/server.ts

@@ -1,29 +0,0 @@
-import fs from 'node:fs'
-import { MongoMemoryServer } from 'mongodb-memory-server'
-import mongoose from 'mongoose'
-
-export const server = (dbName: string) => {
-  let mongo: MongoMemoryServer
-  const dbPath = `./tests/mongo/${dbName}`
-
-  const create = async () => {
-    fs.mkdirSync(dbPath, { recursive: true })
-    mongo = await MongoMemoryServer.create({
-      instance: {
-        dbName,
-        dbPath,
-      },
-    })
-
-    const uri = mongo.getUri()
-    await mongoose.connect(uri)
-  }
-
-  const destroy = async () => {
-    await mongoose.connection.dropDatabase()
-    await mongoose.connection.close()
-    await mongo.stop({ doCleanup: true, force: true })
-  }
-
-  return { create, destroy }
-}

package/tests/ms.test.ts

@@ -1,93 +0,0 @@
-import { describe, expect, it } from 'vitest'
-
-import { ms } from '../src/ms'
-
-describe('ms', () => {
-  it('should parse seconds', () => {
-    expect(ms('1s')).toBe(1000)
-    expect(ms('5 seconds')).toBe(5000)
-    expect(ms('30 sec')).toBe(30000)
-    expect(ms('1 second')).toBe(1000)
-    expect(ms('2 secs')).toBe(2000)
-  })
-
-  it('should parse minutes', () => {
-    expect(ms('1m')).toBe(60000)
-    expect(ms('5 minutes')).toBe(300000)
-    expect(ms('1 minute')).toBe(60000)
-    expect(ms('2 min')).toBe(120000)
-    expect(ms('3 mins')).toBe(180000)
-  })
-
-  it('should parse hours', () => {
-    expect(ms('1h')).toBe(3600000)
-    expect(ms('2 hours')).toBe(7200000)
-    expect(ms('1 hour')).toBe(3600000)
-    expect(ms('3 hr')).toBe(10800000)
-    expect(ms('4 hrs')).toBe(14400000)
-  })
-
-  it('should parse days', () => {
-    expect(ms('1d')).toBe(86400000)
-    expect(ms('2 days')).toBe(172800000)
-    expect(ms('1 day')).toBe(86400000)
-  })
-
-  it('should parse weeks', () => {
-    expect(ms('1w')).toBe(604800000)
-    expect(ms('2 weeks')).toBe(1209600000)
-    expect(ms('1 week')).toBe(604800000)
-  })
-
-  it('should parse years', () => {
-    expect(ms('1y')).toBe(31557600000)
-    expect(ms('1 year')).toBe(31557600000)
-    expect(ms('2 yrs')).toBe(63115200000)
-    expect(ms('1 yr')).toBe(31557600000)
-  })
-
-  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 decimal values', () => {
-    expect(ms('1.5h')).toBe(5400000)
-    expect(ms('0.5d')).toBe(43200000)
-    expect(ms('.5s')).toBe(500)
-  })
-
-  it('should parse negative values', () => {
-    expect(ms('-1s')).toBe(-1000)
-    expect(ms('-3m')).toBe(-180000)
-  })
-
-  it('should default to milliseconds without unit', () => {
-    expect(ms('100')).toBe(100)
-    expect(ms('0')).toBe(0)
-  })
-
-  it('should be case insensitive', () => {
-    expect(ms('1S')).toBe(1000)
-    expect(ms('1M')).toBe(60000)
-    expect(ms('1H')).toBe(3600000)
-  })
-
-  it('should return 0 for invalid strings', () => {
-    expect(ms('invalid')).toBe(0)
-    expect(ms('')).toBe(0)
-    expect(ms('abc123')).toBe(0)
-  })
-
-  it('should return 0 for strings longer than 100 characters', () => {
-    expect(ms('a'.repeat(101))).toBe(0)
-  })
-
-  it('should handle whitespace between number and unit', () => {
-    expect(ms('1 s')).toBe(1000)
-    expect(ms('5  minutes')).toBe(300000)
-  })
-})

package/tests/nest.test.ts

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

@@ -1,80 +0,0 @@
-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,34 +0,0 @@
-{
-  "include": ["src"],
-  "compilerOptions": {
-    "target": "ES2021",
-    "lib": ["ES2021"],
-    "types": ["node"],
-    "module": "Preserve",
-    "moduleResolution": "bundler",
-    "outDir": "dist",
-    "strict": true,
-    "allowSyntheticDefaultImports": true,
-    "allowUnreachableCode": false,
-    "allowUnusedLabels": false,
-    "checkJs": true,
-    "declaration": true,
-    "declarationMap": true,
-    "esModuleInterop": true,
-    "experimentalDecorators": true,
-    "exactOptionalPropertyTypes": true,
-    "forceConsistentCasingInFileNames": true,
-    "importHelpers": true,
-    "isolatedModules": true,
-    "noEmitOnError": true,
-    "noFallthroughCasesInSwitch": true,
-    "noImplicitOverride": true,
-    "noImplicitReturns": true,
-    "noUncheckedIndexedAccess": true,
-    "noUnusedLocals": true,
-    "noUnusedParameters": true,
-    "removeComments": true,
-    "skipLibCheck": true,
-    "sourceMap": true
-  }
-}

package/vite.config.mts

@@ -1,23 +0,0 @@
-import { defineConfig } from 'vitest/config'
-
-export default defineConfig({
-  test: {
-    include: ['tests/**/*.test.ts'],
-    name: 'node',
-    environment: 'node',
-    coverage: {
-      provider: 'v8',
-      reporter: ['text', 'json', 'html', 'lcov'],
-      include: ['src/**/*.ts'],
-      exclude: [
-        'node_modules/**',
-        'dist/**',
-        'coverage/**',
-        '**/*.d.ts',
-        '**/*.config.*',
-        '**/tests/**',
-        'examples/**',
-      ],
-    },
-  },
-})