ts-cache-mongoose 2.0.0 → 2.2.0

package/dist/index.d.cts

@@ -1,17 +1,59 @@
 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;
+    onError?: (error: Error) => void;
+    maxEntries?: number;
+    maxBytes?: number;
+    sizeCalculation?: (value: CacheData) => number;
 };
 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 +61,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 +73,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 +90,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;;sBAEH,KAAK;;;8BAGG,SAAS;;AAG/B,UAAW,WAAW;0BACJ,OAAO,CAAC,SAAS,IAAI,SAAS;8BAC1B,SAAS,QAAQ,QAAQ,KAAK,OAAO;0BACzC,OAAO;iBAChB,OAAO;iBACP,OAAO;;;ACdtB;;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,59 @@
 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;
+    onError?: (error: Error) => void;
+    maxEntries?: number;
+    maxBytes?: number;
+    sizeCalculation?: (value: CacheData) => number;
 };
 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 +61,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 +73,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 +90,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;;sBAEH,KAAK;;;8BAGG,SAAS;;AAG/B,UAAW,WAAW;0BACJ,OAAO,CAAC,SAAS,IAAI,SAAS;8BAC1B,SAAS,QAAQ,QAAQ,KAAK,OAAO;0BACzC,OAAO;iBAChB,OAAO;iBACP,OAAO;;;ACdtB;;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.mjs

@@ -1,3 +1,4 @@
+import { serialize } from 'node:v8';
 import { EJSON } from 'bson';
 import IORedis from 'ioredis';
 import mongoose from 'mongoose';
