@cratis/arc 20.3.3 → 20.4.1

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@cratis/arc",
-    "version": "20.3.3",
+    "version": "20.4.1",
     "description": "",
     "author": "Cratis",
     "license": "MIT",

package/queries/ObservableQueryConnection.ts

@@ -169,8 +169,9 @@ export class ObservableQueryConnection<TDataType> implements IObservableQueryCon
             if (message.type === WebSocketMessageType.Pong) {
                 this.handlePong(message);
             } else if (message.type === WebSocketMessageType.Data || !message.type) {
-                // For backward compatibility, treat messages without a type as data messages
-                const data = message.data ?? message;
+                // For new-style messages (type === 'Data') the query result is wrapped in message.data.
+                // For legacy/backward-compatible messages (no type) the entire message IS the query result.
+                const data = message.type === WebSocketMessageType.Data ? message.data : message;
                 dataReceived(data as QueryResult<TDataType>);
             }
         } catch (error) {

package/queries/ServerSentEventHubConnection.ts

@@ -153,7 +153,16 @@ export class ServerSentEventHubConnection implements IObservableQueryHubConnecti
         this._policy.cancel();
         this._keepAlive.stop();
         this.clearConnectTimeout();
-        this._eventSource?.close();
+        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._connectionId = undefined;
     }

package/queries/WebSocketHubConnection.ts

@@ -175,7 +175,18 @@ export class WebSocketHubConnection {
         this._disconnected = true;
         this._keepAlive.stop();
         this._policy.cancel();
-        this._socket?.close();
+        if (this._socket) {
+            // Detach all handlers BEFORE closing so that the async onclose event cannot
+            // fire after a new subscription has reset _disconnected to false and opened a
+            // fresh socket. Without this, the stale onclose triggers an unintended
+            // reconnect via the back-off policy, causing a 1-10 second delay before the
+            // new page's queries receive their first data.
+            this._socket.onopen = null;
+            this._socket.onclose = null;
+            this._socket.onerror = null;
+            this._socket.onmessage = null;
+            this._socket.close();
+        }
         this._socket = undefined;
     }
 

package/queries/for_ObservableQueryConnection/given/an_observable_query_connection_with_websocket.ts

@@ -0,0 +1,58 @@
+// 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 { ObservableQueryConnection } from '../../ObservableQueryConnection';
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+export type FakeWebSocket = {
+    onopen: (() => void) | null;
+    onclose: (() => void) | null;
+    onerror: ((error: unknown) => void) | null;
+    onmessage: ((event: { data: string }) => void) | null;
+    close: sinon.SinonStub;
+    send: sinon.SinonStub;
+    readyState: number;
+};
+
+export class an_observable_query_connection_with_websocket {
+    connection: ObservableQueryConnection<unknown>;
+    fakeWebSocket!: FakeWebSocket;
+
+    constructor() {
+        this.fakeWebSocket = {
+            onopen: null,
+            onclose: null,
+            onerror: null,
+            onmessage: null,
+            close: sinon.stub(),
+            send: sinon.stub(),
+            readyState: WebSocket.OPEN,
+        };
+
+        const fakeWebSocket = this.fakeWebSocket;
+        const FakeWebSocketClass = function (this: any) {
+            fakeWebSocket.onopen = null;
+            fakeWebSocket.onclose = null;
+            fakeWebSocket.onerror = null;
+            fakeWebSocket.onmessage = null;
+            return fakeWebSocket;
+        };
+        (globalThis as any)['WebSocket'] = FakeWebSocketClass;
+
+        this.connection = new ObservableQueryConnection<unknown>(
+            new URL('https://example.com/api/test'),
+            'test-microservice'
+        );
+    }
+
+    simulateMessage(payload: object): void {
+        this.fakeWebSocket.onmessage?.({ data: JSON.stringify(payload) });
+    }
+
+    simulateOpen(): void {
+        this.fakeWebSocket.readyState = WebSocket.OPEN;
+        this.fakeWebSocket.onopen?.();
+    }
+}

package/queries/for_ObservableQueryConnection/when_receiving_data_message_with_type.ts

@@ -0,0 +1,48 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { given } from '../../given';
+import { an_observable_query_connection_with_websocket } from './given/an_observable_query_connection_with_websocket';
+import { QueryResult } from '../QueryResult';
+import { WebSocketMessageType } from '../WebSocketMessage';
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+describe('when receiving data message with Data type', given(an_observable_query_connection_with_websocket, context => {
+    const innerQueryResult = {
+        data: [{ id: '2', name: 'Item' }],
+        isSuccess: true,
+        isAuthorized: true,
+        isValid: true,
+        hasExceptions: false,
+        validationResults: [],
+        exceptionMessages: [],
+        exceptionStackTrace: '',
+        paging: { page: 0, size: 0, totalItems: 1, totalPages: 1 }
+    };
+
+    let receivedData: QueryResult<unknown> | null = null;
+
+    beforeEach(() => {
+        receivedData = null;
+        context.connection.connect((data) => {
+            receivedData = data as QueryResult<unknown>;
+        });
+        context.simulateMessage({
+            type: WebSocketMessageType.Data,
+            data: innerQueryResult
+        });
+    });
+
+    it('should pass the inner data payload as the query result', () => {
+        receivedData!.should.not.be.null;
+    });
+
+    it('should have the correct data field', () => {
+        (receivedData as any)!.data.should.deep.equal(innerQueryResult.data);
+    });
+
+    it('should have the correct isSuccess field', () => {
+        (receivedData as any)!.isSuccess.should.equal(true);
+    });
+}));

