@cratis/arc 20.63.0 → 20.64.0

package/index.ts

@@ -13,6 +13,7 @@ export * from './deepEqual';
 export * from './Globals';
 export * from './ICanBeConfigured';
 export * from './GetHttpHeaders';
+export * from './EventSourceFactory';
 
 export {
     commands,

package/package.json

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

package/queries/ServerSentEventHubConnection.ts

@@ -192,7 +192,7 @@ export class ServerSentEventHubConnection implements IObservableQueryHubConnecti
         }
 
         this._connectionId = undefined;
-        this._eventSource = new EventSource(url);
+        this._eventSource = Globals.eventSourceFactory ? Globals.eventSourceFactory(url) : new EventSource(url);
 
         this._eventSource.onopen = () => {
             if (this._disconnected) return;

package/queries/ServerSentEventQueryConnection.ts

@@ -1,6 +1,7 @@
 // Copyright (c) Cratis. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
+import { Globals } from '../Globals';
 import { IObservableQueryConnection } from './IObservableQueryConnection';
 import { DataReceived } from './ObservableQueryConnection';
 import { QueryResult } from './QueryResult';
@@ -39,8 +40,9 @@ export class ServerSentEventQueryConnection<TDataType> implements IObservableQue
     connect(dataReceived: DataReceived<TDataType>, queryArguments?: object): void {
         if (this._disconnected) return;
 
-        // Guard against environments where EventSource is not available (e.g. Node.js, SSR).
-        if (typeof EventSource === 'undefined') {
+        // Guard against environments where EventSource is not available (e.g. Node.js, SSR)
+        // and no custom factory has been supplied to substitute it.
+        if (!Globals.eventSourceFactory && typeof EventSource === 'undefined') {
             return;
         }
 
@@ -56,7 +58,7 @@ export class ServerSentEventQueryConnection<TDataType> implements IObservableQue
             }
         }
 
-        this._eventSource = new EventSource(url);
+        this._eventSource = Globals.eventSourceFactory ? Globals.eventSourceFactory(url) : new EventSource(url);
 
         this._eventSource.onmessage = (event: MessageEvent) => {
             if (this._disconnected) return;

package/queries/for_ServerSentEventHubConnection/when_subscribing/uses_custom_event_source_factory.ts

@@ -0,0 +1,57 @@
+// 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 { Globals } from '../../../Globals';
+import { EventSourceFactory } from '../../../EventSourceFactory';
+import { a_server_sent_event_hub_connection } from '../given/a_server_sent_event_hub_connection';
+import { given } from '../../../given';
+import { HubMessageType } from '../../WebSocketHubConnection';
+
+interface FakeEventSource {
+    onopen: (() => void) | null;
+    onmessage: ((event: MessageEvent) => void) | null;
+    onerror: (() => void) | null;
+    close: sinon.SinonStub;
+    readyState: number;
+}
+
+describe('when subscribing with a custom event source factory configured', given(a_server_sent_event_hub_connection, context => {
+    let customEventSource: FakeEventSource;
+    let factoryStub: sinon.SinonStub;
+    let originalFactory: EventSourceFactory | undefined;
+
+    beforeEach(() => {
+        originalFactory = Globals.eventSourceFactory;
+
+        customEventSource = {
+            onopen: null,
+            onmessage: null,
+            onerror: null,
+            close: sinon.stub(),
+            readyState: 1, // OPEN
+        };
+        factoryStub = sinon.stub().returns(customEventSource);
+        Globals.eventSourceFactory = factoryStub as unknown as EventSourceFactory;
+
+        context.setup();
+        context.connection.subscribe('q1', { queryName: 'MyQuery' }, sinon.stub());
+    });
+
+    afterEach(() => {
+        Globals.eventSourceFactory = originalFactory;
+        sinon.restore();
+    });
+
+    it('should call the custom factory with the SSE hub url', () => factoryStub.calledOnce.should.be.true);
+    it('should pass the hub url to the factory', () => factoryStub.getCall(0).args[0].should.equal('http://localhost/.cratis/queries/sse'));
+    it('should not use the default global EventSource', () => (context.fakeEventSource.onopen === null).should.be.true);
+
+    describe('when the custom event source receives the Connected message', () => {
+        beforeEach(() => {
+            customEventSource.onmessage!({ data: JSON.stringify({ type: HubMessageType.Connected, payload: 'conn-1' }) } as MessageEvent);
+        });
+
+        it('should record the connection as open', () => context.connection.isConnected.should.be.true);
+    });
+}));

package/queries/for_ServerSentEventQueryConnection/when_connecting/with_custom_event_source_factory.ts

@@ -0,0 +1,63 @@
+// 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 { Globals } from '../../../Globals';
+import { EventSourceFactory } from '../../../EventSourceFactory';
+import { ServerSentEventQueryConnection } from '../../ServerSentEventQueryConnection';
+import { QueryResult } from '../../QueryResult';
+
+interface FakeEventSource {
+    onmessage: ((event: MessageEvent) => void) | null;
+    onerror: (() => void) | null;
+    close: sinon.SinonStub;
+}
+
+describe('when connecting with a custom event source factory configured and no global EventSource available', () => {
+    let originalEventSource: typeof EventSource;
+    let originalFactory: EventSourceFactory | undefined;
+    let fakeEventSource: FakeEventSource;
+    let factoryStub: sinon.SinonStub;
+    let connection: ServerSentEventQueryConnection<string[]>;
+    let receivedData: QueryResult<string[]>[];
+
+    beforeEach(() => {
+        originalEventSource = (globalThis as Record<string, unknown>)['EventSource'] as typeof EventSource;
+        delete (globalThis as Record<string, unknown>)['EventSource'];
+
+        originalFactory = Globals.eventSourceFactory;
+
+        fakeEventSource = {
+            onmessage: null,
+            onerror: null,
+            close: sinon.stub(),
+        };
+        factoryStub = sinon.stub().returns(fakeEventSource);
+        Globals.eventSourceFactory = factoryStub as unknown as EventSourceFactory;
+
+        receivedData = [];
+        connection = new ServerSentEventQueryConnection<string[]>(new URL('http://localhost/.cratis/queries/sse?query=Test'));
+        connection.connect((result: QueryResult<string[]>) => receivedData.push(result));
+    });
+
+    afterEach(() => {
+        if (originalEventSource !== undefined) {
+            (globalThis as Record<string, unknown>)['EventSource'] = originalEventSource;
+        }
+        Globals.eventSourceFactory = originalFactory;
+        sinon.restore();
+    });
+
+    it('should call the custom factory instead of the global EventSource constructor', () => factoryStub.calledOnce.should.be.true);
+    it('should pass the connection url to the factory', () => (factoryStub.getCall(0).args[0] as string).should.contain('/.cratis/queries/sse'));
+
+    describe('when a message arrives on the custom event source', () => {
+        const result = { data: ['a', 'b'], isSuccess: true, isAuthorized: true, isValid: true, hasExceptions: false, hasData: true, validationResults: [], exceptionMessages: [], exceptionStackTrace: '', paging: { page: 0, size: 0, totalItems: 0, totalPages: 0 } };
+
+        beforeEach(() => {
+            fakeEventSource.onmessage!({ data: JSON.stringify(result) } as MessageEvent);
+        });
+
+        it('should deliver the payload to the callback', () => receivedData.length.should.equal(1));
+    });
+});