@arcote.tech/arc-host 0.7.14 → 0.7.15

package/src/middleware/ws.ts

@@ -1,19 +1,122 @@
-import { ScopedModel } from "@arcote.tech/arc";
+import {
+  ScopedModel,
+  ScopedStore,
+  checkItemMatchesWhere,
+  type CommittedChange,
+} from "@arcote.tech/arc";
+import type { ConnectionManager } from "../connection-manager";
 import { filterEventsForTokens } from "../event-auth";
-import type { ConnectedClient } from "../types";
+import type { ConnectedClient, HostToClientMessage } from "../types";
 import type { ArcWsContext, ArcWsHandler } from "./types";
 
 // ---------------------------------------------------------------------------
-// View subscription tracking (per client)
+// View replica 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.
 // ---------------------------------------------------------------------------
 
-const clientViewSubs = new Map<string, Map<string, () => void>>();
+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>>();
 
 export function cleanupClientSubs(clientId: string): void {
-  const subs = clientViewSubs.get(clientId);
-  if (subs) {
-    for (const unsub of subs.values()) unsub();
-    clientViewSubs.delete(clientId);
+  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);
+    }
   }
 }
 
@@ -45,6 +148,10 @@ export function syncEventsHandler(): ArcWsHandler {
   return async (client, message, ctx) => {
     if (message.type !== "sync-events") return false;
 
+    // NOTE: sync-events alone does NOT mark the client as local-mode —
+    // streaming clients also push their optimistic mutations through it.
+    // Only request-sync (local-mode catch-up) sets `wantsEventSync`.
+
     const allTokens = ctx.connectionManager.getAllScopeTokens(client.id);
     const token = allTokens.length > 0 ? allTokens[0] : null;
 
@@ -55,9 +162,10 @@ export function syncEventsHandler(): ArcWsHandler {
     );
     if (persisted.length === 0) return true;
 
-    // Broadcast to other authorized clients
+    // Broadcast to other authorized LOCAL-MODE clients
     for (const c of ctx.connectionManager.getAllClients()) {
       if (c.id === client.id) continue;
+      if (!c.wantsEventSync) continue;
       const clientTokens = ctx.connectionManager.getAllScopeTokens(c.id);
       const authorized = filterEventsForTokens(
         clientTokens,
@@ -90,6 +198,10 @@ export function requestSyncHandler(): ArcWsHandler {
   return async (client, message, ctx) => {
     if (message.type !== "request-sync") return false;
 
+    // Only local-mode clients request the event log (streaming clients use
+    // view replicas) — mark so domain-event broadcasts reach this client.
+    client.wantsEventSync = true;
+
     const allTokens = ctx.connectionManager.getAllScopeTokens(client.id);
     const token = allTokens.length > 0 ? allTokens[0] : null;
     const events = await ctx.contextHandler.getEventsSince(
@@ -155,96 +267,110 @@ export function executeCommandHandler(): ArcWsHandler {
 }
 
 // ---------------------------------------------------------------------------
-// subscribe-view / unsubscribe-view — with scope-aware token selection
+// subscribe-view / unsubscribe-view — view replica subscriptions
 // ---------------------------------------------------------------------------
 
-export function querySubscriptionHandler(): ArcWsHandler {
+export function viewSubscriptionHandler(): ArcWsHandler {
   return async (client, message, ctx) => {
-    if (message.type === "subscribe-query") {
-      const { subscriptionId, descriptor, scope } = message;
+    if (message.type === "subscribe-view") {
+      const { element: elementName } = message;
+      const scope: string = message.scope ?? "default";
 
       // Pick the token matching the requested scope
-      const scopeToken = scope ? client.scopeTokens.get(scope) : null;
+      const scopeToken = client.scopeTokens.get(scope) ?? null;
       let rawToken = scopeToken?.raw ?? null;
 
-      // Fallback to first available token if no scope specified
+      // Fallback to first available token if no scope match
       if (!rawToken && client.scopeTokens.size > 0) {
         rawToken = client.scopeTokens.values().next().value!.raw;
       }
 
-      // Per-request scoped model with the right token
-      const scoped = new ScopedModel(ctx.contextHandler.getModel(), scope ?? "default");
+      // Scoped model just to resolve restrictions for this token
+      const scoped = new ScopedModel(ctx.contextHandler.getModel(), scope);
       if (rawToken) scoped.setToken(rawToken);
 
-      // Cache last result to avoid re-sending unchanged data
-      let lastResultJson = "";
-
-      const sendData = async () => {
-        try {
-          const data = await scoped.callQuery(descriptor);
-          const json = JSON.stringify(data ?? null);
-          if (json === lastResultJson) return; // No change — skip
-          lastResultJson = json;
-          ctx.connectionManager.sendToClient(client.id, {
-            type: "query-data",
-            subscriptionId,
-            data: data ?? null,
-          } as any);
-        } catch (err) {
-          console.error(`[Arc] Query subscription error:`, err);
-        }
-      };
-
-      // Initial data
-      sendData();
-
-      // Subscribe to SPECIFIC event types this element handles (namespaced keys)
-      const element = ctx.contextHandler.getModel().context.get(descriptor.element);
-      const handlers = (element as any)?.getHandlers?.();
-      const eventTypes: string[] = handlers ? Object.keys(handlers) : [];
+      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;
+      }
 
-      let debounceTimer: ReturnType<typeof setTimeout> | undefined;
-      const debouncedSend = () => {
-        if (debounceTimer) clearTimeout(debounceTimer);
-        debounceTimer = setTimeout(() => sendData(), 50);
-      };
+      const { restrictions, denied } = element.getRestrictionsFor(
+        scoped.getAdapters(),
+      );
 
-      const unsubscribes: (() => void)[] = [];
-      if (eventTypes.length > 0) {
-        for (const eventType of eventTypes) {
-          unsubscribes.push(
-            ctx.contextHandler.getEventPublisher().subscribe(eventType, debouncedSend),
-          );
-        }
-      } else {
-        // Fallback to wildcard if no event types declared
-        unsubscribes.push(
-          ctx.contextHandler.getEventPublisher().subscribe("*", debouncedSend),
-        );
+      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;
       }
 
-      const cleanup = () => {
-        if (debounceTimer) clearTimeout(debounceTimer);
-        for (const unsub of unsubscribes) unsub();
+      // 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());
+      }
+      viewSubscribers.get(elementName)!.set(subKey, subscriber);
+
+      try {
+        const store = ctx.contextHandler
+          .getDataStorage()
+          .getStore<any>(elementName);
+        const items = restrictions
+          ? await new ScopedStore(store, restrictions, false).find({})
+          : await store.find({});
+
+        ctx.connectionManager.sendToClient(client.id, {
+          type: "view-snapshot",
+          element: elementName,
+          scope,
+          items,
+        });
+      } catch (err) {
+        viewSubscribers.get(elementName)?.delete(subKey);
+        console.error(`[Arc] View subscription error (${elementName}):`, err);
+        ctx.connectionManager.sendToClient(client.id, {
+          type: "error",
+          message: `Failed to subscribe to view "${elementName}"`,
+        });
+        return true;
+      }
 
-      // Track for cleanup on disconnect
-      if (!clientViewSubs.has(client.id)) {
-        clientViewSubs.set(client.id, new Map());
+      // 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,
+        });
       }
-      clientViewSubs.get(client.id)!.set(subscriptionId, cleanup);
       return true;
     }
 
-    if (message.type === "unsubscribe-query") {
-      const subs = clientViewSubs.get(client.id);
-      if (subs) {
-        const unsub = subs.get(message.subscriptionId);
-        if (unsub) {
-          unsub();
-          subs.delete(message.subscriptionId);
-        }
-      }
+    if (message.type === "unsubscribe-view") {
+      const scope: string = message.scope ?? "default";
+      viewSubscribers.get(message.element)?.delete(`${client.id}:${scope}`);
       return true;
     }
 
@@ -262,6 +388,6 @@ export function arcWsHandlers(): ArcWsHandler[] {
     syncEventsHandler(),
     requestSyncHandler(),
     executeCommandHandler(),
-    querySubscriptionHandler(),
+    viewSubscriptionHandler(),
   ];
 }

package/src/types.ts

@@ -42,6 +42,12 @@ export interface ConnectedClient {
   lastHostEventId: string | null;
   /** WebSocket instance */
   ws: any;
+  /**
+   * True for local-mode clients (they sent request-sync / sync-events).
+   * Only these receive domain-event broadcasts — streaming clients are
+   * served by view snapshots + deltas instead.
+   */
+  wantsEventSync?: boolean;
 }
 
 /**
@@ -104,14 +110,14 @@ export type ClientToHostMessage =
       token: string;
     }
   | {
-      type: "subscribe-query";
-      subscriptionId: string;
-      descriptor: { element: string; method: string; args: any[] };
-      scope?: string;
+      type: "subscribe-view";
+      element: string;
+      scope: string;
     }
   | {
-      type: "unsubscribe-query";
-      subscriptionId: string;
+      type: "unsubscribe-view";
+      element: string;
+      scope: string;
     };
 
 /**
@@ -137,7 +143,17 @@ export type HostToClientMessage =
       message: string;
     }
   | {
-      type: "query-data";
-      subscriptionId: string;
-      data: any[];
+      type: "view-snapshot";
+      element: string;
+      scope: string;
+      items: any[];
+    }
+  | {
+      type: "view-changes";
+      element: string;
+      scope: string;
+      changes: Array<
+        | { type: "set"; id: string; item: any }
+        | { type: "delete"; id: string; item: null }
+      >;
     };