@minnowdb/core 0.9.1 → 0.10.0

package/dist/engine/worker-server.js

@@ -1,5 +1,5 @@
 import { MAX_SNAPSHOT_STREAM_CHUNK_BYTES } from "../storage/snapshot.js";
-import { parseRpcRequest, MAX_DATABASE_RPC_IN_FLIGHT, rpcEvent, rpcFailure, rpcResult, serializeError } from "../worker-protocol/index.js";
+import { MAX_DATABASE_RPC_IN_FLIGHT, parseRpcRequest, rpcEvent, rpcFailure, rpcResult, serializeError, MIN_WORKER_KEEPALIVE_INTERVAL_MS, WORKER_KEEPALIVE_INTERVAL_MS, workerErrorEvent, workerKeepaliveEvent } from "../worker-protocol/index.js";
 import { MinnowDatabase } from "./database.js";
 import { encodeQueryResult, encodeQueryRows } from "./result-wire.js";
 import { deserializeSchema, serializeMigrationSteps } from "./schema-wire.js";
@@ -156,6 +156,40 @@ function abortError(message) {
   error.name = "AbortError";
   return error;
 }
+const errorSinks = /* @__PURE__ */ new WeakMap();
+function workerErrorReporter(scope) {
+  const existing = errorSinks.get(scope);
+  if (existing !== void 0)
+    return existing;
+  const report = (kind, error, context) => {
+    try {
+      scope.postMessage(workerErrorEvent({ kind, context, error: serializeError(error) }));
+    } catch {
+    }
+  };
+  errorSinks.set(scope, report);
+  const listen = (type, listener) => {
+    try {
+      scope.addEventListener(type, listener);
+    } catch {
+    }
+  };
+  listen("error", (event) => {
+    const where = typeof event.filename === "string" && event.filename !== "" ? `${event.filename}:${String(event.lineno)}:${String(event.colno)}` : "worker global scope";
+    const error = event.error instanceof Error ? event.error : new Error(typeof event.message === "string" ? event.message : "Uncaught error");
+    report("uncaught", error, where);
+    event.preventDefault?.();
+  });
+  listen("unhandledrejection", (event) => {
+    report("unhandled-rejection", event.reason, "worker global scope");
+    event.preventDefault?.();
+  });
+  listen("messageerror", (event) => {
+    report("messageerror", new Error("A frame sent to the database worker could not be deserialized"), "worker inbound channel");
+    event.preventDefault?.();
+  });
+  return report;
+}
 const MAX_WORKER_HANDLES_PER_CONNECTION = 256;
 const DEFAULT_WRITE_HANDLE_IDLE_TIMEOUT_MS = 3e4;
 const MAX_TIMER_DELAY_MS = 2147483647;
