@minnowdb/core 0.10.0 → 0.10.2

package/dist/engine/live-maintenance.js

@@ -0,0 +1,220 @@
+import { dateMilliseconds } from "../date-value.js";
+import { estimateValuesBytes } from "./byte-estimates.js";
+import { planMemoKey, sameQueryRow as sameLiveRow } from "./query-cache.js";
+import { externalizeQueryResult } from "./query.js";
+import { compareSqlValues } from "./sql-semantics.js";
+const LIVE_HIDDEN_PREFIX = "__minnow_live_";
+const LIVE_KEY_ALIAS = `${LIVE_HIDDEN_PREFIX}key`;
+const LIVE_ORDER_ALIAS = `${LIVE_HIDDEN_PREFIX}order_`;
+const LIVE_MAINTENANCE_MAX_DELTA_ROWS = 2048;
+const LIVE_WINDOW_MARGIN_MIN = 16;
+const LIVE_WINDOW_MARGIN_MAX = 64;
+function liveKeyToken(value) {
+  if (typeof value === "number")
+    return `n:${String(value)}`;
+  if (typeof value === "string")
+    return `s:${value}`;
+  if (typeof value === "boolean")
+    return value ? "b:1" : "b:0";
+  if (value instanceof Date)
+    return `d:${String(dateMilliseconds(value))}`;
+  return "z";
+}
+function splitLiveHiddenColumns(executed, state) {
+  const publicCount = state.publicColumns.length;
+  const hidden = executed.columns.slice(publicCount);
+  const count = executed.rows.length;
+  const keys = new Array(count);
+  const order = state.orderTerms.map(() => new Array(count));
+  for (let index = 0; index < count; index += 1) {
+    const row = executed.rows[index] ?? {};
+    keys[index] = liveKeyToken(row[LIVE_KEY_ALIAS] ?? null);
+    for (const [term, { alias }] of state.orderTerms.entries()) {
+      const values = order[term];
+      if (values !== void 0)
+        values[index] = row[alias] ?? null;
+    }
+    for (const column of hidden)
+      Reflect.deleteProperty(row, column);
+  }
+  return {
+    result: externalizeQueryResult({
+      columns: executed.columns.slice(0, publicCount),
+      columnDomains: executed.columnDomains.slice(0, publicCount),
+      rows: executed.rows
+    }),
+    keys,
+    order
+  };
+}
+function liveMaintainedOutcome(state, previous, previousIndex) {
+  const positions = /* @__PURE__ */ new Map();
+  let retainedBytes = state.retainedBytes ?? 128 + planMemoKey(state.fullPlan).length * 2 + planMemoKey(state.deltaPlan).length * 2;
+  for (const [index, key] of state.keys.entries()) {
+    if (positions.has(key))
+      throw new TypeError("Duplicate live input key");
+    positions.set(key, index);
+    if (state.retainedBytes === void 0)
+      retainedBytes += liveRowStateBytes(state, index);
+  }
+  state = { ...state, positions, retainedBytes };
+  const visibleCount = state.limit === void 0 ? state.rows.length : Math.min(state.rows.length, state.limit);
+  const visible = state.rows.slice(0, visibleCount);
+  if (previous === void 0) {
+    return {
+      result: {
+        columns: [...state.publicColumns],
+        columnDomains: [...state.columnDomains],
+        rows: visible
+      },
+      state,
+      retainedBytes,
+      changed: true
+    };
+  }
+  const previousCount = previous.rows.length;
+  const retained = new Int32Array(visibleCount);
+  let same = visibleCount === previousCount;
+  for (let index = 0; index < visibleCount; index += 1) {
+    const was = previousIndex?.[index] ?? -1;
+    if (was >= 0 && was < previousCount) {
+      retained[index] = was;
+      if (was !== index)
+        same = false;
+      continue;
+    }
+    retained[index] = -1;
+    const before = previous.rows[index];
+    const now = visible[index];
+    if (before !== void 0 && now !== void 0 && sameLiveRow(before, now, previous.columns)) {
+      visible[index] = before;
+      retained[index] = index;
+    } else
+      same = false;
+  }
+  if (same)
+    return { result: previous, state, retainedBytes, changed: false };
+  return {
+    result: {
+      columns: [...state.publicColumns],
+      columnDomains: [...state.columnDomains],
+      rows: visible
+    },
+    state,
+    retainedBytes,
+    changed: true,
+    retained
+  };
+}
+function liveRowStateBytes(state, index) {
+  let bytes = 112 + (state.keys[index]?.length ?? 0) * 2 + estimateValuesBytes(Object.values(state.rows[index] ?? {})) * 2;
+  for (const values of state.order)
+    bytes += 8 + estimateValuesBytes([values[index]]) * 2;
+  return bytes;
+}
+function filterLiveRows(state, keep) {
+  const rows = [];
+  const keys = [];
+  const order = state.order.map(() => new Array());
+  const previous = [];
+  for (let index = 0; index < state.rows.length; index += 1) {
+    const row = state.rows[index];
+    if (row === void 0 || !keep(index))
+      continue;
+    rows.push(row);
+    keys.push(state.keys[index] ?? "z");
+    for (const [term, values] of state.order.entries()) {
+      order[term]?.push(values[index] ?? null);
+    }
+    previous.push(index);
+  }
+  return { rows, keys, order, previousIndex: Int32Array.from(previous) };
+}
+function trimLiveRows(rows, count) {
+  return {
+    rows: rows.rows.slice(0, count),
+    keys: rows.keys.slice(0, count),
+    order: rows.order.map((values) => values.slice(0, count)),
+    previousIndex: rows.previousIndex.slice(0, count)
+  };
+}
+function liveOrderComparator(terms) {
+  return (leftOrder, leftIndex, rightOrder, rightIndex) => {
+    for (const [term, { descending, nulls }] of terms.entries()) {
+      const a = leftOrder[term]?.[leftIndex] ?? null;
+      const b = rightOrder[term]?.[rightIndex] ?? null;
+      if (a === null || b === null) {
+        if (a === null && b === null)
+          continue;
+        const nullsFirst = nulls === "first" || nulls === void 0 && descending;
+        return a === null ? nullsFirst ? -1 : 1 : nullsFirst ? 1 : -1;
+      }
+      let comparison = compareSqlValues(a, b);
+      if (descending)
+        comparison = -comparison;
+      if (comparison !== 0)
+        return comparison;
+    }
+    return 0;
+  };
+}
+function mergeLiveRows(kept, added, compare, ordered) {
+  if (added.rows.length === 0)
+    return kept;
+  const terms = kept.order.length;
+  const total = kept.rows.length + added.rows.length;
+  const rows = new Array(total);
+  const keys = new Array(total);
+  const order = Array.from({ length: terms }, () => new Array(total));
+  const previousIndex = new Int32Array(total);
+  const take = (source, from, to) => {
+    rows[to] = source.rows[from] ?? {};
+    keys[to] = source.keys[from] ?? "z";
+    for (let term = 0; term < terms; term += 1) {
+      const values = order[term];
+      if (values !== void 0)
+        values[to] = source.order[term]?.[from] ?? null;
+    }
+    previousIndex[to] = source.previousIndex[from] ?? -1;
+  };
+  if (!ordered) {
+    for (let index = 0; index < kept.rows.length; index += 1)
+      take(kept, index, index);
+    for (let index = 0; index < added.rows.length; index += 1) {
+      take(added, index, kept.rows.length + index);
+    }
+    return { rows, keys, order, previousIndex };
+  }
+  const addedIndexes = added.rows.map((_, index) => index);
+  addedIndexes.sort((left, right) => compare(added.order, left, added.order, right));
+  let keptIndex = 0;
+  let addedPosition = 0;
+  for (let to = 0; to < total; to += 1) {
+    const addedIndex = addedIndexes[addedPosition];
+    const takeAdded = addedIndex !== void 0 && (keptIndex >= kept.rows.length || compare(added.order, addedIndex, kept.order, keptIndex) < 0);
+    if (takeAdded) {
+      take(added, addedIndex, to);
+      addedPosition += 1;
+    } else {
+      take(kept, keptIndex, to);
+      keptIndex += 1;
+    }
+  }
+  return { rows, keys, order, previousIndex };
+}
+export {
+  LIVE_HIDDEN_PREFIX,
+  LIVE_KEY_ALIAS,
+  LIVE_MAINTENANCE_MAX_DELTA_ROWS,
+  LIVE_ORDER_ALIAS,
+  LIVE_WINDOW_MARGIN_MAX,
+  LIVE_WINDOW_MARGIN_MIN,
+  filterLiveRows,
+  liveKeyToken,
+  liveMaintainedOutcome,
+  liveOrderComparator,
+  liveRowStateBytes,
+  mergeLiveRows,
+  splitLiveHiddenColumns,
+  trimLiveRows
+};

