@aws-amplify/pubsub 4.5.11 → 4.5.12-unstable.4

package/src/Providers/AWSAppSyncRealTimeProvider/index.ts

@@ -1,15 +1,5 @@
-/*
- * 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.
- */
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
 import Observable, { ZenObservable } from 'zen-observable-ts';
 import { GraphQLError } from 'graphql';
 import * as url from 'url';
@@ -26,11 +16,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 { Cache } from '@aws-amplify/cache';
+import { Auth, GRAPHQL_AUTH_MODE } from '@aws-amplify/auth';
 import { AbstractPubSubProvider } from '../PubSubProvider';
-import { CONTROL_MSG } from '../../types/PubSub';
+import { CONTROL_MSG, ConnectionState } from '../../types/PubSub';
 
 import {
 	AMPLIFY_SYMBOL,
@@ -50,6 +41,10 @@ import {
 	ConnectionStateMonitor,
 	CONNECTION_CHANGE,
 } from '../../utils/ConnectionStateMonitor';
+import {
+	ReconnectEvent,
+	ReconnectionMonitor,
+} from '../../utils/ReconnectionMonitor';
 
 const logger = new Logger('AWSAppSyncRealTimeProvider');
 
@@ -99,23 +94,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) {
@@ -158,26 +193,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
@@ -288,24 +341,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;
 		}
 
@@ -333,6 +369,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 =
@@ -505,6 +579,10 @@ export class AWSAppSyncRealTimeProvider extends AbstractPubSubProvider {
 					subscriptionState,
 				});
 
+				logger.debug(
+					`${CONTROL_MSG.CONNECTION_FAILED}: ${JSON.stringify(payload)}`
+				);
+
 				observer.error({
 					errors: [
 						{
@@ -514,9 +592,9 @@ export class AWSAppSyncRealTimeProvider extends AbstractPubSubProvider {
 						},
 					],
 				});
+
 				if (startAckTimeoutId) clearTimeout(startAckTimeoutId);
 
-				observer.complete();
 				if (typeof subscriptionFailedCallback === 'function') {
 					subscriptionFailedCallback();
 				}
@@ -526,14 +604,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();
@@ -557,22 +628,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 })
@@ -641,6 +697,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 (
@@ -677,9 +734,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 = () => {
@@ -688,7 +742,6 @@ export class AWSAppSyncRealTimeProvider extends AbstractPubSubProvider {
 					};
 				});
 			})();
-
 			// Step 2: wait for ack from AWS AppSyncReaTime after sending init
 			await (() => {
 				return new Promise((res, rej) => {

package/src/Providers/AWSIotProvider.ts

@@ -1,15 +1,5 @@
-/*
- * Copyright 2017-2018 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.
- */
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
 import { MqttOverWSProvider, MqttProviderOptions } from './MqttOverWSProvider';
 import { Signer, Credentials } from '@aws-amplify/core';
 

package/src/Providers/MqttOverWSProvider.ts

@@ -1,27 +1,21 @@
-/*
- * Copyright 2017-2018 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.
- */
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
 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 { SubscriptionObserver } from '../types/PubSub';
+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');
@@ -45,27 +39,20 @@ export interface MqttProviderOptions extends ProviderOptions {
 	url?: string;
 }
 
-/**
- * @deprecated Migrated to MqttProviderOptions
- */
-export type MqttProvidertOptions = MqttProviderOptions;
-
 class ClientsQueue {
 	private promises: Map<string, Promise<any>> = new Map();
 
 	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;
 	}
 
@@ -86,7 +73,9 @@ 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() });
@@ -102,6 +91,16 @@ export class MqttOverWSProvider extends AbstractPubSubProvider {
 					},
 					`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);
+				}
 			}
 		);
 	}
@@ -142,7 +141,6 @@ export class MqttOverWSProvider extends AbstractPubSubProvider {
 		if (errorCode !== 0) {
 			logger.warn(clientId, JSON.stringify({ errorCode, ...args }, null, 2));
 
-			const topicsToDelete: string[] = [];
 			if (!clientId) {
 				return;
 			}
@@ -150,24 +148,7 @@ 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);
 		}
 	}
 
@@ -177,7 +158,7 @@ export class MqttOverWSProvider extends AbstractPubSubProvider {
 		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,
@@ -197,23 +178,24 @@ export class MqttOverWSProvider extends AbstractPubSubProvider {
 			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();
-					this.connectionStateMonitor.record(
-						CONNECTION_CHANGE.CONNECTION_FAILED
-					);
+				onSuccess: () => resolve(true),
+				onFailure: x => {
+					if (clientId) this._clientsQueue.remove(clientId);
+					this.connectionStateMonitor.record(CONNECTION_CHANGE.CLOSED);
+					resolve(false);
 				},
 			});
 		});
 
-		this.connectionStateMonitor.record(
-			CONNECTION_CHANGE.CONNECTION_ESTABLISHED
-		);
+		if (connected) {
+			this.connectionStateMonitor.record(
+				CONNECTION_CHANGE.CONNECTION_ESTABLISHED
+			);
+		}
 
 		return client;
 	}
@@ -222,9 +204,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> {
@@ -232,21 +224,27 @@ export class MqttOverWSProvider extends AbstractPubSubProvider {
 
 		if (client && client.isConnected()) {
 			client.disconnect();
-			this.connectionStateMonitor.record(CONNECTION_CHANGE.CLOSED);
 		}
 		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>>> =
@@ -283,6 +281,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 => {
@@ -298,8 +297,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
@@ -311,30 +308,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.disconnect(clientId);
 						this._clientIdObservers.delete(clientId);
 					}
 

package/src/Providers/PubSubProvider.ts

@@ -1,15 +1,5 @@
-/*
- * Copyright 2017-2018 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.
- */
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
 import Observable from 'zen-observable-ts';
 import { PubSubProvider, ProviderOptions } from '../types/Provider';
 import { ConsoleLogger as Logger } from '@aws-amplify/core';

package/src/Providers/constants.ts

@@ -100,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;