@happyvertical/smrt-web 0.38.6 → 0.38.7

package/dist/index.js

@@ -48,20 +48,20 @@ async function wipeDurableStore(namespace) {
 //#region src/offline/durable-queue.ts
 var OUTBOX_STORE = "outbox";
 var OUTBOX_STATE_INDEX = "state";
-function promisifyRequest(request) {
+function promisifyRequest$2(request) {
 	return new Promise((resolve, reject) => {
 		request.onsuccess = () => resolve(request.result);
 		request.onerror = () => reject(request.error ?? /* @__PURE__ */ new Error("[smrt-web] IndexedDB request failed"));
 	});
 }
-function awaitTransaction(tx) {
+function awaitTransaction$2(tx) {
 	return new Promise((resolve, reject) => {
 		tx.oncomplete = () => resolve();
 		tx.onerror = () => reject(tx.error ?? /* @__PURE__ */ new Error("[smrt-web] IndexedDB transaction failed"));
 		tx.onabort = () => reject(tx.error ?? /* @__PURE__ */ new Error("[smrt-web] IndexedDB transaction aborted"));
 	});
 }
-async function probeIndexedDb() {
+async function probeIndexedDb$1() {
 	const idb = globalThis.indexedDB;
 	if (!idb) return false;
 	const probeName = "__smrt_web_outbox_probe__";
@@ -108,8 +108,8 @@ var DurableOutboxQueue = class {
 			enqueuedAt: now
 		};
 		const tx = this.db.transaction(OUTBOX_STORE, "readwrite");
-		const seq = await promisifyRequest(tx.objectStore(OUTBOX_STORE).add(row));
-		await awaitTransaction(tx);
+		const seq = await promisifyRequest$2(tx.objectStore(OUTBOX_STORE).add(row));
+		await awaitTransaction$2(tx);
 		return seq;
 	}
 	/**
@@ -121,9 +121,9 @@ var DurableOutboxQueue = class {
 	async markState(seq, patch) {
 		const tx = this.db.transaction(OUTBOX_STORE, "readwrite");
 		const store = tx.objectStore(OUTBOX_STORE);
-		const existing = await promisifyRequest(store.get(seq));
+		const existing = await promisifyRequest$2(store.get(seq));
 		if (!existing) {
-			await awaitTransaction(tx);
+			await awaitTransaction$2(tx);
 			return;
 		}
 		const next = {
@@ -131,8 +131,8 @@ var DurableOutboxQueue = class {
 			...patch,
 			seq
 		};
-		await promisifyRequest(store.put(next));
-		await awaitTransaction(tx);
+		await promisifyRequest$2(store.put(next));
+		await awaitTransaction$2(tx);
 	}
 	/**
 	* All rows that are due to (re)send at `now`: state `pending` AND
@@ -142,21 +142,21 @@ var DurableOutboxQueue = class {
 	*/
 	async listPending(now) {
 		const tx = this.db.transaction(OUTBOX_STORE, "readonly");
-		const rows = await promisifyRequest(tx.objectStore(OUTBOX_STORE).index(OUTBOX_STATE_INDEX).getAll(IDBKeyRange.only("pending")));
-		await awaitTransaction(tx);
+		const rows = await promisifyRequest$2(tx.objectStore(OUTBOX_STORE).index(OUTBOX_STATE_INDEX).getAll(IDBKeyRange.only("pending")));
+		await awaitTransaction$2(tx);
 		return rows.filter((row) => row.nextAttemptAt <= now).sort((a, b) => (a.seq ?? 0) - (b.seq ?? 0));
 	}
 	/** Remove the row at `seq` (a terminal transition drops it). */
 	async remove(seq) {
 		const tx = this.db.transaction(OUTBOX_STORE, "readwrite");
-		await promisifyRequest(tx.objectStore(OUTBOX_STORE).delete(seq));
-		await awaitTransaction(tx);
+		await promisifyRequest$2(tx.objectStore(OUTBOX_STORE).delete(seq));
+		await awaitTransaction$2(tx);
 	}
 	/** Every row currently in the queue (any state), ascending `seq`. */
 	async all() {
 		const tx = this.db.transaction(OUTBOX_STORE, "readonly");
-		const rows = await promisifyRequest(tx.objectStore(OUTBOX_STORE).getAll());
-		await awaitTransaction(tx);
+		const rows = await promisifyRequest$2(tx.objectStore(OUTBOX_STORE).getAll());
+		await awaitTransaction$2(tx);
 		return rows.sort((a, b) => (a.seq ?? 0) - (b.seq ?? 0));
 	}
 	/**
@@ -166,8 +166,8 @@ var DurableOutboxQueue = class {
 	*/
 	async clear() {
 		const tx = this.db.transaction(OUTBOX_STORE, "readwrite");
-		await promisifyRequest(tx.objectStore(OUTBOX_STORE).clear());
-		await awaitTransaction(tx);
+		await promisifyRequest$2(tx.objectStore(OUTBOX_STORE).clear());
+		await awaitTransaction$2(tx);
 	}
 	/** Close the underlying database handle (called on engine dispose). */
 	close() {
@@ -328,7 +328,7 @@ var OutboxEngine = class {
 	}
 	/** Open the durable queue (or mark degraded if IndexedDB is unusable). */
 	async open() {
-		if (!await probeIndexedDb()) {
+		if (!await probeIndexedDb$1()) {
 			this.degraded = true;
 			console.warn("[smrt-web] IndexedDB unavailable — the offline outbox is disabled; offline writes will not be durable.");
 			return;
@@ -860,6 +860,246 @@ function getOutboxHandle(namespace) {
 	};
 }
 //#endregion
+//#region src/persistence/snapshot-store.ts
+var SNAPSHOT_STORE = "snapshots";
+var SNAPSHOT_DB_SUFFIX = "::snapshots";
+function promisifyRequest$1(request) {
+	return new Promise((resolve, reject) => {
+		request.onsuccess = () => resolve(request.result);
+		request.onerror = () => reject(request.error ?? /* @__PURE__ */ new Error("[smrt-web] IndexedDB request failed"));
+	});
+}
+function awaitTransaction$1(tx) {
+	return new Promise((resolve, reject) => {
+		tx.oncomplete = () => resolve();
+		tx.onerror = () => reject(tx.error ?? /* @__PURE__ */ new Error("[smrt-web] IndexedDB transaction failed"));
+		tx.onabort = () => reject(tx.error ?? /* @__PURE__ */ new Error("[smrt-web] IndexedDB transaction aborted"));
+	});
+}
+async function probeIndexedDb() {
+	const idb = globalThis.indexedDB;
+	if (!idb) return false;
+	const probeName = "__smrt_web_snapshot_probe__";
+	try {
+		(await new Promise((resolve, reject) => {
+			const request = idb.open(probeName, 1);
+			request.onsuccess = () => resolve(request.result);
+			request.onerror = () => reject(request.error ?? /* @__PURE__ */ new Error("probe failed"));
+			request.onblocked = () => reject(/* @__PURE__ */ new Error("probe blocked"));
+		})).close();
+		try {
+			idb.deleteDatabase(probeName);
+		} catch {}
+		return true;
+	} catch {
+		return false;
+	}
+}
+var SnapshotStore = class {
+	db;
+	/** The IndexedDB database name (== the durable-store namespace). */
+	dbName;
+	constructor(db, dbName) {
+		this.db = db;
+		this.dbName = dbName;
+	}
+	/**
+	* Read the persisted rows for `collection`, or `undefined` if none were ever
+	* saved (or the record is malformed). `undefined` is the warm-start "nothing
+	* on disk" signal — the engine then fetches fresh.
+	*/
+	async load(collection) {
+		const tx = this.db.transaction(SNAPSHOT_STORE, "readonly");
+		const record = await promisifyRequest$1(tx.objectStore(SNAPSHOT_STORE).get(collection));
+		await awaitTransaction$1(tx);
+		if (!record || !Array.isArray(record.rows)) return void 0;
+		return record.rows;
+	}
+	/**
+	* Write (replacing) the snapshot for `collection`. Resolves once the write is
+	* durably committed. A single blob per collection — the whole current row set,
+	* not a delta — so a restore is one read with no reconciliation.
+	*/
+	async save(collection, rows) {
+		const tx = this.db.transaction(SNAPSHOT_STORE, "readwrite");
+		const store = tx.objectStore(SNAPSHOT_STORE);
+		const record = {
+			collection,
+			rows
+		};
+		await promisifyRequest$1(store.put(record));
+		await awaitTransaction$1(tx);
+	}
+	/**
+	* Drop the snapshot for a single `collection` (its capability's own teardown
+	* does NOT clear — the persisted rows must survive for the next load; this is
+	* only for an explicit targeted purge). Kept for completeness / tests.
+	*/
+	async remove(collection) {
+		const tx = this.db.transaction(SNAPSHOT_STORE, "readwrite");
+		await promisifyRequest$1(tx.objectStore(SNAPSHOT_STORE).delete(collection));
+		await awaitTransaction$1(tx);
+	}
+	/**
+	* Drop EVERY snapshot — the durable-store `clear()` for `wipeDurableStore`.
+	* Empties the store but keeps the database so a subsequent save still works.
+	*/
+	async clear() {
+		const tx = this.db.transaction(SNAPSHOT_STORE, "readwrite");
+		await promisifyRequest$1(tx.objectStore(SNAPSHOT_STORE).clear());
+		await awaitTransaction$1(tx);
+	}
+	/** Close the underlying database handle (called on the last detach). */
+	close() {
+		this.db.close();
+	}
+};
+function openSnapshotStore(namespace) {
+	const idb = globalThis.indexedDB;
+	if (!idb) return Promise.reject(/* @__PURE__ */ new Error("[smrt-web] IndexedDB is unavailable in this environment"));
+	const dbName = `${namespace}${SNAPSHOT_DB_SUFFIX}`;
+	return new Promise((resolve, reject) => {
+		const request = idb.open(dbName, 1);
+		request.onupgradeneeded = () => {
+			const db = request.result;
+			if (!db.objectStoreNames.contains("snapshots")) db.createObjectStore(SNAPSHOT_STORE, { keyPath: "collection" });
+		};
+		request.onsuccess = () => resolve(new SnapshotStore(request.result, dbName));
+		request.onerror = () => reject(request.error ?? /* @__PURE__ */ new Error(`[smrt-web] failed to open snapshot database "${dbName}"`));
+		request.onblocked = () => reject(/* @__PURE__ */ new Error(`[smrt-web] opening snapshot database "${dbName}" was blocked`));
+	});
+}
+//#endregion
+//#region src/persistence.ts
+var DEFAULT_PERSIST_DEBOUNCE_MS = 250;
+var enginesByNamespace = /* @__PURE__ */ new Map();
+var warnedNoIndexedDb = false;
+function warnNoIndexedDbOnce() {
+	if (warnedNoIndexedDb) return;
+	warnedNoIndexedDb = true;
+	console.warn("[smrt-web] IndexedDB is unavailable; persistence is disabled (collections behave as non-persistent).");
+}
+function acquireSnapshotEngine(namespace) {
+	const existing = enginesByNamespace.get(namespace);
+	if (existing) {
+		existing.refCount += 1;
+		return existing;
+	}
+	const engine = {
+		store: void 0,
+		refCount: 1,
+		unregister: void 0,
+		ready: Promise.resolve(void 0)
+	};
+	engine.ready = (async () => {
+		if (!await probeIndexedDb()) {
+			warnNoIndexedDbOnce();
+			return;
+		}
+		try {
+			const store = await openSnapshotStore(namespace);
+			engine.store = store;
+			engine.unregister = registerDurableResource(namespace, {
+				kind: "persisted-collection",
+				clear: () => store.clear()
+			});
+			return store;
+		} catch {
+			warnNoIndexedDbOnce();
+			return;
+		}
+	})();
+	enginesByNamespace.set(namespace, engine);
+	return engine;
+}
+async function releaseSnapshotEngine(namespace) {
+	const engine = enginesByNamespace.get(namespace);
+	if (!engine) return;
+	engine.refCount -= 1;
+	if (engine.refCount > 0) return;
+	enginesByNamespace.delete(namespace);
+	await engine.ready;
+	engine.unregister?.();
+	engine.unregister = void 0;
+	engine.store?.close();
+	engine.store = void 0;
+}
+function persistCollection(config) {
+	const namespace = durableStoreNamespace(config.namespace);
+	const collectionName = config.collection;
+	const debounceMs = config.debounceMs ?? 250;
+	let engine;
+	let subscription;
+	let debounceTimer;
+	let readSnapshot;
+	let detached = false;
+	let flushing;
+	let dirty = false;
+	const doFlush = async () => {
+		while (dirty && !detached) {
+			dirty = false;
+			if (!engine || !readSnapshot) return;
+			const store = await engine.ready;
+			if (detached || !store) return;
+			const rows = readSnapshot().map((row) => ({ ...row }));
+			try {
+				await store.save(collectionName, rows);
+			} catch {}
+		}
+	};
+	const runFlush = () => {
+		dirty = true;
+		if (flushing) return;
+		flushing = doFlush().finally(() => {
+			flushing = void 0;
+			if (dirty && !detached) runFlush();
+		});
+	};
+	const scheduleFlush = () => {
+		if (detached) return;
+		if (debounceTimer) clearTimeout(debounceTimer);
+		debounceTimer = setTimeout(() => {
+			debounceTimer = void 0;
+			runFlush();
+		}, Math.max(0, debounceMs));
+		debounceTimer.unref?.();
+	};
+	return {
+		name: "persistence",
+		async warmStart(ctx) {
+			const acquired = acquireSnapshotEngine(namespace);
+			engine = acquired;
+			readSnapshot = ctx.snapshot ? () => ctx.snapshot?.() ?? [] : void 0;
+			const store = await acquired.ready;
+			if (!store) return void 0;
+			const rows = await store.load(collectionName);
+			if (!rows || rows.length === 0) return void 0;
+			return rows;
+		},
+		onAttach(ctx) {
+			if (!engine) engine = acquireSnapshotEngine(namespace);
+			if (!readSnapshot && ctx.snapshot) readSnapshot = () => ctx.snapshot?.() ?? [];
+			if (!ctx.snapshot || !ctx.subscribe || !readSnapshot) return;
+			subscription = ctx.subscribe(() => scheduleFlush());
+			scheduleFlush();
+		},
+		async teardown() {
+			detached = true;
+			if (debounceTimer) {
+				clearTimeout(debounceTimer);
+				debounceTimer = void 0;
+			}
+			subscription?.unsubscribe();
+			subscription = void 0;
+			readSnapshot = void 0;
+			if (flushing) await flushing;
+			const current = engine;
+			engine = void 0;
+			if (current) await releaseSnapshotEngine(namespace);
+		}
+	};
+}
+//#endregion
 //#region src/sse-client.ts
 var EVENT_SOURCE_CLOSED = 2;
 function defaultEventSourceFactory(url, init) {
@@ -1033,6 +1273,166 @@ function liveInvalidation(config) {
 	};
 }
 //#endregion
+//#region src/update-state/meta-store.ts
+var META_STORE = "meta";
+var META_DB_SUFFIX = "::meta";
+var LAST_SEEN_MANIFEST_HASH_KEY = "lastSeenManifestHash";
+function promisifyRequest(request) {
+	return new Promise((resolve, reject) => {
+		request.onsuccess = () => resolve(request.result);
+		request.onerror = () => reject(request.error ?? /* @__PURE__ */ new Error("[smrt-web] IndexedDB request failed"));
+	});
+}
+function awaitTransaction(tx) {
+	return new Promise((resolve, reject) => {
+		tx.oncomplete = () => resolve();
+		tx.onerror = () => reject(tx.error ?? /* @__PURE__ */ new Error("[smrt-web] IndexedDB transaction failed"));
+		tx.onabort = () => reject(tx.error ?? /* @__PURE__ */ new Error("[smrt-web] IndexedDB transaction aborted"));
+	});
+}
+var VersionMetaStore = class {
+	db;
+	/** The IndexedDB database name (== the durable-store namespace). */
+	dbName;
+	constructor(db, dbName) {
+		this.db = db;
+		this.dbName = dbName;
+	}
+	/** Read the value for `key`, or `undefined` if unset / malformed. */
+	async get(key) {
+		const tx = this.db.transaction(META_STORE, "readonly");
+		const record = await promisifyRequest(tx.objectStore(META_STORE).get(key));
+		await awaitTransaction(tx);
+		return record && typeof record.value === "string" ? record.value : void 0;
+	}
+	/** Write (replacing) the value for `key`; resolves once durably committed. */
+	async set(key, value) {
+		const tx = this.db.transaction(META_STORE, "readwrite");
+		const record = {
+			key,
+			value
+		};
+		await promisifyRequest(tx.objectStore(META_STORE).put(record));
+		await awaitTransaction(tx);
+	}
+	/**
+	* Drop EVERY meta record — the durable-store `clear()` for
+	* {@link wipeDurableStore}, so a logout also clears the last-seen manifest
+	* hash (the AC "wipe clears the last-seen-hash record").
+	*/
+	async clear() {
+		const tx = this.db.transaction(META_STORE, "readwrite");
+		await promisifyRequest(tx.objectStore(META_STORE).clear());
+		await awaitTransaction(tx);
+	}
+	/** Close the underlying database handle. */
+	close() {
+		this.db.close();
+	}
+};
+function openVersionMetaStore(namespace) {
+	const idb = globalThis.indexedDB;
+	if (!idb) return Promise.reject(/* @__PURE__ */ new Error("[smrt-web] IndexedDB is unavailable in this environment"));
+	const dbName = `${namespace}${META_DB_SUFFIX}`;
+	return new Promise((resolve, reject) => {
+		const request = idb.open(dbName, 1);
+		request.onupgradeneeded = () => {
+			const db = request.result;
+			if (!db.objectStoreNames.contains("meta")) db.createObjectStore(META_STORE, { keyPath: "key" });
+		};
+		request.onsuccess = () => resolve(new VersionMetaStore(request.result, dbName));
+		request.onerror = () => reject(request.error ?? /* @__PURE__ */ new Error(`[smrt-web] failed to open meta database "${dbName}"`));
+		request.onblocked = () => reject(/* @__PURE__ */ new Error(`[smrt-web] opening meta database "${dbName}" was blocked`));
+	});
+}
+//#endregion
+//#region src/update-state.ts
+function createUpdateState(config) {
+	const namespace = durableStoreNamespace(config.namespace);
+	let bundle = false;
+	let contract = false;
+	const subscribers = /* @__PURE__ */ new Set();
+	let metaStore;
+	let unregister;
+	let disposed = false;
+	const snapshot = () => ({
+		bundle,
+		contract,
+		updateAvailable: bundle || contract
+	});
+	const notify = () => {
+		const state = snapshot();
+		for (const callback of [...subscribers]) try {
+			callback(state);
+		} catch (error) {
+			console.warn("[smrt-web] updateAvailable subscriber threw", error);
+		}
+	};
+	const setBundle = () => {
+		if (bundle) return;
+		bundle = true;
+		notify();
+	};
+	const setContract = () => {
+		if (contract) return;
+		contract = true;
+		notify();
+	};
+	return {
+		get: snapshot,
+		subscribe(callback) {
+			subscribers.add(callback);
+			try {
+				callback(snapshot());
+			} catch (error) {
+				console.warn("[smrt-web] updateAvailable subscriber threw", error);
+			}
+			return () => {
+				subscribers.delete(callback);
+			};
+		},
+		notifyBundleUpdated: setBundle,
+		ready: (async () => {
+			const runningHash = config.manifestHash;
+			if (runningHash === void 0) return;
+			let store;
+			try {
+				store = await openVersionMetaStore(namespace);
+			} catch {
+				return;
+			}
+			if (disposed) {
+				store.close();
+				return;
+			}
+			metaStore = store;
+			unregister = registerDurableResource(namespace, {
+				kind: "persisted-collection",
+				clear: () => store.clear()
+			});
+			let lastSeen;
+			try {
+				lastSeen = await store.get(LAST_SEEN_MANIFEST_HASH_KEY);
+			} catch {
+				lastSeen = void 0;
+			}
+			if (disposed) return;
+			if (lastSeen !== void 0 && lastSeen !== runningHash) setContract();
+			if (lastSeen !== runningHash) try {
+				await store.set(LAST_SEEN_MANIFEST_HASH_KEY, runningHash);
+			} catch {}
+		})(),
+		dispose() {
+			disposed = true;
+			unregister?.();
+			unregister = void 0;
+			metaStore?.close();
+			metaStore = void 0;
+			subscribers.clear();
+		}
+	};
+}
+//#endregion
 //#region src/index.ts
 var SmrtWebRequestError = class extends Error {
 	payload;
@@ -1174,7 +1574,12 @@ function createSmrtCollection(definition, options) {
 		get cacheId() {
 			return cacheId;
 		},
-		invalidate: () => invalidateRelated()
+		invalidate: () => invalidateRelated(),
+		snapshot: () => collection.toArray.map((row) => toPlainRow(row)),
+		subscribe: (callback) => {
+			const subscription = collection.subscribeChanges((changes) => callback(projectChanges(changes)));
+			return { unsubscribe: () => subscription.unsubscribe() };
+		}
 	};
 	for (const capability of capabilities) {
 		let extra;
@@ -1374,6 +1779,6 @@ function createSmrtCollection(definition, options) {
 	return handle;
 }
 //#endregion
-export { SmrtWebRequestError, createDefinitionFetchers, createSmrtCollection, createSmrtWebClient, createSmrtWebEventSubscriber, durableStoreNamespace, getEngineCollection, getOutboxHandle, liveInvalidation, newLocalId, offlineOutbox, registerDurableResource, runWrapMutation, unwrapItemResult, unwrapListResult, wipeDurableStore };
+export { DEFAULT_PERSIST_DEBOUNCE_MS, SmrtWebRequestError, createDefinitionFetchers, createSmrtCollection, createSmrtWebClient, createSmrtWebEventSubscriber, createUpdateState, durableStoreNamespace, getEngineCollection, getOutboxHandle, liveInvalidation, newLocalId, offlineOutbox, persistCollection, registerDurableResource, runWrapMutation, unwrapItemResult, unwrapListResult, wipeDurableStore };
 
 //# sourceMappingURL=index.js.map