@aws-amplify/datastore 3.14.1-unstable.2 → 3.14.1

package/src/sync/processors/subscription.ts

@@ -1,7 +1,12 @@
 import API, { GraphQLResult, GRAPHQL_AUTH_MODE } from '@aws-amplify/api';
 import { Auth } from '@aws-amplify/auth';
 import Cache from '@aws-amplify/cache';
-import { ConsoleLogger as Logger, Hub, HubCapsule } from '@aws-amplify/core';
+import {
+	ConsoleLogger as Logger,
+	Hub,
+	HubCapsule,
+	BackgroundProcessManager,
+} from '@aws-amplify/core';
 import { CONTROL_MSG as PUBSUB_CONTROL_MSG } from '@aws-amplify/pubsub';
 import Observable, { ZenObservable } from 'zen-observable-ts';
 import {
@@ -56,6 +61,8 @@ class SubscriptionProcessor {
 		[];
 	private dataObserver: ZenObservable.Observer<any>;
 
+	private runningProcesses = new BackgroundProcessManager();
+
 	constructor(
 		private readonly schema: InternalSchema,
 		private readonly syncPredicates: WeakMap<SchemaModel, ModelPredicate<any>>,
@@ -252,7 +259,7 @@ class SubscriptionProcessor {
 			let cognitoTokenPayload: { [field: string]: any },
 				oidcTokenPayload: { [field: string]: any };
 			let userCredentials = USER_CREDENTIALS.none;
-			(async () => {
+			this.runningProcesses.add(async () => {
 				try {
 					// retrieving current AWS Credentials
 					const credentials =
@@ -310,260 +317,285 @@ class SubscriptionProcessor {
 				Object.values(this.schema.namespaces).forEach(namespace => {
 					Object.values(namespace.models)
 						.filter(({ syncable }) => syncable)
-						.forEach(async modelDefinition => {
-							const modelAuthModes = await getModelAuthModes({
-								authModeStrategy: this.authModeStrategy,
-								defaultAuthMode:
-									this.amplifyConfig.aws_appsync_authenticationType,
-								modelName: modelDefinition.name,
-								schema: this.schema,
-							});
-
-							// subscriptions are created only based on the READ auth mode(s)
-							const readAuthModes = modelAuthModes.READ;
-
-							subscriptions = {
-								...subscriptions,
-								[modelDefinition.name]: {
-									[TransformerMutationType.CREATE]: [],
-									[TransformerMutationType.UPDATE]: [],
-									[TransformerMutationType.DELETE]: [],
-								},
-							};
-
-							const operations = [
-								TransformerMutationType.CREATE,
-								TransformerMutationType.UPDATE,
-								TransformerMutationType.DELETE,
-							];
-
-							const operationAuthModeAttempts = {
-								[TransformerMutationType.CREATE]: 0,
-								[TransformerMutationType.UPDATE]: 0,
-								[TransformerMutationType.DELETE]: 0,
-							};
-
-							// Retry failed subscriptions with next auth mode (if available)
-							const authModeRetry = async operation => {
-								const {
-									opType: transformerMutationType,
-									opName,
-									query,
-									isOwner,
-									ownerField,
-									ownerValue,
-									authMode,
-								} = this.buildSubscription(
-									namespace,
-									modelDefinition,
-									operation,
-									userCredentials,
-									cognitoTokenPayload,
-									oidcTokenPayload,
-									readAuthModes[operationAuthModeAttempts[operation]]
-								);
-
-								const authToken = await getTokenForCustomAuth(
-									authMode,
-									this.amplifyConfig
-								);
-
-								const variables = {};
-
-								if (isOwner) {
-									if (!ownerValue) {
-										observer.error(
-											'Owner field required, sign in is needed in order to perform this operation'
+						.forEach(
+							modelDefinition =>
+								this.runningProcesses.isOpen &&
+								this.runningProcesses.add(async () => {
+									const modelAuthModes = await getModelAuthModes({
+										authModeStrategy: this.authModeStrategy,
+										defaultAuthMode:
+											this.amplifyConfig.aws_appsync_authenticationType,
+										modelName: modelDefinition.name,
+										schema: this.schema,
+									});
+
+									// subscriptions are created only based on the READ auth mode(s)
+									const readAuthModes = modelAuthModes.READ;
+
+									subscriptions = {
+										...subscriptions,
+										[modelDefinition.name]: {
+											[TransformerMutationType.CREATE]: [],
+											[TransformerMutationType.UPDATE]: [],
+											[TransformerMutationType.DELETE]: [],
+										},
+									};
+
+									const operations = [
+										TransformerMutationType.CREATE,
+										TransformerMutationType.UPDATE,
+										TransformerMutationType.DELETE,
+									];
+
+									const operationAuthModeAttempts = {
+										[TransformerMutationType.CREATE]: 0,
+										[TransformerMutationType.UPDATE]: 0,
+										[TransformerMutationType.DELETE]: 0,
+									};
+
+									// Retry failed subscriptions with next auth mode (if available)
+									const authModeRetry = async operation => {
+										const {
+											opType: transformerMutationType,
+											opName,
+											query,
+											isOwner,
+											ownerField,
+											ownerValue,
+											authMode,
+										} = this.buildSubscription(
+											namespace,
+											modelDefinition,
+											operation,
+											userCredentials,
+											cognitoTokenPayload,
+											oidcTokenPayload,
+											readAuthModes[operationAuthModeAttempts[operation]]
 										);
-										return;
-									}
-
-									variables[ownerField] = ownerValue;
-								}
-
-								logger.debug(
-									`Attempting ${operation} subscription with authMode: ${
-										readAuthModes[operationAuthModeAttempts[operation]]
-									}`
-								);
-
-								const userAgentSuffix = USER_AGENT_SUFFIX_DATASTORE;
-
-								const queryObservable = <
-									Observable<{
-										value: GraphQLResult<Record<string, PersistentModel>>;
-									}>
-								>(<unknown>this.amplifyContext.API.graphql({ query, variables, ...{ authMode }, authToken, userAgentSuffix }));
-
-								let subscriptionReadyCallback: () => void;
-
-								subscriptions[modelDefinition.name][
-									transformerMutationType
-								].push(
-									queryObservable
-										.map(({ value }) => {
-											return value;
-										})
-										.subscribe({
-											next: ({ data, errors }) => {
-												if (Array.isArray(errors) && errors.length > 0) {
-													const messages = (<
-														{
-															message: string;
-														}[]
-													>errors).map(({ message }) => message);
-
-													logger.warn(
-														`Skipping incoming subscription. Messages: ${messages.join(
-															'\n'
-														)}`
-													);
 
-													this.drainBuffer();
-													return;
-												}
+										const authToken = await getTokenForCustomAuth(
+											authMode,
+											this.amplifyConfig
+										);
 
-												const predicatesGroup =
-													ModelPredicateCreator.getPredicates(
-														this.syncPredicates.get(modelDefinition),
-														false
-													);
+										const variables = {};
 
-												const { [opName]: record } = data;
-
-												// checking incoming subscription against syncPredicate.
-												// once AppSync implements filters on subscriptions, we'll be
-												// able to set these when establishing the subscription instead.
-												// Until then, we'll need to filter inbound
-												if (
-													this.passesPredicateValidation(
-														record,
-														predicatesGroup
-													)
-												) {
-													this.pushToBuffer(
-														transformerMutationType,
-														modelDefinition,
-														record
-													);
-												}
-												this.drainBuffer();
-											},
-											error: async subscriptionError => {
-												const {
-													error: { errors: [{ message = '' } = {}] } = {
-														errors: [],
+										if (isOwner) {
+											if (!ownerValue) {
+												observer.error(
+													'Owner field required, sign in is needed in order to perform this operation'
+												);
+												return;
+											}
+
+											variables[ownerField] = ownerValue;
+										}
+
+										logger.debug(
+											`Attempting ${operation} subscription with authMode: ${
+												readAuthModes[operationAuthModeAttempts[operation]]
+											}`
+										);
+
+										const userAgentSuffix = USER_AGENT_SUFFIX_DATASTORE;
+
+										const queryObservable = <
+											Observable<{
+												value: GraphQLResult<Record<string, PersistentModel>>;
+											}>
+										>(<unknown>this.amplifyContext.API.graphql({
+											query,
+											variables,
+											...{ authMode },
+											authToken,
+											userAgentSuffix,
+										}));
+
+										let subscriptionReadyCallback: () => void;
+
+										// TODO: consider onTerminate.then(() => API.cancel(...))
+
+										subscriptions[modelDefinition.name][
+											transformerMutationType
+										].push(
+											queryObservable
+												.map(({ value }) => {
+													return value;
+												})
+												.subscribe({
+													next: ({ data, errors }) => {
+														if (Array.isArray(errors) && errors.length > 0) {
+															const messages = (<
+																{
+																	message: string;
+																}[]
+															>errors).map(({ message }) => message);
+
+															logger.warn(
+																`Skipping incoming subscription. Messages: ${messages.join(
+																	'\n'
+																)}`
+															);
+
+															this.drainBuffer();
+															return;
+														}
+
+														const predicatesGroup =
+															ModelPredicateCreator.getPredicates(
+																this.syncPredicates.get(modelDefinition),
+																false
+															);
+
+														const { [opName]: record } = data;
+
+														// checking incoming subscription against syncPredicate.
+														// once AppSync implements filters on subscriptions, we'll be
+														// able to set these when establishing the subscription instead.
+														// Until then, we'll need to filter inbound
+														if (
+															this.passesPredicateValidation(
+																record,
+																predicatesGroup
+															)
+														) {
+															this.pushToBuffer(
+																transformerMutationType,
+																modelDefinition,
+																record
+															);
+														}
+														this.drainBuffer();
+													},
+													error: async subscriptionError => {
+														const {
+															error: { errors: [{ message = '' } = {}] } = {
+																errors: [],
+															},
+														} = subscriptionError;
+
+														if (
+															message.includes(
+																PUBSUB_CONTROL_MSG.REALTIME_SUBSCRIPTION_INIT_ERROR
+															) ||
+															message.includes(
+																PUBSUB_CONTROL_MSG.CONNECTION_FAILED
+															)
+														) {
+															// Unsubscribe and clear subscription array for model/operation
+															subscriptions[modelDefinition.name][
+																transformerMutationType
+															].forEach(subscription =>
+																subscription.unsubscribe()
+															);
+															subscriptions[modelDefinition.name][
+																transformerMutationType
+															] = [];
+
+															operationAuthModeAttempts[operation]++;
+															if (
+																operationAuthModeAttempts[operation] >=
+																readAuthModes.length
+															) {
+																// last auth mode retry. Continue with error
+																logger.debug(
+																	`${operation} subscription failed with authMode: ${
+																		readAuthModes[
+																			operationAuthModeAttempts[operation] - 1
+																		]
+																	}`
+																);
+															} else {
+																// retry with different auth mode. Do not trigger
+																// observer error or error handler
+																logger.debug(
+																	`${operation} subscription failed with authMode: ${
+																		readAuthModes[
+																			operationAuthModeAttempts[operation] - 1
+																		]
+																	}. Retrying with authMode: ${
+																		readAuthModes[
+																			operationAuthModeAttempts[operation]
+																		]
+																	}`
+																);
+																authModeRetry(operation);
+																return;
+															}
+														}
+														logger.warn('subscriptionError', message);
+
+														try {
+															await this.errorHandler({
+																recoverySuggestion:
+																	'Ensure app code is up to date, auth directives exist and are correct on each model, and that server-side data has not been invalidated by a schema change. If the problem persists, search for or create an issue: https://github.com/aws-amplify/amplify-js/issues',
+																localModel: null,
+																message,
+																model: modelDefinition.name,
+																operation,
+																errorType:
+																	getSubscriptionErrorType(subscriptionError),
+																process: ProcessName.subscribe,
+																remoteModel: null,
+																cause: subscriptionError,
+															});
+														} catch (e) {
+															logger.error(
+																'Subscription error handler failed with:',
+																e
+															);
+														}
+
+														if (
+															typeof subscriptionReadyCallback === 'function'
+														) {
+															subscriptionReadyCallback();
+														}
+
+														if (
+															message.includes('"errorType":"Unauthorized"') ||
+															message.includes(
+																'"errorType":"OperationDisabled"'
+															)
+														) {
+															return;
+														}
+														observer.error(message);
 													},
-												} = subscriptionError;
-
-												if (
-													message.includes(
-														PUBSUB_CONTROL_MSG.REALTIME_SUBSCRIPTION_INIT_ERROR
-													) ||
-													message.includes(PUBSUB_CONTROL_MSG.CONNECTION_FAILED)
-												) {
-													// Unsubscribe and clear subscription array for model/operation
-													subscriptions[modelDefinition.name][
-														transformerMutationType
-													].forEach(subscription => subscription.unsubscribe());
-													subscriptions[modelDefinition.name][
-														transformerMutationType
-													] = [];
-
-													operationAuthModeAttempts[operation]++;
-													if (
-														operationAuthModeAttempts[operation] >=
-														readAuthModes.length
-													) {
-														// last auth mode retry. Continue with error
-														logger.debug(
-															`${operation} subscription failed with authMode: ${
-																readAuthModes[
-																	operationAuthModeAttempts[operation] - 1
-																]
-															}`
-														);
-													} else {
-														// retry with different auth mode. Do not trigger
-														// observer error or error handler
-														logger.debug(
-															`${operation} subscription failed with authMode: ${
-																readAuthModes[
-																	operationAuthModeAttempts[operation] - 1
-																]
-															}. Retrying with authMode: ${
-																readAuthModes[
-																	operationAuthModeAttempts[operation]
-																]
-															}`
-														);
-														authModeRetry(operation);
-														return;
-													}
-												}
-												logger.warn('subscriptionError', message);
-
-												try {
-													await this.errorHandler({
-														recoverySuggestion:
-															'Ensure app code is up to date, auth directives exist and are correct on each model, and that server-side data has not been invalidated by a schema change. If the problem persists, search for or create an issue: https://github.com/aws-amplify/amplify-js/issues',
-														localModel: null,
-														message,
-														model: modelDefinition.name,
-														operation,
-														errorType:
-															getSubscriptionErrorType(subscriptionError),
-														process: ProcessName.subscribe,
-														remoteModel: null,
-														cause: subscriptionError,
-													});
-												} catch (e) {
-													logger.error(
-														'Subscription error handler failed with:',
-														e
+												})
+										);
+
+										promises.push(
+											(async () => {
+												let boundFunction: any;
+
+												await new Promise(res => {
+													subscriptionReadyCallback = res;
+													boundFunction = this.hubQueryCompletionListener.bind(
+														this,
+														res
 													);
-												}
-
-												if (typeof subscriptionReadyCallback === 'function') {
-													subscriptionReadyCallback();
-												}
-
-												if (
-													message.includes('"errorType":"Unauthorized"') ||
-													message.includes('"errorType":"OperationDisabled"')
-												) {
-													return;
-												}
-												observer.error(message);
-											},
-										})
-								);
-
-								promises.push(
-									(async () => {
-										let boundFunction: any;
-
-										await new Promise(res => {
-											subscriptionReadyCallback = res;
-											boundFunction = this.hubQueryCompletionListener.bind(
-												this,
-												res
-											);
-											Hub.listen('api', boundFunction);
-										});
-										Hub.remove('api', boundFunction);
-									})()
-								);
-							};
-
-							operations.forEach(op => authModeRetry(op));
-						});
+													Hub.listen('api', boundFunction);
+												});
+												Hub.remove('api', boundFunction);
+											})()
+										);
+									};
+
+									operations.forEach(op => authModeRetry(op));
+								})
+						);
 				});
 
-				Promise.all(promises).then(() => observer.next(CONTROL_MSG.CONNECTED));
-			})();
+				this.runningProcesses.isOpen &&
+					this.runningProcesses.add(() =>
+						Promise.all(promises).then(() => {
+							observer.next(CONTROL_MSG.CONNECTED);
+						})
+					);
+			}, 'subscription processor new subscriber');
 
-			return () => {
+			return this.runningProcesses.addCleaner(async () => {
 				Object.keys(subscriptions).forEach(modelName => {
 					subscriptions[modelName][TransformerMutationType.CREATE].forEach(
 						subscription => subscription.unsubscribe()
@@ -575,7 +607,7 @@ class SubscriptionProcessor {
 						subscription => subscription.unsubscribe()
 					);
 				});
-			};
+			});
 		});
 
 		const dataObservable = new Observable<
@@ -584,14 +616,19 @@ class SubscriptionProcessor {
 			this.dataObserver = observer;
 			this.drainBuffer();
 
-			return () => {
+			return this.runningProcesses.addCleaner(async () => {
 				this.dataObserver = null;
-			};
+			});
 		});
 
 		return [ctlObservable, dataObservable];
 	}
 
+	public async stop() {
+		await this.runningProcesses.close();
+		await this.runningProcesses.open();
+	}
+
 	private passesPredicateValidation(
 		record: PersistentModel,
 		predicatesGroup: PredicatesGroup<any>