@aws-amplify/pubsub 4.2.6-custom-pk.97 → 4.2.6-custom-pk.98

package/lib-esm/Providers/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.js","sourceRoot":"","sources":["../../src/Providers/constants.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,IAAM,YAAY,GAAG,IAAI,CAAC;AAEjC,MAAM,CAAC,IAAM,mBAAmB,GAAG,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC;AAEnD,MAAM,CAAN,IAAY,aAmDX;AAnDD,WAAY,aAAa;IACxB;;;OAGG;IACH,wDAAuC,CAAA;IACvC;;;OAGG;IACH,0DAAyC,CAAA;IACzC;;;OAGG;IACH,sDAAqC,CAAA;IACrC;;;OAGG;IACH,oCAAmB,CAAA;IACnB;;;OAGG;IACH,4CAA2B,CAAA;IAC3B;;;OAGG;IACH,kCAAiB,CAAA;IACjB;;;OAGG;IACH,iDAAgC,CAAA;IAChC;;;OAGG;IACH,kCAAiB,CAAA;IACjB;;;OAGG;IACH,0CAAyB,CAAA;IACzB;;;OAGG;IACH,oCAAmB,CAAA;AACpB,CAAC,EAnDW,aAAa,KAAb,aAAa,QAmDxB;AAED,MAAM,CAAN,IAAY,mBAIX;AAJD,WAAY,mBAAmB;IAC9B,mEAAO,CAAA;IACP,uEAAS,CAAA;IACT,iEAAM,CAAA;AACP,CAAC,EAJW,mBAAmB,KAAnB,mBAAmB,QAI9B;AAED,MAAM,CAAN,IAAY,aAIX;AAJD,WAAY,aAAa;IACxB,qDAAM,CAAA;IACN,mDAAK,CAAA;IACL,6DAAU,CAAA;AACX,CAAC,EAJW,aAAa,KAAb,aAAa,QAIxB;AAED,MAAM,CAAC,IAAM,cAAc,GAAG,CAC7B,OAAO,MAAM,KAAK,WAAW,IAAI,OAAO,MAAM,CAAC,GAAG,KAAK,UAAU;IAChE,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,iBAAiB,CAAC;IAC/B,CAAC,CAAC,mBAAmB,CACZ,CAAC;AAEZ,MAAM,CAAC,IAAM,4BAA4B,GAAG;IAC3C,MAAM,EAAE,mCAAmC;IAC3C,kBAAkB,EAAE,SAAS;IAC7B,cAAc,EAAE,iCAAiC;CACjD,CAAC;AAEF;;GAEG;AACH,MAAM,CAAC,IAAM,uBAAuB,GAAG,KAAK,CAAC;AAE7C;;GAEG;AACH,MAAM,CAAC,IAAM,iBAAiB,GAAG,KAAK,CAAC;AAEvC;;GAEG;AACH,MAAM,CAAC,IAAM,0BAA0B,GAAG,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC;AAExD;;GAEG;AACH,MAAM,CAAC,IAAM,gCAAgC,GAAG,EAAE,GAAG,IAAI,CAAC"}

package/lib-esm/index.d.ts

@@ -7,6 +7,8 @@ declare enum CONTROL_MSG {
     SUBSCRIPTION_ACK = "Subscription ack",
     TIMEOUT_DISCONNECT = "Timeout disconnect"
 }
