@aws-amplify/api-graphql 4.0.1-api-v6-models.9351bcf.0 → 4.0.1-api-v6-models.891fe0d.0

package/lib-esm/Providers/AWSAppSyncRealTimeProvider/index.js

@@ -1,27 +1,22 @@
-import { __assign, __awaiter, __generator, __read } from "tslib";
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 import { Observable } from 'rxjs';
 import { GraphQLError } from 'graphql';
-import * as url from 'url';
-import { Buffer } from 'buffer';
 import { Hub, fetchAuthSession, ConsoleLogger } from '@aws-amplify/core';
 import { signRequest } from '@aws-amplify/core/internals/aws-client-utils';
-import { NonRetryableError, USER_AGENT_HEADER, getAmplifyUserAgent, isNonRetryableError, jitteredExponentialRetry, amplifyUuid, AmplifyUrl, } from '@aws-amplify/core/internals/utils';
+import { base64Encoder, NonRetryableError, USER_AGENT_HEADER, getAmplifyUserAgent, isNonRetryableError, jitteredExponentialRetry, amplifyUuid, AmplifyUrl, } from '@aws-amplify/core/internals/utils';
 import { CONTROL_MSG, ConnectionState, } from '../../types/PubSub';
 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, CONNECTION_STATE_CHANGE, } from '../constants';
 import { ConnectionStateMonitor, CONNECTION_CHANGE, } from '../../utils/ConnectionStateMonitor';
 import { ReconnectEvent, ReconnectionMonitor, } from '../../utils/ReconnectionMonitor';
