@arcote.tech/arc-host 0.7.15 → 0.7.16

package/src/middleware/ws.ts

@@ -1,122 +1,23 @@
-import {
-  ScopedModel,
-  ScopedStore,
-  checkItemMatchesWhere,
-  type CommittedChange,
-} from "@arcote.tech/arc";
-import type { ConnectionManager } from "../connection-manager";
+import { LiveQuery } from "@arcote.tech/arc";
 import { filterEventsForTokens } from "../event-auth";
-import type { ConnectedClient, HostToClientMessage } from "../types";
-import type { ArcWsContext, ArcWsHandler } from "./types";
+import type { ArcWsHandler } from "./types";
 
 // ---------------------------------------------------------------------------
-// View replica subscriptions
+// Live query subscriptions
 //
-// One entry per (view, client, scope). Restrictions are resolved ONCE at
-// subscribe time (token changes invalidate the subscription client-side and
-// re-subscribe). Deltas committed between registration and the snapshot send
-// are buffered and flushed after the snapshot — sets/deletes are idempotent,
-// so replaying a delta the snapshot already contains is harmless.
+// One LiveQuery per (client, subscriptionId). ALL query logic — execution,
+// token restrictions, change detection, delta computation — lives in core's
+// LiveQuery (query layer); this module only forwards its updates over WS.
 // ---------------------------------------------------------------------------
 