+export declare const CONNECTION_STATE_CHANGE = "ConnectionStateChange";
+export { ConnectionState } from './types';
 export { PubSub, CONTROL_MSG };
 /**
  * @deprecated use named import

package/lib-esm/index.js

@@ -20,6 +20,8 @@ var CONTROL_MSG;
     CONTROL_MSG["SUBSCRIPTION_ACK"] = "Subscription ack";
     CONTROL_MSG["TIMEOUT_DISCONNECT"] = "Timeout disconnect";
 })(CONTROL_MSG || (CONTROL_MSG = {}));
+export var CONNECTION_STATE_CHANGE = 'ConnectionStateChange';
+export { ConnectionState } from './types';
 export { PubSub, CONTROL_MSG };
 /**
  * @deprecated use named import

package/lib-esm/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAElC,cAAc,aAAa,CAAC;AAE5B,IAAK,WAMJ;AAND,WAAK,WAAW;IACf,sDAAuC,CAAA;IACvC,sDAAuC,CAAA;IACvC,4FAA6E,CAAA;IAC7E,oDAAqC,CAAA;IACrC,wDAAyC,CAAA;AAC1C,CAAC,EANI,WAAW,KAAX,WAAW,QAMf;AAED,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,CAAC;AAE/B;;GAEG;AACH,eAAe,MAAM,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAElC,cAAc,aAAa,CAAC;AAE5B,IAAK,WAMJ;AAND,WAAK,WAAW;IACf,sDAAuC,CAAA;IACvC,sDAAuC,CAAA;IACvC,4FAA6E,CAAA;IAC7E,oDAAqC,CAAA;IACrC,wDAAyC,CAAA;AAC1C,CAAC,EANI,WAAW,KAAX,WAAW,QAMf;AAED,MAAM,CAAC,IAAM,uBAAuB,GAAG,uBAAuB,CAAC;AAC/D,OAAO,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAE1C,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,CAAC;AAE/B;;GAEG;AACH,eAAe,MAAM,CAAC"}

package/lib-esm/types/index.d.ts

@@ -6,3 +6,14 @@ export interface SubscriptionObserver<T> {
     error(errorValue: any): void;
     complete(): void;
 }
+/** @enum {string} */
+export declare enum ConnectionState {
+    Connected = "Connected",
+    ConnectedPendingNetwork = "ConnectedPendingNetwork",
+    ConnectionDisrupted = "ConnectionDisrupted",
+    ConnectionDisruptedPendingNetwork = "ConnectionDisruptedPendingNetwork",
+    Connecting = "Connecting",
+    ConnectedPendingDisconnect = "ConnectedPendingDisconnect",
+    Disconnected = "Disconnected",
+    ConnectedPendingKeepAlive = "ConnectedPendingKeepAlive"
+}

package/lib-esm/types/index.js

@@ -1 +1,37 @@
+/** @enum {string} */
+export var ConnectionState;
+(function (ConnectionState) {
+    /*
+     * The connection is alive and healthy
+     */
+    ConnectionState["Connected"] = "Connected";
+    /*
+     * The connection is alive, but the connection is offline
+     */
+    ConnectionState["ConnectedPendingNetwork"] = "ConnectedPendingNetwork";
+    /*
+     * The connection has been disconnected while in use
+     */
+    ConnectionState["ConnectionDisrupted"] = "ConnectionDisrupted";
+    /*
+     * The connection has been disconnected and the network is offline
+     */
+    ConnectionState["ConnectionDisruptedPendingNetwork"] = "ConnectionDisruptedPendingNetwork";
+    /*
+     * The connection is in the process of connecting
+     */
+    ConnectionState["Connecting"] = "Connecting";
+    /*
+     * The connection is not in use and is being disconnected
+     */
+    ConnectionState["ConnectedPendingDisconnect"] = "ConnectedPendingDisconnect";
+    /*
+     * The connection is not in use and has been disconnected
+     */
+    ConnectionState["Disconnected"] = "Disconnected";
+    /*
+     * The connection is alive, but a keep alive message has been missed
+     */
+    ConnectionState["ConnectedPendingKeepAlive"] = "ConnectedPendingKeepAlive";
+})(ConnectionState || (ConnectionState = {}));
 //# sourceMappingURL=index.js.map

package/lib-esm/types/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":""}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":"AAsBA,qBAAqB;AACrB,MAAM,CAAN,IAAY,eAiCX;AAjCD,WAAY,eAAe;IAC1B;;OAEG;IACH,0CAAuB,CAAA;IACvB;;OAEG;IACH,sEAAmD,CAAA;IACnD;;OAEG;IACH,8DAA2C,CAAA;IAC3C;;OAEG;IACH,0FAAuE,CAAA;IACvE;;OAEG;IACH,4CAAyB,CAAA;IACzB;;OAEG;IACH,4EAAyD,CAAA;IACzD;;OAEG;IACH,gDAA6B,CAAA;IAC7B;;OAEG;IACH,0EAAuD,CAAA;AACxD,CAAC,EAjCW,eAAe,KAAf,eAAe,QAiC1B"}

package/lib-esm/utils/ConnectionStateMonitor.d.ts

