@cratis/arc 22.0.2 → 22.1.0

package/queries/QueryResultWithState.ts

@@ -4,14 +4,17 @@
 import { ValidationResult } from '../validation/ValidationResult';
 import { IQueryResult } from './IQueryResult';
 import { PagingInfo } from './PagingInfo';
-import { QueryResult } from './QueryResult';
 import { ChangeSet } from './ChangeSet';
 
 /**
  * Represents a specialized {@link QueryResult<TDataType>} that holds state for its execution
  */
 export class QueryResultWithState<TDataType> implements IQueryResult<TDataType> {
-
+    /**
+     * Creates a settled empty state, such as the state returned by a disabled query.
+     * @param defaultValue The query's empty data value.
+     * @returns A ready state that is not performing.
+     */
     static empty<TDataType>(defaultValue: TDataType): QueryResultWithState<TDataType> {
         return new QueryResultWithState(
             defaultValue,
@@ -23,9 +26,18 @@ export class QueryResultWithState<TDataType> implements IQueryResult<TDataType>
             false,
             [],
             '',
-            false);
+            false,
+            undefined,
+            true,
+        );
     }
 
+    /**
+     * Creates the local initial state before any server result has been received. This state is not ready because
+     * no result exists yet; its performing state independently describes the active client request.
+     * @param defaultValue The query's initial data value.
+     * @returns A not-ready state that is performing.
+     */
     static initial<TDataType>(defaultValue: TDataType): QueryResultWithState<TDataType> {
         return new QueryResultWithState(
             defaultValue,
@@ -37,7 +49,10 @@ export class QueryResultWithState<TDataType> implements IQueryResult<TDataType>
             false,
             [],
             '',
-            true);
+            true,
+            undefined,
+            false,
+        );
     }
 
     /**
@@ -53,6 +68,8 @@ export class QueryResultWithState<TDataType> implements IQueryResult<TDataType>
      * @param {string} exceptionStackTrace Exception stack trace, if any.
      * @param {boolean} isPerforming Whether or not the query is being performed. True if its performing, false if it is done.
      * @param {ChangeSet<unknown> | undefined} changeSet Optional change set from the server describing the delta since the last update.
+     * @param {boolean} isReady Whether the query has produced a result. Defaults to true so existing constructor calls
+     * represent settled synthetic states; {@link initial} explicitly uses false because no server result exists yet.
      */
     constructor(
         readonly data: TDataType,
@@ -65,8 +82,9 @@ export class QueryResultWithState<TDataType> implements IQueryResult<TDataType>
         readonly exceptionMessages: string[],
         readonly exceptionStackTrace: string,
         readonly isPerforming: boolean,
-        readonly changeSet?: ChangeSet<unknown>) {
-    }
+        readonly changeSet?: ChangeSet<unknown>,
+        readonly isReady: boolean = true,
+    ) {}
 
     /** @inheritdoc */
     get hasData(): boolean {
@@ -77,12 +95,15 @@ export class QueryResultWithState<TDataType> implements IQueryResult<TDataType>
     }
 
     /**
-     * Create a new {@link QueryResultWithState<TDataType>} from {@link QueryResult<TDataType>}.
+     * Create a new {@link QueryResultWithState<TDataType>} from an {@link IQueryResult<TDataType>}.
      * @param queryResult The original query result.
      * @param isPerforming Whether or not the query is performing.
      * @returns A new {@link QueryResultWithState<TDataType>}
      */
-    static fromQueryResult<TDataType>(queryResult: QueryResult<TDataType>, isPerforming: boolean) {
+    static fromQueryResult<TDataType>(
+        queryResult: IQueryResult<TDataType>,
+        isPerforming: boolean,
+    ) {
         return new QueryResultWithState<TDataType>(
             queryResult.data,
             queryResult.paging,
@@ -94,6 +115,8 @@ export class QueryResultWithState<TDataType> implements IQueryResult<TDataType>
             queryResult.exceptionMessages,
             queryResult.exceptionStackTrace,
             isPerforming,
-            queryResult.changeSet);
+            queryResult.changeSet,
+            queryResult.isReady ?? true,
+        );
     }
 }

package/queries/ServerSentEventHubConnection.ts

@@ -2,19 +2,24 @@
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
 import { Globals } from '../Globals';
