@cratis/arc 22.125.3 → 22.126.0

package/package.json

@@ -1,7 +1,7 @@
 {
     "type": "module",
     "name": "@cratis/arc",
-    "version": "22.125.3",
+    "version": "22.126.0",
     "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/ServerSentEventHubConnection.ts

@@ -333,6 +333,7 @@ export class ServerSentEventHubConnection implements IObservableQueryHubConnecti
                             message.queryId,
                             message.payload,
                         );
+                        this.handleError(message);
                     }
                     break;
             }
@@ -394,6 +395,26 @@ export class ServerSentEventHubConnection implements IObservableQueryHubConnecti
         this.deliverResult(message, result, result?.isValid === false);
     }
 
+    private handleError(message: HubMessage): void {
+        const result = new QueryResult(
+            {
+                data: undefined,
+                isSuccess: false,
+                isReady: true,
+                isAuthorized: true,
+                isValid: true,
+                hasExceptions: true,
+                validationResults: [],
+                exceptionMessages: [message.payload as string],
+                exceptionStackTrace: '',
+                paging: { totalItems: 0, totalPages: 0, page: 0, size: 0 },
+            },
+            Object,
+            false,
+        );
+        this.deliverResult(message, result, false);
+    }
+
     private handleUnauthorized(message: HubMessage): void {
         this.deliverResult(message, QueryResult.unauthorized(), true);
     }

package/queries/WebSocketHubConnection.ts

@@ -372,6 +372,7 @@ export class WebSocketHubConnection {
                             message.queryId,
                             message.payload,
                         );
+                        this.handleError(message);
                     }
                     break;
             }
@@ -408,6 +409,26 @@ export class WebSocketHubConnection {
         sub.callback(result);
     }
 
