@minnowdb/core 0.6.9 → 0.7.1

package/dist/engine/buffered-writer.js

@@ -1,172 +1,170 @@
 import { copyDate } from "../date-value.js";
 import { estimateRowBytes } from "./byte-estimates.js";
-/** Maximum accepted `add()` calls that have not completed. Callers must await for backpressure. */
-export const MAX_BUFFERED_WRITER_PENDING_ADDS = 64;
-/** Batches row-oriented writes by row count, estimated bytes, or age. */
-export class BufferedTableWriter {
-    database;
-    tableName;
-    #mode;
-    #maxRows;
-    #maxBytes;
-    #maxAgeMs;
-    #onError;
-    #rows = [];
-    #estimatedBytes = 0;
-    #timer;
-    #inFlight;
-    #addTail = Promise.resolve();
-    #pendingAddCount = 0;
-    #acceptingAdds = true;
-    #closed = false;
-    constructor(database, tableName, options = {}) {
-        this.database = database;
-        this.tableName = tableName;
-        this.#mode = options.mode ?? "insert";
-        this.#maxRows = positiveWholeNumber(options.maxRows ?? 1_000, "Buffered row limit");
-        this.#maxBytes = positiveWholeNumber(options.maxBytes ?? 1024 * 1024, "Buffered byte limit");
-        this.#maxAgeMs = positiveWholeNumber(options.maxAgeMs ?? 1_000, "Buffered age limit");
-        this.#onError = options.onError;
+const MAX_BUFFERED_WRITER_PENDING_ADDS = 64;
+class BufferedTableWriter {
+  database;
+  tableName;
+  #mode;
+  #maxRows;
+  #maxBytes;
+  #maxAgeMs;
+  #onError;
+  #rows = [];
+  #estimatedBytes = 0;
+  #timer;
+  #inFlight;
+  #addTail = Promise.resolve();
+  #pendingAddCount = 0;
+  #acceptingAdds = true;
+  #closed = false;
+  constructor(database, tableName, options = {}) {
+    this.database = database;
+    this.tableName = tableName;
+    this.#mode = options.mode ?? "insert";
+    this.#maxRows = positiveWholeNumber(options.maxRows ?? 1e3, "Buffered row limit");
+    this.#maxBytes = positiveWholeNumber(options.maxBytes ?? 1024 * 1024, "Buffered byte limit");
+    this.#maxAgeMs = positiveWholeNumber(options.maxAgeMs ?? 1e3, "Buffered age limit");
+    this.#onError = options.onError;
+  }
+  get pendingRowCount() {
+    return this.#rows.length;
+  }
+  get estimatedBytes() {
+    return this.#estimatedBytes;
+  }
+  async add(row) {
+    this.#assertOpen();
+    if (!this.#acceptingAdds)
+      return Promise.reject(new Error("Buffered writer is closing"));
+    if (this.#pendingAddCount >= MAX_BUFFERED_WRITER_PENDING_ADDS) {
+      return Promise.reject(new RangeError(`Buffered writer cannot queue more than ${String(MAX_BUFFERED_WRITER_PENDING_ADDS)} adds; await add() for backpressure`));
     }
-    get pendingRowCount() {
-        return this.#rows.length;
+    this.#pendingAddCount += 1;
+    const operation = this.#addTail.then(() => this.#addSerial(row));
+    this.#addTail = operation.then(() => void 0, () => void 0);
+    return operation.finally(() => {
+      this.#pendingAddCount -= 1;
+    });
+  }
+  async flush() {
+    if (this.#inFlight !== void 0)
+      return this.#inFlight;
+    if (this.#rows.length === 0)
+      return void 0;
+    this.#clearTimer();
+    const rows = this.#rows.splice(0);
+    this.#estimatedBytes = 0;
+    const operation = this.#mode === "upsert" ? this.database.upsertBatch(this.tableName, rows) : this.database.insertBatch(this.tableName, rows);
+    this.#inFlight = operation;
+    try {
+      return await operation;
+    } catch (error) {
+      this.#rows.unshift(...rows);
+      this.#estimatedBytes = this.#rows.reduce((total, row) => total + estimateRowBytes(row), 0);
+      throw error;
+    } finally {
+      this.#inFlight = void 0;
     }
-    get estimatedBytes() {
-        return this.#estimatedBytes;
+  }
+  requestFlush() {
+    if (this.#closed)
+      return;
+    void this.#flushPending().catch((error) => this.#onError?.(error));
+  }
+  async close() {
+    if (this.#closed)
+      return void 0;
+    this.#acceptingAdds = false;
+    await this.#addTail;
+    let result;
+    while (this.#inFlight !== void 0 || this.#rows.length > 0) {
+      result = await this.flush();
+      if (this.#inFlight !== void 0)
+        await this.#inFlight;
     }
-    async add(row) {
-        this.#assertOpen();
-        if (!this.#acceptingAdds)
-            return Promise.reject(new Error("Buffered writer is closing"));
-        if (this.#pendingAddCount >= MAX_BUFFERED_WRITER_PENDING_ADDS) {
-            return Promise.reject(new RangeError(`Buffered writer cannot queue more than ${String(MAX_BUFFERED_WRITER_PENDING_ADDS)} adds; await add() for backpressure`));
-        }
-        this.#pendingAddCount += 1;
-        const operation = this.#addTail.then(() => this.#addSerial(row));
-        this.#addTail = operation.then(() => undefined, () => undefined);
-        return operation.finally(() => {
-            this.#pendingAddCount -= 1;
-        });
+    this.#closed = true;
+    this.#clearTimer();
+    return result;
+  }
+  discard() {
+    this.#assertOpen();
+    if (this.#pendingAddCount > 0) {
+      throw new Error("Cannot discard while buffered adds are pending");
     }
-    async flush() {
-        if (this.#inFlight !== undefined)
-            return this.#inFlight;
-        if (this.#rows.length === 0)
-            return undefined;
-        this.#clearTimer();
-        const rows = this.#rows.splice(0);
-        this.#estimatedBytes = 0;
-        const operation = this.#mode === "upsert"
-            ? this.database.upsertBatch(this.tableName, rows)
-            : this.database.insertBatch(this.tableName, rows);
-        this.#inFlight = operation;
-        try {
-            return await operation;
-        }
-        catch (error) {
-            this.#rows.unshift(...rows);
-            this.#estimatedBytes = this.#rows.reduce((total, row) => total + estimateRowBytes(row), 0);
-            throw error;
-        }
-        finally {
-            this.#inFlight = undefined;
-        }
+    const discarded = this.#rows.length;
+    this.#rows.length = 0;
+    this.#estimatedBytes = 0;
+    this.#clearTimer();
+    return discarded;
+  }
+  async #flushPending() {
+    while (this.#inFlight !== void 0 || this.#rows.length > 0) {
+      if (this.#inFlight !== void 0)
+        await this.#inFlight;
+      else
+        await this.flush();
     }
-    requestFlush() {
-        if (this.#closed)
-            return;
-        void this.#flushPending().catch((error) => this.#onError?.(error));
-    }
-    async close() {
-        if (this.#closed)
-            return undefined;
-        this.#acceptingAdds = false;
-        await this.#addTail;
-        let result;
-        while (this.#inFlight !== undefined || this.#rows.length > 0) {
-            result = await this.flush();
-            if (this.#inFlight !== undefined)
-                await this.#inFlight;
-        }
-        this.#closed = true;
-        this.#clearTimer();
-        return result;
-    }
-    discard() {
-        this.#assertOpen();
-        if (this.#pendingAddCount > 0) {
-            throw new Error("Cannot discard while buffered adds are pending");
-        }
-        const discarded = this.#rows.length;
-        this.#rows.length = 0;
-        this.#estimatedBytes = 0;
-        this.#clearTimer();
-        return discarded;
-    }
-    async #flushPending() {
-        while (this.#inFlight !== undefined || this.#rows.length > 0) {
-            if (this.#inFlight !== undefined)
-                await this.#inFlight;
-            else
-                await this.flush();
-        }
-    }
-    async #addSerial(row) {
-        const copy = cloneRow(row);
-        this.#rows.push(copy);
-        this.#estimatedBytes += estimateRowBytes(copy);
-        this.#scheduleAgeFlush();
-        if (this.#rows.length < this.#maxRows && this.#estimatedBytes < this.#maxBytes) {
-            return undefined;
-        }
-        if (this.#inFlight !== undefined)
-            await this.#inFlight;
-        return this.flush();
-    }
-    #scheduleAgeFlush() {
-        if (this.#timer !== undefined || this.#rows.length === 0 || this.#closed)
-            return;
-        this.#timer = setTimeout(() => {
-            this.#timer = undefined;
-            void this.#flushPending().catch((error) => this.#onError?.(error));
-        }, this.#maxAgeMs);
-    }
-    #clearTimer() {
-        if (this.#timer === undefined)
-            return;
-        clearTimeout(this.#timer);
-        this.#timer = undefined;
-    }
-    #assertOpen() {
-        if (this.#closed)
-            throw new Error("Buffered writer is closed");
+  }
+  async #addSerial(row) {
+    const copy = cloneRow(row);
+    this.#rows.push(copy);
+    this.#estimatedBytes += estimateRowBytes(copy);
+    this.#scheduleAgeFlush();
+    if (this.#rows.length < this.#maxRows && this.#estimatedBytes < this.#maxBytes) {
+      return void 0;
     }
+    if (this.#inFlight !== void 0)
+      await this.#inFlight;
+    return this.flush();
+  }
+  #scheduleAgeFlush() {
+    if (this.#timer !== void 0 || this.#rows.length === 0 || this.#closed)
+      return;
+    this.#timer = setTimeout(() => {
+      this.#timer = void 0;
+      void this.#flushPending().catch((error) => this.#onError?.(error));
+    }, this.#maxAgeMs);
+  }
+  #clearTimer() {
+    if (this.#timer === void 0)
+      return;
+    clearTimeout(this.#timer);
+    this.#timer = void 0;
+  }
+  #assertOpen() {
+    if (this.#closed)
+      throw new Error("Buffered writer is closed");
+  }
 }
-/** Requests a non-blocking flush when the browser hides or unloads the page. */
-export function attachLifecycleFlush(requester, options = {}) {
-    const documentTarget = options.document ?? (typeof document === "undefined" ? undefined : document);
-    const pageTarget = options.page ?? (typeof window === "undefined" ? undefined : window);
-    const onVisibilityChange = () => {
-        if (documentTarget?.visibilityState === "hidden")
-            requester.requestFlush();
-    };
-    const onPageHide = () => requester.requestFlush();
-    documentTarget?.addEventListener("visibilitychange", onVisibilityChange);
-    pageTarget?.addEventListener("pagehide", onPageHide);
-    return () => {
-        documentTarget?.removeEventListener("visibilitychange", onVisibilityChange);
-        pageTarget?.removeEventListener("pagehide", onPageHide);
-    };
+function attachLifecycleFlush(requester, options = {}) {
+  const documentTarget = options.document ?? (typeof document === "undefined" ? void 0 : document);
+  const pageTarget = options.page ?? (typeof window === "undefined" ? void 0 : window);
+  const onVisibilityChange = () => {
+    if (documentTarget?.visibilityState === "hidden")
+      requester.requestFlush();
+  };
+  const onPageHide = () => requester.requestFlush();
+  documentTarget?.addEventListener("visibilitychange", onVisibilityChange);
+  pageTarget?.addEventListener("pagehide", onPageHide);
+  return () => {
+    documentTarget?.removeEventListener("visibilitychange", onVisibilityChange);
+    pageTarget?.removeEventListener("pagehide", onPageHide);
+  };
 }
 function positiveWholeNumber(value, name) {
-    if (!Number.isSafeInteger(value) || value <= 0) {
-        throw new RangeError(`${name} must be a positive whole number`);
-    }
-    return value;
+  if (!Number.isSafeInteger(value) || value <= 0) {
+    throw new RangeError(`${name} must be a positive whole number`);
+  }
+  return value;
 }
 function cloneRow(row) {
-    return Object.fromEntries(Object.entries(row).map(([name, value]) => [
-        name,
-        value instanceof Date ? copyDate(value) : value,
-    ]));
+  return Object.fromEntries(Object.entries(row).map(([name, value]) => [
+    name,
+    value instanceof Date ? copyDate(value) : value
+  ]));
 }
+export {
+  BufferedTableWriter,
+  MAX_BUFFERED_WRITER_PENDING_ADDS,
+  attachLifecycleFlush
+};

package/dist/engine/byte-estimates.js

@@ -1,25 +1,23 @@
-/**
- * The one modeled per-value size used for flush thresholds, cache accounting, and write
- * metrics. One byte per UTF-16 code unit approximates the UTF-8 payload (exact for ASCII)
- * without encoding the string just to measure it — this estimate feeds metrics and flush
- * thresholds, not the physical format. Keeping a single implementation keeps those
- * accountings from drifting apart.
- */
-export function estimateValuesBytes(values) {
-    let bytes = 0;
-    for (const value of values) {
-        if (typeof value === "string")
-            bytes += 4 + value.length;
-        else if (typeof value === "number" || value instanceof Date)
-            bytes += 8;
-        else
-            bytes += 1;
-    }
-    return bytes;
+function estimateValuesBytes(values) {
+  let bytes = 0;
+  for (const value of values) {
+    if (typeof value === "string")
+      bytes += 4 + value.length;
+    else if (typeof value === "number" || value instanceof Date)
+      bytes += 8;
+    else
+      bytes += 1;
+  }
+  return bytes;
 }
-export function estimateRowBytes(row) {
-    return estimateValuesBytes(Object.values(row));
+function estimateRowBytes(row) {
+  return estimateValuesBytes(Object.values(row));
 }
-export function estimateBatchBytes(input) {
-    return Object.values(input.columns).reduce((total, values) => total + estimateValuesBytes(values), 0);
+function estimateBatchBytes(input) {
+  return Object.values(input.columns).reduce((total, values) => total + estimateValuesBytes(values), 0);
 }
+export {
+  estimateBatchBytes,
+  estimateRowBytes,
+  estimateValuesBytes
+};

package/dist/engine/cache-limits.js

@@ -1,25 +1,24 @@
-/** Valid inputs beyond this length execute normally but are not retained in process-wide caches. */
-export const MAX_CACHEABLE_TEXT_CHARACTERS = 16 * 1024;
-/**
- * Compilation happens before a query memory context exists. These limits therefore bound parser
- * allocations and recursion independently of the execution budget. They are intentionally much
- * larger than ordinary application SQL while remaining small enough for deterministic refusal.
- */
-export const MAX_SQL_TEXT_CHARACTERS = 1024 * 1024;
-export const MAX_SQL_TOKENS = 16_384;
-export const MAX_SQL_NESTING_DEPTH = 128;
-export const MAX_SQL_PARAMETERS = 4_096;
-/**
- * Scalar functions that create a new string must not allocate an attacker-selected result before
- * query memory accounting can observe it. Plain projection does not use this limit: a stored wide
- * value can still be selected or streamed without asking a scalar function to expand it.
- */
-export const MAX_SQL_SCALAR_RESULT_CHARACTERS = 1024 * 1024;
-/** Bounds object/array walks performed before an execution memory context exists. */
-export const MAX_SQL_STRUCTURED_VALUE_ITEMS = 65_536;
-export const MAX_SQL_STRUCTURED_VALUE_DEPTH = 128;
-/** SQL patterns compile outside the execution memory budget and may be retained in small caches. */
-export const MAX_SQL_PATTERN_CHARACTERS = 16 * 1024;
-/** Deterministic CPU ceiling for one non-trivial LIKE or SIMILAR TO match. */
-export const MAX_SQL_PATTERN_MATCH_STEPS = 8 * 1024 * 1024;
-export const MAX_SQL_NUMERIC_DIGITS = 100_000;
+const MAX_CACHEABLE_TEXT_CHARACTERS = 16 * 1024;
+const MAX_SQL_TEXT_CHARACTERS = 1024 * 1024;
+const MAX_SQL_TOKENS = 16384;
+const MAX_SQL_NESTING_DEPTH = 128;
+const MAX_SQL_PARAMETERS = 4096;
+const MAX_SQL_SCALAR_RESULT_CHARACTERS = 1024 * 1024;
+const MAX_SQL_STRUCTURED_VALUE_ITEMS = 65536;
+const MAX_SQL_STRUCTURED_VALUE_DEPTH = 128;
+const MAX_SQL_PATTERN_CHARACTERS = 16 * 1024;
+const MAX_SQL_PATTERN_MATCH_STEPS = 8 * 1024 * 1024;
+const MAX_SQL_NUMERIC_DIGITS = 1e5;
+export {
+  MAX_CACHEABLE_TEXT_CHARACTERS,
+  MAX_SQL_NESTING_DEPTH,
+  MAX_SQL_NUMERIC_DIGITS,
+  MAX_SQL_PARAMETERS,
+  MAX_SQL_PATTERN_CHARACTERS,
+  MAX_SQL_PATTERN_MATCH_STEPS,
+  MAX_SQL_SCALAR_RESULT_CHARACTERS,
+  MAX_SQL_STRUCTURED_VALUE_DEPTH,
+  MAX_SQL_STRUCTURED_VALUE_ITEMS,
+  MAX_SQL_TEXT_CHARACTERS,
+  MAX_SQL_TOKENS
+};

package/dist/engine/cancellation.js

@@ -1,4 +1,6 @@
-/** One compact check shared by every bounded query-execution path. */
-export function throwIfAborted(signal) {
-    signal?.throwIfAborted();
+function throwIfAborted(signal) {
+  signal?.throwIfAborted();
 }
+export {
+  throwIfAborted
+};

package/dist/engine/catalog.js

@@ -1,78 +1,69 @@
-import { secondaryIndexColumnIds, secondaryIndexDirections, } from "../storage/types.js";
+import { secondaryIndexColumnIds, secondaryIndexDirections } from "../storage/types.js";
 import { externalSqlDomainValue } from "./sql-domains.js";
 function toCatalogColumn(column) {
-    return {
-        id: column.id,
-        name: column.name,
-        type: column.type,
-        ...(column.integer === true ? { integer: true } : {}),
-        ...(column.sqlDomain === undefined ? {} : { sqlDomain: structuredClone(column.sqlDomain) }),
-        nullable: column.nullable,
-        ...(column.defaultValue === undefined ? {} : { defaultValue: column.defaultValue }),
-        ...(column.generatedValue === undefined ? {} : { generatedValue: column.generatedValue }),
-        ...(column.enumValues === undefined ? {} : { enumValues: [...column.enumValues] }),
-        ...(column.backfill === undefined
-            ? {}
-            : { backfill: externalSqlDomainValue(column.backfill) }),
-        isAutoIncrementing: column.defaultValue?.kind === "autoincrement",
-    };
+  return {
+    id: column.id,
+    name: column.name,
+    type: column.type,
+    ...column.integer === true ? { integer: true } : {},
+    ...column.sqlDomain === void 0 ? {} : { sqlDomain: structuredClone(column.sqlDomain) },
+    nullable: column.nullable,
+    ...column.defaultValue === void 0 ? {} : { defaultValue: column.defaultValue },
+    ...column.generatedValue === void 0 ? {} : { generatedValue: column.generatedValue },
+    ...column.enumValues === void 0 ? {} : { enumValues: [...column.enumValues] },
+    ...column.backfill === void 0 ? {} : { backfill: externalSqlDomainValue(column.backfill) },
+    isAutoIncrementing: column.defaultValue?.kind === "autoincrement"
+  };
 }
-/** Projects storage's table records into the published catalog, sorted by name for stable diffs. */
-export function toCatalog(records) {
-    const byName = [...records].sort((left, right) => left.name.localeCompare(right.name));
-    const tables = [];
-    const views = [];
-    for (const record of byName) {
-        if (record.enumType !== undefined || record.sequence !== undefined)
-            continue;
-        const columns = record.columns.filter((column) => !column.hidden).map(toCatalogColumn);
-        if (record.view !== undefined) {
-            views.push({
-                name: record.name,
-                sql: record.view.sql,
-                columns,
-                managed: record.view.managed,
-            });
-            continue;
-        }
-        tables.push({
-            name: record.name,
-            managed: record.managed,
-            columns,
-            ...(record.uniqueKeyColumnId === undefined ||
-                record.columns.find((column) => column.id === record.uniqueKeyColumnId)?.hidden === true
-                ? {}
-                : { uniqueKeyColumnId: record.uniqueKeyColumnId }),
-            ...(record.primaryKeyColumnIds === undefined
-                ? {}
-                : { primaryKeyColumnIds: [...record.primaryKeyColumnIds] }),
-            foreignKeys: (record.foreignKeys ?? []).map((key) => ({
-                ...key,
-                enforced: key.enforced !== false,
-            })),
-            checks: (record.checks ?? []).map((check) => ({ ...check })),
-            ...(record.secondaryIndexes === undefined
-                ? {}
-                : {
-                    indexes: Object.values(record.secondaryIndexes)
-                        .map((index) => ({
-                        name: index.name,
-                        columns: secondaryIndexColumnIds(index).map((columnId, position) => ({
-                            name: record.columns.find((column) => column.id === columnId)?.name ?? columnId,
-                            direction: secondaryIndexDirections(index)[position] ?? "asc",
-                        })),
-                        unique: index.unique === true,
-                        state: index.state,
-                    }))
-                        .sort((left, right) => left.name.localeCompare(right.name)),
-                }),
-            triggers: (record.triggers ?? []).map(({ id, name, event, timing }) => ({
-                id,
-                name,
-                event,
-                timing,
-            })),
-        });
+function toCatalog(records) {
+  const byName = [...records].sort((left, right) => left.name.localeCompare(right.name));
+  const tables = [];
+  const views = [];
+  for (const record of byName) {
+    if (record.enumType !== void 0 || record.sequence !== void 0)
+      continue;
+    const columns = record.columns.filter((column) => !column.hidden).map(toCatalogColumn);
+    if (record.view !== void 0) {
+      views.push({
+        name: record.name,
+        sql: record.view.sql,
+        columns,
+        managed: record.view.managed
+      });
+      continue;
     }
-    return { tables, views };
+    tables.push({
+      name: record.name,
+      managed: record.managed,
+      columns,
+      ...record.uniqueKeyColumnId === void 0 || record.columns.find((column) => column.id === record.uniqueKeyColumnId)?.hidden === true ? {} : { uniqueKeyColumnId: record.uniqueKeyColumnId },
+      ...record.primaryKeyColumnIds === void 0 ? {} : { primaryKeyColumnIds: [...record.primaryKeyColumnIds] },
+      foreignKeys: (record.foreignKeys ?? []).map((key) => ({
+        ...key,
+        enforced: key.enforced !== false
+      })),
+      checks: (record.checks ?? []).map((check) => ({ ...check })),
+      ...record.secondaryIndexes === void 0 ? {} : {
+        indexes: Object.values(record.secondaryIndexes).map((index) => ({
+          name: index.name,
+          columns: secondaryIndexColumnIds(index).map((columnId, position) => ({
+            name: record.columns.find((column) => column.id === columnId)?.name ?? columnId,
+            direction: secondaryIndexDirections(index)[position] ?? "asc"
+          })),
+          unique: index.unique === true,
+          state: index.state
+        })).sort((left, right) => left.name.localeCompare(right.name))
+      },
+      triggers: (record.triggers ?? []).map(({ id, name, event, timing }) => ({
+        id,
+        name,
+        event,
+        timing
+      }))
+    });
+  }
+  return { tables, views };
 }
+export {
+  toCatalog
+};