-import { IObservableQueryHubConnection } from './IObservableQueryHubConnection';
-import { DataReceived } from './ObservableQueryConnection';
+import type { IObservableQueryHubConnection } from './IObservableQueryHubConnection';
+import type { DataReceived } from './ObservableQueryConnection';
 import { HubConnectionKeepAlive } from './HubConnectionKeepAlive';
-import { IReconnectPolicy } from './IReconnectPolicy';
+import type { IReconnectPolicy } from './IReconnectPolicy';
 import { ReconnectPolicy } from './ReconnectPolicy';
 import { QueryResult } from './QueryResult';
-import { HubMessage, HubMessageType, SubscriptionRequest } from './WebSocketHubConnection';
+import {
+    type HubMessage,
+    HubMessageType,
+    type SubscriptionRequest,
+} from './WebSocketHubConnection';
 
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
 interface ActiveSubscription {
     request: SubscriptionRequest;
     callback: DataReceived<any>;
+    revision: number;
 }
 
 /**
@@ -46,6 +51,8 @@ export class ServerSentEventHubConnection implements IObservableQueryHubConnecti
     private _lastPongLatency: number = 0;
     private _latencySamples: number[] = [];
     private _connectTimeoutTimer?: ReturnType<typeof setTimeout>;
+    private _nextRevision = 0;
+    private _supportsSubscriptionRevisions = false;
     private readonly _keepAlive: HubConnectionKeepAlive;
 
     /**
@@ -57,7 +64,7 @@ export class ServerSentEventHubConnection implements IObservableQueryHubConnecti
      * @param {number} keepAliveIntervalMs The keep-alive cadence to assume until the server advertises
      *   its own on the {@link HubMessageType.Connected} message (default: 30 000 ms). The connection is
      *   considered stale after {@link IDLE_THRESHOLD_FACTOR} times this without any server message.
-     * @param {number} connectTimeoutMs How long to wait for the {@link HubMessageType.Connected}
+     * @param {number} _connectTimeoutMs How long to wait for the {@link HubMessageType.Connected}
      *   message after the HTTP connection opens before giving up and retrying (default: 15 000 ms).
      * @param {IReconnectPolicy} _policy The reconnect policy to use (default: {@link ReconnectPolicy}).
      */
@@ -68,7 +75,7 @@ export class ServerSentEventHubConnection implements IObservableQueryHubConnecti
         private readonly _microservice: string,
         keepAliveIntervalMs: number = 30000,
         private readonly _connectTimeoutMs: number = 15000,
-        private readonly _policy: IReconnectPolicy = new ReconnectPolicy()
+        private readonly _policy: IReconnectPolicy = new ReconnectPolicy(),
     ) {
         // SSE is server→client only: the client cannot send pings. Instead we watch for
         // inactivity — if the server stops sending messages (including its own keep-alive
@@ -82,12 +89,20 @@ export class ServerSentEventHubConnection implements IObservableQueryHubConnecti
         //
         // The interval below is only the starting assumption; the server advertises its real
         // cadence on the Connected message and {@link handleConnected} reconfigures from it.
-        this._keepAlive = new HubConnectionKeepAlive(keepAliveIntervalMs, () => {
-            if (!this._disconnected && this._subscriptions.size > 0) {
-                console.warn(`SSE hub: no messages received for ${this._keepAlive.idleThresholdMs}ms, reconnecting '${this._sseUrl}'`);
-                this.reconnect();
-            }
-        }, keepAliveIntervalMs * IDLE_THRESHOLD_FACTOR);
+        this._keepAlive = new HubConnectionKeepAlive(
+            keepAliveIntervalMs,
+            () => {
+                if (!this._disconnected && this._subscriptions.size > 0) {
+                    console.warn(
+                        'SSE hub: no messages received; reconnecting',
+                        this._keepAlive.idleThresholdMs,
+                        this._sseUrl,
+                    );
+                    this.reconnect();
+                }
+            },
+            keepAliveIntervalMs * IDLE_THRESHOLD_FACTOR,
+        );
     }
 
     /** @inheritdoc */
@@ -97,7 +112,10 @@ export class ServerSentEventHubConnection implements IObservableQueryHubConnecti
 
     /** @inheritdoc */
     get isConnected(): boolean {
-        return this._connectionId !== undefined && this._eventSource?.readyState === EventSource.OPEN;
+        return (
+            this._connectionId !== undefined &&
+            this._eventSource?.readyState === EventSource.OPEN
+        );
     }
 
     /** @inheritdoc */
