const db = uniCloud.database()
|
|
function getType(value) {
|
return Object.prototype.toString.call(value).slice(8, -1).toLowerCase()
|
}
|
|
const validator = {
|
key: function(value) {
|
const err = new Error('Invalid key')
|
if (typeof value !== 'string') {
|
throw err
|
}
|
const valueTrim = value.trim()
|
if (!valueTrim || valueTrim !== value) {
|
throw err
|
}
|
},
|
value: function(value) {
|
// 仅作简单校验
|
const type = getType(value)
|
const validValueType = ['null', 'number', 'string', 'array', 'object']
|
if (validValueType.indexOf(type) === -1) {
|
throw new Error('Invalid value type')
|
}
|
},
|
duration: function(value) {
|
const err = new Error('Invalid duration')
|
if (value === undefined) {
|
return
|
}
|
if (typeof value !== 'number' || value === 0) {
|
throw err
|
}
|
}
|
}
|
|
/**
|
* 入库时 expired 为过期时间对应的时间戳，永不过期用-1表示
|
* 返回结果时 与redis对齐，-1表示永不过期，-2表示已过期或不存在
|
*/
|
class DatabaseCache {
|
constructor({
|
collection = 'opendb-open-data'
|
} = {}) {
|
this.type = 'db'
|
this.collection = db.collection(collection)
|
}
|
|
_serializeValue(value) {
|
return value === undefined ? null : JSON.stringify(value)
|
}
|
|
_deserializeValue(value) {
|
return value ? JSON.parse(value) : value
|
}
|
|
async set(key, value, duration) {
|
validator.key(key)
|
validator.value(value)
|
validator.duration(duration)
|
value = this._serializeValue(value)
|
await this.collection.doc(key).set({
|
value,
|
expired: duration && duration !== -1 ? Date.now() + (duration * 1000) : -1
|
})
|
}
|
|
async _getWithDuration(key) {
|
const getKeyRes = await this.collection.doc(key).get()
|
const record = getKeyRes.data[0]
|
if (!record) {
|
return {
|
value: null,
|
duration: -2
|
}
|
}
|
const value = this._deserializeValue(record.value)
|
const expired = record.expired
|
if (expired === -1) {
|
return {
|
value,
|
duration: -1
|
}
|
}
|
const duration = expired - Date.now()
|
if (duration <= 0) {
|
await this.remove(key)
|
return {
|
value: null,
|
duration: -2
|
}
|
}
|
return {
|
value,
|
duration: Math.floor(duration / 1000)
|
}
|
}
|
|
async get(key, {
|
withDuration = true
|
} = {}) {
|
const result = await this._getWithDuration(key)
|
if (!withDuration) {
|
delete result.duration
|
}
|
return result
|
}
|
|
async remove(key) {
|
await this.collection.doc(key).remove()
|
}
|
}
|
|
class RedisCache {
|
constructor() {
|
this.type = 'redis'
|
this.redis = uniCloud.redis()
|
}
|
|
_serializeValue(value) {
|
return value === undefined ? null : JSON.stringify(value)
|
}
|
|
_deserializeValue(value) {
|
return value ? JSON.parse(value) : value
|
}
|
|
async set(key, value, duration) {
|
validator.key(key)
|
validator.value(value)
|
validator.duration(duration)
|
value = this._serializeValue(value)
|
if (!duration || duration === -1) {
|
await this.redis.set(key, value)
|
} else {
|
await this.redis.set(key, value, 'EX', duration)
|
}
|
}
|
|
async get(key, {
|
withDuration = false
|
} = {}) {
|
let value = await this.redis.get(key)
|
value = this._deserializeValue(value)
|
if (!withDuration) {
|
return {
|
value
|
}
|
}
|
const durationSecond = await this.redis.ttl(key)
|
let duration
|
switch (durationSecond) {
|
case -1:
|
duration = -1
|
break
|
case -2:
|
duration = -2
|
break
|
default:
|
duration = durationSecond
|
break
|
}
|
return {
|
value,
|
duration
|
}
|
}
|
|
async remove(key) {
|
await this.redis.del(key)
|
}
|
}
|
|
class Cache {
|
constructor({
|
type,
|
collection
|
} = {}) {
|
if (type === 'database') {
|
return new DatabaseCache({
|
collection
|
})
|
} else if (type === 'redis') {
|
return new RedisCache()
|
} else {
|
throw new Error('Invalid cache type')
|
}
|
}
|
}
|
|
class CacheKey {
|
constructor({
|
type,
|
collection,
|
cache,
|
key,
|
fallback
|
} = {}) {
|
this.cache = cache || new Cache({
|
type,
|
collection
|
})
|
this.key = key
|
this.fallback = fallback
|
}
|
|
async set(value, duration) {
|
await this.cache.set(this.key, value, duration)
|
}
|
|
async setWithSync(value, duration, syncMethod) {
|
await Promise.all([
|
this.set(this.key, value, duration),
|
syncMethod(value, duration)
|
])
|
}
|
|
async get() {
|
let {
|
value,
|
duration
|
} = await this.cache.get(this.key)
|
if (value !== null && value !== undefined) {
|
return {
|
value,
|
duration
|
}
|
}
|
if (!this.fallback) {
|
return {
|
value: null,
|
duration: -2
|
}
|
}
|
const fallbackResult = await this.fallback()
|
value = fallbackResult.value
|
duration = fallbackResult.duration
|
if (value !== null && duration !== undefined) {
|
await this.cache.set(this.key, value, duration)
|
}
|
return {
|
value,
|
duration
|
}
|
}
|
|
async remove() {
|
await this.cache.remove(this.key)
|
}
|
}
|
|
class CacheKeyCascade {
|
constructor({
|
layers, // [{cache, type, collection, key}] 从低级到高级排序，[DbCacheKey, RedisCacheKey]
|
fallback
|
} = {}) {
|
this.layers = layers
|
this.cacheLayers = []
|
let lastCacheKey
|
for (let i = 0; i < layers.length; i++) {
|
const {
|
type,
|
cache,
|
collection,
|
key
|
} = layers[i]
|
const lastCacheKeyTemp = lastCacheKey
|
try {
|
const currentCacheKey = new CacheKey({
|
type,
|
collection,
|
cache,
|
key,
|
fallback: i === 0 ? fallback : function() {
|
return lastCacheKeyTemp.get()
|
}
|
})
|
this.cacheLayers.push(currentCacheKey)
|
lastCacheKey = currentCacheKey
|
} catch (e) {}
|
}
|
this.highLevelCache = lastCacheKey
|
}
|
|
async set(value, duration) {
|
return Promise.all(
|
this.cacheLayers.map(item => {
|
return item.set(value, duration)
|
})
|
)
|
}
|
|
async setWithSync(value, duration, syncMethod) {
|
const setPromise = this.cacheLayers.map(item => {
|
return item.set(value, duration)
|
})
|
return Promise.all(
|
[
|
...setPromise,
|
syncMethod(value, duration)
|
]
|
)
|
}
|
|
async get() {
|
return this.highLevelCache.get()
|
}
|
|
async remove() {
|
await Promise.all(
|
this.cacheLayers.map(cacheKeyItem => {
|
return cacheKeyItem.remove()
|
})
|
)
|
}
|
}
|
|
module.exports = {
|
Cache,
|
DatabaseCache,
|
RedisCache,
|
CacheKey,
|
CacheKeyCascade
|
}
|
