ts-cache-mongoose 2.0.0 → 2.1.0

package/README.md

@@ -17,7 +17,7 @@ Cache query and aggregate in mongoose using in-memory or redis
 
 ts-cache-mongoose is a plugin for mongoose
 \
-Caching queries is a good way to improve performance of your application
+I need a way to cache mongoose queries and aggregations to improve application performance. It should support both in-memory and Redis cache engines, work with all major Node.js frameworks, and be easy to use with a simple `.cache()` method on queries and aggregations.
 
 ## Supports and tested with
 
@@ -42,22 +42,13 @@ Caching queries is a good way to improve performance of your application
 
 ## Installation
 
-- Locally inside your project
+`mongoose` is a peer dependency — install it alongside `ts-cache-mongoose`.
 
 ```bash
-npm install ts-cache-mongoose
-pnpm add ts-cache-mongoose
-yarn add ts-cache-mongoose
-bun add ts-cache-mongoose
-```
-
-- This plugin requires `mongoose` to be installed as a peer dependency
-
-```bash
-npm install mongoose
-pnpm add mongoose
-yarn add mongoose
-bun add mongoose
+npm install ts-cache-mongoose mongoose
+pnpm add ts-cache-mongoose mongoose
+yarn add ts-cache-mongoose mongoose
+bun add ts-cache-mongoose mongoose
 ```
 
 ## Example
