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

package/lib-esm/datastore/datastore.js

@@ -11,8 +11,8 @@ import { isPredicatesAll, ModelPredicateCreator, ModelSortPredicateCreator, } fr
 import { ExclusiveStorage as Storage } from '../storage/storage';
 import { ModelRelationship } from '../storage/relationship';
 import { ControlMessage, SyncEngine } from '../sync';
-import { GraphQLScalarType, isGraphQLScalarType, isSchemaModelWithAttributes, AuthModeStrategyType, isNonModelFieldType, isModelFieldType, isIdentifierObject, isFieldAssociation, } from '../types';
-import { DATASTORE, errorMessages, establishRelationAndKeys, isModelConstructor, monotonicUlidFactory, STORAGE, SYNC, USER, isNullOrUndefined, registerNonModelClass, sortCompareFunction, DeferredCallbackResolver, inMemoryPagination, extractPrimaryKeyFieldNames, extractPrimaryKeysAndValues, isIdManaged, isIdOptionallyManaged, mergePatches, } from '../util';
+import { GraphQLScalarType, isGraphQLScalarType, isSchemaModelWithAttributes, AuthModeStrategyType, isNonModelFieldType, isModelFieldType, isIdentifierObject, } from '../types';
+import { DATASTORE, errorMessages, establishRelationAndKeys, isModelConstructor, monotonicUlidFactory, STORAGE, SYNC, USER, isNullOrUndefined, registerNonModelClass, sortCompareFunction, DeferredCallbackResolver, inMemoryPagination, extractPrimaryKeyFieldNames, extractPrimaryKeysAndValues, isIdManaged, isIdOptionallyManaged, mergePatches, getTimestampFields, } from '../util';
 import { recursivePredicateFor, predicateFor, internals, } from '../predicates/next';
 import { getIdentifierValue } from '../sync/utils';
 setAutoFreeze(true);
@@ -23,70 +23,28 @@ var isNode = browserOrNode().isNode;
 var SETTING_SCHEMA_VERSION = 'schemaVersion';
 var schema;
 var modelNamespaceMap = new WeakMap();
-// 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.
+ */
 var modelPatchesMap = new WeakMap();
 var getModelDefinition = function (modelConstructor) {
-    var e_1, _a, e_2, _b;
     var namespace = modelNamespaceMap.get(modelConstructor);
     var definition = namespace
         ? 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) {
-        var indexes = schema.namespaces[namespace].relationships[modelConstructor.name]
-            .indexes;
-        var indexFields = new Set();
-        try {
-            for (var indexes_1 = __values(indexes), indexes_1_1 = indexes_1.next(); !indexes_1_1.done; indexes_1_1 = indexes_1.next()) {
-                var index = indexes_1_1.value;
-                try {
-                    for (var _c = (e_2 = void 0, __values(index[1])), _d = _c.next(); !_d.done; _d = _c.next()) {
-                        var indexField = _d.value;
-                        indexFields.add(indexField);
-                    }
-                }
-                catch (e_2_1) { e_2 = { error: e_2_1 }; }
-                finally {
-                    try {
-                        if (_d && !_d.done && (_b = _c.return)) _b.call(_c);
-                    }
-                    finally { if (e_2) throw e_2.error; }
-                }
-            }
-        }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-        finally {
-            try {
-                if (indexes_1_1 && !indexes_1_1.done && (_a = indexes_1.return)) _a.call(indexes_1);
-            }
-            finally { if (e_1) throw e_1.error; }
-        }
-        definition.fields = __assign(__assign({}, Object.fromEntries(__spread(indexFields.values()).map(function (name) { return [
-            name,
-            {
-                name: name,
-                type: 'ID',
-                isArray: false,
-            },
-        ]; }, []))), definition.fields);
-    }
     return definition;
 };
