@loggerjs/browser 0.5.3 → 0.5.4

package/dist/indexeddb-transport.cjs

@@ -7,10 +7,12 @@ const DEFAULT_SESSION_CONTEXT_KEY = "sessionId";
 const DEFAULT_SPILL_MAX_ENTRIES = 200;
 const DEFAULT_SPILL_MAX_BYTES = 512 * 1024;
 const DEFAULT_SPILL_MAX_ORIGIN_BYTES = 5 * 1024 * 1024;
-const DB_VERSION = 3;
+const DB_VERSION = 4;
 const ORDER_INDEX_NAME = "createdAtSeq";
 const SESSION_INDEX_NAME = "sessionId";
 const SESSION_ORDER_INDEX_NAME = "sessionIdCreatedAtSeq";
+const SESSION_STORE_SUFFIX = "__sessions";
+const SESSION_LAST_SEEN_INDEX_NAME = "lastSeenSessionId";
 const SPILL_SCHEMA = "loggerjs.indexeddb-spill.v1";
 function normalizePositiveInteger(value, fallback) {
 	if (value === void 0 || !Number.isFinite(value)) return fallback;
@@ -135,6 +137,9 @@ function indexExists(store, name) {
 function ensureIndex(store, name, keyPath) {
 	if (!indexExists(store, name)) store.createIndex(name, keyPath);
 }
+function sessionStoreNameFor(storeName) {
+	return `${storeName}${SESSION_STORE_SUFFIX}`;
+}
 function getStoreIndex(store, name) {
 	const maybeStore = store;
 	if (typeof maybeStore.index !== "function" || !indexExists(store, name)) return void 0;
@@ -164,6 +169,44 @@ function shouldKeepEntry(entry, options) {
 	if (options.type !== void 0 && entry.type !== options.type) return false;
 	return true;
 }
+function addSessionSummary(sessions, entry) {
+	if (!entry.sessionId) return;
+	const current = sessions.get(entry.sessionId);
+	if (current) {
+		current.firstSeen = Math.min(current.firstSeen, entry.createdAt);
+		current.lastSeen = Math.max(current.lastSeen, entry.createdAt);
+		current.count += 1;
+		current.byteLength += entry.byteLength;
+		return;
+	}
+	sessions.set(entry.sessionId, {
+		byteLength: entry.byteLength,
+		count: 1,
+		firstSeen: entry.createdAt,
+		lastSeen: entry.createdAt,
+		sessionId: entry.sessionId
+	});
+}
+function mergeSessionSummary(current, incoming) {
+	if (!current) return incoming;
+	return {
+		byteLength: current.byteLength + incoming.byteLength,
+		count: current.count + incoming.count,
+		firstSeen: Math.min(current.firstSeen, incoming.firstSeen),
+		lastSeen: Math.max(current.lastSeen, incoming.lastSeen),
+		sessionId: incoming.sessionId
+	};
+}
+function orderSessions(sessions, order = "desc") {
+	const sorted = [...sessions].sort((left, right) => {
+		if (left.lastSeen !== right.lastSeen) return left.lastSeen - right.lastSeen;
+		return left.sessionId < right.sessionId ? -1 : left.sessionId > right.sessionId ? 1 : 0;
+	});
+	if (order === "asc") return sorted;
+	const reversed = [];
+	for (let index = sorted.length - 1; index >= 0; index -= 1) reversed.push(sorted[index]);
+	return reversed;
+}
 function orderRangeForQuery(options) {
 	if (typeof IDBKeyRange === "undefined") return void 0;
 	if (options.sessionId !== void 0) {
@@ -195,6 +238,33 @@ function orderRangeForQuery(options) {
 	if (lower) return IDBKeyRange.lowerBound(lower);
 	if (upper) return IDBKeyRange.upperBound(upper);
 }
+function orderRangeForSessionId(sessionId) {
+	if (typeof IDBKeyRange === "undefined") return void 0;
+	return IDBKeyRange.bound([
+		sessionId,
+		Number.MIN_SAFE_INTEGER,
+		Number.MIN_SAFE_INTEGER,
+		""
+	], [
+		sessionId,
+		Number.MAX_SAFE_INTEGER,
+		Number.MAX_SAFE_INTEGER,
+		"￿"
+	]);
+}
+function migrateSessionSummaries(logStore, sessionStore) {
+	const summaries = /* @__PURE__ */ new Map();
+	const request = logStore.openCursor();
+	request.addEventListener("success", () => {
+		const cursor = request.result;
+		if (!cursor) {
+			for (const summary of summaries.values()) sessionStore.put(summary);
+			return;
+		}
+		addSessionSummary(summaries, cursor.value);
+		cursor.continue();
+	});
+}
 function iterateCursor(request, visit) {
 	return new Promise((resolve, reject) => {
 		request.addEventListener("success", () => {
@@ -219,6 +289,7 @@ function iterateCursor(request, visit) {
 function indexedDbTransport(options = {}) {
 	const dbName = options.dbName ?? DEFAULT_DB_NAME;
 	const storeName = options.storeName ?? DEFAULT_STORE_NAME;
+	const sessionStoreName = sessionStoreNameFor(storeName);
 	const codec = options.codec ?? (0, _loggerjs_core.safeJsonCodec)();
 	const batchSize = normalizePositiveInteger(options.batchSize, 100);
 	const flushIntervalMs = normalizePositiveInteger(options.flushIntervalMs, 1e3);
@@ -237,6 +308,7 @@ function indexedDbTransport(options = {}) {
 	let indexedDBFactoryPromise;
 	let timer;
 	let flushPromise;
+	let clearPromise;
 	let pendingFlushBatch;
 	let spillDrainPromise;
 	let localStorageSpillClearCandidate;
@@ -347,7 +419,7 @@ function indexedDbTransport(options = {}) {
 			if (!idb) throw new Error("IndexedDB is not available for indexedDbTransport");
 			return new Promise((resolve, reject) => {
 				const request = idb.open(dbName, DB_VERSION);
-				request.addEventListener("upgradeneeded", () => {
+				request.addEventListener("upgradeneeded", (event) => {
 					const db = request.result;
 					const store = db.objectStoreNames.contains(storeName) ? request.transaction?.objectStore(storeName) : db.createObjectStore(storeName, { keyPath: "id" });
 					if (!store) return;
@@ -367,6 +439,10 @@ function indexedDbTransport(options = {}) {
 						"seq",
 						"id"
 					]);
+					const sessionStore = db.objectStoreNames.contains(sessionStoreName) ? request.transaction?.objectStore(sessionStoreName) : db.createObjectStore(sessionStoreName, { keyPath: "sessionId" });
+					if (!sessionStore) return;
+					ensureIndex(sessionStore, SESSION_LAST_SEEN_INDEX_NAME, ["lastSeen", "sessionId"]);
+					if (event.oldVersion < 4) migrateSessionSummaries(store, sessionStore);
 				});
 				request.addEventListener("success", () => {
 					statsState.databaseOpenCount += 1;
@@ -377,13 +453,13 @@ function indexedDbTransport(options = {}) {
 		});
 		return dbPromise;
 	};
-	const createTransaction = (db, mode) => {
-		if (mode !== "readwrite" || !transactionOptions) return db.transaction(storeName, mode);
+	const createTransaction = (db, mode, stores = storeName) => {
+		if (mode !== "readwrite" || !transactionOptions) return db.transaction(stores, mode);
 		try {
-			return db.transaction(storeName, mode, transactionOptions);
+			return db.transaction(stores, mode, transactionOptions);
 		} catch {
 			statsState.transactionOptionFallbacks += 1;
-			return db.transaction(storeName, mode);
+			return db.transaction(stores, mode);
 		}
 	};
 	const withStore = async (mode, run) => {
@@ -400,6 +476,57 @@ function indexedDbTransport(options = {}) {
 			throw error;
 		}
 	};
+	const withLogAndSessionStores = async (mode, run) => {
+		const tx = createTransaction(await openDb(), mode, [storeName, sessionStoreName]);
+		const settled = transactionToPromise(tx);
+		try {
+			const result = await run(tx.objectStore(storeName), tx.objectStore(sessionStoreName), tx);
+			await settled;
+			return result;
+		} catch (error) {
+			if (tx.error === null) try {
+				tx.abort();
+			} catch {}
+			throw error;
+		}
+	};
+	const withSessionStore = async (mode, run) => {
+		const tx = createTransaction(await openDb(), mode, sessionStoreName);
+		const settled = transactionToPromise(tx);
+		try {
+			const result = await run(tx.objectStore(sessionStoreName), tx);
+			await settled;
+			return result;
+		} catch (error) {
+			if (tx.error === null) try {
+				tx.abort();
+			} catch {}
+			throw error;
+		}
+	};
+	const mergeSessionSummaries = async (sessionStore, entries) => {
+		const summaries = /* @__PURE__ */ new Map();
+		for (const entry of entries) addSessionSummary(summaries, entry);
+		for (const summary of summaries.values()) {
+			const current = await requestToPromise(sessionStore.get(summary.sessionId));
+			await requestToPromise(sessionStore.put(mergeSessionSummary(current, summary)));
+		}
+	};
+	const rebuildSessionSummaries = async (store, sessionStore, sessionIds) => {
+		if (sessionIds.size === 0) return;
+		const index = getStoreIndex(store, SESSION_ORDER_INDEX_NAME);
+		for (const sessionId of sessionIds) {
+			const summaries = /* @__PURE__ */ new Map();
+			const range = orderRangeForSessionId(sessionId);
+			await iterateCursor(index && range ? index.openCursor(range) : store.openCursor(), (cursor) => {
+				const entry = cursor.value;
+				if (entry.sessionId === sessionId) addSessionSummary(summaries, entry);
+			});
+			const summary = summaries.get(sessionId);
+			if (summary) await requestToPromise(sessionStore.put(summary));
+			else await requestToPromise(sessionStore.delete(sessionId));
+		}
+	};
 	const getEntries = async () => orderEntries(await withStore("readonly", (store) => requestToPromise(store.getAll())));
 	const countEntries = async () => withStore("readonly", (store) => {
 		const maybeStore = store;
@@ -408,25 +535,31 @@ function indexedDbTransport(options = {}) {
 	});
 	const deleteEntries = async (entries, reason) => {
 		if (entries.length === 0) return;
-		await withStore("readwrite", async (store) => {
+		await withLogAndSessionStores("readwrite", async (store, sessionStore) => {
+			const affectedSessionIds = /* @__PURE__ */ new Set();
 			for (const entry of entries) {
 				await requestToPromise(store.delete(entry.id));
+				if (entry.sessionId) affectedSessionIds.add(entry.sessionId);
 				dropPersistedEntry(entry, reason);
 			}
+			await rebuildSessionSummaries(store, sessionStore, affectedSessionIds);
 		});
 	};
-	const deleteByCursor = async (reason, openCursor, shouldDelete) => withStore("readwrite", async (store) => {
+	const deleteByCursor = async (reason, openCursor, shouldDelete) => withLogAndSessionStores("readwrite", async (store, sessionStore) => {
 		const request = openCursor(store);
 		if (!request) return void 0;
 		let deleted = 0;
+		const affectedSessionIds = /* @__PURE__ */ new Set();
 		await iterateCursor(request, (cursor) => {
 			const entry = cursor.value;
 			if (!shouldDelete(entry, deleted)) return false;
 			cursor.delete();
 			deleted += 1;
+			if (entry.sessionId) affectedSessionIds.add(entry.sessionId);
 			dropPersistedEntry(entry, reason);
 			return true;
 		});
+		await rebuildSessionSummaries(store, sessionStore, affectedSessionIds);
 		return deleted;
 	});
 	const deleteExpiredByCursor = async (cutoff) => {
@@ -471,29 +604,18 @@ function indexedDbTransport(options = {}) {
 		return entries;
 	});
 	const listSessions = async (sessionQueryOptions = {}) => {
-		const sessions = /* @__PURE__ */ new Map();
-		for (const entry of await getEntries()) {
-			if (!entry.sessionId) continue;
-			const current = sessions.get(entry.sessionId);
-			if (current) {
-				current.firstSeen = Math.min(current.firstSeen, entry.createdAt);
-				current.lastSeen = Math.max(current.lastSeen, entry.createdAt);
-				current.count += 1;
-				current.byteLength += entry.byteLength;
-			} else sessions.set(entry.sessionId, {
-				byteLength: entry.byteLength,
-				count: 1,
-				firstSeen: entry.createdAt,
-				lastSeen: entry.createdAt,
-				sessionId: entry.sessionId
+		const limit = sessionQueryOptions.limit;
+		if (limit !== void 0 && limit <= 0) return [];
+		return withSessionStore("readonly", async (sessionStore) => {
+			const sessions = [];
+			const index = getStoreIndex(sessionStore, SESSION_LAST_SEEN_INDEX_NAME);
+			if (!index) return orderSessions(await requestToPromise(sessionStore.getAll()), sessionQueryOptions.order).slice(0, limit);
+			await iterateCursor(index.openCursor(void 0, sessionQueryOptions.order === "asc" ? "next" : "prev"), (cursor) => {
+				sessions.push(cursor.value);
+				return limit === void 0 || sessions.length < limit;
 			});
-		}
-		const ordered = [...sessions.values()].sort((left, right) => {
-			if (left.lastSeen !== right.lastSeen) return left.lastSeen - right.lastSeen;
-			return left.sessionId < right.sessionId ? -1 : left.sessionId > right.sessionId ? 1 : 0;
+			return sessions;
 		});
-		if (sessionQueryOptions.order !== "asc") ordered.reverse();
-		return ordered.slice(0, sessionQueryOptions.limit);
 	};
 	const pruneWithEntries = async () => {
 		const now = Date.now();
@@ -618,8 +740,16 @@ function indexedDbTransport(options = {}) {
 		statsState.lastFlushBatchSize = events.length;
 		const entries = events.map(eventToEntry);
 		try {
-			await withStore("readwrite", (store) => {
-				for (const entry of entries) store.put(entry);
+			await withLogAndSessionStores("readwrite", async (store, sessionStore) => {
+				const rebuildSessionIds = /* @__PURE__ */ new Set();
+				for (const entry of entries) {
+					const existing = await requestToPromise(store.get(entry.id));
+					if (existing?.sessionId) rebuildSessionIds.add(existing.sessionId);
+					if (existing && entry.sessionId) rebuildSessionIds.add(entry.sessionId);
+					await requestToPromise(store.put(entry));
+				}
+				await rebuildSessionSummaries(store, sessionStore, rebuildSessionIds);
+				await mergeSessionSummaries(sessionStore, entries.filter((entry) => !entry.sessionId || !rebuildSessionIds.has(entry.sessionId)));
 			});
 			statsState.persisted += entries.length;
 			(0, _loggerjs_core.incrementLoggerMetaCounter)("transport.indexeddb.persisted", entries.length);
@@ -760,7 +890,9 @@ function indexedDbTransport(options = {}) {
 		clearTimer();
 		const batch = buffer.splice(0, buffer.length);
 		pendingFlushBatch = batch;
+		const clearBarrier = clearPromise;
 		flushPromise = (async () => {
+			await clearBarrier;
 			await ensureSpillDrained();
 			await writeBatch(batch);
 		})().finally(() => {
@@ -829,17 +961,36 @@ function indexedDbTransport(options = {}) {
 			return await countEntries() ?? (await getEntries()).length;
 		},
 		async clear() {
+			if (clearPromise) return clearPromise;
+			const inFlightFlush = flushPromise;
+			const inFlightDrain = spillDrainPromise;
 			buffer.length = 0;
 			clearTimer();
 			clearLocalStorageSpill();
-			await withStore("readwrite", (store) => requestToPromise(store.clear()));
+			clearPromise = (async () => {
+				await inFlightFlush;
+				await inFlightDrain;
+				await withLogAndSessionStores("readwrite", async (store, sessionStore) => {
+					await requestToPromise(store.clear());
+					await requestToPromise(sessionStore.clear());
+				});
+			})().finally(() => {
+				clearPromise = void 0;
+			});
+			return clearPromise;
 		},
 		async remove(ids) {
 			await flushPending();
 			const items = typeof ids === "string" ? [ids] : ids;
 			if (items.length === 0) return;
-			await withStore("readwrite", async (store) => {
-				for (const id of items) await requestToPromise(store.delete(id));
+			await withLogAndSessionStores("readwrite", async (store, sessionStore) => {
+				const affectedSessionIds = /* @__PURE__ */ new Set();
+				for (const id of items) {
+					const entry = await requestToPromise(store.get(id));
+					if (entry?.sessionId) affectedSessionIds.add(entry.sessionId);
+					await requestToPromise(store.delete(id));
+				}
+				await rebuildSessionSummaries(store, sessionStore, affectedSessionIds);
 			});
 		},
 		async *query(queryOptions = {}) {