@@ -164,6 +155,14 @@ export class SomeService {
 }
 ```
 
+## Contributing
+
+Check [CONTRIBUTING.md](CONTRIBUTING.md)
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details
+
 ## Check my other projects
 
 - [ts-migrate-mongoose](https://github.com/ilovepixelart/ts-migrate-mongoose) - Migration framework for mongoose

package/dist/index.cjs

@@ -11,65 +11,62 @@ const h = m * 60;
 const d = h * 24;
 const w = d * 7;
 const y = d * 365.25;
-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 mo = y / 12;
 const UNITS = {
-  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,
+  milliseconds: 1,
+  millisecond: 1,
+  msecs: 1,
+  msec: 1,
+  ms: 1,
   seconds: s,
   second: s,
   secs: s,
   sec: s,
   s,
-  milliseconds: 1,
-  millisecond: 1,
-  msecs: 1,
-  msec: 1,
-  ms: 1
+  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
 };
+const unitPattern = Object.keys(UNITS).sort((a, b) => b.length - a.length).join("|");
+const RE = new RegExp(String.raw`^(-?(?:\d+)?\.?\d+)\s*(${unitPattern})?$`, "i");
 const ms = (val) => {
   const str = String(val);
-  if (str.length > 100) return 0;
+  if (str.length > 100) return Number.NaN;
   const match = RE.exec(str);
-  if (!match) return 0;
+  if (!match) return Number.NaN;
   const n = Number.parseFloat(match[1] ?? "");
   const type = (match[2] ?? "ms").toLowerCase();
   return n * (UNITS[type] ?? 0);
 };
 
-var __typeError$3 = (msg) => {
-  throw TypeError(msg);
-};
-var __accessCheck$3 = (obj, member, msg) => member.has(obj) || __typeError$3("Cannot " + msg);
-var __privateGet$3 = (obj, member, getter) => (__accessCheck$3(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
-var __privateAdd$3 = (obj, member, value) => member.has(obj) ? __typeError$3("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
-var __privateSet$3 = (obj, member, value, setter) => (__accessCheck$3(obj, member, "write to private field"), member.set(obj, value), value);
-var _cache;
 class MemoryCacheEngine {
+  #cache;
   constructor() {
-    __privateAdd$3(this, _cache);
-    __privateSet$3(this, _cache, /* @__PURE__ */ new Map());
+    this.#cache = /* @__PURE__ */ new Map();
   }
   get(key) {
-    const item = __privateGet$3(this, _cache).get(key);
+    const item = this.#cache.get(key);
     if (!item || item.expiresAt < Date.now()) {
       this.del(key);
       return void 0;
@@ -77,23 +74,22 @@ class MemoryCacheEngine {
     return item.value;
   }
   set(key, value, ttl) {
-    const givenTTL = typeof ttl === "string" ? ms(ttl) : ttl;
+    const givenTTL = ttl == null ? void 0 : ms(ttl);
     const actualTTL = givenTTL ?? Number.POSITIVE_INFINITY;
-    __privateGet$3(this, _cache).set(key, {
+    this.#cache.set(key, {
       value,
       expiresAt: Date.now() + actualTTL
     });
   }
   del(key) {
-    __privateGet$3(this, _cache).delete(key);
+    this.#cache.delete(key);
   }
   clear() {
-    __privateGet$3(this, _cache).clear();
+    this.#cache.clear();
   }
   close() {
   }
 }
-_cache = new WeakMap();
 
 const isMongooseLessThan7 = Number.parseInt(mongoose.version, 10) < 7;
 const convertToObject = (value) => {
@@ -108,23 +104,15 @@ const convertToObject = (value) => {
   return value;
 };
 
-var __typeError$2 = (msg) => {
-  throw TypeError(msg);
-};
-var __accessCheck$2 = (obj, member, msg) => member.has(obj) || __typeError$2("Cannot " + msg);
-var __privateGet$2 = (obj, member, getter) => (__accessCheck$2(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
-var __privateAdd$2 = (obj, member, value) => member.has(obj) ? __typeError$2("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
-var __privateSet$2 = (obj, member, value, setter) => (__accessCheck$2(obj, member, "write to private field"), member.set(obj, value), value);
-var _client;
 class RedisCacheEngine {
+  #client;
   constructor(options) {
-    __privateAdd$2(this, _client);
     options.keyPrefix ??= "cache-mongoose:";
-    __privateSet$2(this, _client, new IORedis(options));
+    this.#client = new IORedis(options);
   }
   async get(key) {
     try {
-      const value = await __privateGet$2(this, _client).get(key);
+      const value = await this.#client.get(key);
       if (value === null) {
         return void 0;
       }
@@ -136,92 +124,79 @@ class RedisCacheEngine {
   }
   async set(key, value, ttl) {
     try {
-      const givenTTL = typeof ttl === "string" ? ms(ttl) : ttl;
+      const givenTTL = ttl == null ? void 0 : ms(ttl);
       const actualTTL = givenTTL ?? Number.POSITIVE_INFINITY;
       const serializedValue = bson.EJSON.stringify(convertToObject(value));
-      await __privateGet$2(this, _client).setex(key, Math.ceil(actualTTL / 1e3), serializedValue);
+      await this.#client.setex(key, Math.ceil(actualTTL / 1e3), serializedValue);
     } catch (err) {
       console.error(err);
     }
   }
   async del(key) {
-    await __privateGet$2(this, _client).del(key);
+    await this.#client.del(key);
   }
   async clear() {
-    await __privateGet$2(this, _client).flushdb();
+    await this.#client.flushdb();
   }
   async close() {
-    await __privateGet$2(this, _client).quit();
+    await this.#client.quit();
   }
 }
-_client = new WeakMap();
 
-var __typeError$1 = (msg) => {
-  throw TypeError(msg);
-};
-var __accessCheck$1 = (obj, member, msg) => member.has(obj) || __typeError$1("Cannot " + msg);
-var __privateGet$1 = (obj, member, getter) => (__accessCheck$1(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
-var __privateAdd$1 = (obj, member, value) => member.has(obj) ? __typeError$1("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
-var __privateSet$1 = (obj, member, value, setter) => (__accessCheck$1(obj, member, "write to private field"), member.set(obj, value), value);
-var _engine, _defaultTTL, _debug, _engines;
 class Cache {
+  #engine;
+  #defaultTTL;
+  #debug;
+  #engines = ["memory", "redis"];
   constructor(cacheOptions) {
-    __privateAdd$1(this, _engine);
-    __privateAdd$1(this, _defaultTTL);
-    __privateAdd$1(this, _debug);
-    __privateAdd$1(this, _engines, ["memory", "redis"]);
-    if (!__privateGet$1(this, _engines).includes(cacheOptions.engine)) {
+    if (!this.#engines.includes(cacheOptions.engine)) {
       throw new Error(`Invalid engine name: ${cacheOptions.engine}`);
     }
     if (cacheOptions.engine === "redis" && !cacheOptions.engineOptions) {
       throw new Error(`Engine options are required for ${cacheOptions.engine} engine`);
     }
     cacheOptions.defaultTTL ??= "1 minute";
-    __privateSet$1(this, _defaultTTL, typeof cacheOptions.defaultTTL === "string" ? ms(cacheOptions.defaultTTL) : cacheOptions.defaultTTL);
+    this.#defaultTTL = ms(cacheOptions.defaultTTL);
     if (cacheOptions.engine === "redis" && cacheOptions.engineOptions) {
-      __privateSet$1(this, _engine, new RedisCacheEngine(cacheOptions.engineOptions));
+      this.#engine = new RedisCacheEngine(cacheOptions.engineOptions);
     }
     if (cacheOptions.engine === "memory") {
-      __privateSet$1(this, _engine, new MemoryCacheEngine());
+      this.#engine = new MemoryCacheEngine();
     }
-    __privateSet$1(this, _debug, cacheOptions.debug === true);
+    this.#debug = cacheOptions.debug === true;
   }
   async get(key) {
-    const cacheEntry = await __privateGet$1(this, _engine).get(key);
-    if (__privateGet$1(this, _debug)) {
+    const cacheEntry = await this.#engine.get(key);
+    if (this.#debug) {
       const cacheHit = cacheEntry == null ? "MISS" : "HIT";
       console.log(`[ts-cache-mongoose] GET '${key}' - ${cacheHit}`);
     }
     return cacheEntry;
   }
   async set(key, value, ttl) {
-    const givenTTL = typeof ttl === "string" ? ms(ttl) : ttl;
-    const actualTTL = givenTTL ?? __privateGet$1(this, _defaultTTL);
-    await __privateGet$1(this, _engine).set(key, value, actualTTL);
-    if (__privateGet$1(this, _debug)) {
+    const givenTTL = ttl == null ? null : ms(ttl);
+    const actualTTL = givenTTL ?? this.#defaultTTL;
+    await this.#engine.set(key, value, actualTTL);
+    if (this.#debug) {
       console.log(`[ts-cache-mongoose] SET '${key}' - ttl: ${actualTTL.toFixed(0)} ms`);
     }
   }
   async del(key) {
-    await __privateGet$1(this, _engine).del(key);
-    if (__privateGet$1(this, _debug)) {
+    await this.#engine.del(key);
+    if (this.#debug) {
       console.log(`[ts-cache-mongoose] DEL '${key}'`);
     }
   }
   async clear() {
-    await __privateGet$1(this, _engine).clear();
-    if (__privateGet$1(this, _debug)) {
+    await this.#engine.clear();
+    if (this.#debug) {
       console.log("[ts-cache-mongoose] CLEAR");
     }
   }
   async close() {
-    return __privateGet$1(this, _engine).close();
+    return this.#engine.close();
   }
 }
-_engine = new WeakMap();
-_defaultTTL = new WeakMap();
-_debug = new WeakMap();
-_engines = new WeakMap();
 
 const isPlainObject = (value) => {
   if (typeof value !== "object" || value === null) return false;
@@ -273,7 +248,7 @@ function extendAggregate(mongoose, cache) {
       pipeline: this.pipeline()
     });
   };
-  mongoose.Aggregate.prototype.getCacheTTL = function() {
+  mongoose.Aggregate.prototype.getDuration = function() {
     return this._ttl;
   };
   mongoose.Aggregate.prototype.cache = function(ttl, customKey) {
@@ -282,11 +257,11 @@ function extendAggregate(mongoose, cache) {
     return this;
   };
   mongoose.Aggregate.prototype.exec = async function(...args) {
-    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) => {
       console.error(err);
     });
@@ -322,7 +297,7 @@ function extendQuery(mongoose, cache) {
       _conditions: this._conditions
     });
   };
-  mongoose.Query.prototype.getCacheTTL = function() {
+  mongoose.Query.prototype.getDuration = function() {
     return this._ttl;
   };
   mongoose.Query.prototype.cache = function(ttl, customKey) {
@@ -331,11 +306,11 @@ function extendQuery(mongoose, cache) {
     return this;
   };
   mongoose.Query.prototype.exec = async function(...args) {
-    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;
     const isDistinct = this.op === "distinct";
@@ -363,26 +338,20 @@ function extendQuery(mongoose, cache) {
   };
 }
 
-var __typeError = (msg) => {
-  throw TypeError(msg);
-};
-var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
-var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
-var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
-var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), member.set(obj, value), value);
-var _instance;
-const _CacheMongoose = class _CacheMongoose {
+class CacheMongoose {
+  static #instance;
+  cache;
   constructor() {
   }
   static init(mongoose, cacheOptions) {
-    if (!__privateGet(_CacheMongoose, _instance)) {
-      __privateSet(_CacheMongoose, _instance, new _CacheMongoose());
-      __privateGet(_CacheMongoose, _instance).cache = new Cache(cacheOptions);
-      const cache = __privateGet(_CacheMongoose, _instance).cache;
+    if (!CacheMongoose.#instance) {
+      CacheMongoose.#instance = new CacheMongoose();
+      CacheMongoose.#instance.cache = new Cache(cacheOptions);
+      const cache = CacheMongoose.#instance.cache;
       extendQuery(mongoose, cache);
       extendAggregate(mongoose, cache);
     }
-    return __privateGet(_CacheMongoose, _instance);
+    return CacheMongoose.#instance;
   }
   async clear(customKey) {
     if (customKey == null) {
@@ -394,9 +363,6 @@ const _CacheMongoose = class _CacheMongoose {
   async close() {
     await this.cache.close();
   }
-};
-_instance = new WeakMap();
-__privateAdd(_CacheMongoose, _instance);
-let CacheMongoose = _CacheMongoose;
+}
 
 module.exports = CacheMongoose;

package/dist/index.d.cts

@@ -1,17 +1,55 @@
 import { Mongoose } from 'mongoose';
 import { RedisOptions } from 'ioredis';
 
-type CacheTTL = number | string;
+declare const UNITS: {
+    readonly milliseconds: 1;
+    readonly millisecond: 1;
+    readonly msecs: 1;
+    readonly msec: 1;
+    readonly ms: 1;
+    readonly seconds: 1000;
+    readonly second: 1000;
+    readonly secs: 1000;
+    readonly sec: 1000;
+    readonly s: 1000;
+    readonly minutes: number;
+    readonly minute: number;
+    readonly mins: number;
+    readonly min: number;
+    readonly m: number;
+    readonly hours: number;
+    readonly hour: number;
+    readonly hrs: number;
+    readonly hr: number;
+    readonly h: number;
+    readonly days: number;
+    readonly day: number;
+    readonly d: number;
+    readonly weeks: number;
+    readonly week: number;
+    readonly w: number;
+    readonly months: number;
+    readonly month: number;
+    readonly mo: number;
+    readonly years: number;
+    readonly year: number;
+    readonly yrs: number;
+    readonly yr: number;
+    readonly y: number;
+};
+type Unit = keyof typeof UNITS;
+type Duration = number | `${number}` | `${number}${Unit}` | `${number} ${Unit}`;
+
 type CacheData = Record<string, unknown> | Record<string, unknown>[] | unknown[] | number | undefined;
 type CacheOptions = {
     engine: 'memory' | 'redis';
     engineOptions?: RedisOptions;
-    defaultTTL?: CacheTTL;
+    defaultTTL?: Duration;
     debug?: boolean;
 };
 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;
@@ -19,11 +57,11 @@ interface CacheEngine {
 
 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;
@@ -31,11 +69,11 @@ declare module 'mongoose' {
         _conditions?: unknown;
     }
     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;
     }
 }
 declare class CacheMongoose {
@@ -48,5 +86,5 @@ declare class CacheMongoose {
 }
 
 export { CacheMongoose as default };
-export type { CacheData, CacheEngine, CacheOptions, CacheTTL };
+export type { CacheData, CacheEngine, CacheOptions, Duration };
 //# sourceMappingURL=index.d.cts.map

package/dist/index.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.cts","sources":["../src/types.ts","../src/index.ts"],"mappings":";;;AAEM,KAAM,QAAQ;AAEd,KAAM,SAAS,GAAG,MAAM,oBAAoB,MAAM;AAElD,KAAM,YAAY;;oBAEN,YAAY;iBACf,QAAQ;;;AAIjB,UAAW,WAAW;0BACJ,OAAO,CAAC,SAAS,IAAI,SAAS;8BAC1B,SAAS,QAAQ,QAAQ,KAAK,OAAO;0BACzC,OAAO;iBAChB,OAAO;iBACP,OAAO;;;ACTtB;;8EAE0E,QAAQ;;;cAGxE,QAAQ;iFAC2D,QAAQ;;;;;;;;mDAStC,QAAQ;;;cAG7C,QAAQ;sDACgC,QAAQ;;;AAI1D,cAAM,aAAa;;;;0BAQY,QAAQ,gBAAgB,YAAY,GAAG,aAAa;+BAczC,OAAO;aAQzB,OAAO","names":[]}
+{"version":3,"file":"index.d.cts","sources":["../src/ms.ts","../src/types.ts","../src/index.ts"],"mappings":";;;AAQA,cAAa,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqCZ,KAAM,IAAI,gBAAgB,KAAK;AAE/B,KAAM,QAAQ,sCAAsC,IAAI,kBAAkB,IAAI;;AC1C9E,KAAM,SAAS,GAAG,MAAM,oBAAoB,MAAM;AAElD,KAAM,YAAY;;oBAEN,YAAY;iBACf,QAAQ;;;AAIjB,UAAW,WAAW;0BACJ,OAAO,CAAC,SAAS,IAAI,SAAS;8BAC1B,SAAS,QAAQ,QAAQ,KAAK,OAAO;0BACzC,OAAO;iBAChB,OAAO;iBACP,OAAO;;;ACVtB;;8EAE0E,QAAQ;;;cAGxE,QAAQ;iFAC2D,QAAQ;;;;;;;;mDAStC,QAAQ;;;cAG7C,QAAQ;sDACgC,QAAQ;;;AAI1D,cAAM,aAAa;;;;0BAQY,QAAQ,gBAAgB,YAAY,GAAG,aAAa;+BAczC,OAAO;aAQzB,OAAO","names":[]}

package/dist/index.d.mts

@@ -1,17 +1,55 @@
 import { Mongoose } from 'mongoose';
 import { RedisOptions } from 'ioredis';
 
-type CacheTTL = number | string;
+declare const UNITS: {
+    readonly milliseconds: 1;
+    readonly millisecond: 1;
+    readonly msecs: 1;
+    readonly msec: 1;
+    readonly ms: 1;
+    readonly seconds: 1000;
+    readonly second: 1000;
+    readonly secs: 1000;
+    readonly sec: 1000;
+    readonly s: 1000;
+    readonly minutes: number;
+    readonly minute: number;
+    readonly mins: number;
+    readonly min: number;
+    readonly m: number;
+    readonly hours: number;
+    readonly hour: number;
+    readonly hrs: number;
+    readonly hr: number;
+    readonly h: number;
+    readonly days: number;
+    readonly day: number;
+    readonly d: number;
+    readonly weeks: number;
+    readonly week: number;
+    readonly w: number;
+    readonly months: number;
+    readonly month: number;
+    readonly mo: number;
+    readonly years: number;
+    readonly year: number;
+    readonly yrs: number;
+    readonly yr: number;
+    readonly y: number;
+};
+type Unit = keyof typeof UNITS;
+type Duration = number | `${number}` | `${number}${Unit}` | `${number} ${Unit}`;
+
 type CacheData = Record<string, unknown> | Record<string, unknown>[] | unknown[] | number | undefined;
 type CacheOptions = {
     engine: 'memory' | 'redis';
     engineOptions?: RedisOptions;
-    defaultTTL?: CacheTTL;
+    defaultTTL?: Duration;
     debug?: boolean;
 };
 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;
@@ -19,11 +57,11 @@ interface CacheEngine {
 
 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;
@@ -31,11 +69,11 @@ declare module 'mongoose' {
         _conditions?: unknown;
     }
     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;
     }
 }
 declare class CacheMongoose {
@@ -48,5 +86,5 @@ declare class CacheMongoose {
 }
 
 export { CacheMongoose as default };
-export type { CacheData, CacheEngine, CacheOptions, CacheTTL };
+export type { CacheData, CacheEngine, CacheOptions, Duration };
 //# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","sources":["../src/types.ts","../src/index.ts"],"mappings":";;;AAEM,KAAM,QAAQ;AAEd,KAAM,SAAS,GAAG,MAAM,oBAAoB,MAAM;AAElD,KAAM,YAAY;;oBAEN,YAAY;iBACf,QAAQ;;;AAIjB,UAAW,WAAW;0BACJ,OAAO,CAAC,SAAS,IAAI,SAAS;8BAC1B,SAAS,QAAQ,QAAQ,KAAK,OAAO;0BACzC,OAAO;iBAChB,OAAO;iBACP,OAAO;;;ACTtB;;8EAE0E,QAAQ;;;cAGxE,QAAQ;iFAC2D,QAAQ;;;;;;;;mDAStC,QAAQ;;;cAG7C,QAAQ;sDACgC,QAAQ;;;AAI1D,cAAM,aAAa;;;;0BAQY,QAAQ,gBAAgB,YAAY,GAAG,aAAa;+BAczC,OAAO;aAQzB,OAAO","names":[]}
+{"version":3,"file":"index.d.mts","sources":["../src/ms.ts","../src/types.ts","../src/index.ts"],"mappings":";;;AAQA,cAAa,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqCZ,KAAM,IAAI,gBAAgB,KAAK;AAE/B,KAAM,QAAQ,sCAAsC,IAAI,kBAAkB,IAAI;;AC1C9E,KAAM,SAAS,GAAG,MAAM,oBAAoB,MAAM;AAElD,KAAM,YAAY;;oBAEN,YAAY;iBACf,QAAQ;;;AAIjB,UAAW,WAAW;0BACJ,OAAO,CAAC,SAAS,IAAI,SAAS;8BAC1B,SAAS,QAAQ,QAAQ,KAAK,OAAO;0BACzC,OAAO;iBAChB,OAAO;iBACP,OAAO;;;ACVtB;;8EAE0E,QAAQ;;;cAGxE,QAAQ;iFAC2D,QAAQ;;;;;;;;mDAStC,QAAQ;;;cAG7C,QAAQ;sDACgC,QAAQ;;;AAI1D,cAAM,aAAa;;;;0BAQY,QAAQ,gBAAgB,YAAY,GAAG,aAAa;+BAczC,OAAO;aAQzB,OAAO","names":[]}