@aws-amplify/datastore 3.12.12 → 3.12.13-custom-pk.1

package/src/storage/adapter/index.ts

@@ -29,7 +29,7 @@ export interface Adapter extends SystemComponent {
 		firstOrLast: QueryOne
 	): Promise<T | undefined>;
 	batchSave<T extends PersistentModel>(
-		modelConstructor: PersistentModelConstructor<any>,
+		modelConstructor: PersistentModelConstructor<T>,
 		items: ModelInstanceMetadata[]
 	): Promise<[T, OpType][]>;
 }

package/src/storage/storage.ts

@@ -26,6 +26,7 @@ import {
 	validatePredicate,
 	valuesEqual,
 } from '../util';
+import { getIdentifierValue } from '../sync/utils';
 import { Adapter } from './adapter';
 import getDefaultAdapter from './adapter/getDefaultAdapter';
 
@@ -188,7 +189,21 @@ class StorageClass implements StorageFacade {
 			condition
 		);
 
-		const modelIds = new Set(models.map(({ id }) => id));
+		const modelConstructor = isModelConstructor(modelOrModelConstructor)
+			? modelOrModelConstructor
+			: (Object.getPrototypeOf(modelOrModelConstructor || {})
+					.constructor as PersistentModelConstructor<T>);
+		const namespaceName = this.namespaceResolver(modelConstructor);
+
+		const modelDefinition =
+			this.schema.namespaces[namespaceName].models[modelConstructor.name];
+
+		const modelIds = new Set(
+			models.map(model => {
+				const modelId = getIdentifierValue(modelDefinition, model);
+				return modelId;
+			})
+		);
 
 		if (
 			!isModelConstructor(modelOrModelConstructor) &&
@@ -204,7 +219,8 @@ class StorageClass implements StorageFacade {
 			let theCondition: PredicatesGroup<any>;
 
 			if (!isModelConstructor(modelOrModelConstructor)) {
-				theCondition = modelIds.has(model.id)
+				const modelId = getIdentifierValue(modelDefinition, model);
+				theCondition = modelIds.has(modelId)
 					? ModelPredicateCreator.getPredicates(condition, false)
 					: undefined;
 			}
@@ -337,30 +353,65 @@ class StorageClass implements StorageFacade {
 
 		// set original values for these fields
 		updatedFields.forEach((field: string) => {
-			const targetName: any = isTargetNameAssociation(
+			const targetNames: any = isTargetNameAssociation(
 				fields[field]?.association
 			);
 
-			// if field refers to a belongsTo relation, use the target field instead
-			const key = targetName || field;
+			if (Array.isArray(targetNames)) {
+				// if field refers to a belongsTo relation, use the target field instead
+
+				for (const targetName of targetNames) {
+					// check field values by value. Ignore unchanged fields
+					if (!valuesEqual(source[targetName], originalElement[targetName])) {
+						// if the field was updated to 'undefined', replace with 'null' for compatibility with JSON and GraphQL
+
+						updatedElement[targetName] =
+							originalElement[targetName] === undefined
+								? null
+								: originalElement[targetName];
+
+						for (const fieldSet of compositeKeys) {
+							// include all of the fields that comprise the composite key
+							if (fieldSet.has(targetName)) {
+								for (const compositeField of fieldSet) {
+									updatedElement[compositeField] =
+										originalElement[compositeField];
+								}
+							}
+						}
+					}
+				}
+			} else {
+				// Backwards compatibility pre-CPK
+
+				// if field refers to a belongsTo relation, use the target field instead
+				const key = targetNames || field;
+
+				// check field values by value. Ignore unchanged fields
+				if (!valuesEqual(source[key], originalElement[key])) {
+					// if the field was updated to 'undefined', replace with 'null' for compatibility with JSON and GraphQL
 
-			// check field values by value. Ignore unchanged fields
-			if (!valuesEqual(source[key], originalElement[key])) {
-				// if the field was updated to 'undefined', replace with 'null' for compatibility with JSON and GraphQL
-				updatedElement[key] =
-					originalElement[key] === undefined ? null : originalElement[key];
+					updatedElement[key] =
+						originalElement[key] === undefined ? null : originalElement[key];
 
-				for (const fieldSet of compositeKeys) {
-					// include all of the fields that comprise the composite key
-					if (fieldSet.has(key)) {
-						for (const compositeField of fieldSet) {
-							updatedElement[compositeField] = originalElement[compositeField];
+					for (const fieldSet of compositeKeys) {
+						// include all of the fields that comprise the composite key
+						if (fieldSet.has(key)) {
+							for (const compositeField of fieldSet) {
+								updatedElement[compositeField] =
+									originalElement[compositeField];
+							}
 						}
 					}
 				}
 			}
 		});
 
+        // Exit early when there are no changes introduced in the update mutation 
+		if (Object.keys(updatedElement).length === 0) {
+			return null;
+		}
+
 		// include field(s) from custom PK if one is specified for the model
 		if (primaryKey && primaryKey.length) {
 			for (const pkField of primaryKey) {
@@ -368,10 +419,6 @@ class StorageClass implements StorageFacade {
 			}
 		}
 
-		if (Object.keys(updatedElement).length === 0) {
-			return null;
-		}
-
 		const { id, _version, _lastChangedAt, _deleted } = originalElement;
 
 		// For update mutations we only want to send fields with changes
@@ -421,7 +468,7 @@ class ExclusiveStorage implements StorageFacade {
 		patchesTuple?: [Patch[], PersistentModel]
 	): Promise<[T, OpType.INSERT | OpType.UPDATE][]> {
 		return this.runExclusive<[T, OpType.INSERT | OpType.UPDATE][]>(storage =>
-			storage.save<T>(model, condition, mutator, patchesTuple)
+			storage.save(model, condition, mutator, patchesTuple)
 		);
 	}
 
@@ -489,7 +536,7 @@ class ExclusiveStorage implements StorageFacade {
 	}
 
 	batchSave<T extends PersistentModel>(
-		modelConstructor: PersistentModelConstructor<any>,
+		modelConstructor: PersistentModelConstructor<T>,
 		items: ModelInstanceMetadata[]
 	): Promise<[T, OpType][]> {
 		return this.storage.batchSave(modelConstructor, items);

package/src/sync/index.ts

@@ -21,6 +21,9 @@ import {
 	TypeConstructorMap,
 	ModelPredicate,
 	AuthModeStrategy,
+	ManagedIdentifier,
+	OptionallyManagedIdentifier,
+	__modelMeta__,
 	AmplifyContext,
 } from '../types';
 import { exhaustiveCheck, getNow, SYNC, USER } from '../util';
@@ -32,6 +35,7 @@ import { CONTROL_MSG, SubscriptionProcessor } from './processors/subscription';
 import { SyncProcessor } from './processors/sync';
 import {
 	createMutationInstanceFromModelOperation,
+	getIdentifierValue,
 	predicateToGraphQLCondition,
 	TransformerMutationType,
 } from './utils';
@@ -46,25 +50,26 @@ type StartParams = {
 };
 
 export declare class MutationEvent {
-	constructor(init: ModelInit<MutationEvent>);
-	static copyOf(
-		src: MutationEvent,
-		mutator: (draft: MutableModel<MutationEvent>) => void | MutationEvent
-	): MutationEvent;
+	readonly [__modelMeta__]: {
+		identifier: OptionallyManagedIdentifier<MutationEvent, 'id'>;
+	};
 	public readonly id: string;
 	public readonly model: string;
 	public readonly operation: TransformerMutationType;
 	public readonly modelId: string;
 	public readonly condition: string;
-	public data: string;
+	public readonly data: string;
+	constructor(init: ModelInit<MutationEvent>);
+	static copyOf(
+		src: MutationEvent,
+		mutator: (draft: MutableModel<MutationEvent>) => void | MutationEvent
+	): MutationEvent;
 }
 
-declare class ModelMetadata {
-	constructor(init: ModelInit<ModelMetadata>);
-	static copyOf(
-		src: ModelMetadata,
-		mutator: (draft: MutableModel<ModelMetadata>) => void | ModelMetadata
-	): ModelMetadata;
+export declare class ModelMetadata {
+	readonly [__modelMeta__]: {
+		identifier: ManagedIdentifier<ModelMetadata, 'id'>;
+	};
 	public readonly id: string;
 	public readonly namespace: string;
 	public readonly model: string;
@@ -72,6 +77,11 @@ declare class ModelMetadata {
 	public readonly lastSync?: number;
 	public readonly lastFullSync?: number;
 	public readonly lastSyncPredicate?: null | string;
+	constructor(init: ModelInit<ModelMetadata>);
+	static copyOf(
+		src: ModelMetadata,
+		mutator: (draft: MutableModel<ModelMetadata>) => void | ModelMetadata
+	): ModelMetadata;
 }
 
 export enum ControlMessage {
@@ -123,7 +133,7 @@ export class SyncEngine {
 	) {
 		const MutationEvent = this.modelClasses[
 			'MutationEvent'
-		] as PersistentModelConstructor<any>;
+		] as PersistentModelConstructor<MutationEvent>;
 
 		this.outbox = new MutationEventOutbox(
 			this.schema,
@@ -296,7 +306,7 @@ export class SyncEngine {
 										);
 
 										this.storage.runExclusive(storage =>
-											this.modelMerger.merge(storage, model)
+											this.modelMerger.merge(storage, model, modelDefinition)
 										);
 
 										observer.next({
@@ -333,7 +343,7 @@ export class SyncEngine {
 											);
 
 											this.storage.runExclusive(storage =>
-												this.modelMerger.merge(storage, model)
+												this.modelMerger.merge(storage, model, modelDefinition)
 											);
 										}
 									)
@@ -362,7 +372,6 @@ export class SyncEngine {
 					.observe(null, null, ownSymbol)
 					.filter(({ model }) => {
 						const modelDefinition = this.getModelDefinition(model);
-
 						return modelDefinition.syncable === true;
 					})
 					.subscribe({
@@ -372,7 +381,11 @@ export class SyncEngine {
 							const MutationEventConstructor = this.modelClasses[
 								'MutationEvent'
 							] as PersistentModelConstructor<MutationEvent>;
-							const graphQLCondition = predicateToGraphQLCondition(condition);
+							const modelDefinition = this.getModelDefinition(model);
+							const graphQLCondition = predicateToGraphQLCondition(
+								condition,
+								modelDefinition
+							);
 							const mutationEvent = createMutationInstanceFromModelOperation(
 								namespace.relationships,
 								this.getModelDefinition(model),
@@ -537,7 +550,9 @@ export class SyncEngine {
 
 										const oneByOne: ModelInstanceMetadata[] = [];
 										const page = items.filter(item => {
-											if (!idsInOutbox.has(item.id)) {
+											const itemId = getIdentifierValue(modelDefinition, item);
+
+											if (!idsInOutbox.has(itemId)) {
 												return true;
 											}
 
@@ -550,7 +565,8 @@ export class SyncEngine {
 										for (const item of oneByOne) {
 											const opType = await this.modelMerger.merge(
 												storage,
-												item
+												item,
+												modelDefinition
 											);
 
 											if (opType !== undefined) {
@@ -562,7 +578,8 @@ export class SyncEngine {
 											...(await this.modelMerger.mergePage(
 												storage,
 												modelConstructor,
-												page
+												page,
+												modelDefinition
 											))
 										);
 
@@ -608,7 +625,7 @@ export class SyncEngine {
 
 										modelMetadata = (
 											this.modelClasses
-												.ModelMetadata as PersistentModelConstructor<any>
+												.ModelMetadata as PersistentModelConstructor<ModelMetadata>
 										).copyOf(modelMetadata, draft => {
 											draft.lastSync = startedAt;
 											draft.lastFullSync = isFullSync
@@ -709,7 +726,7 @@ export class SyncEngine {
 
 	private async setupModels(params: StartParams) {
 		const { fullSyncInterval } = params;
-		const ModelMetadata = this.modelClasses
+		const ModelMetadataConstructor = this.modelClasses
 			.ModelMetadata as PersistentModelConstructor<ModelMetadata>;
 
 		const models: [string, SchemaModel][] = [];
@@ -741,7 +758,7 @@ export class SyncEngine {
 
 			if (modelMetadata === undefined) {
 				[[savedModel]] = await this.storage.save(
-					this.modelInstanceCreator(ModelMetadata, {
+					this.modelInstanceCreator(ModelMetadataConstructor, {
 						model: model.name,
 						namespace,
 						lastSync: null,
@@ -759,9 +776,7 @@ export class SyncEngine {
 				const syncPredicateUpdated = prevSyncPredicate !== lastSyncPredicate;
 
 				[[savedModel]] = await this.storage.save(
-					(
-						this.modelClasses.ModelMetadata as PersistentModelConstructor<any>
-					).copyOf(modelMetadata, draft => {
+					ModelMetadataConstructor.copyOf(modelMetadata, draft => {
 						draft.fullSyncInterval = fullSyncInterval;
 						// perform a base sync if the syncPredicate changed in between calls to DataStore.start
 						// ensures that the local store contains all the data specified by the syncExpression

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 {
@@ -15,10 +17,15 @@ class ModelMerger {
 
 	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 +44,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
@@ -35,6 +36,8 @@ class MutationEventOutbox {
 			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

@@ -27,7 +27,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,
@@ -452,63 +458,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;
-								}
+		let mutationInput;
 
-								// All other connections
-								return false;
-							}
-
-							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,
 		};
 

package/src/sync/processors/subscription.ts

@@ -393,7 +393,6 @@ class SubscriptionProcessor {
 									Observable<{
 										value: GraphQLResult<Record<string, PersistentModel>>;
 									}>
-
 								>(<unknown>this.amplifyContext.API.graphql({ query, variables, ...{ authMode }, authToken, userAgentSuffix }));
 
 								let subscriptionReadyCallback: () => void;

package/src/sync/processors/sync.ts

@@ -85,9 +85,7 @@ class SyncProcessor {
 		return predicateToGraphQLFilter(predicatesGroup);
 	}
 
-	private async retrievePage<
-		T extends ModelInstanceMetadata = ModelInstanceMetadata
-	>(
+	private async retrievePage<T extends ModelInstanceMetadata>(
 		modelDefinition: SchemaModel,
 		lastSync: number,
 		nextToken: string,