@minnowdb/core 0.7.2 → 0.7.7

package/dist/storage/memory.js

@@ -3,6 +3,27 @@ import { verifyStoredBlock } from "../block-format/index.js";
 import { crc32 } from "../block-format/checksum.js";
 import { decodeSnapshotMetadataItems, encodeSnapshotFrameStreamFooter, encodeSnapshotFrameStreamHeader, encodeSnapshotMetadataPage, extendSnapshotFrameStreamChecksum, prepareSnapshotFrameStreamHeader, snapshotFrameEnvelopeParts, snapshotFrameStreamHeaderIdentity } from "./snapshot-stream.js";
 import { RecordCore, validateFtsPostingChunks, validateId, validateTempRunPage, validateTempRunPageIdentity } from "./toolkit/record-core.js";
+const commitTurn = (() => {
+  const immediate = globalThis.setImmediate;
+  if (immediate !== void 0 && !Reflect.has(immediate, "clock")) {
+    return () => new Promise((resolve) => {
+      immediate(resolve);
+    });
+  }
+  if (typeof MessageChannel === "undefined") {
+    return () => new Promise((resolve) => setTimeout(resolve, 0));
+  }
+  let channel;
+  const waiting = [];
+  return () => new Promise((resolve) => {
+    if (channel === void 0) {
+      channel = new MessageChannel();
+      channel.port1.onmessage = () => waiting.shift()?.();
+    }
+    waiting.push(resolve);
+    channel.port2.postMessage(void 0);
+  });
+})();
 class MemoryBlockStore {
   #blocks = /* @__PURE__ */ new Map();
   #blockChecksums = /* @__PURE__ */ new Map();
@@ -549,15 +570,19 @@ class MemoryBlockStore {
     });
   }
   async commitTransaction(input) {
-    return this.#runAtomic(() => this.#core.commitTransaction(input));
+    const summary = await this.#runAtomic(() => this.#core.commitTransaction(input));
+    await commitTurn();
+    return summary;
   }
   async writeTransaction(input) {
-    return this.#runAtomic(() => {
-      const summary = this.#core.writeTransaction(input);
+    const summary = await this.#runAtomic(() => {
+      const summary2 = this.#core.writeTransaction(input);
       for (const block of input.blocks)
         this.#putBlock(block.id, block.bytes);
-      return summary;
+      return summary2;
     });
+    await commitTurn();
+    return summary;
   }
   async createLease(record) {
     return this.#runAtomic(() => {

package/dist/storage/toolkit/record-core.js

@@ -3567,7 +3567,12 @@ class RecordCore {
       throw new GarbageCollectionJobConflictError(input.jobId, input.expectedRevision, current?.revision ?? null);
     }
     const updated = updateGarbageCollectionPlanningRecord(current, input);
-    assertGarbageCollectionCandidateProvenance(updated, this.#manifests, this.#manifestBlocks, this.#segments, this.#transactions, this.#roots);
+    assertGarbageCollectionCandidateProvenance({
+      candidateManifestVersions: input.candidateManifestVersions ?? [],
+      candidateSegmentIds: input.candidateSegmentIds ?? [],
+      candidateBlockIds: input.candidateBlockIds ?? [],
+      candidateTransactionIds: input.candidateTransactionIds ?? []
+    }, this.#manifests, this.#manifestBlocks, this.#segments, this.#transactions, this.#roots);
     this.#garbageCollectionJobs.set(updated.id, updated);
     return cloneRecord(updated);
   }
@@ -5661,23 +5666,23 @@ function assertPendingArtifactsAvailable(transaction, physical, segments, valida
     }
   }
 }