@@ -0,0 +1,40 @@
+import Observable from 'zen-observable-ts';
+import { ConnectionState } from '../index';
+declare type LinkedConnectionState = 'connected' | 'disconnected';
+declare type LinkedHealthState = 'healthy' | 'unhealthy';
+declare type LinkedConnectionStates = {
+    networkState: LinkedConnectionState;
+    connectionState: LinkedConnectionState | 'connecting';
+    intendedConnectionState: LinkedConnectionState;
+    keepAliveState: LinkedHealthState;
+};
+export declare const CONNECTION_CHANGE: {
+    [key in 'KEEP_ALIVE_MISSED' | 'KEEP_ALIVE' | 'CONNECTION_ESTABLISHED' | 'CONNECTION_FAILED' | 'CLOSING_CONNECTION' | 'OPENING_CONNECTION' | 'CLOSED' | 'ONLINE' | 'OFFLINE']: Partial<LinkedConnectionStates>;
+};
+export declare class ConnectionStateMonitor {
+    /**
+     * @private
+     */
+    private _linkedConnectionState;
+    private _linkedConnectionStateObservable;
+    private _linkedConnectionStateObserver;
+    private _networkMonitoringSubscription?;
+    constructor();
+    /**
+     * Turn network state monitoring on if it isn't on already
+     */
+    private enableNetworkMonitoring;
+    /**
+     * Turn network state monitoring off if it isn't off already
+     */
+    private disableNetworkMonitoring;
+    /**
+     * Get the observable that allows us to monitor the connection state
+     *
+     * @returns {Observable<ConnectionState>} - The observable that emits ConnectionState updates
+     */
+    get connectionStateObservable(): Observable<ConnectionState>;
+    record(statusUpdates: Partial<LinkedConnectionStates>): void;
+    private connectionStatesTranslator;
+}
+export {};

package/lib-esm/utils/ConnectionStateMonitor.js

