@minnowdb/core 0.7.0 → 0.7.1

package/dist/engine/defaults.js

@@ -1,122 +1,115 @@
-/**
- * Write-time default filling. Only an omitted property or SQL `DEFAULT` means "generate";
- * explicit NULL passes through untouched. Literal and SQL-expression defaults are filled before
- * validation. Auto-increment slots stay null until the write path atomically reserves a range.
- */
 import { copyDate } from "../date-value.js";
-export async function fillColumnDefaults(table, input, evaluateExpression, knownRowCount) {
-    const rowCount = knownRowCount ?? Object.values(input.columns).find((values) => values.length > 0)?.length ?? 0;
-    if (!Number.isSafeInteger(rowCount) || rowCount < 0) {
-        throw new TypeError(`Batch row count must be a non-negative safe integer: ${String(rowCount)}`);
+async function fillColumnDefaults(table, input, evaluateExpression, knownRowCount) {
+  const rowCount = knownRowCount ?? Object.values(input.columns).find((values) => values.length > 0)?.length ?? 0;
+  if (!Number.isSafeInteger(rowCount) || rowCount < 0) {
+    throw new TypeError(`Batch row count must be a non-negative safe integer: ${String(rowCount)}`);
+  }
+  for (const [name, values] of Object.entries(input.columns)) {
+    if (values.length !== rowCount) {
+      throw new TypeError(`Column ${name} has ${String(values.length)} rows; expected ${String(rowCount)}`);
     }
-    for (const [name, values] of Object.entries(input.columns)) {
-        if (values.length !== rowCount) {
-            throw new TypeError(`Column ${name} has ${String(values.length)} rows; expected ${String(rowCount)}`);
-        }
+  }
+  if (rowCount === 0)
+    return { batch: input, generated: /* @__PURE__ */ new Map() };
+  const columns = { ...input.columns };
+  const generated = /* @__PURE__ */ new Map();
+  let autoIncrement;
+  for (const [name, mask] of Object.entries(input.omitted ?? {})) {
+    if (!table.columns.some((column) => column.name === name)) {
+      throw new TypeError(`Unknown column in omission mask: ${name}`);
     }
-    if (rowCount === 0)
-        return { batch: input, generated: new Map() };
-    const columns = { ...input.columns };
-    const generated = new Map();
-    let autoIncrement;
-    for (const [name, mask] of Object.entries(input.omitted ?? {})) {
-        if (!table.columns.some((column) => column.name === name)) {
-            throw new TypeError(`Unknown column in omission mask: ${name}`);
-        }
-        if (mask.length !== rowCount) {
-            throw new TypeError(`Omission mask ${name} has ${String(mask.length)} rows; expected ${String(rowCount)}`);
-        }
-        if (mask.some((value) => typeof value !== "boolean")) {
-            throw new TypeError(`Omission mask ${name} must contain booleans`);
-        }
+    if (mask.length !== rowCount) {
+      throw new TypeError(`Omission mask ${name} has ${String(mask.length)} rows; expected ${String(rowCount)}`);
     }
-    for (const column of table.columns) {
-        const defaultValue = column.defaultValue;
-        const provided = input.columns[column.name];
-        const omitted = input.omitted?.[column.name];
-        const isOmitted = (index) => provided === undefined || omitted?.[index] === true;
-        if (column.generatedValue !== undefined) {
-            if (provided !== undefined) {
-                for (let index = 0; index < rowCount; index += 1) {
-                    if (!isOmitted(index)) {
-                        throw new TypeError(`Generated column cannot be assigned: ${column.name}`);
-                    }
-                }
-            }
-            columns[column.name] = new Array(rowCount).fill(null);
-            continue;
-        }
-        if (defaultValue === undefined) {
-            if (provided === undefined || omitted?.some(Boolean) === true) {
-                const values = provided === undefined ? new Array(rowCount).fill(null) : [...provided];
-                for (let index = 0; index < rowCount; index += 1) {
-                    if (isOmitted(index))
-                        values[index] = null;
-                }
-                columns[column.name] = values;
-            }
-            continue;
-        }
-        if (defaultValue.kind === "autoincrement") {
-            const missingIndexes = [];
-            let maxExplicit = 0n;
-            for (let index = 0; index < rowCount; index += 1) {
-                const value = provided?.[index] ?? null;
-                if (isOmitted(index)) {
-                    missingIndexes.push(index);
-                    continue;
-                }
-                if (typeof value !== "number" || !Number.isSafeInteger(value)) {
-                    throw new TypeError(`${column.name}[${String(index)}] must be a whole number in the safe integer range`);
-                }
-                if (BigInt(value) > maxExplicit)
-                    maxExplicit = BigInt(value);
-            }
-            if (missingIndexes.length > 0) {
-                columns[column.name] =
-                    provided === undefined ? new Array(rowCount).fill(null) : [...provided];
-            }
-            autoIncrement = { column, missingIndexes, atLeast: maxExplicit + 1n };
-            continue;
+    if (mask.some((value) => typeof value !== "boolean")) {
+      throw new TypeError(`Omission mask ${name} must contain booleans`);
+    }
+  }
+  for (const column of table.columns) {
+    const defaultValue = column.defaultValue;
+    const provided = input.columns[column.name];
+    const omitted = input.omitted?.[column.name];
+    const isOmitted = (index) => provided === void 0 || omitted?.[index] === true;
+    if (column.generatedValue !== void 0) {
+      if (provided !== void 0) {
+        for (let index = 0; index < rowCount; index += 1) {
+          if (!isOmitted(index)) {
+            throw new TypeError(`Generated column cannot be assigned: ${column.name}`);
+          }
         }
-        const values = provided === undefined ? new Array(rowCount).fill(null) : [...provided];
-        let filled = false;
+      }
+      columns[column.name] = new Array(rowCount).fill(null);
+      continue;
+    }
+    if (defaultValue === void 0) {
+      if (provided === void 0 || omitted?.some(Boolean) === true) {
+        const values2 = provided === void 0 ? new Array(rowCount).fill(null) : [...provided];
         for (let index = 0; index < rowCount; index += 1) {
-            if (!isOmitted(index))
-                continue;
-            filled = true;
-            switch (defaultValue.kind) {
-                case "literal":
-                    values[index] =
-                        defaultValue.value instanceof Date ? copyDate(defaultValue.value) : defaultValue.value;
-                    break;
-                case "expression":
-                    values[index] = await evaluateExpression(defaultValue.sql, index);
-                    break;
-            }
+          if (isOmitted(index))
+            values2[index] = null;
+        }
+        columns[column.name] = values2;
+      }
+      continue;
+    }
+    if (defaultValue.kind === "autoincrement") {
+      const missingIndexes = [];
+      let maxExplicit = 0n;
+      for (let index = 0; index < rowCount; index += 1) {
+        const value = provided?.[index] ?? null;
+        if (isOmitted(index)) {
+          missingIndexes.push(index);
+          continue;
         }
-        if (filled) {
-            columns[column.name] = values;
-            generated.set(column.name, values);
+        if (typeof value !== "number" || !Number.isSafeInteger(value)) {
+          throw new TypeError(`${column.name}[${String(index)}] must be a whole number in the safe integer range`);
         }
+        if (BigInt(value) > maxExplicit)
+          maxExplicit = BigInt(value);
+      }
+      if (missingIndexes.length > 0) {
+        columns[column.name] = provided === void 0 ? new Array(rowCount).fill(null) : [...provided];
+      }
+      autoIncrement = { column, missingIndexes, atLeast: maxExplicit + 1n };
+      continue;
+    }
+    const values = provided === void 0 ? new Array(rowCount).fill(null) : [...provided];
+    let filled = false;
+    for (let index = 0; index < rowCount; index += 1) {
+      if (!isOmitted(index))
+        continue;
+      filled = true;
+      switch (defaultValue.kind) {
+        case "literal":
+          values[index] = defaultValue.value instanceof Date ? copyDate(defaultValue.value) : defaultValue.value;
+          break;
+        case "expression":
+          values[index] = await evaluateExpression(defaultValue.sql, index);
+          break;
+      }
     }
-    return {
-        batch: { columns, rowCount },
-        generated,
-        ...(autoIncrement === undefined ? {} : { autoIncrement }),
-    };
+    if (filled) {
+      columns[column.name] = values;
+      generated.set(column.name, values);
+    }
+  }
+  return {
+    batch: { columns, rowCount },
+    generated,
+    ...autoIncrement === void 0 ? {} : { autoIncrement }
+  };
 }
-/**
- * Writes the reserved range into the batch's null slots. The vector is the fresh array
- * `fillColumnDefaults` created for this fill, never a caller-owned one.
- */
-export function patchAutoIncrementValues(input, fill, range) {
-    const vector = input.columns[fill.column.name];
-    fill.missingIndexes.forEach((rowIndex, offset) => {
-        const value = range.start + BigInt(offset);
-        if (value > BigInt(Number.MAX_SAFE_INTEGER)) {
-            throw new RangeError(`Auto-increment exhausted the safe integer range: ${fill.column.name}`);
-        }
-        vector[rowIndex] = Number(value);
-    });
+function patchAutoIncrementValues(input, fill, range) {
+  const vector = input.columns[fill.column.name];
+  fill.missingIndexes.forEach((rowIndex, offset) => {
+    const value = range.start + BigInt(offset);
+    if (value > BigInt(Number.MAX_SAFE_INTEGER)) {
+      throw new RangeError(`Auto-increment exhausted the safe integer range: ${fill.column.name}`);
+    }
+    vector[rowIndex] = Number(value);
+  });
 }
+export {
+  fillColumnDefaults,
+  patchAutoIncrementValues
+};

package/dist/engine/errors.js

@@ -1,142 +1,127 @@
-/**
- * Typed engine errors, kept free of engine imports so the main-thread worker client can rehydrate
- * them (name, fields, instanceof) without bundling the executor.
- */
 function formatValue(value) {
-    return value instanceof Date ? dateIsoString(value) : String(value);
+  return value instanceof Date ? dateIsoString(value) : String(value);
 }
-/** A database operation named a table that is not present in the current catalog. */
-export class UnknownTableError extends TypeError {
-    tableName;
-    name = "UnknownTableError";
-    constructor(tableName) {
-        super(`Unknown table: ${tableName}`);
-        this.tableName = tableName;
-    }
+class UnknownTableError extends TypeError {
+  tableName;
+  name = "UnknownTableError";
+  constructor(tableName) {
+    super(`Unknown table: ${tableName}`);
+    this.tableName = tableName;
+  }
 }
-/** Refuses another read before one database instance retains an unbounded request backlog. */
-export class DatabaseReadBacklogError extends Error {
-    limit;
-    name = "DatabaseReadBacklogError";
-    constructor(limit = 256) {
-        super(`A database cannot retain more than ${String(limit)} active reads; await a read`);
-        this.limit = limit;
-    }
+class DatabaseReadBacklogError extends Error {
+  limit;
+  name = "DatabaseReadBacklogError";
+  constructor(limit = 256) {
+    super(`A database cannot retain more than ${String(limit)} active reads; await a read`);
+    this.limit = limit;
+  }
 }
-/** A live-query owner reached one of its documented resident-resource ceilings. */
-export class LiveQueryLimitError extends Error {
-    resource;
-    limit;
-    name = "LiveQueryLimitError";
-    constructor(resource, limit) {
-        super(resource === "set"
-            ? `A database cannot retain more than ${String(limit)} live-query sets`
-            : `A live-query set cannot retain more than ${String(limit)} ${resource} records`);
-        this.resource = resource;
-        this.limit = limit;
-    }
+class LiveQueryLimitError extends Error {
+  resource;
+  limit;
+  name = "LiveQueryLimitError";
+  constructor(resource, limit) {
+    super(resource === "set" ? `A database cannot retain more than ${String(limit)} live-query sets` : `A live-query set cannot retain more than ${String(limit)} ${resource} records`);
+    this.resource = resource;
+    this.limit = limit;
+  }
 }
-export class UniqueConstraintError extends Error {
-    tableName;
-    columnName;
-    value;
-    name = "UniqueConstraintError";
-    constructor(tableName, columnName, value) {
-        super(`Duplicate value for ${tableName}.${columnName}: ${formatValue(value)}`);
-        this.tableName = tableName;
-        this.columnName = columnName;
-        this.value = value;
-    }
+class UniqueConstraintError extends Error {
+  tableName;
+  columnName;
+  value;
+  name = "UniqueConstraintError";
+  constructor(tableName, columnName, value) {
+    super(`Duplicate value for ${tableName}.${columnName}: ${formatValue(value)}`);
+    this.tableName = tableName;
+    this.columnName = columnName;
+    this.value = value;
+  }
 }
-export class MissingKeyError extends Error {
-    tableName;
-    columnName;
-    value;
-    name = "MissingKeyError";
-    constructor(tableName, columnName, value) {
-        super(`Missing value for ${tableName}.${columnName}: ${formatValue(value)}`);
-        this.tableName = tableName;
-        this.columnName = columnName;
-        this.value = value;
-    }
+class MissingKeyError extends Error {
+  tableName;
+  columnName;
+  value;
+  name = "MissingKeyError";
+  constructor(tableName, columnName, value) {
+    super(`Missing value for ${tableName}.${columnName}: ${formatValue(value)}`);
+    this.tableName = tableName;
+    this.columnName = columnName;
+    this.value = value;
+  }
 }
-export class CompactionMemoryBudgetError extends Error {
-    budgetBytes;
-    minimumBytes;
-    name = "CompactionMemoryBudgetError";
-    constructor(budgetBytes, minimumBytes) {
-        super(`Compaction needs at least ${String(minimumBytes)} bytes of working memory; budget is ${String(budgetBytes)} bytes`);
-        this.budgetBytes = budgetBytes;
-        this.minimumBytes = minimumBytes;
-    }
+class CompactionMemoryBudgetError extends Error {
+  budgetBytes;
+  minimumBytes;
+  name = "CompactionMemoryBudgetError";
+  constructor(budgetBytes, minimumBytes) {
+    super(`Compaction needs at least ${String(minimumBytes)} bytes of working memory; budget is ${String(budgetBytes)} bytes`);
+    this.budgetBytes = budgetBytes;
+    this.minimumBytes = minimumBytes;
+  }
 }
-export class CompactionWriteAmplificationError extends Error {
-    outputBytes;
-    maximumOutputBytes;
-    name = "CompactionWriteAmplificationError";
-    constructor(outputBytes, maximumOutputBytes) {
-        super(`Compaction output would use ${String(outputBytes)} stored bytes; limit is ${String(maximumOutputBytes)} bytes`);
-        this.outputBytes = outputBytes;
-        this.maximumOutputBytes = maximumOutputBytes;
-    }
+class CompactionWriteAmplificationError extends Error {
+  outputBytes;
+  maximumOutputBytes;
+  name = "CompactionWriteAmplificationError";
+  constructor(outputBytes, maximumOutputBytes) {
+    super(`Compaction output would use ${String(outputBytes)} stored bytes; limit is ${String(maximumOutputBytes)} bytes`);
+    this.outputBytes = outputBytes;
+    this.maximumOutputBytes = maximumOutputBytes;
+  }
 }
-export class CompactionJobCancelledError extends Error {
-    jobId;
-    name = "CompactionJobCancelledError";
-    constructor(jobId) {
-        super(`Compaction job cancelled: ${jobId}`);
-        this.jobId = jobId;
-    }
+class CompactionJobCancelledError extends Error {
+  jobId;
+  name = "CompactionJobCancelledError";
+  constructor(jobId) {
+    super(`Compaction job cancelled: ${jobId}`);
+    this.jobId = jobId;
+  }
 }
-/** Refuses more growth after automatic collection repeatedly fails at a generous debt limit. */
-export class MaintenanceBacklogError extends Error {
-    pendingCommits;
-    causeMessage;
-    name = "MaintenanceBacklogError";
-    constructor(pendingCommits, causeMessage) {
-        super(`Automatic storage collection could not keep up after ${String(pendingCommits)} commits${causeMessage === null ? "" : `: ${causeMessage}`}`);
-        this.pendingCommits = pendingCommits;
-        this.causeMessage = causeMessage;
-    }
+class MaintenanceBacklogError extends Error {
+  pendingCommits;
+  causeMessage;
+  name = "MaintenanceBacklogError";
+  constructor(pendingCommits, causeMessage) {
+    super(`Automatic storage collection could not keep up after ${String(pendingCommits)} commits${causeMessage === null ? "" : `: ${causeMessage}`}`);
+    this.pendingCommits = pendingCommits;
+    this.causeMessage = causeMessage;
+  }
 }
-/**
- * A paged visible-segment scan cannot continue after its table is dropped or replaced. Segment
- * metadata for a dropped table is removed immediately, so returning an empty or partial page
- * would silently misrepresent the captured scan.
- */
-export class VisibleSegmentCursorStaleError extends Error {
-    tableName;
-    capturedTableId;
-    currentTableId;
-    name = "VisibleSegmentCursorStaleError";
-    constructor(tableName, capturedTableId, currentTableId) {
-        super(`Visible segment cursor for ${tableName} is stale: captured table ${capturedTableId}; ${currentTableId === null
-            ? "the table no longer exists"
-            : `current table is ${currentTableId}`}`);
-        this.tableName = tableName;
-        this.capturedTableId = capturedTableId;
-        this.currentTableId = currentTableId;
-    }
+class VisibleSegmentCursorStaleError extends Error {
+  tableName;
+  capturedTableId;
+  currentTableId;
+  name = "VisibleSegmentCursorStaleError";
+  constructor(tableName, capturedTableId, currentTableId) {
+    super(`Visible segment cursor for ${tableName} is stale: captured table ${capturedTableId}; ${currentTableId === null ? "the table no longer exists" : `current table is ${currentTableId}`}`);
+    this.tableName = tableName;
+    this.capturedTableId = capturedTableId;
+    this.currentTableId = currentTableId;
+  }
 }
-/**
- * SQL that failed to compile, located in the text the caller passed. `offset` and `length` are
- * character positions into that exact string — leading whitespace included — so an editor can
- * underline the token that failed without re-deriving the position from the message.
- *
- * `length` is 0 where the failure has no width: an empty statement, or a query that ended before
- * the parser expected it to. Errors raised after parsing succeeds (plan optimization, execution)
- * carry no position and stay plain `TypeError`s.
- *
- * It extends `TypeError` because that is what compilation failures threw before positions existed.
- */
-export class SqlCompileError extends TypeError {
-    offset;
-    length;
-    name = "SqlCompileError";
-    constructor(message, offset, length) {
-        super(message);
-        this.offset = offset;
-        this.length = length;
-    }
+class SqlCompileError extends TypeError {
+  offset;
+  length;
+  name = "SqlCompileError";
+  constructor(message, offset, length) {
+    super(message);
+    this.offset = offset;
+    this.length = length;
+  }
 }
 import { dateIsoString } from "../date-value.js";
+export {
+  CompactionJobCancelledError,
+  CompactionMemoryBudgetError,
+  CompactionWriteAmplificationError,
+  DatabaseReadBacklogError,
+  LiveQueryLimitError,
+  MaintenanceBacklogError,
+  MissingKeyError,
+  SqlCompileError,
+  UniqueConstraintError,
+  UnknownTableError,
+  VisibleSegmentCursorStaleError
+};