@aws-amplify/datastore 3.14.4 → 3.14.5-unstable.2

package/lib/datastore/datastore.js

@@ -1,116 +1,27 @@
 "use strict";
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (_) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
-var __read = (this && this.__read) || function (o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-};
-var __values = (this && this.__values) || function(o) {
-    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
-    if (m) return m.call(o);
-    if (o && typeof o.length === "number") return {
-        next: function () {
-            if (o && i >= o.length) o = void 0;
-            return { value: o && o[i++], done: !o };
-        }
-    };
-    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
-};
-var __spread = (this && this.__spread) || function () {
-    for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));
-    return ar;
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-var api_1 = __importDefault(require("@aws-amplify/api"));
+var tslib_1 = require("tslib");
+var api_1 = require("@aws-amplify/api");
 var auth_1 = require("@aws-amplify/auth");
-var cache_1 = __importDefault(require("@aws-amplify/cache"));
+var cache_1 = require("@aws-amplify/cache");
 var core_1 = require("@aws-amplify/core");
 var immer_1 = require("immer");
 var uuid_1 = require("uuid");
-var zen_observable_ts_1 = __importDefault(require("zen-observable-ts"));
+var zen_observable_ts_1 = tslib_1.__importDefault(require("zen-observable-ts"));
 var authModeStrategies_1 = require("../authModeStrategies");
 var predicates_1 = require("../predicates");
 var storage_1 = require("../storage/storage");
+var relationship_1 = require("../storage/relationship");
 var sync_1 = require("../sync");
 var types_1 = require("../types");
 var util_1 = require("../util");
+var next_1 = require("../predicates/next");
 var utils_1 = require("../sync/utils");
 immer_1.setAutoFreeze(true);
 immer_1.enablePatches();
 var logger = new core_1.ConsoleLogger('DataStore');
 var ulid = util_1.monotonicUlidFactory(Date.now());
-var isNode = core_1.JS.browserOrNode().isNode;
+var isNode = core_1.browserOrNode().isNode;
 var SETTING_SCHEMA_VERSION = 'schemaVersion';
 var schema;
 var modelNamespaceMap = new WeakMap();
@@ -119,18 +30,156 @@ var modelNamespaceMap = new WeakMap();
 // 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);
-    return schema.namespaces[namespace].models[modelConstructor.name];
+    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 = tslib_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, tslib_1.__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 = tslib_1.__assign(tslib_1.__assign({}, Object.fromEntries(tslib_1.__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']);
 };
 var isValidModelConstructor = function (obj) {
-    return util_1.isModelConstructor(obj) && modelNamespaceMap.has(obj);
+    if (util_1.isModelConstructor(obj) && modelNamespaceMap.has(obj)) {
+        return true;
+    }
+    else {
+        return false;
+    }
 };
 var namespaceResolver = function (modelConstructor) {
-    return modelNamespaceMap.get(modelConstructor);
+    var resolver = modelNamespaceMap.get(modelConstructor);
+    if (!resolver) {
+        throw new Error("Namespace Resolver for '" + modelConstructor.name + "' not found! This is probably a bug in '@amplify-js/datastore'.");
+    }
+    return resolver;
+};
+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);
+    if (!pks)
+        throw new Error('Could not determine PK');
+    return next_1.recursivePredicateFor({
+        builder: modelConstructor,
+        schema: modelSchema,
+        pkField: pks,
+    });
 };
 var userClasses;
 var dataStoreClasses;
 var storageClasses;
