ts-cache-mongoose 1.7.7 → 2.1.0

package/README.md

@@ -17,14 +17,14 @@ Cache query and aggregate in mongoose using in-memory or redis
 
 ts-cache-mongoose is a plugin for mongoose
 \
-Caching queries is a good way to improve performance of your application
+I need a way to cache mongoose queries and aggregations to improve application performance. It should support both in-memory and Redis cache engines, work with all major Node.js frameworks, and be easy to use with a simple `.cache()` method on queries and aggregations.
 
 ## Supports and tested with
 
 ```json
 {
-  "node": "18.x || 20.x || 22.x",
-  "mongoose": ">=6.6.x || 7.x || 8.x",
+  "node": "20.x || 22.x || 24.x",
+  "mongoose": ">=6.6.x || 7.x || 8.x || 9.x",
 }
 ```
 
@@ -42,105 +42,127 @@ Caching queries is a good way to improve performance of your application
 
 ## Installation
 
-- Locally inside your project
+`mongoose` is a peer dependency — install it alongside `ts-cache-mongoose`.
 
 ```bash
-npm install ts-cache-mongoose
-pnpm add ts-cache-mongoose
-yarn add ts-cache-mongoose
-bun add ts-cache-mongoose
-```
-
-- This plugin requires mongoose `>=6.6.x || 7.x || 8.x` to be installed as a peer dependency
-
-```bash
-# For latest mongoose 6
-npm install mongoose@6
-pnpm add mongoose@6
-yarn add mongoose@6
-bun add mongoose@6
-# For latest mongoose 7
-npm install mongoose@7
-pnpm add mongoose@7
-yarn add mongoose@7
-bun add mongoose@7
-# For latest mongoose 8
-npm install mongoose@8
-pnpm add mongoose@8
-yarn add mongoose@8
-bun add mongoose@8
+npm install ts-cache-mongoose mongoose
+pnpm add ts-cache-mongoose mongoose
+yarn add ts-cache-mongoose mongoose
+bun add ts-cache-mongoose mongoose
 ```
 
 ## Example
 
+Works with any Node.js framework — Express, Fastify, Koa, Hono, etc:
+
 ```typescript
-// On your application startup
 import mongoose from 'mongoose'
 import cache from 'ts-cache-mongoose'
 
-// In-memory example 
-const instance = cache.init(mongoose, {
+// In-memory
+cache.init(mongoose, {
   defaultTTL: '60 seconds',
   engine: 'memory',
-  debug: true, // Debug mode enables hit/miss logs in console, not for production use
 })
 
-// OR
-
-// Redis example
-const instance = cache.init(mongoose, {
+// Or Redis
+cache.init(mongoose, {
   defaultTTL: '60 seconds',
   engine: 'redis',
   engineOptions: {
     host: 'localhost',
     port: 6379,
   },
-  debug: true, // Debug mode enables hit/miss logs in console, not for production use
 })
 
-// Connect to your database
 mongoose.connect('mongodb://localhost:27017/my-database')
+```
 
-// Somewhere in your code
-const users = await User.find({ role: 'user' }).cache('10 seconds').exec()
-// Cache hit
-const users = await User.find({ role: 'user' }).cache('10 seconds').exec()
+### Query caching
 
+```typescript
+const users = await User.find({ role: 'user' }).cache('10 seconds').exec()
 const book = await Book.findById(id).cache('1 hour').exec()
-const bookCount = await Book.countDocuments().cache('1 minute').exec()
+const count = await Book.countDocuments().cache('1 minute').exec()
 const authors = await Book.distinct('author').cache('30 seconds').exec()
+```
+
+### Aggregate caching
 
+```typescript
 const books = await Book.aggregate([
-  {
-    $match: {
-      genre: 'fantasy',
-    },
-  },
-  {
-    $group: {
-      _id: '$author',
-      count: { $sum: 1 },
-    },
-  },
-  {
-    $project: {
-      _id: 0,
-      author: '$_id',
-      count: 1,
-    },
-  }
+  { $match: { genre: 'fantasy' } },
+  { $group: { _id: '$author', count: { $sum: 1 } } },
 ]).cache('1 minute').exec()
+```
+
+### Cache invalidation
 
