@minnowdb/core 0.10.0 → 0.10.1

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-audit-harness.js

@@ -0,0 +1,123 @@
+import { MemoryBlockStore } from "../storage/index.js";
+function createBoundary() {
+  const clientListeners = /* @__PURE__ */ new Map();
+  const workerListeners = /* @__PURE__ */ new Map();
+  let chain = Promise.resolve();
+  let severed = false;
+  const sentByClient = [];
+  const sentByWorker = [];
+  const deliver = (target, message, transfer) => {
+    const data = structuredClone(message, transfer === void 0 ? void 0 : { transfer });
+    if (severed)
+      return;
+    chain = chain.then(() => {
+      if (severed)
+        return;
+      for (const listener of target.get("message") ?? [])
+        listener({ data });
+    });
+  };
+  const add = (map, type, listener) => {
+    const list = map.get(type) ?? [];
+    list.push(listener);
+    map.set(type, list);
+  };
+  const remove = (map, type, listener) => {
+    const list = map.get(type) ?? [];
+    const index = list.indexOf(listener);
+    if (index >= 0)
+      list.splice(index, 1);
+  };
+  const clientSide = {
+    postMessage: (message, options) => {
+      sentByClient.push(structuredClone(message));
+      deliver(workerListeners, message, options?.transfer);
+    },
+    addEventListener: (type, listener) => {
+      add(clientListeners, type, listener);
+    },
+    removeEventListener: (type, listener) => {
+      remove(clientListeners, type, listener);
+    },
+    terminate: () => {
+      severed = true;
+    }
+  };
+  const workerSide = {
+    postMessage: (message, options) => {
+      sentByWorker.push(structuredClone(message));
+      deliver(clientListeners, message, options?.transfer);
+    },
+    addEventListener: (type, listener) => {
+      add(workerListeners, type, listener);
+    }
+  };
+  return {
+    sentByClient,
+    sentByWorker,
+    clientSide,
+    workerSide,
+    sever: () => {
+      severed = true;
+    },
+    injectToClient: (frame) => {
+      for (const listener of clientListeners.get("message") ?? []) {
+        listener({ data: frame });
+      }
+    },
+    injectToWorker: (frame) => {
+      for (const listener of workerListeners.get("message") ?? []) {
+        listener({ data: frame });
+      }
+    },
+    emitWorkerGlobal: (type, event) => {
+      for (const listener of workerListeners.get(type) ?? [])
+        listener(event);
+    },
+    emitTransport: (type, event) => {
+      for (const listener of clientListeners.get(type) ?? [])
+        listener(event);
+    },
+    flush: async () => {
+      await chain;
+      await new Promise((resolve) => setTimeout(resolve, 5));
+    }
+  };
+}
+function settled(ms = 20) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function faultyStore(fault, options = {}) {
+  const inner = new MemoryBlockStore();
+  const calls = [];
+  const hidden = new Set(options.hide ?? []);
+  const store = new Proxy(inner, {
+    get(target, property) {
+      if (typeof property === "string" && hidden.has(property))
+        return void 0;
+      const value = target[property];
+      if (typeof value !== "function" || typeof property !== "string")
+        return value;
+      const method = property;
+      return (...args) => {
+        const run = () => value.apply(inner, args);
+        const isAsync = value.constructor?.name === "AsyncFunction";
+        if (!isAsync)
+          return run();
+        calls.push({ method, args });
+        return fault(method, args, run);
+      };
+    },
+    has(target, property) {
+      if (typeof property === "string" && hidden.has(property))
+        return false;
+      return Reflect.has(target, property);
+    }
+  });
+  return { store, calls };
+}
+export {
+  createBoundary,
+  faultyStore,
+  settled
+};

package/dist/engine/client.js

@@ -188,6 +188,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 +581,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 +753,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);