ts-cache-mongoose 1.7.7 → 2.0.0

package/dist/nest/index.mjs

@@ -0,0 +1,108 @@
+import { Logger, Module } from '@nestjs/common';
+import mongoose from 'mongoose';
+import CacheMongoose from '../index.mjs';
+import 'bson';
+import 'ioredis';
+import 'node:crypto';
+
+const CACHE_OPTIONS = Symbol("CACHE_OPTIONS");
+class CacheService {
+  constructor(options) {
+    this.logger = new Logger(CacheService.name);
+    this.options = options;
+  }
+  get instance() {
+    return this.cacheMongoose;
+  }
+  async onApplicationBootstrap() {
+    this.cacheMongoose = CacheMongoose.init(mongoose, this.options);
+    this.logger.log(`Cache initialized with ${this.options.engine} engine`);
+  }
+  async onApplicationShutdown() {
+    if (this.cacheMongoose) {
+      await this.cacheMongoose.close();
+    }
+  }
+  async clear(customKey) {
+    await this.cacheMongoose.clear(customKey);
+  }
+}
+
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (decorator(result)) || result;
+  return result;
+};
+let CacheModule = class {
+  static forRoot(options) {
+    return {
+      module: CacheModule,
+      global: options.isGlobal ?? false,
+      providers: [
+        { provide: CACHE_OPTIONS, useValue: options },
+        {
+          provide: CacheService,
+          useFactory: (opts) => new CacheService(opts),
+          inject: [CACHE_OPTIONS]
+        }
+      ],
+      exports: [CacheService]
+    };
+  }
+  static forRootAsync(options) {
+    const asyncProviders = CacheModule.createAsyncProviders(options);
+    return {
+      module: CacheModule,
+      global: options.isGlobal ?? false,
+      imports: options.imports ?? [],
+      providers: [
+        ...asyncProviders,
+        {
+          provide: CacheService,
+          useFactory: (opts) => new CacheService(opts),
+          inject: [CACHE_OPTIONS]
+        }
+      ],
+      exports: [CacheService]
+    };
+  }
+  static createAsyncProviders(options) {
+    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) => factory.createCacheOptions(),
+          inject: [options.useClass]
+        }
+      ];
+    }
+    if (options.useExisting) {
+      return [
+        {
+          provide: CACHE_OPTIONS,
+          useFactory: (factory) => factory.createCacheOptions(),
+          inject: [options.useExisting]
+        }
+      ];
+    }
+    return [];
+  }
+};
+CacheModule = __decorateClass([
+  Module({})
+], CacheModule);
+
+export { CACHE_OPTIONS, CacheModule, CacheService };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-cache-mongoose",
-  "version": "1.7.7",
+  "version": "2.0.0",
   "description": "Cache plugin for mongoose Queries and Aggregate (in-memory, redis)",
   "author": "ilovepixelart",
   "license": "MIT",
@@ -47,13 +47,32 @@
   ],
   "type": "module",
   "exports": {
-    "require": {
-      "types": "./dist/index.d.cts",
-      "default": "./dist/index.cjs"
+    ".": {
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      },
+      "import": {
+        "types": "./dist/index.d.mts",
+        "default": "./dist/index.mjs"
+      }
     },
-    "import": {
-      "types": "./dist/index.d.mts",
-      "default": "./dist/index.mjs"
+    "./nest": {
+      "require": {
+        "types": "./dist/nest/index.d.cts",
+        "default": "./dist/nest/index.cjs"
+      },
+      "import": {
+        "types": "./dist/nest/index.d.mts",
+        "default": "./dist/nest/index.mjs"
+      }
+    }
+  },
+  "typesVersions": {
+    "*": {
+      "nest": [
+        "./dist/nest/index.d.cts"
+      ]
     }
   },
   "main": "./dist/index.cjs",
@@ -71,31 +90,33 @@
     "release": "npm install && npm run biome && npm run type:check && npm run build && np --no-publish"
   },
   "dependencies": {
-    "@types/ms": "2.1.0",
-    "@types/semver": "7.7.1",
-    "ioredis": "5.9.3",
-    "ms": "2.1.3",
-    "semver": "7.7.4",
-    "sort-keys": "4.2.0"
+    "ioredis": "5.10.0"
   },
   "devDependencies": {
-    "@biomejs/biome": "2.4.4",
-    "@types/node": "25.3.0",
-    "@vitest/coverage-v8": "4.0.18",
+    "@biomejs/biome": "2.4.7",
+    "@nestjs/common": "11.1.16",
+    "@types/node": "25.5.0",
+    "@vitest/coverage-v8": "4.1.0",
     "bson": "7.2.0",
     "mongodb-memory-server": "11.0.1",
-    "mongoose": "9.2.2",
+    "mongoose": "9.3.0",
+    "np": "11.0.2",
     "open-cli": "8.0.0",
-    "pkgroll": "2.26.3",
+    "pkgroll": "2.27.0",
     "simple-git-hooks": "2.13.1",
     "typescript": "5.9.3",
-    "vitest": "4.0.18",
-    "np": "11.0.2"
+    "vitest": "4.1.0"
   },
   "peerDependencies": {
+    "@nestjs/common": ">=9.0.0",
     "bson": ">=4.7.2 < 8",
     "mongoose": ">=6.6.0 < 10"
   },
