@aws-amplify/pubsub 4.4.9 → 4.4.10-next.20

package/src/Providers/AWSAppSyncRealTimeProvider/index.ts

@@ -15,7 +15,7 @@ import { GraphQLError } from 'graphql';
 import * as url from 'url';
 import { v4 as uuid } from 'uuid';
 import { Buffer } from 'buffer';
-import { ProviderOptions } from '../../types';
+import { ProviderOptions } from '../../types/Provider';
 import {
 	Logger,
 	Credentials,
@@ -26,11 +26,12 @@ import {
 	jitteredExponentialRetry,
 	NonRetryableError,
 	ICredentials,
+	isNonRetryableError,
 } from '@aws-amplify/core';
 import Cache from '@aws-amplify/cache';
 import Auth, { GRAPHQL_AUTH_MODE } from '@aws-amplify/auth';
 import { AbstractPubSubProvider } from '../PubSubProvider';
-import { CONNECTION_STATE_CHANGE, CONTROL_MSG } from '../../index';
+import { CONTROL_MSG, ConnectionState } from '../../types/PubSub';
 
 import {
 	AMPLIFY_SYMBOL,
@@ -44,11 +45,16 @@ import {
 	SOCKET_STATUS,
 	START_ACK_TIMEOUT,
 	SUBSCRIPTION_STATUS,
-} from './constants';
+	CONNECTION_STATE_CHANGE,
+} from '../constants';
 import {
 	ConnectionStateMonitor,
 	CONNECTION_CHANGE,
 } from '../../utils/ConnectionStateMonitor';
+import {
+	ReconnectEvent,
+	ReconnectionMonitor,
+} from '../../utils/ReconnectionMonitor';
 
 const logger = new Logger('AWSAppSyncRealTimeProvider');
 
@@ -98,23 +104,63 @@ export class AWSAppSyncRealTimeProvider extends AbstractPubSubProvider {
 	private keepAliveAlertTimeoutId?: ReturnType<typeof setTimeout>;
 	private subscriptionObserverMap: Map<string, ObserverQuery> = new Map();
 	private promiseArray: Array<{ res: Function; rej: Function }> = [];
+	private connectionState: ConnectionState;
 	private readonly connectionStateMonitor = new ConnectionStateMonitor();
+	private readonly reconnectionMonitor = new ReconnectionMonitor();
+	private connectionStateMonitorSubscription: ZenObservable.Subscription;
 
 	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}`
-				);
-			}
-		);
+		this.connectionStateMonitorSubscription =
+			this.connectionStateMonitor.connectionStateObservable.subscribe(
+				connectionState => {
+					dispatchApiEvent(
+						CONNECTION_STATE_CHANGE,
+						{
+							provider: this,
+							connectionState,
+						},
+						`Connection state is ${connectionState}`
+					);
+					this.connectionState = connectionState;
+
+					// Trigger START_RECONNECT when the connection is disrupted
+					if (connectionState === ConnectionState.ConnectionDisrupted) {
+						this.reconnectionMonitor.record(ReconnectEvent.START_RECONNECT);
+					}
+
+					// Trigger HALT_RECONNECT to halt reconnection attempts when the state is anything other than
+					//   ConnectionDisrupted or Connecting
+					if (
+						[
+							ConnectionState.Connected,
+							ConnectionState.ConnectedPendingDisconnect,
+							ConnectionState.ConnectedPendingKeepAlive,
+							ConnectionState.ConnectedPendingNetwork,
+							ConnectionState.ConnectedPendingNetwork,
+							ConnectionState.ConnectionDisruptedPendingNetwork,
+							ConnectionState.Disconnected,
+						].includes(connectionState)
+					) {
+						this.reconnectionMonitor.record(ReconnectEvent.HALT_RECONNECT);
+					}
+				}
+			);
+	}
+
+	/**
+	 * Mark the socket closed and release all active listeners
+	 */
+	close() {
+		// Mark the socket closed both in status and the connection monitor
+		this.socketStatus = SOCKET_STATUS.CLOSED;
+		this.connectionStateMonitor.record(CONNECTION_CHANGE.CONNECTION_FAILED);
+
+		// Turn off the subscription monitor Hub publishing
+		this.connectionStateMonitorSubscription.unsubscribe();
+		// Complete all reconnect observers
+		this.reconnectionMonitor.close();
 	}
 
 	getNewWebSocket(url, protocol) {
@@ -157,26 +203,44 @@ export class AWSAppSyncRealTimeProvider extends AbstractPubSubProvider {
 				});
 				observer.complete();
 			} else {
+				let subscriptionStartActive = false;
 				const subscriptionId = uuid();
-				this._startSubscriptionWithAWSAppSyncRealTime({
-					options,
-					observer,
-					subscriptionId,
-				}).catch<any>(err => {
-					observer.error({
-						errors: [
-							{
-								...new GraphQLError(
+				const startSubscription = () => {
+					if (!subscriptionStartActive) {
+						subscriptionStartActive = true;
+						const startSubscriptionPromise =
+							this._startSubscriptionWithAWSAppSyncRealTime({
+								options,
+								observer,
+								subscriptionId,
+							}).catch<any>(err => {
+								logger.debug(
 									`${CONTROL_MSG.REALTIME_SUBSCRIPTION_INIT_ERROR}: ${err}`
-								),
-							},
-						],
-					});
-					this.connectionStateMonitor.record(CONNECTION_CHANGE.CLOSED);
-					observer.complete();
+								);
+
+								this.connectionStateMonitor.record(CONNECTION_CHANGE.CLOSED);
+							});
+						startSubscriptionPromise.finally(() => {
+							subscriptionStartActive = false;
+						});
+					}
+				};
+
+				let reconnectSubscription: ZenObservable.Subscription;
+
+				// Add an observable to the reconnection list to manage reconnection for this subscription
+				reconnectSubscription = new Observable(observer => {
+					this.reconnectionMonitor.addObserver(observer);
+				}).subscribe(() => {
+					startSubscription();
 				});
 
+				startSubscription();
+
 				return async () => {
+					// Cleanup reconnection subscription
+					reconnectSubscription?.unsubscribe();
+
 					// Cleanup after unsubscribing or observer.complete was called after _startSubscriptionWithAWSAppSyncRealTime
 					try {
 						// Waiting that subscription has been connected before trying to unsubscribe
@@ -287,24 +351,7 @@ export class AWSAppSyncRealTimeProvider extends AbstractPubSubProvider {
 				additionalHeaders,
 			});
 		} catch (err) {
-			logger.debug({ err });
-			const message = err['message'] ?? '';
-			this.connectionStateMonitor.record(CONNECTION_CHANGE.CLOSED);
-			observer.error({
-				errors: [
-					{
-						...new GraphQLError(`${CONTROL_MSG.CONNECTION_FAILED}: ${message}`),
-					},
-				],
-			});
-			observer.complete();
-			const { subscriptionFailedCallback } =
-				this.subscriptionObserverMap.get(subscriptionId) || {};
-
-			// Notify concurrent unsubscription
-			if (typeof subscriptionFailedCallback === 'function') {
-				subscriptionFailedCallback();
-			}
+			this._logStartSubscriptionError(subscriptionId, observer, err);
 			return;
 		}
 
@@ -332,6 +379,44 @@ export class AWSAppSyncRealTimeProvider extends AbstractPubSubProvider {
 		}
 	}
 
+	// Log logic for start subscription failures
+	private _logStartSubscriptionError(subscriptionId, observer, err) {
+		logger.debug({ err });
+		const message = err['message'] ?? '';
+		// Resolving to give the state observer time to propogate the update
+		Promise.resolve(
+			this.connectionStateMonitor.record(CONNECTION_CHANGE.CLOSED)
+		);
+
+		// Capture the error only when the network didn't cause disruption
+		if (
+			this.connectionState !== ConnectionState.ConnectionDisruptedPendingNetwork
+		) {
+			// When the error is non-retriable, error out the observable
+			if (isNonRetryableError(err)) {
+				observer.error({
+					errors: [
+						{
+							...new GraphQLError(
+								`${CONTROL_MSG.CONNECTION_FAILED}: ${message}`
+							),
+						},
+					],
+				});
+			} else {
+				logger.debug(`${CONTROL_MSG.CONNECTION_FAILED}: ${message}`);
+			}
+
+			const { subscriptionFailedCallback } =
+				this.subscriptionObserverMap.get(subscriptionId) || {};
+
+			// Notify concurrent unsubscription
+			if (typeof subscriptionFailedCallback === 'function') {
+				subscriptionFailedCallback();
+			}
+		}
+	}
+
 	// Waiting that subscription has been connected before trying to unsubscribe
 	private async _waitForSubscriptionToBeConnected(subscriptionId: string) {
 		const subscriptionObserver =
@@ -504,6 +589,10 @@ export class AWSAppSyncRealTimeProvider extends AbstractPubSubProvider {
 					subscriptionState,
 				});
 
+				logger.debug(
+					`${CONTROL_MSG.CONNECTION_FAILED}: ${JSON.stringify(payload)}`
+				);
+
 				observer.error({
 					errors: [
 						{
@@ -513,9 +602,9 @@ export class AWSAppSyncRealTimeProvider extends AbstractPubSubProvider {
 						},
 					],
 				});
+
 				if (startAckTimeoutId) clearTimeout(startAckTimeoutId);
 
-				observer.complete();
 				if (typeof subscriptionFailedCallback === 'function') {
 					subscriptionFailedCallback();
 				}
@@ -525,14 +614,7 @@ export class AWSAppSyncRealTimeProvider extends AbstractPubSubProvider {
 
 	private _errorDisconnect(msg: string) {
 		logger.debug(`Disconnect error: ${msg}`);
-		this.subscriptionObserverMap.forEach(({ observer }) => {
-			if (observer && !observer.closed) {
-				observer.error({
-					errors: [{ ...new GraphQLError(msg) }],
-				});
-			}
-		});
-		this.subscriptionObserverMap.clear();
+
 		if (this.awsRealTimeSocket) {
 			this.connectionStateMonitor.record(CONNECTION_CHANGE.CLOSED);
 			this.awsRealTimeSocket.close();
@@ -556,22 +638,7 @@ export class AWSAppSyncRealTimeProvider extends AbstractPubSubProvider {
 				subscriptionState: SUBSCRIPTION_STATUS.FAILED,
 			});
 
-			if (observer && !observer.closed) {
-				observer.error({
-					errors: [
-						{
-							...new GraphQLError(
-								`Subscription timeout ${JSON.stringify({
-									query,
-									variables,
-								})}`
-							),
-						},
-					],
-				});
-				// Cleanup will be automatically executed
-				observer.complete();
-			}
+			this.connectionStateMonitor.record(CONNECTION_CHANGE.CLOSED);
 			logger.debug(
 				'timeoutStartSubscription',
 				JSON.stringify({ query, variables })
@@ -640,6 +707,7 @@ export class AWSAppSyncRealTimeProvider extends AbstractPubSubProvider {
 					this.socketStatus = SOCKET_STATUS.READY;
 					this.promiseArray = [];
 				} catch (err) {
+					logger.debug('Connection exited with', err);
 					this.promiseArray.forEach(({ rej }) => rej(err));
 					this.promiseArray = [];
 					if (
@@ -676,9 +744,6 @@ 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 = () => {
@@ -687,7 +752,6 @@ export class AWSAppSyncRealTimeProvider extends AbstractPubSubProvider {
 					};
 				});
 			})();
-
 			// Step 2: wait for ack from AWS AppSyncReaTime after sending init
 			await (() => {
 				return new Promise((res, rej) => {
@@ -747,20 +811,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) {
-							this.connectionStateMonitor.record(
-								CONNECTION_CHANGE.CONNECTION_FAILED
-							);
-							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

@@ -12,11 +12,21 @@
  */
 import * as Paho from 'paho-mqtt';
 import { v4 as uuid } from 'uuid';
-import Observable from 'zen-observable-ts';
+import Observable, { ZenObservable } from 'zen-observable-ts';
 
 import { AbstractPubSubProvider } from './PubSubProvider';
-import { ProviderOptions, SubscriptionObserver } from '../types';
-import { ConsoleLogger as Logger } from '@aws-amplify/core';
+import { SubscriptionObserver, ConnectionState } from '../types/PubSub';
+import { ProviderOptions } from '../types/Provider';
+import { ConsoleLogger as Logger, Hub } from '@aws-amplify/core';
+import {
+	ConnectionStateMonitor,
+	CONNECTION_CHANGE,
+} from '../utils/ConnectionStateMonitor';
+import {
+	ReconnectEvent,
+	ReconnectionMonitor,
+} from '../utils/ReconnectionMonitor';
+import { AMPLIFY_SYMBOL, CONNECTION_STATE_CHANGE } from './constants';
 
 const logger = new Logger('MqttOverWSProvider');
 
@@ -49,17 +59,15 @@ class ClientsQueue {
 
 	async get(clientId: string, clientFactory?: (input: string) => Promise<any>) {
 		const cachedPromise = this.promises.get(clientId);
-		if (cachedPromise) {
-			return cachedPromise;
-		}
+		if (cachedPromise) return cachedPromise;
 
 		if (clientFactory) {
 			const newPromise = clientFactory(clientId);
-
 			this.promises.set(clientId, newPromise);
-
+			newPromise.catch(v => this.promises.delete(clientId));
 			return newPromise;
 		}
+
 		return undefined;
 	}
 
@@ -72,13 +80,44 @@ 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 connectionState: ConnectionState;
+	private readonly connectionStateMonitor = new ConnectionStateMonitor();
+	private readonly reconnectionMonitor = new ReconnectionMonitor();
 
 	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}`
+				);
+
+				this.connectionState = connectionStateChange;
+
+				// Trigger reconnection when the connection is disrupted
+				if (connectionStateChange === ConnectionState.ConnectionDisrupted) {
+					this.reconnectionMonitor.record(ReconnectEvent.START_RECONNECT);
+				} else if (connectionStateChange !== ConnectionState.Connecting) {
+					// Trigger connected to halt reconnection attempts
+					this.reconnectionMonitor.record(ReconnectEvent.HALT_RECONNECT);
+				}
+			}
+		);
 	}
 
 	protected get clientId() {
@@ -117,7 +156,6 @@ export class MqttOverWSProvider extends AbstractPubSubProvider {
 		if (errorCode !== 0) {
 			logger.warn(clientId, JSON.stringify({ errorCode, ...args }, null, 2));
 
-			const topicsToDelete: string[] = [];
 			if (!clientId) {
 				return;
 			}
@@ -125,33 +163,17 @@ export class MqttOverWSProvider extends AbstractPubSubProvider {
 			if (!clientIdObservers) {
 				return;
 			}
-			clientIdObservers.forEach(observer => {
-				observer.error('Disconnected, error code: ' + errorCode);
-				// removing observers for disconnected clientId
-				this._topicObservers.forEach((observerForTopic, observerTopic) => {
-					observerForTopic.delete(observer);
-					if (observerForTopic.size === 0) {
-						topicsToDelete.push(observerTopic);
-					}
-				});
-			});
-
-			// forgiving any trace of clientId
-			this._clientIdObservers.delete(clientId);
-
-			// Removing topics that are not listen by an observer
-			topicsToDelete.forEach(topic => {
-				this._topicObservers.delete(topic);
-			});
+			this.disconnect(clientId);
 		}
 	}
 
 	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));
