Move all types to one file and renamed:

ilovepixelart · ilovepixelart · commit 8851b9a7d272 · 2025-01-19T13:37:53.000+01:00
- type IData -&gt; CacheData
- type ICacheOptions -&gt; CacheOptions
- type ICacheEngine -&gt; CacheEngine
- class CacheEngine -&gt; Cache
diff --git a/src/cache/Cache.ts b/src/cache/Cache.ts
@@ -3,18 +3,15 @@ import ms from 'ms'
 import MemoryCacheEngine from './engine/MemoryCacheEngine'
 import RedisCacheEngine from './engine/RedisCacheEngine'
 
-import type { StringValue } from 'ms'
-import type ICacheEngine from '../interfaces/ICacheEngine'
-import type ICacheOptions from '../interfaces/ICacheOptions'
-import type IData from '../interfaces/IData'
-
-class CacheEngine {
-  #engine!: ICacheEngine
-  #defaultTTL: number
-  #debug: boolean
+import type { CacheData, CacheEngine, CacheOptions, CacheTTL } from '../types'
+
+class Cache {
+  readonly #engine!: CacheEngine
+  readonly #defaultTTL: number
+  readonly #debug: boolean
   readonly #engines = ['memory', 'redis'] as const
 
-  constructor(cacheOptions: ICacheOptions) {
+  constructor(cacheOptions: CacheOptions) {
     if (!this.#engines.includes(cacheOptions.engine)) {
       throw new Error(`Invalid engine name: ${cacheOptions.engine}`)
     }
@@ -40,7 +37,7 @@ class CacheEngine {
     this.#debug = cacheOptions.debug === true
   }
 
-  async get(key: string): Promise<IData> {
+  async get(key: string): Promise<CacheData> {
     const cacheEntry = await this.#engine.get(key)
     if (this.#debug) {
       const cacheHit = cacheEntry != null ? 'HIT' : 'MISS'
@@ -49,7 +46,7 @@ class CacheEngine {
     return cacheEntry
   }
 
-  async set(key: string, value: IData, ttl: number | StringValue | null): Promise<void> {
+  async set(key: string, value: CacheData, ttl: CacheTTL | null): Promise<void> {
     const givenTTL = typeof ttl === 'string' ? ms(ttl) : ttl
     const actualTTL = givenTTL ?? this.#defaultTTL
     await this.#engine.set(key, value, actualTTL)
@@ -77,4 +74,4 @@ class CacheEngine {
   }
 }
 
-export default CacheEngine
+export default Cache
diff --git a/src/cache/engine/MemoryCacheEngine.ts b/src/cache/engine/MemoryCacheEngine.ts
@@ -1,17 +1,15 @@
 import ms from 'ms'
 
-import type { StringValue } from 'ms'
-import type ICacheEngine from '../../interfaces/ICacheEngine'
-import type IData from '../../interfaces/IData'
+import type { CacheData, CacheEngine, CacheTTL } from '../../types'
 
-class MemoryCacheEngine implements ICacheEngine {
-  #cache: Map<string, { value: IData; expiresAt: number } | undefined>
+class MemoryCacheEngine implements CacheEngine {
+  readonly #cache: Map<string, { value: CacheData; expiresAt: number } | undefined>
 
   constructor() {
     this.#cache = new Map()
   }
 
-  get(key: string): IData {
+  get(key: string): CacheData {
     const item = this.#cache.get(key)
     if (!item || item.expiresAt < Date.now()) {
       this.del(key)
@@ -20,7 +18,7 @@ class MemoryCacheEngine implements ICacheEngine {
     return item.value
   }
 
-  set(key: string, value: IData, ttl?: number | StringValue): void {
+  set(key: string, value: CacheData, ttl?: CacheTTL): void {
     const givenTTL = typeof ttl === 'string' ? ms(ttl) : ttl
     const actualTTL = givenTTL ?? Number.POSITIVE_INFINITY
     this.#cache.set(key, {
diff --git a/src/cache/engine/RedisCacheEngine.ts b/src/cache/engine/RedisCacheEngine.ts
@@ -5,12 +5,10 @@ import ms from 'ms'
 import { convertToObject } from '../../version'
 
 import type { Redis, RedisOptions } from 'ioredis'
-import type { StringValue } from 'ms'
-import type ICacheEngine from '../../interfaces/ICacheEngine'
-import type IData from '../../interfaces/IData'
+import type { CacheData, CacheEngine, CacheTTL } from '../../types'
 
-class RedisCacheEngine implements ICacheEngine {
-  #client: Redis
+class RedisCacheEngine implements CacheEngine {
+  readonly #client: Redis
 
   constructor(options: RedisOptions) {
     if (!options.keyPrefix) {
@@ -19,20 +17,20 @@ class RedisCacheEngine implements ICacheEngine {
     this.#client = new IORedis(options)
   }
 
-  async get(key: string): Promise<IData> {
+  async get(key: string): Promise<CacheData> {
     try {
       const value = await this.#client.get(key)
       if (value === null) {
         return undefined
       }
-      return EJSON.parse(value) as IData
+      return EJSON.parse(value) as CacheData
     } catch (err) {
       console.error(err)
       return undefined
     }
   }
 
-  async set(key: string, value: IData, ttl?: number | StringValue): Promise<void> {
+  async set(key: string, value: CacheData, ttl?: CacheTTL): Promise<void> {
     try {
       const givenTTL = typeof ttl === 'string' ? ms(ttl) : ttl
       const actualTTL = givenTTL ?? Number.POSITIVE_INFINITY
diff --git a/src/extend/aggregate.ts b/src/extend/aggregate.ts
@@ -1,8 +1,8 @@
 import { getKey } from '../key'
 
 import type { Mongoose } from 'mongoose'
-import type { StringValue } from 'ms'
 import type Cache from '../cache/Cache'
+import type { CacheTTL } from '../types'
 
 export default function extendQuery(mongoose: Mongoose, cache: Cache): void {
   const mongooseExec = mongoose.Aggregate.prototype.exec
@@ -19,7 +19,7 @@ export default function extendQuery(mongoose: Mongoose, cache: Cache): void {
     return this._ttl
   }
 
-  mongoose.Aggregate.prototype.cache = function (ttl?: number | StringValue, customKey?: string) {
+  mongoose.Aggregate.prototype.cache = function (ttl?: CacheTTL, customKey?: string) {
     this._ttl = ttl ?? null
     this._key = customKey ?? null
     return this
diff --git a/src/extend/query.ts b/src/extend/query.ts
@@ -1,8 +1,8 @@
 import { getKey } from '../key'
 
 import type { Mongoose } from 'mongoose'
-import type { StringValue } from 'ms'
 import type Cache from '../cache/Cache'
+import type { CacheTTL } from '../types'
 
 export default function extendQuery(mongoose: Mongoose, cache: Cache): void {
   const mongooseExec = mongoose.Query.prototype.exec
@@ -33,7 +33,7 @@ export default function extendQuery(mongoose: Mongoose, cache: Cache): void {
     return this._ttl
   }
 
-  mongoose.Query.prototype.cache = function (ttl?: number | StringValue, customKey?: string) {
+  mongoose.Query.prototype.cache = function (ttl?: CacheTTL, customKey?: string) {
     this._ttl = ttl ?? null
     this._key = customKey ?? null
     return this
diff --git a/src/interfaces/ICacheEngine.ts b/src/interfaces/ICacheEngine.ts
diff --git a/src/interfaces/ICacheOptions.ts b/src/interfaces/ICacheOptions.ts
diff --git a/src/interfaces/IData.ts b/src/interfaces/IData.ts
diff --git a/src/plugin.ts b/src/plugin.ts
@@ -3,16 +3,15 @@ import extendAggregate from './extend/aggregate'
 import extendQuery from './extend/query'
 
 import type { Mongoose } from 'mongoose'
-import type { StringValue } from 'ms'
-import type ICacheOptions from './interfaces/ICacheOptions'
+import type { CacheOptions, CacheTTL } from './types'
 
 declare module 'mongoose' {
   interface Query<ResultType, DocType, THelpers, RawDocType> {
-    cache: (this: Query<ResultType, DocType, THelpers, RawDocType>, ttl?: number | StringValue, customKey?: string) => this
+    cache: (this: Query<ResultType, DocType, THelpers, RawDocType>, ttl?: CacheTTL, customKey?: string) => this
     _key: string | null
     getCacheKey: (this: Query<ResultType, DocType, THelpers, RawDocType>) => string
-    _ttl: number | StringValue | null
-    getCacheTTL: (this: Query<ResultType, DocType, THelpers, RawDocType>) => number | StringValue | null
+    _ttl: CacheTTL | null
+    getCacheTTL: (this: Query<ResultType, DocType, THelpers, RawDocType>) => CacheTTL | null
     op?: string
     _path?: unknown
     _fields?: unknown
@@ -21,11 +20,11 @@ declare module 'mongoose' {
   }
 
   interface Aggregate<ResultType> {
-    cache: (this: Aggregate<ResultType>, ttl?: number | StringValue, customKey?: string) => this
+    cache: (this: Aggregate<ResultType>, ttl?: CacheTTL, customKey?: string) => this
     _key: string | null
     getCacheKey: (this: Aggregate<ResultType>) => string
-    _ttl: number | StringValue | null
-    getCacheTTL: (this: Aggregate<ResultType>) => number | StringValue | null
+    _ttl: CacheTTL | null
+    getCacheTTL: (this: Aggregate<ResultType>) => CacheTTL | null
   }
 }
 
@@ -37,7 +36,7 @@ class CacheMongoose {
     // Private constructor to prevent external instantiation
   }
 
-  public static init(mongoose: Mongoose, cacheOptions: ICacheOptions): CacheMongoose {
+  public static init(mongoose: Mongoose, cacheOptions: CacheOptions): CacheMongoose {
     if (!CacheMongoose.#instance) {
       CacheMongoose.#instance = new CacheMongoose()
       CacheMongoose.#instance.cache = new Cache(cacheOptions)
diff --git a/src/types.ts b/src/types.ts
@@ -0,0 +1,21 @@
+import type { RedisOptions } from 'ioredis'
+import type { StringValue } from 'ms'
+
+export type CacheTTL = number | StringValue
+
+export type CacheData = Record<string, unknown> | Record<string, unknown>[] | unknown[] | number | undefined
+
+export 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
+}
+
+export interface CacheOptions {
+  engine: 'memory' | 'redis'
+  engineOptions?: RedisOptions
+  defaultTTL?: CacheTTL
+  debug?: boolean
+}
diff --git a/src/version.ts b/src/version.ts
@@ -1,11 +1,11 @@
 import mongoose from 'mongoose'
 import { satisfies } from 'semver'
 
-import type IData from './interfaces/IData'
+import type { CacheData } from './types'
 
 export const isMongooseLessThan7 = satisfies(mongoose.version, '<7')
 
-export const convertToObject = <T>(value: (T & { toObject?: () => IData }) | undefined): IData => {
+export const convertToObject = <T>(value: (T & { toObject?: () => CacheData }) | undefined): CacheData => {
   if (isMongooseLessThan7) {
     if (value != null && typeof value === 'object' && !Array.isArray(value) && value.toObject) {
       return value.toObject()
diff --git a/tests/cache-options.test.ts b/tests/cache-options.test.ts
@@ -2,11 +2,11 @@ import { describe, expect, it, vi } from 'vitest'
 
 import Cache from '../src/cache/Cache'
 
-import type ICacheOptions from '../src/interfaces/ICacheOptions'
+import type { CacheOptions } from '../src/types'
 
 describe('Cache class tests', () => {
   it('should create a new instance of Cache', () => {
-    const cacheOptions: ICacheOptions = {
+    const cacheOptions: CacheOptions = {
       engine: 'memory',
     }
 
@@ -20,7 +20,7 @@ describe('Cache class tests', () => {
   })
 
   it('should throw an error if the cache engine is not supported', () => {
-    const cacheOptions: ICacheOptions = {
+    const cacheOptions: CacheOptions = {
       // @ts-expect-error Testing invalid engine name
       engine: 'not-supported',
     }
@@ -29,15 +29,15 @@ describe('Cache class tests', () => {
   })
 
   it('should throw an error if the cache engine is redis and no engine options are provided', () => {
-    const cacheOptions: ICacheOptions = {
+    const cacheOptions: CacheOptions = {
       engine: 'redis',
     }
 
     expect(() => new Cache(cacheOptions)).toThrow(`Engine options are required for ${cacheOptions.engine} engine`)
   })
 
   it('should create a new instance of Cache with redis engine', async () => {
-    const cacheOptions: ICacheOptions = {
+    const cacheOptions: CacheOptions = {
       engine: 'redis',
       engineOptions: {
         host: 'localhost',
