ts-cache-mongoose 1.7.0 → 1.7.2

package/LICENSE

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2024 ilovepixelart
+Copyright (c) 2025 ilovepixelart
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -30,15 +30,15 @@ Caching queries is a good way to improve performance of your application
 
 ## Features
 
-- [x] In-memory caching
-- [x] Redis caching
-- [x] Cache expiration
-- [x] Cache invalidation
-- [x] Cache key generation
-- [x] Cache key prefix
-- [x] Query caching
-- [x] Aggregate caching
-- [x] Supports ESM and CommonJS
+- In-memory caching
+- Redis caching
+- Cache expiration
+- Cache invalidation
+- Cache key generation
+- Cache key prefix
+- Query caching
+- Aggregate caching
+- Supports ESM and CommonJS
 
 ## Installation
 

package/biome.json

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

package/dist/index.cjs

@@ -0,0 +1,325 @@
+'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);
+};
+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 {
+  constructor() {
+    __privateAdd$3(this, _cache);
+    __privateSet$3(this, _cache, /* @__PURE__ */ new Map());
+  }
+  get(key) {
+    const item = __privateGet$3(this, _cache).get(key);
+    if (!item || item.expiresAt < Date.now()) {
+      this.del(key);
+      return void 0;
+    }
+    return item.value;
+  }
+  set(key, value, ttl) {
+    const givenTTL = typeof ttl === "string" ? ms(ttl) : ttl;
+    const actualTTL = givenTTL ?? Number.POSITIVE_INFINITY;
+    __privateGet$3(this, _cache).set(key, {
+      value,
+      expiresAt: Date.now() + actualTTL
+    });
+  }
+  del(key) {
+    __privateGet$3(this, _cache).delete(key);
+  }
+  clear() {
+    __privateGet$3(this, _cache).clear();
+  }
+  close() {
+  }
+}
+_cache = new WeakMap();
+
+const isMongooseLessThan7 = semver.satisfies(mongoose.version, "<7");
+const convertToObject = (value) => {
+  if (isMongooseLessThan7) {
+    if (value != null && typeof value === "object" && !Array.isArray(value) && value.toObject) {
+      return value.toObject();
+    }
+    if (Array.isArray(value)) {
+      return value.map((doc) => convertToObject(doc));
+    }
+  }
+  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);
+    if (!options.keyPrefix) {
+      options.keyPrefix = "cache-mongoose:";
+    }
+    __privateSet$2(this, _client, new IORedis(options));
+  }
+  async get(key) {
+    try {
+      const value = await __privateGet$2(this, _client).get(key);
+      if (value === null) {
+        return void 0;
+      }
+      return bson.EJSON.parse(value);
+    } catch (err) {
+      console.error(err);
+      return void 0;
+    }
+  }
+  async set(key, value, ttl) {
+    try {
+      const givenTTL = typeof ttl === "string" ? ms(ttl) : 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);
+    } catch (err) {
+      console.error(err);
+    }
+  }
+  async del(key) {
+    await __privateGet$2(this, _client).del(key);
+  }
+  async clear() {
+    await __privateGet$2(this, _client).flushdb();
+  }
+  async close() {
+    await __privateGet$2(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 {
+  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)) {
+      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`);
+    }
+    if (!cacheOptions.defaultTTL) {
+      cacheOptions.defaultTTL = "1 minute";
+    }
+    __privateSet$1(this, _defaultTTL, typeof cacheOptions.defaultTTL === "string" ? ms(cacheOptions.defaultTTL) : cacheOptions.defaultTTL);
+    if (cacheOptions.engine === "redis" && cacheOptions.engineOptions) {
+      __privateSet$1(this, _engine, new RedisCacheEngine(cacheOptions.engineOptions));
+    }
+    if (cacheOptions.engine === "memory") {
+      __privateSet$1(this, _engine, new MemoryCacheEngine());
+    }
+    __privateSet$1(this, _debug, cacheOptions.debug === true);
+  }
+  async get(key) {
+    const cacheEntry = await __privateGet$1(this, _engine).get(key);
+    if (__privateGet$1(this, _debug)) {
+      const cacheHit = cacheEntry != null ? "HIT" : "MISS";
+      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)) {
+      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)) {
+      console.log(`[ts-cache-mongoose] DEL '${key}'`);
+    }
+  }
+  async clear() {
+    await __privateGet$1(this, _engine).clear();
+    if (__privateGet$1(this, _debug)) {
+      console.log("[ts-cache-mongoose] CLEAR");
+    }
+  }
+  async close() {
+    return __privateGet$1(this, _engine).close();
+  }
+}
+_engine = new WeakMap();
+_defaultTTL = new WeakMap();
+_debug = new WeakMap();
+_engines = new WeakMap();
+
+function getKey(data) {
+  const sortedObj = sortKeys(data, { deep: true });
+  const sortedStr = JSON.stringify(sortedObj, (_, val) => {
+    return val instanceof RegExp ? String(val) : val;
+  });
+  return node_crypto.createHash("sha1").update(sortedStr).digest("hex");
+}
+
+function extendAggregate(mongoose, cache) {
+  const mongooseExec = mongoose.Aggregate.prototype.exec;
+  mongoose.Aggregate.prototype.getCacheKey = function() {
+    if (this._key != null) return this._key;
+    return getKey({
+      pipeline: this.pipeline()
+    });
+  };
+  mongoose.Aggregate.prototype.getCacheTTL = function() {
+    return this._ttl;
+  };
+  mongoose.Aggregate.prototype.cache = function(ttl, customKey) {
+    this._ttl = ttl ?? null;
+    this._key = customKey ?? null;
+    return this;
+  };
+  mongoose.Aggregate.prototype.exec = async function(...args) {
+    if (!Object.prototype.hasOwnProperty.call(this, "_ttl")) {
+      return mongooseExec.apply(this, args);
+    }
+    const key = this.getCacheKey();
+    const ttl = this.getCacheTTL();
+    const resultCache = await cache.get(key).catch((err) => {
+      console.error(err);
+    });
+    if (resultCache) {
+      return resultCache;
+    }
+    const result = await mongooseExec.call(this);
+    await cache.set(key, result, ttl).catch((err) => {
+      console.error(err);
+    });
+    return result;
+  };
+}
+
+function extendQuery(mongoose, cache) {
+  const mongooseExec = mongoose.Query.prototype.exec;
+  mongoose.Query.prototype.getCacheKey = function() {
+    if (this._key != null) return this._key;
+    const filter = this.getFilter();
+    const update = this.getUpdate();
+    const options = this.getOptions();
+    const mongooseOptions = this.mongooseOptions();
+    return getKey({
+      model: this.model.modelName,
+      op: this.op,
+      filter,
+      update,
+      options,
+      mongooseOptions,
+      _path: this._path,
+      _fields: this._fields,
+      _distinct: this._distinct,
+      _conditions: this._conditions
+    });
+  };
+  mongoose.Query.prototype.getCacheTTL = function() {
+    return this._ttl;
+  };
+  mongoose.Query.prototype.cache = function(ttl, customKey) {
+    this._ttl = ttl ?? null;
+    this._key = customKey ?? null;
+    return this;
+  };
+  mongoose.Query.prototype.exec = async function(...args) {
+    if (!Object.prototype.hasOwnProperty.call(this, "_ttl")) {
+      return mongooseExec.apply(this, args);
+    }
+    const key = this.getCacheKey();
+    const ttl = this.getCacheTTL();
+    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);
+    });
+    if (resultCache) {
+      if (isCount || isDistinct || mongooseOptions.lean) {
+        return resultCache;
+      }
+      const modelConstructor = mongoose.model(model);
+      if (Array.isArray(resultCache)) {
+        return resultCache.map((item) => {
+          return modelConstructor.hydrate(item);
+        });
+      }
+      return modelConstructor.hydrate(resultCache);
+    }
+    const result = await mongooseExec.call(this);
+    await cache.set(key, result, ttl).catch((err) => {
+      console.error(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 {
+  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;
+      extendQuery(mongoose, cache);
+      extendAggregate(mongoose, cache);
+    }
+    return __privateGet(_CacheMongoose, _instance);
+  }
+  async clear(customKey) {
+    if (customKey != null) {
+      await this.cache.del(customKey);
+    } else {
+      await this.cache.clear();
+    }
+  }
+  async close() {
+    await this.cache.close();
+  }
+};
+_instance = new WeakMap();
+__privateAdd(_CacheMongoose, _instance);
+let CacheMongoose = _CacheMongoose;
+
+module.exports = CacheMongoose;

package/dist/{cjs/types/plugin.d.ts → index.d.cts}

@@ -1,5 +1,23 @@
-import type { Mongoose } from 'mongoose';
-import type { CacheOptions, CacheTTL } from './types';
+import { Mongoose } from 'mongoose';
+import { RedisOptions } from 'ioredis';
+import { StringValue } from 'ms';
+
+type CacheTTL = number | StringValue;
+type CacheData = Record<string, unknown> | Record<string, unknown>[] | unknown[] | number | undefined;
+type CacheOptions = {
+    engine: 'memory' | 'redis';
+    engineOptions?: RedisOptions;
+    defaultTTL?: CacheTTL;
+    debug?: boolean;
+};
+interface CacheEngine {
+    get: (key: string) => Promise<CacheData> | CacheData;
+    set: (key: string, value: CacheData, ttl?: CacheTTL) => Promise<void> | void;
+    del: (key: string) => Promise<void> | void;
+    clear: () => Promise<void> | void;
+    close: () => Promise<void> | void;
+}
+
 declare module 'mongoose' {
     interface Query<ResultType, DocType, THelpers, RawDocType> {
         cache: (this: Query<ResultType, DocType, THelpers, RawDocType>, ttl?: CacheTTL, customKey?: string) => this;
@@ -29,5 +47,5 @@ declare class CacheMongoose {
     clear(customKey?: string): Promise<void>;
     close(): Promise<void>;
 }
-export default CacheMongoose;
-//# sourceMappingURL=plugin.d.ts.map
+
+export { type CacheData, type CacheEngine, type CacheOptions, type CacheTTL, CacheMongoose as default };

package/dist/{esm/types/plugin.d.ts → index.d.mts}

@@ -1,5 +1,23 @@
-import type { Mongoose } from 'mongoose';
-import type { CacheOptions, CacheTTL } from './types';
+import { Mongoose } from 'mongoose';
+import { RedisOptions } from 'ioredis';
+import { StringValue } from 'ms';
+
+type CacheTTL = number | StringValue;
+type CacheData = Record<string, unknown> | Record<string, unknown>[] | unknown[] | number | undefined;
+type CacheOptions = {
+    engine: 'memory' | 'redis';
+    engineOptions?: RedisOptions;
+    defaultTTL?: CacheTTL;
+    debug?: boolean;
+};
+interface CacheEngine {
+    get: (key: string) => Promise<CacheData> | CacheData;
+    set: (key: string, value: CacheData, ttl?: CacheTTL) => Promise<void> | void;
+    del: (key: string) => Promise<void> | void;
+    clear: () => Promise<void> | void;
+    close: () => Promise<void> | void;
+}
+
 declare module 'mongoose' {
     interface Query<ResultType, DocType, THelpers, RawDocType> {
         cache: (this: Query<ResultType, DocType, THelpers, RawDocType>, ttl?: CacheTTL, customKey?: string) => this;
@@ -29,5 +47,5 @@ declare class CacheMongoose {
     clear(customKey?: string): Promise<void>;
     close(): Promise<void>;
 }
-export default CacheMongoose;
-//# sourceMappingURL=plugin.d.ts.map
+
+export { type CacheData, type CacheEngine, type CacheOptions, type CacheTTL, CacheMongoose as default };