-function assertGarbageCollectionCandidateProvenance(job, manifests, manifestBlocks, segments, transactions, roots) {
-  for (const version of job.candidateManifestVersions) {
+function assertGarbageCollectionCandidateProvenance(candidates, manifests, manifestBlocks, segments, transactions, roots) {
+  for (const version of candidates.candidateManifestVersions) {
     if (!manifests.has(version)) {
       throw new Error(`Garbage collection candidate manifest is missing: ${String(version)}`);
     }
   }
-  for (const id of job.candidateTransactionIds) {
+  for (const id of candidates.candidateTransactionIds) {
     const transaction = transactions.get(id);
     if (transaction === void 0 || transaction.status !== "aborted" && (transaction.status !== "committed" || transaction.committedVersion === null)) {
       throw new Error(`Garbage collection transaction candidate is not terminal: ${id}`);
     }
   }
-  const unprovenBlockId = job.candidateBlockIds.find((id) => !manifestBlocks.has(id) && roots.abortedTransactionBlockCount(id) === 0 && roots.terminalJobBlockCount(id) === 0);
+  const unprovenBlockId = candidates.candidateBlockIds.find((id) => !manifestBlocks.has(id) && roots.abortedTransactionBlockCount(id) === 0 && roots.terminalJobBlockCount(id) === 0);
   if (unprovenBlockId !== void 0) {
     throw new Error(`Garbage collection block candidate has no persisted provenance: ${unprovenBlockId}`);
   }
-  const unprovenSegmentId = job.candidateSegmentIds.find((id) => {
+  const unprovenSegmentId = candidates.candidateSegmentIds.find((id) => {
     return !segments.has(id);
   });
   if (unprovenSegmentId !== void 0) {

package/dist/storage/types.d.ts

@@ -815,6 +815,17 @@ export interface UpdateGarbageCollectionPlanningInput {
     discovery: GarbageCollectionDiscovery;
     updatedAt: string;
 }
+/**
+ * One page's (or one job's full) proposed garbage-collection candidates, checked for persisted
+ * provenance before being accepted. Shared by every adapter's provenance assertion so a candidate
+ * kind added to one cannot be forgotten in another.
+ */
+export interface GarbageCollectionCandidateSet {
+    readonly candidateManifestVersions: readonly number[];
+    readonly candidateSegmentIds: readonly string[];
+    readonly candidateBlockIds: readonly string[];
+    readonly candidateTransactionIds: readonly string[];
+}
 export interface GarbageCollectionJobRecord {
     id: string;
     candidateManifestVersions: number[];

package/dist/testing/sqllogictest.js

@@ -166,7 +166,9 @@ function parseExpected(lines, file, line) {
   return { kind: "hash", valueCount, hash: (match[2] ?? "").toLowerCase() };
 }
 function tokenizeDirective(line) {
-  return line.trim().split(/\s+/u);
+  const hash = line.indexOf("#");
+  const directive = hash === -1 ? line : line.slice(0, hash);
+  return directive.trim().split(/\s+/u);
 }
 function sqlLines(lines) {
   return lines.map((line) => line.text).join("\n");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@minnowdb/core",
-  "version": "0.7.2",
+  "version": "0.7.7",
   "description": "A columnar SQL database for the browser: PostgreSQL-style SQL over durable IndexedDB or OPFS data, with no server or WebAssembly module.",
   "license": "MIT",
   "author": "Eric Wilhite",

package/postgres-feature-profile.json

@@ -31,7 +31,7 @@
     {
       "id": "expression.arithmetic",
       "classification": "different",
-      "reason": "Minnow has one JavaScript number type: integer-looking division stays fractional, and division by zero returns NULL instead of raising PostgreSQL's error."
+      "reason": "Division by zero returns NULL instead of raising PostgreSQL's error. Integer division itself follows PostgreSQL: two integer operands truncate toward zero."
     },
     {
       "id": "expression.round",
@@ -43,6 +43,11 @@
       "classification": "extension",
       "reason": "PostgreSQL uses $n parameters. Minnow also accepts ? as adapter-friendly shorthand."
     },
+    {
+      "id": "mutation.truncate",
+      "classification": "different",
+      "reason": "TRUNCATE reports the number of rows it removed, where PostgreSQL's command tag carries no count. The resulting table state is identical."
+    },
     {
       "id": "mutation.upsert-replace",
       "classification": "extension",
@@ -91,7 +96,7 @@
     {
       "id": "expression.modulo",
       "classification": "different",
-      "reason": "Minnow permits % on its number type; PostgreSQL has no % operator for double precision."
+      "reason": "Minnow permits % on double precision values; PostgreSQL has no % operator for double precision."
     },
     {
       "id": "expression.date-trunc",
@@ -101,7 +106,7 @@
     {
       "id": "function.numeric-core",
       "classification": "different",
-      "reason": "Minnow's one number type accepts combinations that PostgreSQL's distinct integer, numeric, and double-precision overloads do not."
+      "reason": "Minnow's numeric functions accept integer, exact, and double-precision arguments interchangeably, where PostgreSQL's distinct integer, numeric, and double-precision overloads do not."
     },
     {
       "id": "function.string-extended",
@@ -247,7 +252,7 @@
     {
       "id": "transaction.isolation-level",
       "classification": "inapplicable",
-      "reason": "Minnow exposes one snapshot transaction model, so there is no session isolation level to configure."
+      "reason": "Every transaction reads one snapshot and commits atomically, which satisfies READ UNCOMMITTED, READ COMMITTED, and REPEATABLE READ, so those levels are accepted and ignored. SERIALIZABLE promises more than one snapshot can, and is refused rather than silently downgraded."
     },
     {
       "id": "privileges.grant",