@aws-amplify/datastore 3.7.3 → 3.7.4-custom-pk.86

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

@@ -16,8 +16,10 @@ import {
 	PredicatesGroup,
 	QueryOne,
 	SchemaNamespace,
+	InternalSubscriptionMessage,
 	SubscriptionMessage,
 	isTargetNameAssociation,
+	// isTargetNamesAssociation,
 } from '../types';
 import {
 	isModelConstructor,
@@ -25,11 +27,12 @@ import {
 	validatePredicate,
 	valuesEqual,
 } from '../util';
+import { getIdentifierValue } from '../sync/utils';
 import { Adapter } from './adapter';
 import getDefaultAdapter from './adapter/getDefaultAdapter';
 
 export type StorageSubscriptionMessage<T extends PersistentModel> =
-	SubscriptionMessage<T> & {
+	InternalSubscriptionMessage<T> & {
 		mutator?: Symbol;
 	};
 
@@ -111,7 +114,7 @@ class StorageClass implements StorageFacade {
 		const result = await this.adapter.save(model, condition);
 
 		result.forEach(r => {
-			const [originalElement, opType] = r;
+			const [savedElement, opType] = r;
 
 			// truthy when save is called by the Merger
 			const syncResponse = !!mutator;
@@ -120,9 +123,21 @@ class StorageClass implements StorageFacade {
 			// don't attempt to calc mutation input when storage.save
 			// is called by Merger, i.e., when processing an AppSync response
 			if (opType === OpType.UPDATE && !syncResponse) {
+				//
+				// TODO: LOOK!!!
+				// the `model` used here is in effect regardless of what model
+				// comes back from adapter.save().
+				// Prior to fix, SQLite adapter had been returning two models
+				// of different types, resulting in invalid outbox entries.
+				//
+				// the bug is essentially fixed in SQLite adapter.
+				// leaving as-is, because it's currently unclear whether anything
+				// depends on this remaining as-is.
+				//
+
 				updateMutationInput = this.getUpdateMutationInput(
 					model,
-					originalElement,
+					savedElement,
 					patchesTuple
 				);
 				// // an update without changed user fields
@@ -132,11 +147,10 @@ class StorageClass implements StorageFacade {
 				}
 			}
 
-			const element = updateMutationInput || originalElement;
+			const element = updateMutationInput || savedElement;
 
-			const modelConstructor = (
-				Object.getPrototypeOf(originalElement) as Object
-			).constructor as PersistentModelConstructor<T>;
+			const modelConstructor = (Object.getPrototypeOf(savedElement) as Object)
+				.constructor as PersistentModelConstructor<T>;
 
 			this.pushStream.next({
 				model: modelConstructor,
@@ -144,6 +158,7 @@ class StorageClass implements StorageFacade {
 				element,
 				mutator,
 				condition: ModelPredicateCreator.getPredicates(condition, false),
+				savedElement,
 			});
 		});
 
@@ -175,7 +190,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) &&
@@ -191,7 +220,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;
 			}
@@ -324,24 +354,55 @@ class StorageClass implements StorageFacade {
 
 		// set original values for these fields
 		updatedFields.forEach((field: string) => {
-			const targetName: any = isTargetNameAssociation(
+			// CPK TODO: rename:
+			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
-				updatedElement[key] =
-					originalElement[key] === undefined ? null : originalElement[key];
+				// 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
 
-				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];
+					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];
+							}
 						}
 					}
 				}
@@ -408,7 +469,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)
 		);
 	}
 
@@ -476,7 +537,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,10 @@ import {
 	TypeConstructorMap,
 	ModelPredicate,
 	AuthModeStrategy,
+	ManagedIdentifier,
+	OptionallyManagedIdentifier,
+	__modelMeta__,
+	AmplifyContext,
 } from '../types';
 import { exhaustiveCheck, getNow, SYNC, USER } from '../util';
 import DataStoreConnectivity from './datastoreConnectivity';
