ts-cache-mongoose 1.7.0 → 1.7.2

package/dist/index.mjs

@@ -0,0 +1,323 @@
+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);
+};
+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 = 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 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 = 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 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;
+
+export { CacheMongoose as default };

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "ts-cache-mongoose",
-  "version": "1.7.0",
+  "version": "1.7.2",
   "description": "Cache plugin for mongoose Queries and Aggregate (in-memory, redis)",
-  "author": "Alex Eagle",
+  "author": "ilovepixelart",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -26,7 +26,6 @@
     "nosql",
     "ts",
     "typescript",
-    "swc",
     "cache",
     "redis",
     "store",
@@ -42,59 +41,65 @@
     "dist",
     "src",
     "tests",
-    ".swcrc",
     "tsconfig.json",
     "vite.config.mts",
     "biome.json"
   ],
+  "type": "module",
   "exports": {
-    ".": {
-      "import": {
-        "types": "./dist/esm/types/plugin.d.ts",
-        "default": "./dist/esm/plugin.js"
-      },
-      "require": {
-        "types": "./dist/cjs/types/plugin.d.ts",
-        "default": "./dist/cjs/plugin.js"
-      }
+    "require": {
+      "types": "./dist/index.d.cts",
+      "default": "./dist/index.cjs"
+    },
+    "import": {
+      "types": "./dist/index.d.mts",
+      "default": "./dist/index.mjs"
     }
   },
-  "main": "dist/cjs/plugin.js",
-  "module": "dist/esm/plugin.js",
-  "types": "dist/cjs/types/plugin.d.ts",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.cts",
   "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",
-    "build": "npm run clean && npm run build:cjs && npm run build:esm",
-    "build:cjs": "tsc -p config/tsconfig.cjs.json",
-    "build:esm": "tsc -p config/tsconfig.esm.json && bash/esm.sh",
-    "release": "npm install && npm run biome && npm run build && np"
+    "type:check": "tsc --noEmit",
+    "build": "pkgroll --clean-dist",
+    "release": "npm install && npm run biome && npm run type:check && npm run build && np"
   },
   "dependencies": {
-    "ioredis": "5.4.2",
+    "@types/ms": "2.1.0",
+    "@types/semver": "7.5.8",
+    "ioredis": "5.5.0",
     "ms": "2.1.3",
-    "semver": "7.6.3",
+    "semver": "7.7.1",
     "sort-keys": "4.2.0"
   },
   "devDependencies": {
     "@biomejs/biome": "1.9.4",
-    "@types/ms": "2.1.0",
-    "@types/node": "22.10.7",
-    "@types/semver": "7.5.8",
-    "@vitest/coverage-v8": "3.0.2",
-    "bson": "^6.10.1",
-    "merge": "2.1.1",
-    "mongodb-memory-server": "10.1.3",
-    "mongoose": "8.9.5",
+    "@types/node": "22.13.8",
+    "@vitest/coverage-v8": "3.0.7",
+    "bson": "^6.10.3",
+    "mongodb-memory-server": "10.1.4",
+    "mongoose": "8.11.0",
     "open-cli": "8.0.0",
-    "typescript": "5.7.3",
-    "vitest": "3.0.2"
+    "pkgroll": "2.11.2",
+    "simple-git-hooks": "^2.11.1",
+    "typescript": "5.8.2",
+    "vitest": "3.0.7"
   },
   "peerDependencies": {
     "bson": ">=4.7.2 < 7",
     "mongoose": ">=6.6.0 < 9"
+  },
+  "simple-git-hooks": {
+    "pre-commit": "npm run type:check",
+    "pre-push": "npm run biome:fix"
+  },
+  "overrides": {
+    "esbuild": "0.25.0"
   }
 }

package/src/extend/aggregate.ts

