@abraca/dabra 1.0.11 → 1.0.13

package/dist/index.d.ts

@@ -163,6 +163,7 @@ declare class OfflineStore {
    */
   constructor(docId: string, serverOrigin?: string);
   private dbPromise;
+  private _destroyed;
   private getDb;
   persistUpdate(update: Uint8Array): Promise<void>;
   getPendingUpdates(): Promise<Uint8Array[]>;
@@ -359,6 +360,8 @@ declare class AbracadabraClient {
   /** Create a child document under a parent (requires write permission). */
   createChild(docId: string, opts?: {
     child_id?: string;
+    doc_type?: string;
+    label?: string;
   }): Promise<DocumentMeta>;
   /** List all permissions for a document (requires read access). */
   listPermissions(docId: string): Promise<PermissionEntry[]>;
@@ -1368,6 +1371,9 @@ declare class FileBlobStore extends EventEmitter {
   private db;
   /** Tracks active object URLs so we can revoke them on destroy. */
   private readonly objectUrls;
+  /** Keys that returned 404 from the server — avoids repeated requests. TTL: 5 min. */
+  private readonly _notFound;
+  private static readonly NOT_FOUND_TTL;
   /** Prevents concurrent flush runs. */
   private _flushing;
   private readonly _onlineHandler;
@@ -1387,6 +1393,12 @@ declare class FileBlobStore extends EventEmitter {
    * that haven't been uploaded to the server yet (e.g. offline upload queue).
    */
   putBlob(docId: string, uploadId: string, blob: Blob, filename: string): Promise<string>;
+  /**
+   * Retrieve the raw Blob from IDB for a previously cached upload.
+   * Returns null if the blob has been evicted or was never stored.
+   * Use this to re-upload a file after a page reload.
+   */
+  getBlob(docId: string, uploadId: string): Promise<Blob | null>;
   /** Revoke the object URL and remove the blob from cache. */
   evictBlob(docId: string, uploadId: string): Promise<void>;
   /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@abraca/dabra",
-  "version": "1.0.11",
+  "version": "1.0.13",
   "description": "abracadabra provider",
   "keywords": [
     "abracadabra",

package/src/AbracadabraClient.ts

@@ -330,7 +330,7 @@ export class AbracadabraClient {
 	}
 
 	/** Create a child document under a parent (requires write permission). */
-	async createChild(docId: string, opts?: { child_id?: string }): Promise<DocumentMeta> {
+	async createChild(docId: string, opts?: { child_id?: string; doc_type?: string; label?: string }): Promise<DocumentMeta> {
 		return this.request<DocumentMeta>(
 			"POST",
 			`/docs/${encodeURIComponent(docId)}/children`,

package/src/AbracadabraWS.ts

@@ -349,12 +349,21 @@ export class AbracadabraWS extends EventEmitter {
       delete this.webSocketHandlers[identifier];
     });
 
+    // After removing our handlers, ensure there is always at least one error
+    // listener on the socket. Without one, any asynchronously-fired error
+    // (e.g. "WebSocket was closed before the connection was established" when
+    // closing a CONNECTING socket) will propagate as an uncaught exception in
+    // Node.js. The no-op listener absorbs these post-cleanup errors safely.
+    if (this.webSocket.readyState !== 3 /* CLOSED */) {
+      this.webSocket.addEventListener("error", () => {});
+    }
+
     try {
-      // Check if the WebSocket is still in CONNECTING state (0)
-      // If so, calling close() might throw in some environments or be race-prone
-      if (this.webSocket.readyState !== 0 && this.webSocket.readyState !== 3) {
+      if (this.webSocket.readyState !== 0 /* CONNECTING */ && this.webSocket.readyState !== 3 /* CLOSED */) {
         this.webSocket.close();
       }
+      // CONNECTING (0): already being closed by disconnect(), or will be closed imminently.
+      // CLOSED (3): nothing to do.
     } catch (e) {
       // Ignore errors during close
     }
@@ -539,6 +548,10 @@ export class AbracadabraWS extends EventEmitter {
   }
 
   destroy() {
+    // Mark as not wanting a connection FIRST so that onClose (fired by disconnect()
+    // below) does not schedule a new reconnect setTimeout after we've torn down.
+    this.shouldConnect = false;
+
     this.emit("destroy");
 
     clearInterval(this.intervals.connectionChecker);

package/src/FileBlobStore.ts

@@ -70,6 +70,10 @@ export class FileBlobStore extends EventEmitter {
 	/** Tracks active object URLs so we can revoke them on destroy. */
 	private readonly objectUrls = new Map<string, string>();
 
+	/** Keys that returned 404 from the server — avoids repeated requests. TTL: 5 min. */
+	private readonly _notFound = new Map<string, number>();
+	private static readonly NOT_FOUND_TTL = 5 * 60 * 1000;
+
 	/** Prevents concurrent flush runs. */
 	private _flushing = false;
 
@@ -137,10 +141,21 @@ export class FileBlobStore extends EventEmitter {
 
 		// Not cached — try downloading from server (requires a client)
 		if (!this.client) return null;
+
+		// Skip if we recently got a 404 for this key
+		const nfTime = this._notFound.get(key);
+		if (nfTime && Date.now() - nfTime < FileBlobStore.NOT_FOUND_TTL) {
+			return null;
+		}
+
 		let blob: Blob;
 		try {
 			blob = await this.client.getUpload(docId, uploadId);
-		} catch {
+		} catch (err: unknown) {
+			const status = (err as any)?.status;
+			if (status === 404) {
+				this._notFound.set(key, Date.now());
+			}
 			return null;
 		}
 
@@ -175,6 +190,7 @@ export class FileBlobStore extends EventEmitter {
 		if (typeof window === "undefined") return URL.createObjectURL(blob);
 
 		const key = this.blobKey(docId, uploadId);
+		this._notFound.delete(key);
 
 		// Return existing URL if already cached in-memory
 		const existing = this.objectUrls.get(key);
@@ -197,6 +213,24 @@ export class FileBlobStore extends EventEmitter {
 		return url;
 	}
 
+	/**
+	 * Retrieve the raw Blob from IDB for a previously cached upload.
+	 * Returns null if the blob has been evicted or was never stored.
+	 * Use this to re-upload a file after a page reload.
+	 */
+	async getBlob(docId: string, uploadId: string): Promise<Blob | null> {
+		const db = await this.getDb();
+		if (!db) return null;
+
+		const key = this.blobKey(docId, uploadId);
+		const tx = db.transaction("blobs", "readonly");
+		const entry = await txPromise<BlobCacheEntry | undefined>(
+			tx.objectStore("blobs"),
+			tx.objectStore("blobs").get(key),
+		);
+		return entry?.blob ?? null;
+	}
+
 	/** Revoke the object URL and remove the blob from cache. */
 	async evictBlob(docId: string, uploadId: string): Promise<void> {
 		const key = this.blobKey(docId, uploadId);

package/src/OfflineStore.ts

@@ -79,8 +79,10 @@ export class OfflineStore {
 
 	private dbPromise: Promise<IDBDatabase | null> | null = null;
 
+	private _destroyed = false;
+
 	private getDb(): Promise<IDBDatabase | null> {
-		if (!idbAvailable()) return Promise.resolve(null);
+		if (this._destroyed || !idbAvailable()) return Promise.resolve(null);
 		if (!this.dbPromise) {
 			// Cache the promise so concurrent callers share a single open operation.
 			this.dbPromise = openDb(this.storeKey).catch(() => null).then(db => {
@@ -234,7 +236,7 @@ export class OfflineStore {
 		const tx = db.transaction("meta", "readonly");
 		const result = await txPromise<string | undefined>(
 			tx.objectStore("meta"),
-			tx.objectStore("meta").get(key),
+			tx.objectStore("meta").get(`meta:${key}`),
 		);
 		return result ?? null;
 	}
@@ -245,14 +247,19 @@ export class OfflineStore {
 		const tx = db.transaction("meta", "readwrite");
 		await txPromise(
 			tx.objectStore("meta"),
-			tx.objectStore("meta").put(value, key),
+			tx.objectStore("meta").put(value, `meta:${key}`),
 		);
 	}
 
 	// ── Lifecycle ─────────────────────────────────────────────────────────────
 
 	destroy() {
-		this.db?.close();
+		// Set the destroyed flag first so getDb() returns null for any new operations.
+		// Do NOT call db.close() here — in-flight IDB transactions hold their own
+		// reference to the database and closing it prematurely causes InvalidStateError.
+		// The DB will be closed and garbage-collected once all transactions complete.
+		this._destroyed = true;
 		this.db = null;
+		this.dbPromise = null;
 	}
 }