137 lines
4.2 KiB
JavaScript
137 lines
4.2 KiB
JavaScript
import { createClient } from 'redis';
|
|
|
|
function positiveInteger(value, fallback, maximum = Number.MAX_SAFE_INTEGER) {
|
|
const parsed = Number(value);
|
|
return Number.isInteger(parsed) && parsed > 0 ? Math.min(parsed, maximum) : fallback;
|
|
}
|
|
|
|
function disabledCache(status = 'disabled') {
|
|
return {
|
|
enabled: false,
|
|
status,
|
|
async remember(_namespace, _key, loader) {
|
|
return loader();
|
|
},
|
|
async invalidate() { return false; },
|
|
async close() {}
|
|
};
|
|
}
|
|
|
|
export async function createRedisCache({ env = process.env, logger = console, clientFactory = createClient } = {}) {
|
|
const url = String(env.REDIS_URL || '').trim();
|
|
if (!url) return disabledCache();
|
|
|
|
const prefix = String(env.REDIS_CACHE_PREFIX || 'exam-information')
|
|
.trim()
|
|
.replace(/[^a-zA-Z0-9:_-]/g, '-') || 'exam-information';
|
|
const defaultTtlSeconds = positiveInteger(env.REDIS_CACHE_TTL_SECONDS, 60, 86400);
|
|
const connectTimeout = positiveInteger(env.REDIS_CONNECT_TIMEOUT_MS, 1500, 30000);
|
|
const pending = new Map();
|
|
let warningReported = false;
|
|
|
|
const warn = error => {
|
|
if (warningReported) return;
|
|
warningReported = true;
|
|
logger.warn(`Redis 缓存暂不可用，已回源数据库：${error?.message || error}`);
|
|
};
|
|
|
|
const client = clientFactory({
|
|
url,
|
|
socket: {
|
|
connectTimeout,
|
|
reconnectStrategy(retries) {
|
|
return retries >= 3 ? false : Math.min(100 * 2 ** retries, 1000);
|
|
}
|
|
}
|
|
});
|
|
client.on('error', warn);
|
|
client.on('ready', () => {
|
|
warningReported = false;
|
|
});
|
|
|
|
try {
|
|
await client.connect();
|
|
} catch (error) {
|
|
warn(error);
|
|
if (client.isOpen) client.destroy();
|
|
return disabledCache('unavailable');
|
|
}
|
|
|
|
const versionKey = namespace => `${prefix}:namespace:${namespace}`;
|
|
|
|
async function namespaceVersion(namespace) {
|
|
const key = versionKey(namespace);
|
|
const current = await client.get(key);
|
|
if (current) return current;
|
|
await client.set(key, '1', { NX: true });
|
|
return (await client.get(key)) || '1';
|
|
}
|
|
|
|
return {
|
|
get enabled() {
|
|
return client.isReady;
|
|
},
|
|
get status() {
|
|
return client.isReady ? 'ready' : 'unavailable';
|
|
},
|
|
async remember(namespace, key, loader, { ttlSeconds = defaultTtlSeconds } = {}) {
|
|
if (!client.isReady) return loader();
|
|
try {
|
|
const version = await namespaceVersion(namespace);
|
|
const cacheKey = `${prefix}:${namespace}:${version}:${key}`;
|
|
const cached = await client.get(cacheKey);
|
|
if (cached !== null) return JSON.parse(cached);
|
|
|
|
if (pending.has(cacheKey)) return pending.get(cacheKey);
|
|
const loading = Promise.resolve(loader()).then(async value => {
|
|
if (client.isReady) {
|
|
try {
|
|
await client.set(cacheKey, JSON.stringify(value), {
|
|
EX: positiveInteger(ttlSeconds, defaultTtlSeconds, 86400)
|
|
});
|
|
} catch (error) {
|
|
warn(error);
|
|
}
|
|
}
|
|
return value;
|
|
}).finally(() => pending.delete(cacheKey));
|
|
pending.set(cacheKey, loading);
|
|
return loading;
|
|
} catch (error) {
|
|
warn(error);
|
|
return loader();
|
|
}
|
|
},
|
|
async invalidate(namespace) {
|
|
if (!client.isReady) return false;
|
|
try {
|
|
await client.incr(versionKey(namespace));
|
|
return true;
|
|
} catch (error) {
|
|
warn(error);
|
|
return false;
|
|
}
|
|
},
|
|
async close() {
|
|
if (client.isOpen) await client.quit();
|
|
}
|
|
};
|
|
}
|
|
|
|
export function withCacheInvalidation(database, cache, namespaces = ['public']) {
|
|
const resolveNamespaces = typeof namespaces === 'function' ? namespaces : () => namespaces;
|
|
return new Proxy(database, {
|
|
get(target, property, receiver) {
|
|
const value = Reflect.get(target, property, receiver);
|
|
if (typeof value !== 'function') return value;
|
|
if (property === 'read' || property === 'close') return value.bind(target);
|
|
return async (...args) => {
|
|
const result = await value.apply(target, args);
|
|
const affected = [...new Set(resolveNamespaces(property, args, result) || [])];
|
|
await Promise.all(affected.map(namespace => cache.invalidate(namespace)));
|
|
return result;
|
|
};
|
|
}
|
|
});
|
|
}
|