@@ -31,6 +35,7 @@ import { CONTROL_MSG, SubscriptionProcessor } from './processors/subscription';
 import { SyncProcessor } from './processors/sync';
 import {
 	createMutationInstanceFromModelOperation,
+	getIdentifierValue,
 	predicateToGraphQLCondition,
 	TransformerMutationType,
 } from './utils';
@@ -45,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;
@@ -71,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 {
@@ -113,17 +124,16 @@ export class SyncEngine {
 		private readonly userModelClasses: TypeConstructorMap,
 		private readonly storage: Storage,
 		private readonly modelInstanceCreator: ModelInstanceCreator,
-		private readonly maxRecordsToSync: number,
-		private readonly syncPageSize: number,
 		conflictHandler: ConflictHandler,
 		errorHandler: ErrorHandler,
 		private readonly syncPredicates: WeakMap<SchemaModel, ModelPredicate<any>>,
 		private readonly amplifyConfig: Record<string, any> = {},
-		private readonly authModeStrategy: AuthModeStrategy
+		private readonly authModeStrategy: AuthModeStrategy,
+		private readonly amplifyContext: AmplifyContext
 	) {
 		const MutationEvent = this.modelClasses[
 			'MutationEvent'
-		] as PersistentModelConstructor<any>;
+		] as PersistentModelConstructor<MutationEvent>;
 
 		this.outbox = new MutationEventOutbox(
 			this.schema,
@@ -138,14 +148,20 @@ export class SyncEngine {
 			this.schema,
 			this.syncPredicates,
 			this.amplifyConfig,
-			this.authModeStrategy
+			this.authModeStrategy,
+			errorHandler,
+			this.amplifyContext
 		);
+
 		this.subscriptionsProcessor = new SubscriptionProcessor(
 			this.schema,
 			this.syncPredicates,
 			this.amplifyConfig,
-			this.authModeStrategy
+			this.authModeStrategy,
+			errorHandler,
+			this.amplifyContext
 		);
+
 		this.mutationsProcessor = new MutationProcessor(
 			this.schema,
 			this.storage,
@@ -155,9 +171,11 @@ export class SyncEngine {
 			MutationEvent,
 			this.amplifyConfig,
 			this.authModeStrategy,
+			errorHandler,
 			conflictHandler,
-			errorHandler
+			this.amplifyContext
 		);
+
 		this.datastoreConnectivity = new DataStoreConnectivity();
 	}
 
@@ -189,11 +207,9 @@ export class SyncEngine {
 							});
 
 							let ctlSubsObservable: Observable<CONTROL_MSG>;
-							let dataSubsObservable: Observable<[
-								TransformerMutationType,
-								SchemaModel,
-								PersistentModel
-							]>;
+							let dataSubsObservable: Observable<
+								[TransformerMutationType, SchemaModel, PersistentModel]
+							>;
 
 							if (isNode) {
 								logger.warn(
@@ -244,8 +260,8 @@ export class SyncEngine {
 							//#region Base & Sync queries
 							try {
 								await new Promise((resolve, reject) => {
-									const syncQuerySubscription = this.syncQueriesObservable().subscribe(
-										{
+									const syncQuerySubscription =
+										this.syncQueriesObservable().subscribe({
 											next: message => {
 												const { type } = message;
 
@@ -263,8 +279,7 @@ export class SyncEngine {
 											error: error => {
 												reject(error);
 											},
-										}
-									);
+										});
 
 									if (syncQuerySubscription) {
 										subscriptions.push(syncQuerySubscription);
@@ -291,12 +306,11 @@ export class SyncEngine {
 										);
 
 										this.storage.runExclusive(storage =>
-											this.modelMerger.merge(storage, model)
+											this.modelMerger.merge(storage, model, modelDefinition)
 										);
 
 										observer.next({
-											type:
-												ControlMessage.SYNC_ENGINE_OUTBOX_MUTATION_PROCESSED,
+											type: ControlMessage.SYNC_ENGINE_OUTBOX_MUTATION_PROCESSED,
 											data: {
 												model: modelConstructor,
 												element: model,
@@ -329,7 +343,7 @@ export class SyncEngine {
 											);
 
 											this.storage.runExclusive(storage =>
-												this.modelMerger.merge(storage, model)
+												this.modelMerger.merge(storage, model, modelDefinition)
 											);
 										}
 									)
@@ -358,18 +372,20 @@ export class SyncEngine {
 					.observe(null, null, ownSymbol)
 					.filter(({ model }) => {
 						const modelDefinition = this.getModelDefinition(model);
-
 						return modelDefinition.syncable === true;
 					})
 					.subscribe({
 						next: async ({ opType, model, element, condition }) => {
-							const namespace = this.schema.namespaces[
-								this.namespaceResolver(model)
-							];
+							const namespace =
+								this.schema.namespaces[this.namespaceResolver(model)];
 							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),
@@ -534,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;
 											}
 
@@ -547,7 +565,8 @@ export class SyncEngine {
 										for (const item of oneByOne) {
 											const opType = await this.modelMerger.merge(
 												storage,
-												item
+												item,
+												modelDefinition
 											);
 
 											if (opType !== undefined) {
@@ -559,7 +578,8 @@ export class SyncEngine {
 											...(await this.modelMerger.mergePage(
 												storage,
 												modelConstructor,
-												page
+												page,
+												modelDefinition
 											))
 										);
 
@@ -603,16 +623,15 @@ export class SyncEngine {
 														isFullSync ? startedAt : lastFullSync
 												  );
 
-										modelMetadata = (this.modelClasses
-											.ModelMetadata as PersistentModelConstructor<any>).copyOf(
-											modelMetadata,
-											draft => {
-												draft.lastSync = startedAt;
-												draft.lastFullSync = isFullSync
-													? startedAt
-													: modelMetadata.lastFullSync;
-											}
-										);
+										modelMetadata = (
+											this.modelClasses
+												.ModelMetadata as PersistentModelConstructor<ModelMetadata>
+										).copyOf(modelMetadata, draft => {
+											draft.lastSync = startedAt;
+											draft.lastFullSync = isFullSync
+												? startedAt
+												: modelMetadata.lastFullSync;
+										});
 
 										await this.storage.save(
 											modelMetadata,
@@ -707,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][] = [];
@@ -739,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,
@@ -757,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
@@ -819,9 +836,8 @@ export class SyncEngine {
 	): SchemaModel {
 		const namespaceName = this.namespaceResolver(modelConstructor);
 
-		const modelDefinition = this.schema.namespaces[namespaceName].models[
-			modelConstructor.name
-		];
+		const modelDefinition =
+			this.schema.namespaces[namespaceName].models[modelConstructor.name];
 
 		return modelDefinition;
 	}

package/src/sync/merger.ts

@@ -3,8 +3,12 @@ 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 {
 	constructor(
 		private readonly outbox: MutationEventOutbox,
@@ -13,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;
 
@@ -35,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,11 +11,13 @@ 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
 class MutationEventOutbox {
 	private inProgressMutationEventId: string;
 
@@ -34,6 +36,8 @@ class MutationEventOutbox {
 			const mutationEventModelDefinition =
 				this.schema.namespaces[SYNC].models['MutationEvent'];
 
+			// `id` is the id of the record in the mutationEvent
+			// `modelId` is the id of the actual record that was mutated
 			const predicate = ModelPredicateCreator.createFromExisting<MutationEvent>(
 				mutationEventModelDefinition,
 				c =>
@@ -42,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) {
@@ -121,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)
 			)
 		);
 
@@ -186,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(
@@ -223,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,
@@ -235,7 +250,6 @@ class MutationEventOutbox {
 		} = JSON.parse(current.data);
 
 		const data = JSON.stringify({
-			id,
 			_version,
 			_lastChangedAt,
 			_deleted,