ts-cache-mongoose 1.7.6 → 2.0.0

package/README.md

@@ -23,8 +23,8 @@ Caching queries is a good way to improve performance of your application
 
 ```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",
 }
 ```
 
@@ -51,94 +51,117 @@ 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
+- This plugin requires `mongoose` 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 mongoose
+pnpm add mongoose
+yarn add mongoose
+bun add 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
 
-// To clear all cache, don't use in production unless you know what you are doing
+```typescript
+const instance = cache.init(mongoose, { engine: 'memory', defaultTTL: '60 seconds' })
+
+// 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')
+  }
+}
 ```
 
 ## Check my other projects

package/biome.json

@@ -1,5 +1,5 @@
 {
-  "$schema": "https://biomejs.dev/schemas/2.2.7/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,12 +1,59 @@
 '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');
+
+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 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 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,
+  seconds: s,
+  second: s,
+  secs: s,
+  sec: s,
+  s,
+  milliseconds: 1,
+  millisecond: 1,
+  msecs: 1,
+  msec: 1,
+  ms: 1
+};
+const ms = (val) => {
+  const str = String(val);
+  if (str.length > 100) return 0;
+  const match = RE.exec(str);
+  if (!match) return 0;
+  const n = Number.parseFloat(match[1] ?? "");
+  const type = (match[2] ?? "ms").toLowerCase();
+  return n * (UNITS[type] ?? 0);
+};
 
 var __typeError$3 = (msg) => {
   throw TypeError(msg);
@@ -48,7 +95,7 @@ class MemoryCacheEngine {
 }
 _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) {
@@ -176,8 +223,42 @@ _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;
   });

package/dist/index.d.cts

@@ -1,8 +1,7 @@
 import { Mongoose } from 'mongoose';
 import { RedisOptions } from 'ioredis';
-import { StringValue } from 'ms';
 