@@ -0,0 +1,152 @@
+/*
+ * Copyright 2017-2021 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"). You may not use this file except in compliance with
+ * the License. A copy of the License is located at
+ *
+ *     http://aws.amazon.com/apache2.0/
+ *
+ * or in the "license" file accompanying this file. This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+ * CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions
+ * and limitations under the License.
+ */
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+import Observable from 'zen-observable-ts';
+import { ConnectionState } from '../index';
+import { ReachabilityMonitor } from './ReachabilityMonitor';
+export var CONNECTION_CHANGE = {
+    KEEP_ALIVE_MISSED: { keepAliveState: 'unhealthy' },
+    KEEP_ALIVE: { keepAliveState: 'healthy' },
+    CONNECTION_ESTABLISHED: { connectionState: 'connected' },
+    CONNECTION_FAILED: {
+        intendedConnectionState: 'disconnected',
+        connectionState: 'disconnected',
+    },
+    CLOSING_CONNECTION: { intendedConnectionState: 'disconnected' },
+    OPENING_CONNECTION: {
+        intendedConnectionState: 'connected',
+        connectionState: 'connecting',
+    },
+    CLOSED: { connectionState: 'disconnected' },
+    ONLINE: { networkState: 'connected' },
+    OFFLINE: { networkState: 'disconnected' },
+};
+var ConnectionStateMonitor = /** @class */ (function () {
+    function ConnectionStateMonitor() {
+        var _this = this;
+        this._networkMonitoringSubscription = undefined;
+        this._linkedConnectionState = {
+            networkState: 'connected',
+            connectionState: 'disconnected',
+            intendedConnectionState: 'disconnected',
+            keepAliveState: 'healthy',
+        };
+        this._linkedConnectionStateObservable =
+            new Observable(function (connectionStateObserver) {
+                connectionStateObserver.next(_this._linkedConnectionState);
+                _this._linkedConnectionStateObserver = connectionStateObserver;
+            });
+    }
+    /**
+     * Turn network state monitoring on if it isn't on already
+     */
+    ConnectionStateMonitor.prototype.enableNetworkMonitoring = function () {
+        var _this = this;
+        // Maintain the network state based on the reachability monitor
+        if (this._networkMonitoringSubscription === undefined) {
+            this._networkMonitoringSubscription = ReachabilityMonitor().subscribe(function (_a) {
+                var online = _a.online;
+                _this.record(online ? CONNECTION_CHANGE.ONLINE : CONNECTION_CHANGE.OFFLINE);
+            });
+        }
+    };
+    /**
+     * Turn network state monitoring off if it isn't off already
+     */
+    ConnectionStateMonitor.prototype.disableNetworkMonitoring = function () {
+        var _a;
+        (_a = this._networkMonitoringSubscription) === null || _a === void 0 ? void 0 : _a.unsubscribe();
+        this._networkMonitoringSubscription = undefined;
+    };
+    Object.defineProperty(ConnectionStateMonitor.prototype, "connectionStateObservable", {
+        /**
+         * Get the observable that allows us to monitor the connection state
+         *
+         * @returns {Observable<ConnectionState>} - The observable that emits ConnectionState updates
+         */
+        get: function () {
+            var _this = this;
+            var previous;
+            // The linked state aggregates state changes to any of the network, connection,
+            // intendedConnection and keepAliveHealth. Some states will change these independent
+            // states without changing the overall connection state.
+            // After translating from linked states to ConnectionState, then remove any duplicates
+            return this._linkedConnectionStateObservable
+                .map(function (value) {
+                return _this.connectionStatesTranslator(value);
+            })
+                .filter(function (current) {
+                var toInclude = current !== previous;
+                previous = current;
+                return toInclude;
+            });
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /*
+     * Updates local connection state and emits the full state to the observer.
+     */
+    ConnectionStateMonitor.prototype.record = function (statusUpdates) {
+        // Maintain the network monitor
+        if (statusUpdates.intendedConnectionState === 'connected') {
+            this.enableNetworkMonitoring();
+        }
+        else if (statusUpdates.intendedConnectionState === 'disconnected') {
+            this.disableNetworkMonitoring();
+        }
+        // Maintain the socket state
+        var newSocketStatus = __assign(__assign({}, this._linkedConnectionState), statusUpdates);
+        this._linkedConnectionState = __assign({}, newSocketStatus);
+        this._linkedConnectionStateObserver.next(this._linkedConnectionState);
+    };
+    /*
+     * Translate the ConnectionState structure into a specific ConnectionState string literal union
+     */
+    ConnectionStateMonitor.prototype.connectionStatesTranslator = function (_a) {
+        var connectionState = _a.connectionState, networkState = _a.networkState, intendedConnectionState = _a.intendedConnectionState, keepAliveState = _a.keepAliveState;
+        if (connectionState === 'connected' && networkState === 'disconnected')
+            return ConnectionState.ConnectedPendingNetwork;
+        if (connectionState === 'connected' &&
+            intendedConnectionState === 'disconnected')
+            return ConnectionState.ConnectedPendingDisconnect;
+        if (connectionState === 'disconnected' &&
+            intendedConnectionState === 'connected' &&
+            networkState === 'disconnected')
+            return ConnectionState.ConnectionDisruptedPendingNetwork;
+        if (connectionState === 'disconnected' &&
+            intendedConnectionState === 'connected')
+            return ConnectionState.ConnectionDisrupted;
+        if (connectionState === 'connected' && keepAliveState === 'unhealthy')
+            return ConnectionState.ConnectedPendingKeepAlive;
+        // All remaining states directly correspond to the connection state
+        if (connectionState === 'connecting')
+            return ConnectionState.Connecting;
+        if (connectionState === 'disconnected')
+            return ConnectionState.Disconnected;
+        return ConnectionState.Connected;
+    };
+    return ConnectionStateMonitor;
+}());
+export { ConnectionStateMonitor };
+//# sourceMappingURL=ConnectionStateMonitor.js.map

package/lib-esm/utils/ConnectionStateMonitor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConnectionStateMonitor.js","sourceRoot":"","sources":["../../src/utils/ConnectionStateMonitor.ts"],"names":[],"mappings":"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"}

package/lib-esm/utils/ReachabilityMonitor/index.d.ts

@@ -0,0 +1,3 @@
+export declare const ReachabilityMonitor: () => import("zen-observable-ts").default<{
+    online: boolean;
+}>;

package/lib-esm/utils/ReachabilityMonitor/index.js

@@ -0,0 +1,3 @@
+import { Reachability } from '@aws-amplify/core';
+export var ReachabilityMonitor = function () { return new Reachability().networkMonitor(); };
+//# sourceMappingURL=index.js.map

package/lib-esm/utils/ReachabilityMonitor/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/utils/ReachabilityMonitor/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAEjD,MAAM,CAAC,IAAM,mBAAmB,GAAG,cAAM,OAAA,IAAI,YAAY,EAAE,CAAC,cAAc,EAAE,EAAnC,CAAmC,CAAC"}

package/lib-esm/utils/ReachabilityMonitor/index.native.d.ts

@@ -0,0 +1,3 @@
+export declare const ReachabilityMonitor: () => import("zen-observable-ts").default<{
+    online: boolean;
+}>;

package/lib-esm/utils/ReachabilityMonitor/index.native.js

@@ -0,0 +1,6 @@
+import { Reachability } from '@aws-amplify/core';
+import { default as NetInfo } from '@react-native-community/netinfo';
+export var ReachabilityMonitor = function () {
+    return new Reachability().networkMonitor(NetInfo);
+};
+//# sourceMappingURL=index.native.js.map

package/lib-esm/utils/ReachabilityMonitor/index.native.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.native.js","sourceRoot":"","sources":["../../../src/utils/ReachabilityMonitor/index.native.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,EAAE,OAAO,IAAI,OAAO,EAAE,MAAM,iCAAiC,CAAC;AAErE,MAAM,CAAC,IAAM,mBAAmB,GAAG;IAClC,OAAA,IAAI,YAAY,EAAE,CAAC,cAAc,CAAC,OAAO,CAAC;AAA1C,CAA0C,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aws-amplify/pubsub",
-  "version": "4.2.6-custom-pk.97+f42d7ac04",
+  "version": "4.2.6-custom-pk.98+b9656543b",
   "description": "Pubsub category of aws-amplify",
   "main": "./lib/index.js",
   "module": "./lib-esm/index.js",
@@ -45,9 +45,9 @@
     "cpx": "^1.5.0"
   },
   "dependencies": {
-    "@aws-amplify/auth": "4.3.20-custom-pk.97+f42d7ac04",
-    "@aws-amplify/cache": "4.0.32-custom-pk.97+f42d7ac04",
-    "@aws-amplify/core": "4.3.12-custom-pk.97+f42d7ac04",
+    "@aws-amplify/auth": "4.3.20-custom-pk.98+b9656543b",
+    "@aws-amplify/cache": "4.0.32-custom-pk.98+b9656543b",
+    "@aws-amplify/core": "4.3.12-custom-pk.98+b9656543b",
     "graphql": "15.8.0",
     "paho-mqtt": "^1.1.0",
     "uuid": "^3.2.1",
@@ -103,5 +103,5 @@
       "lib-esm"
     ]
   },
-  "gitHead": "f42d7ac045b4421c1da433e051f91c41b568c03c"
+  "gitHead": "b9656543bd5572aa18162805a2370d676961563e"
 }

