ts-cache-mongoose 1.7.7 → 2.1.0

package/dist/index.d.cts

@@ -1,18 +1,55 @@
 import { Mongoose } from 'mongoose';
 import { RedisOptions } from 'ioredis';
-import { StringValue } from 'ms';
 
-type CacheTTL = number | StringValue;
+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;
@@ -20,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;
@@ -32,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 {
@@ -49,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":";;;;AAGM,KAAM,QAAQ,YAAY,WAAW;AAErC,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":[]}
+{"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,18 +1,55 @@
 import { Mongoose } from 'mongoose';
 import { RedisOptions } from 'ioredis';
-import { StringValue } from 'ms';
 
-type CacheTTL = number | StringValue;
+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;
@@ -20,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;
@@ -32,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 {
@@ -49,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":";;;;AAGM,KAAM,QAAQ,YAAY,WAAW;AAErC,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":[]}
+{"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":[]}

package/dist/index.mjs

@@ -1,26 +1,70 @@
-import ms from 'ms';
 import { EJSON } from 'bson';
 import IORedis from 'ioredis';
 import mongoose from 'mongoose';
-import { satisfies } from 'semver';
 import { createHash } from 'node:crypto';
-import sortKeys from 'sort-keys';
 
-var __typeError$3 = (msg) => {
-  throw TypeError(msg);
+const s = 1e3;
+const m = s * 60;
+const h = m * 60;
+const d = h * 24;
+const w = d * 7;
+const y = d * 365.25;
+const mo = y / 12;
+const UNITS = {
+  milliseconds: 1,
+  millisecond: 1,
+  msecs: 1,
+  msec: 1,
+  ms: 1,
+  seconds: s,
+  second: s,
+  secs: s,
+  sec: s,
+  s,
+  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
 };
-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 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 Number.NaN;
+  const match = RE.exec(str);
+  if (!match) return Number.NaN;
+  const n = Number.parseFloat(match[1] ?? "");
+  const type = (match[2] ?? "ms").toLowerCase();
+  return n * (UNITS[type] ?? 0);
+};
+
 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;
@@ -28,25 +72,24 @@ 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 = satisfies(mongoose.version, "<7");
+const isMongooseLessThan7 = Number.parseInt(mongoose.version, 10) < 7;
 const convertToObject = (value) => {
   if (isMongooseLessThan7) {
     if (value != null && typeof value === "object" && !Array.isArray(value) && value.toObject) {
@@ -59,23 +102,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;
       }
@@ -87,95 +122,116 @@ 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 = 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;
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+};
+const sortKeys = (input) => {
+  const seen = /* @__PURE__ */ new WeakSet();
+  const sortObject = (obj) => {
+    if (seen.has(obj)) return obj;
+    seen.add(obj);
+    const sorted = {};
+    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) => {
+    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);
+  return sortObject(input);
+};
 
 function getKey(data) {
-  const sortedObj = sortKeys(data, { deep: true });
+  const sortedObj = sortKeys(data);
   const sortedStr = JSON.stringify(sortedObj, (_, val) => {
     return val instanceof RegExp ? String(val) : val;
   });
@@ -190,7 +246,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) {
@@ -199,11 +255,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);
     });
@@ -239,7 +295,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) {
@@ -248,11 +304,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";
@@ -280,26 +336,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) {
@@ -311,9 +361,6 @@ const _CacheMongoose = class _CacheMongoose {
   async close() {
     await this.cache.close();
   }
-};
-_instance = new WeakMap();
-__privateAdd(_CacheMongoose, _instance);
-let CacheMongoose = _CacheMongoose;
+}
 
 export { CacheMongoose as default };