@aws-amplify/datastore 3.12.6-next.13 → 3.12.6-next.32

package/src/sync/merger.ts

@@ -3,8 +3,10 @@ import {
 	ModelInstanceMetadata,
 	OpType,
 	PersistentModelConstructor,
+	SchemaModel,
 } from '../types';
 import { MutationEventOutbox } from './outbox';
+import { getIdentifierValue } from './utils';
 
 // https://github.com/aws-amplify/amplify-js/blob/datastore-docs/packages/datastore/docs/sync-engine.md#merger
 class ModelMerger {
@@ -13,12 +15,23 @@ 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
+		model: T,
+		modelDefinition: SchemaModel
 	): Promise<OpType> {
 		let result: OpType;
-		const mutationsForModel = await this.outbox.getForModel(storage, model);
+		const mutationsForModel = await this.outbox.getForModel(
+			storage,
+			model,
+			modelDefinition
+		);
 
 		const isDelete = model._deleted;
 
@@ -37,13 +50,16 @@ class ModelMerger {
 	public async mergePage(
 		storage: Storage,
 		modelConstructor: PersistentModelConstructor<any>,
-		items: ModelInstanceMetadata[]
+		items: ModelInstanceMetadata[],
+		modelDefinition: SchemaModel
 	): Promise<[ModelInstanceMetadata, OpType][]> {
 		const itemsMap: Map<string, ModelInstanceMetadata> = new Map();
 
 		for (const item of items) {
 			// merge items by model id. Latest record for a given id remains.
-			itemsMap.set(item.id, item);
+			const modelId = getIdentifierValue(modelDefinition, item);
+
+			itemsMap.set(modelId, item);
 		}
 
 		const page = [...itemsMap.values()];

package/src/sync/outbox.ts

@@ -11,9 +11,10 @@ import {
 	PersistentModel,
 	PersistentModelConstructor,
 	QueryOne,
+	SchemaModel,
 } from '../types';
 import { USER, SYNC, valuesEqual } from '../util';
-import { TransformerMutationType } from './utils';
+import { getIdentifierValue, TransformerMutationType } from './utils';
 
 // TODO: Persist deleted ids
 // https://github.com/aws-amplify/amplify-js/blob/datastore-docs/packages/datastore/docs/sync-engine.md#outbox
@@ -31,10 +32,12 @@ 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'];
 
+			// `id` is the key for the record in the mutationEvent;
+			// `modelId` is the key for the actual record that was mutated
 			const predicate = ModelPredicateCreator.createFromExisting<MutationEvent>(
 				mutationEventModelDefinition,
 				c =>
@@ -43,13 +46,16 @@ class MutationEventOutbox {
 						.id('ne', this.inProgressMutationEventId)
 			);
 
+			// Check if there are any other records with same id
 			const [first] = await s.query(this.MutationEvent, predicate);
 
+			// No other record with same modelId, so enqueue
 			if (first === undefined) {
 				await s.save(mutationEvent, undefined, this.ownSymbol);
 				return;
 			}
 
+			// There was an enqueued mutation for the modelId, so continue
 			const { operation: incomingMutationType } = mutationEvent;
 
 			if (first.operation === TransformerMutationType.CREATE) {
@@ -122,16 +128,19 @@ class MutationEventOutbox {
 
 	public async getForModel<T extends PersistentModel>(
 		storage: StorageFacade,
-		model: T
+		model: T,
+		userModelDefinition: SchemaModel
 	): Promise<MutationEvent[]> {
 		const mutationEventModelDefinition =
 			this.schema.namespaces[SYNC].models.MutationEvent;
 
+		const modelId = getIdentifierValue(userModelDefinition, model);
+
 		const mutationEvents = await storage.query(
 			this.MutationEvent,
 			ModelPredicateCreator.createFromExisting(
 				mutationEventModelDefinition,
-				c => c.modelId('eq', model.id)
+				c => c.modelId('eq', modelId)
 			)
 		);
 
@@ -187,9 +196,14 @@ class MutationEventOutbox {
 		const mutationEventModelDefinition =
 			this.schema.namespaces[SYNC].models['MutationEvent'];
 
+		const userModelDefinition =
+			this.schema.namespaces['user'].models[head.model];
+
+		const recordId = getIdentifierValue(userModelDefinition, record);
+
 		const predicate = ModelPredicateCreator.createFromExisting<MutationEvent>(
 			mutationEventModelDefinition,
-			c => c.modelId('eq', record.id).id('ne', this.inProgressMutationEventId)
+			c => c.modelId('eq', recordId).id('ne', this.inProgressMutationEventId)
 		);
 
 		const outdatedMutations = await storage.query(
@@ -224,11 +238,11 @@ class MutationEventOutbox {
 		previous: MutationEvent,
 		current: MutationEvent
 	): MutationEvent {
-		const { _version, id, _lastChangedAt, _deleted, ...previousData } =
-			JSON.parse(previous.data);
+		const { _version, _lastChangedAt, _deleted, ...previousData } = JSON.parse(
+			previous.data
+		);
 
 		const {
-			id: __id,
 			_version: __version,
 			_lastChangedAt: __lastChangedAt,
 			_deleted: __deleted,
@@ -236,7 +250,6 @@ class MutationEventOutbox {
 		} = JSON.parse(current.data);
 
 		const data = JSON.stringify({
-			id,
 			_version,
 			_lastChangedAt,
 			_deleted,

package/src/sync/processors/mutation.ts

@@ -1,9 +1,10 @@
-import API, { GraphQLResult, GRAPHQL_AUTH_MODE } from '@aws-amplify/api';
+import { API, GraphQLResult, GRAPHQL_AUTH_MODE } from '@aws-amplify/api';
 import {
 	ConsoleLogger as Logger,
 	jitteredBackoff,
 	NonRetryableError,
 	retry,
+	BackgroundProcessManager,
 } from '@aws-amplify/core';
 import Observable, { ZenObservable } from 'zen-observable-ts';
 import { MutationEvent } from '../';
@@ -27,7 +28,13 @@ import {
 	ProcessName,
 	AmplifyContext,
 } from '../../types';
-import { exhaustiveCheck, USER, USER_AGENT_SUFFIX_DATASTORE } from '../../util';
+import {
+	exhaustiveCheck,
+	extractTargetNamesFromSrc,
+	USER,
+	USER_AGENT_SUFFIX_DATASTORE,
+	ID,
+} from '../../util';
 import { MutationEventOutbox } from '../outbox';
 import {
 	buildGraphQLOperation,
@@ -57,6 +64,8 @@ class MutationProcessor {
 	>();
 	private processing: boolean = false;
 
+	private runningProcesses = new BackgroundProcessManager();
+
 	constructor(
 		private readonly schema: InternalSchema,
 		private readonly storage: Storage,
@@ -112,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(
@@ -243,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]
 	> {
@@ -287,7 +321,10 @@ 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;
@@ -360,6 +397,8 @@ class MutationProcessor {
 										userAgentSuffix: USER_AGENT_SUFFIX_DATASTORE,
 									});
 
+									// onTerminate cancel graphql()
+
 									return [serverData, opName, modelDefinition];
 								}
 
@@ -384,7 +423,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,
@@ -428,7 +467,8 @@ class MutationProcessor {
 				MutationEvent,
 				mutationEvent,
 			],
-			safeJitteredBackoff
+			safeJitteredBackoff,
+			onTerminate
 		);
 	}
 
@@ -452,63 +492,61 @@ class MutationProcessor {
 
 		// include all the fields that comprise a custom PK if one is specified
 		const deleteInput = {};
-		if (primaryKey && primaryKey.length) {
+		if (primaryKey?.length) {
 			for (const pkField of primaryKey) {
 				deleteInput[pkField] = parsedData[pkField];
 			}
 		} else {
-			deleteInput['id'] = parsedData.id;
+			deleteInput[ID] = (<any>parsedData).id;
 		}
 
-		const filteredData =
-			operation === TransformerMutationType.DELETE
-				? <ModelInstanceMetadata>deleteInput // For DELETE mutations, only PK is sent
-				: Object.values(modelDefinition.fields)
-						.filter(({ name, type, association }) => {
-							// connections
-							if (isModelFieldType(type)) {
-								// BELONGS_TO
-								if (
-									isTargetNameAssociation(association) &&
-									association.connectionType === 'BELONGS_TO'
-								) {
-									return true;
-								}
-
-								// All other connections
-								return false;
-							}
+		let mutationInput;
 
-							if (operation === TransformerMutationType.UPDATE) {
-								// this limits the update mutation input to changed fields only
-								return parsedData.hasOwnProperty(name);
+		if (operation === TransformerMutationType.DELETE) {
+			// For DELETE mutations, only the key(s) are included in the input
+			mutationInput = <ModelInstanceMetadata>deleteInput;
+		} else {
+			// Otherwise, we construct the mutation input with the following logic
+			mutationInput = {};
+			const modelFields = Object.values(modelDefinition.fields);
+
+			for (const { name, type, association } of modelFields) {
+				// model fields should be stripped out from the input
+				if (isModelFieldType(type)) {
+					// except for belongs to relations - we need to replace them with the correct foreign key(s)
+					if (
+						isTargetNameAssociation(association) &&
+						association.connectionType === 'BELONGS_TO'
+					) {
+						const targetNames: string[] | undefined =
+							extractTargetNamesFromSrc(association);
+
+						if (targetNames) {
+							// instead of including the connected model itself, we add its key(s) to the mutation input
+							for (const targetName of targetNames) {
+								mutationInput[targetName] = parsedData[targetName];
 							}
+						}
+					}
+					continue;
+				}
+				// scalar fields / non-model types
 
-							// scalars and non-model types
-							return true;
-						})
-						.map(({ name, type, association }) => {
-							let fieldName = name;
-							let val = parsedData[name];
-
-							if (
-								isModelFieldType(type) &&
-								isTargetNameAssociation(association)
-							) {
-								fieldName = association.targetName;
-								val = parsedData[fieldName];
-							}
+				if (operation === TransformerMutationType.UPDATE) {
+					if (!parsedData.hasOwnProperty(name)) {
+						// for update mutations - strip out a field if it's unchanged
+						continue;
+					}
+				}
 
-							return [fieldName, val];
-						})
-						.reduce((acc, [k, v]) => {
-							acc[k] = v;
-							return acc;
-						}, <typeof parsedData>{});
+				// all other fields are added to the input object
+				mutationInput[name] = parsedData[name];
+			}
+		}
 
 		// Build mutation variables input object
 		const input: ModelInstanceMetadata = {
-			...filteredData,
+			...mutationInput,
 			_version,
 		};