@@ -7,7 +7,7 @@ import type { CacheTTL } from '../types'
 export function extendAggregate(mongoose: Mongoose, cache: Cache): void {
   const mongooseExec = mongoose.Aggregate.prototype.exec
 
-  mongoose.Aggregate.prototype.getCacheKey = function () {
+  mongoose.Aggregate.prototype.getCacheKey = function (): string {
     if (this._key != null) return this._key
 
     return getKey({
@@ -15,7 +15,7 @@ export function extendAggregate(mongoose: Mongoose, cache: Cache): void {
     })
   }
 
-  mongoose.Aggregate.prototype.getCacheTTL = function () {
+  mongoose.Aggregate.prototype.getCacheTTL = function (): CacheTTL | null {
     return this._ttl
   }
 

package/src/extend/query.ts

@@ -7,7 +7,7 @@ import type { CacheTTL } from '../types'
 export function extendQuery(mongoose: Mongoose, cache: Cache): void {
   const mongooseExec = mongoose.Query.prototype.exec
 
-  mongoose.Query.prototype.getCacheKey = function () {
+  mongoose.Query.prototype.getCacheKey = function (): string {
     if (this._key != null) return this._key
 
     const filter = this.getFilter()
@@ -29,7 +29,7 @@ export function extendQuery(mongoose: Mongoose, cache: Cache): void {
     })
   }
 
-  mongoose.Query.prototype.getCacheTTL = function () {
+  mongoose.Query.prototype.getCacheTTL = function (): CacheTTL | null {
     return this._ttl
   }
 

package/src/{plugin.ts → index.ts}

@@ -5,6 +5,8 @@ import { extendQuery } from './extend/query'
 import type { Mongoose } from 'mongoose'
 import type { CacheOptions, CacheTTL } 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

package/tests/cache-debug.test.ts

@@ -1,10 +1,9 @@
 import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, vi } from 'vitest'
 
 import mongoose from 'mongoose'
-import CacheMongoose from '../src/plugin'
-import { server } from './mongo/server'
-
+import CacheMongoose from '../src/index'
 import { UserModel } from './models/User'
+import { server } from './mongo/server'
 
 describe('cache-debug', async () => {
   const instance = server('cache-debug')

package/tests/cache-memory.test.ts

@@ -1,10 +1,9 @@
 import { afterAll, beforeAll, beforeEach, describe, expect, it } from 'vitest'
 
 import mongoose from 'mongoose'
-import CacheMongoose from '../src/plugin'
-import { server } from './mongo/server'
-
+import CacheMongoose from '../src/index'
 import { UserModel } from './models/User'
+import { server } from './mongo/server'
 
 describe('cache-memory', async () => {
   const instance = server('cache-memory')

package/tests/cache-options.test.ts

@@ -1,5 +1,4 @@
 import { describe, expect, it, vi } from 'vitest'
-
 import { Cache } from '../src/cache/Cache'
 
 import type { CacheOptions } from '../src/types'

package/tests/cache-redis.test.ts

@@ -1,16 +1,14 @@
 import { afterAll, beforeAll, beforeEach, describe, expect, it } from 'vitest'
 
 import mongoose from 'mongoose'
-import plugin from '../src/plugin'
+import plugin from '../src/index'
 import { server } from './mongo/server'
 
+import { ObjectId } from 'bson'
 import { StoryModel } from './models/Story'
 import { UserModel } from './models/User'
 
-import { ObjectId } from 'bson'
-import { Types } from 'mongoose'
-
-import type CacheMongoose from '../src/plugin'
+import type CacheMongoose from '../src/index'
 
 describe('cache-redis', async () => {
   const instance = server('cache-redis')
@@ -244,7 +242,7 @@ describe('cache-redis', async () => {
     expect(miss).not.toBeNull()
 
     expect(typeof miss?._id).toBe('object')
-    expect(miss?._id instanceof Types.ObjectId).toBeTruthy()
+    expect(miss?._id instanceof mongoose.Types.ObjectId).toBeTruthy()
 
     expect(miss).toHaveProperty('name', 'G')
 
@@ -273,7 +271,7 @@ describe('cache-redis', async () => {
     expect(miss?.length).toBe(3)
 
     expect(typeof miss?.[0]).toBe('object')
-    expect(miss?.[0] instanceof Types.ObjectId).toBeTruthy()
+    expect(miss?.[0] instanceof mongoose.Types.ObjectId).toBeTruthy()
 
     const hit = await UserModel.distinct('_id').cache('30 seconds').exec()
     expect(hit).not.toBeNull()
@@ -314,7 +312,7 @@ describe('cache-redis', async () => {
     expect(miss).not.toBeNull()
 
     expect(typeof miss?._id).toBe('object')
-    expect(miss?._id instanceof Types.ObjectId).toBeTruthy()
+    expect(miss?._id instanceof mongoose.Types.ObjectId).toBeTruthy()
 
     expect(miss?.name).toBe('i')
     expect(miss?.stories).not.toBeNull()
@@ -323,7 +321,7 @@ describe('cache-redis', async () => {
     expect(miss?.stories?.[0]._id.toString()).toBe(story1._id.toString())
 
     expect(typeof miss?.stories?.[0]._id).toBe('object')
-    expect(miss?.stories?.[0]._id instanceof Types.ObjectId).toBeTruthy()
+    expect(miss?.stories?.[0]._id instanceof mongoose.Types.ObjectId).toBeTruthy()
 
     expect(typeof miss?.stories?.[0].createdAt).toBe('object')
     expect(miss?.stories?.[0].createdAt instanceof Date).toBeTruthy()
@@ -331,7 +329,7 @@ describe('cache-redis', async () => {
     expect(miss?.stories?.[1]._id.toString()).toBe(story2._id.toString())
 
     expect(typeof miss?.stories?.[1]._id).toBe('object')
-    expect(miss?.stories?.[1]._id instanceof Types.ObjectId).toBeTruthy()
+    expect(miss?.stories?.[1]._id instanceof mongoose.Types.ObjectId).toBeTruthy()
 
     expect(typeof miss?.stories?.[1].createdAt).toBe('object')
     expect(miss?.stories?.[1].createdAt instanceof Date).toBeTruthy()
@@ -450,7 +448,7 @@ describe('cache-redis', async () => {
     expect(populatedOriginal).not.toBeNull()
 
     expect(typeof populatedOriginal?._id).toBe('object')
-    expect(populatedOriginal?._id instanceof Types.ObjectId).toBeTruthy()
+    expect(populatedOriginal?._id instanceof mongoose.Types.ObjectId).toBeTruthy()
 
     expect(populatedOriginal?.name).toBe('Alex')
     expect(populatedOriginal?.stories).not.toBeNull()
@@ -459,7 +457,7 @@ describe('cache-redis', async () => {
     expect(populatedOriginal?.stories?.[0]._id.toString()).toBe(story1._id.toString())
 
     expect(typeof populatedOriginal?.stories?.[0]._id).toBe('object')
-    expect(populatedOriginal?.stories?.[0]._id instanceof Types.ObjectId).toBeTruthy()
+    expect(populatedOriginal?.stories?.[0]._id instanceof mongoose.Types.ObjectId).toBeTruthy()
 
     expect(typeof populatedOriginal?.stories?.[0].createdAt).toBe('object')
     expect(populatedOriginal?.stories?.[0].createdAt instanceof Date).toBeTruthy()
@@ -467,7 +465,7 @@ describe('cache-redis', async () => {
     expect(populatedOriginal?.stories?.[1]._id.toString()).toBe(story2._id.toString())
 
     expect(typeof populatedOriginal?.stories?.[1]._id).toBe('object')
-    expect(populatedOriginal?.stories?.[1]._id instanceof Types.ObjectId).toBeTruthy()
+    expect(populatedOriginal?.stories?.[1]._id instanceof mongoose.Types.ObjectId).toBeTruthy()
 
     expect(typeof populatedOriginal?.stories?.[1].createdAt).toBe('object')
     expect(populatedOriginal?.stories?.[1].createdAt instanceof Date).toBeTruthy()

package/tests/key.test.ts

@@ -1,7 +1,8 @@
 import { describe, expect, it } from 'vitest'
-import { getKey } from '../src/key'
 
 import { Types } from 'mongoose'
+import { getKey } from '../src/key'
+
 const { ObjectId } = Types
 
 describe('generateHash()', () => {

package/tsconfig.json

@@ -1,9 +1,11 @@
 {
+  "include": ["src"],
   "compilerOptions": {
     "target": "ES2021",
     "lib": ["ES2021"],
-    "module": "CommonJS",
-    "moduleResolution": "Node",
+    "types": ["node"],
+    "module": "Preserve",
+    "moduleResolution": "bundler",
     "outDir": "dist",
     "strict": true,
     "allowSyntheticDefaultImports": true,
@@ -27,7 +29,5 @@
     "removeComments": true,
     "skipLibCheck": true,
     "sourceMap": true
-  },
-  "include": ["src"],
-  "exclude": ["tests", "dist", "coverage", "node_modules"]
+  }
 }

package/vite.config.mts

@@ -7,6 +7,7 @@ export default defineConfig({
     environment: 'node',
     coverage: {
       reporter: ['lcov'],
+      include: ['src/**/*.ts'],
     },
   },
 })

package/.swcrc

@@ -1,17 +0,0 @@
-{
-  "$schema": "https://json.schemastore.org/swcrc",
-  "jsc": {
-    "parser": {
-      "syntax": "typescript",
-      "decorators": true,
-      "dynamicImport": true
-    },
-    "target": "es2021",
-    "keepClassNames": true,
-    "loose": true
-  },
-  "module": {
-    "type": "commonjs"
-  },
-  "sourceMaps": true
-}