package/src/Providers/AWSAppSyncRealTimeProvider/index.ts

@@ -30,19 +30,25 @@ import {
 import Cache from '@aws-amplify/cache';
 import Auth, { GRAPHQL_AUTH_MODE } from '@aws-amplify/auth';
 import { AbstractPubSubProvider } from '../PubSubProvider';
-import { CONTROL_MSG } from '../../index';
+import { CONNECTION_STATE_CHANGE, CONTROL_MSG } from '../../index';
+
 import {
 	AMPLIFY_SYMBOL,
 	AWS_APPSYNC_REALTIME_HEADERS,
 	CONNECTION_INIT_TIMEOUT,
 	DEFAULT_KEEP_ALIVE_TIMEOUT,
+	DEFAULT_KEEP_ALIVE_ALERT_TIMEOUT,
 	MAX_DELAY_MS,
 	MESSAGE_TYPES,
 	NON_RETRYABLE_CODES,
 	SOCKET_STATUS,
 	START_ACK_TIMEOUT,
 	SUBSCRIPTION_STATUS,
-} from './constants';
+} from '../constants';
+import {
+	ConnectionStateMonitor,
+	CONNECTION_CHANGE,
+} from '../../utils/ConnectionStateMonitor';
 
 const logger = new Logger('AWSAppSyncRealTimeProvider');
 
