@abraca/dabra 2.19.0 → 2.20.0

package/dist/index.d.ts

@@ -1257,6 +1257,7 @@ interface AbracadabraProviderConfiguration extends Omit<AbracadabraBaseProviderC
  */
 declare class AbracadabraProvider extends AbracadabraBaseProvider {
   effectiveRole: EffectiveRole;
+  private _writeDropWarned;
   private _client;
   private offlineStore;
   private childProviders;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@abraca/dabra",
-  "version": "2.19.0",
+  "version": "2.20.0",
   "description": "abracadabra provider",
   "keywords": [
     "abracadabra",
@@ -41,7 +41,7 @@
     "yjs": "^13.6.8"
   },
   "devDependencies": {
-    "@abraca/schema": "2.19.0"
+    "@abraca/schema": "2.20.0"
   },
   "scripts": {
     "test": "node --no-warnings --conditions=source --experimental-transform-types --test 'tests/*.test.ts'"

package/src/AbracadabraProvider.ts

@@ -113,6 +113,10 @@ function isValidDocId(id: string): boolean {
 export class AbracadabraProvider extends AbracadabraBaseProvider {
 	public effectiveRole: EffectiveRole = null;
 
+	// Throttle the "write-drop" warning/event to once per (role) transition so a
+	// read-only editor session doesn't flood the console on every keystroke.
+	private _writeDropWarned = false;
+
 	private _client: AbracadabraClient | null;
 	private offlineStore: OfflineStore | null;
 	private childProviders = new Map<string, AbracadabraProvider>();
@@ -281,6 +285,10 @@ export class AbracadabraProvider extends AbracadabraBaseProvider {
 	// ── Auth / permission snapshot ────────────────────────────────────────────
 
 	override authenticatedHandler(scope: string) {
+		// NB: super.authenticatedHandler emits "authenticated" BEFORE we set
+		// effectiveRole below, so listeners of "authenticated" must not read the
+		// role from this provider — use the "roleChanged" event emitted at the end
+		// of this method instead, which fires once effectiveRole reflects `scope`.
 		super.authenticatedHandler(scope);
 
 		const roleMap: Record<string, import("./types.ts").EffectiveRole> = {
@@ -293,9 +301,28 @@ export class AbracadabraProvider extends AbracadabraBaseProvider {
 			"read-write": "editor",
 			readonly: "viewer",
 		};
+		const couldWrite = this.canWrite;
 		this.effectiveRole = roleMap[scope] ?? "observer";
 
 		this.offlineStore?.savePermissionSnapshot(this.effectiveRole);
+
+		// Regaining write access re-arms the one-shot write-drop warning so a later
+		// downgrade to a read-only role surfaces again.
+		if (this.canWrite) this._writeDropWarned = false;
+
+		// Reactive role signal for consumers (e.g. the editor edit-gate). Fired
+		// AFTER effectiveRole is set so `canWrite` reflects the new role.
+		this.emit("roleChanged", { role: this.effectiveRole, canWrite: this.canWrite });
+
+		// Self-heal: if the server's authentication frame arrived AFTER the initial
+		// sync (so the "synced" flush ran while the role was still null/stale and
+		// skipped, see flushPendingUpdates' canWrite guard), and we now have write
+		// access, push any updates that were queued to IndexedDB while we couldn't
+		// send. Without this, edits made before auth completed stay stuck in IDB
+		// (visible locally, never on the server) until the next reconnect.
+		if (!couldWrite && this.canWrite && this.isSynced) {
+			this.flushPendingUpdates().catch(() => null);
+		}
 	}
 
 	/**
@@ -363,6 +390,10 @@ export class AbracadabraProvider extends AbracadabraBaseProvider {
 		const role = await this.offlineStore.getPermissionSnapshot();
 		if (role && !this.effectiveRole) {
 			this.effectiveRole = role as EffectiveRole;
+			// Surface the cached role reactively so the offline edit-gate can open
+			// before any server round-trip. The server's authenticatedHandler will
+			// later override this with ground truth (and re-emit).
+			this.emit("roleChanged", { role: this.effectiveRole, canWrite: this.canWrite });
 		}
 	}
 
@@ -696,7 +727,32 @@ export class AbracadabraProvider extends AbracadabraBaseProvider {
 		this.offlineStore?.persistUpdate(update).catch(() => null);
 
 		// Don't send writes over the wire if we lack write permission.
-		if (!this.canWrite) return;
+		if (!this.canWrite) {
+			// Make the otherwise-silent write-drop observable. A local edit was just
+			// persisted to IndexedDB but will NOT be sent to the server because this
+			// provider's effective role can't write. If the editor UI let the user
+			// type here, the UI's write-gate diverged from this provider's — the edit
+			// lives only in local IDB (looks fine locally, empty on the server). We
+			// emit a "writeDropped" event so consumers can surface a read-only /
+			// "unsynced changes" banner, and warn once per role-transition so a
+			// read-only session doesn't flood the console on every keystroke.
+			if (!this._writeDropWarned) {
+				this._writeDropWarned = true;
+				try {
+					console.warn(
+						`[abra:write-drop] dropping wire-send for doc "${this.configuration?.name}" ` +
+							`— effectiveRole=${this.effectiveRole ?? "null"} (canWrite=false). ` +
+							`Edits are persisted to IndexedDB only; the server will NOT receive them ` +
+							`until this doc regains write access.`,
+					);
+				} catch { /* noop */ }
+			}
+			this.emit("writeDropped", {
+				name: this.configuration?.name,
+				role: this.effectiveRole ?? null,
+			});
+			return;
+		}
 
 		super.documentUpdateHandler(update, origin);
 	}