@minnowdb/core 0.10.0 → 0.10.1

package/dist/storage/indexeddb-audit-helpers.js

@@ -0,0 +1,269 @@
+import { IndexedDbBlockStore } from "./indexeddb.js";
+const NOW = "2026-09-12T12:00:00.000Z";
+async function openStore(indexedDB, name = crypto.randomUUID(), durability) {
+  return IndexedDbBlockStore.open({ name, indexedDB, ...durability ? { durability } : {} });
+}
+const EVENTS_TABLE = {
+  managed: false,
+  id: "events",
+  name: "events",
+  columns: [{ id: "value", name: "value", type: "number", nullable: false }],
+  revision: 0,
+  createdAt: NOW
+};
+function activeTransaction(id, snapshotVersion) {
+  return {
+    id,
+    ownerId: `owner-${id}`,
+    expiresAt: "2026-09-12T12:30:00.000Z",
+    snapshotVersion,
+    pendingBlockIds: [],
+    pendingSegmentIds: [],
+    status: "active",
+    revision: 0,
+    startedAt: NOW,
+    updatedAt: NOW,
+    committedVersion: null
+  };
+}
+function segment(id, transactionId, blockId, commitOrdinal = 0, rowIdStart = 1n) {
+  return {
+    id,
+    tableId: "events",
+    transactionId,
+    rowCount: 1,
+    rowIdStart,
+    rowIdEndExclusive: rowIdStart + 1n,
+    columnBlockIds: { value: [blockId] },
+    kind: "insert",
+    level: 0,
+    logicalOrder: 0,
+    commitOrdinal,
+    rowIdSpans: [],
+    createdAt: NOW
+  };
+}
+async function rawOpen(indexedDB, name) {
+  return new Promise((resolve, reject) => {
+    const request = indexedDB.open(name);
+    request.onsuccess = () => resolve(request.result);
+    request.onerror = () => reject(request.error ?? new Error("raw IndexedDB open failed"));
+  });
+}
+async function readRawValue(indexedDB, name, storeName, key) {
+  const database = await rawOpen(indexedDB, name);
+  try {
+    const transaction = database.transaction(storeName, "readonly");
+    const value = await new Promise((resolve, reject) => {
+      const request = transaction.objectStore(storeName).get(key);
+      request.onsuccess = () => resolve(request.result);
+      request.onerror = () => reject(request.error ?? new Error("raw IndexedDB read failed"));
+    });
+    await new Promise((resolve, reject) => {
+      transaction.oncomplete = () => resolve();
+      transaction.onabort = () => reject(transaction.error ?? new Error("raw read aborted"));
+    });
+    return value;
+  } finally {
+    database.close();
+  }
+}
+async function readRawKeys(indexedDB, name, storeName) {
+  const database = await rawOpen(indexedDB, name);
+  try {
+    const transaction = database.transaction(storeName, "readonly");
+    const keys = await new Promise((resolve, reject) => {
+      const request = transaction.objectStore(storeName).getAllKeys();
+      request.onsuccess = () => resolve(request.result);
+      request.onerror = () => reject(request.error ?? new Error("raw IndexedDB read failed"));
+    });
+    await new Promise((resolve, reject) => {
+      transaction.oncomplete = () => resolve();
+      transaction.onabort = () => reject(transaction.error ?? new Error("raw read aborted"));
+    });
+    return keys;
+  } finally {
+    database.close();
+  }
+}
+function instrumentFactory(indexedDB) {
+  const state = {
+    factory: indexedDB,
+    transactions: [],
+    requestCounts: /* @__PURE__ */ new Map(),
+    setHook(hook) {
+      currentHook = hook;
+    },
+    reset() {
+      state.transactions.length = 0;
+      state.requestCounts.clear();
+    }
+  };
+  let currentHook;
+  const wrappedScanners = /* @__PURE__ */ new WeakSet();
+  const countScans = (target, label) => {
+    if (wrappedScanners.has(target))
+      return;
+    wrappedScanners.add(target);
+    for (const method of [
+      "openCursor",
+      "openKeyCursor",
+      "getAll",
+      "getAllKeys",
+      "count"
+    ]) {
+      const original = target[method].bind(target);
+      Object.defineProperty(target, method, {
+        configurable: true,
+        value: (...args) => {
+          const key = `${label}:${method}`;
+          state.requestCounts.set(key, (state.requestCounts.get(key) ?? 0) + 1);
+          const request = original(...args);
+          if (method === "openCursor" || method === "openKeyCursor") {
+            request.addEventListener("success", () => {
+              const stepKey = `${label}:cursor-steps`;
+              if (request.result !== null && request.result !== void 0) {
+                state.requestCounts.set(stepKey, (state.requestCounts.get(stepKey) ?? 0) + 1);
+              }
+            });
+          }
+          return request;
+        }
+      });
+    }
+  };
+  const wrappedStores = /* @__PURE__ */ new WeakSet();
+  const originalOpen = indexedDB.open.bind(indexedDB);
+  Object.defineProperty(indexedDB, "open", {
+    configurable: true,
+    value: (name, version) => {
+      const request = version === void 0 ? originalOpen(name) : originalOpen(name, version);
+      request.addEventListener("success", () => {
+        const database = request.result;
+        const originalTransaction = database.transaction.bind(database);
+        Object.defineProperty(database, "transaction", {
+          configurable: true,
+          value: (stores, mode, options) => {
+            const transaction = originalTransaction(stores, mode, options);
+            const entry = {
+              transaction,
+              stores: typeof stores === "string" ? [stores] : [...stores],
+              mode: mode ?? "readonly",
+              options,
+              completed: false,
+              aborted: false
+            };
+            transaction.addEventListener("complete", () => {
+              entry.completed = true;
+            });
+            transaction.addEventListener("abort", () => {
+              entry.aborted = true;
+            });
+            state.transactions.push(entry);
+            const originalObjectStore = transaction.objectStore.bind(transaction);
+            Object.defineProperty(transaction, "objectStore", {
+              configurable: true,
+              value: (storeName) => {
+                const store = originalObjectStore(storeName);
+                if (wrappedStores.has(store))
+                  return store;
+                wrappedStores.add(store);
+                countScans(store, storeName);
+                const originalIndex = store.index.bind(store);
+                Object.defineProperty(store, "index", {
+                  configurable: true,
+                  value: (indexName) => {
+                    const index = originalIndex(indexName);
+                    countScans(index, `${storeName}.${indexName}`);
+                    return index;
+                  }
+                });
+                for (const method of ["put", "add", "delete", "get", "getKey"]) {
+                  const original = store[method].bind(store);
+                  Object.defineProperty(store, method, {
+                    configurable: true,
+                    value: (...args) => {
+                      state.requestCounts.set(storeName, (state.requestCounts.get(storeName) ?? 0) + 1);
+                      const [first, second] = args;
+                      const isWrite = method === "put" || method === "add";
+                      const decision = currentHook?.({
+                        transaction,
+                        storeName,
+                        method,
+                        key: isWrite ? second : first,
+                        value: isWrite ? first : void 0
+                      });
+                      if (decision === "throw-quota") {
+                        const failing = original(...args);
+                        const queue = transaction._requests;
+                        const entry2 = queue.find((candidate) => candidate.request === failing);
+                        if (entry2 === void 0)
+                          throw new Error("request not queued");
+                        entry2.operation = () => {
+                          throw new DOMException("The quota has been exceeded.", "QuotaExceededError");
+                        };
+                        return failing;
+                      }
+                      const result = original(...args);
+                      if (decision === "abort") {
+                        try {
+                          transaction.abort();
+                        } catch {
+                        }
+                      }
+                      return result;
+                    }
+                  });
+                }
+                return store;
+              }
+            });
+            return transaction;
+          }
+        });
+      });
+      return request;
+    }
+  });
+  return state;
+}
+async function stageBlocks(store, record, ids) {
+  let current = record;
+  for (let start = 0; start < ids.length; start += 64) {
+    const slice = ids.slice(start, start + 64);
+    current = await store.stageTransactionArtifacts({
+      transactionId: record.id,
+      expectedRevision: current.revision,
+      blocks: slice.map((id) => ({ id, bytes: Uint8Array.of(1) })),
+      segments: [],
+      updatedAt: NOW
+    });
+  }
+  return current;
+}
+async function stageSegments(store, record, ids, blockId) {
+  let current = record;
+  for (let start = 0; start < ids.length; start += 64) {
+    const slice = ids.slice(start, start + 64);
+    current = await store.stageTransactionArtifacts({
+      transactionId: record.id,
+      expectedRevision: current.revision,
+      blocks: [],
+      segments: slice.map((id, offset) => segment(id, record.id, blockId, current.pendingSegmentIds.length + offset, BigInt(current.pendingSegmentIds.length + offset + 1))),
+      updatedAt: NOW
+    });
+  }
+  return current;
+}
+export {
+  EVENTS_TABLE,
+  NOW,
+  activeTransaction,
+  instrumentFactory,
+  openStore,
+  readRawKeys,
+  readRawValue,
+  segment,
+  stageBlocks,
+  stageSegments
+};