@@ -89,8 +95,27 @@ export class AWSAppSyncRealTimeProvider extends AbstractPubSubProvider {
 	private socketStatus: SOCKET_STATUS = SOCKET_STATUS.CLOSED;
 	private keepAliveTimeoutId?: ReturnType<typeof setTimeout>;
 	private keepAliveTimeout = DEFAULT_KEEP_ALIVE_TIMEOUT;
+	private keepAliveAlertTimeoutId?: ReturnType<typeof setTimeout>;
 	private subscriptionObserverMap: Map<string, ObserverQuery> = new Map();
 	private promiseArray: Array<{ res: Function; rej: Function }> = [];
+	private readonly connectionStateMonitor = new ConnectionStateMonitor();
+
+	constructor(options: ProviderOptions = {}) {
+		super(options);
+		// Monitor the connection state and pass changes along to Hub
+		this.connectionStateMonitor.connectionStateObservable.subscribe(
+			ConnectionState => {
+				dispatchApiEvent(
+					CONNECTION_STATE_CHANGE,
+					{
+						provider: this,
+						connectionState: ConnectionState,
+					},
+					`Connection state is ${ConnectionState}`
+				);
+			}
+		);
+	}
 
 	getNewWebSocket(url, protocol) {
 		return new WebSocket(url, protocol);
@@ -147,6 +172,7 @@ export class AWSAppSyncRealTimeProvider extends AbstractPubSubProvider {
 							},
 						],
 					});
+					this.connectionStateMonitor.record(CONNECTION_CHANGE.CLOSED);
 					observer.complete();
 				});
 