@@ -9,89 +10,119 @@ 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;
+const defaultSizer = (value) => serialize(value).byteLength;
 class MemoryCacheEngine {
-  constructor() {
-    __privateAdd$3(this, _cache);
-    __privateSet$3(this, _cache, /* @__PURE__ */ new Map());
+  #cache;
+  #maxEntries;
+  #maxBytes;
+  #sizeOf;
+  #totalBytes;
+  constructor(options) {
+    this.#cache = /* @__PURE__ */ new Map();
+    this.#maxEntries = options?.maxEntries != null && options.maxEntries > 0 ? options.maxEntries : Number.POSITIVE_INFINITY;
+    this.#maxBytes = options?.maxBytes != null && options.maxBytes > 0 ? options.maxBytes : Number.POSITIVE_INFINITY;
+    this.#sizeOf = options?.sizeCalculation ?? defaultSizer;
+    this.#totalBytes = 0;
+  }
+  get totalBytes() {
+    return this.#totalBytes;
+  }
+  get size() {
+    return this.#cache.size;
   }
   get(key) {
-    const item = __privateGet$3(this, _cache).get(key);
-    if (!item || item.expiresAt < Date.now()) {
-      this.del(key);
+    const item = this.#cache.get(key);
+    if (!item) return void 0;
+    if (item.expiresAt < Date.now()) {
+      this.#cache.delete(key);
+      this.#totalBytes -= item.bytes;
       return void 0;
     }
+    this.#cache.delete(key);
+    this.#cache.set(key, item);
     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, {
-      value,
-      expiresAt: Date.now() + actualTTL
-    });
+    const existing = this.#cache.get(key);
+    if (existing) {
+      this.#cache.delete(key);
+      this.#totalBytes -= existing.bytes;
+    }
+    const bytes = this.#sizeOf(value);
+    this.#cache.set(key, { value, expiresAt: Date.now() + actualTTL, bytes });
+    this.#totalBytes += bytes;
+    while ((this.#cache.size > this.#maxEntries || this.#totalBytes > this.#maxBytes) && this.#cache.size > 1) {
+      const oldestKey = this.#cache.keys().next().value;
+      if (oldestKey === void 0 || oldestKey === key) break;
+      const oldest = this.#cache.get(oldestKey);
+      this.#cache.delete(oldestKey);
+      if (oldest) this.#totalBytes -= oldest.bytes;
+    }
   }
   del(key) {
-    __privateGet$3(this, _cache).delete(key);
+    const item = this.#cache.get(key);
+    if (!item) return;
+    this.#cache.delete(key);
+    this.#totalBytes -= item.bytes;
   }
   clear() {
-    __privateGet$3(this, _cache).clear();
+    this.#cache.clear();
+    this.#totalBytes = 0;
   }
   close() {
   }
 }
-_cache = new WeakMap();
 
 const isMongooseLessThan7 = Number.parseInt(mongoose.version, 10) < 7;
 const convertToObject = (value) => {
@@ -106,120 +137,120 @@ 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 {
-  constructor(options) {
-    __privateAdd$2(this, _client);
+  #client;
+  #onError;
+  constructor(options, onError) {
     options.keyPrefix ??= "cache-mongoose:";
-    __privateSet$2(this, _client, new IORedis(options));
+    this.#client = new IORedis(options);
+    this.#onError = onError;
   }
   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;
       }
       return EJSON.parse(value);
     } catch (err) {
-      console.error(err);
+      this.#onError(err);
       return void 0;
     }
   }
   async set(key, value, ttl) {
     try {
-      const givenTTL = typeof ttl === "string" ? ms(ttl) : ttl;
+      const converted = convertToObject(value);
+      if (converted === void 0) {
+        return;
+      }
+      const givenTTL = ttl == null ? void 0 : ms(ttl);
       const actualTTL = givenTTL ?? Number.POSITIVE_INFINITY;
-      const serializedValue = EJSON.stringify(convertToObject(value));
-      await __privateGet$2(this, _client).setex(key, Math.ceil(actualTTL / 1e3), serializedValue);
+      const serializedValue = EJSON.stringify(converted);
+      await this.#client.setex(key, Math.ceil(actualTTL / 1e3), serializedValue);
     } catch (err) {
-      console.error(err);
+      this.#onError(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;
+  #onError;
+  #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);
+    this.#onError = cacheOptions.onError ?? console.error;
     if (cacheOptions.engine === "redis" && cacheOptions.engineOptions) {
-      __privateSet$1(this, _engine, new RedisCacheEngine(cacheOptions.engineOptions));
+      this.#engine = new RedisCacheEngine(cacheOptions.engineOptions, this.#onError);
     }
     if (cacheOptions.engine === "memory") {
-      __privateSet$1(this, _engine, new MemoryCacheEngine());
+      this.#engine = new MemoryCacheEngine({
+        maxEntries: cacheOptions.maxEntries,
+        maxBytes: cacheOptions.maxBytes,
+        sizeCalculation: cacheOptions.sizeCalculation
+      });
     }
-    __privateSet$1(this, _debug, cacheOptions.debug === true);
+    this.#debug = cacheOptions.debug === true;
+  }
+  get onError() {
+    return this.#onError;
   }
   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;
+    if (Number.isNaN(actualTTL) || actualTTL <= 0) {
+      if (this.#debug) {
+        console.log(`[ts-cache-mongoose] SET '${key}' - skipped (non-positive ttl: ${String(actualTTL)} ms)`);
+      }
+      return;
+    }
+    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;
@@ -271,7 +302,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) {
@@ -280,20 +311,20 @@ 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);
+      cache.onError(err);
     });
     if (resultCache) {
       return resultCache;
     }
     const result = await mongooseExec.call(this);
     await cache.set(key, result, ttl).catch((err) => {
-      console.error(err);
+      cache.onError(err);
     });
     return result;
   };
@@ -320,7 +351,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) {
@@ -329,17 +360,17 @@ 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";
     const model = this.model.modelName;
     const resultCache = await cache.get(key).catch((err) => {
-      console.error(err);
+      cache.onError(err);
     });
     if (resultCache) {
       if (isCount || isDistinct || mongooseOptions.lean) {
@@ -355,32 +386,26 @@ function extendQuery(mongoose, cache) {
     }
     const result = await mongooseExec.call(this);
     await cache.set(key, result, ttl).catch((err) => {
-      console.error(err);
+      cache.onError(err);
     });
     return result;
   };
 }
 
-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) {
@@ -392,9 +417,6 @@ const _CacheMongoose = class _CacheMongoose {
   async close() {
     await this.cache.close();
   }
-};
-_instance = new WeakMap();
-__privateAdd(_CacheMongoose, _instance);
-let CacheMongoose = _CacheMongoose;
+}
 
 export { CacheMongoose as default };