+
 		client.onMessageArrived = ({
 			destinationName: topic,
 			payloadString: msg,
@@ -168,17 +190,28 @@ export class MqttOverWSProvider extends AbstractPubSubProvider {
 			errorCode: number;
 		}) => {
 			this.onDisconnect({ clientId, errorCode, ...args });
+			this.connectionStateMonitor.record(CONNECTION_CHANGE.CLOSED);
 		};
 
-		await new Promise((resolve, reject) => {
+		const connected = await new Promise((resolve, reject) => {
 			client.connect({
 				useSSL: this.isSSLEnabled,
 				mqttVersion: 3,
-				onSuccess: () => resolve(client),
-				onFailure: reject,
+				onSuccess: () => resolve(true),
+				onFailure: x => {
+					if (clientId) this._clientsQueue.remove(clientId);
+					this.connectionStateMonitor.record(CONNECTION_CHANGE.CLOSED);
+					resolve(false);
+				},
 			});
 		});
 
+		if (connected) {
+			this.connectionStateMonitor.record(
+				CONNECTION_CHANGE.CONNECTION_ESTABLISHED
+			);
+		}
+
 		return client;
 	}
 
@@ -186,9 +219,19 @@ export class MqttOverWSProvider extends AbstractPubSubProvider {
 		clientId: string,
 		options: MqttProviderOptions = {}
 	): Promise<any> {
-		return await this.clientsQueue.get(clientId, clientId =>
-			this.newClient({ ...options, clientId })
-		);
+		return await this.clientsQueue.get(clientId, async clientId => {
+			const client = await this.newClient({ ...options, clientId });
+
+			if (client) {
+				// Once connected, subscribe to all topics registered observers
+				this._topicObservers.forEach(
+					(_value: Set<SubscriptionObserver<any>>, key: string) => {
+						client.subscribe(key);
+					}
+				);
+			}
+			return client;
+		});
 	}
 
 	protected async disconnect(clientId: string): Promise<void> {
@@ -198,18 +241,25 @@ export class MqttOverWSProvider extends AbstractPubSubProvider {
 			client.disconnect();
 		}
 		this.clientsQueue.remove(clientId);
+		this.connectionStateMonitor.record(CONNECTION_CHANGE.CLOSED);
 	}
 
 	async publish(topics: string[] | string, msg: any) {
 		const targetTopics = ([] as string[]).concat(topics);
 		const message = JSON.stringify(msg);
 
-		const url = await this.endpoint;
-
-		const client = await this.connect(this.clientId, { url });
-
-		logger.debug('Publishing to topic(s)', targetTopics.join(','), message);
-		targetTopics.forEach(topic => client.send(topic, message));
+		const client = await this.clientsQueue.get(this.clientId);
+
+		if (client) {
+			logger.debug('Publishing to topic(s)', targetTopics.join(','), message);
+			targetTopics.forEach(topic => client.send(topic, message));
+		} else {
+			logger.debug(
+				'Publishing to topic(s) failed',
+				targetTopics.join(','),
+				message
+			);
+		}
 	}
 
 	protected _topicObservers: Map<string, Set<SubscriptionObserver<any>>> =
@@ -246,6 +296,7 @@ export class MqttOverWSProvider extends AbstractPubSubProvider {
 	): Observable<any> {
 		const targetTopics = ([] as string[]).concat(topics);
 		logger.debug('Subscribing to topic(s)', targetTopics.join(','));
+		let reconnectSubscription: ZenObservable.Subscription;
 
 		return new Observable(observer => {
 			targetTopics.forEach(topic => {
@@ -261,8 +312,6 @@ export class MqttOverWSProvider extends AbstractPubSubProvider {
 				observersForTopic.add(observer);
 			});
 
-			// @ts-ignore
-			let client: Paho.Client;
 			const { clientId = this.clientId } = options;
 
 			// this._clientIdObservers is used to close observers when client gets disconnected
@@ -274,26 +323,44 @@ export class MqttOverWSProvider extends AbstractPubSubProvider {
 			this._clientIdObservers.set(clientId, observersForClientId);
 
 			(async () => {
-				const { url = await this.endpoint } = options;
+				const getClient = async () => {
+					try {
+						const { url = await this.endpoint } = options;
+						const client = await this.connect(clientId, { url });
+						if (client !== undefined) {
+							targetTopics.forEach(topic => {
+								client.subscribe(topic);
+							});
+						}
+					} catch (e) {
+						logger.debug('Error forming connection', e);
+					}
+				};
 
-				try {
-					client = await this.connect(clientId, { url });
-					targetTopics.forEach(topic => {
-						client.subscribe(topic);
-					});
-				} catch (e) {
-					observer.error(e);
-				}
+				// Establish the initial connection
+				await getClient();
+
+				// Add an observable to the reconnection list to manage reconnection for this subscription
+				reconnectSubscription = new Observable(observer => {
+					this.reconnectionMonitor.addObserver(observer);
+				}).subscribe(() => {
+					getClient();
+				});
 			})();
 
-			return () => {
-				logger.debug('Unsubscribing from topic(s)', targetTopics.join(','));
+			return async () => {
+				const client = await this.clientsQueue.get(clientId);
+
+				reconnectSubscription?.unsubscribe();
 
 				if (client) {
 					this._clientIdObservers.get(clientId)?.delete(observer);
 					// No more observers per client => client not needed anymore
 					if (this._clientIdObservers.get(clientId)?.size === 0) {
 						this.disconnect(clientId);
+						this.connectionStateMonitor.record(
+							CONNECTION_CHANGE.CLOSING_CONNECTION
+						);
 						this._clientIdObservers.delete(clientId);
 					}
 

package/src/Providers/PubSubProvider.ts

@@ -11,7 +11,7 @@
  * and limitations under the License.
  */
 import Observable from 'zen-observable-ts';
-import { PubSubProvider, ProviderOptions } from '../types';
+import { PubSubProvider, ProviderOptions } from '../types/Provider';
 import { ConsoleLogger as Logger } from '@aws-amplify/core';
 
 const logger = new Logger('AbstractPubSubProvider');

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

@@ -2,6 +2,8 @@ export const MAX_DELAY_MS = 5000;
 
 export const NON_RETRYABLE_CODES = [400, 401, 403];
 
+export const CONNECTION_STATE_CHANGE = 'ConnectionStateChange';
+
 export enum MESSAGE_TYPES {
 	/**
 	 * Client -> Server message.
@@ -98,3 +100,13 @@ 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;
+
+/**
+ * Default delay time in milleseconds between when reconnect is triggered vs when it is attempted
+ */
+export const RECONNECT_DELAY = 5 * 1000;
+
+/**
+ * Default interval time in milleseconds between when reconnect is re-attempted
+ */
+export const RECONNECT_INTERVAL = 60 * 1000;