@minnowdb/core 0.7.0 → 0.7.1

package/dist/engine/worker-store-indexeddb.d.ts

@@ -0,0 +1,2 @@
+import { type WorkerStoreFactory } from "./worker-server.js";
+export declare const indexedDbWorkerStore: WorkerStoreFactory;

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

@@ -0,0 +1,11 @@
+import { IndexedDbBlockStore } from "../storage/indexeddb.js";
+import { singleStoreFactory } from "./worker-server.js";
+const indexedDbWorkerStore = singleStoreFactory("indexeddb", (descriptor, options) => IndexedDbBlockStore.open({
+  name: descriptor.name,
+  ...descriptor.durability === void 0 ? {} : { durability: descriptor.durability },
+  ...descriptor.uniqueKeyCacheBytes === void 0 ? {} : { uniqueKeyCacheBytes: descriptor.uniqueKeyCacheBytes },
+  ...options.indexedDB === void 0 ? {} : { indexedDB: options.indexedDB }
+}));
+export {
+  indexedDbWorkerStore
+};

package/dist/engine/worker-store-memory.d.ts

@@ -0,0 +1,2 @@
+import { type WorkerStoreFactory } from "./worker-server.js";
+export declare const memoryWorkerStore: WorkerStoreFactory;

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

@@ -0,0 +1,6 @@
+import { MemoryBlockStore } from "../storage/memory.js";
+import { singleStoreFactory } from "./worker-server.js";
+const memoryWorkerStore = singleStoreFactory("memory", () => new MemoryBlockStore());
+export {
+  memoryWorkerStore
+};

package/dist/engine/worker-store-opfs.d.ts

@@ -0,0 +1,2 @@
+import { type WorkerStoreFactory } from "./worker-server.js";
+export declare const opfsWorkerStore: WorkerStoreFactory;

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

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

package/dist/engine/worker.js

@@ -1,14 +1,2 @@
-/// <reference lib="webworker" />
-/**
- * Ready-made dedicated-worker entry, published as `@minnowdb/core/worker`. Point a
- * module worker at it and connect a MinnowDatabaseClient — the client's init frame carries the
- * store descriptor and options, so this entry needs no configuration of its own:
- *
- *   // db-worker.ts: import "@minnowdb/core/worker";
- *   new Worker(new URL("./db-worker.ts", import.meta.url), { type: "module" })
- *
- * For non-cloneable construction options (custom store, `now`, `createId`), write your own entry
- * and import `exposeDatabase()` from `@minnowdb/core/worker-host` instead.
- */
 import { attachDatabaseWorker } from "./worker-host.js";
 attachDatabaseWorker(self);

package/dist/engine/write-block-planner.js