+/**
+ * Maps a model to its related models for memoization/immutability.
+ */
+var modelInstanceAssociationsMap = new WeakMap();
+/**
+ * Describes whether and to what a model is attached for lazy loading purposes.
+ */
+var ModelAttachment;
+(function (ModelAttachment) {
+    /**
+     * Model doesn't lazy load from any data source.
+     *
+     * Related entity properties provided at instantiation are returned
+     * via the respective lazy interfaces when their properties are invoked.
+     */
+    ModelAttachment["Detached"] = "Detached";
+    /**
+     * Model lazy loads from the global DataStore.
+     */
+    ModelAttachment["DataStore"] = "DataStore";
+    /**
+     * Demonstrative. Not yet implemented.
+     */
+    ModelAttachment["API"] = "API";
+})(ModelAttachment || (ModelAttachment = {}));
+/**
+ * Tells us which data source a model is attached to (lazy loads from).
+ *
+ * If `Deatched`, the model's lazy properties will only ever return properties
+ * from memory provided at construction time.
+ */
+var attachedModelInstances = new WeakMap();
+/**
+ * Registers a model instance against a data source (DataStore, API, or
+ * Detached/None).
+ *
+ * The API option is demonstrative. Lazy loading against API is not yet
+ * implemented.
+ *
+ * @param result A model instance or array of instances
+ * @param attachment A ModelAttachment data source
+ * @returns passes the `result` back through after attachment
+ */
+function attached(result, attachment) {
+    if (Array.isArray(result)) {
+        result.map(function (record) { return attached(record, attachment); });
+    }
+    else {
+        result && attachedModelInstances.set(result, attachment);
+    }
+    return result;
+}
+exports.attached = attached;
+/**
+ * Determines what source a model instance should lazy load from.
+ *
+ * If the instace was never explicitly registered, it is detached by default.
+ *
+ * @param instance A model instance
+ */
+exports.getAttachment = function (instance) {
+    return attachedModelInstances.has(instance)
+        ? attachedModelInstances.get(instance)
+        : ModelAttachment.Detached;
+};
 var initSchema = function (userSchema) {
     var _a;
     if (schema !== undefined) {
@@ -138,7 +187,8 @@ var initSchema = function (userSchema) {
         return userClasses;
     }
     logger.log('validating schema', { schema: userSchema });
-    var internalUserNamespace = __assign({ name: util_1.USER }, userSchema);
+    checkSchemaCodegenVersion(userSchema.codegenVersion);
+    var internalUserNamespace = tslib_1.__assign({ name: util_1.USER }, userSchema);
     logger.log('DataStore', 'Init models');
     userClasses = createTypeClasses(internalUserNamespace);
     logger.log('DataStore', 'Models initialized');
@@ -156,10 +206,11 @@ var initSchema = function (userSchema) {
             _a[syncNamespace.name] = syncNamespace,
             _a),
         version: userSchema.version,
+        codegenVersion: userSchema.codegenVersion,
     };
     Object.keys(schema.namespaces).forEach(function (namespace) {
-        var e_1, _a;
-        var _b = __read(util_1.establishRelationAndKeys(schema.namespaces[namespace]), 2), relations = _b[0], keys = _b[1];
+        var e_3, _a;
+        var _b = tslib_1.__read(util_1.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();
@@ -175,6 +226,20 @@ var initSchema = function (userSchema) {
                 return connectedModels.push(field.type.model);
             });
             modelAssociations.set(model.name, connectedModels);
+            Object.values(model.fields).forEach(function (field) {
+                if (typeof field.type === 'object' &&
+                    !Object.getOwnPropertyDescriptor(field.type, 'modelConstructor')) {
+                    Object.defineProperty(field.type, 'modelConstructor', {
+                        get: function () {
+                            return {
+                                builder: userClasses[field.type.model],
+                                schema: schema.namespaces[namespace].models[field.type.model],
+                                pkField: getModelPKFieldName(userClasses[field.type.model]),
+                            };
+                        },
+                    });
+                }
+            });
         });
         var result = new Map();
         var count = 1000;
@@ -187,20 +252,20 @@ var initSchema = function (userSchema) {
                 throw new Error('Models are not topologically sortable. Please verify your schema.');
             }
             try {
-                for (var _c = (e_1 = void 0, __values(Array.from(modelAssociations.keys()))), _d = _c.next(); !_d.done; _d = _c.next()) {
+                for (var _c = (e_3 = void 0, tslib_1.__values(Array.from(modelAssociations.keys()))), _d = _c.next(); !_d.done; _d = _c.next()) {
                     var modelName = _d.value;
                     var parents = modelAssociations.get(modelName);
-                    if (parents.every(function (x) { return result.has(x); })) {
+                    if (parents === null || parents === void 0 ? void 0 : parents.every(function (x) { return result.has(x); })) {
                         result.set(modelName, parents);
                     }
                 }
             }
-            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            catch (e_3_1) { e_3 = { error: e_3_1 }; }
             finally {
                 try {
                     if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
                 }
-                finally { if (e_1) throw e_1.error; }
+                finally { if (e_3) throw e_3.error; }
             }
             Array.from(result.keys()).forEach(function (x) { return modelAssociations.delete(x); });
         }
@@ -225,16 +290,54 @@ var checkSchemaInitialized = function () {
         throw new Error(message);
     }
 };
+/**
+ * Throws an exception if the schema is using a codegen version that is not supported.
+ *
+ * Set the supported version by setting majorVersion and minorVersion
+ * This functions similar to ^ version range.
+ * The tested codegenVersion major version must exactly match the set majorVersion
+ * The tested codegenVersion minor version must be gt or equal to the set minorVersion
+ * Example: For a min supported version of 5.4.0 set majorVersion = 5 and minorVersion = 4
+ *
+ * This regex will not work when setting a supported range with minor version
+ * of 2 or more digits.
+ * i.e. minorVersion = 10 will not work
+ * The regex will work for testing a codegenVersion with multi digit minor
+ * versions as long as the minimum minorVersion is single digit.
+ * i.e. codegenVersion = 5.30.1, majorVersion = 5, minorVersion = 4 PASSES
+ *
+ * @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;
+    try {
+        var versionParts = codegenVersion.split('.');
+        var _a = tslib_1.__read(versionParts, 4), major = _a[0], minor = _a[1], patch = _a[2], patchrevision = _a[3];
+        isValid = Number(major) === majorVersion && Number(minor) >= minorVersion;
+    }
+    catch (err) {
+        console.log("Error parsing codegen version: " + codegenVersion + "\n" + err);
+    }
+    if (!isValid) {
+        var message = "Models were generated with an unsupported version of codegen. Codegen artifacts are from " + (codegenVersion || 'an unknown version') + ", whereas ^" + majorVersion + "." + minorVersion + ".0 is required. " +
+            "Update to the latest CLI and run 'amplify codegen models'.";
+        logger.error(message);
+        throw new Error(message);
+    }
+};
 var createTypeClasses = function (namespace) {
     var classes = {};
     Object.entries(namespace.models).forEach(function (_a) {
-        var _b = __read(_a, 2), modelName = _b[0], modelDefinition = _b[1];
+        var _b = tslib_1.__read(_a, 2), modelName = _b[0], modelDefinition = _b[1];
         var clazz = createModelClass(modelDefinition);
         classes[modelName] = clazz;
         modelNamespaceMap.set(clazz, namespace.name);
     });
     Object.entries(namespace.nonModels || {}).forEach(function (_a) {
-        var _b = __read(_a, 2), typeName = _b[0], typeDefinition = _b[1];
+        var _b = tslib_1.__read(_a, 2), typeName = _b[0], typeDefinition = _b[1];
         var clazz = createNonModelClass(typeDefinition);
         classes[typeName] = clazz;
     });
@@ -325,7 +428,8 @@ var validateModelFields = function (modelDefinition) { return function (k, v) {
             }
             else if (!util_1.isNullOrUndefined(v) &&
                 validateScalar_1 &&
-                !validateScalar_1(v)) {
+                !validateScalar_1(v) // TODO: why never, TS ... why ...
+            ) {
                 throw new Error("Field " + name_1 + " should be of type " + type_1 + ", validation failed. " + v);
             }
         }
@@ -390,7 +494,7 @@ var castInstanceType = function (modelDefinition, k, v) {
 var initializeInstance = function (init, modelDefinition, draft) {
     var modelValidator = validateModelFields(modelDefinition);
     Object.entries(init).forEach(function (_a) {
-        var _b = __read(_a, 2), k = _b[0], v = _b[1];
+        var _b = tslib_1.__read(_a, 2), k = _b[0], v = _b[1];
         var parsedValue = castInstanceType(modelDefinition, k, v);
         modelValidator(k, parsedValue);
         draft[k] = parsedValue;
@@ -447,7 +551,7 @@ var createModelClass = function (modelDefinition) {
                 keyNames.forEach(function (key) { return (draft[key] = source[key]); });
                 var modelValidator = validateModelFields(modelDefinition);
                 Object.entries(draft).forEach(function (_a) {
-                    var _b = __read(_a, 2), k = _b[0], v = _b[1];
+                    var _b = tslib_1.__read(_a, 2), k = _b[0], v = _b[1];
                     var parsedValue = castInstanceType(modelDefinition, k, v);
                     modelValidator(k, parsedValue);
                 });
@@ -455,7 +559,7 @@ var createModelClass = function (modelDefinition) {
             var hasExistingPatches = modelPatchesMap.has(source);
             if (patches.length || hasExistingPatches) {
                 if (hasExistingPatches) {
-                    var _a = __read(modelPatchesMap.get(source), 2), existingPatches = _a[0], existingSource = _a[1];
+                    var _a = tslib_1.__read(modelPatchesMap.get(source), 2), existingPatches = _a[0], existingSource = _a[1];
                     var mergedPatches = util_1.mergePatches(existingSource, existingPatches, patches);
                     modelPatchesMap.set(model, [mergedPatches, existingSource]);
                     checkReadOnlyPropertyOnUpdate(mergedPatches, modelDefinition);
@@ -465,7 +569,7 @@ var createModelClass = function (modelDefinition) {
                     checkReadOnlyPropertyOnUpdate(patches, modelDefinition);
                 }
             }
-            return model;
+            return attached(model, ModelAttachment.DataStore);
         };
         // "private" method (that's hidden via `Setting`) for `withSSRContext` to use
         // to gain access to `modelInstanceCreator` and `clazz` for persisting IDs from server to client.
@@ -477,17 +581,208 @@ var createModelClass = function (modelDefinition) {
             var instance = modelInstanceCreator(clazz, json);
             var modelValidator = validateModelFields(modelDefinition);
             Object.entries(instance).forEach(function (_a) {
-                var _b = __read(_a, 2), k = _b[0], v = _b[1];
+                var _b = tslib_1.__read(_a, 2), k = _b[0], v = _b[1];
                 modelValidator(k, v);
             });
-            return instance;
+            return attached(instance, ModelAttachment.DataStore);
         };
         return Model;
     }());
     clazz[immer_1.immerable] = true;
     Object.defineProperty(clazz, 'name', { value: modelDefinition.name });
+    var _loop_1 = function (field) {
+        if (!types_1.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 relationship_1.ModelRelationship({
+            builder: clazz,
+            schema: modelDefinition,
+            pkField: util_1.extractPrimaryKeyFieldNames(modelDefinition),
+        }, field);
+        Object.defineProperty(clazz.prototype, modelDefinition.fields[field].name, {
+            set: function (model) {
+                if (!model || !(typeof model === 'object'))
+                    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 (relationship.isComplete) {
+                    for (var i = 0; i < relationship.localJoinFields.length; i++) {
+                        this[relationship.localJoinFields[i]] =
+                            model[relationship.remoteJoinFields[i]];
+                    }
+                    var instanceMemos = modelInstanceAssociationsMap.has(this)
+                        ? modelInstanceAssociationsMap.get(this)
+                        : modelInstanceAssociationsMap.set(this, {}).get(this);
+                    instanceMemos[field] = model;
+                }
+            },
+            get: function () {
+                var _this = this;
+                var instanceMemos = modelInstanceAssociationsMap.has(this)
+                    ? modelInstanceAssociationsMap.get(this)
+                    : modelInstanceAssociationsMap.set(this, {}).get(this);
+                if (!instanceMemos.hasOwnProperty(field)) {
+                    if (exports.getAttachment(this) === ModelAttachment.DataStore) {
+                        var resultPromise = instance.query(relationship.remoteModelConstructor, function (base) {
+                            return base.and(function (q) {
+                                return relationship.remoteJoinFields.map(function (field, index) {
+                                    return q[field].eq(_this[relationship.localJoinFields[index]]);
+                                });
+                            });
+                        });
+                        if (relationship.type === 'HAS_MANY') {
+                            instanceMemos[field] = new AsyncCollection(resultPromise);
+                        }
+                        else {
+                            instanceMemos[field] = resultPromise.then(function (rows) {
+                                if (rows.length > 1) {
+                                    // should never happen for a HAS_ONE or BELONGS_TO.
+                                    var err = new Error("\n\t\t\t\t\t\t\t\t\tData integrity error.\n\t\t\t\t\t\t\t\t\tToo many records found for a HAS_ONE/BELONGS_TO field '" + modelDefinition.name + "." + field + "'\n\t\t\t\t\t\t\t\t");
+                                    console.error(err);
+                                    throw err;
+                                }
+                                else {
+                                    return rows[0];
+                                }
+                            });
+                        }
+                    }
+                    else if (exports.getAttachment(this) === ModelAttachment.API) {
+                        throw new Error('Lazy loading from API is not yet supported!');
+                    }
+                    else {
+                        if (relationship.type === 'HAS_MANY') {
+                            return new AsyncCollection([]);
+                        }
+                        else {
+                            return Promise.resolve(undefined);
+                        }
+                    }
+                }
+                return instanceMemos[field];
+            },
+        });
+    };
+    for (var field in modelDefinition.fields) {
+        _loop_1(field);
+    }
     return clazz;
 };
+var AsyncItem = /** @class */ (function (_super) {
+    tslib_1.__extends(AsyncItem, _super);
+    function AsyncItem() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    return AsyncItem;
+}(Promise));
+exports.AsyncItem = AsyncItem;
+var AsyncCollection = /** @class */ (function () {
+    function AsyncCollection(values) {
+        this.values = values;
+    }
+    AsyncCollection.prototype[Symbol.asyncIterator] = function () {
+        var _this = this;
+        var values;
+        var index = 0;
+        return {
+            next: function () { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                var result;
+                return tslib_1.__generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            if (!!values) return [3 /*break*/, 2];
+                            return [4 /*yield*/, this.values];
+                        case 1:
+                            values = _a.sent();
+                            _a.label = 2;
+                        case 2:
+                            if (index < values.length) {
+                                result = {
+                                    value: values[index],
+                                    done: false,
+                                };
+                                index++;
+                                return [2 /*return*/, result];
+                            }
+                            return [2 /*return*/, {
+                                    value: null,
+                                    done: true,
+                                }];
+                    }
+                });
+            }); },
+        };
+    };
+    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;
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var output, i, _d, _e, element, e_4_1;
+            return tslib_1.__generator(this, function (_f) {
+                switch (_f.label) {
+                    case 0:
+                        output = [];
+                        i = 0;
+                        _f.label = 1;
+                    case 1:
+                        _f.trys.push([1, 6, 7, 12]);
+                        _d = tslib_1.__asyncValues(this);
+                        _f.label = 2;
+                    case 2: return [4 /*yield*/, _d.next()];
+                    case 3:
+                        if (!(_e = _f.sent(), !_e.done)) return [3 /*break*/, 5];
+                        element = _e.value;
+                        if (i < max) {
+                            output.push(element);
+                            i++;
+                        }
+                        else {
+                            return [3 /*break*/, 5];
+                        }
+                        _f.label = 4;
+                    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 };
+                        return [3 /*break*/, 12];
+                    case 7:
+                        _f.trys.push([7, , 10, 11]);
+                        if (!(_e && !_e.done && (_c = _d.return))) return [3 /*break*/, 9];
+                        return [4 /*yield*/, _c.call(_d)];
+                    case 8:
+                        _f.sent();
+                        _f.label = 9;
+                    case 9: return [3 /*break*/, 11];
+                    case 10:
+                        if (e_4) throw e_4.error;
+                        return [7 /*endfinally*/];
+                    case 11: return [7 /*endfinally*/];
+                    case 12: return [2 /*return*/, output];
+                }
+            });
+        });
+    };
+    return AsyncCollection;
+}());
+exports.AsyncCollection = AsyncCollection;
 var checkReadOnlyPropertyOnCreate = function (draft, modelDefinition) {
     var modelKeys = Object.keys(draft);
     var fields = modelDefinition.fields;
@@ -501,7 +796,7 @@ var checkReadOnlyPropertyOnUpdate = function (patches, modelDefinition) {
     var patchArray = patches.map(function (p) { return [p.path[0], p.value]; });
     var fields = modelDefinition.fields;
     patchArray.forEach(function (_a) {
-        var _b = __read(_a, 2), key = _b[0], val = _b[1];
+        var _b = tslib_1.__read(_a, 2), key = _b[0], val = _b[1];
         if (!val || !fields[key])
             return;
         if (fields[key].isReadOnly) {
@@ -530,7 +825,7 @@ function isQueryOne(obj) {
 function defaultConflictHandler(conflictData) {
     var localModel = conflictData.localModel, modelConstructor = conflictData.modelConstructor, remoteModel = conflictData.remoteModel;
     var _version = remoteModel._version;
-    return modelInstanceCreator(modelConstructor, __assign(__assign({}, localModel), { _version: _version }));
+    return modelInstanceCreator(modelConstructor, tslib_1.__assign(tslib_1.__assign({}, localModel), { _version: _version }));
 }
 function defaultErrorHandler(error) {
     logger.warn(error);
@@ -551,8 +846,7 @@ function getModelConstructorByModelName(namespaceName, modelName) {
             result = storageClasses[modelName];
             break;
         default:
-            util_1.exhaustiveCheck(namespaceName);
-            break;
+            throw new Error("Invalid namespace: " + namespaceName);
     }
     if (isValidModelConstructor(result)) {
         return result;
@@ -576,23 +870,23 @@ function getModelConstructorByModelName(namespaceName, modelName) {
  * @param version The expected schema version.
  */
 function checkSchemaVersion(storage, version) {
-    return __awaiter(this, void 0, void 0, function () {
+    return tslib_1.__awaiter(this, void 0, void 0, function () {
         var Setting, modelDefinition;
         var _this = this;
-        return __generator(this, function (_a) {
+        return tslib_1.__generator(this, function (_a) {
             switch (_a.label) {
                 case 0:
                     Setting = dataStoreClasses.Setting;
                     modelDefinition = schema.namespaces[util_1.DATASTORE].models.Setting;
-                    return [4 /*yield*/, storage.runExclusive(function (s) { return __awaiter(_this, void 0, void 0, function () {
+                    return [4 /*yield*/, storage.runExclusive(function (s) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
                             var _a, schemaVersionSetting, storedValue;
-                            return __generator(this, function (_b) {
+                            return tslib_1.__generator(this, function (_b) {
                                 switch (_b.label) {
                                     case 0: return [4 /*yield*/, s.query(Setting, predicates_1.ModelPredicateCreator.createFromExisting(modelDefinition, function (c) {
                                             return c.key('eq', SETTING_SCHEMA_VERSION);
                                         }), { page: 0, limit: 1 })];
                                     case 1:
-                                        _a = __read.apply(void 0, [_b.sent(), 1]), schemaVersionSetting = _a[0];
+                                        _a = tslib_1.__read.apply(void 0, [_b.sent(), 1]), schemaVersionSetting = _a[0];
                                         if (!(schemaVersionSetting !== undefined &&
                                             schemaVersionSetting.value !== undefined)) return [3 /*break*/, 4];
                                         storedValue = JSON.parse(schemaVersionSetting.value);
@@ -670,8 +964,14 @@ var DataStore = /** @class */ (function () {
         var _this = this;
         // reference to configured category instances. Used for preserving SSR context
         this.Auth = auth_1.Auth;
-        this.API = api_1.default;
-        this.Cache = cache_1.default;
+        this.API = api_1.API;
+        this.Cache = cache_1.Cache;
+        // Non-null assertions (bang operator) have been added to most of these properties
+        // to make TS happy. These properties are all expected to be set immediately after
+        // construction.
+        // TODO: Refactor to use proper DI if possible. If not possible, change these to
+        // optionals and implement conditional checks throughout. Rinse/repeat on all
+        // sync engine processors, storage engine, adapters, etc..
         this.amplifyConfig = {};
         this.syncPredicates = new WeakMap();
         // object that gets passed to descendent classes. Allows us to pass these down by reference
@@ -726,14 +1026,14 @@ var DataStore = /** @class */ (function () {
          * 1. 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 () {
+        this.start = function () { return tslib_1.__awaiter(_this, void 0, void 0, function () {
             var _this = this;
-            return __generator(this, function (_a) {
+            return tslib_1.__generator(this, function (_a) {
                 return [2 /*return*/, this.runningProcesses
-                        .add(function () { return __awaiter(_this, void 0, void 0, function () {
+                        .add(function () { return tslib_1.__awaiter(_this, void 0, void 0, function () {
                         var aws_appsync_graphqlEndpoint, _a, fullSyncIntervalInMilliseconds;
                         var _this = this;
-                        return __generator(this, function (_b) {
+                        return tslib_1.__generator(this, function (_b) {
                             switch (_b.label) {
                                 case 0:
                                     this.state = DataStoreState.Starting;
@@ -807,17 +1107,21 @@ var DataStore = /** @class */ (function () {
                         .catch(this.handleAddProcError('DataStore.start()'))];
             });
         }); };
-        this.query = function (modelConstructor, identifierOrCriteria, paginationProducer) { return __awaiter(_this, void 0, void 0, function () {
+        this.query = function (modelConstructor, identifierOrCriteria, paginationProducer) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
             var _this = this;
-            return __generator(this, function (_a) {
+            return tslib_1.__generator(this, function (_a) {
                 return [2 /*return*/, this.runningProcesses
-                        .add(function () { return __awaiter(_this, void 0, void 0, function () {
-                        var msg, modelDefinition, keyFields, predicate, msg, pagination, result, returnOne;
-                        return __generator(this, function (_a) {
-                            switch (_a.label) {
+                        .add(function () { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                        var result, msg, modelDefinition, pagination, keyFields, msg, predicate, predicate, seedPredicate, predicate, returnOne;
+                        var _a;
+                        return tslib_1.__generator(this, function (_b) {
+                            switch (_b.label) {
                                 case 0: return [4 /*yield*/, this.start()];
                                 case 1:
-                                    _a.sent();
+                                    _b.sent();
+                                    if (!this.storage) {
+                                        throw new Error('No storage to query');
+                                    }
                                     //#region Input validation
                                     if (!isValidModelConstructor(modelConstructor)) {
                                         msg = 'Constructor is not for a valid model';
@@ -830,59 +1134,73 @@ var DataStore = /** @class */ (function () {
                                         }
                                     }
                                     modelDefinition = getModelDefinition(modelConstructor);
-                                    keyFields = util_1.extractPrimaryKeyFieldNames(modelDefinition);
-                                    if (isQueryOne(identifierOrCriteria)) {
-                                        if (keyFields.length > 1) {
-                                            msg = util_1.errorMessages.queryByPkWithCompositeKeyPresent;
-                                            logger.error(msg, { keyFields: keyFields });
-                                            throw new Error(msg);
-                                        }
-                                        predicate = predicates_1.ModelPredicateCreator.createForSingleField(modelDefinition, keyFields[0], identifierOrCriteria);
-                                    }
-                                    else {
-                                        // Object is being queried using object literal syntax
-                                        if (types_1.isIdentifierObject(identifierOrCriteria, modelDefinition)) {
-                                            predicate = predicates_1.ModelPredicateCreator.createForPk(modelDefinition, identifierOrCriteria);
-                                        }
-                                        else if (predicates_1.isPredicatesAll(identifierOrCriteria)) {
-                                            // Predicates.ALL means "all records", so no predicate (undefined)
-                                            predicate = undefined;
-                                        }
-                                        else {
-                                            predicate = predicates_1.ModelPredicateCreator.createFromExisting(modelDefinition, identifierOrCriteria);
-                                        }
+                                    if (!modelDefinition) {
+                                        throw new Error('Invalid model definition provided!');
                                     }
                                     pagination = this.processPagination(modelDefinition, paginationProducer);
-                                    //#endregion
-                                    logger.debug('params ready', {
-                                        modelConstructor: modelConstructor,
-                                        predicate: predicates_1.ModelPredicateCreator.getPredicates(predicate, false),
-                                        pagination: __assign(__assign({}, pagination), { sort: predicates_1.ModelSortPredicateCreator.getPredicates(pagination && pagination.sort, false) }),
-                                    });
+                                    keyFields = util_1.extractPrimaryKeyFieldNames(modelDefinition);
+                                    if (!isQueryOne(identifierOrCriteria)) return [3 /*break*/, 3];
+                                    if (keyFields.length > 1) {
+                                        msg = util_1.errorMessages.queryByPkWithCompositeKeyPresent;
+                                        logger.error(msg, { keyFields: keyFields });
+                                        throw new Error(msg);
+                                    }
+                                    predicate = predicates_1.ModelPredicateCreator.createForSingleField(modelDefinition, keyFields[0], identifierOrCriteria);
                                     return [4 /*yield*/, this.storage.query(modelConstructor, predicate, pagination)];
                                 case 2:
-                                    result = _a.sent();
+                                    result = _b.sent();
+                                    return [3 /*break*/, 9];
+                                case 3:
+                                    if (!types_1.isIdentifierObject(identifierOrCriteria, modelDefinition)) return [3 /*break*/, 5];
+                                    predicate = predicates_1.ModelPredicateCreator.createForPk(modelDefinition, identifierOrCriteria);
+                                    return [4 /*yield*/, this.storage.query(modelConstructor, predicate, pagination)];
+                                case 4:
+                                    result = _b.sent();
+                                    return [3 /*break*/, 9];
+                                case 5:
+                                    if (!(!identifierOrCriteria ||
+                                        predicates_1.isPredicatesAll(identifierOrCriteria))) return [3 /*break*/, 7];
+                                    return [4 /*yield*/, ((_a = this.storage) === null || _a === void 0 ? void 0 : _a.query(modelConstructor, undefined, pagination))];
+                                case 6:
+                                    result = _b.sent();
+                                    return [3 /*break*/, 9];
+                                case 7:
+                                    seedPredicate = next_1.recursivePredicateFor({
+                                        builder: modelConstructor,
+                                        schema: modelDefinition,
+                                        pkField: getModelPKFieldName(modelConstructor),
+                                    });
+                                    predicate = next_1.internals(identifierOrCriteria(seedPredicate));
+                                    return [4 /*yield*/, predicate.fetch(this.storage)];
+                                case 8:
+                                    result = (_b.sent());
+                                    result = util_1.inMemoryPagination(result, pagination);
+                                    _b.label = 9;
+                                case 9:
                                     returnOne = isQueryOne(identifierOrCriteria) ||
                                         types_1.isIdentifierObject(identifierOrCriteria, modelDefinition);
-                                    return [2 /*return*/, returnOne ? result[0] : result];
+                                    return [2 /*return*/, attached(returnOne ? result[0] : result, ModelAttachment.DataStore)];
                             }
                         });
                     }); }, 'datastore query')
                         .catch(this.handleAddProcError('DataStore.query()'))];
             });
         }); };
-        this.save = function (model, condition) { return __awaiter(_this, void 0, void 0, function () {
+        this.save = function (model, condition) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
             var _this = this;
-            return __generator(this, function (_a) {
+            return tslib_1.__generator(this, function (_a) {
                 return [2 /*return*/, this.runningProcesses
-                        .add(function () { return __awaiter(_this, void 0, void 0, function () {
-                        var patchesTuple, modelConstructor, msg, modelDefinition, producedCondition, _a, savedModel;
+                        .add(function () { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                        var patchesTuple, modelConstructor, msg, modelDefinition, modelMeta, producedCondition, _a, savedModel;
                         var _this = this;
-                        return __generator(this, function (_b) {
+                        return tslib_1.__generator(this, function (_b) {
                             switch (_b.label) {
                                 case 0: return [4 /*yield*/, this.start()];
                                 case 1:
                                     _b.sent();
+                                    if (!this.storage) {
+                                        throw new Error('No storage to save to');
+                                    }
                                     patchesTuple = modelPatchesMap.get(model);
                                     modelConstructor = model ? model.constructor : undefined;
                                     if (!isValidModelConstructor(modelConstructor)) {
@@ -891,20 +1209,81 @@ var DataStore = /** @class */ (function () {
                                         throw new Error(msg);
                                     }
                                     modelDefinition = getModelDefinition(modelConstructor);
-                                    producedCondition = predicates_1.ModelPredicateCreator.createFromExisting(modelDefinition, condition);
-                                    return [4 /*yield*/, this.storage.runExclusive(function (s) { return __awaiter(_this, void 0, void 0, function () {
-                                            return __generator(this, function (_a) {
+                                    if (!modelDefinition) {
+                                        throw new Error('Model Definition could not be found for model');
+                                    }
+                                    modelMeta = {
+                                        builder: modelConstructor,
+                                        schema: modelDefinition,
+                                        pkField: util_1.extractPrimaryKeyFieldNames(modelDefinition),
+                                    };
+                                    return [4 /*yield*/, this.storage.runExclusive(function (s) { return tslib_1.__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 _b;
+                                            return tslib_1.__generator(this, function (_c) {
+                                                switch (_c.label) {
+                                                    case 0:
+                                                        nonHasManyRelationships = relationship_1.ModelRelationship.allFrom(modelMeta).filter(function (r) { return r.type === 'BELONGS_TO'; });
+                                                        _c.label = 1;
+                                                    case 1:
+                                                        _c.trys.push([1, 6, 7, 8]);
+                                                        nonHasManyRelationships_1 = tslib_1.__values(nonHasManyRelationships), nonHasManyRelationships_1_1 = nonHasManyRelationships_1.next();
+                                                        _c.label = 2;
+                                                    case 2:
+                                                        if (!!nonHasManyRelationships_1_1.done) return [3 /*break*/, 5];
+                                                        relationship = nonHasManyRelationships_1_1.value;
+                                                        queryObject = relationship.createRemoteQueryObject(model);
+                                                        if (!(queryObject !== null)) return [3 /*break*/, 4];
+                                                        return [4 /*yield*/, s.query(relationship.remoteModelConstructor, predicates_1.ModelPredicateCreator.createFromFlatEqualities(relationship.remoteDefinition, queryObject))];
+                                                    case 3:
+                                                        related = _c.sent();
+                                                        if (related.length === 0) {
+                                                            throw new Error([
+                                                                "Data integrity error. You tried to save a " + modelDefinition.name + " (" + JSON.stringify(model) + ")",
+                                                                "but the instance assigned to the \"" + relationship.field + "\" property",
+                                                                "does not exist in the local database. If you're trying to create the related",
+                                                                "\"" + ((_b = relationship.remoteDefinition) === null || _b === void 0 ? void 0 : _b.name) + "\", you must save it independently first.",
+                                                            ].join(' '));
+                                                        }
+                                                        _c.label = 4;
+                                                    case 4:
+                                                        nonHasManyRelationships_1_1 = nonHasManyRelationships_1.next();
+                                                        return [3 /*break*/, 2];
+                                                    case 5: return [3 /*break*/, 8];
+                                                    case 6:
+                                                        e_5_1 = _c.sent();
+                                                        e_5 = { error: e_5_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; }
+                                                        return [7 /*endfinally*/];
+                                                    case 8: return [2 /*return*/];
+                                                }
+                                            });
+                                        }); })];
+                                case 2:
+                                    _b.sent();
+                                    producedCondition = condition
+                                        ? next_1.internals(condition(next_1.predicateFor(modelMeta))).toStoragePredicate()
+                                        : undefined;
+                                    return [4 /*yield*/, this.storage.runExclusive(function (s) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                                            var saved;
+                                            return tslib_1.__generator(this, function (_a) {
                                                 switch (_a.label) {
                                                     case 0: return [4 /*yield*/, s.save(model, producedCondition, undefined, patchesTuple)];
                                                     case 1:
-                                                        _a.sent();
+                                                        saved = _a.sent();
                                                         return [2 /*return*/, s.query(modelConstructor, predicates_1.ModelPredicateCreator.createForPk(modelDefinition, model))];
                                                 }
                                             });
                                         }); })];
-                                case 2:
-                                    _a = __read.apply(void 0, [_b.sent(), 1]), savedModel = _a[0];
-                                    return [2 /*return*/, savedModel];
+                                case 3:
+                                    _a = tslib_1.__read.apply(void 0, [_b.sent(), 1]), savedModel = _a[0];
+                                    return [2 /*return*/, attached(savedModel, ModelAttachment.DataStore)];
                             }
                         });
                     }); }, 'datastore save')
@@ -937,17 +1316,20 @@ var DataStore = /** @class */ (function () {
             }
             return _this.errorHandler || defaultErrorHandler;
         };
-        this.delete = function (modelOrConstructor, identifierOrCriteria) { return __awaiter(_this, void 0, void 0, function () {
+        this.delete = function (modelOrConstructor, identifierOrCriteria) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
             var _this = this;
-            return __generator(this, function (_a) {
+            return tslib_1.__generator(this, function (_a) {
                 return [2 /*return*/, this.runningProcesses
-                        .add(function () { return __awaiter(_this, void 0, void 0, function () {
+                        .add(function () { return tslib_1.__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) {
+                        return tslib_1.__generator(this, function (_d) {
                             switch (_d.label) {
                                 case 0: return [4 /*yield*/, this.start()];
                                 case 1:
                                     _d.sent();
+                                    if (!this.storage) {
+                                        throw new Error('No storage to delete from');
+                                    }
                                     if (!modelOrConstructor) {
                                         msg = 'Model or Model Constructor required';
                                         logger.error(msg, { modelOrConstructor: modelOrConstructor });
@@ -961,6 +1343,9 @@ var DataStore = /** @class */ (function () {
                                         throw new Error(msg);
                                     }
                                     modelDefinition = getModelDefinition(modelConstructor);
+                                    if (!modelDefinition) {
+                                        throw new Error('Could not find model definition for modelConstructor.');
+                                    }
                                     if (typeof identifierOrCriteria === 'string') {
                                         keyFields = util_1.extractPrimaryKeyFieldNames(modelDefinition);
                                         if (keyFields.length > 1) {
@@ -968,19 +1353,18 @@ var DataStore = /** @class */ (function () {
                                             logger.error(msg, { keyFields: keyFields });
                                             throw new Error(msg);
                                         }
-                                        condition = predicates_1.ModelPredicateCreator.createForSingleField(getModelDefinition(modelConstructor), keyFields[0], identifierOrCriteria);
+                                        condition = predicates_1.ModelPredicateCreator.createForSingleField(modelDefinition, keyFields[0], identifierOrCriteria);
                                     }
                                     else {
                                         if (types_1.isIdentifierObject(identifierOrCriteria, modelDefinition)) {
                                             condition = predicates_1.ModelPredicateCreator.createForPk(modelDefinition, identifierOrCriteria);
                                         }
                                         else {
-                                            condition = predicates_1.ModelPredicateCreator.createFromExisting(modelDefinition, 
-                                            /**
-                                             * idOrCriteria is always a ProducerModelPredicate<T>, never a symbol.
-                                             * The symbol is used only for typing purposes. e.g. see Predicates.ALL
-                                             */
-                                            identifierOrCriteria);
+                                            condition = next_1.internals(identifierOrCriteria(next_1.predicateFor({
+                                                builder: modelConstructor,
+                                                schema: modelDefinition,
+                                                pkField: util_1.extractPrimaryKeyFieldNames(modelDefinition),
+                                            }))).toStoragePredicate();
                                         }
                                         if (!condition ||
                                             !predicates_1.ModelPredicateCreator.isValidPredicate(condition)) {
@@ -991,8 +1375,8 @@ 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];
-                                    return [2 /*return*/, deleted];
+                                    _a = tslib_1.__read.apply(void 0, [_d.sent(), 1]), deleted = _a[0];
+                                    return [2 /*return*/, attached(deleted, ModelAttachment.DataStore)];
                                 case 3:
                                     model = modelOrConstructor;
                                     modelConstructor = Object.getPrototypeOf(model || {})
@@ -1003,6 +1387,9 @@ var DataStore = /** @class */ (function () {
                                         throw new Error(msg);
                                     }
                                     modelDefinition = getModelDefinition(modelConstructor);
+                                    if (!modelDefinition) {
+                                        throw new Error('Could not find model definition for modelConstructor.');
+                                    }
                                     pkPredicate = predicates_1.ModelPredicateCreator.createForPk(modelDefinition, model);
                                     if (identifierOrCriteria) {
                                         if (typeof identifierOrCriteria !== 'function') {
@@ -1010,15 +1397,19 @@ var DataStore = /** @class */ (function () {
                                             logger.error(msg, { identifierOrCriteria: identifierOrCriteria });
                                             throw new Error(msg);
                                         }
-                                        condition = identifierOrCriteria(pkPredicate);
+                                        condition = next_1.internals(identifierOrCriteria(next_1.predicateFor({
+                                            builder: modelConstructor,
+                                            schema: modelDefinition,
+                                            pkField: util_1.extractPrimaryKeyFieldNames(modelDefinition),
+                                        }))).toStoragePredicate(pkPredicate);
                                     }
                                     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];
-                                    return [2 /*return*/, deleted];
+                                    _b = tslib_1.__read.apply(void 0, [_d.sent(), 1]), _c = tslib_1.__read(_b[0], 1), deleted = _c[0];
+                                    return [2 /*return*/, attached(deleted, ModelAttachment.DataStore)];
                             }
                         });
                     }); }, 'datastore delete')
@@ -1026,7 +1417,7 @@ var DataStore = /** @class */ (function () {
             });
         }); };
         this.observe = function (modelOrConstructor, identifierOrCriteria) {
-            var predicate;
+            var executivePredicate;
             var modelConstructor = modelOrConstructor && isValidModelConstructor(modelOrConstructor)
                 ? modelOrConstructor
                 : undefined;
@@ -1066,35 +1457,26 @@ var DataStore = /** @class */ (function () {
                 logger.error(msg, { modelConstructor: modelConstructor });
                 throw new Error(msg);
             }
-            if (typeof identifierOrCriteria === 'string') {
-                var modelDefinition = getModelDefinition(modelConstructor);
-                var _a = __read(util_1.extractPrimaryKeyFieldNames(modelDefinition), 1), keyField = _a[0];
-                predicate = predicates_1.ModelPredicateCreator.createForSingleField(getModelDefinition(modelConstructor), keyField, identifierOrCriteria);
+            if (modelConstructor && typeof identifierOrCriteria === 'string') {
+                var buildIdPredicate = function (seed) { return seed.id.eq(identifierOrCriteria); };
+                executivePredicate = next_1.internals(buildIdPredicate(buildSeedPredicate(modelConstructor)));
             }
-            else {
-                if (predicates_1.isPredicatesAll(identifierOrCriteria)) {
-                    predicate = undefined;
-                }
-                else {
-                    predicate =
-                        modelConstructor &&
-                            predicates_1.ModelPredicateCreator.createFromExisting(getModelDefinition(modelConstructor), identifierOrCriteria);
-                }
+            else if (modelConstructor && typeof identifierOrCriteria === 'function') {
+                executivePredicate = next_1.internals(identifierOrCriteria(buildSeedPredicate(modelConstructor)));
             }
             return new zen_observable_ts_1.default(function (observer) {
-                var handle;
+                var source;
                 _this.runningProcesses
-                    .add(function () { return __awaiter(_this, void 0, void 0, function () {
+                    .add(function () { return tslib_1.__awaiter(_this, void 0, void 0, function () {
                     var _this = this;
-                    return __generator(this, function (_a) {
+                    return tslib_1.__generator(this, function (_a) {
                         switch (_a.label) {
                             case 0: return [4 /*yield*/, this.start()];
                             case 1:
                                 _a.sent();
                                 // Filter the events returned by Storage according to namespace,
                                 // append original element data, and subscribe to the observable
-                                handle = this.storage
-                                    .observe(modelConstructor, predicate)
+                                source = this.storage.observe(modelConstructor)
                                     .filter(function (_a) {
                                     var model = _a.model;
                                     return namespaceResolver(model) === util_1.USER;
@@ -1102,10 +1484,10 @@ var DataStore = /** @class */ (function () {
                                     .subscribe({
                                     next: function (item) {
                                         return _this.runningProcesses.isOpen &&
-                                            _this.runningProcesses.add(function () { return __awaiter(_this, void 0, void 0, function () {
-                                                var message, modelDefinition, keyFields, primaryKeysAndValues, freshElement;
-                                                return __generator(this, function (_a) {
-                                                    switch (_a.label) {
+                                            _this.runningProcesses.add(function () { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                                                var message, modelDefinition, keyFields, primaryKeysAndValues, freshElement, _a;
+                                                return tslib_1.__generator(this, function (_b) {
+                                                    switch (_b.label) {
                                                         case 0:
                                                             message = item;
                                                             if (!(item.opType !== 'DELETE')) return [3 /*break*/, 2];
@@ -1114,11 +1496,20 @@ var DataStore = /** @class */ (function () {
                                                             primaryKeysAndValues = util_1.extractPrimaryKeysAndValues(item.element, keyFields);
                                                             return [4 /*yield*/, this.query(item.model, primaryKeysAndValues)];
                                                         case 1:
-                                                            freshElement = _a.sent();
-                                                            message = __assign(__assign({}, message), { element: freshElement });
-                                                            _a.label = 2;
+                                                            freshElement = _b.sent();
+                                                            message = tslib_1.__assign(tslib_1.__assign({}, message), { element: freshElement });
+                                                            _b.label = 2;
                                                         case 2:
-                                                            observer.next(message);
+                                                            _a = !executivePredicate;
+                                                            if (_a) return [3 /*break*/, 4];
+                                                            return [4 /*yield*/, executivePredicate.matches(message.element)];
+                                                        case 3:
+                                                            _a = (_b.sent());
+                                                            _b.label = 4;
+                                                        case 4:
+                                                            if (_a) {
+                                                                observer.next(message);
+                                                            }
                                                             return [2 /*return*/];
                                                     }
                                                 });
@@ -1138,10 +1529,10 @@ var DataStore = /** @class */ (function () {
                 // better than no cleaner, but if the subscriber is handling the
                 // complete() message async and not registering with the context,
                 // this will still be problematic.
-                return _this.runningProcesses.addCleaner(function () { return __awaiter(_this, void 0, void 0, function () {
-                    return __generator(this, function (_a) {
-                        if (handle) {
-                            handle.unsubscribe();
+                return _this.runningProcesses.addCleaner(function () { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                    return tslib_1.__generator(this, function (_a) {
+                        if (source) {
+                            source.unsubscribe();
                         }
                         return [2 /*return*/];
                     });
@@ -1154,7 +1545,8 @@ var DataStore = /** @class */ (function () {
                 var itemsChanged = new Map();
                 var deletedItemIds = [];
                 var handle;
-                var predicate;
+                // let predicate: ModelPredicate<T> | undefined;
+                var executivePredicate;
                 /**
                  * As the name suggests, this geneates a snapshot in the form of
                  * 	`{items: T[], isSynced: boolean}`
@@ -1179,26 +1571,20 @@ var DataStore = /** @class */ (function () {
                 var sort = (options || {}).sort;
                 var sortOptions = sort ? { sort: sort } : undefined;
                 var modelDefinition = getModelDefinition(model);
-                var keyFields = util_1.extractPrimaryKeyFieldNames(modelDefinition);
-                if (isQueryOne(criteria)) {
-                    predicate = predicates_1.ModelPredicateCreator.createForSingleField(modelDefinition, keyFields[0], criteria);
+                if (!modelDefinition) {
+                    throw new Error('Could not find model definition.');
                 }
-                else {
-                    if (predicates_1.isPredicatesAll(criteria)) {
-                        // Predicates.ALL means "all records", so no predicate (undefined)
-                        predicate = undefined;
-                    }
-                    else {
-                        predicate = predicates_1.ModelPredicateCreator.createFromExisting(modelDefinition, criteria);
-                    }
+                if (model && typeof criteria === 'function') {
+                    executivePredicate = next_1.internals(criteria(buildSeedPredicate(model)));
+                }
+                else if (predicates_1.isPredicatesAll(criteria)) {
+                    executivePredicate = undefined;
                 }
-                var _a = predicates_1.ModelPredicateCreator.getPredicates(predicate, false) || {}, predicates = _a.predicates, predicateGroupType = _a.type;
-                var hasPredicate = !!predicates;
                 _this.runningProcesses
-                    .add(function () { return __awaiter(_this, void 0, void 0, function () {
+                    .add(function () { return tslib_1.__awaiter(_this, void 0, void 0, function () {
                     var err_1;
                     var _this = this;
-                    return __generator(this, function (_a) {
+                    return tslib_1.__generator(this, function (_a) {
                         switch (_a.label) {
                             case 0:
                                 _a.trys.push([0, 2, , 3]);
@@ -1216,42 +1602,58 @@ var DataStore = /** @class */ (function () {
                                 // We need to explicitly remove those items from the existing snapshot.
                                 handle = this.observe(model).subscribe(function (_a) {
                                     var element = _a.element, model = _a.model, opType = _a.opType;
-                                    var _b, _c;
-                                    var itemModelDefinition = getModelDefinition(model);
-                                    var idOrPk = utils_1.getIdentifierValue(itemModelDefinition, element);
-                                    if (hasPredicate &&
-                                        !util_1.validatePredicate(element, predicateGroupType, predicates)) {
-                                        if (opType === 'UPDATE' &&
-                                            (items.has(idOrPk) || itemsChanged.has(idOrPk))) {
-                                            // tracking as a "deleted item" will include the item in
-                                            // page limit calculations and ensure it is removed from the
-                                            // final items collection, regardless of which collection(s)
-                                            // it is currently in. (I mean, it could be in both, right!?)
-                                            deletedItemIds.push(idOrPk);
-                                        }
-                                        else {
-                                            // ignore updates for irrelevant/filtered items.
-                                            return;
-                                        }
-                                    }
-                                    // Flag items which have been recently deleted
-                                    // NOTE: Merging of separate operations to the same model instance is handled upstream
-                                    // in the `mergePage` method within src/sync/merger.ts. The final state of a model instance
-                                    // depends on the LATEST record (for a given id).
-                                    if (opType === 'DELETE') {
-                                        deletedItemIds.push(idOrPk);
-                                    }
-                                    else {
-                                        itemsChanged.set(idOrPk, element);
-                                    }
-                                    var isSynced = (_c = (_b = _this.sync) === null || _b === void 0 ? void 0 : _b.getModelSyncedStatus(model)) !== null && _c !== void 0 ? _c : false;
-                                    var limit = itemsChanged.size - deletedItemIds.length >=
-                                        _this.syncPageSize;
-                                    if (limit || isSynced) {
-                                        limitTimerRace.resolve();
-                                    }
-                                    // kicks off every subsequent race as results sync down
-                                    limitTimerRace.start();
+                                    return _this.runningProcesses.isOpen &&
+                                        _this.runningProcesses.add(function () { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                                            var itemModelDefinition, idOrPk, _a, isSynced, limit;
+                                            var _b, _c;
+                                            return tslib_1.__generator(this, function (_d) {
+                                                switch (_d.label) {
+                                                    case 0:
+                                                        itemModelDefinition = getModelDefinition(model);
+                                                        idOrPk = utils_1.getIdentifierValue(itemModelDefinition, element);
+                                                        _a = executivePredicate;
+                                                        if (!_a) return [3 /*break*/, 2];
+                                                        return [4 /*yield*/, executivePredicate.matches(element)];
+                                                    case 1:
+                                                        _a = !(_d.sent());
+                                                        _d.label = 2;
+                                                    case 2:
+                                                        if (_a) {
+                                                            if (opType === 'UPDATE' &&
+                                                                (items.has(idOrPk) || itemsChanged.has(idOrPk))) {
+                                                                // tracking as a "deleted item" will include the item in
+                                                                // page limit calculations and ensure it is removed from the
+                                                                // final items collection, regardless of which collection(s)
+                                                                // it is currently in. (I mean, it could be in both, right!?)
+                                                                deletedItemIds.push(idOrPk);
+                                                            }
+                                                            else {
+                                                                // ignore updates for irrelevant/filtered items.
+                                                                return [2 /*return*/];
+                                                            }
+                                                        }
+                                                        // Flag items which have been recently deleted
+                                                        // NOTE: Merging of separate operations to the same model instance is handled upstream
+                                                        // in the `mergePage` method within src/sync/merger.ts. The final state of a model instance
+                                                        // depends on the LATEST record (for a given id).
+                                                        if (opType === 'DELETE') {
+                                                            deletedItemIds.push(idOrPk);
+                                                        }
+                                                        else {
+                                                            itemsChanged.set(idOrPk, element);
+                                                        }
+                                                        isSynced = (_c = (_b = this.sync) === null || _b === void 0 ? void 0 : _b.getModelSyncedStatus(model)) !== null && _c !== void 0 ? _c : false;
+                                                        limit = itemsChanged.size - deletedItemIds.length >=
+                                                            this.syncPageSize;
+                                                        if (limit || isSynced) {
+                                                            limitTimerRace.resolve();
+                                                        }
+                                                        // kicks off every subsequent race as results sync down
+                                                        limitTimerRace.start();
+                                                        return [2 /*return*/];
+                                                }
+                                            });
+                                        }); }, 'handle observeQuery observed event');
                                 });
                                 // returns a set of initial/locally-available results
                                 generateAndEmitSnapshot();
@@ -1277,7 +1679,7 @@ var DataStore = /** @class */ (function () {
                 var generateSnapshot = 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()));
+                    var itemsArray = tslib_1.__spread(Array.from(items.values()), Array.from(itemsChanged.values()));
                     if (options === null || options === void 0 ? void 0 : options.sort) {
                         sortItems(itemsArray);
                     }
@@ -1344,8 +1746,8 @@ var DataStore = /** @class */ (function () {
                     }
                 };
                 core_1.Hub.listen('datastore', hubCallback);
-                return _this.runningProcesses.addCleaner(function () { return __awaiter(_this, void 0, void 0, function () {
-                    return __generator(this, function (_a) {
+                return _this.runningProcesses.addCleaner(function () { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                    return tslib_1.__generator(this, function (_a) {
                         if (handle) {
                             handle.unsubscribe();
                         }
@@ -1359,8 +1761,8 @@ var DataStore = /** @class */ (function () {
             _this.amplifyContext.Auth = _this.Auth;
             _this.amplifyContext.API = _this.API;
             _this.amplifyContext.Cache = _this.Cache;
-            var configDataStore = config.DataStore, configAuthModeStrategyType = config.authModeStrategyType, configConflictHandler = config.conflictHandler, configErrorHandler = config.errorHandler, configMaxRecordsToSync = config.maxRecordsToSync, configSyncPageSize = config.syncPageSize, configFullSyncInterval = config.fullSyncInterval, configSyncExpressions = config.syncExpressions, configAuthProviders = config.authProviders, configStorageAdapter = config.storageAdapter, configFromAmplify = __rest(config, ["DataStore", "authModeStrategyType", "conflictHandler", "errorHandler", "maxRecordsToSync", "syncPageSize", "fullSyncInterval", "syncExpressions", "authProviders", "storageAdapter"]);
-            _this.amplifyConfig = __assign(__assign({}, configFromAmplify), _this.amplifyConfig);
+            var configDataStore = config.DataStore, configAuthModeStrategyType = config.authModeStrategyType, configConflictHandler = config.conflictHandler, configErrorHandler = config.errorHandler, configMaxRecordsToSync = config.maxRecordsToSync, configSyncPageSize = config.syncPageSize, configFullSyncInterval = config.fullSyncInterval, configSyncExpressions = config.syncExpressions, configAuthProviders = config.authProviders, configStorageAdapter = config.storageAdapter, configFromAmplify = tslib_1.__rest(config, ["DataStore", "authModeStrategyType", "conflictHandler", "errorHandler", "maxRecordsToSync", "syncPageSize", "fullSyncInterval", "syncExpressions", "authProviders", "storageAdapter"]);
+            _this.amplifyConfig = tslib_1.__assign(tslib_1.__assign({}, configFromAmplify), _this.amplifyConfig);
             _this.conflictHandler = _this.setConflictHandler(config);
             _this.errorHandler = _this.setErrorHandler(config);
             var authModeStrategyType = (configDataStore && configDataStore.authModeStrategyType) ||
@@ -1453,8 +1855,8 @@ var DataStore = /** @class */ (function () {
      * DataStore, such as `query()`, `save()`, or `delete()`.
      */
     DataStore.prototype.clear = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
                         checkSchemaInitialized();
@@ -1501,8 +1903,8 @@ var DataStore = /** @class */ (function () {
      * running queries and terminates subscriptions."
      */
     DataStore.prototype.stop = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
                         this.state = DataStoreState.Stopping;
@@ -1562,7 +1964,7 @@ var DataStore = /** @class */ (function () {
             }
         }
         if (sort) {
-            sortPredicate = predicates_1.ModelSortPredicateCreator.createFromExisting(modelDefinition, paginationProducer.sort);
+            sortPredicate = predicates_1.ModelSortPredicateCreator.createFromExisting(modelDefinition, sort);
         }
         return {
             limit: limit,
@@ -1575,18 +1977,18 @@ var DataStore = /** @class */ (function () {
      * SchemaModel -> predicate to use during sync.
      */
     DataStore.prototype.processSyncExpressions = function () {
-        return __awaiter(this, void 0, void 0, function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
             var syncPredicates;
             var _this = this;
-            return __generator(this, function (_a) {
+            return tslib_1.__generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
                         if (!this.syncExpressions || !this.syncExpressions.length) {
                             return [2 /*return*/, new WeakMap()];
                         }
-                        return [4 /*yield*/, Promise.all(this.syncExpressions.map(function (syncExpression) { return __awaiter(_this, void 0, void 0, function () {
+                        return [4 /*yield*/, Promise.all(this.syncExpressions.map(function (syncExpression) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
                                 var _a, modelConstructor, conditionProducer, modelDefinition, condition, predicate;
-                                return __generator(this, function (_b) {
+                                return tslib_1.__generator(this, function (_b) {
                                     switch (_b.label) {
                                         case 0: return [4 /*yield*/, syncExpression];
                                         case 1:
@@ -1598,7 +2000,11 @@ var DataStore = /** @class */ (function () {
                                             if (predicates_1.isPredicatesAll(condition)) {
                                                 return [2 /*return*/, [modelDefinition, null]];
                                             }
-                                            predicate = this.createFromCondition(modelDefinition, condition);
+                                            predicate = next_1.internals(condition(next_1.predicateFor({
+                                                builder: modelConstructor,
+                                                schema: modelDefinition,
+                                                pkField: util_1.extractPrimaryKeyFieldNames(modelDefinition),
+                                            }))).toStoragePredicate();
                                             return [2 /*return*/, [modelDefinition, predicate]];
                                     }
                                 });
@@ -1620,16 +2026,16 @@ var DataStore = /** @class */ (function () {
         }
     };
     DataStore.prototype.unwrapPromise = function (conditionProducer) {
-        return __awaiter(this, void 0, void 0, function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
             var condition, error_1;
-            return __generator(this, function (_a) {
+            return tslib_1.__generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
                         _a.trys.push([0, 2, , 3]);
                         return [4 /*yield*/, conditionProducer()];
                     case 1:
                         condition = _a.sent();
-                        return [2 /*return*/, condition];
+                        return [2 /*return*/, condition || conditionProducer];
                     case 2:
                         error_1 = _a.sent();
                         if (error_1 instanceof TypeError) {
@@ -1643,7 +2049,7 @@ var DataStore = /** @class */ (function () {
     };
     DataStore.prototype.weakMapFromEntries = function (entries) {
         return entries.reduce(function (map, _a) {
-            var _b = __read(_a, 2), modelDefinition = _b[0], predicate = _b[1];
+            var _b = tslib_1.__read(_a, 2), modelDefinition = _b[0], predicate = _b[1];
             if (map.has(modelDefinition)) {
                 var name_2 = modelDefinition.name;
                 logger.warn("You can only utilize one Sync Expression per model.\n          Subsequent sync expressions for the " + name_2 + " model will be ignored.");
@@ -1665,7 +2071,7 @@ var DataStore = /** @class */ (function () {
             if (sessionId) {
                 var aws_appsync_graphqlEndpoint = this.amplifyConfig.aws_appsync_graphqlEndpoint;
                 var appSyncUrl = aws_appsync_graphqlEndpoint.split('/')[2];
-                var _a = __read(appSyncUrl.split('.'), 1), appSyncId = _a[0];
+                var _a = tslib_1.__read(appSyncUrl.split('.'), 1), appSyncId = _a[0];
                 return sessionId + "-" + appSyncId;
             }
         }