@minnowdb/core 0.8.0 → 0.9.1

package/dist/engine/errors.d.ts

@@ -3,6 +3,25 @@
  * them (name, fields, instanceof) without bundling the executor.
  */
 type ErrorValue = boolean | number | string | Date;
+/** An idle SQL transaction rolled back; later statements must not become autocommits. */
+export declare class TransactionExpiredError extends Error {
+    readonly name = "TransactionExpiredError";
+    constructor();
+}
+/** The worker stopped responding within the configured request deadline. */
+export declare class DatabaseWorkerTimeoutError extends Error {
+    readonly method: string;
+    readonly timeoutMs: number;
+    readonly name = "DatabaseWorkerTimeoutError";
+    constructor(method: string, timeoutMs: number);
+}
+/** A transport failure cannot prove whether this operation published before its reply was lost. */
+export declare class DatabaseWorkerOutcomeUnknownError extends Error {
+    readonly method: string;
+    readonly requestId: string;
+    readonly name = "DatabaseWorkerOutcomeUnknownError";
+    constructor(method: string, requestId: string, options?: ErrorOptions);
+}
 /** A database operation named a table that is not present in the current catalog. */
 export declare class UnknownTableError extends TypeError {
     readonly tableName: string;

package/dist/engine/errors.js

@@ -1,3 +1,29 @@
+class TransactionExpiredError extends Error {
+  name = "TransactionExpiredError";
+  constructor() {
+    super("The SQL transaction expired and rolled back; issue ROLLBACK or BEGIN before continuing");
+  }
+}
+class DatabaseWorkerTimeoutError extends Error {
+  method;
+  timeoutMs;
+  name = "DatabaseWorkerTimeoutError";
+  constructor(method, timeoutMs) {
+    super(`Database worker ${method} did not respond within ${String(timeoutMs)}ms`);
+    this.method = method;
+    this.timeoutMs = timeoutMs;
+  }
+}
+class DatabaseWorkerOutcomeUnknownError extends Error {
+  method;
+  requestId;
+  name = "DatabaseWorkerOutcomeUnknownError";
+  constructor(method, requestId, options) {
+    super(`Database worker outcome is unknown for ${method}; reconcile durable application IDs before retrying`, options);
+    this.method = method;
+    this.requestId = requestId;
+  }
+}
 function formatValue(value) {
   return value instanceof Date ? dateIsoString(value) : String(value);
 }
@@ -117,10 +143,13 @@ export {
   CompactionMemoryBudgetError,
   CompactionWriteAmplificationError,
   DatabaseReadBacklogError,
+  DatabaseWorkerOutcomeUnknownError,
+  DatabaseWorkerTimeoutError,
   LiveQueryLimitError,
   MaintenanceBacklogError,
   MissingKeyError,
   SqlCompileError,
+  TransactionExpiredError,
   UniqueConstraintError,
   UnknownTableError,
   VisibleSegmentCursorStaleError

package/dist/engine/index.d.ts

@@ -17,3 +17,4 @@ export type * from "./schema.js";
 export type { InsertValue, CompiledQuery, CompiledStatement, QueryResult, QueryRow, QueryExecutionOptions, QueryValue, SqlColumnSchema, SqlColumnType, } from "./query.js";
 export type { AsyncQueryExecutionOptions, QueryBatchExecutionOptions, QuerySpillStore, } from "./vector.js";
 export type { MinnowSqlDriver, MinnowSqlExecutor } from "./sql-driver.js";
+export { OpfsCoordinationError, OpfsDatabaseInUseError, OpfsUncertainOutcomeError, } from "../storage/types.js";

package/dist/engine/index.js

@@ -4,6 +4,7 @@ export * from "./errors.js";
 import { QueryMemoryBudgetError } from "./memory.js";
 import { 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 } from "./cache-limits.js";
 import { column, foreignKeyName, isDestructiveStep, planMigration, schema, table, view } from "./schema.js";
+import { OpfsCoordinationError, OpfsDatabaseInUseError, OpfsUncertainOutcomeError } from "../storage/types.js";
 export {
   MAX_SQL_NESTING_DEPTH,
   MAX_SQL_NUMERIC_DIGITS,
@@ -15,6 +16,9 @@ export {
   MAX_SQL_STRUCTURED_VALUE_ITEMS,
   MAX_SQL_TEXT_CHARACTERS,
   MAX_SQL_TOKENS,
+  OpfsCoordinationError,
+  OpfsDatabaseInUseError,
+  OpfsUncertainOutcomeError,
   QueryMemoryBudgetError,
   column,
   foreignKeyName,

package/dist/engine/live-accept.js

@@ -0,0 +1,13 @@
+const publications = /* @__PURE__ */ new WeakMap();
+function stageLiveExecution(execution, publish) {
+  publications.set(execution, publish);
+  return execution;
+}
+function acceptLiveExecution(execution) {
+  publications.get(execution)?.();
+  publications.delete(execution);
+}
+export {
+  acceptLiveExecution,
+  stageLiveExecution
+};

package/dist/engine/live-aggregate.js

@@ -2,23 +2,35 @@ import { childExpressions, hasAggregate, mapChildExpressions, executeRowQueryInt
 import { encodeQueryIdentity } from "./query-identity.js";
 import { exactNumericBinary, exactNumericValue, externalSqlDomainValue, isExactNumeric } from "./sql-domains.js";
 import { encodeSqlEqualityValue } from "./sql-semantics.js";
+function contributionBytes(key, row) {
+  return 64 + key.length * 2 + row.group.length * 2 + row.values.reduce((sum, value) => sum + (typeof value === "string" ? value.length * 2 + 16 : 16), 0);
+}
+function groupBytes(key, group) {
+  return 96 + key.length * 2 + group.sums.reduce((sum, value) => sum + value.length * 2 + 24, 0);
+}
 class LiveAggregate {
   inputPlan;
   #outputPlan;
   #aggregates;
   #groupAliases;
-  #rows;
+  #contributions;
+  #revision;
+  #pending;
+  #bytes;
   #groups;
   #domains;
   keyAlias;
   #schema;
-  constructor(inputPlan, outputPlan, aggregates, groupAliases, keyAlias, rows = /* @__PURE__ */ new Map(), groups = /* @__PURE__ */ new Map(), domains = [], schema = []) {
+  constructor(inputPlan, outputPlan, aggregates, groupAliases, keyAlias, contributions = { rows: /* @__PURE__ */ new Map(), revision: 0 }, groups = /* @__PURE__ */ new Map(), domains = [], schema = [], bytes = 256 + encodeQueryIdentity(inputPlan).length * 2 + encodeQueryIdentity(outputPlan).length * 2, pending) {
     this.inputPlan = inputPlan;
     this.#outputPlan = outputPlan;
     this.#aggregates = aggregates;
     this.#groupAliases = groupAliases;
     this.keyAlias = keyAlias;
-    this.#rows = rows;
+    this.#contributions = contributions;
+    this.#revision = contributions.revision;
+    this.#pending = pending;
+    this.#bytes = bytes;
     this.#groups = groups;
     this.#domains = domains;
     this.#schema = schema;
@@ -38,7 +50,7 @@ class LiveAggregate {
       if (grouped !== void 0)
         return { kind: "column", reference: grouped };
       if (expression.kind === "call" && hasAggregate(expression)) {
-        if (!["COUNT", "SUM", "AVG"].includes(expression.name) || expression.arguments.length !== 1)
+        if (!["COUNT", "SUM", "AVG"].includes(expression.name) || expression.arguments.length !== 1 || expression.distinct === true)
           throw new TypeError("Not an additive live aggregate");
         const argument = expression.arguments[0];
         if (argument === void 0 || !(rowLocal(argument) || expression.name === "COUNT" && argument.kind === "wildcard"))
@@ -102,11 +114,17 @@ class LiveAggregate {
     }
   }
   patch(result, changed, token) {
-    const rows = new Map(this.#rows);
+    if (this.#pending !== void 0 || this.#revision !== this.#contributions.revision)
+      throw new Error("Unaccepted or stale aggregate");
+    const rows = this.#contributions.rows;
+    const pending = /* @__PURE__ */ new Map();
+    let bytes = this.#bytes;
     const groups = new Map(this.#groups);
     const touched = /* @__PURE__ */ new Set();
     const groupFor = (key, keys = []) => {
       let group = groups.get(key);
+      if (group !== void 0 && !touched.has(key))
+        bytes -= groupBytes(key, group);
       if (group === void 0) {
         group = {
           keys,
@@ -158,15 +176,20 @@ class LiveAggregate {
       if (old === void 0)
         continue;
       apply(groupFor(old.group), old.values, -1);
-      rows.delete(key);
+      pending.set(key, void 0);
+      bytes -= contributionBytes(key, old);
     }
     for (const row of result.rows) {
       const key = token(row[this.keyAlias] ?? null);
+      if (pending.get(key) !== void 0 || rows.has(key) && !changed.has(key))
+        throw new TypeError("Duplicate live input key");
       const keys = this.#groupAliases.map((alias) => row[alias] ?? null);
       const group = JSON.stringify(keys.map(encodeSqlEqualityValue));
       const values = this.#aggregates.map(({ alias }) => row[alias] ?? null);
       apply(groupFor(group, keys), values, 1);
-      rows.set(key, { group, values });
+      const contribution = { group, values };
+      pending.set(key, contribution);
+      bytes += contributionBytes(key, contribution);
     }
     if (this.#groupAliases.length === 0)
       groupFor("[]");
@@ -174,17 +197,37 @@ class LiveAggregate {
       for (const key of touched)
         if (groups.get(key)?.members === 0)
           groups.delete(key);
+    for (const key of touched) {
+      const group = groups.get(key);
+      if (group !== void 0)
+        bytes += groupBytes(key, group);
+    }
     const domains = this.#aggregates.map(({ alias }, index) => result.columnDomains[result.columns.indexOf(alias)] ?? this.#domains[index] ?? null);
-    return new LiveAggregate(this.inputPlan, this.#outputPlan, this.#aggregates, this.#groupAliases, this.keyAlias, rows, groups, domains, result.columns.map((name, index) => {
+    return new LiveAggregate(this.inputPlan, this.#outputPlan, this.#aggregates, this.#groupAliases, this.keyAlias, this.#contributions, groups, domains, result.columns.map((name, index) => {
       const domain = result.columnDomains[index];
       const value = result.rows.find((row) => row[name] !== null)?.[name];
       const aggregate = this.#aggregates.find((item) => item.alias === name);
       return {
         name,
-        type: aggregate?.name === "COUNT" ? "number" : domain !== null && domain !== void 0 ? "string" : typeof value === "number" ? "number" : typeof value === "boolean" ? "boolean" : value instanceof Date ? "datetime" : "string",
+        type: aggregate?.name === "COUNT" ? "number" : domain !== null && domain !== void 0 ? "string" : typeof value === "number" ? "number" : typeof value === "boolean" ? "boolean" : value instanceof Date ? "datetime" : value === void 0 || value === null ? this.#schema[index]?.type ?? "string" : "string",
         ...domain === null || domain === void 0 || aggregate?.name === "COUNT" ? {} : { sqlDomain: domain }
       };
-    }));
+    }), bytes, pending);
+  }
+  accept() {
+    const pending = this.#pending;
+    if (pending === void 0)
+      return;
+    if (this.#revision !== this.#contributions.revision)
+      throw new Error("Stale aggregate");
+    for (const [key, contribution] of pending) {
+      if (contribution === void 0)
+        this.#contributions.rows.delete(key);
+      else
+        this.#contributions.rows.set(key, contribution);
+    }
+    this.#revision = ++this.#contributions.revision;
+    this.#pending = void 0;
   }
   result() {
     const rows = [];
@@ -213,12 +256,7 @@ class LiveAggregate {
     return externalizeQueryResult(result);
   }
   get retainedBytes() {
-    let bytes = 256 + encodeQueryIdentity(this.inputPlan).length * 2 + encodeQueryIdentity(this.#outputPlan).length * 2;
-    for (const [key, row] of this.#rows)
-      bytes += 64 + key.length * 2 + row.group.length * 2 + row.values.reduce((sum, value) => sum + (typeof value === "string" ? value.length * 2 + 16 : 16), 0);
-    for (const [key, group] of this.#groups)
-      bytes += 96 + key.length * 2 + group.sums.reduce((sum, value) => sum + value.length * 2 + 24, 0);
-    return bytes;
+    return this.#bytes;
   }
 }
 export {

package/dist/engine/live.d.ts

@@ -169,6 +169,8 @@ export interface LiveQueryHost {
     dependencyTableIds(query: LiveQueryInput, probe?: CatalogProbe): Promise<Set<string>>;
     /** Executes the statement; the returned result belongs to the set and is never shared. */
     execute(query: LiveQueryInput, context?: LiveQueryExecuteContext): Promise<QueryResult>;
+    /** Optionally publishes an accepted result for adapters that re-execute after invalidation. */
+    memoize?(query: LiveQueryInput, result: QueryResult, probe: CatalogProbe): Promise<void>;
     /**
      * Executes a statement the host can later maintain incrementally, or returns undefined when
      * the statement's shape rules that out; the set then executes it in full from then on.