@aws-amplify/api-graphql 4.0.22-unstable.f6055cb.0 → 4.0.22

package/src/Providers/AWSAppSyncRealTimeProvider/index.ts

@@ -3,26 +3,25 @@
 import { Observable, SubscriptionLike } from 'rxjs';
 import { GraphQLError } from 'graphql';
 import {
-	ConsoleLogger,
 	Hub,
-	HubPayload,
 	fetchAuthSession,
+	ConsoleLogger,
+	HubPayload,
 } from '@aws-amplify/core';
 import { signRequest } from '@aws-amplify/core/internals/aws-client-utils';
 import {
-	AmplifyUrl,
-	CustomUserAgentDetails,
-	DocumentType,
+	base64Encoder,
 	GraphQLAuthMode,
+	CustomUserAgentDetails,
 	NonRetryableError,
 	USER_AGENT_HEADER,
-	amplifyUuid,
-	base64Encoder,
 	getAmplifyUserAgent,
 	isNonRetryableError,
 	jitteredExponentialRetry,
+	DocumentType,
+	amplifyUuid,
+	AmplifyUrl,
 } from '@aws-amplify/core/internals/utils';
-import { CustomHeaders, RequestOptions } from '@aws-amplify/data-schema-types';
 
 import {
 	CONTROL_MSG,
@@ -33,24 +32,25 @@ import {
 	AMPLIFY_SYMBOL,
 	AWS_APPSYNC_REALTIME_HEADERS,
 	CONNECTION_INIT_TIMEOUT,
-	CONNECTION_STATE_CHANGE,
-	DEFAULT_KEEP_ALIVE_ALERT_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 {
-	CONNECTION_CHANGE,
 	ConnectionStateMonitor,
+	CONNECTION_CHANGE,
 } from '../../utils/ConnectionStateMonitor';
 import {
 	ReconnectEvent,
 	ReconnectionMonitor,
 } from '../../utils/ReconnectionMonitor';
+import { CustomHeaders, RequestOptions } from '@aws-amplify/data-schema-types';
 
 const logger = new ConsoleLogger('AWSAppSyncRealTimeProvider');
 
@@ -58,38 +58,38 @@ const dispatchApiEvent = (payload: HubPayload) => {
 	Hub.dispatch('api', payload, 'PubSub', AMPLIFY_SYMBOL);
 };
 
-export interface ObserverQuery {
+export type ObserverQuery = {
 	observer: PubSubContentObserver;
 	query: string;
 	variables: Record<string, DocumentType>;
 	subscriptionState: SUBSCRIPTION_STATUS;
-	subscriptionReadyCallback?(): void;
-	subscriptionFailedCallback?(reason?: any): void;
+	subscriptionReadyCallback?: Function;
+	subscriptionFailedCallback?: Function;
 	startAckTimeoutId?: ReturnType<typeof setTimeout>;
-}
+};
 
 const standardDomainPattern =
-	/^https:\/\/\w{26}\.appsync-api\.\w{2}(?:(?:-\w{2,})+)-\d\.amazonaws.com(?:\.cn)?\/graphql$/i;
+	/^https:\/\/\w{26}\.appsync\-api\.\w{2}(?:(?:\-\w{2,})+)\-\d\.amazonaws.com(?:\.cn)?\/graphql$/i;
 
 const customDomainPath = '/realtime';
 
-interface DataObject extends Record<string, unknown> {
+type DataObject = {
 	data: Record<string, unknown>;
-}
+};
 
-interface DataPayload {
+type DataPayload = {
 	id: string;
 	payload: DataObject;
 	type: string;
-}
+};
 
-interface ParsedMessagePayload {
+type ParsedMessagePayload = {
 	type: string;
 	payload: {
 		connectionTimeoutMs: number;
 		errors?: [{ errorType: string; errorCode: number }];
 	};
-}
+};
 
 export interface AWSAppSyncRealTimeProviderOptions {
 	appSyncGraphqlEndpoint?: string;
@@ -98,7 +98,7 @@ export interface AWSAppSyncRealTimeProviderOptions {
 	variables?: Record<string, DocumentType>;
 	apiKey?: string;
 	region?: string;
-	libraryConfigHeaders?(): Promise<Record<string, unknown> | Headers>;
+	libraryConfigHeaders?: () => {} | (() => Promise<{}>);
 	additionalHeaders?: CustomHeaders;
 	additionalCustomHeaders?: Record<string, string>;
 	authToken?: string;
@@ -117,14 +117,14 @@ export class AWSAppSyncRealTimeProvider {
 	private keepAliveTimeoutId?: ReturnType<typeof setTimeout>;
 	private keepAliveTimeout = DEFAULT_KEEP_ALIVE_TIMEOUT;
 	private keepAliveAlertTimeoutId?: ReturnType<typeof setTimeout>;
-	private subscriptionObserverMap = new Map<string, ObserverQuery>();
-	private promiseArray: { res(): void; rej(reason?: any): void }[] = [];
+	private subscriptionObserverMap: Map<string, ObserverQuery> = new Map();
+	private promiseArray: Array<{ res: Function; rej: Function }> = [];
 	private connectionState: ConnectionState | undefined;
 	private readonly connectionStateMonitor = new ConnectionStateMonitor();
 	private readonly reconnectionMonitor = new ReconnectionMonitor();
 	private connectionStateMonitorSubscription: SubscriptionLike;
 
-	constructor() {
+	constructor(options: AWSAppSyncRealTimeProviderOptions = {}) {
 		// Monitor the connection state and pass changes along to Hub
 		this.connectionStateMonitorSubscription =
 			this.connectionStateMonitor.connectionStateObservable.subscribe(
@@ -253,12 +253,12 @@ export class AWSAppSyncRealTimeProvider {
 					}
 				};
 
+				let reconnectSubscription: SubscriptionLike;
+
 				// Add an observable to the reconnection list to manage reconnection for this subscription
-				const reconnectSubscription = new Observable(
-					reconnectSubscriptionObserver => {
-						this.reconnectionMonitor.addObserver(reconnectSubscriptionObserver);
-					},
-				).subscribe(() => {
+				reconnectSubscription = new Observable(observer => {
+					this.reconnectionMonitor.addObserver(observer);
+				}).subscribe(() => {
 					startSubscription();
 				});
 
@@ -397,7 +397,6 @@ export class AWSAppSyncRealTimeProvider {
 			});
 		} catch (err: any) {
 			this._logStartSubscriptionError(subscriptionId, observer, err);
-
 			return;
 		}
 
@@ -417,7 +416,7 @@ export class AWSAppSyncRealTimeProvider {
 			subscriptionReadyCallback,
 			subscriptionFailedCallback,
 			startAckTimeoutId: setTimeout(() => {
-				this._timeoutStartSubscriptionAck(subscriptionId);
+				this._timeoutStartSubscriptionAck.call(this, subscriptionId);
 			}, START_ACK_TIMEOUT),
 		});
 		if (this.awsRealTimeSocket) {
@@ -434,7 +433,9 @@ export class AWSAppSyncRealTimeProvider {
 		logger.debug({ err });
 		const message = String(err.message ?? '');
 		// Resolving to give the state observer time to propogate the update
-		this.connectionStateMonitor.record(CONNECTION_CHANGE.CLOSED);
+		Promise.resolve(
+			this.connectionStateMonitor.record(CONNECTION_CHANGE.CLOSED),
+		);
 
 		// Capture the error only when the network didn't cause disruption
 		if (
@@ -473,20 +474,16 @@ export class AWSAppSyncRealTimeProvider {
 			const { subscriptionState } = subscriptionObserver;
 			// This in case unsubscribe is invoked before sending start subscription message
 			if (subscriptionState === SUBSCRIPTION_STATUS.PENDING) {
-				return new Promise<void>((resolve, reject) => {
-					const {
-						observer,
-						subscriptionState: observedSubscriptionState,
-						variables,
-						query,
-					} = subscriptionObserver;
+				return new Promise((res, rej) => {
+					const { observer, subscriptionState, variables, query } =
+						subscriptionObserver;
 					this.subscriptionObserverMap.set(subscriptionId, {
 						observer,
-						subscriptionState: observedSubscriptionState,
+						subscriptionState,
 						variables,
 						query,
-						subscriptionReadyCallback: resolve,
-						subscriptionFailedCallback: reject,
+						subscriptionReadyCallback: res,
+						subscriptionFailedCallback: rej,
 					});
 				});
 			}
@@ -529,7 +526,6 @@ export class AWSAppSyncRealTimeProvider {
 
 		if (!this.awsRealTimeSocket) {
 			this.socketStatus = SOCKET_STATUS.CLOSED;
-
 			return;
 		}
 
@@ -586,7 +582,6 @@ export class AWSAppSyncRealTimeProvider {
 			} else {
 				logger.debug(`observer not found for id: ${id}`);
 			}
-
 			return;
 		}
 
@@ -626,14 +621,14 @@ export class AWSAppSyncRealTimeProvider {
 			if (this.keepAliveTimeoutId) clearTimeout(this.keepAliveTimeoutId);
 			if (this.keepAliveAlertTimeoutId)
 				clearTimeout(this.keepAliveAlertTimeoutId);
-			this.keepAliveTimeoutId = setTimeout(() => {
-				this._errorDisconnect(CONTROL_MSG.TIMEOUT_DISCONNECT);
-			}, this.keepAliveTimeout);
+			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;
 		}
 
@@ -717,11 +712,8 @@ export class AWSAppSyncRealTimeProvider {
 		if (this.socketStatus === SOCKET_STATUS.READY) {
 			return;
 		}
-
-		// TODO(Eslint): refactor to now use async function as the promise executor
-		// eslint-disable-next-line no-async-promise-executor
-		return new Promise<void>(async (resolve, reject) => {
-			this.promiseArray.push({ res: resolve, rej: reject });
+		return new Promise(async (res, rej) => {
+			this.promiseArray.push({ res, rej });
 
 			if (this.socketStatus === SOCKET_STATUS.CLOSED) {
 				try {
@@ -773,9 +765,7 @@ export class AWSAppSyncRealTimeProvider {
 					this.promiseArray = [];
 				} catch (err) {
 					logger.debug('Connection exited with', err);
-					this.promiseArray.forEach(({ rej }) => {
-						rej(err);
-					});
+					this.promiseArray.forEach(({ rej }) => rej(err));
 					this.promiseArray = [];
 					if (
 						this.awsRealTimeSocket &&
@@ -805,24 +795,23 @@ export class AWSAppSyncRealTimeProvider {
 		// Step 1: connect websocket
 		try {
 			await (() => {
-				return new Promise<void>((resolve, reject) => {
+				return new Promise<void>((res, rej) => {
 					const newSocket = this.getNewWebSocket(awsRealTimeUrl, 'graphql-ws');
 					newSocket.onerror = () => {
 						logger.debug(`WebSocket connection error`);
 					};
 					newSocket.onclose = () => {
-						reject(new Error('Connection handshake error'));
+						rej(new Error('Connection handshake error'));
 					};
 					newSocket.onopen = () => {
 						this.awsRealTimeSocket = newSocket;
-
-						resolve();
+						return res();
 					};
 				});
 			})();
 			// Step 2: wait for ack from AWS AppSyncReaTime after sending init
 			await (() => {
-				return new Promise((resolve, reject) => {
+				return new Promise((res, rej) => {
 					if (this.awsRealTimeSocket) {
 						let ackOk = false;
 						this.awsRealTimeSocket.onerror = error => {
@@ -830,7 +819,7 @@ export class AWSAppSyncRealTimeProvider {
 						};
 						this.awsRealTimeSocket.onclose = event => {
 							logger.debug(`WebSocket closed ${event.reason}`);
-							reject(new Error(JSON.stringify(event)));
+							rej(new Error(JSON.stringify(event)));
 						};
 
 						this.awsRealTimeSocket.onmessage = (message: MessageEvent) => {
@@ -862,8 +851,7 @@ export class AWSAppSyncRealTimeProvider {
 										this._errorDisconnect(CONTROL_MSG.CONNECTION_CLOSED);
 									};
 								}
-								resolve('Cool, connected to AWS AppSyncRealTime');
-
+								res('Cool, connected to AWS AppSyncRealTime');
 								return;
 							}
 
@@ -874,9 +862,7 @@ export class AWSAppSyncRealTimeProvider {
 									} = {},
 								} = data;
 
-								// TODO(Eslint): refactor to reject an Error object instead of a plain object
-								// eslint-disable-next-line prefer-promise-reject-errors
-								reject({ errorType, errorCode });
+								rej({ errorType, errorCode });
 							}
 						};
 
@@ -885,12 +871,12 @@ export class AWSAppSyncRealTimeProvider {
 						};
 						this.awsRealTimeSocket.send(JSON.stringify(gqlInit));
 
-						const checkAckOk = (targetAckOk: boolean) => {
-							if (!targetAckOk) {
+						const checkAckOk = (ackOk: boolean) => {
+							if (!ackOk) {
 								this.connectionStateMonitor.record(
 									CONNECTION_CHANGE.CONNECTION_FAILED,
 								);
-								reject(
+								rej(
 									new Error(
 										`Connection timeout: ack from AWSAppSyncRealTime was not received after ${CONNECTION_INIT_TIMEOUT} ms`,
 									),
@@ -898,9 +884,7 @@ export class AWSAppSyncRealTimeProvider {
 							}
 						};
 
-						setTimeout(() => {
-							checkAckOk(ackOk);
-						}, CONNECTION_INIT_TIMEOUT);
+						setTimeout(() => checkAckOk(ackOk), CONNECTION_INIT_TIMEOUT);
 					}
 				});
 			})();
@@ -932,9 +916,7 @@ export class AWSAppSyncRealTimeProvider {
 		Record<string, unknown> | undefined
 	> {
 		const headerHandler: {
-			[key in GraphQLAuthMode]: (
-				arg0: AWSAppSyncRealTimeAuthInput,
-			) => Promise<Record<string, unknown>> | Record<string, unknown>;
+			[key in GraphQLAuthMode]: (arg0: AWSAppSyncRealTimeAuthInput) => {};
 		} = {
 			apiKey: this._awsRealTimeApiKeyHeader.bind(this),
 			iam: this._awsRealTimeIAMHeader.bind(this),
@@ -946,7 +928,6 @@ export class AWSAppSyncRealTimeProvider {
 
 		if (!authenticationType || !headerHandler[authenticationType]) {
 			logger.debug(`Authentication type ${authenticationType} not supported`);
-
 			return undefined;
 		} else {
 			const handler = headerHandler[authenticationType];
@@ -988,7 +969,7 @@ export class AWSAppSyncRealTimeProvider {
 		host,
 	}: AWSAppSyncRealTimeAuthInput) {
 		const dt = new Date();
-		const dtStr = dt.toISOString().replace(/[:-]|\.\d{3}/g, '');
+		const dtStr = dt.toISOString().replace(/[:\-]|\.\d{3}/g, '');
 
 		return {
 			host,
@@ -1017,7 +998,7 @@ export class AWSAppSyncRealTimeProvider {
 			headers: { ...AWS_APPSYNC_REALTIME_HEADERS },
 		};
 
-		const signedParams = signRequest(
+		const signed_params = signRequest(
 			{
 				headers: request.headers,
 				method: request.method,
@@ -1031,8 +1012,7 @@ export class AWSAppSyncRealTimeProvider {
 				signingService: endpointInfo.service,
 			},
 		);
-
-		return signedParams.headers;
+		return signed_params.headers;
 	}
 
 	private _customAuthHeader({
@@ -1044,7 +1024,7 @@ export class AWSAppSyncRealTimeProvider {
 		 * the headers that are returned by that function will already have been
 		 * provided before this function is called.
 		 */
-		if (!additionalCustomHeaders?.Authorization) {
+		if (!additionalCustomHeaders?.['Authorization']) {
 			throw new Error('No auth token specified');
 		}