ts-cache-mongoose 2.0.0 → 2.1.0

package/dist/index.mjs

@@ -9,65 +9,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;
@@ -75,23 +72,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) => {
@@ -106,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;
       }
@@ -134,92 +122,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 = 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;
@@ -271,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) {
@@ -280,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);
     });
@@ -320,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) {
@@ -329,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";
@@ -361,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) {
@@ -392,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 };

package/dist/nest/index.cjs

@@ -9,8 +9,10 @@ require('node:crypto');
 
 const CACHE_OPTIONS = Symbol("CACHE_OPTIONS");
 class CacheService {
+  logger = new common.Logger(CacheService.name);
+  options;
+  cacheMongoose;
   constructor(options) {
-    this.logger = new common.Logger(CacheService.name);
     this.options = options;
   }
   get instance() {

package/dist/nest/index.mjs

@@ -7,8 +7,10 @@ import 'node:crypto';
 
 const CACHE_OPTIONS = Symbol("CACHE_OPTIONS");
 class CacheService {
+  logger = new Logger(CacheService.name);
+  options;
+  cacheMongoose;
   constructor(options) {
-    this.logger = new Logger(CacheService.name);
     this.options = options;
   }
   get instance() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-cache-mongoose",
-  "version": "2.0.0",
+  "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",

package/src/cache/Cache.ts

@@ -2,7 +2,7 @@ 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 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

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