@minnowdb/core 0.10.0 → 0.10.2

package/dist/engine/auto-store.d.ts

@@ -1,3 +1,11 @@
+/**
+ * What the composition root knows that this module must not import: whether an OPFS database
+ * directory of a name exists. The OPFS adapter provides it (`opfsDatabaseExists`); a root that
+ * cannot bundle OPFS leaves it out, and OPFS is then never chosen for an unknown name anyway.
+ */
+export interface AutoStoreProbes {
+    opfsDatabaseExists?: (name: string) => Promise<boolean>;
+}
 /**
  * The `{ kind: "auto" }` store: OPFS where this context can hold synchronous access handles,
  * IndexedDB where it cannot (Safari's private browsing, a page context, an older build).
@@ -11,6 +19,8 @@ export type AutoStoreKind = "opfs" | "indexeddb";
 /** Test seams: the OPFS probe and the IndexedDB factory that keeps the choices. */
 export declare const autoStoreTestHooks: {
     opfsAvailable?: () => Promise<boolean>;
+    /** Whether an OPFS database directory of this name exists; Node has no OPFS to ask. */
+    opfsDatabaseExists?: (name: string) => Promise<boolean>;
     indexedDB?: IDBFactory;
 };
 /**
@@ -24,15 +34,17 @@ export declare function opfsAvailable(): Promise<boolean>;
  * instant in contexts that disagree still end up on the one store the record names; the
  * caller reports through `settleAutoStoreChoice` whether that reservation produced a database.
  */