package/queries/for_ObservableQueryConnection/when_receiving_legacy_data_message.ts

@@ -0,0 +1,48 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { given } from '../../given';
+import { an_observable_query_connection_with_websocket } from './given/an_observable_query_connection_with_websocket';
+import { QueryResult } from '../QueryResult';
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+describe('when receiving legacy data message without type field', given(an_observable_query_connection_with_websocket, context => {
+    const queryResult = {
+        data: [{ id: '1', name: 'Test' }],
+        isSuccess: true,
+        isAuthorized: true,
+        isValid: true,
+        hasExceptions: false,
+        validationResults: [],
+        exceptionMessages: [],
+        exceptionStackTrace: '',
+        paging: { page: 0, size: 0, totalItems: 1, totalPages: 1 }
+    };
+
+    let receivedData: QueryResult<unknown> | null = null;
+
+    beforeEach(() => {
+        receivedData = null;
+        context.connection.connect((data) => {
+            receivedData = data as QueryResult<unknown>;
+        });
+        context.simulateMessage(queryResult);
+    });
+
+    it('should pass the entire message as the query result', () => {
+        receivedData!.should.not.be.null;
+    });
+
+    it('should have the correct data field', () => {
+        (receivedData as any)!.data.should.deep.equal(queryResult.data);
+    });
+
+    it('should have the correct isSuccess field', () => {
+        (receivedData as any)!.isSuccess.should.equal(true);
+    });
+
+    it('should have the correct paging field', () => {
+        (receivedData as any)!.paging.should.deep.equal(queryResult.paging);
+    });
+}));

package/queries/for_ServerSentEventHubConnection/when_unsubscribing/nulls_event_source_handlers_before_closing.ts

@@ -0,0 +1,36 @@
+// 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_server_sent_event_hub_connection } from '../given/a_server_sent_event_hub_connection';
+import { given } from '../../../given';
+import { HubMessageType } from '../../WebSocketHubConnection';
+
+describe('when unsubscribing the only query, nulls event source handlers before closing the event source', given(a_server_sent_event_hub_connection, context => {
+    let handlersWereNullWhenClosed: { onopen: boolean; onmessage: boolean; onerror: boolean };
+
+    beforeEach(async () => {
+        context.setup();
+        context.connection.subscribe('q1', { queryName: 'MyQuery' }, sinon.stub());
+        context.simulateOpen();
+        context.simulateMessage({ type: HubMessageType.Connected, payload: 'conn-abc' });
+
+        handlersWereNullWhenClosed = { onopen: false, onmessage: false, onerror: false };
+        context.fakeEventSource.close.callsFake(() => {
+            handlersWereNullWhenClosed.onopen = context.fakeEventSource.onopen === null;
+            handlersWereNullWhenClosed.onmessage = context.fakeEventSource.onmessage === null;
+            handlersWereNullWhenClosed.onerror = context.fakeEventSource.onerror === null;
+        });
+
+        context.connection.unsubscribe('q1');
+
+        // Allow the micro-task queue to drain so the async fetch completes.
+        await Promise.resolve();
+    });
+
+    afterEach(() => sinon.restore());
+
+    it('should have nulled onopen before calling eventSource.close()', () => handlersWereNullWhenClosed.onopen.should.be.true);
+    it('should have nulled onmessage before calling eventSource.close()', () => handlersWereNullWhenClosed.onmessage.should.be.true);
+    it('should have nulled onerror before calling eventSource.close()', () => handlersWereNullWhenClosed.onerror.should.be.true);
+}));

package/queries/for_WebSocketHubConnection/when_unsubscribing/nulls_socket_handlers_before_closing.ts

@@ -0,0 +1,33 @@
+// 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';
+import { given } from '../../../given';
+
+describe('when unsubscribing the only query, nulls socket handlers before closing the socket', given(a_web_socket_hub_connection, context => {
+    let handlersWereNullWhenClosed: { onopen: boolean; onclose: boolean; onerror: boolean; onmessage: boolean };
+
+    beforeEach(() => {
+        context.setup();
+        context.connection.subscribe('q1', { queryName: 'MyQuery' }, sinon.stub());
+        context.simulateOpen();
+
+        handlersWereNullWhenClosed = { onopen: false, onclose: false, onerror: false, onmessage: false };
+        context.fakeSocket.close.callsFake(() => {
+            handlersWereNullWhenClosed.onopen = context.fakeSocket.onopen === null;
+            handlersWereNullWhenClosed.onclose = context.fakeSocket.onclose === null;
+            handlersWereNullWhenClosed.onerror = context.fakeSocket.onerror === null;
+            handlersWereNullWhenClosed.onmessage = context.fakeSocket.onmessage === null;
+        });
+
+        context.connection.unsubscribe('q1');
+    });
+
+    afterEach(() => sinon.restore());
+
+    it('should have nulled onopen before calling socket.close()', () => handlersWereNullWhenClosed.onopen.should.be.true);
+    it('should have nulled onclose before calling socket.close()', () => handlersWereNullWhenClosed.onclose.should.be.true);
+    it('should have nulled onerror before calling socket.close()', () => handlersWereNullWhenClosed.onerror.should.be.true);
+    it('should have nulled onmessage before calling socket.close()', () => handlersWereNullWhenClosed.onmessage.should.be.true);
+}));