Merge pull request #273 from ilovepixelart/feature/move-all-types-to-one-file

Types

Author: ilovepixelart

.gitignore

@@ -14,5 +14,5 @@ npm-debug.log
 .idea
 .env
 
-# Inmemmory mongo config
+# In-memory mongo config
 /globalConfig.json

.vscode/settings.json

@@ -30,6 +30,7 @@
     "sonarqube",
     "sonarsource",
     "swcrc",
-    "virtuals"
+    "virtuals",
+    "Webstorm"
   ]
 }

src/cache/Cache.ts

@@ -1,20 +1,17 @@
 import ms from 'ms'
 
-import MemoryCacheEngine from './engine/MemoryCacheEngine'
-import RedisCacheEngine from './engine/RedisCacheEngine'
+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'
+import type { CacheData, CacheEngine, CacheOptions, CacheTTL } from '../types'
 
-class CacheEngine {
-  #engine!: ICacheEngine
-  #defaultTTL: number
-  #debug: boolean
+export 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)
@@ -76,5 +73,3 @@ class CacheEngine {
     return this.#engine.close()
   }
 }
-
-export default CacheEngine

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>
+export 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, {
@@ -41,5 +39,3 @@ class MemoryCacheEngine implements ICacheEngine {
     // do nothing
   }
 }
-
-export default MemoryCacheEngine

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
+export 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
@@ -55,5 +53,3 @@ class RedisCacheEngine implements ICacheEngine {
     await this.#client.quit()
   }
 }
-
-export default RedisCacheEngine

src/extend/aggregate.ts

@@ -1,10 +1,10 @@
 import { getKey } from '../key'
 
 import type { Mongoose } from 'mongoose'
-import type { StringValue } from 'ms'
-import type Cache from '../cache/Cache'
+import type { Cache } from '../cache/Cache'
+import type { CacheTTL } from '../types'
 
-export default function extendQuery(mongoose: Mongoose, cache: Cache): void {
+export function extendAggregate(mongoose: Mongoose, cache: Cache): void {
   const mongooseExec = mongoose.Aggregate.prototype.exec
 
   mongoose.Aggregate.prototype.getCacheKey = function () {
@@ -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

src/extend/query.ts

@@ -1,10 +1,10 @@
 import { getKey } from '../key'
 
 import type { Mongoose } from 'mongoose'
-import type { StringValue } from 'ms'
-import type Cache from '../cache/Cache'
+import type { Cache } from '../cache/Cache'
+import type { CacheTTL } from '../types'
 
-export default function extendQuery(mongoose: Mongoose, cache: Cache): void {
+export function extendQuery(mongoose: Mongoose, cache: Cache): void {
   const mongooseExec = mongoose.Query.prototype.exec
 
   mongoose.Query.prototype.getCacheKey = function () {
@@ -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

src/interfaces/ICacheEngine.ts

@@ -1,18 +1,17 @@
-import Cache from './cache/Cache'
-import extendAggregate from './extend/aggregate'
-import extendQuery from './extend/query'
+import { Cache } from './cache/Cache'
+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)

src/interfaces/ICacheOptions.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 type CacheOptions = {
+  engine: 'memory' | 'redis'
+  engineOptions?: RedisOptions
+  defaultTTL?: CacheTTL
+  debug?: boolean
+}
+
+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
+}

src/interfaces/IData.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()

src/plugin.ts

@@ -2,9 +2,9 @@ import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, vi }
 
 import mongoose from 'mongoose'
 import CacheMongoose from '../src/plugin'
-import server from './mongo/server'
+import { server } from './mongo/server'
 
-import User from './models/User'
+import { UserModel } from './models/User'
 
 describe('cache-debug', async () => {
   const instance = server('cache-debug')
@@ -36,7 +36,7 @@ describe('cache-debug', async () => {
 
   describe('debug scenarios', () => {
     it('should create a use and and query it two time first is cache miss second is hit, also clear by key and global', async () => {
-      const user = await User.create({
+      const user = await UserModel.create({
         name: 'John Doe',
         role: 'admin',
       })
@@ -49,14 +49,14 @@ describe('cache-debug', async () => {
       const cacheClearRegExp = /\[ts-cache-mongoose\] CLEAR/
       const cacheDelRegExp = /\[ts-cache-mongoose\] DEL '.*?'/
 
-      const userCacheMiss = await User.findById(user._id).cache(ttl, key).exec()
+      const userCacheMiss = await UserModel.findById(user._id).cache(ttl, key).exec()
       expect(console.log).toHaveBeenCalledWith(expect.stringMatching(cacheMissRegExp))
       expect(userCacheMiss).not.toBeNull()
       expect(userCacheMiss?._id.toString()).toBe(user._id.toString())
       expect(userCacheMiss?.name).toEqual(user.name)
       expect(userCacheMiss?.role).toEqual(user.role)
 
-      const userCacheHit = await User.findById(user._id).cache(ttl, key).exec()
+      const userCacheHit = await UserModel.findById(user._id).cache(ttl, key).exec()
       expect(console.log).toHaveBeenCalledWith(expect.stringMatching(cacheSetRegExp))
       expect(console.log).toHaveBeenCalledWith(expect.stringMatching(cacheHitRegExp))
       expect(userCacheHit).not.toBeNull()