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

package/src/sync/merger.ts

@@ -15,6 +15,12 @@ class ModelMerger {
 		private readonly ownSymbol: Symbol
 	) {}
 
+	/**
+	 *
+	 * @param storage Storage adapter that contains the data.
+	 * @param model The model from an outbox mutation.
+	 * @returns The type of operation (INSERT/UPDATE/DELETE)
+	 */
 	public async merge<T extends ModelInstanceMetadata>(
 		storage: Storage,
 		model: T,

package/src/sync/outbox.ts

@@ -32,7 +32,7 @@ class MutationEventOutbox {
 		storage: Storage,
 		mutationEvent: MutationEvent
 	): Promise<void> {
-		storage.runExclusive(async s => {
+		await storage.runExclusive(async s => {
 			const mutationEventModelDefinition =
 				this.schema.namespaces[SYNC].models['MutationEvent'];
 

package/src/sync/processors/mutation.ts

@@ -4,6 +4,7 @@ import {
 	jitteredBackoff,
 	NonRetryableError,
 	retry,
+	BackgroundProcessManager,
 } from '@aws-amplify/core';
 import Observable, { ZenObservable } from 'zen-observable-ts';
 import { MutationEvent } from '../';
@@ -63,6 +64,8 @@ class MutationProcessor {
 	>();
 	private processing: boolean = false;
 
+	private runningProcesses = new BackgroundProcessManager();
+
 	constructor(
 		private readonly schema: InternalSchema,
 		private readonly storage: Storage,
@@ -118,126 +121,150 @@ class MutationProcessor {
 		const observable = new Observable<MutationProcessorEvent>(observer => {
 			this.observer = observer;
 
-			this.resume();
+			try {
+				this.resume();
+			} catch (error) {
+				logger.error('mutations processor start error', error);
+				throw error;
+			}
 
-			return () => {
+			return this.runningProcesses.addCleaner(async () => {
 				this.pause();
-			};
+			});
 		});
 
 		return observable;
 	}
 
-	public async resume(): Promise<void> {
-		if (this.processing || !this.isReady()) {
-			return;
-		}
+	public async stop() {
+		await this.runningProcesses.close();
+		await this.runningProcesses.open();
+	}
 
-		this.processing = true;
-		let head: MutationEvent;
-		const namespaceName = USER;
-
-		// start to drain outbox
-		while (
-			this.processing &&
-			(head = await this.outbox.peek(this.storage)) !== undefined
-		) {
-			const { model, operation, data, condition } = head;
-			const modelConstructor = this.userClasses[
-				model
-			] as PersistentModelConstructor<MutationEvent>;
-			let result: GraphQLResult<Record<string, PersistentModel>>;
-			let opName: string;
-			let modelDefinition: SchemaModel;
-			try {
-				const modelAuthModes = await getModelAuthModes({
-					authModeStrategy: this.authModeStrategy,
-					defaultAuthMode: this.amplifyConfig.aws_appsync_authenticationType,
-					modelName: model,
-					schema: this.schema,
-				});
+	public async resume(): Promise<void> {
+		await (this.runningProcesses.isOpen &&
+			this.runningProcesses.add(async onTerminate => {
+				if (
+					this.processing ||
+					!this.isReady() ||
+					!this.runningProcesses.isOpen
+				) {
+					return;
+				}
 
-				const operationAuthModes = modelAuthModes[operation.toUpperCase()];
+				this.processing = true;
+				let head: MutationEvent;
+				const namespaceName = USER;
+
+				// start to drain outbox
+				while (
+					this.processing &&
+					this.runningProcesses.isOpen &&
+					(head = await this.outbox.peek(this.storage)) !== undefined
+				) {
+					const { model, operation, data, condition } = head;
+					const modelConstructor = this.userClasses[
+						model
+					] as PersistentModelConstructor<MutationEvent>;
+					let result: GraphQLResult<Record<string, PersistentModel>>;
+					let opName: string;
+					let modelDefinition: SchemaModel;
 
-				let authModeAttempts = 0;
-				const authModeRetry = async () => {
 					try {
-						logger.debug(
-							`Attempting mutation with authMode: ${operationAuthModes[authModeAttempts]}`
-						);
-						const response = await this.jitteredRetry(
-							namespaceName,
-							model,
-							operation,
-							data,
-							condition,
-							modelConstructor,
-							this.MutationEvent,
-							head,
-							operationAuthModes[authModeAttempts]
-						);
-
-						logger.debug(
-							`Mutation sent successfully with authMode: ${operationAuthModes[authModeAttempts]}`
-						);
+						const modelAuthModes = await getModelAuthModes({
+							authModeStrategy: this.authModeStrategy,
+							defaultAuthMode:
+								this.amplifyConfig.aws_appsync_authenticationType,
+							modelName: model,
+							schema: this.schema,
+						});
+
+						const operationAuthModes = modelAuthModes[operation.toUpperCase()];
+
+						let authModeAttempts = 0;
+						const authModeRetry = async () => {
+							try {
+								logger.debug(
+									`Attempting mutation with authMode: ${operationAuthModes[authModeAttempts]}`
+								);
+								const response = await this.jitteredRetry(
+									namespaceName,
+									model,
+									operation,
+									data,
+									condition,
+									modelConstructor,
+									this.MutationEvent,
+									head,
+									operationAuthModes[authModeAttempts],
+									onTerminate
+								);
+
+								logger.debug(
+									`Mutation sent successfully with authMode: ${operationAuthModes[authModeAttempts]}`
+								);
+
+								return response;
+							} catch (error) {
+								authModeAttempts++;
+								if (authModeAttempts >= operationAuthModes.length) {
+									logger.debug(
+										`Mutation failed with authMode: ${
+											operationAuthModes[authModeAttempts - 1]
+										}`
+									);
+									throw error;
+								}
+								logger.debug(
+									`Mutation failed with authMode: ${
+										operationAuthModes[authModeAttempts - 1]
+									}. Retrying with authMode: ${
+										operationAuthModes[authModeAttempts]
+									}`
+								);
+								return await authModeRetry();
+							}
+						};
 
-						return response;
+						[result, opName, modelDefinition] = await authModeRetry();
 					} catch (error) {
-						authModeAttempts++;
-						if (authModeAttempts >= operationAuthModes.length) {
-							logger.debug(
-								`Mutation failed with authMode: ${
-									operationAuthModes[authModeAttempts - 1]
-								}`
-							);
-							throw error;
+						if (
+							error.message === 'Offline' ||
+							error.message === 'RetryMutation'
+						) {
+							continue;
 						}
-						logger.debug(
-							`Mutation failed with authMode: ${
-								operationAuthModes[authModeAttempts - 1]
-							}. Retrying with authMode: ${
-								operationAuthModes[authModeAttempts]
-							}`
-						);
-						return await authModeRetry();
 					}
-				};
-
-				[result, opName, modelDefinition] = await authModeRetry();
-			} catch (error) {
-				if (error.message === 'Offline' || error.message === 'RetryMutation') {
-					continue;
-				}
-			}
 
-			if (result === undefined) {
-				logger.debug('done retrying');
-				await this.storage.runExclusive(async storage => {
-					await this.outbox.dequeue(storage);
-				});
-				continue;
-			}
+					if (result === undefined) {
+						logger.debug('done retrying');
+						await this.storage.runExclusive(async storage => {
+							await this.outbox.dequeue(storage);
+						});
+						continue;
+					}
 
-			const record = result.data[opName];
-			let hasMore = false;
+					const record = result.data[opName];
+					let hasMore = false;
 
-			await this.storage.runExclusive(async storage => {
-				// using runExclusive to prevent possible race condition
-				// when another record gets enqueued between dequeue and peek
-				await this.outbox.dequeue(storage, record, operation);
-				hasMore = (await this.outbox.peek(storage)) !== undefined;
-			});
+					await this.storage.runExclusive(async storage => {
+						// using runExclusive to prevent possible race condition
+						// when another record gets enqueued between dequeue and peek
+						await this.outbox.dequeue(storage, record, operation);
+						hasMore = (await this.outbox.peek(storage)) !== undefined;
+					});
 
-			this.observer.next({
-				operation,
-				modelDefinition,
-				model: record,
-				hasMore,
-			});
-		}
+					this.observer.next({
+						operation,
+						modelDefinition,
+						model: record,
+						hasMore,
+					});
+				}
 
-		// pauses itself
-		this.pause();
+				// pauses itself
+				this.pause();
+			}, 'mutation resume loop'));
 	}
 
 	private async jitteredRetry(
@@ -249,7 +276,8 @@ class MutationProcessor {
 		modelConstructor: PersistentModelConstructor<PersistentModel>,
 		MutationEvent: PersistentModelConstructor<MutationEvent>,
 		mutationEvent: MutationEvent,
-		authMode: GRAPHQL_AUTH_MODE
+		authMode: GRAPHQL_AUTH_MODE,
+		onTerminate: Promise<void>
 	): Promise<
 		[GraphQLResult<Record<string, PersistentModel>>, string, SchemaModel]
 	> {
@@ -293,7 +321,11 @@ class MutationProcessor {
 						const result = <GraphQLResult<Record<string, PersistentModel>>>(
 							await this.amplifyContext.API.graphql(tryWith)
 						);
-						return [result, opName, modelDefinition];
+
+
+						// `as any` because TypeScript doesn't seem to like passing tuples
+						// through generic params???
+						return [result, opName, modelDefinition] as any;
 					} catch (err) {
 						if (err.errors && err.errors.length > 0) {
 							const [error] = err.errors;
@@ -366,6 +398,8 @@ class MutationProcessor {
 										userAgentSuffix: USER_AGENT_SUFFIX_DATASTORE,
 									});
 
+									// onTerminate cancel graphql()
+
 									return [serverData, opName, modelDefinition];
 								}
 
@@ -390,7 +424,7 @@ class MutationProcessor {
 								throw new NonRetryableError('RetryMutation');
 							} else {
 								try {
-									await this.errorHandler({
+									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: variables.input,
@@ -434,7 +468,8 @@ class MutationProcessor {
 				MutationEvent,
 				mutationEvent,
 			],
-			safeJitteredBackoff
+			safeJitteredBackoff,
+			onTerminate
 		);
 	}