-// Cache invalidation
+```typescript
+const instance = cache.init(mongoose, { engine: 'memory', defaultTTL: '60 seconds' })
 
-// To clear all cache, don't use in production unless you know what you are doing
+// Clear all cache
 await instance.clear()
 
-// Instead use custom cache key
-const user = await User.findById('61bb4d6a1786e5123d7f4cf1').cache('1 minute', 'some-custom-key').exec()
-await instance.clear('some-custom-key')
+// Or use custom cache key
+const user = await User.findById(id).cache('1 minute', 'user-key').exec()
+await instance.clear('user-key')
 ```
 
+### NestJS (because it's special)
+
+Import `CacheModule` from `ts-cache-mongoose/nest`:
+
+```typescript
+import { CacheModule } from 'ts-cache-mongoose/nest'
+
+@Module({
+  imports: [
+    MongooseModule.forRoot(process.env.MONGO_URI),
+    CacheModule.forRoot({
+      engine: 'memory',
+      defaultTTL: '60 seconds',
+    }),
+  ],
+})
+export class AppModule {}
+```
+
+With `ConfigService`:
+
+```typescript
+CacheModule.forRootAsync({
+  inject: [ConfigService],
+  useFactory: (config: ConfigService) => ({
+    engine: config.get('CACHE_ENGINE', 'memory'),
+    defaultTTL: config.get('CACHE_TTL', '60 seconds'),
+  }),
+})
+```
+
+Inject `CacheService` for programmatic cache clearing:
+
+```typescript
+import { CacheService } from 'ts-cache-mongoose/nest'
+
+@Injectable()
+export class SomeService {
+  constructor(private readonly cacheService: CacheService) {}
+
+  async clearUserCache() {
+    await this.cacheService.clear('user-cache-key')
+  }
+}
+```
+
+## Contributing
+
+Check [CONTRIBUTING.md](CONTRIBUTING.md)
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details
+
 ## Check my other projects
 
 - [ts-migrate-mongoose](https://github.com/ilovepixelart/ts-migrate-mongoose) - Migration framework for mongoose

package/biome.json

@@ -1,5 +1,5 @@
 {
-  "$schema": "https://biomejs.dev/schemas/2.4.4/schema.json",
+  "$schema": "https://biomejs.dev/schemas/2.4.7/schema.json",
   "vcs": { "enabled": false, "clientKind": "git", "useIgnoreFile": false },
   "files": {
     "ignoreUnknown": false,

package/dist/index.cjs

@@ -1,28 +1,72 @@
 'use strict';
 
-var ms = require('ms');
 var bson = require('bson');
 var IORedis = require('ioredis');
 var mongoose = require('mongoose');
-var semver = require('semver');
 var node_crypto = require('node:crypto');
-var sortKeys = require('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;
@@ -30,25 +74,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 = semver.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) {
@@ -61,23 +104,15 @@ const convertToObject = (value) => {
   return value;
 };
 
-var __typeError$2 = (msg) => {
-  throw TypeError(msg);
-};
-var __accessCheck$2 = (obj, member, msg) => member.has(obj) || __typeError$2("Cannot " + msg);
-var __privateGet$2 = (obj, member, getter) => (__accessCheck$2(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
-var __privateAdd$2 = (obj, member, value) => member.has(obj) ? __typeError$2("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
-var __privateSet$2 = (obj, member, value, setter) => (__accessCheck$2(obj, member, "write to private field"), member.set(obj, value), value);
-var _client;
 class RedisCacheEngine {
+  #client;
   constructor(options) {
-    __privateAdd$2(this, _client);
     options.keyPrefix ??= "cache-mongoose:";
-    __privateSet$2(this, _client, new IORedis(options));
+    this.#client = new IORedis(options);
   }
   async get(key) {
     try {
-      const value = await __privateGet$2(this, _client).get(key);
+      const value = await this.#client.get(key);
       if (value === null) {
         return void 0;
       }
@@ -89,95 +124,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 = bson.EJSON.stringify(convertToObject(value));
-      await __privateGet$2(this, _client).setex(key, Math.ceil(actualTTL / 1e3), serializedValue);
+      await this.#client.setex(key, Math.ceil(actualTTL / 1e3), serializedValue);
     } catch (err) {
       console.error(err);
     }
   }
   async del(key) {
-    await __privateGet$2(this, _client).del(key);
+    await this.#client.del(key);
   }
   async clear() {
-    await __privateGet$2(this, _client).flushdb();
+    await this.#client.flushdb();
   }
   async close() {
-    await __privateGet$2(this, _client).quit();
+    await this.#client.quit();
   }
 }
-_client = new WeakMap();
 
-var __typeError$1 = (msg) => {
-  throw TypeError(msg);
-};
-var __accessCheck$1 = (obj, member, msg) => member.has(obj) || __typeError$1("Cannot " + msg);
-var __privateGet$1 = (obj, member, getter) => (__accessCheck$1(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
-var __privateAdd$1 = (obj, member, value) => member.has(obj) ? __typeError$1("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
-var __privateSet$1 = (obj, member, value, setter) => (__accessCheck$1(obj, member, "write to private field"), member.set(obj, value), value);
-var _engine, _defaultTTL, _debug, _engines;
 class Cache {
+  #engine;
+  #defaultTTL;
+  #debug;
+  #engines = ["memory", "redis"];
   constructor(cacheOptions) {
-    __privateAdd$1(this, _engine);
-    __privateAdd$1(this, _defaultTTL);
-    __privateAdd$1(this, _debug);
-    __privateAdd$1(this, _engines, ["memory", "redis"]);
-    if (!__privateGet$1(this, _engines).includes(cacheOptions.engine)) {
+    if (!this.#engines.includes(cacheOptions.engine)) {
       throw new Error(`Invalid engine name: ${cacheOptions.engine}`);
     }
     if (cacheOptions.engine === "redis" && !cacheOptions.engineOptions) {
       throw new Error(`Engine options are required for ${cacheOptions.engine} engine`);
     }
     cacheOptions.defaultTTL ??= "1 minute";
-    __privateSet$1(this, _defaultTTL, typeof cacheOptions.defaultTTL === "string" ? ms(cacheOptions.defaultTTL) : cacheOptions.defaultTTL);
+    this.#defaultTTL = ms(cacheOptions.defaultTTL);
     if (cacheOptions.engine === "redis" && cacheOptions.engineOptions) {
-      __privateSet$1(this, _engine, new RedisCacheEngine(cacheOptions.engineOptions));
+      this.#engine = new RedisCacheEngine(cacheOptions.engineOptions);
     }
     if (cacheOptions.engine === "memory") {
-      __privateSet$1(this, _engine, new MemoryCacheEngine());
+      this.#engine = new MemoryCacheEngine();
     }
-    __privateSet$1(this, _debug, cacheOptions.debug === true);
+    this.#debug = cacheOptions.debug === true;
   }
   async get(key) {
-    const cacheEntry = await __privateGet$1(this, _engine).get(key);
-    if (__privateGet$1(this, _debug)) {
+    const cacheEntry = await this.#engine.get(key);
+    if (this.#debug) {
       const cacheHit = cacheEntry == null ? "MISS" : "HIT";
       console.log(`[ts-cache-mongoose] GET '${key}' - ${cacheHit}`);
     }
     return cacheEntry;
   }
   async set(key, value, ttl) {
-    const givenTTL = typeof ttl === "string" ? ms(ttl) : ttl;
-    const actualTTL = givenTTL ?? __privateGet$1(this, _defaultTTL);
-    await __privateGet$1(this, _engine).set(key, value, actualTTL);
-    if (__privateGet$1(this, _debug)) {
+    const givenTTL = ttl == null ? null : ms(ttl);
+    const actualTTL = givenTTL ?? this.#defaultTTL;
+    await this.#engine.set(key, value, actualTTL);
+    if (this.#debug) {
       console.log(`[ts-cache-mongoose] SET '${key}' - ttl: ${actualTTL.toFixed(0)} ms`);
     }
   }
   async del(key) {
-    await __privateGet$1(this, _engine).del(key);
-    if (__privateGet$1(this, _debug)) {
+    await this.#engine.del(key);
+    if (this.#debug) {
       console.log(`[ts-cache-mongoose] DEL '${key}'`);
     }
   }
   async clear() {
-    await __privateGet$1(this, _engine).clear();
-    if (__privateGet$1(this, _debug)) {
+    await this.#engine.clear();
+    if (this.#debug) {
       console.log("[ts-cache-mongoose] CLEAR");
     }
   }
   async close() {
-    return __privateGet$1(this, _engine).close();
+    return this.#engine.close();
   }
 }
-_engine = new WeakMap();
-_defaultTTL = new WeakMap();
-_debug = new WeakMap();
-_engines = new WeakMap();
+
+const isPlainObject = (value) => {
+  if (typeof value !== "object" || value === null) return false;
+  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;
   });
@@ -192,7 +248,7 @@ function extendAggregate(mongoose, cache) {
       pipeline: this.pipeline()
     });
   };
-  mongoose.Aggregate.prototype.getCacheTTL = function() {
+  mongoose.Aggregate.prototype.getDuration = function() {
     return this._ttl;
   };
   mongoose.Aggregate.prototype.cache = function(ttl, customKey) {
@@ -201,11 +257,11 @@ function extendAggregate(mongoose, cache) {
     return this;
   };
   mongoose.Aggregate.prototype.exec = async function(...args) {
-    if (!Object.prototype.hasOwnProperty.call(this, "_ttl")) {
+    if (!Object.hasOwn(this, "_ttl")) {
       return mongooseExec.apply(this, args);
     }
     const key = this.getCacheKey();
-    const ttl = this.getCacheTTL();
+    const ttl = this.getDuration();
     const resultCache = await cache.get(key).catch((err) => {
       console.error(err);
     });
@@ -241,7 +297,7 @@ function extendQuery(mongoose, cache) {
       _conditions: this._conditions
     });
   };
-  mongoose.Query.prototype.getCacheTTL = function() {
+  mongoose.Query.prototype.getDuration = function() {
     return this._ttl;
   };
   mongoose.Query.prototype.cache = function(ttl, customKey) {
@@ -250,11 +306,11 @@ function extendQuery(mongoose, cache) {
     return this;
   };
   mongoose.Query.prototype.exec = async function(...args) {
-    if (!Object.prototype.hasOwnProperty.call(this, "_ttl")) {
+    if (!Object.hasOwn(this, "_ttl")) {
       return mongooseExec.apply(this, args);
     }
     const key = this.getCacheKey();
-    const ttl = this.getCacheTTL();
+    const ttl = this.getDuration();
     const mongooseOptions = this.mongooseOptions();
     const isCount = this.op?.includes("count") ?? false;
     const isDistinct = this.op === "distinct";
@@ -282,26 +338,20 @@ function extendQuery(mongoose, cache) {
   };
 }
 
-var __typeError = (msg) => {
-  throw TypeError(msg);
-};
-var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
-var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
-var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
-var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), member.set(obj, value), value);
-var _instance;
-const _CacheMongoose = class _CacheMongoose {
+class CacheMongoose {
+  static #instance;
+  cache;
   constructor() {
   }
   static init(mongoose, cacheOptions) {
-    if (!__privateGet(_CacheMongoose, _instance)) {
-      __privateSet(_CacheMongoose, _instance, new _CacheMongoose());
-      __privateGet(_CacheMongoose, _instance).cache = new Cache(cacheOptions);
-      const cache = __privateGet(_CacheMongoose, _instance).cache;
+    if (!CacheMongoose.#instance) {
+      CacheMongoose.#instance = new CacheMongoose();
+      CacheMongoose.#instance.cache = new Cache(cacheOptions);
+      const cache = CacheMongoose.#instance.cache;
       extendQuery(mongoose, cache);
       extendAggregate(mongoose, cache);
     }
-    return __privateGet(_CacheMongoose, _instance);
+    return CacheMongoose.#instance;
   }
   async clear(customKey) {
     if (customKey == null) {
@@ -313,9 +363,6 @@ const _CacheMongoose = class _CacheMongoose {
   async close() {
     await this.cache.close();
   }
-};
-_instance = new WeakMap();
-__privateAdd(_CacheMongoose, _instance);
-let CacheMongoose = _CacheMongoose;
+}
 
 module.exports = CacheMongoose;