@minnowdb/core 0.7.8 → 0.7.10

package/dist/engine/typed-live.d.ts

@@ -1,7 +1,10 @@
-import type { LiveQueryInput, LiveQueryObserveOptions } from "./live.js";
+import type { LiveQueryInput, LiveQueryObserveOptions, LiveQuerySubscribeOptions } from "./live.js";
+import type { QueryResult } from "./query.js";
 /** The structural live-query surface shared by MinnowDatabase and its worker client. */
 export interface LiveQueryBackend {
     observe(query: LiveQueryInput, options: LiveQueryObserveOptions): Promise<LiveQuerySubscriptionLike>;
+    /** Result delivery, used when the source can decode the engine's result itself. */
+    subscribe?(query: LiveQueryInput, options: LiveQuerySubscribeOptions): Promise<LiveQuerySubscriptionLike>;
     refresh(): Promise<void>;
     close(): void | Promise<void>;
 }
@@ -22,6 +25,14 @@ export interface LiveQueryDriver {
 export interface LiveQuerySource<out TRow> {
     readonly query: LiveQueryInput;
     execute(signal?: AbortSignal): Promise<readonly TRow[]>;
+    /**
+     * Turns a result the engine delivered into the adapter's rows. With it, the query subscribes
+     * for results rather than invalidations: the engine executes or patches the statement where
+     * the data is, compares, and hands over a changed result once — over a worker channel, as
+     * one columnar transfer — and `execute` is never called after the statement is registered.
+     * Without it, an invalidation is followed by `execute`, which the engine's memo serves.
+     */
+    decode?(result: QueryResult): readonly TRow[] | Promise<readonly TRow[]>;
 }
 export type LiveSnapshot<TRow> = {
     readonly status: "loading";

package/dist/engine/typed-live.js

@@ -1,6 +1,26 @@
 import { sameLiveValue } from "./live-equal.js";
-function immutableRows(rows) {
-  return Object.freeze([...rows]);
+function reconcileRows(previous, next, retained) {
+  const rows = new Array(next.length);
+  let changed = previous.length !== next.length;
+  const provenance = retained?.length === next.length ? retained : void 0;
+  for (let index = 0; index < next.length; index += 1) {
+    const row = next[index];
+    const was = provenance?.[index] ?? -1;
+    if (was >= 0 && was < previous.length) {
+      rows[index] = previous[was];
+      if (was !== index)
+        changed = true;
+      continue;
+    }
+    const before = previous[index];
+    if (index < previous.length && sameLiveValue(before, row))
+      rows[index] = before;
+    else {
+      rows[index] = row;
+      changed = true;
+    }
+  }
+  return changed ? Object.freeze(rows) : void 0;
 }
 class LiveQuery {
   #listeners = /* @__PURE__ */ new Set();
@@ -11,6 +31,9 @@ class LiveQuery {
   #subscription;
   #observationGeneration = 0;
   #queued;
+  #lastDelivered;
+  #deliveriesReceived = 0;
+  #rowsFromDelivery = 0;
   #execution;
   #executionAbort;
   #invalidationSequence = 0;
@@ -52,10 +75,24 @@ class LiveQuery {
     }
     if (this.#invalidationSequence === sequence) {
       const version = this.#snapshot.status === "loading" ? null : this.#snapshot.version;
-      this.#schedule({ manifestVersion: version, catalogEpoch: 0, initial: false });
+      if (this.#decodes()) {
+        const last = this.#lastDelivered;
+        if (this.#snapshot.status === "error" && last !== void 0)
+          this.#schedule(last);
+      } else
+        this.#schedule({ manifestVersion: version, catalogEpoch: 0, initial: false });
     }
     await this.#waitForIdle();
   }
+  #decodes() {
+    return this.#source.decode !== void 0 && this.#backend.subscribe !== void 0;
+  }
+  async #decodeDelivered(result) {
+    const source = this.#source;
+    if (source.decode === void 0)
+      throw new TypeError("Live query source lost its decoder");
+    return source.decode(result);
+  }
   close() {
     if (this.#closed)
       return;
@@ -75,7 +112,36 @@ class LiveQuery {
     if (this.#subscription !== void 0 || this.#closed)
       return;
     const generation = this.#observationGeneration += 1;
+    if (this.#source.decode !== void 0 && this.#backend.subscribe !== void 0) {
+      const subscription2 = this.#backend.subscribe(this.#source.query, {
+        onChange: (result, delivery) => {
+          if (generation !== this.#observationGeneration || this.#closed)
+            return;
+          this.#deliveriesReceived += 1;
+          this.#schedule({ result, delivery, sequence: this.#deliveriesReceived });
+        },
+        onError: (error) => {
+          if (generation !== this.#observationGeneration || this.#closed)
+            return;
+          this.#setError(error, this.#currentVersion());
+        },
+        onComplete: () => {
+          if (generation !== this.#observationGeneration)
+            return;
+          this.#subscription = void 0;
+        }
+      });
+      this.#subscription = subscription2;
+      subscription2.catch((error) => {
+        if (generation !== this.#observationGeneration || this.#closed)
+          return;
+        this.#subscription = void 0;
+        this.#setError(error, this.#currentVersion());
+      });
+      return;
+    }
     const subscription = this.#backend.observe(this.#source.query, {
+      suppressUnchanged: true,
       onInvalidate: (invalidation) => {
         if (generation !== this.#observationGeneration || this.#closed)
           return;
@@ -109,9 +175,9 @@ class LiveQuery {
       void subscription.then((handle) => handle.close()).catch(() => void 0);
     }
   }
-  #schedule(invalidation) {
+  #schedule(work) {
     this.#invalidationSequence += 1;
-    this.#queued = invalidation;
+    this.#queued = work;
     if (this.#execution !== void 0)
       return;
     const execution = this.#drain();
@@ -125,24 +191,35 @@ class LiveQuery {
   }
   async #drain() {
     while (this.#queued !== void 0 && !this.#closed) {
-      const invalidation = this.#queued;
+      const work = this.#queued;
       this.#queued = void 0;
       const abort = new AbortController();
       this.#executionAbort = abort;
+      const invalidation = "result" in work ? work.delivery : work;
       try {
-        const rows = immutableRows(await this.#source.execute(abort.signal));
+        let executed;
+        if ("result" in work) {
+          this.#lastDelivered = work;
+          executed = await this.#decodeDelivered(work.result);
+          this.#lastDelivered = void 0;
+        } else
+          executed = await this.#source.execute(abort.signal);
         if (this.#executionWasCancelled(abort))
           continue;
         if (this.#hasQueuedInvalidation())
           continue;
         const previous = this.#snapshot.rows;
-        if (this.#snapshot.status === "ready" && this.#snapshot.version === invalidation.manifestVersion && sameLiveValue(previous, rows)) {
-          continue;
-        }
-        if (sameLiveValue(previous, rows) && this.#snapshot.status !== "loading") {
+        const provenance = "result" in work && this.#rowsFromDelivery === work.sequence - 1 ? work.delivery.retained : void 0;
+        const rows = reconcileRows(previous, executed, provenance);
+        if ("result" in work)
+          this.#rowsFromDelivery = work.sequence;
+        if (rows === void 0) {
+          if (this.#snapshot.status === "ready" && this.#snapshot.version === invalidation.manifestVersion) {
+            continue;
+          }
           this.#snapshot = {
             status: "ready",
-            rows: previous,
+            rows: this.#snapshot.status === "loading" ? Object.freeze([...previous]) : previous,
             version: invalidation.manifestVersion
           };
         } else {

package/dist/engine/worker-server.js

@@ -379,7 +379,8 @@ class DatabaseRpcServer {
         try {
           set = this.database.liveQueries({
             ...channelName === void 0 ? {} : { channelName },
-            ...pollIntervalMs === void 0 ? {} : { pollIntervalMs }
+            ...pollIntervalMs === void 0 ? {} : { pollIntervalMs },
+            sharedResults: true
           });
           this.#publishHandle(handleId, { type: "live-set", set, subscriptionIds: /* @__PURE__ */ new Set() });
         } catch (error) {
@@ -667,11 +668,15 @@ class DatabaseRpcServer {
         let subscription;
         try {
           subscription = await handle.set.subscribe(query, {
-            onChange: (result) => {
+            onChange: (result, delivery) => {
               const encoded = encodeQueryResult(result);
-              this.scope.postMessage(rpcEvent(subscriptionId, "change", encoded.payload), {
-                transfer: encoded.transfer
-              });
+              const retained = delivery.retained?.slice();
+              if (retained !== void 0)
+                encoded.transfer.push(retained.buffer);
+              this.scope.postMessage(rpcEvent(subscriptionId, "change", {
+                result: encoded.payload,
+                delivery: retained === void 0 ? delivery : { ...delivery, retained }
+              }), { transfer: encoded.transfer });
             },
             onError: (error) => {
               this.scope.postMessage(rpcEvent(subscriptionId, "error", serializeError(error)));
@@ -700,9 +705,11 @@ class DatabaseRpcServer {
       case "observe": {
         const subscriptionId = this.#claimHandleId(args[0]);
         const query = args[1];
+        const { suppressUnchanged } = args[2] ?? {};
         let subscription;
         try {
           subscription = await handle.set.observe(query, {
+            ...suppressUnchanged === true ? { suppressUnchanged: true } : {},
             onInvalidate: (invalidation) => {
               this.scope.postMessage(rpcEvent(subscriptionId, "invalidate", invalidation));
             },

package/dist/worker-protocol/index.d.ts

@@ -1,4 +1,4 @@
-export declare const protocolVersion: 4;
+export declare const protocolVersion: 6;
 /** Outstanding request/response pairs retained by either side of one database RPC connection. */
 export declare const MAX_DATABASE_RPC_IN_FLIGHT = 256;
 export type RpcRequest = {

package/dist/worker-protocol/index.js

@@ -1,4 +1,4 @@
-const protocolVersion = 4;
+const protocolVersion = 6;
 const MAX_DATABASE_RPC_IN_FLIGHT = 256;
 function serializeError(error) {
   if (!(error instanceof Error)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@minnowdb/core",
-  "version": "0.7.8",
+  "version": "0.7.10",
   "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",