ts-cache-mongoose 1.7.7 → 2.1.0

package/dist/nest/index.cjs

@@ -0,0 +1,113 @@
+'use strict';
+
+var common = require('@nestjs/common');
+var mongoose = require('mongoose');
+var index = require('../index.cjs');
+require('bson');
+require('ioredis');
+require('node:crypto');
+
+const CACHE_OPTIONS = Symbol("CACHE_OPTIONS");
+class CacheService {
+  logger = new common.Logger(CacheService.name);
+  options;
+  cacheMongoose;
+  constructor(options) {
+    this.options = options;
+  }
+  get instance() {
+    return this.cacheMongoose;
+  }
+  async onApplicationBootstrap() {
+    this.cacheMongoose = index.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;
+};
+exports.CacheModule = class CacheModule {
+  static forRoot(options) {
+    return {
+      module: exports.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 = exports.CacheModule.createAsyncProviders(options);
+    return {
+      module: exports.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 [];
+  }
+};
+exports.CacheModule = __decorateClass([
+  common.Module({})
+], exports.CacheModule);
+
+exports.CACHE_OPTIONS = CACHE_OPTIONS;
+exports.CacheService = CacheService;

package/dist/nest/index.d.cts

@@ -0,0 +1,40 @@
+import { ModuleMetadata, InjectionToken, OptionalFactoryDependency, Type, DynamicModule, OnApplicationBootstrap, OnApplicationShutdown } from '@nestjs/common';
+import CacheMongoose, { CacheOptions } from '../index.cjs';
+import 'mongoose';
+import 'ioredis';
+
+type CacheModuleOptions = CacheOptions;
+interface CacheOptionsFactory {
+    createCacheOptions(): CacheModuleOptions | Promise<CacheModuleOptions>;
+}
+interface CacheModuleAsyncOptions extends Pick<ModuleMetadata, 'imports'> {
+    isGlobal?: boolean;
+    inject?: (InjectionToken | OptionalFactoryDependency)[];
+    useClass?: Type<CacheOptionsFactory>;
+    useExisting?: Type<CacheOptionsFactory>;
+    useFactory?: (...args: any[]) => CacheModuleOptions | Promise<CacheModuleOptions>;
+}
+
+declare class CacheModule {
+    static forRoot(options: CacheModuleOptions & {
+        isGlobal?: boolean;
+    }): DynamicModule;
+    static forRootAsync(options: CacheModuleAsyncOptions): DynamicModule;
+    private static createAsyncProviders;
+}
+
+declare const CACHE_OPTIONS: unique symbol;
+declare class CacheService implements OnApplicationBootstrap, OnApplicationShutdown {
+    private readonly logger;
+    private readonly options;
+    private cacheMongoose;
+    constructor(options: CacheModuleOptions);
+    get instance(): CacheMongoose;
+    onApplicationBootstrap(): Promise<void>;
+    onApplicationShutdown(): Promise<void>;
+    clear(customKey?: string): Promise<void>;
+}
+
+export { CACHE_OPTIONS, CacheModule, CacheService };
+export type { CacheModuleAsyncOptions, CacheModuleOptions, CacheOptionsFactory };
+//# sourceMappingURL=index.d.cts.map

package/dist/nest/index.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.cts","sources":["../../src/nest/interfaces.ts","../../src/nest/cache.module.ts","../../src/nest/cache.service.ts"],"mappings":";;;;;AAGM,KAAM,kBAAkB,GAAG,YAAY;AAEvC,UAAW,mBAAmB;0BACZ,kBAAkB,GAAG,OAAO,CAAC,kBAAkB;;AAGjE,UAAW,uBAAwB,SAAQ,IAAI,CAAC,cAAc;;cAExD,cAAc,GAAG,yBAAyB;eACzC,IAAI,CAAC,mBAAmB;kBACrB,IAAI,CAAC,mBAAmB;qCAEL,kBAAkB,GAAG,OAAO,CAAC,kBAAkB;;;ACRlF,cACa,WAAW;4BACE,kBAAkB;;QAA4B,aAAa;iCAgBtD,uBAAuB,GAAG,aAAa;;;;AClBtE,cAAa,aAAa;AAE1B,cAAa,YAAa,YAAW,sBAAsB,EAAE,qBAAqB;;;;yBAK3D,kBAAkB;oBAIvB,aAAa;8BAIG,OAAO;6BAKR,OAAO;+BAML,OAAO","names":[]}

package/dist/nest/index.d.mts

@@ -0,0 +1,40 @@
+import { ModuleMetadata, InjectionToken, OptionalFactoryDependency, Type, DynamicModule, OnApplicationBootstrap, OnApplicationShutdown } from '@nestjs/common';
+import CacheMongoose, { CacheOptions } from '../index.mjs';
+import 'mongoose';
+import 'ioredis';
+
+type CacheModuleOptions = CacheOptions;
+interface CacheOptionsFactory {
+    createCacheOptions(): CacheModuleOptions | Promise<CacheModuleOptions>;
+}
+interface CacheModuleAsyncOptions extends Pick<ModuleMetadata, 'imports'> {
+    isGlobal?: boolean;
+    inject?: (InjectionToken | OptionalFactoryDependency)[];
+    useClass?: Type<CacheOptionsFactory>;
+    useExisting?: Type<CacheOptionsFactory>;
+    useFactory?: (...args: any[]) => CacheModuleOptions | Promise<CacheModuleOptions>;
+}
+
+declare class CacheModule {
+    static forRoot(options: CacheModuleOptions & {
+        isGlobal?: boolean;
+    }): DynamicModule;
+    static forRootAsync(options: CacheModuleAsyncOptions): DynamicModule;
+    private static createAsyncProviders;
+}
+
+declare const CACHE_OPTIONS: unique symbol;
+declare class CacheService implements OnApplicationBootstrap, OnApplicationShutdown {
+    private readonly logger;
+    private readonly options;
+    private cacheMongoose;
+    constructor(options: CacheModuleOptions);
+    get instance(): CacheMongoose;
+    onApplicationBootstrap(): Promise<void>;
+    onApplicationShutdown(): Promise<void>;
+    clear(customKey?: string): Promise<void>;
+}
+
+export { CACHE_OPTIONS, CacheModule, CacheService };
+export type { CacheModuleAsyncOptions, CacheModuleOptions, CacheOptionsFactory };
+//# sourceMappingURL=index.d.mts.map

package/dist/nest/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","sources":["../../src/nest/interfaces.ts","../../src/nest/cache.module.ts","../../src/nest/cache.service.ts"],"mappings":";;;;;AAGM,KAAM,kBAAkB,GAAG,YAAY;AAEvC,UAAW,mBAAmB;0BACZ,kBAAkB,GAAG,OAAO,CAAC,kBAAkB;;AAGjE,UAAW,uBAAwB,SAAQ,IAAI,CAAC,cAAc;;cAExD,cAAc,GAAG,yBAAyB;eACzC,IAAI,CAAC,mBAAmB;kBACrB,IAAI,CAAC,mBAAmB;qCAEL,kBAAkB,GAAG,OAAO,CAAC,kBAAkB;;;ACRlF,cACa,WAAW;4BACE,kBAAkB;;QAA4B,aAAa;iCAgBtD,uBAAuB,GAAG,aAAa;;;;AClBtE,cAAa,aAAa;AAE1B,cAAa,YAAa,YAAW,sBAAsB,EAAE,qBAAqB;;;;yBAK3D,kBAAkB;oBAIvB,aAAa;8BAIG,OAAO;6BAKR,OAAO;+BAML,OAAO","names":[]}

package/dist/nest/index.mjs

@@ -0,0 +1,110 @@
+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 {
+  logger = new Logger(CacheService.name);
+  options;
+  cacheMongoose;
+  constructor(options) {
+    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.1.0",
   "description": "Cache plugin for mongoose Queries and Aggregate (in-memory, redis)",
   "author": "ilovepixelart",
   "license": "MIT",
@@ -35,7 +35,7 @@
     "aggregate"
   ],
   "engines": {
-    "node": ">=16"
+    "node": ">=18"
   },
   "files": [
     "dist",
@@ -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,8 +1,8 @@
-import ms from 'ms'
+import { ms } from '../ms'
 import { MemoryCacheEngine } from './engine/MemoryCacheEngine'
 import { RedisCacheEngine } from './engine/RedisCacheEngine'
 
-import type { CacheData, CacheEngine, CacheOptions, CacheTTL } from '../types'
+import type { CacheData, CacheEngine, CacheOptions, Duration } from '../types'
 
 export class Cache {
   readonly #engine!: CacheEngine
@@ -21,7 +21,7 @@ export class Cache {
 
     cacheOptions.defaultTTL ??= '1 minute'
 
-    this.#defaultTTL = typeof cacheOptions.defaultTTL === 'string' ? ms(cacheOptions.defaultTTL) : cacheOptions.defaultTTL
+    this.#defaultTTL = ms(cacheOptions.defaultTTL)
 
     if (cacheOptions.engine === 'redis' && cacheOptions.engineOptions) {
       this.#engine = new RedisCacheEngine(cacheOptions.engineOptions)
@@ -43,8 +43,8 @@ export class Cache {
     return cacheEntry
   }
 
-  async set(key: string, value: CacheData, ttl: CacheTTL | null): Promise<void> {
-    const givenTTL = typeof ttl === 'string' ? ms(ttl) : ttl
+  async set(key: string, value: CacheData, ttl: Duration | null): Promise<void> {
+    const givenTTL = ttl == null ? null : ms(ttl)
     const actualTTL = givenTTL ?? this.#defaultTTL
     await this.#engine.set(key, value, actualTTL)
     if (this.#debug) {

package/src/cache/engine/MemoryCacheEngine.ts

@@ -1,6 +1,6 @@
-import ms from 'ms'
+import { ms } from '../../ms'
 
-import type { CacheData, CacheEngine, CacheTTL } from '../../types'
+import type { CacheData, CacheEngine, Duration } from '../../types'
 
 export class MemoryCacheEngine implements CacheEngine {
   readonly #cache: Map<string, { value: CacheData; expiresAt: number } | undefined>
@@ -18,8 +18,8 @@ export class MemoryCacheEngine implements CacheEngine {
     return item.value
   }
 
-  set(key: string, value: CacheData, ttl?: CacheTTL): void {
-    const givenTTL = typeof ttl === 'string' ? ms(ttl) : ttl
+  set(key: string, value: CacheData, ttl?: Duration): void {
+    const givenTTL = ttl == null ? undefined : ms(ttl)
     const actualTTL = givenTTL ?? Number.POSITIVE_INFINITY
     this.#cache.set(key, {
       value,

package/src/cache/engine/RedisCacheEngine.ts

@@ -1,10 +1,10 @@
 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'
-import type { CacheData, CacheEngine, CacheTTL } from '../../types'
+import type { CacheData, CacheEngine, Duration } from '../../types'
 
 export class RedisCacheEngine implements CacheEngine {
   readonly #client: Redis
@@ -27,9 +27,9 @@ export class RedisCacheEngine implements CacheEngine {
     }
   }
 
-  async set(key: string, value: CacheData, ttl?: CacheTTL): Promise<void> {
+  async set(key: string, value: CacheData, ttl?: Duration): Promise<void> {
     try {
-      const givenTTL = typeof ttl === 'string' ? ms(ttl) : ttl
+      const givenTTL = ttl == null ? undefined : ms(ttl)
       const actualTTL = givenTTL ?? Number.POSITIVE_INFINITY
       const serializedValue = EJSON.stringify(convertToObject(value))
       await this.#client.setex(key, Math.ceil(actualTTL / 1000), serializedValue)

package/src/extend/aggregate.ts

@@ -2,7 +2,7 @@ import { getKey } from '../key'
 
 import type { Mongoose } from 'mongoose'
 import type { Cache } from '../cache/Cache'
-import type { CacheTTL } from '../types'
+import type { Duration } from '../types'
 
 export function extendAggregate(mongoose: Mongoose, cache: Cache): void {
   const mongooseExec = mongoose.Aggregate.prototype.exec
@@ -15,24 +15,23 @@ export function extendAggregate(mongoose: Mongoose, cache: Cache): void {
     })
   }
 
-  mongoose.Aggregate.prototype.getCacheTTL = function (): CacheTTL | null {
+  mongoose.Aggregate.prototype.getDuration = function (): Duration | null {
     return this._ttl
   }
 
-  mongoose.Aggregate.prototype.cache = function (ttl?: CacheTTL, customKey?: string) {
+  mongoose.Aggregate.prototype.cache = function (ttl?: Duration, customKey?: string) {
     this._ttl = ttl ?? null
     this._key = customKey ?? null
     return this
   }
 
   mongoose.Aggregate.prototype.exec = async function (...args: []) {
-    // biome-ignore lint/suspicious/noPrototypeBuiltins: to support node 16
-    if (!Object.prototype.hasOwnProperty.call(this, '_ttl')) {
+    if (!Object.hasOwn(this, '_ttl')) {
       return mongooseExec.apply(this, args)
     }
 
     const key = this.getCacheKey()
-    const ttl = this.getCacheTTL()
+    const ttl = this.getDuration()
 
     const resultCache = await cache.get(key).catch((err: unknown) => {
       console.error(err)

package/src/extend/query.ts

@@ -2,7 +2,7 @@ import { getKey } from '../key'
 
 import type { Mongoose } from 'mongoose'
 import type { Cache } from '../cache/Cache'
-import type { CacheTTL } from '../types'
+import type { Duration } from '../types'
 
 export function extendQuery(mongoose: Mongoose, cache: Cache): void {
   const mongooseExec = mongoose.Query.prototype.exec
@@ -29,24 +29,23 @@ export function extendQuery(mongoose: Mongoose, cache: Cache): void {
     })
   }
 
-  mongoose.Query.prototype.getCacheTTL = function (): CacheTTL | null {
+  mongoose.Query.prototype.getDuration = function (): Duration | null {
     return this._ttl
   }
 
-  mongoose.Query.prototype.cache = function (ttl?: CacheTTL, customKey?: string) {
+  mongoose.Query.prototype.cache = function (ttl?: Duration, customKey?: string) {
     this._ttl = ttl ?? null
     this._key = customKey ?? null
     return this
   }
 
   mongoose.Query.prototype.exec = async function (...args: []) {
-    // biome-ignore lint/suspicious/noPrototypeBuiltins: to support node 16
-    if (!Object.prototype.hasOwnProperty.call(this, '_ttl')) {
+    if (!Object.hasOwn(this, '_ttl')) {
       return mongooseExec.apply(this, args)
     }
 
     const key = this.getCacheKey()
-    const ttl = this.getCacheTTL()
+    const ttl = this.getDuration()
     const mongooseOptions = this.mongooseOptions()
 
     const isCount = this.op?.includes('count') ?? false

package/src/index.ts

@@ -3,17 +3,17 @@ import { extendAggregate } from './extend/aggregate'
 import { extendQuery } from './extend/query'
 
 import type { Mongoose } from 'mongoose'
-import type { CacheOptions, CacheTTL } from './types'
+import type { CacheOptions, Duration } from './types'
 
 export * from './types'
 
 declare module 'mongoose' {
   interface Query<ResultType, DocType, THelpers, RawDocType> {
-    cache: (this: Query<ResultType, DocType, THelpers, RawDocType>, ttl?: CacheTTL, customKey?: string) => this
+    cache: (this: Query<ResultType, DocType, THelpers, RawDocType>, ttl?: Duration, customKey?: string) => this
     _key: string | null
     getCacheKey: (this: Query<ResultType, DocType, THelpers, RawDocType>) => string
-    _ttl: CacheTTL | null
-    getCacheTTL: (this: Query<ResultType, DocType, THelpers, RawDocType>) => CacheTTL | null
+    _ttl: Duration | null
+    getDuration: (this: Query<ResultType, DocType, THelpers, RawDocType>) => Duration | null
     op?: string
     _path?: unknown
     _fields?: unknown
@@ -22,11 +22,11 @@ declare module 'mongoose' {
   }
 
   interface Aggregate<ResultType> {
-    cache: (this: Aggregate<ResultType>, ttl?: CacheTTL, customKey?: string) => this
+    cache: (this: Aggregate<ResultType>, ttl?: Duration, customKey?: string) => this
     _key: string | null
     getCacheKey: (this: Aggregate<ResultType>) => string
-    _ttl: CacheTTL | null
-    getCacheTTL: (this: Aggregate<ResultType>) => CacheTTL | null
+    _ttl: Duration | null
+    getDuration: (this: Aggregate<ResultType>) => Duration | null
   }
 }
 

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