@cratis/arc 22.138.1 → 22.138.2

package/package.json

@@ -1,7 +1,7 @@
 {
     "type": "module",
     "name": "@cratis/arc",
-    "version": "22.138.1",
+    "version": "22.138.2",
     "description": "TypeScript command, query, validation, identity, and messaging runtime for Cratis Arc — the CQRS application framework for ASP.NET Core — used by generated proxies.",
     "keywords": [
         "cratis",

package/queries/WebSocketHubConnection.ts

@@ -80,6 +80,9 @@ interface ActiveSubscription {
  * revision-aware operations when the server advertises support in a Connected message.
  */
 export class WebSocketHubConnection {
+    /** How long to wait for the server's Connected message before subscribing the way older servers expect. */
+    static readonly ConnectedGraceMs = 1000;
+
     private _socket?: WebSocket;
     private _disconnected = false;
     private _subscriptions: Map<string, ActiveSubscription> = new Map();
@@ -90,6 +93,8 @@ export class WebSocketHubConnection {
     private _nextRevision = 0;
     private _supportsSubscriptionRevisions = false;
     private _reconnectPending = false;
+    private _subscriptionsReleased = false;
+    private _releaseTimer?: ReturnType<typeof setTimeout>;
 
     /**
      * Initializes a new instance of {@link WebSocketHubConnection}.
@@ -162,10 +167,10 @@ export class WebSocketHubConnection {
         this._subscriptions.set(queryId, subscription);
         this.ensureConnected();
 
-        if (this._socket?.readyState === WebSocket.OPEN) {
+        if (this._socket?.readyState === WebSocket.OPEN && this._subscriptionsReleased) {
             this.sendSubscribeMessage(queryId, subscription);
         }
-        // If not yet open, sendAllSubscriptions will fire in onopen.
+        // Until the server has said what it supports, subscriptions are held back and sent once, by releaseSubscriptions.
     }
 
     /**
@@ -176,7 +181,7 @@ export class WebSocketHubConnection {
         const subscription = this._subscriptions.get(queryId);
         this._subscriptions.delete(queryId);
 
-        if (this._socket?.readyState === WebSocket.OPEN && subscription) {
+        if (this._socket?.readyState === WebSocket.OPEN && this._subscriptionsReleased && subscription) {
             const message: HubMessage = {
                 type: HubMessageType.Unsubscribe,
                 queryId,
@@ -227,6 +232,7 @@ export class WebSocketHubConnection {
         this._keepAlive.stop();
         this._policy.cancel();
         this._reconnectPending = false;
+        this.resetSubscriptionRelease();
         const socket = this._socket;
         this._socket = undefined;
         this._supportsSubscriptionRevisions = false;
@@ -251,6 +257,7 @@ export class WebSocketHubConnection {
         }
 
         this._supportsSubscriptionRevisions = false;
+        this.resetSubscriptionRelease();
 
         let url = this._url;
         if (this._microservice?.length > 0) {
@@ -267,7 +274,17 @@ export class WebSocketHubConnection {
             this.cancelPendingReconnect();
             this._policy.reset();
             this._keepAlive.start();
-            this.sendAllSubscriptions();
+
+            // A capable server announces itself with a Connected message straight after accepting the socket. Sending
+            // the subscriptions before that would mean sending them twice (once without a revision, once with), and the
+            // server would run every query twice and cancel the first run. Wait for it, and only fall back to the
+            // revision-less form for a server that never says anything.
+            this._releaseTimer = setTimeout(() => {
+                this._releaseTimer = undefined;
+                if (this._socket === socket && !this._disconnected) {
+                    this.releaseSubscriptions();
+                }
+            }, WebSocketHubConnection.ConnectedGraceMs);
         };
 
         socket.onclose = () => {
@@ -275,6 +292,7 @@ export class WebSocketHubConnection {
             console.log('Hub connection closed', url);
             this._socket = undefined;
             this._supportsSubscriptionRevisions = false;
+            this.resetSubscriptionRelease();
             this._keepAlive.stop();
             if (this._subscriptions.size === 0) return;
             this._reconnectPending = true;
@@ -317,6 +335,24 @@ export class WebSocketHubConnection {
         socket.close();
     }
 
+    private resetSubscriptionRelease(): void {
+        this._subscriptionsReleased = false;
+        if (this._releaseTimer !== undefined) {
+            clearTimeout(this._releaseTimer);
+            this._releaseTimer = undefined;
+        }
+    }
+
+    private releaseSubscriptions(): void {
+        if (this._subscriptionsReleased) return;
+        this._subscriptionsReleased = true;
+        if (this._releaseTimer !== undefined) {
+            clearTimeout(this._releaseTimer);
+            this._releaseTimer = undefined;
+        }
+        this.sendAllSubscriptions();
+    }
+
     private sendAllSubscriptions(): void {
         for (const [queryId, sub] of this._subscriptions) {
             this.sendSubscribeMessage(queryId, sub);
@@ -382,18 +418,11 @@ export class WebSocketHubConnection {
     }
 
     private handleConnected(message: HubMessage): void {
-        if (
-            message.supportsSubscriptionRevisions !== true ||
-            this._supportsSubscriptionRevisions
-        ) {
-            return;
-        }
+        if (this._subscriptionsReleased) return;
 
-        this._supportsSubscriptionRevisions = true;
-
-        // The legacy subscriptions sent on socket open keep this client compatible with older servers.
-        // Ordered WebSocket delivery means these revision-aware replacements are processed afterwards.
-        this.sendAllSubscriptions();
+        // Capability is known before anything is sent, so every subscription goes out exactly once, in its final form.
+        this._supportsSubscriptionRevisions = message.supportsSubscriptionRevisions === true;
+        this.releaseSubscriptions();
     }
 
     private handleQueryResult(message: HubMessage): void {

package/queries/for_ObservableQueryFor/when_subscribing/with_server_validation_failing.ts

@@ -54,6 +54,8 @@ for (const direct of [true, false]) {
                     stream.onmessage?.({ data: JSON.stringify({ type: 'Connected', payload: 'connection-1' }) });
                     return JSON.parse(fetchStub.firstCall.args[1].body).queryId;
                 }
+                // The server announces itself before any subscription is sent.
+                stream.onmessage?.({ data: JSON.stringify({ type: 'Connected', payload: 'connection-1' }) });
                 return JSON.parse(stream.send.firstCall.args[0]).queryId;
             };
 

package/queries/for_ObservableQueryFor/when_subscribing/with_web_socket_hub_payload_without_readiness.ts

@@ -62,8 +62,9 @@ describe(
             socket.readyState = 1;
             socket.onopen?.();
 
-            // An older Arc server sends no Connected capability message, so this fixture intentionally
+            // An older Arc server announces itself without the revision capability, so this fixture intentionally
             // remains in legacy mode and accepts only result frames without a revision.
+            socket.onmessage?.({ data: JSON.stringify({ type: HubMessageType.Connected, payload: 'connection-1' }) });
             let subscribeMessage: { queryId: string };
             try {
                 subscribeMessage = JSON.parse(socket.send.firstCall.args[0]);

package/queries/for_WebSocketHubConnection/given/a_web_socket_hub_connection.ts

@@ -65,7 +65,20 @@ export class a_web_socket_hub_connection {
         );
     }
 
-    simulateOpen(): void {
+    /**
+     * Opens the socket and has the server announce itself, as a real server does straight after accepting it.
+     * Subscriptions are only sent once that announcement arrives.
+     * @param supportsSubscriptionRevisions Whether the announcing server supports revision-aware subscriptions.
+     */
+    simulateOpen(supportsSubscriptionRevisions = false): void {
+        this.simulateOpenWithoutAnnouncement();
+        this.simulateMessage({
+            type: 'Connected',
+            ...(supportsSubscriptionRevisions ? { supportsSubscriptionRevisions: true } : {}),
+        });
+    }
+
+    simulateOpenWithoutAnnouncement(): void {
         this.fakeSocket.readyState = 1; // OPEN
         this.fakeSocket.onopen?.();
     }

package/queries/for_WebSocketHubConnection/when_receiving_unauthorized/notifies_subscriber_and_removes_subscription.ts

@@ -19,11 +19,7 @@ describe(
             callback = sinon.stub();
 
             context.connection.subscribe(queryId, { queryName: 'SecureQuery' }, callback);
-            context.simulateOpen();
-            context.simulateMessage({
-                type: HubMessageType.Connected,
-                supportsSubscriptionRevisions: true,
-            });
+            context.simulateOpen(true);
             const subscribe = getSubscribeMessage();
 
             // Server replies with Unauthorized for this exact subscription.
@@ -44,7 +40,7 @@ describe(
 
         function getSubscribeMessage(): { revision: number } {
             try {
-                return JSON.parse(context.fakeSocket.send.getCall(1).args[0]) as {
+                return JSON.parse(context.fakeSocket.send.getCall(0).args[0]) as {
                     revision: number;
                 };
             } catch (error) {

package/queries/for_WebSocketHubConnection/when_reconnecting/resubscribes_all_queries.ts

@@ -17,11 +17,7 @@ describe(
             callbackStub = sinon.stub();
             context.setup();
             context.connection.subscribe(queryId, { queryName: 'MyQuery' }, callbackStub);
-            context.simulateOpen();
-            context.simulateMessage({
-                type: HubMessageType.Connected,
-                supportsSubscriptionRevisions: true,
-            });
+            context.simulateOpen(true);
 
             // Simulate drop and policy-driven reconnect
             context.simulateClose();
@@ -32,27 +28,17 @@ describe(
             (context.policy.reset as sinon.SinonStub).reset();
             reconnectCallback();
 
-            // The new socket opens in legacy mode, then upgrades when the new handshake arrives.
-            context.simulateOpen();
-            context.simulateMessage({
-                type: HubMessageType.Connected,
-                supportsSubscriptionRevisions: true,
-            });
+            // The new socket announces itself again, and only then are the subscriptions sent.
+            context.simulateOpen(true);
         });
 
         afterEach(() => sinon.restore());
 
-        it('should reset to a legacy subscription on the new socket', () => {
+        it('should resubscribe once, in revision-aware form, on the new socket', () => {
+            context.fakeSocket.send.calledOnce.should.equal(true);
             const msg = getSentMessage(0);
             msg.type.should.equal(HubMessageType.Subscribe);
             msg.queryId.should.equal(queryId);
-            (msg.revision === undefined).should.equal(true);
-        });
-
-        it('should upgrade the reconnect subscription after the new handshake', () => {
-            const msg = getSentMessage(1);
-            msg.type.should.equal(HubMessageType.Subscribe);
-            msg.queryId.should.equal(queryId);
             (msg.revision ?? 0).should.be.greaterThan(0);
         });
 

package/queries/for_WebSocketHubConnection/when_replacing_a_subscription/ignores_stale_result_unauthorized_and_error.ts

@@ -25,19 +25,15 @@ describe(
                 { queryName: 'Original' },
                 originalCallback,
             );
-            context.simulateOpen();
-            context.simulateMessage({
-                type: HubMessageType.Connected,
-                supportsSubscriptionRevisions: true,
-            });
-            const originalRevision = sentMessage(1).revision!;
+            context.simulateOpen(true);
+            const originalRevision = sentMessage(0).revision!;
 
             context.connection.subscribe(
                 queryId,
                 { queryName: 'Replacement' },
                 replacementCallback,
             );
-            const replacementRevision = sentMessage(2).revision!;
+            const replacementRevision = sentMessage(1).revision!;
 
             context.simulateMessage({
                 type: HubMessageType.QueryResult,

package/queries/for_WebSocketHubConnection/when_subscribing/before_the_server_announces_itself.ts

@@ -0,0 +1,43 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import sinon from 'sinon';
+import { a_web_socket_hub_connection } from '../given/a_web_socket_hub_connection.js';
+import { given } from '../../../given.js';
+import { HubMessageType, WebSocketHubConnection } from '../../WebSocketHubConnection.js';
+
+describe(
+    'when the socket opens but the server has not announced itself',
+    given(a_web_socket_hub_connection, (context) => {
+        let clock: sinon.SinonFakeTimers;
+
+        beforeEach(() => {
+            clock = sinon.useFakeTimers();
+            context.setup();
+            context.connection.subscribe('q1', { queryName: 'MyQuery' }, sinon.stub());
+            context.simulateOpenWithoutAnnouncement();
+        });
+
+        afterEach(() => {
+            clock.restore();
+            sinon.restore();
+        });
+
+        it('should hold the subscription back', () =>
+            context.fakeSocket.send.called.should.equal(false));
+
+        it('should send nothing more than a subscription without a revision once the grace period passes', () => {
+            clock.tick(WebSocketHubConnection.ConnectedGraceMs);
+            context.fakeSocket.send.calledOnce.should.equal(true);
+            const message = JSON.parse(context.fakeSocket.send.firstCall.args[0]);
+            message.type.should.equal(HubMessageType.Subscribe);
+            (message.revision === undefined).should.equal(true);
+        });
+
+        it('should not send it a second time when the announcement arrives late', () => {
+            clock.tick(WebSocketHubConnection.ConnectedGraceMs);
+            context.simulateMessage({ type: HubMessageType.Connected, supportsSubscriptionRevisions: true });
+            context.fakeSocket.send.calledOnce.should.equal(true);
+        });
+    }),
+);

package/queries/for_WebSocketHubConnection/when_subscription_revisions_are_supported/upgrades_active_subscriptions_to_strict_mode.ts

@@ -17,15 +17,10 @@ describe(
             context.setup();
             callback = sinon.stub();
             context.connection.subscribe(queryId, { queryName: 'MyQuery' }, callback);
-            context.simulateOpen();
-
-            context.simulateMessage({
-                type: HubMessageType.Connected,
-                supportsSubscriptionRevisions: true,
-            });
-            const upgradedRevision = sentMessage(1).revision;
+            context.simulateOpen(true);
+            const upgradedRevision = sentMessage(0).revision;
             if (upgradedRevision === undefined) {
-                throw new Error('Expected the upgraded subscription to carry a revision');
+                throw new Error('Expected the subscription to carry a revision');
             }
             revision = upgradedRevision;
 
@@ -44,17 +39,15 @@ describe(
 
         afterEach(() => sinon.restore());
 
-        it('should initially subscribe without a revision for older servers', () =>
-            (sentMessage(0).revision === undefined).should.equal(true));
-
-        it('should replace the legacy subscription with its current revision', () => {
-            const message = sentMessage(1);
+        it('should send the subscription once, with its revision, and not before the server has announced itself', () => {
+            context.fakeSocket.send.calledOnce.should.equal(true);
+            const message = sentMessage(0);
             message.type.should.equal(HubMessageType.Subscribe);
             (message.queryId === queryId).should.equal(true);
             revision.should.be.greaterThan(0);
         });
 
-        it('should ignore the temporary legacy result and deliver the strict result once', () => {
+        it('should ignore a result without a revision and deliver the strict result once', () => {
             callback.calledOnce.should.equal(true);
             callback.firstCall.args[0].should.deep.equal({ data: ['current'] });
         });

package/queries/for_WebSocketHubConnection/when_unsubscribing/the_only_query.ts

@@ -14,11 +14,7 @@ describe(
         beforeEach(() => {
             context.setup();
             context.connection.subscribe(queryId, { queryName: 'MyQuery' }, sinon.stub());
-            context.simulateOpen();
-            context.simulateMessage({
-                type: HubMessageType.Connected,
-                supportsSubscriptionRevisions: true,
-            });
+            context.simulateOpen(true);
             context.fakeSocket.send.reset();
             context.connection.unsubscribe(queryId);
         });