SHA256
134 lines
5.1 KiB
JavaScript
134 lines
5.1 KiB
JavaScript
// V3-only cache: IndexedDB + memory fallback, TTL 24 hours. V1/V2 retain 2-minute TTL.
|
|
export const EXPLORER_CACHE_TTL_MS = 24 * 60 * 60 * 1000;
|
|
const DB_NAME = 'shine-network-explorer-v3';
|
|
const STORE = 'connections';
|
|
let dbPromise = null;
|
|
const memory = new Map();
|
|
const inflight = new Map();
|
|
let epoch = 0;
|
|
|
|
function dbOpen() {
|
|
if (typeof indexedDB === 'undefined') return Promise.resolve(null);
|
|
if (!dbPromise) dbPromise = new Promise((resolve) => {
|
|
try {
|
|
const request = indexedDB.open(DB_NAME, 1);
|
|
request.onupgradeneeded = () => request.result.createObjectStore(STORE, { keyPath: 'key' });
|
|
request.onsuccess = () => resolve(request.result);
|
|
request.onerror = () => resolve(null);
|
|
request.onblocked = () => resolve(null);
|
|
} catch { resolve(null); }
|
|
});
|
|
return dbPromise;
|
|
}
|
|
|
|
async function read(key) {
|
|
const db = await dbOpen();
|
|
if (!db) return null;
|
|
return new Promise((resolve) => {
|
|
try {
|
|
const req = db.transaction(STORE, 'readonly').objectStore(STORE).get(key);
|
|
req.onsuccess = () => resolve(req.result || null);
|
|
req.onerror = () => resolve(null);
|
|
} catch { resolve(null); }
|
|
});
|
|
}
|
|
|
|
async function write(record) {
|
|
const db = await dbOpen();
|
|
if (!db) return;
|
|
await new Promise((resolve) => {
|
|
try {
|
|
const tx = db.transaction(STORE, 'readwrite');
|
|
tx.objectStore(STORE).put(record);
|
|
tx.oncomplete = resolve;
|
|
tx.onerror = resolve;
|
|
tx.onabort = resolve;
|
|
} catch { resolve(); }
|
|
});
|
|
}
|
|
|
|
// Восстанавливаем ранее исследованную карту без сети. Просроченные графы не выдаём:
|
|
// их обновит обычный запрос, когда пользователь снова откроет соответствующую ветку.
|
|
export async function readExplorerCachedGraphs(scope, limit = 1000) {
|
|
const prefix = `${scope}|`;
|
|
const collected = new Map();
|
|
for (const row of memory.values()) {
|
|
if (row.key.startsWith(prefix) && row.savedAt <= Date.now() && Date.now() - row.savedAt < EXPLORER_CACHE_TTL_MS)
|
|
collected.set(row.key, row);
|
|
}
|
|
const db = await dbOpen();
|
|
if (!db) return [...collected.values()].slice(0, limit);
|
|
await new Promise((resolve) => {
|
|
try {
|
|
const range = IDBKeyRange.bound(prefix, `${prefix}\uffff`);
|
|
const request = db.transaction(STORE, 'readonly').objectStore(STORE).openCursor(range);
|
|
request.onerror = () => resolve();
|
|
request.onsuccess = () => {
|
|
const cursor = request.result;
|
|
if (!cursor || collected.size >= limit) { resolve(); return; }
|
|
const row = cursor.value;
|
|
if (row?.savedAt <= Date.now() && Date.now() - row.savedAt < EXPLORER_CACHE_TTL_MS)
|
|
collected.set(row.key, row);
|
|
cursor.continue();
|
|
};
|
|
} catch { resolve(); }
|
|
});
|
|
return [...collected.values()].slice(0, limit);
|
|
}
|
|
|
|
export function explorerCacheScope(service, sessionLogin) {
|
|
return `${String(service?.serverUrl || '').trim().toLowerCase()}|${String(sessionLogin || '').trim()}`;
|
|
}
|
|
|
|
export async function getExplorerGraph(service, login, { scope, force = false } = {}) {
|
|
const key = `${scope || explorerCacheScope(service, '')}|${String(login || '').trim().toLowerCase()}`;
|
|
if (!login) throw new Error('LOGIN_REQUIRED');
|
|
const valid = (record) => record && record.graph && Date.now() - record.savedAt < EXPLORER_CACHE_TTL_MS && record.savedAt <= Date.now();
|
|
if (!force) {
|
|
const item = memory.get(key) || await read(key);
|
|
if (valid(item)) {
|
|
memory.set(key, item);
|
|
return item.graph;
|
|
}
|
|
}
|
|
if (inflight.has(key)) return inflight.get(key);
|
|
const started = epoch;
|
|
const task = (async () => {
|
|
const graph = await service.getUserConnectionsGraph(login);
|
|
if (started !== epoch) throw new Error('EXPLORER_CACHE_INVALIDATED');
|
|
const record = { key, graph, savedAt: Date.now() };
|
|
memory.set(key, record);
|
|
// Ограничиваем горячий слой. Записи IndexedDB остаются до ручной очистки или перезаписи по TTL.
|
|
while (memory.size > 800) memory.delete(memory.keys().next().value);
|
|
await write(record);
|
|
return graph;
|
|
})();
|
|
inflight.set(key, task);
|
|
try { return await task; }
|
|
finally { if (inflight.get(key) === task) inflight.delete(key); }
|
|
}
|
|
|
|
// Модель V3 должна наследовать время фактического получения ответа, а не время
|
|
// очередного чтения его из IndexedDB: иначе повторные визиты продлевали бы TTL.
|
|
export function explorerGraphSavedAt(scope, login) {
|
|
const key = `${scope}|${String(login || '').trim().toLowerCase()}`;
|
|
return memory.get(key)?.savedAt || null;
|
|
}
|
|
|
|
export async function clearExplorerGraphCache() {
|
|
epoch += 1;
|
|
inflight.clear();
|
|
memory.clear();
|
|
const db = await dbOpen();
|
|
if (!db) return;
|
|
await new Promise((resolve) => {
|
|
try {
|
|
const tx = db.transaction(STORE, 'readwrite');
|
|
tx.objectStore(STORE).clear();
|
|
tx.oncomplete = resolve;
|
|
tx.onerror = resolve;
|
|
tx.onabort = resolve;
|
|
} catch { resolve(); }
|
|
});
|
|
}
|