+    private handleError(message: HubMessage): void {
+        const result = new QueryResult(
+            {
+                data: undefined,
+                isSuccess: false,
+                isReady: true,
+                isAuthorized: true,
+                isValid: true,
+                hasExceptions: true,
+                validationResults: [],
+                exceptionMessages: [message.payload as string],
+                exceptionStackTrace: '',
+                paging: { totalItems: 0, totalPages: 0, page: 0, size: 0 },
+            },
+            Object,
+            false,
+        );
+        this.handleQueryResult({ ...message, payload: result });
+    }
+
     private handleUnauthorized(message: HubMessage): void {
         if (!message.queryId) return;
 

package/queries/for_ServerSentEventHubConnection/when_receiving_an_error_message/and_the_query_is_subscribed.ts

@@ -0,0 +1,80 @@
+// 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.js';
+import { given } from '../../../given.js';
+import { HubMessageType } from '../../WebSocketHubConnection.js';
+import { QueryResult } from '../../QueryResult.js';
+
+for (const supportsRevisions of [false, true]) {
+    describe(
+        `when receiving an SSE query error with revision support ${supportsRevisions}`,
+        given(a_server_sent_event_hub_connection, (context) => {
+            const queryId = 'query-failed';
+            const failure = 'MongoDB is unreachable.';
+            let callback: sinon.SinonStub;
+            let otherCallback: sinon.SinonStub;
+            let result: QueryResult<unknown>;
+            let revision: number | undefined;
+
+            beforeEach(() => {
+                context.setup();
+                sinon.stub(console, 'error');
+                callback = sinon.stub();
+                otherCallback = sinon.stub();
+                context.connection.subscribe(queryId, { queryName: 'Authors' }, callback);
+                context.simulateOpen();
+                context.simulateMessage({
+                    type: HubMessageType.Connected,
+                    payload: 'connection-a',
+                    supportsSubscriptionRevisions: supportsRevisions,
+                });
+                try {
+                    revision = (JSON.parse(context.fetchStub.firstCall.args[1].body as string) as { revision?: number }).revision;
+                } catch (error) {
+                    throw new Error('Expected a valid subscribe body', { cause: error });
+                }
+                context.connection.subscribe('other-query', { queryName: 'Other' }, otherCallback);
+
+                context.simulateMessage({ type: HubMessageType.Error, queryId, revision, payload: failure });
+
+                result = callback.firstCall?.args[0] as QueryResult<unknown>;
+            });
+
+            afterEach(() => {
+                context.connection.dispose();
+                sinon.restore();
+            });
+
+            it('should deliver one QueryResult to the subscriber', () => {
+                callback.calledOnce.should.be.true;
+                result.should.be.instanceOf(QueryResult);
+            });
+            it('should report a ready failed result', () => {
+                result.isReady.should.be.true;
+                result.isSuccess.should.be.false;
+                result.hasExceptions.should.be.true;
+            });
+            it('should carry the server error message', () =>
+                result.exceptionMessages.should.deep.equal([failure]));
+            it('should not report a validation or authorization rejection', () => {
+                result.isValid.should.be.true;
+                result.isAuthorized.should.be.true;
+            });
+            it('should have no result data', () => result.hasData.should.be.false);
+            it('should not notify another query', () => otherCallback.called.should.be.false);
+            it('should retain subscriptions for later results', () => {
+                context.connection.queryCount.should.equal(2);
+                context.simulateMessage({
+                    type: HubMessageType.QueryResult,
+                    queryId,
+                    revision,
+                    payload: { isSuccess: true, data: ['recovered'] },
+                });
+                callback.calledTwice.should.be.true;
+                callback.secondCall.args[0].isSuccess.should.be.true;
+            });
+        }),
+    );
+}

package/queries/for_WebSocketHubConnection/when_receiving_an_error_message/and_the_query_is_subscribed.ts

@@ -0,0 +1,79 @@
+// 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 } from '../../WebSocketHubConnection.js';
+import { QueryResult } from '../../QueryResult.js';
+
+for (const supportsRevisions of [false, true]) {
+    describe(
+        `when receiving a WebSocket query error with revision support ${supportsRevisions}`,
+        given(a_web_socket_hub_connection, (context) => {
+            const queryId = 'query-failed';
+            const failure = 'MongoDB is unreachable.';
+            let callback: sinon.SinonStub;
+            let otherCallback: sinon.SinonStub;
+            let result: QueryResult<unknown>;
+            let revision: number | undefined;
+
+            beforeEach(() => {
+                context.setup();
+                sinon.stub(console, 'error');
+                callback = sinon.stub();
+                otherCallback = sinon.stub();
+                context.connection.subscribe(queryId, { queryName: 'Authors' }, callback);
+                context.simulateOpen();
+                context.simulateMessage({
+                    type: HubMessageType.Connected,
+                    supportsSubscriptionRevisions: supportsRevisions,
+                });
+                try {
+                    revision = (JSON.parse(context.fakeSocket.send.lastCall.args[0] as string) as { revision?: number }).revision;
+                } catch (error) {
+                    throw new Error('Expected a valid subscribe message', { cause: error });
+                }
+                context.connection.subscribe('other-query', { queryName: 'Other' }, otherCallback);
+
+                context.simulateMessage({ type: HubMessageType.Error, queryId, revision, payload: failure });
+
+                result = callback.firstCall?.args[0] as QueryResult<unknown>;
+            });
+
+            afterEach(() => {
+                context.connection.dispose();
+                sinon.restore();
+            });
+
+            it('should deliver one QueryResult to the subscriber', () => {
+                callback.calledOnce.should.be.true;
+                result.should.be.instanceOf(QueryResult);
+            });
+            it('should report a ready failed result', () => {
+                result.isReady.should.be.true;
+                result.isSuccess.should.be.false;
+                result.hasExceptions.should.be.true;
+            });
+            it('should carry the server error message', () =>
+                result.exceptionMessages.should.deep.equal([failure]));
+            it('should not report a validation or authorization rejection', () => {
+                result.isValid.should.be.true;
+                result.isAuthorized.should.be.true;
+            });
+            it('should have no result data', () => result.hasData.should.be.false);
+            it('should not notify another query', () => otherCallback.called.should.be.false);
+            it('should retain subscriptions for later results', () => {
+                context.connection.queryCount.should.equal(2);
+                context.simulateMessage({
+                    type: HubMessageType.QueryResult,
+                    queryId,
+                    revision,
+                    payload: { isSuccess: true, data: ['recovered'] },
+                });
+                callback.calledTwice.should.be.true;
+                callback.secondCall.args[0].isSuccess.should.be.true;
+            });
+        }),
+    );
+}