fixup! Push SSE history updates to non-owner viewers

Author: mvdbeek

client/src/api/schema/schema.ts

@@ -1292,6 +1292,31 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/api/events/history-subscriptions": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Subscribe to history_update SSE events for histories you don't own.
+         * @description Asks every webapp worker to start routing ``history_update`` events
+         *     for these histories to the requesting user/session, in addition to the
+         *     default owner-routing. Idempotent: re-subscribing to the same id is a
+         *     no-op. Clients re-send the full set after each ``EventSource.onopen``
+         *     so reconnects don't drop subscriptions.
+         */
+        post: operations["subscribe_history_viewer_api_events_history_subscriptions_post"];
+        /** Cancel viewer subscriptions for these histories. */
+        delete: operations["unsubscribe_history_viewer_api_events_history_subscriptions_delete"];
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/api/events/stream": {
         parameters: {
             query?: never;
@@ -15433,6 +15458,14 @@ export interface components {
              */
             url: string;
         };
+        /**
+         * HistoryViewerSubscriptionPayload
+         * @description REST payload for ``/api/events/history-subscriptions`` endpoints.
+         */
+        HistoryViewerSubscriptionPayload: {
+            /** History Ids */
+            history_ids: string[];
+        };
         /**
          * Hyperlink
          * @description Represents some text with an Hyperlink.
@@ -33478,6 +33511,92 @@ export interface operations {
             };
         };
     };
+    subscribe_history_viewer_api_events_history_subscriptions_post: {
+        parameters: {
+            query?: never;
+            header?: {
+                /** @description The user ID that will be used to effectively make this API call. Only admins and designated users can make API calls on behalf of other users. */
+                "run-as"?: string | null;
+            };
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["HistoryViewerSubscriptionPayload"];
+            };
+        };
+        responses: {
+            /** @description Successful Response */
+            204: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Request Error */
+            "4XX": {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["MessageExceptionModel"];
+                };
+            };
+            /** @description Server Error */
+            "5XX": {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["MessageExceptionModel"];
+                };
+            };
+        };
+    };
+    unsubscribe_history_viewer_api_events_history_subscriptions_delete: {
+        parameters: {
+            query?: never;
+            header?: {
+                /** @description The user ID that will be used to effectively make this API call. Only admins and designated users can make API calls on behalf of other users. */
+                "run-as"?: string | null;
+            };
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["HistoryViewerSubscriptionPayload"];
+            };
+        };
+        responses: {
+            /** @description Successful Response */
+            204: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Request Error */
+            "4XX": {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["MessageExceptionModel"];
+                };
+            };
+            /** @description Server Error */
+            "5XX": {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["MessageExceptionModel"];
+                };
+            };
+        };
+    };
     stream_events_api_events_stream_get: {
         parameters: {
             query?: never;

client/src/components/History/Multiple/MultipleViewItem.vue

@@ -6,12 +6,9 @@ import { storeToRefs } from "pinia";
 import { computed, ref, watch } from "vue";
 
 import { userOwnsHistory } from "@/api";
+import { useConfig } from "@/composables/config";
 import { useExtendedHistory } from "@/composables/detailedHistory";
-import {
-    addHistoryViewerSubscription,
-    removeHistoryViewerSubscription,
-} from "@/composables/useNotificationSSE";
-import { useConfigStore } from "@/stores/configurationStore";
+import { addHistoryViewerSubscription, removeHistoryViewerSubscription } from "@/composables/useNotificationSSE";
 import { useHistoryStore } from "@/stores/historyStore";
 import { useUserStore } from "@/stores/userStore";
 
@@ -32,7 +29,7 @@ const props = defineProps<Props>();
 const historyStore = useHistoryStore();
 const { currentHistoryId, pinnedHistories } = storeToRefs(historyStore);
 const { currentUser } = storeToRefs(useUserStore());
-const configStore = useConfigStore();
+const { config } = useConfig();
 
 const { history } = useExtendedHistory(props.source.id);
 
@@ -46,7 +43,7 @@ const sameToCurrent = computed(() => {
 // histories need a viewer subscription. Skip in polling mode — there's no
 // SSE channel to push events to and the REST call would still hit the queue.
 const needsViewerSubscription = computed(() => {
-    if (!configStore.config?.enable_sse_updates) {
+    if (!config.value?.enable_sse_updates) {
         return false;
     }
     if (!history.value || !currentUser.value) {

client/src/composables/useNotificationSSE.test.ts

@@ -7,6 +7,7 @@
  * into the (test-only) onopen replay path.
  */
 
+import flushPromises from "flush-promises";
 import { http, HttpResponse } from "msw";
 import { afterEach, beforeEach, describe, expect, it } from "vitest";
 
@@ -51,7 +52,7 @@ describe("useNotificationSSE viewer subscriptions", () => {
 
     it("POSTs once per first subscriber for a given history id", async () => {
         addHistoryViewerSubscription("hist-A");
-        await Promise.resolve();
+        await flushPromises();
         expect(requests).toHaveLength(1);
         expect(requests[0]?.method).toBe("POST");
         expect(requests[0]?.history_ids).toEqual(["hist-A"]);
@@ -60,39 +61,39 @@ describe("useNotificationSSE viewer subscriptions", () => {
     it("refcounts duplicate subscriptions — second add is a no-op on the wire", async () => {
         addHistoryViewerSubscription("hist-A");
         addHistoryViewerSubscription("hist-A");
-        await Promise.resolve();
+        await flushPromises();
         expect(requests.filter((r) => r.method === "POST")).toHaveLength(1);
     });
 
     it("only DELETEs when the last subscriber for an id releases", async () => {
         addHistoryViewerSubscription("hist-A");
         addHistoryViewerSubscription("hist-A");
-        await Promise.resolve();
+        await flushPromises();
         const postCount = requests.filter((r) => r.method === "POST").length;
 
         removeHistoryViewerSubscription("hist-A");
-        await Promise.resolve();
+        await flushPromises();
         // First remove still has one outstanding refcount — must not DELETE yet.
         expect(requests.filter((r) => r.method === "DELETE")).toHaveLength(0);
         expect(requests.filter((r) => r.method === "POST")).toHaveLength(postCount);
 
         removeHistoryViewerSubscription("hist-A");
-        await Promise.resolve();
+        await flushPromises();
         const deletes = requests.filter((r) => r.method === "DELETE");
         expect(deletes).toHaveLength(1);
         expect(deletes[0]?.history_ids).toEqual(["hist-A"]);
     });
 
     it("ignores unsubscribes for ids that were never subscribed", async () => {
         removeHistoryViewerSubscription("hist-never");
-        await Promise.resolve();
+        await flushPromises();
         expect(requests).toHaveLength(0);
     });
 
     it("tracks distinct history ids independently", async () => {
         addHistoryViewerSubscription("hist-A");
         addHistoryViewerSubscription("hist-B");
-        await Promise.resolve();
+        await flushPromises();
         const ids = requests.filter((r) => r.method === "POST").map((r) => r.history_ids[0]);
         expect(new Set(ids)).toEqual(new Set(["hist-A", "hist-B"]));
     });

lib/galaxy/webapps/galaxy/api/events.py

@@ -31,6 +31,7 @@ class HistoryViewerSubscriptionPayload(BaseModel):
 
     history_ids: list[str]
 
+
 log = logging.getLogger(__name__)
 
 router = Router(tags=["events"])