PeerTube/server/core/models/shared/model-cache.ts

95 lines
2.2 KiB
TypeScript

import { Model } from 'sequelize-typescript'
import { logger } from '@server/helpers/logger.js'
type ModelCacheType =
'server-account'
| 'local-actor-name'
| 'local-actor-url'
| 'load-video-immutable-id'
| 'load-video-immutable-url'
type DeleteKey =
'video'
class ModelCache {
private static instance: ModelCache
private readonly localCache: { [id in ModelCacheType]: Map<string, any> } = {
'server-account': new Map(),
'local-actor-name': new Map(),
'local-actor-url': new Map(),
'load-video-immutable-id': new Map(),
'load-video-immutable-url': new Map()
}
private readonly deleteIds: {
[deleteKey in DeleteKey]: Map<number, { cacheType: ModelCacheType, key: string }[]>
} = {
video: new Map()
}
private constructor () {
}
static get Instance () {
return this.instance || (this.instance = new this())
}
doCache<T extends Model> (options: {
cacheType: ModelCacheType
key: string
fun: () => Promise<T>
whitelist?: () => boolean
deleteKey?: DeleteKey
}) {
const { cacheType, key, fun, whitelist, deleteKey } = options
if (whitelist && whitelist() !== true) return fun()
const cache = this.localCache[cacheType]
if (cache.has(key)) {
logger.debug('Model cache hit for %s -> %s.', cacheType, key)
return Promise.resolve<T>(cache.get(key))
}
return fun().then(m => {
if (!m) return m
if (!whitelist || whitelist()) cache.set(key, m)
if (deleteKey) {
const map = this.deleteIds[deleteKey]
if (!map.has(m.id)) map.set(m.id, [])
const a = map.get(m.id)
a.push({ cacheType, key })
}
return m
})
}
invalidateCache (deleteKey: DeleteKey, modelId: number) {
const map = this.deleteIds[deleteKey]
if (!map.has(modelId)) return
for (const toDelete of map.get(modelId)) {
logger.debug('Removing %s -> %d of model cache %s -> %s.', deleteKey, modelId, toDelete.cacheType, toDelete.key)
this.localCache[toDelete.cacheType].delete(toDelete.key)
}
map.delete(modelId)
}
clearCache (cacheType: ModelCacheType) {
this.localCache[cacheType] = new Map()
}
}
export {
ModelCache
}