@aws-amplify/datastore 4.0.12 → 4.0.13-push-notification-dryrun.43

package/src/datastore/datastore.ts

@@ -98,6 +98,7 @@ import {
 	isIdManaged,
 	isIdOptionallyManaged,
 	mergePatches,
+	getTimestampFields,
 } from '../util';
 import {
 	recursivePredicateFor,
@@ -139,9 +140,13 @@ const modelNamespaceMap = new WeakMap<
 	PersistentModelConstructor<any>,
 	string
 >();
-// stores data for crafting the correct update mutation input for a model
-// Patch[] - array of changed fields and metadata
-// PersistentModel - the source model, used for diffing object-type fields
+
+/**
+ * Stores data for crafting the correct update mutation input for a model.
+ *
+ * - `Patch[]` - array of changed fields and metadata.
+ * - `PersistentModel` - the source model, used for diffing object-type fields.
+ */
 const modelPatchesMap = new WeakMap<
 	PersistentModel,
 	[Patch[], PersistentModel]
@@ -155,60 +160,19 @@ const getModelDefinition = (
 		? schema.namespaces[namespace].models[modelConstructor.name]
 		: undefined;
 
-	// compatibility with legacy/pre-PK codegen for lazy loading to inject
-	// index fields into the model definition.
-	if (definition) {
-		const indexes =
-			schema.namespaces[namespace].relationships![modelConstructor.name]
-				.indexes;
-
-		const indexFields = new Set<string>();
-		for (const index of indexes) {
-			for (const indexField of index[1]) {
-				indexFields.add(indexField);
-			}
-		}
-
-		definition.fields = {
-			...Object.fromEntries(
-				[...indexFields.values()].map(
-					name => [
-						name,
-						{
-							name,
-							type: 'ID',
-							isArray: false,
-						},
-					],
-					[]
-				)
-			),
-			...definition.fields,
-		};
-	}
-
 	return definition;
 };
 
-const getModelPKFieldName = (
-	modelConstructor: PersistentModelConstructor<any>
-) => {
-	const namespace = modelNamespaceMap.get(modelConstructor);
-	return (
-		(namespace &&
-			schema.namespaces?.[namespace]?.keys?.[modelConstructor.name]
-				.primaryKey) || ['id']
-	);
-};
-
+/**
+ * Determines whether the given object is a Model Constructor that DataStore can
+ * safely use to construct objects and discover related metadata.
+ *
+ * @param obj The object to test.
+ */
 const isValidModelConstructor = <T extends PersistentModel>(
 	obj: any
 ): obj is PersistentModelConstructor<T> => {
-	if (isModelConstructor(obj) && modelNamespaceMap.has(obj)) {
-		return true;
-	} else {
-		return false;
-	}
+	return isModelConstructor(obj) && modelNamespaceMap.has(obj);
 };
 
 const namespaceResolver: NamespaceResolver = modelConstructor => {
@@ -221,6 +185,25 @@ const namespaceResolver: NamespaceResolver = modelConstructor => {
 	return resolver;
 };
 
+/**
+ * Creates a predicate without any conditions that can be passed to customer
+ * code to have conditions added to it.
+ *
+ * For example, in this query:
+ *
+ * ```ts
+ * await DataStore.query(
+ * 	Model,
+ * 	item => item.field.eq('value')
+ * );
+ * ```
+ *
+ * `buildSeedPredicate(Model)` is used to create `item`, which is passed to the
+ * predicate function, which in turn uses that "seed" predicate (`item`) to build
+ * a predicate tree.
+ *
+ * @param modelConstructor The model the predicate will query.
+ */
 const buildSeedPredicate = <T extends PersistentModel>(
 	modelConstructor: PersistentModelConstructor<T>
 ) => {
@@ -231,9 +214,7 @@ const buildSeedPredicate = <T extends PersistentModel>(
 	);
 	if (!modelSchema) throw new Error('Missing modelSchema');
 
-	const pks = getModelPKFieldName(
-		modelConstructor as PersistentModelConstructor<T>
-	);
+	const pks = extractPrimaryKeyFieldNames(modelSchema);
 	if (!pks) throw new Error('Could not determine PK');
 
 	return recursivePredicateFor<T>({
@@ -386,32 +367,56 @@ const initSchema = (userSchema: Schema) => {
 
 			modelAssociations.set(model.name, connectedModels);
 
+			// Precompute model info (such as pk fields) so that downstream schema consumers
+			// (such as predicate builders) don't have to reach back into "DataStore" space
+			// to go looking for it.
 			Object.values(model.fields).forEach(field => {
-				if (
-					typeof field.type === 'object' &&
-					!Object.getOwnPropertyDescriptor(
-						<ModelFieldType>field.type,
-						'modelConstructor'
-					)
-				) {
+				const relatedModel = userClasses[(<ModelFieldType>field.type).model];
+				if (isModelConstructor(relatedModel)) {
 					Object.defineProperty(field.type, 'modelConstructor', {
 						get: () => {
+							const relatedModelDefinition = getModelDefinition(relatedModel);
+							if (!relatedModelDefinition)
+								throw new Error(
+									`Could not find model definition for ${relatedModel.name}`
+								);
 							return {
-								builder: userClasses[(<ModelFieldType>field.type).model],
-								schema:
-									schema.namespaces[namespace].models[
-										(<ModelFieldType>field.type).model
-									],
-								pkField: getModelPKFieldName(
-									userClasses[
-										(<ModelFieldType>field.type).model
-									] as PersistentModelConstructor<any>
-								),
+								builder: relatedModel,
+								schema: relatedModelDefinition,
+								pkField: extractPrimaryKeyFieldNames(relatedModelDefinition),
 							};
 						},
 					});
 				}
 			});
+
+			// compatibility with legacy/pre-PK codegen for lazy loading to inject
+			// index fields into the model definition.
+			// definition.cloudFields = { ...definition.fields };
+
+			const indexes =
+				schema.namespaces[namespace].relationships![model.name].indexes;
+
+			const indexFields = new Set<string>();
+			for (const index of indexes) {
+				for (const indexField of index[1]) {
+					indexFields.add(indexField);
+				}
+			}
+
+			model.allFields = {
+				...Object.fromEntries(
+					[...indexFields.values()].map(name => [
+						name,
+						{
+							name,
+							type: 'ID',
+							isArray: false,
+						},
+					])
+				),
+				...model.fields,
+			};
 		});
 
 		const result = new Map<string, string[]>();
@@ -482,7 +487,6 @@ const checkSchemaInitialized = () => {
  * @param codegenVersion schema codegenVersion
  */
 const checkSchemaCodegenVersion = (codegenVersion: string) => {
-	// TODO: set to correct version when released in codegen
 	const majorVersion = 3;
 	const minorVersion = 2;
 	let isValid = false;
@@ -520,7 +524,7 @@ const createTypeClasses: (
 
 	Object.entries(namespace.nonModels || {}).forEach(
 		([typeName, typeDefinition]) => {
-			const clazz = createNonModelClass(typeDefinition) as any;
+			const clazz = createNonModelClass(typeDefinition);
 			classes[typeName] = clazz;
 		}
 	);
@@ -563,8 +567,14 @@ const validateModelFields =
 			const { type, isRequired, isArrayNullable, name, isArray } =
 				fieldDefinition;
 
+			const timestamps = isSchemaModelWithAttributes(modelDefinition)
+				? getTimestampFields(modelDefinition)
+				: {};
+			const isTimestampField = !!timestamps[name];
+
 			if (
 				((!isArray && isRequired) || (isArray && !isArrayNullable)) &&
+				!isTimestampField &&
 				(v === null || v === undefined)
 			) {
 				throw new Error(`Field ${name} is required`);
@@ -741,6 +751,21 @@ const castInstanceType = (
 	return v;
 };
 
+/**
+ * Records the patches (as if against an empty object) used to initialize
+ * an instance of a Model. This can be used for determining which fields to
+ * send to the cloud durnig a CREATE mutation.
+ */
+const initPatches = new WeakMap<PersistentModel, Patch[]>();
+
+/**
+ * Attempts to apply type-aware, casted field values from a given `init`
+ * object to the given `draft`.
+ *
+ * @param init The initialization object to extract field values from.
+ * @param modelDefinition The definition describing the target object shape.
+ * @param draft The draft to apply field values to.
+ */
 const initializeInstance = <T extends PersistentModel>(
 	init: ModelInit<T>,
 	modelDefinition: SchemaModel | SchemaNonModel,
@@ -755,12 +780,44 @@ const initializeInstance = <T extends PersistentModel>(
 	});
 };
 
+/**
+ * Updates a draft to standardize its customer-defined fields so that they are
+ * consistent with the data as it would look after having been synchronized from
+ * Cloud storage.
+ *
+ * The exceptions to this are:
+ *
+ * 1. Non-schema/Internal [sync] metadata fields.
+ * 2. Cloud-managed fields, which are `null` until set by cloud storage.
+ *
+ * This function should be expanded if/when deviations between canonical Cloud
+ * storage data and locally managed data are found. For now, the known areas
+ * that require normalization are:
+ *
+ * 1. Ensuring all non-metadata fields are *defined*. (I.e., turn `undefined` -> `null`.)
+ *
+ * @param modelDefinition Definition for the draft. Used to discover all fields.
+ * @param draft The instance draft to apply normalizations to.
+ */
+const normalize = <T extends PersistentModel>(
+	modelDefinition: SchemaModel | SchemaNonModel,
+	draft: Draft<T>
+) => {
+	for (const k of Object.keys(modelDefinition.fields)) {
+		if (draft[k] === undefined) (<any>draft)[k] = null;
+	}
+};
+
 const createModelClass = <T extends PersistentModel>(
 	modelDefinition: SchemaModel
 ) => {
 	const clazz = <PersistentModelConstructor<T>>(<unknown>class Model {
 		constructor(init: ModelInit<T>) {
-			const instance = produce(
+			// we create a base instance first so we can distinguish which fields were explicitly
+			// set by customer code versus those set by normalization. only those fields
+			// which are explicitly set by customers should be part of create mutations.
+			let patches: Patch[] = [];
+			const baseInstance = produce(
 				this,
 				(draft: Draft<T & ModelInstanceMetadata>) => {
 					initializeInstance(init, modelDefinition, draft);
@@ -804,10 +861,24 @@ const createModelClass = <T extends PersistentModel>(
 						draft._lastChangedAt = _lastChangedAt;
 						draft._deleted = _deleted;
 					}
-				}
+				},
+				p => (patches = p)
 			);
 
-			return instance;
+			// now that we have a list of patches that encapsulate the explicit, customer-provided
+			// fields, we can normalize. patches from normalization are ignored, because the changes
+			// are only create to provide a consistent view of the data for fields pre/post sync
+			// where possible. (not all fields can be normalized pre-sync, because they're generally
+			// "cloud managed" fields, like createdAt and updatedAt.)
+			const normalized = produce(
+				baseInstance,
+				(draft: Draft<T & ModelInstanceMetadata>) =>
+					normalize(modelDefinition, draft)
+			);
+
+			initPatches.set(normalized, patches);
+
+			return normalized;
 		}
 
 		static copyOf(source: T, fn: (draft: MutableModel<T>) => T) {
@@ -842,6 +913,8 @@ const createModelClass = <T extends PersistentModel>(
 
 						modelValidator(k, parsedValue);
 					});
+
+					normalize(modelDefinition, draft);
 				},
 				p => (patches = p)
 			);
@@ -863,6 +936,14 @@ const createModelClass = <T extends PersistentModel>(
 					modelPatchesMap.set(model, [patches, source]);
 					checkReadOnlyPropertyOnUpdate(patches, modelDefinition);
 				}
+			} else {
+				// always register patches when performing a copyOf, even if the
+				// patches list is empty. this allows `save()` to recognize when an
+				// instance is the result of a `copyOf()`. without more significant
+				// refactoring, this is the only way for `save()` to know which
+				// diffs (patches) are relevant for `storage` to use in building
+				// the list of "changed" fields for mutations.
+				modelPatchesMap.set(model, [[], source]);
 			}
 
 			return attached(model, ModelAttachment.DataStore);
@@ -891,88 +972,103 @@ const createModelClass = <T extends PersistentModel>(
 
 	Object.defineProperty(clazz, 'name', { value: modelDefinition.name });
 
-	for (const field in modelDefinition.fields) {
-		if (!isFieldAssociation(modelDefinition, field)) {
-			continue;
-		}
-
-		const {
-			type,
-			association: localAssociation,
-			association: { targetName, targetNames },
-		} = modelDefinition.fields[field] as Required<ModelField>;
-
-		const relationship = new ModelRelationship(
-			{
-				builder: clazz,
-				schema: modelDefinition,
-				pkField: extractPrimaryKeyFieldNames(modelDefinition),
-			},
-			field
-		);
+	// Add getters/setters for relationship fields.
+	//  getter - for lazy loading
+	//  setter - for FK management
+	const allModelRelationships = ModelRelationship.allFrom({
+		builder: clazz,
+		schema: modelDefinition,
+		pkField: extractPrimaryKeyFieldNames(modelDefinition),
+	});
+	for (const relationship of allModelRelationships) {
+		const field = relationship.field;
 
 		Object.defineProperty(clazz.prototype, modelDefinition.fields[field].name, {
-			set(model: PersistentModel) {
-				if (!model || !(typeof model === 'object')) return;
+			set(model: T | undefined | null) {
+				if (!(typeof model === 'object' || typeof model === 'undefined'))
+					return;
 
-				// Avoid validation error when processing AppSync response with nested
-				// selection set. Nested entitites lack version field and can not be validated
-				// TODO: explore a more reliable method to solve this
-				if (model.hasOwnProperty('_version')) {
-					const modelConstructor = Object.getPrototypeOf(model || {})
-						.constructor as PersistentModelConstructor<T>;
+				// if model is undefined or null, the connection should be removed
+				if (model) {
+					// Avoid validation error when processing AppSync response with nested
+					// selection set. Nested entitites lack version field and can not be validated
+					// TODO: explore a more reliable method to solve this
+					if (model.hasOwnProperty('_version')) {
+						const modelConstructor = Object.getPrototypeOf(model || {})
+							.constructor as PersistentModelConstructor<T>;
 
-					if (!isValidModelConstructor(modelConstructor)) {
-						const msg = `Value passed to ${modelDefinition.name}.${field} is not a valid instance of a model`;
-						logger.error(msg, { model });
+						if (!isValidModelConstructor(modelConstructor)) {
+							const msg = `Value passed to ${modelDefinition.name}.${field} is not a valid instance of a model`;
+							logger.error(msg, { model });
 
-						throw new Error(msg);
-					}
+							throw new Error(msg);
+						}
 
-					if (
-						modelConstructor.name.toLowerCase() !==
-						relationship.remoteModelConstructor.name.toLowerCase()
-					) {
-						const msg = `Value passed to ${modelDefinition.name}.${field} is not an instance of ${relationship.remoteModelConstructor.name}`;
-						logger.error(msg, { model });
+						if (
+							modelConstructor.name.toLowerCase() !==
+							relationship.remoteModelConstructor.name.toLowerCase()
+						) {
+							const msg = `Value passed to ${modelDefinition.name}.${field} is not an instance of ${relationship.remoteModelConstructor.name}`;
+							logger.error(msg, { model });
 
-						throw new Error(msg);
+							throw new Error(msg);
+						}
 					}
 				}
 
+				// if the relationship can be managed automagically, set the FK's
 				if (relationship.isComplete) {
 					for (let i = 0; i < relationship.localJoinFields.length; i++) {
 						this[relationship.localJoinFields[i]] =
-							model[relationship.remoteJoinFields[i]];
+							model?.[relationship.remoteJoinFields[i]];
 					}
 					const instanceMemos = modelInstanceAssociationsMap.has(this)
 						? modelInstanceAssociationsMap.get(this)!
 						: modelInstanceAssociationsMap.set(this, {}).get(this)!;
-					instanceMemos[field] = model;
+					instanceMemos[field] = model || undefined;
 				}
 			},
 			get() {
+				/**
+				 * Bucket for holding related models instances specific to `this` instance.
+				 */
 				const instanceMemos = modelInstanceAssociationsMap.has(this)
 					? modelInstanceAssociationsMap.get(this)!
 					: modelInstanceAssociationsMap.set(this, {}).get(this)!;
 
+				// if the memos already has a result for this field, we'll use it.
+				// there is no "cache" invalidation of any kind; memos are permanent to
+				// keep an immutable perception of the instance.
 				if (!instanceMemos.hasOwnProperty(field)) {
+					// before we populate the memo, we need to know where to look for relatives.
+					// today, this only supports DataStore. Models aren't managed elsewhere in Amplify.
 					if (getAttachment(this) === ModelAttachment.DataStore) {
+						// when we fetch the results using a query constructed under the guidance
+						// of the relationship metadata, we DO NOT AWAIT resolution. we want to
+						// drop the promise into the memo's synchronously, eliminating the chance
+						// for a race.
 						const resultPromise = instance.query(
 							relationship.remoteModelConstructor as PersistentModelConstructor<T>,
 							base =>
 								base.and(q => {
 									return relationship.remoteJoinFields.map((field, index) => {
-										return (q[field] as any).eq(
+										// TODO: anything we can use instead of `any` here?
+										return (q[field] as T[typeof field]).eq(
 											this[relationship.localJoinFields[index]]
 										);
 									});
 								})
 						);
 
+						// results in hand, how we return them to the caller depends on the relationship type.
 						if (relationship.type === 'HAS_MANY') {
+							// collections should support async iteration, even though we don't
+							// leverage it fully [yet].
 							instanceMemos[field] = new AsyncCollection(resultPromise);
 						} else {
+							// non-collections should only ever return 1 value *or nothing*.
+							// if we have more than 1 record, something's amiss. it's not our job
+							// pick a result for the customer. it's our job to say "something's wrong."
 							instanceMemos[field] = resultPromise.then(rows => {
 								if (rows.length > 1) {
 									// should never happen for a HAS_ONE or BELONGS_TO.
@@ -1006,8 +1102,16 @@ const createModelClass = <T extends PersistentModel>(
 	return clazz;
 };
 
+/**
+ * An eventually loaded related model instance.
+ */
 export class AsyncItem<T> extends Promise<T> {}
 
+/**
+ * A collection of related model instances.
+ *
+ * This collection can be async-iterated or turned directly into an array using `toArray()`.
+ */
 export class AsyncCollection<T> implements AsyncIterable<T> {
 	private values: Array<any> | Promise<Array<any>>;
 
@@ -1015,6 +1119,17 @@ export class AsyncCollection<T> implements AsyncIterable<T> {
 		this.values = values;
 	}
 
+	/**
+	 * Facilitates async iteration.
+	 *
+	 * ```ts
+	 * for await (const item of collection) {
+	 *   handle(item)
+	 * }
+	 * ```
+	 *
+	 * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/for-await...of
+	 */
 	[Symbol.asyncIterator](): AsyncIterator<T> {
 		let values;
 		let index = 0;
@@ -1037,6 +1152,14 @@ export class AsyncCollection<T> implements AsyncIterable<T> {
 		};
 	}
 
+	/**
+	 * Turns the collection into an array, up to the amount specified in `max` param.
+	 *
+	 * ```ts
+	 * const all = await collection.toArray();
+	 * const first100 = await collection.toArray({max: 100});
+	 * ```
+	 */
 	async toArray({
 		max = Number.MAX_SAFE_INTEGER,
 	}: { max?: number } = {}): Promise<T[]> {
@@ -1180,9 +1303,9 @@ async function checkSchemaVersion(
 	await storage.runExclusive(async s => {
 		const [schemaVersionSetting] = await s.query(
 			Setting,
-			ModelPredicateCreator.createFromExisting(modelDefinition, c =>
-				c.key('eq', SETTING_SCHEMA_VERSION)
-			),
+			ModelPredicateCreator.createFromAST(modelDefinition, {
+				and: { key: { eq: SETTING_SCHEMA_VERSION } },
+			}),
 			{ page: 0, limit: 1 }
 		);
 
@@ -1254,6 +1377,8 @@ enum DataStoreState {
 	Clearing = 'Clearing',
 }
 
+// TODO: How can we get rid of the non-null assertions?
+// https://github.com/aws-amplify/amplify-js/pull/10477/files#r1007363485
 class DataStore {
 	// reference to configured category instances. Used for preserving SSR context
 	private Auth = Auth;
@@ -1281,7 +1406,7 @@ class DataStore {
 	private sync?: SyncEngine;
 	private syncPageSize!: number;
 	private syncExpressions!: SyncExpression[];
-	private syncPredicates: WeakMap<SchemaModel, ModelPredicate<any>> =
+	private syncPredicates: WeakMap<SchemaModel, ModelPredicate<any> | null> =
 		new WeakMap<SchemaModel, ModelPredicate<any>>();
 	private sessionId?: string;
 	private storageAdapter!: Adapter;
@@ -1373,8 +1498,8 @@ class DataStore {
 	/**
 	 * If not already done:
 	 * 1. Attaches and initializes storage.
-	 * 1. Loads the schema and records metadata.
-	 * 1. If `this.amplifyConfig.aws_appsync_graphqlEndpoint` contains a URL,
+	 * 2. Loads the schema and records metadata.
+	 * 3. If `this.amplifyConfig.aws_appsync_graphqlEndpoint` contains a URL,
 	 * attaches a sync engine, starts it, and subscribes.
 	 */
 	start = async (): Promise<void> => {
@@ -1542,10 +1667,9 @@ class DataStore {
 						throw new Error(msg);
 					}
 
-					const predicate = ModelPredicateCreator.createForSingleField<T>(
+					const predicate = ModelPredicateCreator.createFromFlatEqualities<T>(
 						modelDefinition,
-						keyFields[0],
-						identifierOrCriteria
+						{ [keyFields[0]]: identifierOrCriteria }
 					);
 
 					result = await this.storage.query<T>(
@@ -1578,7 +1702,7 @@ class DataStore {
 						const seedPredicate = recursivePredicateFor<T>({
 							builder: modelConstructor,
 							schema: modelDefinition,
-							pkField: getModelPKFieldName(modelConstructor),
+							pkField: extractPrimaryKeyFieldNames(modelDefinition),
 						});
 						const predicate = internals(
 							(identifierOrCriteria as RecursiveModelPredicateExtender<T>)(
@@ -1618,7 +1742,24 @@ class DataStore {
 
 				// Immer patches for constructing a correct update mutation input
 				// Allows us to only include changed fields for updates
-				const patchesTuple = modelPatchesMap.get(model);
+				const updatedPatchesTuple = modelPatchesMap.get(model);
+
+				// Immer patches for initial object construction. These are used if
+				// there are no `update` patches under the assumption we're performing
+				// a CREATE and wish to send only explicitly specified fields to the cloud.
+				const initPatchesTuple = initPatches.has(model)
+					? ([initPatches.get(model)!, {}] as [
+							Patch[],
+							Readonly<Record<string, any>>
+					  ])
+					: undefined;
+
+				// favor update patches over init/create patches, because init patches
+				// are ALWAYS present, whereas update patches are only present if copyOf
+				// was used to create the instance.
+				const patchesTuple:
+					| [Patch[], Readonly<Record<string, any>>]
+					| undefined = updatedPatchesTuple || initPatchesTuple;
 
 				const modelConstructor: PersistentModelConstructor<T> | undefined =
 					model ? <PersistentModelConstructor<T>>model.constructor : undefined;
@@ -1798,10 +1939,9 @@ class DataStore {
 							throw new Error(msg);
 						}
 
-						condition = ModelPredicateCreator.createForSingleField<T>(
+						condition = ModelPredicateCreator.createFromFlatEqualities<T>(
 							modelDefinition,
-							keyFields[0],
-							identifierOrCriteria
+							{ [keyFields[0]]: identifierOrCriteria }
 						);
 					} else {
 						if (isIdentifierObject(identifierOrCriteria, modelDefinition)) {
@@ -1880,7 +2020,7 @@ class DataStore {
 									pkField: extractPrimaryKeyFieldNames(modelDefinition),
 								})
 							)
-						).toStoragePredicate<T>(pkPredicate);
+						).toStoragePredicate<T>();
 					} else {
 						condition = pkPredicate;
 					}
@@ -1980,7 +2120,7 @@ class DataStore {
 		} else if (modelConstructor && typeof identifierOrCriteria === 'function') {
 			executivePredicate = internals(
 				(identifierOrCriteria as RecursiveModelPredicateExtender<T>)(
-					buildSeedPredicate(modelConstructor) as any
+					buildSeedPredicate(modelConstructor)
 				)
 			);
 		}
@@ -2206,10 +2346,6 @@ class DataStore {
 					...Array.from(itemsChanged.values()),
 				];
 
-				if (options?.sort) {
-					sortItems(itemsArray);
-				}
-
 				items.clear();
 				itemsArray.forEach(item => {
 					const itemModelDefinition = getModelDefinition(model);
@@ -2220,8 +2356,16 @@ class DataStore {
 				// remove deleted items from the final result set
 				deletedItemIds.forEach(idOrPk => items.delete(idOrPk));
 
+				const snapshot = Array.from(items.values());
+
+				// we sort after we merge the snapshots (items, itemsChanged)
+				// otherwise, the merge may not
+				if (options?.sort) {
+					sortItems(snapshot);
+				}
+
 				return {
-					items: Array.from(items.values()),
+					items: snapshot,
 					isSynced,
 				};
 			};
@@ -2509,7 +2653,7 @@ class DataStore {
 	 * SchemaModel -> predicate to use during sync.
 	 */
 	private async processSyncExpressions(): Promise<
-		WeakMap<SchemaModel, ModelPredicate<any>>
+		WeakMap<SchemaModel, ModelPredicate<any> | null>
 	> {
 		if (!this.syncExpressions || !this.syncExpressions.length) {
 			return new WeakMap<SchemaModel, ModelPredicate<any>>();
@@ -2519,7 +2663,7 @@ class DataStore {
 			this.syncExpressions.map(
 				async (
 					syncExpression: SyncExpression
-				): Promise<[SchemaModel, ModelPredicate<any>]> => {
+				): Promise<[SchemaModel, ModelPredicate<any> | null]> => {
 					const { modelConstructor, conditionProducer } = await syncExpression;
 					const modelDefinition = getModelDefinition(modelConstructor)!;
 
@@ -2527,7 +2671,7 @@ class DataStore {
 					// OR a function/promise that returns a predicate
 					const condition = await this.unwrapPromise(conditionProducer);
 					if (isPredicatesAll(condition)) {
-						return [modelDefinition as any, null as any];
+						return [modelDefinition, null];
 					}
 
 					const predicate = internals(
@@ -2540,7 +2684,7 @@ class DataStore {
 						)
 					).toStoragePredicate<any>();
 
-					return [modelDefinition as any, predicate as any];
+					return [modelDefinition, predicate];
 				}
 			)
 		);
@@ -2548,21 +2692,6 @@ class DataStore {
 		return this.weakMapFromEntries(syncPredicates);
 	}
 
-	private createFromCondition(
-		modelDefinition: SchemaModel,
-		condition: ProducerModelPredicate<PersistentModel>
-	) {
-		try {
-			return ModelPredicateCreator.createFromExisting(
-				modelDefinition,
-				condition
-			);
-		} catch (error) {
-			logger.error('Error creating Sync Predicate');
-			throw error;
-		}
-	}
-
 	private async unwrapPromise<T extends PersistentModel>(
 		conditionProducer
 	): Promise<ModelPredicateExtender<T>> {
@@ -2578,7 +2707,7 @@ class DataStore {
 	}
 
 	private weakMapFromEntries(
-		entries: [SchemaModel, ModelPredicate<any>][]
+		entries: [SchemaModel, ModelPredicate<any> | null][]
 	): WeakMap<SchemaModel, ModelPredicate<any>> {
 		return entries.reduce((map, [modelDefinition, predicate]) => {
 			if (map.has(modelDefinition)) {