@abraca/dabra 0.2.0 → 0.3.0

package/dist/abracadabra-provider.cjs

@@ -1991,18 +1991,19 @@ var HocuspocusProvider = class extends EventEmitter {
 
 //#endregion
 //#region packages/provider/src/OfflineStore.ts
-const DB_VERSION = 1;
+const DB_VERSION = 2;
 function idbAvailable() {
 	return typeof globalThis !== "undefined" && "indexedDB" in globalThis;
 }
-function openDb$1(docId) {
+function openDb$1(storeKey) {
 	return new Promise((resolve, reject) => {
-		const req = globalThis.indexedDB.open(`abracadabra:${docId}`, DB_VERSION);
+		const req = globalThis.indexedDB.open(`abracadabra:${storeKey}`, DB_VERSION);
 		req.onupgradeneeded = (event) => {
 			const db = event.target.result;
 			if (!db.objectStoreNames.contains("updates")) db.createObjectStore("updates", { autoIncrement: true });
 			if (!db.objectStoreNames.contains("meta")) db.createObjectStore("meta");
 			if (!db.objectStoreNames.contains("subdoc_queue")) db.createObjectStore("subdoc_queue", { keyPath: "childId" });
+			if (!db.objectStoreNames.contains("doc_state")) db.createObjectStore("doc_state");
 		};
 		req.onsuccess = () => resolve(req.result);
 		req.onerror = () => reject(req.error);
@@ -2015,13 +2016,19 @@ function txPromise(store, request) {
 	});
 }
 var OfflineStore = class {
-	constructor(docId) {
+	/**
+	* @param docId       The document UUID.
+	* @param serverOrigin  Hostname of the server (e.g. "abra.cou.sh").
+	*                    When provided the IndexedDB database is namespaced
+	*                    per-server, preventing cross-server data contamination.
+	*/
+	constructor(docId, serverOrigin) {
 		this.db = null;
-		this.docId = docId;
+		this.storeKey = serverOrigin ? `${serverOrigin}/${docId}` : docId;
 	}
 	async getDb() {
 		if (!idbAvailable()) return null;
-		if (!this.db) this.db = await openDb$1(this.docId).catch(() => null);
+		if (!this.db) this.db = await openDb$1(this.storeKey).catch(() => null);
 		return this.db;
 	}
 	async persistUpdate(update) {
@@ -2045,6 +2052,25 @@ var OfflineStore = class {
 		const tx = db.transaction("updates", "readwrite");
 		await txPromise(tx.objectStore("updates"), tx.objectStore("updates").clear());
 	}
+	/**
+	* Persist a full Y.js state snapshot (Y.encodeStateAsUpdate output).
+	* Replaces any previously stored snapshot.
+	*/
+	async saveDocSnapshot(snapshot) {
+		const db = await this.getDb();
+		if (!db) return;
+		const tx = db.transaction("doc_state", "readwrite");
+		await txPromise(tx.objectStore("doc_state"), tx.objectStore("doc_state").put(snapshot, "snapshot"));
+	}
+	/**
+	* Retrieve the stored full document snapshot, or null if none exists.
+	*/
+	async getDocSnapshot() {
+		const db = await this.getDb();
+		if (!db) return null;
+		const tx = db.transaction("doc_state", "readonly");
+		return await txPromise(tx.objectStore("doc_state"), tx.objectStore("doc_state").get("snapshot")) ?? null;
+	}
 	async getStateVector() {
 		const db = await this.getDb();
 		if (!db) return null;
@@ -2138,10 +2164,16 @@ function isValidDocId(id) {
 *     own AbracadabraProvider instances sharing the same WebSocket connection.
 *
 *  2. Offline-first – persists CRDT updates to IndexedDB so they survive
-*     page reloads and network outages.  On reconnect, pending updates are
-*     flushed before resuming normal sync.
+*     page reloads and network outages.  On startup, the last saved document
+*     snapshot is applied immediately so the UI is usable without a server
+*     connection.  On reconnect, pending updates are flushed and a fresh
+*     snapshot is saved.
+*
+*  3. Server-scoped storage – the IndexedDB database is keyed by server
+*     hostname + docId, preventing cross-server data contamination when the
+*     same docId is used on multiple servers.
 *
-*  3. Permission snapshotting – stores the resolved role locally so the UI
+*  4. Permission snapshotting – stores the resolved role locally so the UI
 *     can gate write operations without a network round-trip.  Role is
 *     refreshed from the server on every reconnect.
 */
@@ -2161,12 +2193,41 @@ var AbracadabraProvider = class AbracadabraProvider extends HocuspocusProvider {
 		this._client = client;
 		this.abracadabraConfig = configuration;
 		this.subdocLoading = configuration.subdocLoading ?? "lazy";
-		this.offlineStore = configuration.disableOfflineStore ? null : new OfflineStore(configuration.name);
+		const serverOrigin = AbracadabraProvider.deriveServerOrigin(configuration, client);
+		this.offlineStore = configuration.disableOfflineStore ? null : new OfflineStore(configuration.name, serverOrigin);
 		this.on("subdocRegistered", configuration.onSubdocRegistered ?? (() => null));
 		this.on("subdocLoaded", configuration.onSubdocLoaded ?? (() => null));
 		this.document.on("subdocs", this.boundHandleYSubdocsChange);
 		this.on("synced", () => this.flushPendingUpdates());
 		this.restorePermissionSnapshot();
+		this.ready = this._initFromOfflineStore();
+	}
+	/**
+	* Extract the server hostname from the provider configuration.
+	* Used to namespace the IndexedDB key so docs from different servers
+	* never share the same database.
+	*/
+	static deriveServerOrigin(config, client) {
+		try {
+			const url = config.url ?? config.websocketProvider?.url ?? client?.wsUrl;
+			if (url) return new URL(url).hostname;
+		} catch {}
+	}
+	/**
+	* Load the stored document snapshot (and any pending local edits) from
+	* IndexedDB and apply them to the Y.Doc so the UI can render without a
+	* server connection.
+	*
+	* Uses `this.offlineStore` as the Y.js update origin so that
+	* `documentUpdateHandler` ignores these replayed updates and does not
+	* attempt to re-persist or re-send them.
+	*/
+	async _initFromOfflineStore() {
+		if (!this.offlineStore) return;
+		const snapshot = await this.offlineStore.getDocSnapshot().catch(() => null);
+		if (snapshot) yjs.applyUpdate(this.document, snapshot, this.offlineStore);
+		const pending = await this.offlineStore.getPendingUpdates().catch(() => []);
+		for (const update of pending) yjs.applyUpdate(this.document, update, this.offlineStore);
 	}
 	authenticatedHandler(scope) {
 		super.authenticatedHandler(scope);
@@ -2304,7 +2365,7 @@ var AbracadabraProvider = class AbracadabraProvider extends HocuspocusProvider {
 	}
 	async _doLoadChild(childId) {
 		const childDoc = new yjs.Doc({ guid: childId });
-		await new Promise((resolve) => {
+		if (this.isConnected) await new Promise((resolve) => {
 			const onRegistered = ({ childId: cid }) => {
 				if (cid === childId) {
 					this.off("subdocRegistered", onRegistered);
@@ -2315,6 +2376,7 @@ var AbracadabraProvider = class AbracadabraProvider extends HocuspocusProvider {
 			this.registerSubdoc(childDoc);
 			setTimeout(resolve, 3e3);
 		});
+		else this.registerSubdoc(childDoc);
 		const childProvider = new AbracadabraProvider({
 			name: childId,
 			document: childDoc,
@@ -2347,31 +2409,45 @@ var AbracadabraProvider = class AbracadabraProvider extends HocuspocusProvider {
 	/**
 	* Override to persist every local update to IndexedDB before sending it
 	* over the wire, ensuring no work is lost during connection outages.
+	*
+	* Updates applied by the server (origin === this) and updates replayed
+	* from the offline store (origin === this.offlineStore) are both skipped
+	* to avoid loops.
 	*/
 	documentUpdateHandler(update, origin) {
 		if (origin === this) return;
+		if (this.offlineStore !== null && origin === this.offlineStore) return;
 		this.offlineStore?.persistUpdate(update).catch(() => null);
 		super.documentUpdateHandler(update, origin);
 	}
 	/**
-	* After reconnect + sync, flush any updates that were generated while
-	* offline, then flush any queued subdoc registrations.
+	* After reconnect + sync:
+	*  1. Flush any updates that were generated while offline.
+	*  2. Flush any queued subdoc registrations.
+	*  3. Save a fresh full document snapshot for the next offline session.
+	*
+	* Uses a local `store` reference captured at the start so that a concurrent
+	* `destroy()` call setting `offlineStore = null` does not cause null-ref
+	* errors across async await boundaries.
 	*/
 	async flushPendingUpdates() {
-		if (!this.offlineStore) return;
-		const updates = await this.offlineStore.getPendingUpdates();
+		const store = this.offlineStore;
+		if (!store) return;
+		const updates = await store.getPendingUpdates();
 		if (updates.length > 0) {
 			for (const update of updates) this.send(UpdateMessage, {
 				update,
 				documentName: this.configuration.name
 			});
-			await this.offlineStore.clearPendingUpdates();
+			await store.clearPendingUpdates();
 		}
-		const pendingSubdocs = await this.offlineStore.getPendingSubdocs();
+		const pendingSubdocs = await store.getPendingSubdocs();
 		for (const { childId } of pendingSubdocs) this.send(SubdocMessage, {
 			documentName: this.configuration.name,
 			childDocumentName: childId
 		});
+		const snapshot = yjs.encodeStateAsUpdate(this.document);
+		await store.saveDocSnapshot(snapshot).catch(() => null);
 	}
 	get isConnected() {
 		return this.configuration.websocketProvider.status === "connected";