@@ -1,112 +1,105 @@
-import { MAX_BLOCK_ROW_COUNT, physicalColumnByteLength, wellFormedUtf8ByteLength, } from "../block-format/index.js";
-/**
- * Plans aligned row groups for every column in one segment. The row-wise accumulator visits each
- * string value once, plus at most one overflow recheck at a block boundary, so a late wide column
- * cannot make its siblings rescan the rest of the batch for every output block.
- */
-export function planAlignedWriteBlockRanges(columns, rowCount, maximumRows, targetBytes, measureString = wellFormedUtf8ByteLength) {
-    if (rowCount === 0)
-        return [];
-    if (!Number.isSafeInteger(maximumRows) || maximumRows <= 0 || maximumRows > MAX_BLOCK_ROW_COUNT) {
-        throw new RangeError("Maximum rows per write block exceeds the format limit");
+import { MAX_BLOCK_ROW_COUNT, physicalColumnByteLength, wellFormedUtf8ByteLength } from "../block-format/index.js";
+function planAlignedWriteBlockRanges(columns, rowCount, maximumRows, targetBytes, measureString = wellFormedUtf8ByteLength) {
+  if (rowCount === 0)
+    return [];
+  if (!Number.isSafeInteger(maximumRows) || maximumRows <= 0 || maximumRows > MAX_BLOCK_ROW_COUNT) {
+    throw new RangeError("Maximum rows per write block exceeds the format limit");
+  }
+  for (const column of columns) {
+    if (column.values.length !== rowCount) {
+      throw new RangeError("Column lengths must match while planning write blocks");
     }
-    for (const column of columns) {
-        if (column.values.length !== rowCount) {
-            throw new RangeError("Column lengths must match while planning write blocks");
-        }
+  }
+  let maximumRowsPerRange = maximumRows;
+  const stringColumns = [];
+  for (const column of columns) {
+    if (column.type === "string")
+      stringColumns.push(column);
+    else {
+      maximumRowsPerRange = Math.min(maximumRowsPerRange, maximumFixedWidthRows(column.type, maximumRows, targetBytes));
     }
-    let maximumRowsPerRange = maximumRows;
-    const stringColumns = [];
-    for (const column of columns) {
-        if (column.type === "string")
-            stringColumns.push(column);
-        else {
-            maximumRowsPerRange = Math.min(maximumRowsPerRange, maximumFixedWidthRows(column.type, maximumRows, targetBytes));
-        }
+  }
+  const ranges = [];
+  if (stringColumns.length === 0) {
+    for (let start = 0; start < rowCount; start += maximumRowsPerRange) {
+      ranges.push({ start, end: Math.min(rowCount, start + maximumRowsPerRange) });
     }
-    const ranges = [];
-    if (stringColumns.length === 0) {
-        // Fixed-width sizes depend only on row count. Do not add a value-reading pass to numeric and
-        // boolean writes: calculate the cap once and emit the arithmetic ranges directly.
-        for (let start = 0; start < rowCount; start += maximumRowsPerRange) {
-            ranges.push({ start, end: Math.min(rowCount, start + maximumRowsPerRange) });
+    return ranges;
+  }
+  for (let start = 0; start < rowCount; ) {
+    const rowLimit = Math.min(rowCount, start + maximumRowsPerRange);
+    const stringContentBytes = new Array(stringColumns.length).fill(0);
+    let end = start;
+    for (let row = start; row < rowLimit; row += 1) {
+      const count = row - start + 1;
+      let fitsTarget = true;
+      for (let columnIndex = 0; columnIndex < stringColumns.length; columnIndex += 1) {
+        const column = stringColumns[columnIndex];
+        if (column === void 0)
+          continue;
+        let contentBytes = stringContentBytes[columnIndex] ?? 0;
+        const value = column.values[row];
+        if (value !== null) {
+          if (typeof value !== "string") {
+            throw new TypeError("String column contains a non-string");
+          }
+          contentBytes += column.stringByteLengths?.[row] ?? measureString(value);
+          stringContentBytes[columnIndex] = contentBytes;
         }
-        return ranges;
-    }
-    for (let start = 0; start < rowCount;) {
-        const rowLimit = Math.min(rowCount, start + maximumRowsPerRange);
-        const stringContentBytes = new Array(stringColumns.length).fill(0);
-        let end = start;
-        for (let row = start; row < rowLimit; row += 1) {
-            const count = row - start + 1;
-            let fitsTarget = true;
-            for (let columnIndex = 0; columnIndex < stringColumns.length; columnIndex += 1) {
-                const column = stringColumns[columnIndex];
-                if (column === undefined)
-                    continue;
-                let contentBytes = stringContentBytes[columnIndex] ?? 0;
-                const value = column.values[row];
-                if (value !== null) {
-                    if (typeof value !== "string") {
-                        throw new TypeError("String column contains a non-string");
-                    }
-                    contentBytes += column.stringByteLengths?.[row] ?? measureString(value);
-                    stringContentBytes[columnIndex] = contentBytes;
-                }
-                if (physicalColumnBytesUnchecked("string", count, contentBytes) > targetBytes) {
-                    fitsTarget = false;
-                }
-            }
-            if (!fitsTarget && count > 1)
-                break;
-            if (!fitsTarget) {
-                // The target is soft for one wide row, but the format ceiling is always hard. Validate
-                // every string column's exact one-row size before allowing that row to make progress.
-                for (let columnIndex = 0; columnIndex < stringColumns.length; columnIndex += 1) {
-                    physicalColumnByteLength("string", 1, stringContentBytes[columnIndex] ?? 0);
-                }
-            }
-            end = row + 1;
-            if (!fitsTarget)
-                break;
+        if (physicalColumnBytesUnchecked("string", count, contentBytes) > targetBytes) {
+          fitsTarget = false;
         }
-        if (end <= start)
-            throw new Error("Write block planner made no progress");
-        ranges.push({ start, end });
-        start = end;
+      }
+      if (!fitsTarget && count > 1)
+        break;
+      if (!fitsTarget) {
+        for (let columnIndex = 0; columnIndex < stringColumns.length; columnIndex += 1) {
+          physicalColumnByteLength("string", 1, stringContentBytes[columnIndex] ?? 0);
+        }
+      }
+      end = row + 1;
+      if (!fitsTarget)
+        break;
     }
-    return ranges;
+    if (end <= start)
+      throw new Error("Write block planner made no progress");
+    ranges.push({ start, end });
+    start = end;
+  }
+  return ranges;
 }
 function maximumFixedWidthRows(type, maximumRows, targetBytes) {
-    if (physicalColumnBytesUnchecked(type, maximumRows, 0) <= targetBytes)
-        return maximumRows;
-    if (physicalColumnBytesUnchecked(type, 1, 0) > targetBytes)
-        return 1;
-    let low = 1;
-    let high = maximumRows;
-    while (low < high) {
-        const middle = Math.ceil((low + high) / 2);
-        if (physicalColumnBytesUnchecked(type, middle, 0) <= targetBytes)
-            low = middle;
-        else
-            high = middle - 1;
-    }
-    return low;
+  if (physicalColumnBytesUnchecked(type, maximumRows, 0) <= targetBytes)
+    return maximumRows;
+  if (physicalColumnBytesUnchecked(type, 1, 0) > targetBytes)
+    return 1;
+  let low = 1;
+  let high = maximumRows;
+  while (low < high) {
+    const middle = Math.ceil((low + high) / 2);
+    if (physicalColumnBytesUnchecked(type, middle, 0) <= targetBytes)
+      low = middle;
+    else
+      high = middle - 1;
+  }
+  return low;
 }
-/** Conservative first estimate used by both physical compaction planners. */
-export function estimateCompactionRowsPerOutput(targetBlockBytes, maximumEncodedBytesPerRow) {
-    return Math.max(1, Math.min(MAX_BLOCK_ROW_COUNT, Math.floor(targetBlockBytes / maximumEncodedBytesPerRow)));
+function estimateCompactionRowsPerOutput(targetBlockBytes, maximumEncodedBytesPerRow) {
+  return Math.max(1, Math.min(MAX_BLOCK_ROW_COUNT, Math.floor(targetBlockBytes / maximumEncodedBytesPerRow)));
 }
-/** Exact physical size without applying the 64 MiB hard limit during range search. */
 function physicalColumnBytesUnchecked(type, rowCount, stringContentBytes) {
-    const validityBytes = Math.ceil(rowCount / 8);
-    switch (type) {
-        case "boolean":
-            return validityBytes * 2;
-        case "number":
-        case "datetime":
-            return validityBytes + rowCount * 8;
-        case "string":
-            return validityBytes + (rowCount + 1) * 4 + stringContentBytes;
-    }
+  const validityBytes = Math.ceil(rowCount / 8);
+  switch (type) {
+    case "boolean":
+      return validityBytes * 2;
+    case "number":
+    case "datetime":
+      return validityBytes + rowCount * 8;
+    case "string":
+      return validityBytes + (rowCount + 1) * 4 + stringContentBytes;
+  }
 }
+export {
+  estimateCompactionRowsPerOutput,
+  planAlignedWriteBlockRanges
+};

package/dist/plan/index.js

@@ -1,16 +1,15 @@
-/**
- * The plan-construction primitives, published so a typed query layer can be built externally.
- *
- * A query builder's whole job is to assemble the same logical plan the SQL parser assembles, and
- * then hand it to the engine. That requires the plan's types, the block-assembly functions the
- * parser itself ends in, and the validators that keep a hand-built plan as strict as a parsed one.
- * Exposing them here lets an external builder produce plans the engine treats as indistinguishable
- * from parsed SQL.
- *
- * The recursive logical model lives in the dependency-light `model` leaf; executable assembly
- * and validation stay with the compiler. This entry point keeps that distinction invisible to
- * consumers.
- */
-export { assembleSelectBlock, compoundSelectBlock, derivedTableSource, hasAggregate, splitCondition, validateLimit, validateOffset, } from "../engine/query.js";
-export { optimizePlan, renderPlan } from "../engine/optimizer.js";
-export { validateFtsQuery } from "../engine/fts.js";
+import { assembleSelectBlock, compoundSelectBlock, derivedTableSource, hasAggregate, splitCondition, validateLimit, validateOffset } from "../engine/query.js";
+import { optimizePlan, renderPlan } from "../engine/optimizer.js";
+import { validateFtsQuery } from "../engine/fts.js";
+export {
+  assembleSelectBlock,
+  compoundSelectBlock,
+  derivedTableSource,
+  hasAggregate,
+  optimizePlan,
+  renderPlan,
+  splitCondition,
+  validateFtsQuery,
+  validateLimit,
+  validateOffset
+};

package/dist/plan/model.d.ts

@@ -246,6 +246,12 @@ export interface CompiledQuery {
     pendingSetOrder?: true;
     /** Preserve `{ optimize: false }` after a deferred wildcard shape becomes concrete. */
     preserveUnoptimizedShape?: true;
+    /**
+     * Set by the optimizer on the plan it returns. Parameter binding applies the value-dependent
+     * rewrites (calendar equalities) only to optimized plans, so `{ optimize: false }` stays the
+     * untouched oracle for them.
+     */
+    optimized?: true;
     distinctWildcard?: boolean;
     limitParameter?: number;
     offsetParameter?: number;

package/dist/plan/model.js

@@ -1,29 +1,22 @@
-/**
- * A cross join rides the nested-loop inner-join path with a condition every row pair satisfies:
- * 1 = 1 over null literal key expressions. Producers build the shape with crossJoinPlan and
- * consumers recognize it with isCrossJoinPlan, so the encoding lives in exactly one place.
- */
-export function crossJoinPlan(source) {
-    return {
-        ...source,
-        kind: "inner",
-        left: { kind: "literal", value: null },
-        right: { kind: "literal", value: null },
-        on: {
-            kind: "condition",
-            operator: "=",
-            left: { kind: "literal", value: 1 },
-            right: { kind: "literal", value: 1 },
-        },
-    };
+function crossJoinPlan(source) {
+  return {
+    ...source,
+    kind: "inner",
+    left: { kind: "literal", value: null },
+    right: { kind: "literal", value: null },
+    on: {
+      kind: "condition",
+      operator: "=",
+      left: { kind: "literal", value: 1 },
+      right: { kind: "literal", value: 1 }
+    }
+  };
 }
-export function isCrossJoinPlan(join) {
-    const condition = join.on;
-    return (join.kind === "inner" &&
-        condition?.kind === "condition" &&
-        condition.operator === "=" &&
-        condition.left.kind === "literal" &&
-        condition.left.value === 1 &&
-        condition.right.kind === "literal" &&
-        condition.right.value === 1);
+function isCrossJoinPlan(join) {
+  const condition = join.on;
+  return join.kind === "inner" && condition?.kind === "condition" && condition.operator === "=" && condition.left.kind === "literal" && condition.left.value === 1 && condition.right.kind === "literal" && condition.right.value === 1;
 }
+export {
+  crossJoinPlan,
+  isCrossJoinPlan
+};

package/dist/storage/index.js

@@ -1,15 +1,3 @@
-/**
- * The storage surface, in three layers with enforced dependency directions
- * (contract-boundaries.test.ts):
- *
- * - **The contract** — `types.ts` and `snapshot.ts`: the `BlockStore` capability interfaces,
- *   record types, and error classes. The engine depends on nothing else here.
- * - **The adapters** — `indexeddb.ts`, `memory.ts`, `opfs/`: implementations, each owning its
- *   own low-level strategy.
- * - **The toolkit** — `toolkit/`, published as `@minnowdb/core/storage/toolkit` rather than
- *   from this barrel: optional building blocks for writing new adapters. The contract never
- *   references it.
- */
 export * from "./indexeddb.js";
 export * from "./memory.js";
 export * from "./opfs/index.js";