@arcote.tech/arc 0.7.10 → 0.7.12

package/dist/index.js

@@ -2491,7 +2491,11 @@ class ArcCommand extends ArcContextElement {
       if (!adapters.commandWire) {
         throw new Error(`Command "${this.data.name}" has no handler and no commandWire adapter available for remote execution`);
       }
-      return await adapters.commandWire.executeCommand(this.data.name, params);
+      const wireAuth = adapters.scope ? {
+        scope: adapters.scope.scopeName,
+        token: adapters.scope.getToken()
+      } : undefined;
+      return await adapters.commandWire.executeCommand(this.data.name, params, wireAuth);
     };
     return Object.assign(executeFunc, { params: this.data.params });
   }
@@ -4597,6 +4601,7 @@ class StreamingQueryCache {
   views = [];
   activeStreams = new Map;
   pendingUnsubscribes = new Map;
+  streamScopes = new Map;
   static UNSUBSCRIBE_DELAY_MS = 5000;
   registerViews(views) {
     this.views = views;
@@ -4655,6 +4660,7 @@ class StreamingQueryCache {
         if (current && current.refCount <= 0) {
           current.unsubscribe();
           this.activeStreams.delete(viewName);
+          this.streamScopes.delete(viewName);
         }
       }, StreamingQueryCache.UNSUBSCRIBE_DELAY_MS);
       this.pendingUnsubscribes.set(viewName, timeout);
@@ -4662,6 +4668,8 @@ class StreamingQueryCache {
   }
   subscribeQuery(descriptor, eventWire, scope) {
     const key = descriptor.element;
+    if (scope)
+      this.streamScopes.set(key, scope);
     const { unsubscribe } = this.registerStream(key, () => {
       const subId = eventWire.subscribeQuery(descriptor, (data) => {
         this.setViewData(descriptor.element, data);
@@ -4670,6 +4678,28 @@ class StreamingQueryCache {
     });
     return unsubscribe;
   }
+  invalidateScope(scope) {
+    for (const [viewName, viewScope] of this.streamScopes) {
+      if (viewScope !== scope)
+        continue;
+      const pending = this.pendingUnsubscribes.get(viewName);
+      if (pending) {
+        clearTimeout(pending);
+        this.pendingUnsubscribes.delete(viewName);
+      }
+      const stream = this.activeStreams.get(viewName);
+      if (stream) {
+        try {
+          stream.unsubscribe();
+        } catch {}
+        this.activeStreams.delete(viewName);
+      }
+      this.streamScopes.delete(viewName);
+      const store = this.stores.get(viewName);
+      if (store)
+        store.clear();
+    }
+  }
   setViewData(viewName, data) {
     const store = this.stores.get(viewName);
     if (!store)
@@ -4717,6 +4747,11 @@ class StreamingQueryCache {
       stream.unsubscribe();
     }
     this.activeStreams.clear();
+    this.streamScopes.clear();
+    for (const timeout of this.pendingUnsubscribes.values()) {
+      clearTimeout(timeout);
+    }
+    this.pendingUnsubscribes.clear();
     for (const store of this.stores.values()) {
       store.clear();
     }

package/dist/streaming/streaming-query-cache.d.ts

@@ -38,6 +38,15 @@ export declare class StreamingQueryCache {
     private views;
     private activeStreams;
     private pendingUnsubscribes;
+    /**
+     * Tag each active stream with the scope name that subscribed it. Used by
+     * `invalidateScope()` to force-close streams when a scope's token changes
+     * (workspace switch / re-auth) — without this tag, `registerStream()` would
+     * reuse the stale WS subscription (refCount > 0, or within the
+     * UNSUBSCRIBE_DELAY_MS grace window) and the client would keep receiving
+     * data filtered by the previous token.
+     */
+    private streamScopes;
     private static UNSUBSCRIBE_DELAY_MS;
     /**
      * Register views that this cache will handle
@@ -83,6 +92,23 @@ export declare class StreamingQueryCache {
         method: string;
         args: any[];
     }, eventWire: EventWire, scope?: string): () => void;
+    /**
+     * Force-close every active stream tagged with `scope`. Called when a
+     * scope's token changes (workspace switch / re-auth) so the next
+     * `subscribeQuery()` creates a fresh WS subscription with the new token
+     * instead of reusing the stale one (which would keep pumping data filtered
+     * by the previous token until the page reload).
+     *
+     * Bypasses both `refCount` (other subscribers still mounted) and the
+     * UNSUBSCRIBE_DELAY_MS grace window — both became invalid the moment the
+     * token changed. React's `useQuery` re-subscribes immediately afterwards
+     * via the `subKey` change (token is in the key), getting a fresh stream.
+     *
+     * Bonus: each affected store is also cleared so any in-progress render
+     * that reads `store.find()` between `setToken` and the new WS data
+     * arriving gets `[]` rather than stale rows from the previous workspace.
+     */
+    invalidateScope(scope: string): void;
     /**
      * Set data for a view. Accepts array or single item (from queryMethod findOne).
      */

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@arcote.tech/arc",
   "type": "module",
-  "version": "0.7.10",
+  "version": "0.7.12",
   "private": false,
   "author": "Przemysław Krasiński [arcote.tech]",
   "description": "Arc framework core rewrite with improved event emission and type safety",