-var logger = new ConsoleLogger('AWSAppSyncRealTimeProvider');
-var dispatchApiEvent = function (payload) {
+const logger = new ConsoleLogger('AWSAppSyncRealTimeProvider');
+const dispatchApiEvent = payload => {
     Hub.dispatch('api', payload, 'PubSub', AMPLIFY_SYMBOL);
 };
-var standardDomainPattern = /^https:\/\/\w{26}\.appsync\-api\.\w{2}(?:(?:\-\w{2,})+)\-\d\.amazonaws.com(?:\.cn)?\/graphql$/i;
-var customDomainPath = '/realtime';
-var AWSAppSyncRealTimeProvider = /** @class */ (function () {
-    function AWSAppSyncRealTimeProvider(options) {
-        if (options === void 0) { options = {}; }
-        var _this = this;
+const standardDomainPattern = /^https:\/\/\w{26}\.appsync\-api\.\w{2}(?:(?:\-\w{2,})+)\-\d\.amazonaws.com(?:\.cn)?\/graphql$/i;
+const customDomainPath = '/realtime';
+export class AWSAppSyncRealTimeProvider {
+    constructor(options = {}) {
         this.socketStatus = SOCKET_STATUS.CLOSED;
         this.keepAliveTimeout = DEFAULT_KEEP_ALIVE_TIMEOUT;
         this.subscriptionObserverMap = new Map();
@@ -30,19 +25,19 @@ var AWSAppSyncRealTimeProvider = /** @class */ (function () {
         this.reconnectionMonitor = new ReconnectionMonitor();
         // Monitor the connection state and pass changes along to Hub
         this.connectionStateMonitorSubscription =
-            this.connectionStateMonitor.connectionStateObservable.subscribe(function (connectionState) {
+            this.connectionStateMonitor.connectionStateObservable.subscribe(connectionState => {
                 dispatchApiEvent({
                     event: CONNECTION_STATE_CHANGE,
                     data: {
-                        provider: _this,
-                        connectionState: connectionState,
+                        provider: this,
+                        connectionState,
                     },
-                    message: "Connection state is ".concat(connectionState),
+                    message: `Connection state is ${connectionState}`,
                 });
-                _this.connectionState = connectionState;
+                this.connectionState = connectionState;
                 // Trigger START_RECONNECT when the connection is disrupted
                 if (connectionState === ConnectionState.ConnectionDisrupted) {
-                    _this.reconnectionMonitor.record(ReconnectEvent.START_RECONNECT);
+                    this.reconnectionMonitor.record(ReconnectEvent.START_RECONNECT);
                 }
                 // Trigger HALT_RECONNECT to halt reconnection attempts when the state is anything other than
                 //   ConnectionDisrupted or Connecting
@@ -54,14 +49,14 @@ var AWSAppSyncRealTimeProvider = /** @class */ (function () {
                     ConnectionState.ConnectionDisruptedPendingNetwork,
                     ConnectionState.Disconnected,
                 ].includes(connectionState)) {
-                    _this.reconnectionMonitor.record(ReconnectEvent.HALT_RECONNECT);
+                    this.reconnectionMonitor.record(ReconnectEvent.HALT_RECONNECT);
                 }
             });
     }
     /**
      * Mark the socket closed and release all active listeners
      */
-    AWSAppSyncRealTimeProvider.prototype.close = function () {
+    close() {
         // Mark the socket closed both in status and the connection monitor
         this.socketStatus = SOCKET_STATUS.CLOSED;
         this.connectionStateMonitor.record(CONNECTION_CHANGE.CONNECTION_FAILED);
@@ -69,202 +64,177 @@ var AWSAppSyncRealTimeProvider = /** @class */ (function () {
         this.connectionStateMonitorSubscription.unsubscribe();
         // Complete all reconnect observers
         this.reconnectionMonitor.close();
-    };
-    AWSAppSyncRealTimeProvider.prototype.getNewWebSocket = function (url, protocol) {
+    }
+    getNewWebSocket(url, protocol) {
         return new WebSocket(url, protocol);
-    };
-    AWSAppSyncRealTimeProvider.prototype.getProviderName = function () {
+    }
+    getProviderName() {
         return 'AWSAppSyncRealTimeProvider';
-    };
+    }
     // Check if url matches standard domain pattern
-    AWSAppSyncRealTimeProvider.prototype.isCustomDomain = function (url) {
+    isCustomDomain(url) {
         return url.match(standardDomainPattern) === null;
-    };
-    AWSAppSyncRealTimeProvider.prototype.subscribe = function (options, customUserAgentDetails) {
-        var _this = this;
-        var _a = options || {}, appSyncGraphqlEndpoint = _a.appSyncGraphqlEndpoint, region = _a.region, query = _a.query, variables = _a.variables, authenticationType = _a.authenticationType, additionalHeaders = _a.additionalHeaders, apiKey = _a.apiKey;
-        return new Observable(function (observer) {
+    }
+    subscribe(options, customUserAgentDetails) {
+        const { appSyncGraphqlEndpoint, region, query, variables, authenticationType, additionalHeaders, apiKey, } = options || {};
+        return new Observable(observer => {
             if (!options || !appSyncGraphqlEndpoint) {
                 observer.error({
                     errors: [
-                        __assign({}, new GraphQLError("Subscribe only available for AWS AppSync endpoint")),
+                        {
+                            ...new GraphQLError(`Subscribe only available for AWS AppSync endpoint`),
+                        },
                     ],
                 });
                 observer.complete();
             }
             else {
-                var subscriptionStartActive_1 = false;
-                var subscriptionId_1 = amplifyUuid();
-                var startSubscription_1 = function () {
-                    if (!subscriptionStartActive_1) {
-                        subscriptionStartActive_1 = true;
-                        var startSubscriptionPromise = _this._startSubscriptionWithAWSAppSyncRealTime({
+                let subscriptionStartActive = false;
+                const subscriptionId = amplifyUuid();
+                const startSubscription = () => {
+                    if (!subscriptionStartActive) {
+                        subscriptionStartActive = true;
+                        const startSubscriptionPromise = this._startSubscriptionWithAWSAppSyncRealTime({
                             options: {
-                                query: query,
-                                variables: variables,
-                                region: region,
-                                authenticationType: authenticationType,
-                                appSyncGraphqlEndpoint: appSyncGraphqlEndpoint,
-                                additionalHeaders: additionalHeaders,
-                                apiKey: apiKey,
+                                query,
+                                variables,
+                                region,
+                                authenticationType,
+                                appSyncGraphqlEndpoint,
+                                additionalHeaders,
+                                apiKey,
                             },
-                            observer: observer,
-                            subscriptionId: subscriptionId_1,
-                            customUserAgentDetails: customUserAgentDetails,
-                        }).catch(function (err) {
-                            logger.debug("".concat(CONTROL_MSG.REALTIME_SUBSCRIPTION_INIT_ERROR, ": ").concat(err));
-                            _this.connectionStateMonitor.record(CONNECTION_CHANGE.CLOSED);
+                            observer,
+                            subscriptionId,
+                            customUserAgentDetails,
+                        }).catch(err => {
+                            logger.debug(`${CONTROL_MSG.REALTIME_SUBSCRIPTION_INIT_ERROR}: ${err}`);
+                            this.connectionStateMonitor.record(CONNECTION_CHANGE.CLOSED);
                         });
-                        startSubscriptionPromise.finally(function () {
-                            subscriptionStartActive_1 = false;
+                        startSubscriptionPromise.finally(() => {
+                            subscriptionStartActive = false;
                         });
                     }
                 };
-                var reconnectSubscription_1;
+                let reconnectSubscription;
                 // Add an observable to the reconnection list to manage reconnection for this subscription
-                reconnectSubscription_1 = new Observable(function (observer) {
-                    _this.reconnectionMonitor.addObserver(observer);
-                }).subscribe(function () {
-                    startSubscription_1();
+                reconnectSubscription = new Observable(observer => {
+                    this.reconnectionMonitor.addObserver(observer);
+                }).subscribe(() => {
+                    startSubscription();
                 });
-                startSubscription_1();
-                return function () { return __awaiter(_this, void 0, void 0, function () {
-                    var subscriptionState, err_1;
-                    return __generator(this, function (_a) {
-                        switch (_a.label) {
-                            case 0:
-                                // Cleanup reconnection subscription
-                                reconnectSubscription_1 === null || reconnectSubscription_1 === void 0 ? void 0 : reconnectSubscription_1.unsubscribe();
-                                _a.label = 1;
-                            case 1:
-                                _a.trys.push([1, 3, 4, 5]);
-                                // Waiting that subscription has been connected before trying to unsubscribe
-                                return [4 /*yield*/, this._waitForSubscriptionToBeConnected(subscriptionId_1)];
-                            case 2:
-                                // Waiting that subscription has been connected before trying to unsubscribe
-                                _a.sent();
-                                subscriptionState = (this.subscriptionObserverMap.get(subscriptionId_1) || {}).subscriptionState;
-                                if (!subscriptionState) {
-                                    // subscription already unsubscribed
-                                    return [2 /*return*/];
-                                }
-                                if (subscriptionState === SUBSCRIPTION_STATUS.CONNECTED) {
-                                    this._sendUnsubscriptionMessage(subscriptionId_1);
-                                }
-                                else {
-                                    throw new Error('Subscription never connected');
-                                }
-                                return [3 /*break*/, 5];
-                            case 3:
-                                err_1 = _a.sent();
-                                logger.debug("Error while unsubscribing ".concat(err_1));
-                                return [3 /*break*/, 5];
-                            case 4:
-                                this._removeSubscriptionObserver(subscriptionId_1);
-                                return [7 /*endfinally*/];
-                            case 5: return [2 /*return*/];
+                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
+                        await this._waitForSubscriptionToBeConnected(subscriptionId);
+                        const { subscriptionState } = this.subscriptionObserverMap.get(subscriptionId) || {};
+                        if (!subscriptionState) {
+                            // subscription already unsubscribed
+                            return;
                         }
-                    });
-                }); };
+                        if (subscriptionState === SUBSCRIPTION_STATUS.CONNECTED) {
+                            this._sendUnsubscriptionMessage(subscriptionId);
+                        }
+                        else {
+                            throw new Error('Subscription never connected');
+                        }
+                    }
+                    catch (err) {
+                        logger.debug(`Error while unsubscribing ${err}`);
+                    }
+                    finally {
+                        this._removeSubscriptionObserver(subscriptionId);
+                    }
+                };
             }
         });
-    };
-    AWSAppSyncRealTimeProvider.prototype._startSubscriptionWithAWSAppSyncRealTime = function (_a) {
-        var _b;
-        var options = _a.options, observer = _a.observer, subscriptionId = _a.subscriptionId, customUserAgentDetails = _a.customUserAgentDetails;
-        return __awaiter(this, void 0, void 0, function () {
-            var appSyncGraphqlEndpoint, authenticationType, query, variables, apiKey, region, _c, graphql_headers, _d, additionalHeaders, subscriptionState, data, dataString, headerObj, _e, _f, subscriptionMessage, stringToAWSRealTime, err_2, _g, subscriptionFailedCallback, subscriptionReadyCallback;
-            var _h;
-            var _this = this;
-            return __generator(this, function (_j) {
-                switch (_j.label) {
-                    case 0:
-                        appSyncGraphqlEndpoint = options.appSyncGraphqlEndpoint, authenticationType = options.authenticationType, query = options.query, variables = options.variables, apiKey = options.apiKey, region = options.region, _c = options.graphql_headers, graphql_headers = _c === void 0 ? function () { return ({}); } : _c, _d = options.additionalHeaders, additionalHeaders = _d === void 0 ? {} : _d;
-                        subscriptionState = SUBSCRIPTION_STATUS.PENDING;
-                        data = {
-                            query: query,
-                            variables: variables,
-                        };
-                        // Having a subscription id map will make it simple to forward messages received
-                        this.subscriptionObserverMap.set(subscriptionId, {
-                            observer: observer,
-                            query: query !== null && query !== void 0 ? query : '',
-                            variables: variables !== null && variables !== void 0 ? variables : {},
-                            subscriptionState: subscriptionState,
-                            startAckTimeoutId: undefined,
-                        });
-                        dataString = JSON.stringify(data);
-                        _e = [{}];
-                        return [4 /*yield*/, this._awsRealTimeHeaderBasedAuth({
-                                apiKey: apiKey,
-                                appSyncGraphqlEndpoint: appSyncGraphqlEndpoint,
-                                authenticationType: authenticationType,
-                                payload: dataString,
-                                canonicalUri: '',
-                                region: region,
-                                additionalHeaders: additionalHeaders,
-                            })];
-                    case 1:
-                        _f = [__assign.apply(void 0, _e.concat([(_j.sent())]))];
-                        return [4 /*yield*/, graphql_headers()];
-                    case 2:
-                        headerObj = __assign.apply(void 0, [__assign.apply(void 0, [__assign.apply(void 0, _f.concat([(_j.sent())])), additionalHeaders]), (_h = {}, _h[USER_AGENT_HEADER] = getAmplifyUserAgent(customUserAgentDetails), _h)]);
-                        subscriptionMessage = {
-                            id: subscriptionId,
-                            payload: {
-                                data: dataString,
-                                extensions: {
-                                    authorization: __assign({}, headerObj),
-                                },
-                            },
-                            type: MESSAGE_TYPES.GQL_START,
-                        };
-                        stringToAWSRealTime = JSON.stringify(subscriptionMessage);
-                        _j.label = 3;
-                    case 3:
-                        _j.trys.push([3, 5, , 6]);
-                        this.connectionStateMonitor.record(CONNECTION_CHANGE.OPENING_CONNECTION);
-                        return [4 /*yield*/, this._initializeWebSocketConnection({
-                                apiKey: apiKey,
-                                appSyncGraphqlEndpoint: appSyncGraphqlEndpoint,
-                                authenticationType: authenticationType,
-                                region: region,
-                                additionalHeaders: additionalHeaders,
-                            })];
-                    case 4:
-                        _j.sent();
-                        return [3 /*break*/, 6];
-                    case 5:
-                        err_2 = _j.sent();
-                        this._logStartSubscriptionError(subscriptionId, observer, err_2);
-                        return [2 /*return*/];
-                    case 6:
-                        _g = (_b = this.subscriptionObserverMap.get(subscriptionId)) !== null && _b !== void 0 ? _b : {}, subscriptionFailedCallback = _g.subscriptionFailedCallback, subscriptionReadyCallback = _g.subscriptionReadyCallback;
-                        // This must be done before sending the message in order to be listening immediately
-                        this.subscriptionObserverMap.set(subscriptionId, {
-                            observer: observer,
-                            subscriptionState: subscriptionState,
-                            query: query !== null && query !== void 0 ? query : '',
-                            variables: variables !== null && variables !== void 0 ? variables : {},
-                            subscriptionReadyCallback: subscriptionReadyCallback,
-                            subscriptionFailedCallback: subscriptionFailedCallback,
-                            startAckTimeoutId: setTimeout(function () {
-                                _this._timeoutStartSubscriptionAck.call(_this, subscriptionId);
-                            }, START_ACK_TIMEOUT),
-                        });
-                        if (this.awsRealTimeSocket) {
-                            this.awsRealTimeSocket.send(stringToAWSRealTime);
-                        }
-                        return [2 /*return*/];
-                }
+    }
+    async _startSubscriptionWithAWSAppSyncRealTime({ options, observer, subscriptionId, customUserAgentDetails, }) {
+        const { appSyncGraphqlEndpoint, authenticationType, query, variables, apiKey, region, graphql_headers = () => ({}), additionalHeaders = {}, } = options;
+        const subscriptionState = SUBSCRIPTION_STATUS.PENDING;
+        const data = {
+            query,
+            variables,
+        };
+        // Having a subscription id map will make it simple to forward messages received
+        this.subscriptionObserverMap.set(subscriptionId, {
+            observer,
+            query: query ?? '',
+            variables: variables ?? {},
+            subscriptionState,
+            startAckTimeoutId: undefined,
+        });
+        // Preparing payload for subscription message
+        const dataString = JSON.stringify(data);
+        const headerObj = {
+            ...(await this._awsRealTimeHeaderBasedAuth({
+                apiKey,
+                appSyncGraphqlEndpoint,
+                authenticationType,
+                payload: dataString,
+                canonicalUri: '',
+                region,
+                additionalHeaders,
+            })),
+            ...(await graphql_headers()),
+            ...additionalHeaders,
+            [USER_AGENT_HEADER]: getAmplifyUserAgent(customUserAgentDetails),
+        };
+        const subscriptionMessage = {
+            id: subscriptionId,
+            payload: {
+                data: dataString,
+                extensions: {
+                    authorization: {
+                        ...headerObj,
+                    },
+                },
+            },
+            type: MESSAGE_TYPES.GQL_START,
+        };
+        const stringToAWSRealTime = JSON.stringify(subscriptionMessage);
+        try {
+            this.connectionStateMonitor.record(CONNECTION_CHANGE.OPENING_CONNECTION);
+            await this._initializeWebSocketConnection({
+                apiKey,
+                appSyncGraphqlEndpoint,
+                authenticationType,
+                region,
+                additionalHeaders,
             });
+        }
+        catch (err) {
+            this._logStartSubscriptionError(subscriptionId, observer, err);
+            return;
+        }
+        // Potential race condition can occur when unsubscribe is called during _initializeWebSocketConnection.
+        // E.g.unsubscribe gets invoked prior to finishing WebSocket handshake or START_ACK.
+        // Both subscriptionFailedCallback and subscriptionReadyCallback are used to synchronized this.
+        const { subscriptionFailedCallback, subscriptionReadyCallback } = this.subscriptionObserverMap.get(subscriptionId) ?? {};
+        // This must be done before sending the message in order to be listening immediately
+        this.subscriptionObserverMap.set(subscriptionId, {
+            observer,
+            subscriptionState,
+            query: query ?? '',
+            variables: variables ?? {},
+            subscriptionReadyCallback,
+            subscriptionFailedCallback,
+            startAckTimeoutId: setTimeout(() => {
+                this._timeoutStartSubscriptionAck.call(this, subscriptionId);
+            }, START_ACK_TIMEOUT),
         });
-    };
+        if (this.awsRealTimeSocket) {
+            this.awsRealTimeSocket.send(stringToAWSRealTime);
+        }
+    }
     // Log logic for start subscription failures
-    AWSAppSyncRealTimeProvider.prototype._logStartSubscriptionError = function (subscriptionId, observer, err) {
-        var _a;
-        logger.debug({ err: err });
-        var message = String((_a = err.message) !== null && _a !== void 0 ? _a : '');
+    _logStartSubscriptionError(subscriptionId, observer, err) {
+        logger.debug({ err });
+        const message = String(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
@@ -273,73 +243,68 @@ var AWSAppSyncRealTimeProvider = /** @class */ (function () {
             if (isNonRetryableError(err)) {
                 observer.error({
                     errors: [
-                        __assign({}, new GraphQLError("".concat(CONTROL_MSG.CONNECTION_FAILED, ": ").concat(message))),
+                        {
+                            ...new GraphQLError(`${CONTROL_MSG.CONNECTION_FAILED}: ${message}`),
+                        },
                     ],
                 });
             }
             else {
-                logger.debug("".concat(CONTROL_MSG.CONNECTION_FAILED, ": ").concat(message));
+                logger.debug(`${CONTROL_MSG.CONNECTION_FAILED}: ${message}`);
             }
-            var subscriptionFailedCallback = (this.subscriptionObserverMap.get(subscriptionId) || {}).subscriptionFailedCallback;
+            const { subscriptionFailedCallback } = this.subscriptionObserverMap.get(subscriptionId) || {};
             // Notify concurrent unsubscription
             if (typeof subscriptionFailedCallback === 'function') {
                 subscriptionFailedCallback();
             }
         }
-    };
+    }
     // Waiting that subscription has been connected before trying to unsubscribe
-    AWSAppSyncRealTimeProvider.prototype._waitForSubscriptionToBeConnected = function (subscriptionId) {
-        return __awaiter(this, void 0, void 0, function () {
-            var subscriptionObserver, subscriptionState;
-            var _this = this;
-            return __generator(this, function (_a) {
-                subscriptionObserver = this.subscriptionObserverMap.get(subscriptionId);
-                if (subscriptionObserver) {
-                    subscriptionState = subscriptionObserver.subscriptionState;
-                    // This in case unsubscribe is invoked before sending start subscription message
-                    if (subscriptionState === SUBSCRIPTION_STATUS.PENDING) {
-                        return [2 /*return*/, new Promise(function (res, rej) {
-                                var observer = subscriptionObserver.observer, subscriptionState = subscriptionObserver.subscriptionState, variables = subscriptionObserver.variables, query = subscriptionObserver.query;
-                                _this.subscriptionObserverMap.set(subscriptionId, {
-                                    observer: observer,
-                                    subscriptionState: subscriptionState,
-                                    variables: variables,
-                                    query: query,
-                                    subscriptionReadyCallback: res,
-                                    subscriptionFailedCallback: rej,
-                                });
-                            })];
-                    }
-                }
-                return [2 /*return*/];
-            });
-        });
-    };
-    AWSAppSyncRealTimeProvider.prototype._sendUnsubscriptionMessage = function (subscriptionId) {
+    async _waitForSubscriptionToBeConnected(subscriptionId) {
+        const subscriptionObserver = this.subscriptionObserverMap.get(subscriptionId);
+        if (subscriptionObserver) {
+            const { subscriptionState } = subscriptionObserver;
+            // This in case unsubscribe is invoked before sending start subscription message
+            if (subscriptionState === SUBSCRIPTION_STATUS.PENDING) {
+                return new Promise((res, rej) => {
+                    const { observer, subscriptionState, variables, query } = subscriptionObserver;
+                    this.subscriptionObserverMap.set(subscriptionId, {
+                        observer,
+                        subscriptionState,
+                        variables,
+                        query,
+                        subscriptionReadyCallback: res,
+                        subscriptionFailedCallback: rej,
+                    });
+                });
+            }
+        }
+    }
+    _sendUnsubscriptionMessage(subscriptionId) {
         try {
             if (this.awsRealTimeSocket &&
                 this.awsRealTimeSocket.readyState === WebSocket.OPEN &&
                 this.socketStatus === SOCKET_STATUS.READY) {
                 // Preparing unsubscribe message to stop receiving messages for that subscription
-                var unsubscribeMessage = {
+                const unsubscribeMessage = {
                     id: subscriptionId,
                     type: MESSAGE_TYPES.GQL_STOP,
                 };
-                var stringToAWSRealTime = JSON.stringify(unsubscribeMessage);
+                const stringToAWSRealTime = JSON.stringify(unsubscribeMessage);
                 this.awsRealTimeSocket.send(stringToAWSRealTime);
             }
         }
         catch (err) {
             // If GQL_STOP is not sent because of disconnection issue, then there is nothing the client can do
-            logger.debug({ err: err });
+            logger.debug({ err });
         }
-    };
-    AWSAppSyncRealTimeProvider.prototype._removeSubscriptionObserver = function (subscriptionId) {
+    }
+    _removeSubscriptionObserver(subscriptionId) {
         this.subscriptionObserverMap.delete(subscriptionId);
         // Verifying 1000ms after removing subscription in case there are new subscription unmount/mount
         setTimeout(this._closeSocketIfRequired.bind(this), 1000);
-    };
-    AWSAppSyncRealTimeProvider.prototype._closeSocketIfRequired = function () {
+    }
+    _closeSocketIfRequired() {
         if (this.subscriptionObserverMap.size > 0) {
             // Active subscriptions on the WebSocket
             return;
@@ -361,7 +326,7 @@ var AWSAppSyncRealTimeProvider = /** @class */ (function () {
             if (this.keepAliveAlertTimeoutId) {
                 clearTimeout(this.keepAliveAlertTimeoutId);
             }
-            var tempSocket = this.awsRealTimeSocket;
+            const tempSocket = this.awsRealTimeSocket;
             // Cleaning callbacks to avoid race condition, socket still exists
             tempSocket.onclose = null;
             tempSocket.onerror = null;
@@ -370,27 +335,26 @@ var AWSAppSyncRealTimeProvider = /** @class */ (function () {
             this.socketStatus = SOCKET_STATUS.CLOSED;
             this.connectionStateMonitor.record(CONNECTION_CHANGE.CLOSED);
         }
-    };
-    AWSAppSyncRealTimeProvider.prototype._handleIncomingSubscriptionMessage = function (message) {
-        var _this = this;
+    }
+    _handleIncomingSubscriptionMessage(message) {
         if (typeof message.data !== 'string') {
             return;
         }
-        logger.debug("subscription message from AWS AppSync RealTime: ".concat(message.data));
-        var _a = JSON.parse(String(message.data)), _b = _a.id, id = _b === void 0 ? '' : _b, payload = _a.payload, type = _a.type;
-        var _c = this.subscriptionObserverMap.get(id) || {}, _d = _c.observer, observer = _d === void 0 ? null : _d, _e = _c.query, query = _e === void 0 ? '' : _e, _f = _c.variables, variables = _f === void 0 ? {} : _f, startAckTimeoutId = _c.startAckTimeoutId, subscriptionReadyCallback = _c.subscriptionReadyCallback, subscriptionFailedCallback = _c.subscriptionFailedCallback;
-        logger.debug({ id: id, observer: observer, query: query, variables: variables });
+        logger.debug(`subscription message from AWS AppSync RealTime: ${message.data}`);
+        const { id = '', payload, type, } = JSON.parse(String(message.data));
+        const { observer = null, query = '', variables = {}, startAckTimeoutId, subscriptionReadyCallback, subscriptionFailedCallback, } = this.subscriptionObserverMap.get(id) || {};
+        logger.debug({ id, observer, query, variables });
         if (type === MESSAGE_TYPES.GQL_DATA && payload && payload.data) {
             if (observer) {
                 observer.next(payload);
             }
             else {
-                logger.debug("observer not found for id: ".concat(id));
+                logger.debug(`observer not found for id: ${id}`);
             }
             return;
         }
         if (type === MESSAGE_TYPES.GQL_START_ACK) {
-            logger.debug("subscription ready for ".concat(JSON.stringify({ query: query, variables: variables })));
+            logger.debug(`subscription ready for ${JSON.stringify({ query, variables })}`);
             if (typeof subscriptionReadyCallback === 'function') {
                 subscriptionReadyCallback();
             }
@@ -398,19 +362,19 @@ var AWSAppSyncRealTimeProvider = /** @class */ (function () {
                 clearTimeout(startAckTimeoutId);
             dispatchApiEvent({
                 event: CONTROL_MSG.SUBSCRIPTION_ACK,
-                data: { query: query, variables: variables },
+                data: { query, variables },
                 message: 'Connection established for subscription',
             });
-            var subscriptionState = SUBSCRIPTION_STATUS.CONNECTED;
+            const subscriptionState = SUBSCRIPTION_STATUS.CONNECTED;
             if (observer) {
                 this.subscriptionObserverMap.set(id, {
-                    observer: observer,
-                    query: query,
-                    variables: variables,
+                    observer,
+                    query,
+                    variables,
                     startAckTimeoutId: undefined,
-                    subscriptionState: subscriptionState,
-                    subscriptionReadyCallback: subscriptionReadyCallback,
-                    subscriptionFailedCallback: subscriptionFailedCallback,
+                    subscriptionState,
+                    subscriptionReadyCallback,
+                    subscriptionFailedCallback,
                 });
             }
             this.connectionStateMonitor.record(CONNECTION_CHANGE.CONNECTION_ESTABLISHED);
@@ -421,29 +385,31 @@ var AWSAppSyncRealTimeProvider = /** @class */ (function () {
                 clearTimeout(this.keepAliveTimeoutId);
             if (this.keepAliveAlertTimeoutId)
                 clearTimeout(this.keepAliveAlertTimeoutId);
-            this.keepAliveTimeoutId = setTimeout(function () { return _this._errorDisconnect(CONTROL_MSG.TIMEOUT_DISCONNECT); }, this.keepAliveTimeout);
-            this.keepAliveAlertTimeoutId = setTimeout(function () {
-                _this.connectionStateMonitor.record(CONNECTION_CHANGE.KEEP_ALIVE_MISSED);
+            this.keepAliveTimeoutId = setTimeout(() => 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;
         }
         if (type === MESSAGE_TYPES.GQL_ERROR) {
-            var subscriptionState = SUBSCRIPTION_STATUS.FAILED;
+            const subscriptionState = SUBSCRIPTION_STATUS.FAILED;
             if (observer) {
                 this.subscriptionObserverMap.set(id, {
-                    observer: observer,
-                    query: query,
-                    variables: variables,
-                    startAckTimeoutId: startAckTimeoutId,
-                    subscriptionReadyCallback: subscriptionReadyCallback,
-                    subscriptionFailedCallback: subscriptionFailedCallback,
-                    subscriptionState: subscriptionState,
+                    observer,
+                    query,
+                    variables,
+                    startAckTimeoutId,
+                    subscriptionReadyCallback,
+                    subscriptionFailedCallback,
+                    subscriptionState,
                 });
-                logger.debug("".concat(CONTROL_MSG.CONNECTION_FAILED, ": ").concat(JSON.stringify(payload)));
+                logger.debug(`${CONTROL_MSG.CONNECTION_FAILED}: ${JSON.stringify(payload)}`);
                 observer.error({
                     errors: [
-                        __assign({}, new GraphQLError("".concat(CONTROL_MSG.CONNECTION_FAILED, ": ").concat(JSON.stringify(payload)))),
+                        {
+                            ...new GraphQLError(`${CONTROL_MSG.CONNECTION_FAILED}: ${JSON.stringify(payload)}`),
+                        },
                     ],
                 });
                 if (startAckTimeoutId)
@@ -453,351 +419,269 @@ var AWSAppSyncRealTimeProvider = /** @class */ (function () {
                 }
             }
         }
-    };
-    AWSAppSyncRealTimeProvider.prototype._errorDisconnect = function (msg) {
-        logger.debug("Disconnect error: ".concat(msg));
+    }
+    _errorDisconnect(msg) {
+        logger.debug(`Disconnect error: ${msg}`);
         if (this.awsRealTimeSocket) {
             this.connectionStateMonitor.record(CONNECTION_CHANGE.CLOSED);
             this.awsRealTimeSocket.close();
         }
         this.socketStatus = SOCKET_STATUS.CLOSED;
-    };
-    AWSAppSyncRealTimeProvider.prototype._timeoutStartSubscriptionAck = function (subscriptionId) {
-        var subscriptionObserver = this.subscriptionObserverMap.get(subscriptionId);
+    }
+    _timeoutStartSubscriptionAck(subscriptionId) {
+        const subscriptionObserver = this.subscriptionObserverMap.get(subscriptionId);
         if (subscriptionObserver) {
-            var observer = subscriptionObserver.observer, query = subscriptionObserver.query, variables = subscriptionObserver.variables;
+            const { observer, query, variables } = subscriptionObserver;
             if (!observer) {
                 return;
             }
             this.subscriptionObserverMap.set(subscriptionId, {
-                observer: observer,
-                query: query,
-                variables: variables,
+                observer,
+                query,
+                variables,
                 subscriptionState: SUBSCRIPTION_STATUS.FAILED,
             });
             this.connectionStateMonitor.record(CONNECTION_CHANGE.CLOSED);
-            logger.debug('timeoutStartSubscription', JSON.stringify({ query: query, variables: variables }));
+            logger.debug('timeoutStartSubscription', JSON.stringify({ query, variables }));
         }
-    };
-    AWSAppSyncRealTimeProvider.prototype._initializeWebSocketConnection = function (_a) {
-        var _this = this;
-        var appSyncGraphqlEndpoint = _a.appSyncGraphqlEndpoint, authenticationType = _a.authenticationType, apiKey = _a.apiKey, region = _a.region, additionalHeaders = _a.additionalHeaders;
+    }
+    _initializeWebSocketConnection({ appSyncGraphqlEndpoint, authenticationType, apiKey, region, additionalHeaders, }) {
         if (this.socketStatus === SOCKET_STATUS.READY) {
             return;
         }
-        return new Promise(function (res, rej) { return __awaiter(_this, void 0, void 0, function () {
-            var payloadString, authHeader, headerString, headerQs, payloadQs, discoverableEndpoint, protocol, awsRealTimeUrl, err_3;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        this.promiseArray.push({ res: res, rej: rej });
-                        if (!(this.socketStatus === SOCKET_STATUS.CLOSED)) return [3 /*break*/, 5];
-                        _a.label = 1;
-                    case 1:
-                        _a.trys.push([1, 4, , 5]);
-                        this.socketStatus = SOCKET_STATUS.CONNECTING;
-                        payloadString = '{}';
-                        return [4 /*yield*/, this._awsRealTimeHeaderBasedAuth({
-                                authenticationType: authenticationType,
-                                payload: payloadString,
-                                canonicalUri: '/connect',
-                                apiKey: apiKey,
-                                appSyncGraphqlEndpoint: appSyncGraphqlEndpoint,
-                                region: region,
-                                additionalHeaders: additionalHeaders,
-                            })];
-                    case 2:
-                        authHeader = _a.sent();
-                        headerString = authHeader ? JSON.stringify(authHeader) : '';
-                        headerQs = Buffer.from(headerString).toString('base64');
-                        payloadQs = Buffer.from(payloadString).toString('base64');
-                        discoverableEndpoint = appSyncGraphqlEndpoint !== null && appSyncGraphqlEndpoint !== void 0 ? appSyncGraphqlEndpoint : '';
-                        if (this.isCustomDomain(discoverableEndpoint)) {
-                            discoverableEndpoint =
-                                discoverableEndpoint.concat(customDomainPath);
-                        }
-                        else {
-                            discoverableEndpoint = discoverableEndpoint
-                                .replace('appsync-api', 'appsync-realtime-api')
-                                .replace('gogi-beta', 'grt-beta');
-                        }
-                        protocol = 'wss://';
+        return new Promise(async (res, rej) => {
+            this.promiseArray.push({ res, rej });
+            if (this.socketStatus === SOCKET_STATUS.CLOSED) {
+                try {
+                    this.socketStatus = SOCKET_STATUS.CONNECTING;
+                    const payloadString = '{}';
+                    const authHeader = await this._awsRealTimeHeaderBasedAuth({
+                        authenticationType,
+                        payload: payloadString,
+                        canonicalUri: '/connect',
+                        apiKey,
+                        appSyncGraphqlEndpoint,
+                        region,
+                        additionalHeaders,
+                    });
+                    const headerString = authHeader ? JSON.stringify(authHeader) : '';
+                    const headerQs = base64Encoder.convert(headerString);
+                    const payloadQs = base64Encoder.convert(payloadString);
+                    let discoverableEndpoint = appSyncGraphqlEndpoint ?? '';
+                    if (this.isCustomDomain(discoverableEndpoint)) {
+                        discoverableEndpoint =
+                            discoverableEndpoint.concat(customDomainPath);
+                    }
+                    else {
                         discoverableEndpoint = discoverableEndpoint
-                            .replace('https://', protocol)
-                            .replace('http://', protocol);
-                        awsRealTimeUrl = "".concat(discoverableEndpoint, "?header=").concat(headerQs, "&payload=").concat(payloadQs);
-                        return [4 /*yield*/, this._initializeRetryableHandshake(awsRealTimeUrl)];
-                    case 3:
-                        _a.sent();
-                        this.promiseArray.forEach(function (_a) {
-                            var res = _a.res;
-                            logger.debug('Notifying connection successful');
-                            res();
-                        });
-                        this.socketStatus = SOCKET_STATUS.READY;
-                        this.promiseArray = [];
-                        return [3 /*break*/, 5];
-                    case 4:
-                        err_3 = _a.sent();
-                        logger.debug('Connection exited with', err_3);
-                        this.promiseArray.forEach(function (_a) {
-                            var rej = _a.rej;
-                            return rej(err_3);
-                        });
-                        this.promiseArray = [];
-                        if (this.awsRealTimeSocket &&
-                            this.awsRealTimeSocket.readyState === WebSocket.OPEN) {
-                            this.awsRealTimeSocket.close(3001);
-                        }
-                        this.awsRealTimeSocket = undefined;
-                        this.socketStatus = SOCKET_STATUS.CLOSED;
-                        return [3 /*break*/, 5];
-                    case 5: return [2 /*return*/];
+                            .replace('appsync-api', 'appsync-realtime-api')
+                            .replace('gogi-beta', 'grt-beta');
+                    }
+                    // Creating websocket url with required query strings
+                    const protocol = 'wss://';
+                    discoverableEndpoint = discoverableEndpoint
+                        .replace('https://', protocol)
+                        .replace('http://', protocol);
+                    const awsRealTimeUrl = `${discoverableEndpoint}?header=${headerQs}&payload=${payloadQs}`;
+                    await this._initializeRetryableHandshake(awsRealTimeUrl);
+                    this.promiseArray.forEach(({ res }) => {
+                        logger.debug('Notifying connection successful');
+                        res();
+                    });
+                    this.socketStatus = SOCKET_STATUS.READY;
+                    this.promiseArray = [];
                 }
-            });
-        }); });
-    };
-    AWSAppSyncRealTimeProvider.prototype._initializeRetryableHandshake = function (awsRealTimeUrl) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        logger.debug("Initializaling retryable Handshake");
-                        return [4 /*yield*/, jitteredExponentialRetry(this._initializeHandshake.bind(this), [awsRealTimeUrl], MAX_DELAY_MS)];
-                    case 1:
-                        _a.sent();
-                        return [2 /*return*/];
+                catch (err) {
+                    logger.debug('Connection exited with', err);
+                    this.promiseArray.forEach(({ rej }) => rej(err));
+                    this.promiseArray = [];
+                    if (this.awsRealTimeSocket &&
+                        this.awsRealTimeSocket.readyState === WebSocket.OPEN) {
+                        this.awsRealTimeSocket.close(3001);
+                    }
+                    this.awsRealTimeSocket = undefined;
+                    this.socketStatus = SOCKET_STATUS.CLOSED;
                 }
-            });
+            }
         });
-    };
-    AWSAppSyncRealTimeProvider.prototype._initializeHandshake = function (awsRealTimeUrl) {
-        return __awaiter(this, void 0, void 0, function () {
-            var err_4, _a, errorType, errorCode;
-            var _this = this;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        logger.debug("Initializing handshake ".concat(awsRealTimeUrl));
-                        _b.label = 1;
-                    case 1:
-                        _b.trys.push([1, 4, , 5]);
-                        return [4 /*yield*/, (function () {
-                                return new Promise(function (res, rej) {
-                                    var newSocket = _this.getNewWebSocket(awsRealTimeUrl, 'graphql-ws');
-                                    newSocket.onerror = function () {
-                                        logger.debug("WebSocket connection error");
-                                    };
-                                    newSocket.onclose = function () {
-                                        rej(new Error('Connection handshake error'));
+    }
+    async _initializeRetryableHandshake(awsRealTimeUrl) {
+        logger.debug(`Initializaling retryable Handshake`);
+        await jitteredExponentialRetry(this._initializeHandshake.bind(this), [awsRealTimeUrl], MAX_DELAY_MS);
+    }
+    async _initializeHandshake(awsRealTimeUrl) {
+        logger.debug(`Initializing handshake ${awsRealTimeUrl}`);
+        // Because connecting the socket is async, is waiting until connection is open
+        // Step 1: connect websocket
+        try {
+            await (() => {
+                return new Promise((res, rej) => {
+                    const newSocket = this.getNewWebSocket(awsRealTimeUrl, 'graphql-ws');
+                    newSocket.onerror = () => {
+                        logger.debug(`WebSocket connection error`);
+                    };
+                    newSocket.onclose = () => {
+                        rej(new Error('Connection handshake error'));
+                    };
+                    newSocket.onopen = () => {
+                        this.awsRealTimeSocket = newSocket;
+                        return res();
+                    };
+                });
+            })();
+            // Step 2: wait for ack from AWS AppSyncReaTime after sending init
+            await (() => {
+                return new Promise((res, rej) => {
+                    if (this.awsRealTimeSocket) {
+                        let ackOk = false;
+                        this.awsRealTimeSocket.onerror = error => {
+                            logger.debug(`WebSocket error ${JSON.stringify(error)}`);
+                        };
+                        this.awsRealTimeSocket.onclose = event => {
+                            logger.debug(`WebSocket closed ${event.reason}`);
+                            rej(new Error(JSON.stringify(event)));
+                        };
+                        this.awsRealTimeSocket.onmessage = (message) => {
+                            if (typeof message.data !== 'string') {
+                                return;
+                            }
+                            logger.debug(`subscription message from AWS AppSyncRealTime: ${message.data} `);
+                            const data = JSON.parse(message.data);
+                            const { type, payload: { connectionTimeoutMs = DEFAULT_KEEP_ALIVE_TIMEOUT, } = {}, } = data;
+                            if (type === MESSAGE_TYPES.GQL_CONNECTION_ACK) {
+                                ackOk = true;
+                                if (this.awsRealTimeSocket) {
+                                    this.keepAliveTimeout = connectionTimeoutMs;
+                                    this.awsRealTimeSocket.onmessage =
+                                        this._handleIncomingSubscriptionMessage.bind(this);
+                                    this.awsRealTimeSocket.onerror = err => {
+                                        logger.debug(err);
+                                        this._errorDisconnect(CONTROL_MSG.CONNECTION_CLOSED);
                                     };
-                                    newSocket.onopen = function () {
-                                        _this.awsRealTimeSocket = newSocket;
-                                        return res();
+                                    this.awsRealTimeSocket.onclose = event => {
+                                        logger.debug(`WebSocket closed ${event.reason}`);
+                                        this._errorDisconnect(CONTROL_MSG.CONNECTION_CLOSED);
                                     };
-                                });
-                            })()];
-                    case 2:
-                        _b.sent();
-                        // Step 2: wait for ack from AWS AppSyncReaTime after sending init
-                        return [4 /*yield*/, (function () {
-                                return new Promise(function (res, rej) {
-                                    if (_this.awsRealTimeSocket) {
-                                        var ackOk_1 = false;
-                                        _this.awsRealTimeSocket.onerror = function (error) {
-                                            logger.debug("WebSocket error ".concat(JSON.stringify(error)));
-                                        };
-                                        _this.awsRealTimeSocket.onclose = function (event) {
-                                            logger.debug("WebSocket closed ".concat(event.reason));
-                                            rej(new Error(JSON.stringify(event)));
-                                        };
-                                        _this.awsRealTimeSocket.onmessage = function (message) {
-                                            if (typeof message.data !== 'string') {
-                                                return;
-                                            }
-                                            logger.debug("subscription message from AWS AppSyncRealTime: ".concat(message.data, " "));
-                                            var data = JSON.parse(message.data);
-                                            var type = data.type, _a = data.payload, _b = _a === void 0 ? {} : _a, _c = _b.connectionTimeoutMs, connectionTimeoutMs = _c === void 0 ? DEFAULT_KEEP_ALIVE_TIMEOUT : _c;
-                                            if (type === MESSAGE_TYPES.GQL_CONNECTION_ACK) {
-                                                ackOk_1 = true;
-                                                if (_this.awsRealTimeSocket) {
-                                                    _this.keepAliveTimeout = connectionTimeoutMs;
-                                                    _this.awsRealTimeSocket.onmessage =
-                                                        _this._handleIncomingSubscriptionMessage.bind(_this);
-                                                    _this.awsRealTimeSocket.onerror = function (err) {
-                                                        logger.debug(err);
-                                                        _this._errorDisconnect(CONTROL_MSG.CONNECTION_CLOSED);
-                                                    };
-                                                    _this.awsRealTimeSocket.onclose = function (event) {
-                                                        logger.debug("WebSocket closed ".concat(event.reason));
-                                                        _this._errorDisconnect(CONTROL_MSG.CONNECTION_CLOSED);
-                                                    };
-                                                }
-                                                res('Cool, connected to AWS AppSyncRealTime');
-                                                return;
-                                            }
-                                            if (type === MESSAGE_TYPES.GQL_CONNECTION_ERROR) {
-                                                var _d = data.payload, _e = _d === void 0 ? {} : _d, _f = _e.errors, _g = _f === void 0 ? [] : _f, _h = __read(_g, 1), _j = _h[0], _k = _j === void 0 ? {} : _j, _l = _k.errorType, errorType = _l === void 0 ? '' : _l, _m = _k.errorCode, errorCode = _m === void 0 ? 0 : _m;
-                                                rej({ errorType: errorType, errorCode: errorCode });
-                                            }
-                                        };
-                                        var gqlInit = {
-                                            type: MESSAGE_TYPES.GQL_CONNECTION_INIT,
-                                        };
-                                        _this.awsRealTimeSocket.send(JSON.stringify(gqlInit));
-                                        var checkAckOk_1 = function (ackOk) {
-                                            if (!ackOk) {
-                                                _this.connectionStateMonitor.record(CONNECTION_CHANGE.CONNECTION_FAILED);
-                                                rej(new Error("Connection timeout: ack from AWSAppSyncRealTime was not received after ".concat(CONNECTION_INIT_TIMEOUT, " ms")));
-                                            }
-                                        };
-                                        setTimeout(function () { return checkAckOk_1(ackOk_1); }, CONNECTION_INIT_TIMEOUT);
-                                    }
-                                });
-                            })()];
-                    case 3:
-                        // Step 2: wait for ack from AWS AppSyncReaTime after sending init
-                        _b.sent();
-                        return [3 /*break*/, 5];
-                    case 4:
-                        err_4 = _b.sent();
-                        _a = err_4, errorType = _a.errorType, errorCode = _a.errorCode;
-                        if (NON_RETRYABLE_CODES.includes(errorCode)) {
-                            throw new NonRetryableError(errorType);
-                        }
-                        else if (errorType) {
-                            throw new Error(errorType);
-                        }
-                        else {
-                            throw err_4;
-                        }
-                        return [3 /*break*/, 5];
-                    case 5: return [2 /*return*/];
-                }
-            });
-        });
-    };
-    AWSAppSyncRealTimeProvider.prototype._awsRealTimeHeaderBasedAuth = function (_a) {
-        var apiKey = _a.apiKey, authenticationType = _a.authenticationType, payload = _a.payload, canonicalUri = _a.canonicalUri, appSyncGraphqlEndpoint = _a.appSyncGraphqlEndpoint, region = _a.region, additionalHeaders = _a.additionalHeaders;
-        return __awaiter(this, void 0, void 0, function () {
-            var headerHandler, handler, host, resolvedApiKey, result;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        headerHandler = {
-                            apiKey: this._awsRealTimeApiKeyHeader.bind(this),
-                            iam: this._awsRealTimeIAMHeader.bind(this),
-                            oidc: this._awsAuthTokenHeader.bind(this),
-                            userPool: this._awsAuthTokenHeader.bind(this),
-                            lambda: this._customAuthHeader,
-                            none: this._customAuthHeader,
+                                }
+                                res('Cool, connected to AWS AppSyncRealTime');
+                                return;
+                            }
+                            if (type === MESSAGE_TYPES.GQL_CONNECTION_ERROR) {
+                                const { payload: { errors: [{ errorType = '', errorCode = 0 } = {}] = [], } = {}, } = data;
+                                rej({ errorType, errorCode });
+                            }
                         };
-                        if (!(!authenticationType || !headerHandler[authenticationType])) return [3 /*break*/, 1];
-                        logger.debug("Authentication type ".concat(authenticationType, " not supported"));
-                        return [2 /*return*/, undefined];
-                    case 1:
-                        handler = headerHandler[authenticationType];
-                        host = url.parse(appSyncGraphqlEndpoint !== null && appSyncGraphqlEndpoint !== void 0 ? appSyncGraphqlEndpoint : '').host;
-                        logger.debug("Authenticating with ".concat(JSON.stringify(authenticationType)));
-                        resolvedApiKey = void 0;
-                        if (authenticationType === 'apiKey') {
-                            resolvedApiKey = apiKey;
-                        }
-                        return [4 /*yield*/, handler({
-                                payload: payload,
-                                canonicalUri: canonicalUri,
-                                appSyncGraphqlEndpoint: appSyncGraphqlEndpoint,
-                                apiKey: resolvedApiKey,
-                                region: region,
-                                host: host,
-                                additionalHeaders: additionalHeaders,
-                            })];
-                    case 2:
-                        result = _b.sent();
-                        return [2 /*return*/, result];
-                }
-            });
-        });
-    };
-    AWSAppSyncRealTimeProvider.prototype._awsAuthTokenHeader = function (_a) {
-        var _b, _c;
-        var host = _a.host;
-        return __awaiter(this, void 0, void 0, function () {
-            var session;
-            return __generator(this, function (_d) {
-                switch (_d.label) {
-                    case 0: return [4 /*yield*/, fetchAuthSession()];
-                    case 1:
-                        session = _d.sent();
-                        return [2 /*return*/, {
-                                Authorization: (_c = (_b = session === null || session === void 0 ? void 0 : session.tokens) === null || _b === void 0 ? void 0 : _b.accessToken) === null || _c === void 0 ? void 0 : _c.toString(),
-                                host: host,
-                            }];
-                }
-            });
-        });
-    };
-    AWSAppSyncRealTimeProvider.prototype._awsRealTimeApiKeyHeader = function (_a) {
-        var apiKey = _a.apiKey, host = _a.host;
-        return __awaiter(this, void 0, void 0, function () {
-            var dt, dtStr;
-            return __generator(this, function (_b) {
-                dt = new Date();
-                dtStr = dt.toISOString().replace(/[:\-]|\.\d{3}/g, '');
-                return [2 /*return*/, {
-                        host: host,
-                        'x-amz-date': dtStr,
-                        'x-api-key': apiKey,
-                    }];
-            });
-        });
-    };
-    AWSAppSyncRealTimeProvider.prototype._awsRealTimeIAMHeader = function (_a) {
-        var payload = _a.payload, canonicalUri = _a.canonicalUri, appSyncGraphqlEndpoint = _a.appSyncGraphqlEndpoint, region = _a.region;
-        return __awaiter(this, void 0, void 0, function () {
-            var endpointInfo, creds, request, signed_params;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        endpointInfo = {
-                            region: region,
-                            service: 'appsync',
+                        const gqlInit = {
+                            type: MESSAGE_TYPES.GQL_CONNECTION_INIT,
                         };
-                        return [4 /*yield*/, fetchAuthSession()];
-                    case 1:
-                        creds = (_b.sent()).credentials;
-                        request = {
-                            url: "".concat(appSyncGraphqlEndpoint).concat(canonicalUri),
-                            data: payload,
-                            method: 'POST',
-                            headers: __assign({}, AWS_APPSYNC_REALTIME_HEADERS),
+                        this.awsRealTimeSocket.send(JSON.stringify(gqlInit));
+                        const checkAckOk = (ackOk) => {
+                            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`));
+                            }
                         };
-                        signed_params = signRequest({
-                            headers: request.headers,
-                            method: request.method,
-                            url: new AmplifyUrl(request.url),
-                            body: request.data,
-                        }, {
-                            // TODO: What do we need to do to remove these !'s?
-                            credentials: creds,
-                            signingRegion: endpointInfo.region,
-                            signingService: endpointInfo.service,
-                        });
-                        return [2 /*return*/, signed_params.headers];
-                }
+                        setTimeout(() => checkAckOk(ackOk), CONNECTION_INIT_TIMEOUT);
+                    }
+                });
+            })();
+        }
+        catch (err) {
+            const { errorType, errorCode } = err;
+            if (NON_RETRYABLE_CODES.includes(errorCode)) {
+                throw new NonRetryableError(errorType);
+            }
+            else if (errorType) {
+                throw new Error(errorType);
+            }
+            else {
+                throw err;
+            }
+        }
+    }
+    async _awsRealTimeHeaderBasedAuth({ apiKey, authenticationType, payload, canonicalUri, appSyncGraphqlEndpoint, region, additionalHeaders, }) {
+        const headerHandler = {
+            apiKey: this._awsRealTimeApiKeyHeader.bind(this),
+            iam: this._awsRealTimeIAMHeader.bind(this),
+            oidc: this._awsAuthTokenHeader.bind(this),
+            userPool: this._awsAuthTokenHeader.bind(this),
+            lambda: this._customAuthHeader,
+            none: this._customAuthHeader,
+        };
+        if (!authenticationType || !headerHandler[authenticationType]) {
+            logger.debug(`Authentication type ${authenticationType} not supported`);
+            return undefined;
+        }
+        else {
+            const handler = headerHandler[authenticationType];
+            const host = appSyncGraphqlEndpoint
+                ? new AmplifyUrl(appSyncGraphqlEndpoint).host
+                : undefined;
+            logger.debug(`Authenticating with ${JSON.stringify(authenticationType)}`);
+            let resolvedApiKey;
+            if (authenticationType === 'apiKey') {
+                resolvedApiKey = apiKey;
+            }
+            const result = await handler({
+                payload,
+                canonicalUri,
+                appSyncGraphqlEndpoint,
+                apiKey: resolvedApiKey,
+                region,
+                host,
+                additionalHeaders,
             });
+            return result;
+        }
+    }
+    async _awsAuthTokenHeader({ host }) {
+        const session = await fetchAuthSession();
+        return {
+            Authorization: session?.tokens?.accessToken?.toString(),
+            host,
+        };
+    }
+    async _awsRealTimeApiKeyHeader({ apiKey, host, }) {
+        const dt = new Date();
+        const dtStr = dt.toISOString().replace(/[:\-]|\.\d{3}/g, '');
+        return {
+            host,
+            'x-amz-date': dtStr,
+            'x-api-key': apiKey,
+        };
+    }
+    async _awsRealTimeIAMHeader({ payload, canonicalUri, appSyncGraphqlEndpoint, region, }) {
+        const endpointInfo = {
+            region,
+            service: 'appsync',
+        };
+        const creds = (await fetchAuthSession()).credentials;
+        const request = {
+            url: `${appSyncGraphqlEndpoint}${canonicalUri}`,
+            data: payload,
+            method: 'POST',
+            headers: { ...AWS_APPSYNC_REALTIME_HEADERS },
+        };
+        const signed_params = signRequest({
+            headers: request.headers,
+            method: request.method,
+            url: new AmplifyUrl(request.url),
+            body: request.data,
+        }, {
+            // TODO: What do we need to do to remove these !'s?
+            credentials: creds,
+            signingRegion: endpointInfo.region,
+            signingService: endpointInfo.service,
         });
-    };
-    AWSAppSyncRealTimeProvider.prototype._customAuthHeader = function (_a) {
-        var host = _a.host, additionalHeaders = _a.additionalHeaders;
-        if (!(additionalHeaders === null || additionalHeaders === void 0 ? void 0 : additionalHeaders['Authorization'])) {
+        return signed_params.headers;
+    }
+    _customAuthHeader({ host, additionalHeaders, }) {
+        if (!additionalHeaders?.['Authorization']) {
             throw new Error('No auth token specified');
         }
         return {
             Authorization: additionalHeaders.Authorization,
-            host: host,
+            host,
         };
-    };
-    return AWSAppSyncRealTimeProvider;
-}());
-export { AWSAppSyncRealTimeProvider };
+    }
+}