-type CacheTTL = number | StringValue;
+type CacheTTL = number | string;
 type CacheData = Record<string, unknown> | Record<string, unknown>[] | unknown[] | number | undefined;
 type CacheOptions = {
     engine: 'memory' | 'redis';
@@ -50,3 +49,4 @@ declare class CacheMongoose {
 
 export { CacheMongoose as default };
 export type { CacheData, CacheEngine, CacheOptions, CacheTTL };
+//# sourceMappingURL=index.d.cts.map

package/dist/index.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.cts","sources":["../src/types.ts","../src/index.ts"],"mappings":";;;AAEM,KAAM,QAAQ;AAEd,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;;;ACTtB;;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

@@ -1,8 +1,7 @@
 import { Mongoose } from 'mongoose';
 import { RedisOptions } from 'ioredis';
-import { StringValue } from 'ms';
 
-type CacheTTL = number | StringValue;
+type CacheTTL = number | string;
 type CacheData = Record<string, unknown> | Record<string, unknown>[] | unknown[] | number | undefined;
 type CacheOptions = {
     engine: 'memory' | 'redis';
@@ -50,3 +49,4 @@ declare class CacheMongoose {
 
 export { CacheMongoose as default };
 export type { CacheData, CacheEngine, CacheOptions, CacheTTL };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","sources":["../src/types.ts","../src/index.ts"],"mappings":";;;AAEM,KAAM,QAAQ;AAEd,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;;;ACTtB;;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,10 +1,57 @@
-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';
+
+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 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 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,
+  seconds: s,
+  second: s,
+  secs: s,
+  sec: s,
+  s,
+  milliseconds: 1,
+  millisecond: 1,
+  msecs: 1,
+  msec: 1,
+  ms: 1
+};
+const ms = (val) => {
+  const str = String(val);
+  if (str.length > 100) return 0;
+  const match = RE.exec(str);
+  if (!match) return 0;
+  const n = Number.parseFloat(match[1] ?? "");
+  const type = (match[2] ?? "ms").toLowerCase();
+  return n * (UNITS[type] ?? 0);
+};
 
 var __typeError$3 = (msg) => {
   throw TypeError(msg);
@@ -46,7 +93,7 @@ class MemoryCacheEngine {
 }
 _cache = new WeakMap();
 
-const isMongooseLessThan7 = 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) {
@@ -174,8 +221,42 @@ _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;
   });

package/dist/nest/index.cjs

@@ -0,0 +1,111 @@
+'use strict';
+
+var common = require('@nestjs/common');
+var mongoose = require('mongoose');
+var index = require('../index.cjs');
+require('bson');
+require('ioredis');
+require('node:crypto');
+
+const CACHE_OPTIONS = Symbol("CACHE_OPTIONS");
+class CacheService {
+  constructor(options) {
+    this.logger = new common.Logger(CacheService.name);
+    this.options = options;
+  }
+  get instance() {
+    return this.cacheMongoose;
+  }
+  async onApplicationBootstrap() {
+    this.cacheMongoose = index.init(mongoose, this.options);
+    this.logger.log(`Cache initialized with ${this.options.engine} engine`);
+  }
+  async onApplicationShutdown() {
+    if (this.cacheMongoose) {
+      await this.cacheMongoose.close();
+    }
+  }
+  async clear(customKey) {
+    await this.cacheMongoose.clear(customKey);
+  }
+}
+
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (decorator(result)) || result;
+  return result;
+};
+exports.CacheModule = class CacheModule {
+  static forRoot(options) {
+    return {
+      module: exports.CacheModule,
+      global: options.isGlobal ?? false,
+      providers: [
+        { provide: CACHE_OPTIONS, useValue: options },
+        {
+          provide: CacheService,
+          useFactory: (opts) => new CacheService(opts),
+          inject: [CACHE_OPTIONS]
+        }
+      ],
+      exports: [CacheService]
+    };
+  }
+  static forRootAsync(options) {
+    const asyncProviders = exports.CacheModule.createAsyncProviders(options);
+    return {
+      module: exports.CacheModule,
+      global: options.isGlobal ?? false,
+      imports: options.imports ?? [],
+      providers: [
+        ...asyncProviders,
+        {
+          provide: CacheService,
+          useFactory: (opts) => new CacheService(opts),
+          inject: [CACHE_OPTIONS]
+        }
+      ],
+      exports: [CacheService]
+    };
+  }
+  static createAsyncProviders(options) {
+    if (options.useFactory) {
+      return [
+        {
+          provide: CACHE_OPTIONS,
+          useFactory: options.useFactory,
+          inject: options.inject ?? []
+        }
+      ];
+    }
+    if (options.useClass) {
+      return [
+        { provide: options.useClass, useClass: options.useClass },
+        {
+          provide: CACHE_OPTIONS,
+          useFactory: (factory) => factory.createCacheOptions(),
+          inject: [options.useClass]
+        }
+      ];
+    }
+    if (options.useExisting) {
+      return [
+        {
+          provide: CACHE_OPTIONS,
+          useFactory: (factory) => factory.createCacheOptions(),
+          inject: [options.useExisting]
+        }
+      ];
+    }
+    return [];
+  }
+};
+exports.CacheModule = __decorateClass([
+  common.Module({})
+], exports.CacheModule);
+
+exports.CACHE_OPTIONS = CACHE_OPTIONS;
+exports.CacheService = CacheService;

package/dist/nest/index.d.cts

@@ -0,0 +1,40 @@
+import { ModuleMetadata, InjectionToken, OptionalFactoryDependency, Type, DynamicModule, OnApplicationBootstrap, OnApplicationShutdown } from '@nestjs/common';
+import CacheMongoose, { CacheOptions } from '../index.cjs';
+import 'mongoose';
+import 'ioredis';
+
+type CacheModuleOptions = CacheOptions;
+interface CacheOptionsFactory {
+    createCacheOptions(): CacheModuleOptions | Promise<CacheModuleOptions>;
+}
+interface CacheModuleAsyncOptions extends Pick<ModuleMetadata, 'imports'> {
+    isGlobal?: boolean;
+    inject?: (InjectionToken | OptionalFactoryDependency)[];
+    useClass?: Type<CacheOptionsFactory>;
+    useExisting?: Type<CacheOptionsFactory>;
+    useFactory?: (...args: any[]) => CacheModuleOptions | Promise<CacheModuleOptions>;
+}
+
+declare class CacheModule {
+    static forRoot(options: CacheModuleOptions & {
+        isGlobal?: boolean;
+    }): DynamicModule;
+    static forRootAsync(options: CacheModuleAsyncOptions): DynamicModule;
+    private static createAsyncProviders;
+}
+
+declare const CACHE_OPTIONS: unique symbol;
+declare class CacheService implements OnApplicationBootstrap, OnApplicationShutdown {
+    private readonly logger;
+    private readonly options;
+    private cacheMongoose;
+    constructor(options: CacheModuleOptions);
+    get instance(): CacheMongoose;
+    onApplicationBootstrap(): Promise<void>;
+    onApplicationShutdown(): Promise<void>;
+    clear(customKey?: string): Promise<void>;
+}
+
+export { CACHE_OPTIONS, CacheModule, CacheService };
+export type { CacheModuleAsyncOptions, CacheModuleOptions, CacheOptionsFactory };
+//# sourceMappingURL=index.d.cts.map

package/dist/nest/index.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.cts","sources":["../../src/nest/interfaces.ts","../../src/nest/cache.module.ts","../../src/nest/cache.service.ts"],"mappings":";;;;;AAGM,KAAM,kBAAkB,GAAG,YAAY;AAEvC,UAAW,mBAAmB;0BACZ,kBAAkB,GAAG,OAAO,CAAC,kBAAkB;;AAGjE,UAAW,uBAAwB,SAAQ,IAAI,CAAC,cAAc;;cAExD,cAAc,GAAG,yBAAyB;eACzC,IAAI,CAAC,mBAAmB;kBACrB,IAAI,CAAC,mBAAmB;qCAEL,kBAAkB,GAAG,OAAO,CAAC,kBAAkB;;;ACRlF,cACa,WAAW;4BACE,kBAAkB;;QAA4B,aAAa;iCAgBtD,uBAAuB,GAAG,aAAa;;;;AClBtE,cAAa,aAAa;AAE1B,cAAa,YAAa,YAAW,sBAAsB,EAAE,qBAAqB;;;;yBAK3D,kBAAkB;oBAIvB,aAAa;8BAIG,OAAO;6BAKR,OAAO;+BAML,OAAO","names":[]}

package/dist/nest/index.d.mts

@@ -0,0 +1,40 @@
+import { ModuleMetadata, InjectionToken, OptionalFactoryDependency, Type, DynamicModule, OnApplicationBootstrap, OnApplicationShutdown } from '@nestjs/common';
+import CacheMongoose, { CacheOptions } from '../index.mjs';
+import 'mongoose';
+import 'ioredis';
+
+type CacheModuleOptions = CacheOptions;
+interface CacheOptionsFactory {
+    createCacheOptions(): CacheModuleOptions | Promise<CacheModuleOptions>;
+}
+interface CacheModuleAsyncOptions extends Pick<ModuleMetadata, 'imports'> {
+    isGlobal?: boolean;
+    inject?: (InjectionToken | OptionalFactoryDependency)[];
+    useClass?: Type<CacheOptionsFactory>;
+    useExisting?: Type<CacheOptionsFactory>;
+    useFactory?: (...args: any[]) => CacheModuleOptions | Promise<CacheModuleOptions>;
+}
+
+declare class CacheModule {
+    static forRoot(options: CacheModuleOptions & {
+        isGlobal?: boolean;
+    }): DynamicModule;
+    static forRootAsync(options: CacheModuleAsyncOptions): DynamicModule;
+    private static createAsyncProviders;
+}
+
+declare const CACHE_OPTIONS: unique symbol;
+declare class CacheService implements OnApplicationBootstrap, OnApplicationShutdown {
+    private readonly logger;
+    private readonly options;
+    private cacheMongoose;
+    constructor(options: CacheModuleOptions);
+    get instance(): CacheMongoose;
+    onApplicationBootstrap(): Promise<void>;
+    onApplicationShutdown(): Promise<void>;
+    clear(customKey?: string): Promise<void>;
+}
+
+export { CACHE_OPTIONS, CacheModule, CacheService };
+export type { CacheModuleAsyncOptions, CacheModuleOptions, CacheOptionsFactory };
+//# sourceMappingURL=index.d.mts.map

package/dist/nest/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","sources":["../../src/nest/interfaces.ts","../../src/nest/cache.module.ts","../../src/nest/cache.service.ts"],"mappings":";;;;;AAGM,KAAM,kBAAkB,GAAG,YAAY;AAEvC,UAAW,mBAAmB;0BACZ,kBAAkB,GAAG,OAAO,CAAC,kBAAkB;;AAGjE,UAAW,uBAAwB,SAAQ,IAAI,CAAC,cAAc;;cAExD,cAAc,GAAG,yBAAyB;eACzC,IAAI,CAAC,mBAAmB;kBACrB,IAAI,CAAC,mBAAmB;qCAEL,kBAAkB,GAAG,OAAO,CAAC,kBAAkB;;;ACRlF,cACa,WAAW;4BACE,kBAAkB;;QAA4B,aAAa;iCAgBtD,uBAAuB,GAAG,aAAa;;;;AClBtE,cAAa,aAAa;AAE1B,cAAa,YAAa,YAAW,sBAAsB,EAAE,qBAAqB;;;;yBAK3D,kBAAkB;oBAIvB,aAAa;8BAIG,OAAO;6BAKR,OAAO;+BAML,OAAO","names":[]}