@@ -174,10 +208,16 @@ class DatabaseRpcServer {
   #inFlightRpcDrain;
   #resolveInFlightRpcDrain;
   #writeHandleIdleTimeoutMs;
+  #report;
+  #storeKind;
+  #keepaliveIntervalMs;
   constructor(database, scope, options) {
     this.database = database;
     this.scope = scope;
     this.options = options;
+    this.#report = workerErrorReporter(scope);
+    this.#storeKind = options.storeKind;
+    this.#keepaliveIntervalMs = keepaliveInterval(options.keepaliveIntervalMs);
     this.#writeHandleIdleTimeoutMs = options.writeHandleIdleTimeoutMs ?? DEFAULT_WRITE_HANDLE_IDLE_TIMEOUT_MS;
     if (!Number.isSafeInteger(this.#writeHandleIdleTimeoutMs) || this.#writeHandleIdleTimeoutMs <= 0 || this.#writeHandleIdleTimeoutMs > MAX_TIMER_DELAY_MS) {
       throw new RangeError(`Worker write-handle idle timeout must be a positive whole number no greater than ${String(MAX_TIMER_DELAY_MS)}`);
@@ -185,7 +225,10 @@ class DatabaseRpcServer {
   }
   async handle(request) {
     if (request.kind === "rpc-init") {
-      this.scope.postMessage(rpcResult(request.requestId, { ready: true }));
+      this.scope.postMessage(rpcResult(request.requestId, {
+        ready: true,
+        ...this.#storeKind === void 0 ? {} : { store: this.#storeKind }
+      }));
       return;
     }
     if (request.kind === "rpc-cancel") {
@@ -199,6 +242,13 @@ class DatabaseRpcServer {
     }
     if (!bypassLimit)
       this.#inFlightRpcCount += 1;
+    const keepalive = setInterval(() => {
+      try {
+        this.scope.postMessage(workerKeepaliveEvent(request.requestId));
+      } catch {
+      }
+    }, this.#keepaliveIntervalMs);
+    unrefTimer(keepalive);
     const abort = request.method === "query" || request.method === "execute" ? new AbortController() : void 0;
     if (abort !== void 0)
       this.#requestAborts.set(request.requestId, abort);
@@ -226,6 +276,7 @@ class DatabaseRpcServer {
     } catch (error) {
       this.scope.postMessage(rpcFailure(request.requestId, error));
     } finally {
+      clearInterval(keepalive);
       if (abort !== void 0)
         this.#requestAborts.delete(request.requestId);
       if (!bypassLimit)
@@ -831,7 +882,9 @@ class DatabaseRpcServer {
       handle.idleTimer = void 0;
       if (!handle.open || handle.activeCalls !== 0 || this.#handles.get(handleId) !== handle)
         return;
-      void this.#settleWriteHandle(handleId, handle, false).catch(() => void 0);
+      void this.#settleWriteHandle(handleId, handle, false).catch((error) => {
+        this.#report("maintenance", error, "idle write handle rollback");
+      });
     }, this.#writeHandleIdleTimeoutMs);
     unrefTimer(handle.idleTimer);
   }
@@ -897,7 +950,8 @@ class DatabaseRpcServer {
           handleCleanup.push(handle.task.catch(() => void 0));
         } else if (handle.type === "live-set")
           this.#closeLiveSet(handleId, handle);
-      } catch {
+      } catch (error) {
+        this.#report("maintenance", error, "dispose handle");
       }
     }
     await Promise.allSettled(handleCleanup);
@@ -922,6 +976,7 @@ class DatabaseRpcServer {
 }
 function exposeDatabase(database, scope, options = {}) {
   const server = new DatabaseRpcServer(database, scope, options);
+  const report = workerErrorReporter(scope);
   scope.addEventListener("message", (event) => {
     let request;
     try {
@@ -930,15 +985,28 @@ function exposeDatabase(database, scope, options = {}) {
       const requestId = requestIdOf(event.data);
       if (requestId !== void 0)
         scope.postMessage(rpcFailure(requestId, error));
+      else
+        report("messageerror", error, "unreadable request frame");
       return;
     }
-    if (request !== null)
-      void server.handle(request);
+    if (request !== null) {
+      void server.handle(request).catch((error) => {
+        report("uncaught", error, `${request.kind} dispatch`);
+      });
+    }
   });
 }
 function attachWorkerHost(scope, createStore, options = {}) {
   let initialized;
   let initFailure;
+  const report = workerErrorReporter(scope);
+  const storeOptions = {
+    ...options,
+    onDiagnostic: (error, context) => {
+      report("coordination", error, context);
+      options.onDiagnostic?.(error, context);
+    }
+  };
   scope.addEventListener("message", (event) => {
     let request;
     try {
@@ -947,13 +1015,15 @@ function attachWorkerHost(scope, createStore, options = {}) {
       const requestId = requestIdOf(event.data);
       if (requestId !== void 0)
         scope.postMessage(rpcFailure(requestId, error));
+      else
+        report("messageerror", error, "unreadable request frame");
       return;
     }
     if (request === null)
       return;
     if (request.kind === "rpc-init" && initialized === void 0) {
       initFailure = void 0;
-      const attempt = createServer(scope, request.payload, createStore, options);
+      const attempt = createServer(scope, request.payload, createStore, storeOptions, report);
       initialized = attempt;
       attempt.catch((error) => {
         if (initialized === attempt) {
@@ -969,25 +1039,54 @@ function attachWorkerHost(scope, createStore, options = {}) {
       return;
     }
     void pending.then((server) => server.handle(request)).catch((error) => {
-      scope.postMessage(rpcFailure(request.requestId, error));
+      try {
+        scope.postMessage(rpcFailure(request.requestId, error));
+      } catch (postError) {
+        report("uncaught", postError, `${request.kind} failure frame`);
+      }
     });
   });
 }
-async function createServer(scope, payload, createStore, options) {
-  const store = await createStore(payload.store, options);
-  const database = new MinnowDatabase(store, payload.options ?? {});
+async function createServer(scope, payload, createStore, options, report) {
+  const opened = await createStore(payload.store, options);
+  const { store, kind } = isOpenedStore(opened) ? opened : { store: opened, kind: payload.store.kind === "auto" ? void 0 : payload.store.kind };
+  let database;
+  try {
+    database = new MinnowDatabase(store, {
+      ...payload.options ?? {},
+      onBackgroundError: (error, context) => report("maintenance", error, context)
+    });
+  } catch (error) {
+    try {
+      store.close();
+    } catch (closeError) {
+      report("maintenance", closeError, "store close after failed construction");
+    }
+    throw error;
+  }
   return new DatabaseRpcServer(database, scope, {
     ...payload.options?.transactionIdleTimeoutMs === void 0 ? {} : { writeHandleIdleTimeoutMs: payload.options.transactionIdleTimeoutMs },
     onDispose: () => store.close(),
     onVisibility: (visible) => {
       store.setForeground?.(visible);
-    }
+    },
+    ...kind === void 0 ? {} : { storeKind: kind },
+    ...payload.keepaliveIntervalMs === void 0 ? {} : { keepaliveIntervalMs: payload.keepaliveIntervalMs }
   });
 }
+function keepaliveInterval(value) {
+  if (typeof value !== "number" || !Number.isFinite(value))
+    return WORKER_KEEPALIVE_INTERVAL_MS;
+  return Math.min(WORKER_KEEPALIVE_INTERVAL_MS, Math.max(MIN_WORKER_KEEPALIVE_INTERVAL_MS, value));
+}
+function isOpenedStore(value) {
+  return typeof value.kind === "string" && typeof value.store === "object";
+}
 const storeKindLabels = {
   indexeddb: "IndexedDB",
   opfs: "OPFS",
-  memory: "memory"
+  memory: "memory",
+  auto: "OPFS-or-IndexedDB"
 };
 function singleStoreFactory(kind, open) {
   return (descriptor, options) => {
@@ -997,6 +1096,9 @@ function singleStoreFactory(kind, open) {
     return open(descriptor, options);
   };
 }
+function unsupportedStoreKindError(bundled, requested) {
+  return new Error(unsupportedStoreKindMessage(bundled, requested));
+}
 function unsupportedStoreKindMessage(bundled, requested) {
   const requestedLabel = Object.hasOwn(storeKindLabels, requested) ? storeKindLabels[requested] : void 0;
   const requestedEntry = requestedLabel === void 0 ? "" : ` or "@minnowdb/core/worker/${requested}" for the ${requestedLabel} store`;
@@ -1018,5 +1120,7 @@ export {
   MAX_WORKER_HANDLES_PER_CONNECTION,
   attachWorkerHost,
   exposeDatabase,
-  singleStoreFactory
+  singleStoreFactory,
+  unsupportedStoreKindError,
+  workerErrorReporter
 };

package/dist/engine/worker-store-auto.js

@@ -0,0 +1,36 @@
+import { IndexedDbBlockStore } from "../storage/indexeddb.js";
+import { OpfsBlockStore } from "../storage/opfs/index.js";
+import { openAutoStore } from "./auto-store.js";
+import { unsupportedStoreKindError } from "./worker-server.js";
+const autoWorkerStore = async (descriptor, options) => {
+  const diagnostic = options.onDiagnostic === void 0 ? {} : { onDiagnostic: options.onDiagnostic };
+  switch (descriptor.kind) {
+    case "opfs":
+      return OpfsBlockStore.open({
+        name: descriptor.name,
+        ...descriptor.durability === void 0 ? {} : { durability: descriptor.durability },
+        ...diagnostic
+      });
+    case "indexeddb":
+      return IndexedDbBlockStore.open({
+        name: descriptor.name,
+        ...descriptor.durability === void 0 ? {} : { durability: descriptor.durability },
+        ...descriptor.uniqueKeyCacheBytes === void 0 ? {} : { uniqueKeyCacheBytes: descriptor.uniqueKeyCacheBytes }
+      });
+    case "auto":
+      return openAutoStore(descriptor.name, (kind) => kind === "opfs" ? OpfsBlockStore.open({
+        name: descriptor.name,
+        ...descriptor.opfs?.durability === void 0 ? {} : { durability: descriptor.opfs.durability },
+        ...diagnostic
+      }) : IndexedDbBlockStore.open({
+        name: descriptor.name,
+        ...descriptor.indexeddb?.durability === void 0 ? {} : { durability: descriptor.indexeddb.durability },
+        ...descriptor.indexeddb?.uniqueKeyCacheBytes === void 0 ? {} : { uniqueKeyCacheBytes: descriptor.indexeddb.uniqueKeyCacheBytes }
+      }));
+    default:
+      throw unsupportedStoreKindError("auto", descriptor.kind);
+  }
+};
+export {
+  autoWorkerStore
+};

package/dist/engine/worker-store-opfs.js

@@ -1,8 +1,9 @@
 import { OpfsBlockStore } from "../storage/opfs/index.js";
 import { singleStoreFactory } from "./worker-server.js";
-const opfsWorkerStore = singleStoreFactory("opfs", (descriptor) => OpfsBlockStore.open({
+const opfsWorkerStore = singleStoreFactory("opfs", (descriptor, options) => OpfsBlockStore.open({
   name: descriptor.name,
-  ...descriptor.durability === void 0 ? {} : { durability: descriptor.durability }
+  ...descriptor.durability === void 0 ? {} : { durability: descriptor.durability },
+  ...options.onDiagnostic === void 0 ? {} : { onDiagnostic: options.onDiagnostic }
 }));
 export {
   opfsWorkerStore

package/dist/engine/write-coordinator.js

@@ -1,6 +1,7 @@
 const anonymous = /* @__PURE__ */ new WeakMap();
 const named = /* @__PURE__ */ new Map();
-async function coordinateWrite(store, run, signal) {
+const WRITE_ADMISSION_WAIT_MS = 1e4;
+async function coordinateWrite(store, run, signal, options = {}) {
   signal.throwIfAborted();
   const name = store.liveQueryChannelName;
   let queue = name === void 0 ? anonymous.get(store) : named.get(name);
@@ -19,9 +20,29 @@ async function coordinateWrite(store, run, signal) {
     admitted = true;
     return run();
   };
+  const admissionWaitMs = options.admissionWaitMs ?? WRITE_ADMISSION_WAIT_MS;
   const operation = queue.tail.then(async () => {
     signal.throwIfAborted();
-    return name !== void 0 && locks !== void 0 ? await locks.request(`minnowdb-write:${name}`, { signal: lockController.signal }, enter) : await enter();
+    if (name === void 0 || locks === void 0)
+      return enter();
+    const startedAt = Date.now();
+    const wait = { ranOut: false };
+    const waitTimer = setTimeout(() => {
+      wait.ranOut = true;
+      lockController.abort(new Error("Write admission wait ran out"));
+    }, admissionWaitMs);
+    waitTimer.unref?.();
+    try {
+      return await locks.request(`minnowdb-write:${name}`, { signal: lockController.signal }, enter);
+    } catch (error) {
+      if (!wait.ranOut || admitted)
+        throw error;
+      signal.throwIfAborted();
+      options.onAdmissionWaitExceeded?.(Date.now() - startedAt);
+      return await enter();
+    } finally {
+      clearTimeout(waitTimer);
+    }
   });
   const settled = operation.then(() => void 0, () => void 0);
   queue.tail = settled;
@@ -50,5 +71,6 @@ async function coordinateWrite(store, run, signal) {
   }
 }
 export {
+  WRITE_ADMISSION_WAIT_MS,
   coordinateWrite
 };