@abraca/dabra 1.0.12 → 1.0.14

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[]>;
@@ -1390,6 +1393,23 @@ 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>;
+  /** Return metadata for all cached blobs (for storage stats). */
+  getAllCachedEntries(): Promise<Array<{
+    docId: string;
+    uploadId: string;
+    filename: string;
+    mimeType: string;
+    size: number;
+    cachedAt: number;
+  }>>;
+  /** Revoke all object URLs and clear the entire blob cache from IDB. */
+  clearAllBlobs(): Promise<void>;
   /** 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.12",
+  "version": "1.0.14",
   "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

@@ -213,6 +213,65 @@ 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;
+	}
+
+	/** Return metadata for all cached blobs (for storage stats). */
+	async getAllCachedEntries(): Promise<Array<{
+		docId: string; uploadId: string; filename: string;
+		mimeType: string; size: number; cachedAt: number;
+	}>> {
+		const db = await this.getDb();
+		if (!db) return [];
+		return new Promise((resolve, reject) => {
+			const tx = db.transaction("blobs", "readonly");
+			const store = tx.objectStore("blobs");
+			const keysReq = store.getAllKeys();
+			const valuesReq = store.getAll();
+			tx.oncomplete = () => {
+				const keys = keysReq.result as string[];
+				const values = valuesReq.result as BlobCacheEntry[];
+				resolve(keys.map((key, i) => {
+					const slashIdx = key.indexOf("/");
+					const docId = key.slice(0, slashIdx);
+					const uploadId = key.slice(slashIdx + 1);
+					const e = values[i]!;
+					return { docId, uploadId, filename: e.filename, mimeType: e.mime_type, size: e.blob.size, cachedAt: e.cachedAt };
+				}));
+			};
+			tx.onerror = () => reject(tx.error);
+		});
+	}
+
+	/** Revoke all object URLs and clear the entire blob cache from IDB. */
+	async clearAllBlobs(): Promise<void> {
+		for (const url of this.objectUrls.values()) URL.revokeObjectURL(url);
+		this.objectUrls.clear();
+		const db = await this.getDb();
+		if (!db) return;
+		return new Promise((resolve, reject) => {
+			const tx = db.transaction("blobs", "readwrite");
+			const req = tx.objectStore("blobs").clear();
+			req.onsuccess = () => resolve();
+			req.onerror = () => reject(req.error);
+		});
+	}
+
 	/** 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;
 	}
 }