@rindle/client 0.1.5 → 0.2.0

package/src/types.ts

@@ -3,6 +3,8 @@
 // Cells cross the boundary BARE (the host has a typed schema, so per-column types are
 // known here, not per-cell). JSON columns cross as their raw JSON string.
 
+import type { Ast } from "./ast.ts";
+
 /** A bare wire cell. (JSON columns arrive as their raw JSON string.) */
 export type WireValue = number | string | boolean | null;
 
@@ -143,8 +145,9 @@ export interface Backend {
   unregisterQuery(queryId: QueryId): void;
   /** Optional split path for local-first backends: retain/release a named remote footprint
    *  without creating another local materialized view. `localQueryId`, when provided, names
-   *  the local AST view this remote footprint feeds. */
-  retainRemoteQuery?(queryId: QueryId, remote: RemoteQuery, localQueryId?: QueryId): void;
+   *  the local AST view this remote footprint feeds. `ast`, when provided, gives the backend
+   *  the local schema context for sync-only retains that still need aggregate/table setup. */
+  retainRemoteQuery?(queryId: QueryId, remote: RemoteQuery, localQueryId?: QueryId, ast?: Ast): void;
   releaseRemoteQuery?(queryId: QueryId): void;
   /** Local: applies now (changes flow back on the stream). Remote: sends to the server. */
   mutate(mutations: Mutation[]): Promise<void>;

package/src/view.ts

@@ -124,6 +124,10 @@ function cloneNode(n: Node): Node {
   return { row: n.row.slice(), rc: n.rc, rels: n.rels.map((r) => r.map(cloneNode)), out: null };
 }
 
+function rowsEqual(a: WireValue[], b: WireValue[]): boolean {
+  return a.length === b.length && a.every((v, i) => Object.is(v, b[i]));
+}
+
 const EMPTY: readonly never[] = Object.freeze([]);
 
 export class FlatArrayView<R = unknown> implements ArrayView<R> {
@@ -189,7 +193,9 @@ export class FlatArrayView<R = unknown> implements ArrayView<R> {
    *  while pending (changes never precede the `hello` that resets the schema). */
   applyChanges(events: FlatChange[]): void {
     if (this.schema === null) return;
-    for (const e of events) this.applyAt(this.top, this.schema, e.path, e.op, 0);
+    let changed = false;
+    for (const e of events) changed = this.applyAt(this.top, this.schema, e.path, e.op, 0) || changed;
+    if (!changed) return;
     this.dirty = true;
     this.notify();
   }
@@ -217,41 +223,50 @@ export class FlatArrayView<R = unknown> implements ArrayView<R> {
 
   // --- apply -------------------------------------------------------------------
 
-  private applyAt(list: Node[], schema: WireSchema, path: FlatChange["path"], op: FlatOp, depth: number): void {
+  private applyAt(list: Node[], schema: WireSchema, path: FlatChange["path"], op: FlatOp, depth: number): boolean {
     if (depth === path.length) {
-      this.applyOp(list, schema, op);
-      return;
+      return this.applyOp(list, schema, op);
     }
     const seg = path[depth];
     const child = schema.relationships[seg.rel]?.child;
-    if (!child) return; // in-view gate: a gating slot drops the whole change
+    if (!child) return false; // in-view gate: a gating slot drops the whole change
     const { found, index } = binarySearch(list, seg.parentRow, schema.sort);
     if (!found) throw new Error("flat ArrayView: parent not found at path hop (inconsistent stream)");
     const node = list[index];
-    node.out = null; // a descendant changed → this node must re-project its rel array
-    this.applyAt(node.rels[seg.rel], child, path, op, depth + 1);
+    const changed = this.applyAt(node.rels[seg.rel], child, path, op, depth + 1);
+    if (changed) node.out = null; // a descendant changed → this node must re-project its rel array
+    return changed;
   }
 
-  private applyOp(list: Node[], schema: WireSchema, op: FlatOp): void {
-    if (op.tag === "add") this.applyAdd(list, schema, op.node);
-    else if (op.tag === "remove") this.applyRemove(list, schema, op.row);
-    else this.applyEdit(list, schema, op.old, op.new);
+  private applyOp(list: Node[], schema: WireSchema, op: FlatOp): boolean {
+    if (op.tag === "add") return this.applyAdd(list, schema, op.node);
+    if (op.tag === "remove") return this.applyRemove(list, schema, op.row);
+    return this.applyEdit(list, schema, op.old, op.new);
   }
 
-  private applyAdd(list: Node[], schema: WireSchema, wnode: WireNode): void {
+  private applyAdd(list: Node[], schema: WireSchema, wnode: WireNode): boolean {
     const at = binarySearch(list, wnode.row, schema.sort);
-    if (at.found) list[at.index].rc += 1; // duplicate path to an existing row; ignore subtree
-    else list.splice(at.index, 0, buildNode(wnode, schema));
+    if (at.found) {
+      list[at.index].rc += 1; // duplicate path to an existing row; ignore subtree
+      return false;
+    }
+    list.splice(at.index, 0, buildNode(wnode, schema));
+    return true;
   }
 
-  private applyRemove(list: Node[], schema: WireSchema, row: WireValue[]): void {
+  private applyRemove(list: Node[], schema: WireSchema, row: WireValue[]): boolean {
     const at = binarySearch(list, row, schema.sort);
     if (!at.found) throw new Error("flat ArrayView: remove of a non-existent node");
-    if (list[at.index].rc === 1) list.splice(at.index, 1);
-    else list[at.index].rc -= 1;
+    if (list[at.index].rc === 1) {
+      list.splice(at.index, 1);
+      return true;
+    }
+    list[at.index].rc -= 1;
+    return false;
   }
 
-  private applyEdit(list: Node[], schema: WireSchema, oldRow: WireValue[], newRow: WireValue[]): void {
+  private applyEdit(list: Node[], schema: WireSchema, oldRow: WireValue[], newRow: WireValue[]): boolean {
+    if (rowsEqual(oldRow, newRow)) return false;
     const sort = schema.sort;
     if (compareRows(oldRow, newRow, sort) === 0) {
       // Sort key unchanged → edit in place (keeps position + children + rc).
@@ -259,7 +274,7 @@ export class FlatArrayView<R = unknown> implements ArrayView<R> {
       if (!at.found) throw new Error("flat ArrayView: edit of a non-existent node");
       list[at.index].row = newRow;
       list[at.index].out = null;
-      return;
+      return true;
     }
 
     // Sort key changed → the row may move; rc may be > 1.
@@ -276,7 +291,7 @@ export class FlatArrayView<R = unknown> implements ArrayView<R> {
     if (oldRc === 1 && (pos === oldPos || pos - 1 === oldPos)) {
       list[oldPos].row = newRow;
       list[oldPos].out = null;
-      return;
+      return true;
     }
 
     // General move.
@@ -301,6 +316,7 @@ export class FlatArrayView<R = unknown> implements ArrayView<R> {
       oldEntry.rc = 1;
       list.splice(adjusted, 0, oldEntry);
     }
+    return true;
   }
 
   // --- projection (memoized, structurally shared) -----------------------------