@@ -252,6 +278,7 @@ export class AWSAppSyncRealTimeProvider extends AbstractPubSubProvider {
 		const stringToAWSRealTime = JSON.stringify(subscriptionMessage);
 
 		try {
+			this.connectionStateMonitor.record(CONNECTION_CHANGE.OPENING_CONNECTION);
 			await this._initializeWebSocketConnection({
 				apiKey,
 				appSyncGraphqlEndpoint,
@@ -262,6 +289,7 @@ export class AWSAppSyncRealTimeProvider extends AbstractPubSubProvider {
 		} catch (err) {
 			logger.debug({ err });
 			const message = err['message'] ?? '';
+			this.connectionStateMonitor.record(CONNECTION_CHANGE.CLOSED);
 			observer.error({
 				errors: [
 					{
@@ -366,12 +394,20 @@ export class AWSAppSyncRealTimeProvider extends AbstractPubSubProvider {
 			this.socketStatus = SOCKET_STATUS.CLOSED;
 			return;
 		}
+
+		this.connectionStateMonitor.record(CONNECTION_CHANGE.CLOSING_CONNECTION);
+
 		if (this.awsRealTimeSocket.bufferedAmount > 0) {
 			// Still data on the WebSocket
 			setTimeout(this._closeSocketIfRequired.bind(this), 1000);
 		} else {
 			logger.debug('closing WebSocket...');
-			if (this.keepAliveTimeoutId) clearTimeout(this.keepAliveTimeoutId);
+			if (this.keepAliveTimeoutId) {
+				clearTimeout(this.keepAliveTimeoutId);
+			}
+			if (this.keepAliveAlertTimeoutId) {
+				clearTimeout(this.keepAliveAlertTimeoutId);
+			}
 			const tempSocket = this.awsRealTimeSocket;
 			// Cleaning callbacks to avoid race condition, socket still exists
 			tempSocket.onclose = null;
@@ -379,6 +415,7 @@ export class AWSAppSyncRealTimeProvider extends AbstractPubSubProvider {
 			tempSocket.close(1000);
 			this.awsRealTimeSocket = undefined;
 			this.socketStatus = SOCKET_STATUS.CLOSED;
+			this.connectionStateMonitor.record(CONNECTION_CHANGE.CLOSED);
 		}
 	}
 
@@ -432,17 +469,25 @@ export class AWSAppSyncRealTimeProvider extends AbstractPubSubProvider {
 					subscriptionFailedCallback,
 				});
 			}
+			this.connectionStateMonitor.record(
+				CONNECTION_CHANGE.CONNECTION_ESTABLISHED
+			);
 
-			// TODO: emit event on hub but it requires to store the id first
 			return;
 		}
 
 		if (type === MESSAGE_TYPES.GQL_CONNECTION_KEEP_ALIVE) {
 			if (this.keepAliveTimeoutId) clearTimeout(this.keepAliveTimeoutId);
+			if (this.keepAliveAlertTimeoutId)
+				clearTimeout(this.keepAliveAlertTimeoutId);
 			this.keepAliveTimeoutId = setTimeout(
-				this._errorDisconnect.bind(this, CONTROL_MSG.TIMEOUT_DISCONNECT),
+				() => this._errorDisconnect(CONTROL_MSG.TIMEOUT_DISCONNECT),
 				this.keepAliveTimeout
 			);
+			this.keepAliveAlertTimeoutId = setTimeout(() => {
+				this.connectionStateMonitor.record(CONNECTION_CHANGE.KEEP_ALIVE_MISSED);
+			}, DEFAULT_KEEP_ALIVE_ALERT_TIMEOUT);
+			this.connectionStateMonitor.record(CONNECTION_CHANGE.KEEP_ALIVE);
 			return;
 		}
 
@@ -489,6 +534,7 @@ export class AWSAppSyncRealTimeProvider extends AbstractPubSubProvider {
 		});
 		this.subscriptionObserverMap.clear();
 		if (this.awsRealTimeSocket) {
+			this.connectionStateMonitor.record(CONNECTION_CHANGE.CLOSED);
 			this.awsRealTimeSocket.close();
 		}
 
@@ -630,6 +676,9 @@ export class AWSAppSyncRealTimeProvider extends AbstractPubSubProvider {
 						logger.debug(`WebSocket connection error`);
 					};
 					newSocket.onclose = () => {
+						this.connectionStateMonitor.record(
+							CONNECTION_CHANGE.CONNECTION_FAILED
+						);
 						rej(new Error('Connection handshake error'));
 					};
 					newSocket.onopen = () => {
@@ -698,17 +747,20 @@ export class AWSAppSyncRealTimeProvider extends AbstractPubSubProvider {
 						};
 						this.awsRealTimeSocket.send(JSON.stringify(gqlInit));
 
-						setTimeout(checkAckOk.bind(this, ackOk), CONNECTION_INIT_TIMEOUT);
-					}
+						const checkAckOk = (ackOk: boolean) => {
+							if (!ackOk) {
+								this.connectionStateMonitor.record(
+									CONNECTION_CHANGE.CONNECTION_FAILED
+								);
+								rej(
+									new Error(
+										`Connection timeout: ack from AWSAppSyncRealTime was not received after ${CONNECTION_INIT_TIMEOUT} ms`
+									)
+								);
+							}
+						};
 
-					function checkAckOk(ackOk: boolean) {
-						if (!ackOk) {
-							rej(
-								new Error(
-									`Connection timeout: ack from AWSRealTime was not received on ${CONNECTION_INIT_TIMEOUT} ms`
-								)
-							);
-						}
+						setTimeout(() => checkAckOk(ackOk), CONNECTION_INIT_TIMEOUT);
 					}
 				});
 			})();

package/src/Providers/MqttOverWSProvider.ts

@@ -16,7 +16,13 @@ import Observable from 'zen-observable-ts';
 
 import { AbstractPubSubProvider } from './PubSubProvider';
 import { ProviderOptions, SubscriptionObserver } from '../types';
-import { ConsoleLogger as Logger } from '@aws-amplify/core';
+import { ConsoleLogger as Logger, Hub } from '@aws-amplify/core';
+import {
+	ConnectionStateMonitor,
+	CONNECTION_CHANGE,
+} from '../utils/ConnectionStateMonitor';
+import { AMPLIFY_SYMBOL } from './constants';
+import { CONNECTION_STATE_CHANGE } from '..';
 
 const logger = new Logger('MqttOverWSProvider');
 
@@ -72,13 +78,32 @@ class ClientsQueue {
 	}
 }
 