-var getModelPKFieldName = function (modelConstructor) {
-    var _a, _b, _c;
-    var namespace = modelNamespaceMap.get(modelConstructor);
-    return ((namespace && ((_c = (_b = (_a = schema.namespaces) === null || _a === void 0 ? void 0 : _a[namespace]) === null || _b === void 0 ? void 0 : _b.keys) === null || _c === void 0 ? void 0 : _c[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.
+ */
 var isValidModelConstructor = function (obj) {
-    if (isModelConstructor(obj) && modelNamespaceMap.has(obj)) {
-        return true;
-    }
-    else {
-        return false;
-    }
+    return isModelConstructor(obj) && modelNamespaceMap.has(obj);
 };
 var namespaceResolver = function (modelConstructor) {
     var resolver = modelNamespaceMap.get(modelConstructor);
@@ -95,13 +53,32 @@ var namespaceResolver = function (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.
+ */
 var buildSeedPredicate = function (modelConstructor) {
     if (!modelConstructor)
         throw new Error('Missing modelConstructor');
     var modelSchema = getModelDefinition(modelConstructor);
     if (!modelSchema)
         throw new Error('Missing modelSchema');
-    var pks = getModelPKFieldName(modelConstructor);
+    var pks = extractPrimaryKeyFieldNames(modelSchema);
     if (!pks)
         throw new Error('Could not determine PK');
     return recursivePredicateFor({
@@ -208,12 +185,13 @@ var initSchema = function (userSchema) {
         codegenVersion: userSchema.codegenVersion,
     };
     Object.keys(schema.namespaces).forEach(function (namespace) {
-        var e_3, _a;
+        var e_1, _a;
         var _b = __read(establishRelationAndKeys(schema.namespaces[namespace]), 2), relations = _b[0], keys = _b[1];
         schema.namespaces[namespace].relationships = relations;
         schema.namespaces[namespace].keys = keys;
         var modelAssociations = new Map();
         Object.values(schema.namespaces[namespace].models).forEach(function (model) {
+            var e_2, _a, e_3, _b;
             var connectedModels = [];
             Object.values(model.fields)
                 .filter(function (field) {
@@ -225,20 +203,64 @@ var initSchema = function (userSchema) {
                 return connectedModels.push(field.type.model);
             });
             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(function (field) {
-                if (typeof field.type === 'object' &&
-                    !Object.getOwnPropertyDescriptor(field.type, 'modelConstructor')) {
+                var relatedModel = userClasses[field.type.model];
+                if (isModelConstructor(relatedModel)) {
                     Object.defineProperty(field.type, 'modelConstructor', {
                         get: function () {
+                            var relatedModelDefinition = getModelDefinition(relatedModel);
+                            if (!relatedModelDefinition)
+                                throw new Error("Could not find model definition for " + relatedModel.name);
                             return {
-                                builder: userClasses[field.type.model],
-                                schema: schema.namespaces[namespace].models[field.type.model],
-                                pkField: getModelPKFieldName(userClasses[field.type.model]),
+                                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 };
+            var indexes = schema.namespaces[namespace].relationships[model.name].indexes;
+            var indexFields = new Set();
+            try {
+                for (var indexes_1 = __values(indexes), indexes_1_1 = indexes_1.next(); !indexes_1_1.done; indexes_1_1 = indexes_1.next()) {
+                    var index = indexes_1_1.value;
+                    try {
+                        for (var _c = (e_3 = void 0, __values(index[1])), _d = _c.next(); !_d.done; _d = _c.next()) {
+                            var indexField = _d.value;
+                            indexFields.add(indexField);
+                        }
+                    }
+                    catch (e_3_1) { e_3 = { error: e_3_1 }; }
+                    finally {
+                        try {
+                            if (_d && !_d.done && (_b = _c.return)) _b.call(_c);
+                        }
+                        finally { if (e_3) throw e_3.error; }
+                    }
+                }
+            }
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            finally {
+                try {
+                    if (indexes_1_1 && !indexes_1_1.done && (_a = indexes_1.return)) _a.call(indexes_1);
+                }
+                finally { if (e_2) throw e_2.error; }
+            }
+            model.allFields = __assign(__assign({}, Object.fromEntries(__spread(indexFields.values()).map(function (name) { return [
+                name,
+                {
+                    name: name,
+                    type: 'ID',
+                    isArray: false,
+                },
+            ]; }))), model.fields);
         });
         var result = new Map();
         var count = 1000;
@@ -251,7 +273,7 @@ var initSchema = function (userSchema) {
                 throw new Error('Models are not topologically sortable. Please verify your schema.');
             }
             try {
-                for (var _c = (e_3 = void 0, __values(Array.from(modelAssociations.keys()))), _d = _c.next(); !_d.done; _d = _c.next()) {
+                for (var _c = (e_1 = void 0, __values(Array.from(modelAssociations.keys()))), _d = _c.next(); !_d.done; _d = _c.next()) {
                     var modelName = _d.value;
                     var parents = modelAssociations.get(modelName);
                     if (parents === null || parents === void 0 ? void 0 : parents.every(function (x) { return result.has(x); })) {
@@ -259,12 +281,12 @@ var initSchema = function (userSchema) {
                     }
                 }
             }
-            catch (e_3_1) { e_3 = { error: e_3_1 }; }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
             finally {
                 try {
                     if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
                 }
-                finally { if (e_3) throw e_3.error; }
+                finally { if (e_1) throw e_1.error; }
             }
             Array.from(result.keys()).forEach(function (x) { return modelAssociations.delete(x); });
         }
@@ -307,7 +329,6 @@ var checkSchemaInitialized = function () {
  * @param codegenVersion schema codegenVersion
  */
 var checkSchemaCodegenVersion = function (codegenVersion) {
-    // TODO: set to correct version when released in codegen
     var majorVersion = 3;
     var minorVersion = 2;
     var isValid = false;
@@ -355,7 +376,12 @@ var validateModelFields = function (modelDefinition) { return function (k, v) {
     var fieldDefinition = modelDefinition.fields[k];
     if (fieldDefinition !== undefined) {
         var type_1 = fieldDefinition.type, isRequired_1 = fieldDefinition.isRequired, isArrayNullable = fieldDefinition.isArrayNullable, name_1 = fieldDefinition.name, isArray = fieldDefinition.isArray;
+        var timestamps = isSchemaModelWithAttributes(modelDefinition)
+            ? getTimestampFields(modelDefinition)
+            : {};
+        var isTimestampField = !!timestamps[name_1];
         if (((!isArray && isRequired_1) || (isArray && !isArrayNullable)) &&
+            !isTimestampField &&
             (v === null || v === undefined)) {
             throw new Error("Field " + name_1 + " is required");
         }
@@ -489,6 +515,20 @@ var castInstanceType = function (modelDefinition, k, v) {
     }
     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.
+ */
+var initPatches = new WeakMap();
+/**
+ * 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.
+ */
 var initializeInstance = function (init, modelDefinition, draft) {
     var modelValidator = validateModelFields(modelDefinition);
     Object.entries(init).forEach(function (_a) {
@@ -498,10 +538,51 @@ var initializeInstance = function (init, modelDefinition, draft) {
         draft[k] = parsedValue;
     });
 };
+/**
+ * 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.
+ */
+var normalize = function (modelDefinition, draft) {
+    var e_4, _a;
+    try {
+        for (var _b = __values(Object.keys(modelDefinition.fields)), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var k = _c.value;
+            if (draft[k] === undefined)
+                draft[k] = null;
+        }
+    }
+    catch (e_4_1) { e_4 = { error: e_4_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_4) throw e_4.error; }
+    }
+};
 var createModelClass = function (modelDefinition) {
+    var e_5, _a;
     var clazz = /** @class */ (function () {
         function Model(init) {
-            var instance = produce(this, function (draft) {
+            // 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.
+            var patches = [];
+            var baseInstance = produce(this, function (draft) {
                 initializeInstance(init, modelDefinition, draft);
                 // model is initialized inside a DataStore component (e.g. by Sync Engine, Storage Engine, etc.)
                 var isInternallyInitialized = instancesMetadata.has(init);
@@ -531,8 +612,17 @@ var createModelClass = function (modelDefinition) {
                     draft._lastChangedAt = _lastChangedAt;
                     draft._deleted = _deleted;
                 }
+            }, function (p) { return (patches = p); });
+            // 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.)
+            var normalized = produce(baseInstance, function (draft) {
+                return normalize(modelDefinition, draft);
             });
-            return instance;
+            initPatches.set(normalized, patches);
+            return normalized;
         }
         Model.copyOf = function (source, fn) {
             var modelConstructor = Object.getPrototypeOf(source || {}).constructor;
@@ -558,6 +648,7 @@ var createModelClass = function (modelDefinition) {
                     var parsedValue = castInstanceType(modelDefinition, k, v);
                     modelValidator(k, parsedValue);
                 });
+                normalize(modelDefinition, draft);
             }, function (p) { return (patches = p); });
             var hasExistingPatches = modelPatchesMap.has(source);
             if (patches.length || hasExistingPatches) {
@@ -572,6 +663,15 @@ var createModelClass = function (modelDefinition) {
                     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);
         };
         // "private" method (that's hidden via `Setting`) for `withSSRContext` to use
@@ -593,67 +693,89 @@ var createModelClass = function (modelDefinition) {
     }());
     clazz[immerable] = true;
     Object.defineProperty(clazz, 'name', { value: modelDefinition.name });
-    var _loop_1 = function (field) {
-        if (!isFieldAssociation(modelDefinition, field)) {
-            return "continue";
-        }
-        var _a = modelDefinition.fields[field], type = _a.type, localAssociation = _a.association, _b = _a.association, targetName = _b.targetName, targetNames = _b.targetNames;
-        var 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
+    var allModelRelationships = ModelRelationship.allFrom({
+        builder: clazz,
+        schema: modelDefinition,
+        pkField: extractPrimaryKeyFieldNames(modelDefinition),
+    });
+    var _loop_1 = function (relationship) {
+        var field = relationship.field;
         Object.defineProperty(clazz.prototype, modelDefinition.fields[field].name, {
             set: function (model) {
-                if (!model || !(typeof model === 'object'))
+                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')) {
-                    var modelConstructor = Object.getPrototypeOf(model || {})
-                        .constructor;
-                    if (!isValidModelConstructor(modelConstructor)) {
-                        var msg = "Value passed to " + modelDefinition.name + "." + field + " is not a valid instance of a model";
-                        logger.error(msg, { model: model });
-                        throw new Error(msg);
-                    }
-                    if (modelConstructor.name.toLowerCase() !==
-                        relationship.remoteModelConstructor.name.toLowerCase()) {
-                        var msg = "Value passed to " + modelDefinition.name + "." + field + " is not an instance of " + relationship.remoteModelConstructor.name;
-                        logger.error(msg, { model: model });
-                        throw new Error(msg);
+                // 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')) {
+                        var modelConstructor = Object.getPrototypeOf(model || {})
+                            .constructor;
+                        if (!isValidModelConstructor(modelConstructor)) {
+                            var msg = "Value passed to " + modelDefinition.name + "." + field + " is not a valid instance of a model";
+                            logger.error(msg, { model: model });
+                            throw new Error(msg);
+                        }
+                        if (modelConstructor.name.toLowerCase() !==
+                            relationship.remoteModelConstructor.name.toLowerCase()) {
+                            var msg = "Value passed to " + modelDefinition.name + "." + field + " is not an instance of " + relationship.remoteModelConstructor.name;
+                            logger.error(msg, { model: model });
+                            throw new Error(msg);
+                        }
                     }
                 }
+                // if the relationship can be managed automagically, set the FK's
                 if (relationship.isComplete) {
                     for (var i = 0; i < relationship.localJoinFields.length; i++) {
-                        this[relationship.localJoinFields[i]] =
-                            model[relationship.remoteJoinFields[i]];
+                        this[relationship.localJoinFields[i]] = model === null || model === void 0 ? void 0 : model[relationship.remoteJoinFields[i]];
                     }
                     var instanceMemos = modelInstanceAssociationsMap.has(this)
                         ? modelInstanceAssociationsMap.get(this)
                         : modelInstanceAssociationsMap.set(this, {}).get(this);
-                    instanceMemos[field] = model;
+                    instanceMemos[field] = model || undefined;
                 }
             },
             get: function () {
                 var _this = this;
+                /**
+                 * Bucket for holding related models instances specific to `this` instance.
+                 */
                 var 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.
                         var resultPromise = instance.query(relationship.remoteModelConstructor, function (base) {
                             return base.and(function (q) {
                                 return relationship.remoteJoinFields.map(function (field, index) {
+                                    // TODO: anything we can use instead of `any` here?
                                     return q[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(function (rows) {
                                 if (rows.length > 1) {
                                     // should never happen for a HAS_ONE or BELONGS_TO.
@@ -683,11 +805,24 @@ var createModelClass = function (modelDefinition) {
             },
         });
     };
-    for (var field in modelDefinition.fields) {
-        _loop_1(field);
+    try {
+        for (var allModelRelationships_1 = __values(allModelRelationships), allModelRelationships_1_1 = allModelRelationships_1.next(); !allModelRelationships_1_1.done; allModelRelationships_1_1 = allModelRelationships_1.next()) {
+            var relationship = allModelRelationships_1_1.value;
+            _loop_1(relationship);
+        }
+    }
+    catch (e_5_1) { e_5 = { error: e_5_1 }; }
+    finally {
+        try {
+            if (allModelRelationships_1_1 && !allModelRelationships_1_1.done && (_a = allModelRelationships_1.return)) _a.call(allModelRelationships_1);
+        }
+        finally { if (e_5) throw e_5.error; }
     }
     return clazz;
 };
+/**
+ * An eventually loaded related model instance.
+ */
 var AsyncItem = /** @class */ (function (_super) {
     __extends(AsyncItem, _super);
     function AsyncItem() {
@@ -696,10 +831,26 @@ var AsyncItem = /** @class */ (function (_super) {
     return AsyncItem;
 }(Promise));
 export { AsyncItem };
+/**
+ * A collection of related model instances.
+ *
+ * This collection can be async-iterated or turned directly into an array using `toArray()`.
+ */
 var AsyncCollection = /** @class */ (function () {
     function AsyncCollection(values) {
         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
+     */
     AsyncCollection.prototype[Symbol.asyncIterator] = function () {
         var _this = this;
         var values;
@@ -733,11 +884,19 @@ var AsyncCollection = /** @class */ (function () {
             }); },
         };
     };
+    /**
+     * 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});
+     * ```
+     */
     AsyncCollection.prototype.toArray = function (_a) {
         var _b = (_a === void 0 ? {} : _a).max, max = _b === void 0 ? Number.MAX_SAFE_INTEGER : _b;
-        var e_4, _c;
+        var e_6, _c;
         return __awaiter(this, void 0, void 0, function () {
-            var output, i, _d, _e, element, e_4_1;
+            var output, i, _d, _e, element, e_6_1;
             return __generator(this, function (_f) {
                 switch (_f.label) {
                     case 0:
@@ -763,8 +922,8 @@ var AsyncCollection = /** @class */ (function () {
                     case 4: return [3 /*break*/, 2];
                     case 5: return [3 /*break*/, 12];
                     case 6:
-                        e_4_1 = _f.sent();
-                        e_4 = { error: e_4_1 };
+                        e_6_1 = _f.sent();
+                        e_6 = { error: e_6_1 };
                         return [3 /*break*/, 12];
                     case 7:
                         _f.trys.push([7, , 10, 11]);
@@ -775,7 +934,7 @@ var AsyncCollection = /** @class */ (function () {
                         _f.label = 9;
                     case 9: return [3 /*break*/, 11];
                     case 10:
-                        if (e_4) throw e_4.error;
+                        if (e_6) throw e_6.error;
                         return [7 /*endfinally*/];
                     case 11: return [7 /*endfinally*/];
                     case 12: return [2 /*return*/, output];
@@ -885,8 +1044,8 @@ function checkSchemaVersion(storage, version) {
                             var _a, schemaVersionSetting, storedValue;
                             return __generator(this, function (_b) {
                                 switch (_b.label) {
-                                    case 0: return [4 /*yield*/, s.query(Setting, ModelPredicateCreator.createFromExisting(modelDefinition, function (c) {
-                                            return c.key('eq', SETTING_SCHEMA_VERSION);
+                                    case 0: return [4 /*yield*/, s.query(Setting, ModelPredicateCreator.createFromAST(modelDefinition, {
+                                            and: { key: { eq: SETTING_SCHEMA_VERSION } },
                                         }), { page: 0, limit: 1 })];
                                     case 1:
                                         _a = __read.apply(void 0, [_b.sent(), 1]), schemaVersionSetting = _a[0];
@@ -962,6 +1121,8 @@ var DataStoreState;
     DataStoreState["Stopping"] = "Stopping";
     DataStoreState["Clearing"] = "Clearing";
 })(DataStoreState || (DataStoreState = {}));
+// TODO: How can we get rid of the non-null assertions?
+// https://github.com/aws-amplify/amplify-js/pull/10477/files#r1007363485
 var DataStore = /** @class */ (function () {
     function DataStore() {
         var _this = this;
@@ -1025,8 +1186,8 @@ var DataStore = /** @class */ (function () {
         /**
          * 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.
          */
         this.start = function () { return __awaiter(_this, void 0, void 0, function () {
@@ -1117,11 +1278,12 @@ var DataStore = /** @class */ (function () {
                         .add(function () { return __awaiter(_this, void 0, void 0, function () {
                         var result, msg, modelDefinition, pagination, keyFields, msg, predicate, predicate, seedPredicate, predicate, returnOne;
                         var _a;
-                        return __generator(this, function (_b) {
-                            switch (_b.label) {
+                        var _b;
+                        return __generator(this, function (_c) {
+                            switch (_c.label) {
                                 case 0: return [4 /*yield*/, this.start()];
                                 case 1:
-                                    _b.sent();
+                                    _c.sent();
                                     if (!this.storage) {
                                         throw new Error('No storage to query');
                                     }
@@ -1148,37 +1310,37 @@ var DataStore = /** @class */ (function () {
                                         logger.error(msg, { keyFields: keyFields });
                                         throw new Error(msg);
                                     }
-                                    predicate = ModelPredicateCreator.createForSingleField(modelDefinition, keyFields[0], identifierOrCriteria);
+                                    predicate = ModelPredicateCreator.createFromFlatEqualities(modelDefinition, (_a = {}, _a[keyFields[0]] = identifierOrCriteria, _a));
                                     return [4 /*yield*/, this.storage.query(modelConstructor, predicate, pagination)];
                                 case 2:
-                                    result = _b.sent();
+                                    result = _c.sent();
                                     return [3 /*break*/, 9];
                                 case 3:
                                     if (!isIdentifierObject(identifierOrCriteria, modelDefinition)) return [3 /*break*/, 5];
                                     predicate = ModelPredicateCreator.createForPk(modelDefinition, identifierOrCriteria);
                                     return [4 /*yield*/, this.storage.query(modelConstructor, predicate, pagination)];
                                 case 4:
-                                    result = _b.sent();
+                                    result = _c.sent();
                                     return [3 /*break*/, 9];
                                 case 5:
                                     if (!(!identifierOrCriteria ||
                                         isPredicatesAll(identifierOrCriteria))) return [3 /*break*/, 7];
-                                    return [4 /*yield*/, ((_a = this.storage) === null || _a === void 0 ? void 0 : _a.query(modelConstructor, undefined, pagination))];
+                                    return [4 /*yield*/, ((_b = this.storage) === null || _b === void 0 ? void 0 : _b.query(modelConstructor, undefined, pagination))];
                                 case 6:
-                                    result = _b.sent();
+                                    result = _c.sent();
                                     return [3 /*break*/, 9];
                                 case 7:
                                     seedPredicate = recursivePredicateFor({
                                         builder: modelConstructor,
                                         schema: modelDefinition,
-                                        pkField: getModelPKFieldName(modelConstructor),
+                                        pkField: extractPrimaryKeyFieldNames(modelDefinition),
                                     });
                                     predicate = internals(identifierOrCriteria(seedPredicate));
                                     return [4 /*yield*/, predicate.fetch(this.storage)];
                                 case 8:
-                                    result = (_b.sent());
+                                    result = (_c.sent());
                                     result = inMemoryPagination(result, pagination);
-                                    _b.label = 9;
+                                    _c.label = 9;
                                 case 9:
                                     returnOne = isQueryOne(identifierOrCriteria) ||
                                         isIdentifierObject(identifierOrCriteria, modelDefinition);
@@ -1194,7 +1356,7 @@ var DataStore = /** @class */ (function () {
             return __generator(this, function (_a) {
                 return [2 /*return*/, this.runningProcesses
                         .add(function () { return __awaiter(_this, void 0, void 0, function () {
-                        var patchesTuple, modelConstructor, msg, modelDefinition, modelMeta, producedCondition, _a, savedModel;
+                        var updatedPatchesTuple, initPatchesTuple, patchesTuple, modelConstructor, msg, modelDefinition, modelMeta, producedCondition, _a, savedModel;
                         var _this = this;
                         return __generator(this, function (_b) {
                             switch (_b.label) {
@@ -1204,7 +1366,11 @@ var DataStore = /** @class */ (function () {
                                     if (!this.storage) {
                                         throw new Error('No storage to save to');
                                     }
-                                    patchesTuple = modelPatchesMap.get(model);
+                                    updatedPatchesTuple = modelPatchesMap.get(model);
+                                    initPatchesTuple = initPatches.has(model)
+                                        ? [initPatches.get(model), {}]
+                                        : undefined;
+                                    patchesTuple = updatedPatchesTuple || initPatchesTuple;
                                     modelConstructor = model ? model.constructor : undefined;
                                     if (!isValidModelConstructor(modelConstructor)) {
                                         msg = 'Object is not an instance of a valid model';
@@ -1221,8 +1387,8 @@ var DataStore = /** @class */ (function () {
                                         pkField: extractPrimaryKeyFieldNames(modelDefinition),
                                     };
                                     return [4 /*yield*/, this.storage.runExclusive(function (s) { return __awaiter(_this, void 0, void 0, function () {
-                                            var nonHasManyRelationships, nonHasManyRelationships_1, nonHasManyRelationships_1_1, relationship, queryObject, related, e_5_1;
-                                            var e_5, _a;
+                                            var nonHasManyRelationships, nonHasManyRelationships_1, nonHasManyRelationships_1_1, relationship, queryObject, related, e_7_1;
+                                            var e_7, _a;
                                             var _b;
                                             return __generator(this, function (_c) {
                                                 switch (_c.label) {
@@ -1255,14 +1421,14 @@ var DataStore = /** @class */ (function () {
                                                         return [3 /*break*/, 2];
                                                     case 5: return [3 /*break*/, 8];
                                                     case 6:
-                                                        e_5_1 = _c.sent();
-                                                        e_5 = { error: e_5_1 };
+                                                        e_7_1 = _c.sent();
+                                                        e_7 = { error: e_7_1 };
                                                         return [3 /*break*/, 8];
                                                     case 7:
                                                         try {
                                                             if (nonHasManyRelationships_1_1 && !nonHasManyRelationships_1_1.done && (_a = nonHasManyRelationships_1.return)) _a.call(nonHasManyRelationships_1);
                                                         }
-                                                        finally { if (e_5) throw e_5.error; }
+                                                        finally { if (e_7) throw e_7.error; }
                                                         return [7 /*endfinally*/];
                                                     case 8: return [2 /*return*/];
                                                 }
@@ -1325,11 +1491,12 @@ var DataStore = /** @class */ (function () {
                 return [2 /*return*/, this.runningProcesses
                         .add(function () { return __awaiter(_this, void 0, void 0, function () {
                         var condition, msg, modelConstructor, msg, modelDefinition, keyFields, msg, msg, _a, deleted, model, modelConstructor, msg, modelDefinition, pkPredicate, msg, _b, _c, deleted;
-                        return __generator(this, function (_d) {
-                            switch (_d.label) {
+                        var _d;
+                        return __generator(this, function (_e) {
+                            switch (_e.label) {
                                 case 0: return [4 /*yield*/, this.start()];
                                 case 1:
-                                    _d.sent();
+                                    _e.sent();
                                     if (!this.storage) {
                                         throw new Error('No storage to delete from');
                                     }
@@ -1356,7 +1523,7 @@ var DataStore = /** @class */ (function () {
                                             logger.error(msg, { keyFields: keyFields });
                                             throw new Error(msg);
                                         }
-                                        condition = ModelPredicateCreator.createForSingleField(modelDefinition, keyFields[0], identifierOrCriteria);
+                                        condition = ModelPredicateCreator.createFromFlatEqualities(modelDefinition, (_d = {}, _d[keyFields[0]] = identifierOrCriteria, _d));
                                     }
                                     else {
                                         if (isIdentifierObject(identifierOrCriteria, modelDefinition)) {
@@ -1378,7 +1545,7 @@ var DataStore = /** @class */ (function () {
                                     }
                                     return [4 /*yield*/, this.storage.delete(modelConstructor, condition)];
                                 case 2:
-                                    _a = __read.apply(void 0, [_d.sent(), 1]), deleted = _a[0];
+                                    _a = __read.apply(void 0, [_e.sent(), 1]), deleted = _a[0];
                                     return [2 /*return*/, attached(deleted, ModelAttachment.DataStore)];
                                 case 3:
                                     model = modelOrConstructor;
@@ -1404,14 +1571,14 @@ var DataStore = /** @class */ (function () {
                                             builder: modelConstructor,
                                             schema: modelDefinition,
                                             pkField: extractPrimaryKeyFieldNames(modelDefinition),
-                                        }))).toStoragePredicate(pkPredicate);
+                                        }))).toStoragePredicate();
                                     }
                                     else {
                                         condition = pkPredicate;
                                     }
                                     return [4 /*yield*/, this.storage.delete(model, condition)];
                                 case 4:
-                                    _b = __read.apply(void 0, [_d.sent(), 1]), _c = __read(_b[0], 1), deleted = _c[0];
+                                    _b = __read.apply(void 0, [_e.sent(), 1]), _c = __read(_b[0], 1), deleted = _c[0];
                                     return [2 /*return*/, attached(deleted, ModelAttachment.DataStore)];
                             }
                         });
@@ -1683,9 +1850,6 @@ var DataStore = /** @class */ (function () {
                     var _a, _b;
                     var isSynced = (_b = (_a = _this.sync) === null || _a === void 0 ? void 0 : _a.getModelSyncedStatus(model)) !== null && _b !== void 0 ? _b : false;
                     var itemsArray = __spread(Array.from(items.values()), Array.from(itemsChanged.values()));
-                    if (options === null || options === void 0 ? void 0 : options.sort) {
-                        sortItems(itemsArray);
-                    }
                     items.clear();
                     itemsArray.forEach(function (item) {
                         var itemModelDefinition = getModelDefinition(model);
@@ -1694,8 +1858,14 @@ var DataStore = /** @class */ (function () {
                     });
                     // remove deleted items from the final result set
                     deletedItemIds.forEach(function (idOrPk) { return items.delete(idOrPk); });
+                    var snapshot = Array.from(items.values());
+                    // we sort after we merge the snapshots (items, itemsChanged)
+                    // otherwise, the merge may not
+                    if (options === null || options === void 0 ? void 0 : options.sort) {
+                        sortItems(snapshot);
+                    }
                     return {
-                        items: Array.from(items.values()),
+                        items: snapshot,
                         isSynced: isSynced,
                     };
                 };
@@ -2019,15 +2189,6 @@ var DataStore = /** @class */ (function () {
             });
         });
     };
-    DataStore.prototype.createFromCondition = function (modelDefinition, condition) {
-        try {
-            return ModelPredicateCreator.createFromExisting(modelDefinition, condition);
-        }
-        catch (error) {
-            logger.error('Error creating Sync Predicate');
-            throw error;
-        }
-    };
     DataStore.prototype.unwrapPromise = function (conditionProducer) {
         return __awaiter(this, void 0, void 0, function () {
             var condition, error_1;