-export declare function resolveAutoStoreKind(name: string): Promise<{
+export declare function resolveAutoStoreKind(name: string, probes?: AutoStoreProbes): Promise<{
     kind: AutoStoreKind;
     reserved: boolean;
 }>;
 /**
  * Opens the store `auto` resolves to. A reservation that produced no database is released
- * again, so a first open that failed does not pin the name to a store that never held data.
+ * again, so a first open that failed does not pin the name to a store that never held data —
+ * but only when the store really holds none: another connection may have opened the same
+ * reservation successfully in the meantime, and its database must keep its memory.
  */
-export declare function openAutoStore<Store>(name: string, open: (kind: AutoStoreKind) => Promise<Store>): Promise<{
+export declare function openAutoStore<Store>(name: string, open: (kind: AutoStoreKind) => Promise<Store>, probes?: AutoStoreProbes): Promise<{
     store: Store;
     kind: AutoStoreKind;
 }>;

package/dist/engine/auto-store.js

@@ -19,7 +19,7 @@ async function opfsAvailable() {
     return false;
   }
 }
-async function resolveAutoStoreKind(name) {
+async function resolveAutoStoreKind(name, probes = {}) {
   const remembered = await readChoice(name);
   if (remembered === "indexeddb")
     return { kind: "indexeddb", reserved: false };
@@ -28,22 +28,64 @@ async function resolveAutoStoreKind(name) {
       return { kind: "opfs", reserved: false };
     throw new DatabaseStoreUnavailableError("opfs", name, `Database "${name}" lives on the OPFS store, which this context cannot open; it is not reopened on IndexedDB, where it would be empty`);
   }
-  const kind = await opfsAvailable() ? "opfs" : "indexeddb";
+  const existing = await existingDatabaseStore(name, probes);
+  let kind;
+  if (existing === "opfs" && !await opfsAvailable()) {
+    throw new DatabaseStoreUnavailableError("opfs", name, `Database "${name}" lives on the OPFS store, which this context cannot open; it is not reopened on IndexedDB, where it would be empty`);
+  } else if (existing !== void 0)
+    kind = existing;
+  else
+    kind = await opfsAvailable() ? "opfs" : "indexeddb";
   const reserved = await reserveChoice(name, kind);
   if (reserved)
     return { kind, reserved: true };
-  return resolveAutoStoreKind(name);
+  return resolveAutoStoreKind(name, probes);
 }
-async function openAutoStore(name, open) {
-  const { kind, reserved } = await resolveAutoStoreKind(name);
+async function openAutoStore(name, open, probes = {}) {
+  const { kind, reserved } = await resolveAutoStoreKind(name, probes);
   try {
     return { store: await open(kind), kind };
   } catch (error) {
-    if (reserved)
+    if (reserved && await existingDatabaseStore(name, probes).catch(() => kind) !== kind) {
       await forgetStoreChoice(name).catch(() => void 0);
+    }
     throw error;
   }
 }
+async function existingDatabaseStore(name, probes) {
+  const opfsExists = autoStoreTestHooks.opfsDatabaseExists ?? probes.opfsDatabaseExists;
+  if (opfsExists !== void 0 && await opfsExists(name))
+    return "opfs";
+  if (await indexedDbDatabaseExists(name))
+    return "indexeddb";
+  return void 0;
+}
+async function indexedDbDatabaseExists(name) {
+  const factory = choiceFactory();
+  if (factory === void 0)
+    return false;
+  const list = factory.databases;
+  if (typeof list === "function") {
+    try {
+      return (await list.call(factory)).some((entry) => entry.name === name);
+    } catch {
+    }
+  }
+  return new Promise((resolve) => {
+    const request = factory.open(name);
+    let created = false;
+    request.addEventListener("upgradeneeded", () => {
+      created = true;
+      request.transaction?.abort();
+    });
+    request.addEventListener("success", () => {
+      request.result.close();
+      resolve(!created);
+    });
+    request.addEventListener("error", () => resolve(false));
+    request.addEventListener("blocked", () => resolve(true));
+  });
+}
 async function forgetStoreChoice(name) {
   const database = await openChoices();
   if (database === void 0)

package/dist/engine/client.js

@@ -1,5 +1,5 @@
 import { createLiveQueryPatch } from "./live-patch.js";
-import { BlockReadBatchTooLargeError, CompactionBacklogError, CompactionJobConflictError, ConnectionLostError, GarbageCollectionJobConflictError, IndexedDbSchemaUpgradeBlockedError, LeaseConflictError, LeaseExpiredError, LeaseOwnerConflictError, OpfsCoordinationError, OpfsDatabaseInUseError, OpfsUncertainOutcomeError, PostingBuildConflictError, SchemaConflictError, SnapshotImportConflictError, SnapshotManifestMissingError, StorageCorruptionError, StorageFormatVersionError, StorageResourceLimitError, TableInUseError, TableRecordConflictError, TempOwnerConflictError, TransactionRecordConflictError, UniqueIndexCoverageError, UniqueKeyBuildConflictError, UniqueKeyConflictError, UnknownOutcomeError, WriteConflictError } from "../storage/types.js";
+import { BlockReadBatchTooLargeError, CompactionBacklogError, CompactionJobConflictError, ConnectionLostError, GarbageCollectionJobConflictError, IndexedDbSchemaUpgradeBlockedError, LeaseConflictError, LeaseExpiredError, LeaseOwnerConflictError, OpfsCoordinationError, OpfsDatabaseInUseError, OpfsUncertainOutcomeError, PostingBuildConflictError, SchemaConflictError, SnapshotImportConflictError, SnapshotManifestMissingError, StorageCorruptionError, StorageFormatVersionError, StorageUnresponsiveError, StorageResourceLimitError, TableInUseError, TableRecordConflictError, TempOwnerConflictError, TransactionRecordConflictError, UniqueIndexCoverageError, UniqueKeyBuildConflictError, UniqueKeyConflictError, UnknownOutcomeError, WriteConflictError } from "../storage/types.js";
 import { MAX_SNAPSHOT_STREAM_CHUNK_BYTES } from "../storage/snapshot.js";
 import { MAX_DATABASE_RPC_IN_FLIGHT, WORKER_DIAGNOSTIC_HANDLE_ID, isWorkerErrorReport, parseRpcResponse, MIN_WORKER_KEEPALIVE_INTERVAL_MS, WORKER_KEEPALIVE_INTERVAL_MS, protocolVersion, rehydrateError as rehydrateSerializedError } from "../worker-protocol/index.js";
 import { definedVectors, toColumnarBatch } from "./batch.js";
@@ -65,6 +65,7 @@ const errorRegistry = new Map([
   PostingBuildConflictError,
   StorageCorruptionError,
   StorageFormatVersionError,
+  StorageUnresponsiveError,
   OpfsCoordinationError,
   OpfsDatabaseInUseError,
   OpfsUncertainOutcomeError,
@@ -188,6 +189,9 @@ class MinnowDatabaseClient {
     this.#events.clear();
     this.#transport = next;
     this.#ready = this.#attach(next);
+    if (this.#onVisibilityChange !== void 0 && typeof document !== "undefined") {
+      document.addEventListener("visibilitychange", this.#onVisibilityChange);
+    }
     this.#onVisibilityChange?.();
     await this.#ready;
   }
@@ -578,7 +582,7 @@ class MinnowDatabaseClient {
     try {
       await this.#post("rpc-call", null, "dispose", [], void 0, true, { timeoutMs });
     } finally {
-      this.#fail(new Error("Database client is closed"));
+      this.#fail(new Error("Database client is closed"), true);
       this.#transport.removeEventListener?.("message", this.#onMessage);
       this.#transport.removeEventListener?.("error", this.#onError);
       this.#transport.removeEventListener?.("messageerror", this.#onMessageError);
@@ -750,25 +754,37 @@ class MinnowDatabaseClient {
   }
   #rejectUnreadable(message, cause) {
     const reason = cause instanceof Error ? cause.message : String(cause);
-    const error = new Error(`The database worker sent a frame this client cannot read: ${reason}`, {
-      cause
-    });
+    const text = `The database worker sent a frame this client cannot read: ${reason}`;
     const requestId = message.requestId;
     const pending = typeof requestId === "string" ? this.#pending.get(requestId) : void 0;
     if (pending === void 0 || typeof requestId !== "string") {
-      this.#fail(error);
+      this.#fail(new DatabaseWorkerFailedError("messageerror", text, { cause }));
       return;
     }
+    const error = new Error(text, { cause });
     this.#pending.delete(requestId);
     pending.cleanup?.();
     pending.reject(pending.mayPublish ? new DatabaseWorkerOutcomeUnknownError(pending.method, requestId, { cause: error }) : error);
   }
-  #fail(error) {
+  #fail(error, closing = false) {
     const first = this.#fatal === void 0;
     this.#fatal = error;
     const pending = [...this.#pending.values()];
     this.#pending.clear();
+    const routes = [...this.#events.values()];
     this.#events.clear();
+    for (const route of routes) {
+      if (!closing) {
+        try {
+          route.onError?.(error);
+        } catch {
+        }
+      }
+      try {
+        route.onComplete?.();
+      } catch {
+      }
+    }
     for (const call of pending) {
       call.cleanup?.();
       call.reject(call.mayPublish ? new DatabaseWorkerOutcomeUnknownError(call.method, call.requestId, { cause: error }) : error);