+const dispatchPubSubEvent = (event: string, data: any, message: string) => {
+	Hub.dispatch('pubsub', { event, data, message }, 'PubSub', AMPLIFY_SYMBOL);
+};
+
 const topicSymbol = typeof Symbol !== 'undefined' ? Symbol('topic') : '@@topic';
 
 export class MqttOverWSProvider extends AbstractPubSubProvider {
 	private _clientsQueue = new ClientsQueue();
+	private readonly connectionStateMonitor = new ConnectionStateMonitor();
 
 	constructor(options: MqttProviderOptions = {}) {
 		super({ ...options, clientId: options.clientId || uuid() });
+
+		// Monitor the connection health state and pass changes along to Hub
+		this.connectionStateMonitor.connectionStateObservable.subscribe(
+			connectionStateChange => {
+				dispatchPubSubEvent(
+					CONNECTION_STATE_CHANGE,
+					{
+						provider: this,
+						connectionState: connectionStateChange,
+					},
+					`Connection state is ${connectionStateChange}`
+				);
+			}
+		);
 	}
 
 	protected get clientId() {
@@ -149,6 +174,7 @@ export class MqttOverWSProvider extends AbstractPubSubProvider {
 	public async newClient({ url, clientId }: MqttProviderOptions): Promise<any> {
 		logger.debug('Creating new MQTT client', clientId);
 
+		this.connectionStateMonitor.record(CONNECTION_CHANGE.OPENING_CONNECTION);
 		// @ts-ignore
 		const client = new Paho.Client(url, clientId);
 		// client.trace = (args) => logger.debug(clientId, JSON.stringify(args, null, 2));
@@ -168,6 +194,7 @@ export class MqttOverWSProvider extends AbstractPubSubProvider {
 			errorCode: number;
 		}) => {
 			this.onDisconnect({ clientId, errorCode, ...args });
+			this.connectionStateMonitor.record(CONNECTION_CHANGE.CLOSED);
 		};
 
 		await new Promise((resolve, reject) => {
@@ -175,10 +202,19 @@ export class MqttOverWSProvider extends AbstractPubSubProvider {
 				useSSL: this.isSSLEnabled,
 				mqttVersion: 3,
 				onSuccess: () => resolve(client),
-				onFailure: reject,
+				onFailure: () => {
+					reject();
+					this.connectionStateMonitor.record(
+						CONNECTION_CHANGE.CONNECTION_FAILED
+					);
+				},
 			});
 		});
 
+		this.connectionStateMonitor.record(
+			CONNECTION_CHANGE.CONNECTION_ESTABLISHED
+		);
+
 		return client;
 	}
 
@@ -196,6 +232,7 @@ export class MqttOverWSProvider extends AbstractPubSubProvider {
 
 		if (client && client.isConnected()) {
 			client.disconnect();
+			this.connectionStateMonitor.record(CONNECTION_CHANGE.CLOSED);
 		}
 		this.clientsQueue.remove(clientId);
 	}
@@ -293,6 +330,10 @@ export class MqttOverWSProvider extends AbstractPubSubProvider {
 					this._clientIdObservers.get(clientId)?.delete(observer);
 					// No more observers per client => client not needed anymore
 					if (this._clientIdObservers.get(clientId)?.size === 0) {
+						this.connectionStateMonitor.record(
+							CONNECTION_CHANGE.CLOSING_CONNECTION
+						);
+
 						this.disconnect(clientId);
 						this._clientIdObservers.delete(clientId);
 					}

package/src/Providers/{AWSAppSyncRealTimeProvider/constants.ts → constants.ts}

@@ -93,3 +93,8 @@ export const START_ACK_TIMEOUT = 15000;
  * Default Time in milleseconds to wait for GQL_CONNECTION_KEEP_ALIVE message
  */
 export const DEFAULT_KEEP_ALIVE_TIMEOUT = 5 * 60 * 1000;
+
+/**
+ * Default Time in milleseconds to alert for missed GQL_CONNECTION_KEEP_ALIVE message
+ */
+export const DEFAULT_KEEP_ALIVE_ALERT_TIMEOUT = 65 * 1000;

package/src/index.ts

@@ -22,6 +22,9 @@ enum CONTROL_MSG {
 	TIMEOUT_DISCONNECT = 'Timeout disconnect',
 }
 
+export const CONNECTION_STATE_CHANGE = 'ConnectionStateChange';
+export { ConnectionState } from './types';
+
 export { PubSub, CONTROL_MSG };
 
 /**