@arcote.tech/arc-host 0.7.14 → 0.7.15

package/dist/index.js

@@ -4677,88 +4677,6 @@ function queryHandler(ch) {
     }
   };
 }
-var streamIdCounter = 0;
-var streamConnections = new Map;
-function streamHandler(ch) {
-  return (_req, url, ctx) => {
-    if (!url.pathname.startsWith("/stream/") || _req.method !== "GET")
-      return null;
-    const viewName = url.pathname.split("/stream/")[1];
-    if (!viewName) {
-      return new Response("Invalid stream path", {
-        status: 400,
-        headers: ctx.corsHeaders
-      });
-    }
-    const findOptions = {};
-    const whereParam = url.searchParams.get("where");
-    if (whereParam) {
-      try {
-        findOptions.where = JSON.parse(whereParam);
-      } catch {
-        return new Response("Invalid 'where' parameter", {
-          status: 400,
-          headers: ctx.corsHeaders
-        });
-      }
-    }
-    const orderByParam = url.searchParams.get("orderBy");
-    if (orderByParam) {
-      try {
-        findOptions.orderBy = JSON.parse(orderByParam);
-      } catch {
-        return new Response("Invalid 'orderBy' parameter", {
-          status: 400,
-          headers: ctx.corsHeaders
-        });
-      }
-    }
-    const limitParam = url.searchParams.get("limit");
-    if (limitParam)
-      findOptions.limit = parseInt(limitParam, 10);
-    const streamId = `stream_${++streamIdCounter}_${Date.now()}`;
-    const rawToken = ctx.rawToken;
-    const stream = new ReadableStream({
-      start(controller) {
-        const scoped = new ScopedModel2(ch.getModel(), "stream");
-        if (rawToken)
-          scoped.setToken(rawToken);
-        const descriptor = { element: viewName, method: "find", args: [findOptions] };
-        const sendData = async () => {
-          try {
-            const data = await scoped.callQuery(descriptor);
-            controller.enqueue(new TextEncoder().encode(`data: ${JSON.stringify({ type: "data", data })}
-
-`));
-          } catch {
-            unsubscribe();
-          }
-        };
-        sendData();
-        const unsubscribe = ch.getEventPublisher().subscribe("*", () => sendData());
-        streamConnections.set(streamId, { id: streamId, controller, unsubscribe });
-        controller.enqueue(new TextEncoder().encode(`data: ${JSON.stringify({ type: "connected", streamId })}
-
-`));
-      },
-      cancel() {
-        const conn = streamConnections.get(streamId);
-        if (conn) {
-          conn.unsubscribe();
-          streamConnections.delete(streamId);
-        }
-      }
-    });
-    return new Response(stream, {
-      headers: {
-        ...ctx.corsHeaders,
-        "Content-Type": "text/event-stream",
-        "Cache-Control": "no-cache",
-        Connection: "keep-alive"
-      }
-    });
-  };
-}
 function eventSyncHandler(ch) {
   return async (req, url, ctx) => {
     if (url.pathname !== "/sync/events" || req.method !== "POST")
@@ -4859,25 +4777,71 @@ function arcHttpHandlers(ch, cm) {
     healthHandler(cm),
     commandHandler(ch),
     queryHandler(ch),
-    streamHandler(ch),
     eventSyncHandler(ch),
     routeHandler(ch)
   ];
 }
-function cleanupStreams() {
-  for (const conn of streamConnections.values())
-    conn.unsubscribe();
-  streamConnections.clear();
-}
 // src/middleware/ws.ts
-import { ScopedModel as ScopedModel3 } from "@arcote.tech/arc";
-var clientViewSubs = new Map;
+import {
+  ScopedModel as ScopedModel3,
+  ScopedStore,
+  checkItemMatchesWhere
+} from "@arcote.tech/arc";
+var viewSubscribers = new Map;
 function cleanupClientSubs(clientId) {
-  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);
+    }
+  }
+}
+function filterChangeForSubscriber(change, restrictions) {
+  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;
+}
+function broadcastViewChanges(committed, connectionManager) {
+  const byStore = new Map;
+  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 = [];
+      for (const change of changes) {
+        const wireChange = filterChangeForSubscriber(change, sub.restrictions);
+        if (wireChange)
+          filtered.push(wireChange);
+      }
+      if (filtered.length === 0)
+        continue;
+      if (sub.buffer) {
+        sub.buffer.push(...filtered);
+        continue;
+      }
+      connectionManager.sendToClient(sub.clientId, {
+        type: "view-changes",
+        element: viewName,
+        scope: sub.scope,
+        changes: filtered
+      });
+    }
   }
 }
 function scopeAuthHandler() {
@@ -4903,6 +4867,8 @@ function syncEventsHandler() {
     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, persisted, ctx.contextHandler.getEventDefinitions());
       if (authorized.length > 0) {
@@ -4925,6 +4891,7 @@ function requestSyncHandler() {
   return async (client, message, ctx) => {
     if (message.type !== "request-sync")
       return false;
+    client.wantsEventSync = true;
     const allTokens = ctx.connectionManager.getAllScopeTokens(client.id);
     const token = allTokens.length > 0 ? allTokens[0] : null;
     const events = await ctx.contextHandler.getEventsSince(message.lastHostEventId, token);
@@ -4973,74 +4940,82 @@ function executeCommandHandler() {
     return true;
   };
 }
-function querySubscriptionHandler() {
+function viewSubscriptionHandler() {
   return async (client, message, ctx) => {
-    if (message.type === "subscribe-query") {
-      const { subscriptionId, descriptor, scope } = message;
-      const scopeToken = scope ? client.scopeTokens.get(scope) : null;
+    if (message.type === "subscribe-view") {
+      const { element: elementName } = message;
+      const scope = message.scope ?? "default";
+      const scopeToken = client.scopeTokens.get(scope) ?? null;
       let rawToken = scopeToken?.raw ?? null;
       if (!rawToken && client.scopeTokens.size > 0) {
         rawToken = client.scopeTokens.values().next().value.raw;
       }
-      const scoped = new ScopedModel3(ctx.contextHandler.getModel(), scope ?? "default");
+      const scoped = new ScopedModel3(ctx.contextHandler.getModel(), scope);
       if (rawToken)
         scoped.setToken(rawToken);
-      let lastResultJson = "";
-      const sendData = async () => {
-        try {
-          const data = await scoped.callQuery(descriptor);
-          const json = JSON.stringify(data ?? null);
-          if (json === lastResultJson)
-            return;
-          lastResultJson = json;
-          ctx.connectionManager.sendToClient(client.id, {
-            type: "query-data",
-            subscriptionId,
-            data: data ?? null
-          });
-        } catch (err) {
-          console.error(`[Arc] Query subscription error:`, err);
-        }
-      };
-      sendData();
-      const element = ctx.contextHandler.getModel().context.get(descriptor.element);
-      const handlers = element?.getHandlers?.();
-      const eventTypes = handlers ? Object.keys(handlers) : [];
-      let debounceTimer;
-      const debouncedSend = () => {
-        if (debounceTimer)
-          clearTimeout(debounceTimer);
-        debounceTimer = setTimeout(() => sendData(), 50);
-      };
-      const unsubscribes = [];
-      if (eventTypes.length > 0) {
-        for (const eventType of eventTypes) {
-          unsubscribes.push(ctx.contextHandler.getEventPublisher().subscribe(eventType, debouncedSend));
-        }
-      } else {
-        unsubscribes.push(ctx.contextHandler.getEventPublisher().subscribe("*", debouncedSend));
+      const element = ctx.contextHandler.getModel().context.get(elementName);
+      if (!element || typeof element.getRestrictionsFor !== "function") {
+        ctx.connectionManager.sendToClient(client.id, {
+          type: "error",
+          message: `Cannot subscribe to view "${elementName}": unknown element`
+        });
+        return true;
       }
-      const cleanup = () => {
-        if (debounceTimer)
-          clearTimeout(debounceTimer);
-        for (const unsub of unsubscribes)
-          unsub();
+      const { restrictions, denied } = element.getRestrictionsFor(scoped.getAdapters());
+      const subKey = `${client.id}:${scope}`;
+      if (denied) {
+        viewSubscribers.get(elementName)?.delete(subKey);
+        ctx.connectionManager.sendToClient(client.id, {
+          type: "view-snapshot",
+          element: elementName,
+          scope,
+          items: []
+        });
+        return true;
+      }
+      const subscriber = {
+        clientId: client.id,
+        scope,
+        restrictions,
+        buffer: []
       };
-      if (!clientViewSubs.has(client.id)) {
-        clientViewSubs.set(client.id, new Map);
+      if (!viewSubscribers.has(elementName)) {
+        viewSubscribers.set(elementName, new Map);
+      }
+      viewSubscribers.get(elementName).set(subKey, subscriber);
+      try {
+        const store = ctx.contextHandler.getDataStorage().getStore(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;
+      }
+      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 = message.scope ?? "default";
+      viewSubscribers.get(message.element)?.delete(`${client.id}:${scope}`);
       return true;
     }
     return false;
@@ -5052,7 +5027,7 @@ function arcWsHandlers() {
     syncEventsHandler(),
     requestSyncHandler(),
     executeCommandHandler(),
-    querySubscriptionHandler()
+    viewSubscriptionHandler()
   ];
 }
 // src/create-server.ts
@@ -5065,6 +5040,7 @@ async function createArcServer(config) {
   const cronScheduler = new CronScheduler(contextHandler);
   cronScheduler.start();
   const connectionManager = new ConnectionManager;
+  contextHandler.getEventPublisher().onViewChanges((changes) => broadcastViewChanges(changes, connectionManager));
   function buildCorsHeaders(req) {
     const origin = req?.headers.get("Origin") || "*";
     return {
@@ -5235,7 +5211,6 @@ async function createArcServer(config) {
     cronScheduler,
     stop: () => {
       cronScheduler.stop();
-      cleanupStreams();
       server.stop();
     }
   };
@@ -5248,12 +5223,11 @@ function hostLiveModel(context, dbAdapterFactory) {
   });
 }
 export {
+  viewSubscriptionHandler,
   syncEventsHandler,
-  streamHandler,
   scopeAuthHandler,
   routeHandler,
   requestSyncHandler,
-  querySubscriptionHandler,
   queryHandler,
   hostLiveModel,
   healthHandler,
@@ -5263,10 +5237,10 @@ export {
   eventSyncHandler,
   createArcServer,
   commandHandler,
-  cleanupStreams,
   cleanupClientSubs,
   canTokenReceiveEvent,
   canTokenEmitEvent,
+  broadcastViewChanges,
   arcWsHandlers,
   arcHttpHandlers,
   CronScheduler,
@@ -5274,5 +5248,5 @@ export {
   ConnectionManager
 };
 
-//# debugId=D9115398B339A37F64756E2164756E21
+//# debugId=094B6B350E52DB8A64756E2164756E21
 //# sourceMappingURL=index.js.map