@@ -108,18 +126,28 @@ export class ServerSentEventHubConnection implements IObservableQueryHubConnecti
     /** @inheritdoc */
     get averageLatency(): number {
         if (this._latencySamples.length === 0) return 0;
-        return this._latencySamples.reduce((a, b) => a + b, 0) / this._latencySamples.length;
+        return (
+            this._latencySamples.reduce((a, b) => a + b, 0) / this._latencySamples.length
+        );
     }
 
     /** @inheritdoc */
-    subscribe(queryId: string, request: SubscriptionRequest, callback: DataReceived<any>): void {
-        const sub: ActiveSubscription = { request, callback };
+    subscribe(
+        queryId: string,
+        request: SubscriptionRequest,
+        callback: DataReceived<any>,
+    ): void {
+        const sub: ActiveSubscription = {
+            request,
+            callback,
+            revision: this.getNextRevision(),
+        };
         this._subscriptions.set(queryId, sub);
 
         this.ensureConnected();
 
         if (this._connectionId) {
-            this.sendSubscribe(queryId, request);
+            this.sendSubscribe(queryId, sub);
         } else {
             // Not yet connected, queue for when Connected message arrives.
             this._pendingSubscriptions.set(queryId, sub);
@@ -128,11 +156,12 @@ export class ServerSentEventHubConnection implements IObservableQueryHubConnecti
 
     /** @inheritdoc */
     unsubscribe(queryId: string): void {
+        const subscription = this._subscriptions.get(queryId);
         this._subscriptions.delete(queryId);
         this._pendingSubscriptions.delete(queryId);
 
-        if (this._connectionId) {
-            this.sendUnsubscribe(queryId);
+        if (this._connectionId && subscription) {
+            this.sendUnsubscribe(queryId, subscription.revision);
         }
 
         if (this._subscriptions.size === 0) {
@@ -148,11 +177,24 @@ export class ServerSentEventHubConnection implements IObservableQueryHubConnecti
         this._policy.cancel();
         this._keepAlive.stop();
         this.clearConnectTimeout();
-        this._eventSource?.close();
-        this._eventSource = undefined;
+        this.detachAndCloseEventSource();
         this._connectionId = undefined;
     }
 
+    private detachAndCloseEventSource(): void {
+        const eventSource = this._eventSource;
+        if (!eventSource) return;
+
+        eventSource.onopen = null;
+        eventSource.onmessage = null;
+        eventSource.onerror = null;
+        eventSource.close();
+
+        if (this._eventSource === eventSource) {
+            this._eventSource = undefined;
+        }
+    }
+
     private ensureConnected(): void {
         if (this._disconnected) {
             this._disconnected = false;
@@ -162,6 +204,9 @@ export class ServerSentEventHubConnection implements IObservableQueryHubConnecti
             return;
         }
 
+        // An immediate subscription can win while a back-off callback is pending. Cancel that callback before
+        // opening, and let openEventSource perform the same live-source guard for already-queued callbacks.
+        this._policy.cancel();
         this.openEventSource();
     }
 
@@ -170,21 +215,16 @@ export class ServerSentEventHubConnection implements IObservableQueryHubConnecti
         this._policy.cancel();
         this._keepAlive.stop();
         this.clearConnectTimeout();
-        if (this._eventSource) {
-            // Detach all handlers BEFORE closing so that the async onerror / onmessage
-            // events that fire after close() cannot observe the new _disconnected=false
-            // state set by an immediately following ensureConnected() call. Without this,
-            // a stale onerror triggers an unintended reconnect with exponential back-off.
-            this._eventSource.onopen = null;
-            this._eventSource.onmessage = null;
-            this._eventSource.onerror = null;
-            this._eventSource.close();
-        }
-        this._eventSource = undefined;
+        this.detachAndCloseEventSource();
         this._connectionId = undefined;
     }
 
     private openEventSource(): void {
+        if (this._eventSource && this._eventSource.readyState !== EventSource.CLOSED) {
+            return;
+        }
+
+        this._policy.cancel();
         let url = this._sseUrl;
         if (this._microservice?.length > 0) {
             const param = `${Globals.microserviceWSQueryArgument}=${encodeURIComponent(this._microservice)}`;
@@ -192,11 +232,15 @@ export class ServerSentEventHubConnection implements IObservableQueryHubConnecti
         }
 
         this._connectionId = undefined;
-        this._eventSource = Globals.eventSourceFactory ? Globals.eventSourceFactory(url) : new EventSource(url);
-
-        this._eventSource.onopen = () => {
-            if (this._disconnected) return;
-            console.log(`SSE hub connection established: '${url}'`);
+        this._supportsSubscriptionRevisions = false;
+        const eventSource = Globals.eventSourceFactory
+            ? Globals.eventSourceFactory(url)
+            : new EventSource(url);
+        this._eventSource = eventSource;
+
+        eventSource.onopen = () => {
+            if (this._disconnected || this._eventSource !== eventSource) return;
+            console.log('SSE hub connection established', url);
             this._policy.reset();
             this._keepAlive.start();
 
@@ -204,22 +248,30 @@ export class ServerSentEventHubConnection implements IObservableQueryHubConnecti
             // connection is broken. Close and retry via the reconnect policy.
             this.clearConnectTimeout();
             this._connectTimeoutTimer = setTimeout(() => {
-                if (!this._disconnected && !this._connectionId) {
-                    console.warn(`SSE hub: no Connected message within ${this._connectTimeoutMs}ms, retrying '${url}'`);
+                if (
+                    !this._disconnected &&
+                    this._eventSource === eventSource &&
+                    !this._connectionId
+                ) {
+                    console.warn(
+                        'SSE hub: no Connected message within timeout; retrying',
+                        this._connectTimeoutMs,
+                        url,
+                    );
                     this.reconnect();
                 }
             }, this._connectTimeoutMs);
         };
 
-        this._eventSource.onmessage = (event: MessageEvent) => {
-            if (this._disconnected) return;
+        eventSource.onmessage = (event: MessageEvent) => {
+            if (this._disconnected || this._eventSource !== eventSource) return;
             this._keepAlive.recordActivity();
             this.handleMessage(event.data as string);
         };
 
-        this._eventSource.onerror = () => {
-            if (this._disconnected) return;
-            console.warn(`SSE hub connection error: '${url}'`);
+        eventSource.onerror = () => {
+            if (this._disconnected || this._eventSource !== eventSource) return;
+            console.warn('SSE hub connection error', url);
             this.reconnect();
         };
     }
@@ -228,9 +280,8 @@ export class ServerSentEventHubConnection implements IObservableQueryHubConnecti
         this._keepAlive.stop();
         this.clearConnectTimeout();
 
-        // Close the EventSource so the reconnect policy manages the schedule.
-        this._eventSource?.close();
-        this._eventSource = undefined;
+        // Detach before closing so callbacks already queued by the retired source are inert.
+        this.detachAndCloseEventSource();
         this._connectionId = undefined;
 
         // Move all active subscriptions to pending so they re-subscribe when
@@ -243,7 +294,7 @@ export class ServerSentEventHubConnection implements IObservableQueryHubConnecti
 
         this._policy.schedule(() => {
             if (!this._disconnected && this._subscriptions.size > 0) {
-                this.openEventSource();
+                this.ensureConnected();
             }
         }, this._sseUrl);
     }
@@ -270,11 +321,19 @@ export class ServerSentEventHubConnection implements IObservableQueryHubConnecti
                     // Server-sent keep-alive ping — activity already recorded in onmessage.
                     break;
                 case HubMessageType.Unauthorized:
-                    console.warn(`SSE hub: query '${message.queryId}' unauthorized`);
-                    this.handleUnauthorized(message);
+                    if (this.isMessageForCurrentSubscription(message)) {
+                        console.warn('SSE hub: query unauthorized', message.queryId);
+                        this.handleUnauthorized(message);
+                    }
                     break;
                 case HubMessageType.Error:
-                    console.error(`SSE hub: query '${message.queryId}' error:`, message.payload);
+                    if (this.isMessageForCurrentSubscription(message)) {
+                        console.error(
+                            'SSE hub: query error',
+                            message.queryId,
+                            message.payload,
+                        );
+                    }
                     break;
             }
         } catch (error) {
@@ -283,17 +342,25 @@ export class ServerSentEventHubConnection implements IObservableQueryHubConnecti
     }
 
     private handleConnected(message: HubMessage): void {
-        this._connectionId = message.payload as string;
-        console.log(`SSE hub: connected with id '${this._connectionId}'`);
+        const connectionId = message.payload as string;
+        const connectionIdChanged = this._connectionId !== connectionId;
+        this._connectionId = connectionId;
+        this._supportsSubscriptionRevisions =
+            message.supportsSubscriptionRevisions === true;
+        console.log('SSE hub: connected', this._connectionId);
 
         // Connected message arrived — cancel the connect timeout.
         this.clearConnectTimeout();
 
         this.applyServerKeepAliveInterval(message.keepAliveIntervalMs);
 
-        // Send all pending subscriptions now that we have a connection ID.
-        for (const [queryId, sub] of this._pendingSubscriptions) {
-            this.sendSubscribe(queryId, sub.request);
+        // The active collection is authoritative. A previous connection's subscribe POST may
+        // still be in flight, so relying only on pending subscriptions can orphan a query when
+        // the server assigns a new connection ID before that POST completes.
+        if (connectionIdChanged) {
+            for (const [queryId, subscription] of this._subscriptions) {
+                this.sendSubscribe(queryId, subscription);
+            }
         }
         this._pendingSubscriptions.clear();
     }
@@ -316,14 +383,17 @@ export class ServerSentEventHubConnection implements IObservableQueryHubConnecti
             return;
         }
 
-        this._keepAlive.reconfigure(serverIntervalMs, serverIntervalMs * IDLE_THRESHOLD_FACTOR);
+        this._keepAlive.reconfigure(
+            serverIntervalMs,
+            serverIntervalMs * IDLE_THRESHOLD_FACTOR,
+        );
     }
 
     private handleQueryResult(message: HubMessage): void {
         if (!message.queryId) return;
 
         const sub = this._subscriptions.get(message.queryId);
-        if (!sub) return;
+        if (!sub || !this.isMessageForCurrentSubscription(message)) return;
 
         const result = message.payload as QueryResult<any>;
         sub.callback(result);
@@ -333,25 +403,37 @@ export class ServerSentEventHubConnection implements IObservableQueryHubConnecti
         if (!message.queryId) return;
 
         const sub = this._subscriptions.get(message.queryId);
-        if (!sub) return;
+        if (!sub || !this.isMessageForCurrentSubscription(message)) return;
 
         this._subscriptions.delete(message.queryId);
         this._pendingSubscriptions.delete(message.queryId);
         sub.callback(QueryResult.unauthorized());
     }
 
-    private sendSubscribe(queryId: string, request: SubscriptionRequest, attempt: number = 0): void {
+    private sendSubscribe(
+        queryId: string,
+        subscription: ActiveSubscription,
+        attempt: number = 0,
+    ): void {
         if (!this._connectionId || this._disconnected) return;
 
-        // Capture the connection ID so retries can detect if a reconnect has already fired
-        // for a different reason and made this retry obsolete.
+        // Capture the connection ID and subscription instance so retries can detect whether
+        // either has been replaced while this request is in flight.
         const connectionId = this._connectionId;
 
-        const body = {
+        const body: {
+            connectionId: string;
+            queryId: string;
+            request: SubscriptionRequest;
+            revision?: number;
+        } = {
             connectionId,
             queryId,
-            request,
+            request: subscription.request,
         };
+        if (this._supportsSubscriptionRevisions) {
+            body.revision = subscription.revision;
+        }
 
         const customHeaders = Globals.httpHeadersCallback?.() ?? {};
 
@@ -368,32 +450,137 @@ export class ServerSentEventHubConnection implements IObservableQueryHubConnecti
             method: 'POST',
             headers: { 'Content-Type': 'application/json', ...customHeaders },
             body: JSON.stringify(body),
-        }).then(response => {
-            if (!response.ok) {
-                if (attempt < maxRetries && this._connectionId === connectionId && !this._disconnected) {
-                    setTimeout(() => this.sendSubscribe(queryId, request, attempt + 1), retryDelayMs * (attempt + 1));
-                } else if (this._connectionId === connectionId && !this._disconnected) {
-                    console.warn(`SSE hub: subscribe POST for '${queryId}' returned ${response.status} after ${attempt + 1} attempt(s), reconnecting`);
+        })
+            .then((response) => {
+                if (!response.ok) {
+                    if (
+                        !this.isCurrentSubscription(queryId, subscription, connectionId)
+                    ) {
+                        console.warn(
+                            'SSE hub: subscribe POST returned a failure for an obsolete connection or subscription; ignoring',
+                            queryId,
+                            response.status,
+                        );
+                    } else if (attempt < maxRetries) {
+                        setTimeout(
+                            () => {
+                                if (
+                                    this.isCurrentSubscription(
+                                        queryId,
+                                        subscription,
+                                        connectionId,
+                                    )
+                                ) {
+                                    this.sendSubscribe(
+                                        queryId,
+                                        subscription,
+                                        attempt + 1,
+                                    );
+                                }
+                            },
+                            retryDelayMs * (attempt + 1),
+                        );
+                    } else {
+                        console.warn(
+                            'SSE hub: subscribe POST failed after retries; reconnecting',
+                            queryId,
+                            response.status,
+                            attempt + 1,
+                        );
+                        this.reconnect();
+                    }
+                }
+            })
+            .catch((error) => {
+                if (!this.isCurrentSubscription(queryId, subscription, connectionId)) {
+                    console.warn(
+                        'SSE hub: subscribe POST failed for an obsolete connection or subscription; ignoring',
+                        queryId,
+                        error,
+                    );
+                } else if (attempt < maxRetries) {
+                    setTimeout(
+                        () => {
+                            if (
+                                this.isCurrentSubscription(
+                                    queryId,
+                                    subscription,
+                                    connectionId,
+                                )
+                            ) {
+                                this.sendSubscribe(queryId, subscription, attempt + 1);
+                            }
+                        },
+                        retryDelayMs * (attempt + 1),
+                    );
+                } else {
+                    console.error(
+                        'SSE hub: subscribe POST failed after retries; reconnecting',
+                        queryId,
+                        attempt + 1,
+                        error,
+                    );
                     this.reconnect();
                 }
-            }
-        }).catch(error => {
-            if (attempt < maxRetries && this._connectionId === connectionId && !this._disconnected) {
-                setTimeout(() => this.sendSubscribe(queryId, request, attempt + 1), retryDelayMs * (attempt + 1));
-            } else if (this._connectionId === connectionId && !this._disconnected) {
-                console.error(`SSE hub: subscribe POST failed for '${queryId}' after ${attempt + 1} attempt(s), reconnecting`, error);
-                this.reconnect();
-            }
-        });
+            });
     }
 
-    private sendUnsubscribe(queryId: string): void {
+    private isMessageForCurrentSubscription(message: HubMessage): boolean {
+        if (!message.queryId) return false;
+
+        const subscription = this._subscriptions.get(message.queryId);
+        if (!subscription) return false;
+
+        if (!this._supportsSubscriptionRevisions) {
+            return message.revision === undefined;
+        }
+
+        return (
+            this.isValidRevision(message.revision) &&
+            message.revision === subscription.revision
+        );
+    }
+
+    private isCurrentSubscription(
+        queryId: string,
+        subscription: ActiveSubscription,
+        connectionId: string,
+    ): boolean {
+        return (
+            !this._disconnected &&
+            this._connectionId === connectionId &&
+            this._subscriptions.get(queryId) === subscription
+        );
+    }
+
+    private getNextRevision(): number {
+        if (this._nextRevision >= Number.MAX_SAFE_INTEGER) {
+            throw new RangeError(
+                'SSE hub subscription revision exhausted the safe integer range',
+            );
+        }
+
+        return ++this._nextRevision;
+    }
+
+    private isValidRevision(revision: number | undefined): revision is number {
+        return revision !== undefined && Number.isSafeInteger(revision) && revision > 0;
+    }
+
+    private sendUnsubscribe(queryId: string, revision: number): void {
         if (!this._connectionId) return;
 
-        const body = {
+        const body: {
+            connectionId: string;
+            queryId: string;
+            revision?: number;
+        } = {
             connectionId: this._connectionId,
             queryId,
         };
+        if (this._supportsSubscriptionRevisions) {
+            body.revision = revision;
+        }
 
         const customHeaders = Globals.httpHeadersCallback?.() ?? {};
 
@@ -401,8 +588,8 @@ export class ServerSentEventHubConnection implements IObservableQueryHubConnecti
             method: 'POST',
             headers: { 'Content-Type': 'application/json', ...customHeaders },
             body: JSON.stringify(body),
-        }).catch(error => {
-            console.error(`SSE hub: unsubscribe POST failed for '${queryId}'`, error);
+        }).catch((error) => {
+            console.error('SSE hub: unsubscribe POST failed', queryId, error);
         });
     }
 }