ts-cache-mongoose 2.1.0 → 2.2.1

package/README.md

@@ -12,6 +12,10 @@ Cache query and aggregate in mongoose using in-memory or redis
 [![Reliability Rating](https://sonarcloud.io/api/project_badges/measure?project=ilovepixelart_ts-cache-mongoose&metric=reliability_rating)](https://sonarcloud.io/summary/new_code?id=ilovepixelart_ts-cache-mongoose)
 [![Maintainability Rating](https://sonarcloud.io/api/project_badges/measure?project=ilovepixelart_ts-cache-mongoose&metric=sqale_rating)](https://sonarcloud.io/summary/new_code?id=ilovepixelart_ts-cache-mongoose)
 [![Security Rating](https://sonarcloud.io/api/project_badges/measure?project=ilovepixelart_ts-cache-mongoose&metric=security_rating)](https://sonarcloud.io/summary/new_code?id=ilovepixelart_ts-cache-mongoose)
+\
+[![Socket Badge](https://badge.socket.dev/npm/package/ts-cache-mongoose)](https://socket.dev/npm/package/ts-cache-mongoose)
+[![OpenSSF Scorecard](https://api.securityscorecards.dev/projects/github.com/ilovepixelart/ts-cache-mongoose/badge)](https://securityscorecards.dev/viewer/?uri=github.com/ilovepixelart/ts-cache-mongoose)
+[![OpenSSF Best Practices](https://www.bestpractices.dev/projects/12484/badge?v=1)](https://www.bestpractices.dev/en/projects/12484)
 
 ## Motivation
 
@@ -24,10 +28,12 @@ I need a way to cache mongoose queries and aggregations to improve application p
 ```json
 {
   "node": "20.x || 22.x || 24.x",
-  "mongoose": ">=6.6.x || 7.x || 8.x || 9.x",
+  "mongoose": ">=6.6.0 <10"
 }
 ```
 
+CI tests against mongoose `6.12.2`, `7.6.4`, `8.23.0`, and `9.4.1`.
+
 ## Features
 
 - In-memory caching
@@ -96,6 +102,53 @@ const books = await Book.aggregate([
 ]).cache('1 minute').exec()
 ```
 
+### Bounded in-memory cache
+
+The in-memory engine is unbounded by default. For workloads where query keys are driven by user input (search, filters, pagination), cap the cache so a caller generating unique cache keys cannot grow the map without limit. Two bounds are available and can be combined — eviction is LRU, and whichever bound is hit first triggers it:
+
+```typescript
+cache.init(mongoose, {
+  engine: 'memory',
+  defaultTTL: '60 seconds',
+  maxEntries: 10_000,          // cap by entry count
+  maxBytes: 50 * 1024 * 1024,  // cap by serialized bytes (50 MB)
+})
+```
+
+`maxBytes` measures entry size via `node:v8.serialize(value).byteLength` by default — handles circular references (mongoose `populate` parent-refs), single C++ call per `set`, works on Node / Bun / Deno. Provide your own `sizeCalculation` callback if you want an O(1) estimate instead:
+
+```typescript
+cache.init(mongoose, {
+  engine: 'memory',
+  maxBytes: 50 * 1024 * 1024,
+  sizeCalculation: (value) => {
+    if (Array.isArray(value)) return value.length * 512
+    return 512
+  },
+})
+```
+
+Eviction is soft: the just-written entry is never dropped, even if its own size exceeds `maxBytes`. Everything older gets evicted until both bounds are satisfied (or only the new entry remains).
+
+Both options are ignored for the Redis engine — use Redis's own `maxmemory` + `maxmemory-policy` instead.
+
+### Custom error handling
+
+By default, cache engine failures (Redis disconnects, serialization errors, etc.) are logged via `console.error` and the query falls through to the database. Pass an `onError` callback to route them somewhere else — e.g. a structured logger, Sentry, or a metric counter:
+
+```typescript
+cache.init(mongoose, {
+  engine: 'redis',
+  defaultTTL: '60 seconds',
+  engineOptions: { host: 'localhost', port: 6379 },
+  onError: (error) => {
+    logger.warn({ err: error }, 'cache engine failure')
+  },
+})
+```
+
+The callback receives the raw `Error`. Cache reads and writes never throw — a failing engine degrades to a cache miss.
+
 ### Cache invalidation
 
 ```typescript

package/dist/index.cjs

@@ -1,5 +1,6 @@
 'use strict';
 
+var node_v8 = require('node:v8');
 var bson = require('bson');
 var IORedis = require('ioredis');
 var mongoose = require('mongoose');
@@ -60,32 +61,66 @@ const ms = (val) => {
   return n * (UNITS[type] ?? 0);
 };
 
+const defaultSizer = (value) => node_v8.serialize(value).byteLength;
 class MemoryCacheEngine {
   #cache;
-  constructor() {
+  #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 = this.#cache.get(key);
-    if (!item || item.expiresAt < Date.now()) {
-      this.del(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 = ttl == null ? void 0 : ms(ttl);
     const actualTTL = givenTTL ?? Number.POSITIVE_INFINITY;
-    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) {
+    const item = this.#cache.get(key);
+    if (!item) return;
     this.#cache.delete(key);
+    this.#totalBytes -= item.bytes;
   }
   clear() {
     this.#cache.clear();
+    this.#totalBytes = 0;
   }
   close() {
   }
@@ -106,9 +141,11 @@ const convertToObject = (value) => {
 
 class RedisCacheEngine {
   #client;
-  constructor(options) {
+  #onError;
+  constructor(options, onError) {
     options.keyPrefix ??= "cache-mongoose:";
     this.#client = new IORedis(options);
+    this.#onError = onError;
   }
   async get(key) {
     try {
@@ -118,18 +155,22 @@ class RedisCacheEngine {
       }
       return bson.EJSON.parse(value);
     } catch (err) {
-      console.error(err);
+      this.#onError(err);
       return void 0;
     }
   }
   async set(key, value, ttl) {
     try {
+      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 = bson.EJSON.stringify(convertToObject(value));
+      const serializedValue = bson.EJSON.stringify(converted);
       await this.#client.setex(key, Math.ceil(actualTTL / 1e3), serializedValue);
     } catch (err) {
-      console.error(err);
+      this.#onError(err);
     }
   }
   async del(key) {
@@ -147,6 +188,7 @@ class Cache {
   #engine;
   #defaultTTL;
   #debug;
+  #onError;
   #engines = ["memory", "redis"];
   constructor(cacheOptions) {
     if (!this.#engines.includes(cacheOptions.engine)) {
@@ -157,14 +199,22 @@ class Cache {
     }
     cacheOptions.defaultTTL ??= "1 minute";
     this.#defaultTTL = ms(cacheOptions.defaultTTL);
+    this.#onError = cacheOptions.onError ?? console.error;
     if (cacheOptions.engine === "redis" && cacheOptions.engineOptions) {
-      this.#engine = new RedisCacheEngine(cacheOptions.engineOptions);
+      this.#engine = new RedisCacheEngine(cacheOptions.engineOptions, this.#onError);
     }
     if (cacheOptions.engine === "memory") {
-      this.#engine = new MemoryCacheEngine();
+      this.#engine = new MemoryCacheEngine({
+        maxEntries: cacheOptions.maxEntries,
+        maxBytes: cacheOptions.maxBytes,
+        sizeCalculation: cacheOptions.sizeCalculation
+      });
     }
     this.#debug = cacheOptions.debug === true;
   }
+  get onError() {
+    return this.#onError;
+  }
   async get(key) {
     const cacheEntry = await this.#engine.get(key);
     if (this.#debug) {
@@ -176,6 +226,12 @@ class Cache {
   async set(key, value, ttl) {
     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`);
@@ -263,14 +319,14 @@ function extendAggregate(mongoose, cache) {
     const key = this.getCacheKey();
     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;
   };
@@ -316,7 +372,7 @@ function extendQuery(mongoose, cache) {
     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) {
@@ -332,7 +388,7 @@ 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;
   };

package/dist/index.d.cts

@@ -46,6 +46,10 @@ type CacheOptions = {
     engineOptions?: RedisOptions;
     defaultTTL?: Duration;
     debug?: boolean;
+    onError?: (error: Error) => void;
+    maxEntries?: number;
+    maxBytes?: number;
+    sizeCalculation?: (value: CacheData) => number;
 };
 interface CacheEngine {
     get: (key: string) => Promise<CacheData> | CacheData;

package/dist/index.d.cts.map

@@ -1 +1 @@
-{"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":[]}
+{"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

@@ -46,6 +46,10 @@ type CacheOptions = {
     engineOptions?: RedisOptions;
     defaultTTL?: Duration;
     debug?: boolean;
+    onError?: (error: Error) => void;
+    maxEntries?: number;
+    maxBytes?: number;
+    sizeCalculation?: (value: CacheData) => number;
 };
 interface CacheEngine {
     get: (key: string) => Promise<CacheData> | CacheData;

package/dist/index.d.mts.map

@@ -1 +1 @@
-{"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":[]}
+{"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';
@@ -58,32 +59,66 @@ const ms = (val) => {
   return n * (UNITS[type] ?? 0);
 };
 
+const defaultSizer = (value) => serialize(value).byteLength;
 class MemoryCacheEngine {
   #cache;
-  constructor() {
+  #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 = this.#cache.get(key);
-    if (!item || item.expiresAt < Date.now()) {
-      this.del(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 = ttl == null ? void 0 : ms(ttl);
     const actualTTL = givenTTL ?? Number.POSITIVE_INFINITY;
-    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) {
+    const item = this.#cache.get(key);
+    if (!item) return;
     this.#cache.delete(key);
+    this.#totalBytes -= item.bytes;
   }
   clear() {
     this.#cache.clear();
+    this.#totalBytes = 0;
   }
   close() {
   }
@@ -104,9 +139,11 @@ const convertToObject = (value) => {
 
 class RedisCacheEngine {
   #client;
-  constructor(options) {
+  #onError;
+  constructor(options, onError) {
     options.keyPrefix ??= "cache-mongoose:";
     this.#client = new IORedis(options);
+    this.#onError = onError;
   }
   async get(key) {
     try {
@@ -116,18 +153,22 @@ class RedisCacheEngine {
       }
       return EJSON.parse(value);
     } catch (err) {
-      console.error(err);
+      this.#onError(err);
       return void 0;
     }
   }
   async set(key, value, ttl) {
     try {
+      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));
+      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) {
@@ -145,6 +186,7 @@ class Cache {
   #engine;
   #defaultTTL;
   #debug;
+  #onError;
   #engines = ["memory", "redis"];
   constructor(cacheOptions) {
     if (!this.#engines.includes(cacheOptions.engine)) {
@@ -155,14 +197,22 @@ class Cache {
     }
     cacheOptions.defaultTTL ??= "1 minute";
     this.#defaultTTL = ms(cacheOptions.defaultTTL);
+    this.#onError = cacheOptions.onError ?? console.error;
     if (cacheOptions.engine === "redis" && cacheOptions.engineOptions) {
-      this.#engine = new RedisCacheEngine(cacheOptions.engineOptions);
+      this.#engine = new RedisCacheEngine(cacheOptions.engineOptions, this.#onError);
     }
     if (cacheOptions.engine === "memory") {
-      this.#engine = new MemoryCacheEngine();
+      this.#engine = new MemoryCacheEngine({
+        maxEntries: cacheOptions.maxEntries,
+        maxBytes: cacheOptions.maxBytes,
+        sizeCalculation: cacheOptions.sizeCalculation
+      });
     }
     this.#debug = cacheOptions.debug === true;
   }
+  get onError() {
+    return this.#onError;
+  }
   async get(key) {
     const cacheEntry = await this.#engine.get(key);
     if (this.#debug) {
@@ -174,6 +224,12 @@ class Cache {
   async set(key, value, ttl) {
     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`);
@@ -261,14 +317,14 @@ function extendAggregate(mongoose, cache) {
     const key = this.getCacheKey();
     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;
   };
@@ -314,7 +370,7 @@ function extendQuery(mongoose, cache) {
     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) {
@@ -330,7 +386,7 @@ 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;
   };

package/dist/nest/index.cjs

@@ -3,6 +3,7 @@
 var common = require('@nestjs/common');
 var mongoose = require('mongoose');
 var index = require('../index.cjs');
+require('node:v8');
 require('bson');
 require('ioredis');
 require('node:crypto');

package/dist/nest/index.mjs

@@ -1,6 +1,7 @@
 import { Logger, Module } from '@nestjs/common';
 import mongoose from 'mongoose';
 import CacheMongoose from '../index.mjs';
+import 'node:v8';
 import 'bson';
 import 'ioredis';
 import 'node:crypto';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-cache-mongoose",
-  "version": "2.1.0",
+  "version": "2.2.1",
   "description": "Cache plugin for mongoose Queries and Aggregate (in-memory, redis)",
   "author": "ilovepixelart",
   "license": "MIT",
@@ -12,9 +12,6 @@
     "url": "https://github.com/ilovepixelart/ts-cache-mongoose/issues"
   },
   "homepage": "https://github.com/ilovepixelart/ts-cache-mongoose#readme",
-  "directories": {
-    "examples": "examples"
-  },
   "keywords": [
     "backend",
     "mongo",
@@ -35,15 +32,10 @@
     "aggregate"
   ],
   "engines": {
-    "node": ">=18"
+    "node": ">=20"
   },
   "files": [
-    "dist",
-    "src",
-    "tests",
-    "tsconfig.json",
-    "vite.config.mts",
-    "biome.json"
+    "dist"
   ],
   "type": "module",
   "exports": {
@@ -78,37 +70,43 @@
   "main": "./dist/index.cjs",
   "module": "./dist/index.mjs",
   "types": "./dist/index.d.cts",
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
   "scripts": {
-    "prepare": "simple-git-hooks",
     "biome": "npx @biomejs/biome check",
     "biome:fix": "npx @biomejs/biome check --write .",
     "test": "vitest run --coverage",
     "test:open": "vitest run --coverage && open-cli coverage/lcov-report/index.html",
     "clean": "rm -rf ./dist",
     "type:check": "tsc --noEmit",
+    "type:check:tests": "tsc --noEmit -p tests/tsconfig.json",
     "build": "pkgroll --clean-dist",
-    "release": "npm install && npm run biome && npm run type:check && npm run build && np --no-publish"
+    "release": "npm install && npm run biome && npm run type:check && npm run type:check:tests && npm run build && np --no-publish"
   },
   "dependencies": {
     "ioredis": "5.10.0"
   },
   "devDependencies": {
-    "@biomejs/biome": "2.4.7",
-    "@nestjs/common": "11.1.16",
-    "@types/node": "25.5.0",
-    "@vitest/coverage-v8": "4.1.0",
+    "@biomejs/biome": "2.4.14",
+    "@nestjs/common": "11.1.18",
+    "@nestjs/core": "11.1.18",
+    "@nestjs/testing": "11.1.18",
+    "@types/node": "25.6.1",
+    "@vitest/coverage-v8": "4.1.5",
     "bson": "7.2.0",
+    "fast-check": "4.7.0",
     "mongodb-memory-server": "11.0.1",
-    "mongoose": "9.3.0",
-    "np": "11.0.2",
-    "open-cli": "8.0.0",
+    "mongoose": "9.4.1",
+    "open-cli": "9.0.0",
     "pkgroll": "2.27.0",
     "simple-git-hooks": "2.13.1",
     "typescript": "5.9.3",
-    "vitest": "4.1.0"
+    "vitest": "4.1.5"
   },
   "peerDependencies": {
-    "@nestjs/common": ">=9.0.0",
+    "@nestjs/common": ">=9.0.0 < 12",
     "bson": ">=4.7.2 < 8",
     "mongoose": ">=6.6.0 < 10"
   },
@@ -123,9 +121,5 @@
   },
   "np": {
     "publish": false
-  },
-  "overrides": {
-    "tmp": "0.2.5",
-    "file-type": "21.3.2"
   }
 }

package/biome.json

@@ -1,47 +0,0 @@
-{
-  "$schema": "https://biomejs.dev/schemas/2.4.7/schema.json",
-  "vcs": { "enabled": false, "clientKind": "git", "useIgnoreFile": false },
-  "files": {
-    "ignoreUnknown": false,
-    "includes": ["src/**/*.ts", "tests/**/*.ts"]
-  },
-  "formatter": { "enabled": true, "indentStyle": "space", "indentWidth": 2 },
-  "assist": {
-    "actions": {
-      "source": {
-        "organizeImports": {
-          "level": "on",
-          "options": {
-            "groups": [
-              "vitest",
-              ":BLANK_LINE:",
-              ":NODE:",
-              { "type": false },
-              ":BLANK_LINE:"
-            ]
-          }
-        }
-      }
-    }
-  },
-  "linter": {
-    "enabled": true,
-    "rules": {
-      "recommended": true
-    }
-  },
-  "javascript": {
-    "formatter": {
-      "trailingCommas": "all",
-      "quoteStyle": "single",
-      "semicolons": "asNeeded",
-      "lineWidth": 320
-    },
-    "globals": ["Atomics", "SharedArrayBuffer"]
-  },
-  "json": {
-    "formatter": {
-      "trailingCommas": "none"
-    }
-  }
-}