+  "peerDependenciesMeta": {
+    "@nestjs/common": {
+      "optional": true
+    }
+  },
   "simple-git-hooks": {
     "pre-commit": "npm run type:check",
     "pre-push": "npm run biome:fix"
@@ -104,6 +125,7 @@
     "publish": false
   },
   "overrides": {
-    "esbuild": "0.25.0"
+    "tmp": "0.2.5",
+    "file-type": "21.3.2"
   }
 }

package/src/cache/Cache.ts

@@ -1,4 +1,4 @@
-import ms from 'ms'
+import { ms } from '../ms'
 import { MemoryCacheEngine } from './engine/MemoryCacheEngine'
 import { RedisCacheEngine } from './engine/RedisCacheEngine'
 

package/src/cache/engine/MemoryCacheEngine.ts

@@ -1,4 +1,4 @@
-import ms from 'ms'
+import { ms } from '../../ms'
 
 import type { CacheData, CacheEngine, CacheTTL } from '../../types'
 

package/src/cache/engine/RedisCacheEngine.ts

@@ -1,6 +1,6 @@
 import { EJSON } from 'bson'
 import IORedis from 'ioredis'
-import ms from 'ms'
+import { ms } from '../../ms'
 import { convertToObject } from '../../version'
 
 import type { Redis, RedisOptions } from 'ioredis'

package/src/key.ts

@@ -1,8 +1,8 @@
 import { createHash } from 'node:crypto'
-import sortKeys from 'sort-keys'
+import { sortKeys } from './sort-keys'
 
 export function getKey(data: Record<string, unknown>[] | Record<string, unknown>): string {
-  const sortedObj = sortKeys(data, { deep: true })
+  const sortedObj = sortKeys(data)
   const sortedStr = JSON.stringify(sortedObj, (_, val: unknown) => {
     return val instanceof RegExp ? String(val) : val
   })

package/src/ms.ts

@@ -0,0 +1,55 @@
+const s = 1000
+const m = s * 60
+const h = m * 60
+const d = h * 24
+const w = d * 7
+const y = d * 365.25
+
+// NOSONAR — regex from ms package, intentionally covers all time unit aliases
+const RE = /^(-?(?:\d+)?\.?\d+)\s*(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i
+
+const UNITS: Record<string, number> = {
+  years: y,
+  year: y,
+  yrs: y,
+  yr: y,
+  y,
+  weeks: w,
+  week: w,
+  w,
+  days: d,
+  day: d,
+  d,
+  hours: h,
+  hour: h,
+  hrs: h,
+  hr: h,
+  h,
+  minutes: m,
+  minute: m,
+  mins: m,
+  min: m,
+  m,
+  seconds: s,
+  second: s,
+  secs: s,
+  sec: s,
+  s,
+  milliseconds: 1,
+  millisecond: 1,
+  msecs: 1,
+  msec: 1,
+  ms: 1,
+}
+
+export const ms = (val: string): number => {
+  const str = String(val)
+  if (str.length > 100) return 0
+
+  const match = RE.exec(str)
+  if (!match) return 0
+
+  const n = Number.parseFloat(match[1] ?? '')
+  const type = (match[2] ?? 'ms').toLowerCase()
+  return n * (UNITS[type] ?? 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,7 +1,6 @@
 import type { RedisOptions } from 'ioredis'
-import type { StringValue } from 'ms'
 
-export type CacheTTL = number | StringValue
+export type CacheTTL = number | string
 
 export type CacheData = Record<string, unknown> | Record<string, unknown>[] | unknown[] | number | undefined
 

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,93 @@
+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)
+  })
+})