-type WireViewChange =
-  | { type: "set"; id: string; item: any }
-  | { type: "delete"; id: string; item: null };
-
-interface ViewSubscriber {
-  clientId: string;
-  scope: string;
-  restrictions: Record<string, unknown> | null;
-  /** Non-null while the snapshot is being read/sent — deltas land here. */
-  buffer: WireViewChange[] | null;
-}
-
-/** viewName → `${clientId}:${scope}` → subscriber */
-const viewSubscribers = new Map<string, Map<string, ViewSubscriber>>();
+/** clientId → subscriptionId → LiveQuery */
+const clientQuerySubs = new Map<string, Map<string, LiveQuery>>();
 
 export function cleanupClientSubs(clientId: string): void {
-  const prefix = `${clientId}:`;
-  for (const subs of viewSubscribers.values()) {
-    for (const key of subs.keys()) {
-      if (key.startsWith(prefix)) subs.delete(key);
-    }
-  }
-}
-
-/**
- * Filter a committed change for one subscriber:
- * - new row matches → `set` with the full row
- * - only old row matched → `delete` (item left the subscriber's slice)
- * - neither → nothing (not in this tenant's slice; no id leakage)
- */
-export function filterChangeForSubscriber(
-  change: CommittedChange,
-  restrictions: Record<string, unknown> | null,
-): WireViewChange | null {
-  const newMatches =
-    change.newRow !== null &&
-    (restrictions === null || checkItemMatchesWhere(change.newRow, restrictions));
-  if (newMatches) {
-    return { type: "set", id: change.id, item: change.newRow };
-  }
-  const oldMatches =
-    change.oldRow !== null &&
-    (restrictions === null || checkItemMatchesWhere(change.oldRow, restrictions));
-  if (oldMatches) {
-    return { type: "delete", id: change.id, item: null };
-  }
-  return null;
-}
-
-/**
- * Broadcast committed view deltas to subscribed clients. Wired to
- * `LocalEventPublisher.onViewChanges` in create-server — fires after each
- * successful publish commit, regardless of the event's origin
- * (execute-command, client sync-events, server-side listeners).
- *
- * One `view-changes` message per (commit × view × client); empty results
- * are skipped entirely.
- */
-export function broadcastViewChanges(
-  committed: CommittedChange[],
-  connectionManager: ConnectionManager,
-): void {
-  // Group by view store, preserving commit order
-  const byStore = new Map<string, CommittedChange[]>();
-  for (const change of committed) {
-    let list = byStore.get(change.store);
-    if (!list) {
-      list = [];
-      byStore.set(change.store, list);
-    }
-    list.push(change);
-  }
-
-  for (const [viewName, changes] of byStore) {
-    const subs = viewSubscribers.get(viewName);
-    if (!subs || subs.size === 0) continue;
-
-    for (const sub of subs.values()) {
-      const filtered: WireViewChange[] = [];
-      for (const change of changes) {
-        const wireChange = filterChangeForSubscriber(change, sub.restrictions);
-        if (wireChange) filtered.push(wireChange);
-      }
-      if (filtered.length === 0) continue;
-
-      if (sub.buffer) {
-        // Snapshot in-flight — flushed right after it is sent
-        sub.buffer.push(...filtered);
-        continue;
-      }
-
-      connectionManager.sendToClient(sub.clientId, {
-        type: "view-changes",
-        element: viewName,
-        scope: sub.scope,
-        changes: filtered,
-      } as HostToClientMessage);
-    }
+  const subs = clientQuerySubs.get(clientId);
+  if (subs) {
+    for (const live of subs.values()) live.stop();
+    clientQuerySubs.delete(clientId);
   }
 }
 
@@ -267,13 +168,13 @@ export function executeCommandHandler(): ArcWsHandler {
 }
 
 // ---------------------------------------------------------------------------
-// subscribe-view / unsubscribe-view — view replica subscriptions
+// subscribe-query / unsubscribe-query — live query subscriptions
 // ---------------------------------------------------------------------------
 
-export function viewSubscriptionHandler(): ArcWsHandler {
+export function querySubscriptionHandler(): ArcWsHandler {
   return async (client, message, ctx) => {
-    if (message.type === "subscribe-view") {
-      const { element: elementName } = message;
+    if (message.type === "subscribe-query") {
+      const { subscriptionId, descriptor } = message;
       const scope: string = message.scope ?? "default";
 
       // Pick the token matching the requested scope
@@ -285,92 +186,68 @@ export function viewSubscriptionHandler(): ArcWsHandler {
         rawToken = client.scopeTokens.values().next().value!.raw;
       }
 
-      // Scoped model just to resolve restrictions for this token
-      const scoped = new ScopedModel(ctx.contextHandler.getModel(), scope);
-      if (rawToken) scoped.setToken(rawToken);
+      // Re-subscribe with the same id (reconnect resend) — drop the old one
+      clientQuerySubs.get(client.id)?.get(subscriptionId)?.stop();
 
-      const element = ctx.contextHandler.getModel().context.get(elementName) as any;
-      if (!element || typeof element.getRestrictionsFor !== "function") {
-        ctx.connectionManager.sendToClient(client.id, {
-          type: "error",
-          message: `Cannot subscribe to view "${elementName}": unknown element`,
-        });
-        return true;
-      }
-
-      const { restrictions, denied } = element.getRestrictionsFor(
-        scoped.getAdapters(),
+      const live = new LiveQuery(
+        ctx.contextHandler.getModel(),
+        descriptor,
+        scope,
+        rawToken,
+        (update) => {
+          if (update.type === "changes") {
+            ctx.connectionManager.sendToClient(client.id, {
+              type: "query-changes",
+              subscriptionId,
+              changes: update.changes,
+            });
+          } else {
+            ctx.connectionManager.sendToClient(client.id, {
+              type: "query-snapshot",
+              subscriptionId,
+              result: update.result ?? null,
+            });
+          }
+        },
       );
 
-      const subKey = `${client.id}:${scope}`;
-
-      if (denied) {
-        // No access — empty snapshot, no registration (token change
-        // re-subscribes via invalidateScope on the client)
-        viewSubscribers.get(elementName)?.delete(subKey);
-        ctx.connectionManager.sendToClient(client.id, {
-          type: "view-snapshot",
-          element: elementName,
-          scope,
-          items: [],
-        });
-        return true;
-      }
-
-      // Register FIRST (buffering deltas) so changes committed while the
-      // snapshot is being read are not lost; flushed after the snapshot.
-      const subscriber: ViewSubscriber = {
-        clientId: client.id,
-        scope,
-        restrictions,
-        buffer: [],
-      };
-      if (!viewSubscribers.has(elementName)) {
-        viewSubscribers.set(elementName, new Map());
+      if (!clientQuerySubs.has(client.id)) {
+        clientQuerySubs.set(client.id, new Map());
       }
-      viewSubscribers.get(elementName)!.set(subKey, subscriber);
+      clientQuerySubs.get(client.id)!.set(subscriptionId, live);
 
       try {
-        const store = ctx.contextHandler
-          .getDataStorage()
-          .getStore<any>(elementName);
-        const items = restrictions
-          ? await new ScopedStore(store, restrictions, false).find({})
-          : await store.find({});
-
+        const result = await live.start();
         ctx.connectionManager.sendToClient(client.id, {
-          type: "view-snapshot",
-          element: elementName,
-          scope,
-          items,
+          type: "query-snapshot",
+          subscriptionId,
+          result: result ?? null,
         });
+        // Catch-up pass AFTER the snapshot went out — diffs out any commit
+        // that slipped into the initial-execute window.
+        live.flush();
       } catch (err) {
-        viewSubscribers.get(elementName)?.delete(subKey);
-        console.error(`[Arc] View subscription error (${elementName}):`, err);
+        live.stop();
+        clientQuerySubs.get(client.id)?.delete(subscriptionId);
+        console.error(
+          `[Arc] Query subscription error (${descriptor?.element}.${descriptor?.method}):`,
+          err,
+        );
         ctx.connectionManager.sendToClient(client.id, {
           type: "error",
-          message: `Failed to subscribe to view "${elementName}"`,
-        });
-        return true;
-      }
-
-      // Go live: flush deltas buffered during the snapshot read
-      const buffered = subscriber.buffer!;
-      subscriber.buffer = null;
-      if (buffered.length > 0) {
-        ctx.connectionManager.sendToClient(client.id, {
-          type: "view-changes",
-          element: elementName,
-          scope,
-          changes: buffered,
+          message: `Failed to subscribe to query "${descriptor?.element}.${descriptor?.method}"`,
         });
       }
       return true;
     }
 
-    if (message.type === "unsubscribe-view") {
-      const scope: string = message.scope ?? "default";
-      viewSubscribers.get(message.element)?.delete(`${client.id}:${scope}`);
+    if (message.type === "unsubscribe-query") {
+      const subs = clientQuerySubs.get(client.id);
+      const live = subs?.get(message.subscriptionId);
+      if (live) {
+        live.stop();
+        subs!.delete(message.subscriptionId);
+      }
       return true;
     }
 
@@ -388,6 +265,6 @@ export function arcWsHandlers(): ArcWsHandler[] {
     syncEventsHandler(),
     requestSyncHandler(),
     executeCommandHandler(),
-    viewSubscriptionHandler(),
+    querySubscriptionHandler(),
   ];
 }

package/src/types.ts

@@ -110,14 +110,14 @@ export type ClientToHostMessage =
       token: string;
     }
   | {
-      type: "subscribe-view";
-      element: string;
-      scope: string;
+      type: "subscribe-query";
+      subscriptionId: string;
+      descriptor: { element: string; method: string; args: any[] };
+      scope?: string;
     }
   | {
-      type: "unsubscribe-view";
-      element: string;
-      scope: string;
+      type: "unsubscribe-query";
+      subscriptionId: string;
     };
 
 /**
@@ -143,17 +143,15 @@ export type HostToClientMessage =
       message: string;
     }
   | {
-      type: "view-snapshot";
-      element: string;
-      scope: string;
-      items: any[];
+      type: "query-snapshot";
+      subscriptionId: string;
+      result: any;
     }
   | {
-      type: "view-changes";
-      element: string;
-      scope: string;
+      type: "query-changes";
+      subscriptionId: string;
       changes: Array<
-        | { type: "set"; id: string; item: any }
-        | { type: "delete"; id: string; item: null }
+        | { type: "set"; id: string; item: any; index: number }
+        | { type: "delete"; id: string }
       >;
     };

package/dist/src/middleware/view-subscription.integration.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=view-subscription.integration.test.d.ts.map

package/dist/src/middleware/view-subscription.integration.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"view-subscription.integration.test.d.ts","sourceRoot":"","sources":["../../../src/middleware/view-subscription.integration.test.ts"],"names":[],"mappings":""}

package/dist/src/middleware/ws.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=ws.test.d.ts.map

package/dist/src/middleware/ws.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ws.test.d.ts","sourceRoot":"","sources":["../../../src/middleware/ws.test.ts"],"names":[],"mappings":""}

package/src/middleware/view-subscription.integration.test.ts

@@ -1,307 +0,0 @@
-import { beforeEach, describe, expect, it } from "bun:test";
-import {
-  LocalEventPublisher,
-  MasterDataStorage,
-  context,
-  token,
-  view,
-} from "@arcote.tech/arc";
-import type { ConnectedClient } from "../types";
-import {
-  broadcastViewChanges,
-  cleanupClientSubs,
-  viewSubscriptionHandler,
-} from "./ws";
-
-// ---------------------------------------------------------------------------
-// Test rig: real MasterDataStorage + LocalEventPublisher + ws handler,
-// in-memory DB adapter, fake connection manager collecting messages.
-// Covers the full server pipeline: subscribe-view → snapshot → publish →
-// commit → onViewChanges → per-subscriber filtered view-changes.
-// ---------------------------------------------------------------------------
-
-function memoryAdapter() {
-  const tables = new Map<string, Map<string, any>>();
-  const table = (s: string) => {
-    if (!tables.has(s)) tables.set(s, new Map());
-    return tables.get(s)!;
-  };
-  const tx = {
-    async find(store: string, options: any) {
-      const rows = Array.from(table(store).values());
-      const where = options?.where;
-      if (!where) return rows;
-      return rows.filter((r) =>
-        Object.entries(where).every(([k, v]) => r[k] === v),
-      );
-    },
-    async set(store: string, data: any) {
-      table(store).set(data._id, structuredClone(data));
-    },
-    async remove(store: string, id: any) {
-      table(store).delete(String(id));
-    },
-    async commit() {},
-  };
-  return {
-    readWriteTransaction: () => tx,
-    readTransaction: () => tx,
-    executeReinitTables: async () => {},
-  } as any;
-}
-
-const wsToken = token("workspace", {});
-
-const tasksView = view("tasksView", null as any, {} as any)
-  .handle({
-    "task.created": async (ctx: any, event: any) => {
-      await ctx.set(event.payload.taskId, {
-        title: event.payload.title,
-        workspaceId: event.payload.workspaceId,
-      });
-    },
-    "task.moved": async (ctx: any, event: any) => {
-      await ctx.modify(event.payload.taskId, { workspaceId: event.payload.to });
-    },
-    "task.removed": async (ctx: any, event: any) => {
-      await ctx.remove(event.payload.taskId);
-    },
-  })
-  .protectBy(wsToken as any, (p: any) => ({ workspaceId: p.workspaceId }));
-
-function fakeJwt(tokenName: string, params: Record<string, any>): string {
-  const b64 = (o: any) => Buffer.from(JSON.stringify(o)).toString("base64");
-  return `${b64({ alg: "none" })}.${b64({ tokenName, params })}.sig`;
-}
-
-function fakeClient(
-  id: string,
-  scope: string,
-  tokenName: string,
-  params: Record<string, any>,
-): ConnectedClient {
-  return {
-    id,
-    scopeTokens: new Map([
-      [scope, { decoded: { tokenType: tokenName, params }, raw: fakeJwt(tokenName, params) }],
-    ]),
-    lastHostEventId: null,
-    ws: null,
-  };
-}
-
-let eventCounter = 0;
-function makeEvent(type: string, payload: any) {
-  return {
-    id: `evt_${++eventCounter}`,
-    type,
-    payload,
-    createdAt: new Date(0),
-    authContext: null,
-  } as any;
-}
-
-function rig() {
-  const storage = new MasterDataStorage(memoryAdapter());
-  const testContext = context([tasksView as any]);
-  const fakeModel = {
-    context: testContext,
-    getAdapters: () => ({ dataStorage: storage }),
-    getEnvironment: () => "server" as const,
-  };
-
-  const sent: Array<{ clientId: string; message: any }> = [];
-  const connectionManager = {
-    sendToClient: (clientId: string, message: any) => {
-      sent.push({ clientId, message });
-      return true;
-    },
-  } as any;
-
-  const wsCtx = {
-    contextHandler: {
-      getModel: () => fakeModel,
-      getDataStorage: () => storage,
-    },
-    connectionManager,
-    verifyToken: () => null,
-  } as any;
-
-  const publisher = new LocalEventPublisher(storage);
-  publisher.registerViews([tasksView as any]);
-  publisher.onViewChanges((changes) =>
-    broadcastViewChanges(changes, connectionManager),
-  );
-
-  const handler = viewSubscriptionHandler();
-  const subscribe = (client: ConnectedClient, scope: string) =>
-    handler(client, { type: "subscribe-view", element: "tasksView", scope }, wsCtx);
-
-  const messagesFor = (clientId: string, type?: string) =>
-    sent
-      .filter((s) => s.clientId === clientId)
-      .map((s) => s.message)
-      .filter((m) => (type ? m.type === type : true));
-
-  return { storage, publisher, subscribe, handler, wsCtx, sent, messagesFor };
-}
-
-let clientSeq = 0;
-const uid = (p: string) => `${p}_${++clientSeq}`;
-
-describe("view subscriptions — end-to-end host pipeline", () => {
-  beforeEach(() => {
-    // module-level registry — drop anything previous tests left behind
-    for (let i = 0; i <= clientSeq; i++) {
-      cleanupClientSubs(`A_${i}`);
-      cleanupClientSubs(`B_${i}`);
-      cleanupClientSubs(`X_${i}`);
-    }
-  });
-
-  it("snapshot contains ONLY the subscriber's slice of the view", async () => {
-    const r = rig();
-    await r.publisher.publish(
-      makeEvent("task.created", { taskId: "t1", title: "Mine", workspaceId: "w1" }),
-    );
-    await r.publisher.publish(
-      makeEvent("task.created", { taskId: "t2", title: "Theirs", workspaceId: "w2" }),
-    );
-
-    const a = fakeClient(uid("A"), "workspace", "workspace", { workspaceId: "w1" });
-    await r.subscribe(a, "workspace");
-
-    const snapshots = r.messagesFor(a.id, "view-snapshot");
-    expect(snapshots).toHaveLength(1);
-    expect(snapshots[0].element).toBe("tasksView");
-    expect(snapshots[0].scope).toBe("workspace");
-    expect(snapshots[0].items).toHaveLength(1);
-    expect(snapshots[0].items[0]).toMatchObject({ _id: "t1", title: "Mine" });
-  });
-
-  it("publish → set delta to the owning tenant ONLY (no message to others)", async () => {
-    const r = rig();
-    const a = fakeClient(uid("A"), "workspace", "workspace", { workspaceId: "w1" });
-    const b = fakeClient(uid("B"), "workspace", "workspace", { workspaceId: "w2" });
-    await r.subscribe(a, "workspace");
-    await r.subscribe(b, "workspace");
-    r.sent.length = 0;
-
-    await r.publisher.publish(
-      makeEvent("task.created", { taskId: "t1", title: "New", workspaceId: "w1" }),
-    );
-
-    const toA = r.messagesFor(a.id, "view-changes");
-    expect(toA).toHaveLength(1);
-    expect(toA[0].changes).toEqual([
-      {
-        type: "set",
-        id: "t1",
-        item: { _id: "t1", title: "New", workspaceId: "w1" },
-      },
-    ]);
-
-    // tenant isolation: B gets NOTHING (not even a delete for a foreign id)
-    expect(r.messagesFor(b.id)).toHaveLength(0);
-  });
-
-  it("scope transition: move w1→w2 emits delete to A and full-item set to B", async () => {
-    const r = rig();
-    await r.publisher.publish(
-      makeEvent("task.created", { taskId: "t1", title: "Task", workspaceId: "w1" }),
-    );
-
-    const a = fakeClient(uid("A"), "workspace", "workspace", { workspaceId: "w1" });
-    const b = fakeClient(uid("B"), "workspace", "workspace", { workspaceId: "w2" });
-    await r.subscribe(a, "workspace");
-    await r.subscribe(b, "workspace");
-    r.sent.length = 0;
-
-    await r.publisher.publish(makeEvent("task.moved", { taskId: "t1", to: "w2" }));
-
-    const toA = r.messagesFor(a.id, "view-changes");
-    expect(toA).toHaveLength(1);
-    expect(toA[0].changes).toEqual([{ type: "delete", id: "t1", item: null }]);
-
-    // B receives the FULL merged item (modify was partial — deepMerge on server)
-    const toB = r.messagesFor(b.id, "view-changes");
-    expect(toB).toHaveLength(1);
-    expect(toB[0].changes).toEqual([
-      {
-        type: "set",
-        id: "t1",
-        item: { _id: "t1", title: "Task", workspaceId: "w2" },
-      },
-    ]);
-  });
-
-  it("remove emits delete only to the tenant that owned the item", async () => {
-    const r = rig();
-    await r.publisher.publish(
-      makeEvent("task.created", { taskId: "t1", title: "Task", workspaceId: "w1" }),
-    );
-    const a = fakeClient(uid("A"), "workspace", "workspace", { workspaceId: "w1" });
-    const b = fakeClient(uid("B"), "workspace", "workspace", { workspaceId: "w2" });
-    await r.subscribe(a, "workspace");
-    await r.subscribe(b, "workspace");
-    r.sent.length = 0;
-
-    await r.publisher.publish(makeEvent("task.removed", { taskId: "t1" }));
-
-    expect(r.messagesFor(a.id, "view-changes")).toHaveLength(1);
-    expect(r.messagesFor(a.id, "view-changes")[0].changes).toEqual([
-      { type: "delete", id: "t1", item: null },
-    ]);
-    expect(r.messagesFor(b.id)).toHaveLength(0);
-  });
-
-  it("token that matches no protection → empty snapshot and no deltas", async () => {
-    const r = rig();
-    await r.publisher.publish(
-      makeEvent("task.created", { taskId: "t1", title: "Task", workspaceId: "w1" }),
-    );
-
-    const x = fakeClient(uid("X"), "workspace", "intruder", {});
-    await r.subscribe(x, "workspace");
-
-    const snapshots = r.messagesFor(x.id, "view-snapshot");
-    expect(snapshots).toHaveLength(1);
-    expect(snapshots[0].items).toEqual([]);
-
-    r.sent.length = 0;
-    await r.publisher.publish(
-      makeEvent("task.created", { taskId: "t2", title: "More", workspaceId: "w1" }),
-    );
-    expect(r.messagesFor(x.id)).toHaveLength(0);
-  });
-
-  it("unsubscribe-view stops deltas", async () => {
-    const r = rig();
-    const a = fakeClient(uid("A"), "workspace", "workspace", { workspaceId: "w1" });
-    await r.subscribe(a, "workspace");
-    await r.handler(
-      a,
-      { type: "unsubscribe-view", element: "tasksView", scope: "workspace" },
-      r.wsCtx,
-    );
-    r.sent.length = 0;
-
-    await r.publisher.publish(
-      makeEvent("task.created", { taskId: "t1", title: "New", workspaceId: "w1" }),
-    );
-    expect(r.messagesFor(a.id)).toHaveLength(0);
-  });
-
-  it("disconnect cleanup stops deltas", async () => {
-    const r = rig();
-    const a = fakeClient(uid("A"), "workspace", "workspace", { workspaceId: "w1" });
-    await r.subscribe(a, "workspace");
-    cleanupClientSubs(a.id);
-    r.sent.length = 0;
-
-    await r.publisher.publish(
-      makeEvent("task.created", { taskId: "t1", title: "New", workspaceId: "w1" }),
-    );
-    expect(r.messagesFor(a.id)).toHaveLength(0);
-  });
-});