@aws-amplify/datastore 3.12.13-unstable.7 → 3.13.0

package/src/sync/processors/subscription.ts

@@ -1,12 +1,7 @@
 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,
-	BackgroundProcessManager,
-} from '@aws-amplify/core';
+import { ConsoleLogger as Logger, Hub, HubCapsule } from '@aws-amplify/core';
 import { CONTROL_MSG as PUBSUB_CONTROL_MSG } from '@aws-amplify/pubsub';
 import Observable, { ZenObservable } from 'zen-observable-ts';
 import {
@@ -61,8 +56,6 @@ class SubscriptionProcessor {
 		[];
 	private dataObserver: ZenObservable.Observer<any>;
 
-	private runningProcesses: BackgroundProcessManager;
-
 	constructor(
 		private readonly schema: InternalSchema,
 		private readonly syncPredicates: WeakMap<SchemaModel, ModelPredicate<any>>,
@@ -244,19 +237,6 @@ class SubscriptionProcessor {
 		Observable<CONTROL_MSG>,
 		Observable<[TransformerMutationType, SchemaModel, PersistentModel]>
 	] {
-		if (this.runningProcesses) {
-			throw new Error(
-				[
-					'Subscription processor is already started!',
-					'It must be stopped before it can be restarted.',
-					'Please report this error in a GitHub issue.',
-					'https://github.com/aws-amplify/amplify-js/issues',
-				].join('\n')
-			);
-		}
-
-		this.runningProcesses = new BackgroundProcessManager();
-
 		const ctlObservable = new Observable<CONTROL_MSG>(observer => {
 			const promises: Promise<void>[] = [];
 
@@ -272,7 +252,7 @@ class SubscriptionProcessor {
 			let cognitoTokenPayload: { [field: string]: any },
 				oidcTokenPayload: { [field: string]: any };
 			let userCredentials = USER_CREDENTIALS.none;
-			this.runningProcesses.add(async () => {
+			(async () => {
 				try {
 					// retrieving current AWS Credentials
 					const credentials =
@@ -330,270 +310,260 @@ class SubscriptionProcessor {
 				Object.values(this.schema.namespaces).forEach(namespace => {
 					Object.values(namespace.models)
 						.filter(({ syncable }) => syncable)
-						.forEach(modelDefinition =>
-							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]]
-									);
-
-									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'
-											);
-											return;
-										}
-
-										variables[ownerField] = ownerValue;
+						.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'
+										);
+										return;
 									}
 
-									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
-														);
+									variables[ownerField] = ownerValue;
+								}
 
-													const { [opName]: record } = data;
+								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'
+														)}`
+													);
 
-													// 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;
-
+													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 (
-														message.includes(
-															PUBSUB_CONTROL_MSG.REALTIME_SUBSCRIPTION_INIT_ERROR
-														) ||
-														message.includes(
-															PUBSUB_CONTROL_MSG.CONNECTION_FAILED
-														)
+														operationAuthModeAttempts[operation] >=
+														readAuthModes.length
 													) {
-														// Unsubscribe and clear subscription array for model/operation
-														subscriptions[modelDefinition.name][
-															transformerMutationType
-														].forEach(subscription =>
-															subscription.unsubscribe()
+														// last auth mode retry. Continue with error
+														logger.debug(
+															`${operation} subscription failed with authMode: ${
+																readAuthModes[
+																	operationAuthModeAttempts[operation] - 1
+																]
+															}`
 														);
-														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
+													} 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]
+																]
+															}`
 														);
-													}
-
-													if (typeof subscriptionReadyCallback === 'function') {
-														subscriptionReadyCallback();
-													}
-
-													if (
-														message.includes('"errorType":"Unauthorized"') ||
-														message.includes('"errorType":"OperationDisabled"')
-													) {
+														authModeRetry(operation);
 														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));
-							})
-						);
+												}
+												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);
+											},
+										})
+								);
+
+								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));
+						});
 				});
 
-				this.runningProcesses.add(() =>
-					Promise.all(promises).then(() => observer.next(CONTROL_MSG.CONNECTED))
-				);
-			}, 'subscription processor new subscriber');
+				Promise.all(promises).then(() => observer.next(CONTROL_MSG.CONNECTED));
+			})();
 
-			return this.runningProcesses.addCleaner(async () => {
+			return () => {
 				Object.keys(subscriptions).forEach(modelName => {
 					subscriptions[modelName][TransformerMutationType.CREATE].forEach(
 						subscription => subscription.unsubscribe()
@@ -605,7 +575,7 @@ class SubscriptionProcessor {
 						subscription => subscription.unsubscribe()
 					);
 				});
-			});
+			};
 		});
 
 		const dataObservable = new Observable<
@@ -614,18 +584,14 @@ class SubscriptionProcessor {
 			this.dataObserver = observer;
 			this.drainBuffer();
 
-			return this.runningProcesses.addCleaner(async () => {
+			return () => {
 				this.dataObserver = null;
-			});
+			};
 		});
 
 		return [ctlObservable, dataObservable];
 	}
 
-	public async stop() {
-		this.runningProcesses && (await this.runningProcesses.close());
-	}
-
 	private passesPredicateValidation(
 		record: PersistentModel,
 		predicatesGroup: PredicatesGroup<any>