package/dist/engine/schema.js

@@ -1,4 +1,5 @@
 import { copyDate, dateMilliseconds } from "../date-value.js";
+import { quoteSqlIdentifier } from "./sql-quote.js";
 import { validateColumnDefault, validateEnumValues, validateSqlDomain } from "../storage/types.js";
 import { childExpressions, compileCheckExpression, expressionColumns, hasAggregate, validateDefaultExpression } from "./query.js";
 import { externalSqlDomainValue, normalizeSqlDomainValue } from "./sql-domains.js";
@@ -927,7 +928,7 @@ function planMigration(catalog, definition, options = {}) {
 }
 function typedTable(database, definition) {
   const columnNames = Object.keys(definition.columns);
-  const quote = (name) => `"${name.replaceAll('"', '""')}"`;
+  const quote = quoteSqlIdentifier;
   const scalarUniqueKey = Object.entries(definition.columns).find(([, columnDefinition]) => columnDefinition.isUnique)?.[0];
   const keyColumns = definition.primaryKey.length > 0 ? [...definition.primaryKey] : scalarUniqueKey === void 0 ? [] : [scalarUniqueKey];
   const normalizedRows = (rows) => {

package/dist/engine/sql-functions.js

@@ -1,3 +1,4 @@
+import { quoteSqlIdentifier } from "./sql-quote.js";
 import { dateIsoString, dateMilliseconds, dateUtcDate, dateUtcDay, dateUtcFullYear, dateUtcHours, dateUtcMinutes, dateUtcMonth, dateUtcSeconds } from "../date-value.js";
 import { MAX_SQL_SCALAR_RESULT_CHARACTERS } from "./cache-limits.js";
 import { dateDomainValue, exactNumericRounded, exactNumericUnary, externalSqlDomainValue, intervalDomainValue, isDateDomainValue, isExactNumeric, protectedSqlTextValue } from "./sql-domains.js";
@@ -467,7 +468,7 @@ function formatText(template, values) {
       if (value === null || value === void 0)
         throw new TypeError("FORMAT %I does not accept NULL");
       const name = rendered(value);
-      return /^[a-z_][a-z0-9_]*$/.test(name) ? name : `"${name.replace(/"/g, '""')}"`;
+      return /^[a-z_][a-z0-9_]*$/.test(name) ? name : quoteSqlIdentifier(name);
     }
     if (value === null || value === void 0)
       return "NULL";
@@ -902,7 +903,7 @@ const simpleScalarFunctions = /* @__PURE__ */ new Map([
       returns: "string",
       evaluate: (values) => {
         const name = text("QUOTE_IDENT", values[0]);
-        return /^[a-z_][a-z0-9_]*$/.test(name) ? name : bounded(`"${name.replace(/"/g, '""')}"`, "QUOTE_IDENT");
+        return /^[a-z_][a-z0-9_]*$/.test(name) ? name : bounded(quoteSqlIdentifier(name), "QUOTE_IDENT");
       }
     }
   ],

package/dist/engine/sql-quote.js

@@ -0,0 +1,6 @@
+function quoteSqlIdentifier(identifier) {
+  return `"${identifier.replaceAll('"', '""')}"`;
+}
+export {
+  quoteSqlIdentifier
+};

package/dist/engine/vector.js

@@ -1308,7 +1308,6 @@ async function executeBoundPlanAsync(plan, memory, options) {
   const rows = plan.grouped ? finishGroups(plan, groups.values(), memory) : output.finish();
   return finishResult(plan, rows, memory);
 }
-const SELECTED_ROW_COALESCE_GAP = 32;
 async function scanSelectedRows(plan, selection, groups, output, memory, options) {
   const scanRows = plan.sourceTables[plan.scanSource]?.rowCount ?? 0;
   let index = 0;
@@ -1329,9 +1328,8 @@ async function scanSelectedRows(plan, selection, groups, output, memory, options
       index += 1;
       while (index < selection.length) {
         const next = selection[index] ?? 0;
-        if (next >= windowEnd || next - end > SELECTED_ROW_COALESCE_GAP || next >= begin + DEFAULT_BATCH_ROWS) {
+        if (next !== end || next >= windowEnd || next >= begin + DEFAULT_BATCH_ROWS)
           break;
-        }
         end = next + 1;
         index += 1;
       }

package/dist/engine/worker-host.js

@@ -14,6 +14,8 @@ async function createStore(descriptor, options) {
         ...descriptor.opfs?.durability === void 0 ? {} : { durability: descriptor.opfs.durability }
       } : { kind, name: descriptor.name, ...descriptor.indexeddb }, options);
       return opened;
+    }, {
+      opfsDatabaseExists: async (name) => (await import("../storage/opfs/index.js")).opfsDatabaseExists({ name })
     });
   }
   if (descriptor.kind === "memory") {

package/dist/engine/worker-server.js

@@ -538,7 +538,7 @@ class DatabaseRpcServer {
     if (handle === void 0)
       throw new Error(`Unknown handle: ${handleId}`);
     if (handle.type === "write") {
-      this.#beginWriteHandleCall(handle);
+      await this.#beginWriteHandleCall(handle);
       try {
         return await this.#callWriteHandle(handleId, handle, method, args, context);
       } finally {
@@ -847,12 +847,11 @@ class DatabaseRpcServer {
   #releaseHandleId(id) {
     this.#reservedHandleIds.delete(id);
   }
-  #beginWriteHandleCall(handle) {
+  async #beginWriteHandleCall(handle) {
+    while (handle.activeCalls !== 0)
+      await handle.activeCallDone;
     if (!handle.open)
       throw new Error("Write handle is closed");
-    if (handle.activeCalls !== 0) {
-      throw new Error("Write handle already has a call in flight");
-    }
     handle.activeCalls = 1;
     handle.activeCallDone = new Promise((resolve) => {
       handle.finishActiveCall = resolve;

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

@@ -1,5 +1,5 @@
 import { IndexedDbBlockStore } from "../storage/indexeddb.js";
-import { OpfsBlockStore } from "../storage/opfs/index.js";
+import { OpfsBlockStore, opfsDatabaseExists } from "../storage/opfs/index.js";
 import { openAutoStore } from "./auto-store.js";
 import { unsupportedStoreKindError } from "./worker-server.js";
 const autoWorkerStore = async (descriptor, options) => {
@@ -26,7 +26,7 @@ const autoWorkerStore = async (descriptor, options) => {
         name: descriptor.name,
         ...descriptor.indexeddb?.durability === void 0 ? {} : { durability: descriptor.indexeddb.durability },
         ...descriptor.indexeddb?.uniqueKeyCacheBytes === void 0 ? {} : { uniqueKeyCacheBytes: descriptor.indexeddb.uniqueKeyCacheBytes }
-      }));
+      }), { opfsDatabaseExists: (name) => opfsDatabaseExists({ name }) });
     default:
       throw unsupportedStoreKindError("auto", descriptor.kind);
   }

package/dist/engine/write-coordinator.js

@@ -1,6 +1,11 @@
 const anonymous = /* @__PURE__ */ new WeakMap();
 const named = /* @__PURE__ */ new Map();
+const bypassing = /* @__PURE__ */ new Set();
+const NOT_GRANTED = /* @__PURE__ */ Symbol("write admission lock not granted");
 const WRITE_ADMISSION_WAIT_MS = 1e4;
+function _resetWriteAdmissionForTests() {
+  bypassing.clear();
+}
 async function coordinateWrite(store, run, signal, options = {}) {
   signal.throwIfAborted();
   const name = store.liveQueryChannelName;
@@ -25,6 +30,19 @@ async function coordinateWrite(store, run, signal, options = {}) {
     signal.throwIfAborted();
     if (name === void 0 || locks === void 0)
       return enter();
+    const lockName = `minnowdb-write:${name}`;
+    if (bypassing.has(name)) {
+      const result = await locks.request(lockName, { ifAvailable: true }, async (lock) => {
+        if (lock === null)
+          return NOT_GRANTED;
+        bypassing.delete(name);
+        return enter();
+      });
+      if (result !== NOT_GRANTED)
+        return result;
+      signal.throwIfAborted();
+      return await enter();
+    }
     const startedAt = Date.now();
     const wait = { ranOut: false };
     const waitTimer = setTimeout(() => {
@@ -33,11 +51,12 @@ async function coordinateWrite(store, run, signal, options = {}) {
     }, admissionWaitMs);
     waitTimer.unref?.();
     try {
-      return await locks.request(`minnowdb-write:${name}`, { signal: lockController.signal }, enter);
+      return await locks.request(lockName, { signal: lockController.signal }, enter);
     } catch (error) {
       if (!wait.ranOut || admitted)
         throw error;
       signal.throwIfAborted();
+      bypassing.add(name);
       options.onAdmissionWaitExceeded?.(Date.now() - startedAt);
       return await enter();
     } finally {
@@ -72,5 +91,6 @@ async function coordinateWrite(store, run, signal, options = {}) {
 }
 export {
   WRITE_ADMISSION_WAIT_MS,
+  _resetWriteAdmissionForTests,
   coordinateWrite
 };

package/dist/storage/indexeddb.d.ts

@@ -9,6 +9,12 @@ export interface IndexedDbBlockStoreOptions {
      * 8 MiB so a table's row count cannot silently become an unbounded resident-memory cost.
      */
     uniqueKeyCacheBytes?: number;
+    /**
+     * How long the connection may answer nothing at all, while it has work outstanding, before
+     * every waiting call fails with `StorageUnresponsiveError` and the store refuses new work.
+     * Defaults to `INDEXEDDB_UNRESPONSIVE_AFTER_MS`.
+     */
+    unresponsiveAfterMs?: number;
 }
 export declare class IndexedDbBlockStore implements BlockStore {
     #private;
@@ -189,3 +195,15 @@ export declare class IndexedDbBlockStore implements BlockStore {
         snapshotPeakRetainedBytes: number;
     };
 }
+/**
+ * How long a connection may go without a single IndexedDB event, while it has work outstanding,
+ * before the adapter calls it unresponsive. Nothing in IndexedDB can be cancelled and nothing
+ * reports progress, so this is the only way for a store to tell a wedged browser from a busy
+ * one: any event anywhere on the connection resets the deadline, which means a transaction
+ * queued behind a genuinely long one is never mistaken for a wedge — only total silence is.
+ *
+ * See `StorageUnresponsiveError` for the wedge this bounds. Thirty seconds is far longer than
+ * any single request takes and comfortably inside the worker client's own request deadline, so
+ * the typed error is what a caller sees rather than a lost worker.
+ */
+export declare const INDEXEDDB_UNRESPONSIVE_AFTER_MS = 30000;