expose deep heart beat callbacks to clients

CHANGELOG.md

@@ -4,6 +4,14 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+
+## [2.2.3]
+### Fixed
+- .onConnectionEstablished() is fired twice after invoking .connect(); closes #124
+- enable message receipts by default; closes #132
+- expose deep heartbeat success/failure callback to clients
+
+
 ## [2.2.2]
 ### Fixed
 - reject send callbacks instead of returning null

package.json

@@ -1,6 +1,6 @@
 {
   "name": "amazon-connect-chatjs",
-  "version": "2.2.2",
+  "version": "2.2.3",
   "main": "dist/amazon-connect-chat.js",
   "types": "dist/index.d.ts",
   "engines": {

src/constants.js

@@ -48,7 +48,9 @@ export const WEBSOCKET_EVENTS = {
     ConnectionGained: "WebsocketConnectionGained",
     Ended: "WebsocketEnded",
     IncomingMessage: "WebsocketIncomingMessage",
-    InitWebsocket: "InitWebsocket"
+    InitWebsocket: "InitWebsocket",
+    DeepHeartbeatSuccess: "WebsocketDeepHeartbeatSuccess",
+    DeepHeartbeatFailure: "WebsocketDeepHeartbeatFailure"
 };
 
 export const CHAT_EVENTS = {
@@ -64,7 +66,9 @@ export const CHAT_EVENTS = {
     MESSAGE_METADATA: "MESSAGEMETADATA",
     PARTICIPANT_IDLE: "PARTICIPANT_IDLE",
     PARTICIPANT_RETURNED: "PARTICIPANT_RETURNED",
-    AUTODISCONNECTION: "AUTODISCONNECTION"
+    AUTODISCONNECTION: "AUTODISCONNECTION",
+    DEEP_HEARTBEAT_SUCCESS: "DEEP_HEARTBEAT_SUCCESS",
+    DEEP_HEARTBEAT_FAILURE: "DEEP_HEARTBEAT_FAILURE"
 };
 
 export const CONTENT_TYPE = {
@@ -161,4 +165,4 @@ export const CREATE_PARTICIPANT_CONACK_FAILURE = "CREATE_PARTICIPANT_CONACK_FAIL
 export const SEND_EVENT_CONACK_FAILURE = "SEND_EVENT_CONACK_FAILURE";
 export const CREATE_PARTICIPANT_CONACK_API_CALL_COUNT = "CREATE_PARTICIPANT_CONACK_CALL_COUNT";
 
-export const TYPING_VALIDITY_TIME = 10000;
+export const TYPING_VALIDITY_TIME = 10000;

src/core/chatController.js

@@ -245,6 +245,8 @@ class ChatController {
         this.connectionHelper.onConnectionLost(this._handleLostConnection.bind(this));
         this.connectionHelper.onConnectionGain(this._handleGainedConnection.bind(this));
         this.connectionHelper.onMessage(this._handleIncomingMessage.bind(this));
+        this.connectionHelper.onDeepHeartbeatSuccess(this._handleDeepHeartbeatSuccess.bind(this));
+        this.connectionHelper.onDeepHeartbeatFailure(this._handleDeepHeartbeatFailure.bind(this));
         return this.connectionHelper.start();
     }
 
@@ -281,6 +283,20 @@ class ChatController {
         });
     }
 
+    _handleDeepHeartbeatSuccess(eventData) {
+        this._forwardChatEvent(CHAT_EVENTS.DEEP_HEARTBEAT_SUCCESS, {
+            data: eventData,
+            chatDetails: this.getChatDetails()
+        });
+    }
+
+    _handleDeepHeartbeatFailure(eventData) {
+        this._forwardChatEvent(CHAT_EVENTS.DEEP_HEARTBEAT_FAILURE, {
+            data: eventData,
+            chatDetails: this.getChatDetails()
+        });
+    }
+
     _handleIncomingMessage(incomingData) {
         try {
             let eventType = getEventTypeFromContentType(incomingData?.ContentType);
@@ -437,6 +453,10 @@ class ChatController {
             return NetworkLinkStatus.Broken;
         case ConnectionHelperStatus.Connected:
             return NetworkLinkStatus.Established;
+        case ConnectionHelperStatus.DeepHeartbeatSuccess:
+            return NetworkLinkStatus.Established;
+        case ConnectionHelperStatus.DeepHeartbeatFailure:
+            return NetworkLinkStatus.Broken;
         }
         this._sendInternalLogToServer(this.logger.error(
             "Reached invalid state. Unknown connectionHelperStatus: ",

src/core/chatController.spec.js

@@ -85,6 +85,8 @@ describe("ChatController", () => {
                 onMessage: (handler) => {
                     messageHandlers.push(handler);
                 },
+                onDeepHeartbeatSuccess: () => {},
+                onDeepHeartbeatFailure: () => {},
                 start: () => startResponse,
                 end: () => endResponse,
                 getStatus: () => ConnectionHelperStatus.Connected,
@@ -936,4 +938,32 @@ describe("ChatController", () => {
             expect(console.error).toBeCalledWith('Cannot call disconnectParticipant when participant is disconnected');
         }
     });
+
+    test('_handleDeepHeartbeatSuccess is triggered correctly', () => {
+        const chatController = getChatController();
+        chatController._forwardChatEvent = jest.fn(); // Mock _forwardChatEvent to spy on it
+
+        // Directly invoke the method
+        chatController._handleDeepHeartbeatSuccess({ message: 'Heartbeat succeeded' });
+
+        // Check if _forwardChatEvent was called correctly
+        expect(chatController._forwardChatEvent).toHaveBeenCalledWith(
+            CHAT_EVENTS.DEEP_HEARTBEAT_SUCCESS,
+            { data: { message: 'Heartbeat succeeded' }, chatDetails: expect.anything() }
+        );
+    });
+
+    test('_handleDeepHeartbeatFailure is triggered correctly', () => {
+        const chatController = getChatController();
+        chatController._forwardChatEvent = jest.fn(); // Mock _forwardChatEvent to spy on it
+
+        // Directly invoke the method
+        chatController._handleDeepHeartbeatFailure({ error: 'Heartbeat failed' });
+
+        // Check if _forwardChatEvent was called correctly
+        expect(chatController._forwardChatEvent).toHaveBeenCalledWith(
+            CHAT_EVENTS.DEEP_HEARTBEAT_FAILURE,
+            { data: { error: 'Heartbeat failed' }, chatDetails: expect.anything() }
+        );
+    });
 });

src/core/chatSession.js

@@ -122,6 +122,14 @@ export class ChatSession {
         this.controller.subscribe(CHAT_EVENTS.CONNECTION_LOST, callback);
     }
 
+    onDeepHeartbeatSuccess(callback){
+        this.controller.subscribe(CHAT_EVENTS.DEEP_HEARTBEAT_SUCCESS, callback);
+    }
+
+    onDeepHeartbeatFailure(callback){
+        this.controller.subscribe(CHAT_EVENTS.DEEP_HEARTBEAT_FAILURE, callback);
+    }
+
     sendMessage(args) {
         return this.controller.sendMessage(args);
     }

src/core/chatSession.spec.js

@@ -80,6 +80,8 @@ describe("chatSession", () => {
         const cb9 = jest.fn();
         const cb10 = jest.fn();
         const cb11 = jest.fn();
+        const cb12 = jest.fn();
+        const cb13 = jest.fn();
 
         session.onParticipantIdle(cb1);
         session.onParticipantReturned(cb2);
@@ -92,6 +94,8 @@ describe("chatSession", () => {
         session.onConnectionEstablished(cb9);
         session.onEnded(cb10);
         session.onConnectionLost(cb11);
+        session.onDeepHeartbeatSuccess(cb12);
+        session.onDeepHeartbeatFailure(cb13);
 
         controller._forwardChatEvent(CHAT_EVENTS.PARTICIPANT_IDLE, eventData);
         controller._forwardChatEvent(CHAT_EVENTS.PARTICIPANT_RETURNED, eventData);
@@ -104,6 +108,8 @@ describe("chatSession", () => {
         controller._forwardChatEvent(CHAT_EVENTS.CONNECTION_ESTABLISHED, eventData);
         controller._forwardChatEvent(CHAT_EVENTS.CHAT_ENDED, eventData);
         controller._forwardChatEvent(CHAT_EVENTS.CONNECTION_LOST, eventData);
+        controller._forwardChatEvent(CHAT_EVENTS.DEEP_HEARTBEAT_SUCCESS, eventData);
+        controller._forwardChatEvent(CHAT_EVENTS.DEEP_HEARTBEAT_FAILURE, eventData);
 
         await new Promise((r) => setTimeout(r, 0));
 
@@ -118,6 +124,8 @@ describe("chatSession", () => {
         expect(cb9).toHaveBeenCalled();
         expect(cb10).toHaveBeenCalled();
         expect(cb11).toHaveBeenCalled();
+        expect(cb12).toHaveBeenCalled();
+        expect(cb13).toHaveBeenCalled();
     });
 
     test('events', () => {
@@ -145,4 +153,4 @@ describe("chatSession", () => {
         session.getChatDetails(args);
         expect(controller.getChatDetails).toHaveBeenCalled();
     });
-});
+});

src/core/connectionHelpers/LpcConnectionHelper.js

@@ -48,7 +48,9 @@ class LpcConnectionHelper extends BaseConnectionHelper {
             this.baseInstance.onEnded(this.handleEnded.bind(this)),
             this.baseInstance.onConnectionGain(this.handleConnectionGain.bind(this)),
             this.baseInstance.onConnectionLost(this.handleConnectionLost.bind(this)),
-            this.baseInstance.onMessage(this.handleMessage.bind(this))
+            this.baseInstance.onMessage(this.handleMessage.bind(this)),
+            this.baseInstance.onDeepHeartbeatSuccess(this.handleDeepHeartbeatSuccess.bind(this)),
+            this.baseInstance.onDeepHeartbeatFailure(this.handleDeepHeartbeatFailure.bind(this))
         ];
     }
 
@@ -100,6 +102,22 @@ class LpcConnectionHelper extends BaseConnectionHelper {
         this.eventBus.trigger(ConnectionHelperEvents.ConnectionLost, {});
     }
 
+    onDeepHeartbeatSuccess(handler) {
+        return this.eventBus.subscribe(ConnectionHelperEvents.DeepHeartbeatSuccess, handler);
+    }
+
+    handleDeepHeartbeatSuccess() {
+        this.eventBus.trigger(ConnectionHelperEvents.DeepHeartbeatSuccess, {});
+    }
+
+    onDeepHeartbeatFailure(handler) {
+        return this.eventBus.subscribe(ConnectionHelperEvents.DeepHeartbeatFailure, handler);
+    }
+
+    handleDeepHeartbeatFailure() {
+        this.eventBus.trigger(ConnectionHelperEvents.DeepHeartbeatFailure, {});
+    }
+
     onMessage(handler) {
         return this.eventBus.subscribe(ConnectionHelperEvents.IncomingMessage, handler);
     }
@@ -133,7 +151,9 @@ class LpcConnectionHelperBase {
             this.websocketManager.onMessage("aws/chat", this.handleMessage.bind(this)),
             this.websocketManager.onConnectionGain(this.handleConnectionGain.bind(this)),
             this.websocketManager.onConnectionLost(this.handleConnectionLost.bind(this)),
-            this.websocketManager.onInitFailure(this.handleEnded.bind(this))
+            this.websocketManager.onInitFailure(this.handleEnded.bind(this)),
+            this.websocketManager.onDeepHeartbeatSuccess(this.handleDeepHeartbeatSuccess.bind(this)),
+            this.websocketManager.onDeepHeartbeatFailure(this.handleDeepHeartbeatFailure.bind(this))
         ];
         this.logger.info("Initializing websocket manager.");
         if (!websocketManager) {
@@ -271,6 +291,28 @@ class LpcConnectionHelperBase {
 
         return logEntry;
     }
+
+    onDeepHeartbeatSuccess(handler) {
+        return this.eventBus.subscribe(ConnectionHelperEvents.DeepHeartbeatSuccess, handler);
+    }
+
+    handleDeepHeartbeatSuccess() {
+        this.status = ConnectionHelperStatus.DeepHeartbeatSuccess;
+        this.eventBus.trigger(ConnectionHelperEvents.DeepHeartbeatSuccess, {});
+        csmService.addCountMetric(WEBSOCKET_EVENTS.DeepHeartbeatSuccess, CSM_CATEGORY.API);
+        this.logger.info("Websocket deep heartbeat success.");
+    }
+
+    onDeepHeartbeatFailure(handler) {
+        return this.eventBus.subscribe(ConnectionHelperEvents.DeepHeartbeatFailure, handler);
+    }
+
+    handleDeepHeartbeatFailure() {
+        this.status = ConnectionHelperStatus.DeepHeartbeatFailure;
+        this.eventBus.trigger(ConnectionHelperEvents.DeepHeartbeatFailure, {});
+        csmService.addCountMetric(WEBSOCKET_EVENTS.DeepHeartbeatFailure, CSM_CATEGORY.API);
+        this.logger.info("Websocket deep heartbeat failure.");
+    }
 }
 
 export default LpcConnectionHelper;