@aws-amplify/datastore 4.7.6-api-v6-models.b3abc9b.0 → 5.0.0

package/lib-esm/datastore/datastore.js

@@ -1,13 +1,10 @@
-import { __assign, __asyncValues, __awaiter, __extends, __generator, __read, __rest, __spread, __values } from "tslib";
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 import { InternalAPI } from '@aws-amplify/api/internals';
-import { Auth } from '@aws-amplify/auth';
-import { Cache } from '@aws-amplify/cache';
-import { Amplify, ConsoleLogger as Logger, Hub, browserOrNode, BackgroundProcessManager, } from '@aws-amplify/core';
+import { Amplify, Hub, Cache, ConsoleLogger } from '@aws-amplify/core';
 import { immerable, produce, setAutoFreeze, enablePatches, } from 'immer';
-import { v4 as uuid4 } from 'uuid';
-import Observable from 'zen-observable-ts';
+import { amplifyUuid, isBrowser } from '@aws-amplify/core/internals/utils';
+import { Observable, filter } from 'rxjs';
 import { defaultAuthStrategy, multiAuthStrategy } from '../authModeStrategies';
 import { isPredicatesAll, ModelPredicateCreator, ModelSortPredicateCreator, } from '../predicates';
 import { ExclusiveStorage as Storage } from '../storage/storage';
@@ -17,24 +14,24 @@ import { GraphQLScalarType, isGraphQLScalarType, isSchemaModelWithAttributes, Au
 import { DATASTORE, errorMessages, establishRelationAndKeys, isModelConstructor, monotonicUlidFactory, STORAGE, SYNC, USER, isNullOrUndefined, registerNonModelClass, sortCompareFunction, DeferredCallbackResolver, inMemoryPagination, extractPrimaryKeyFieldNames, extractPrimaryKeysAndValues, isIdManaged, isIdOptionallyManaged, mergePatches, getTimestampFields, } from '../util';
 import { recursivePredicateFor, predicateFor, internals, } from '../predicates/next';
 import { getIdentifierValue } from '../sync/utils';
+import { BackgroundProcessManager } from '@aws-amplify/core/internals/utils';
 setAutoFreeze(true);
 enablePatches();
-var logger = new Logger('DataStore');
-var ulid = monotonicUlidFactory(Date.now());
-var isNode = browserOrNode().isNode;
-var SETTING_SCHEMA_VERSION = 'schemaVersion';
-var schema;
-var modelNamespaceMap = new WeakMap();
+const logger = new ConsoleLogger('DataStore');
+const ulid = monotonicUlidFactory(Date.now());
+const SETTING_SCHEMA_VERSION = 'schemaVersion';
+let schema;
+const modelNamespaceMap = new WeakMap();
 /**
  * Stores data for crafting the correct update mutation input for a model.
  *
  * - `Patch[]` - array of changed fields and metadata.
  * - `PersistentModel` - the source model, used for diffing object-type fields.
  */
-var modelPatchesMap = new WeakMap();
-var getModelDefinition = function (modelConstructor) {
-    var namespace = modelNamespaceMap.get(modelConstructor);
-    var definition = namespace
+const modelPatchesMap = new WeakMap();
+const getModelDefinition = (modelConstructor) => {
+    const namespace = modelNamespaceMap.get(modelConstructor);
+    const definition = namespace
         ? schema.namespaces[namespace].models[modelConstructor.name]
         : undefined;
     return definition;
@@ -45,13 +42,13 @@ var getModelDefinition = function (modelConstructor) {
  *
  * @param obj The object to test.
  */
-var isValidModelConstructor = function (obj) {
+const isValidModelConstructor = (obj) => {
     return isModelConstructor(obj) && modelNamespaceMap.has(obj);
 };
-var namespaceResolver = function (modelConstructor) {
-    var resolver = modelNamespaceMap.get(modelConstructor);
+const namespaceResolver = modelConstructor => {
+    const 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'.");
+        throw new Error(`Namespace Resolver for '${modelConstructor.name}' not found! This is probably a bug in '@amplify-js/datastore'.`);
     }
     return resolver;
 };
@@ -74,13 +71,13 @@ var namespaceResolver = function (modelConstructor) {
  *
  * @param modelConstructor The model the predicate will query.
  */
-var buildSeedPredicate = function (modelConstructor) {
+const buildSeedPredicate = (modelConstructor) => {
     if (!modelConstructor)
         throw new Error('Missing modelConstructor');
-    var modelSchema = getModelDefinition(modelConstructor);
+    const modelSchema = getModelDefinition(modelConstructor);
     if (!modelSchema)
         throw new Error('Missing modelSchema');
-    var pks = extractPrimaryKeyFieldNames(modelSchema);
+    const pks = extractPrimaryKeyFieldNames(modelSchema);
     if (!pks)
         throw new Error('Could not determine PK');
     return recursivePredicateFor({
@@ -90,14 +87,14 @@ var buildSeedPredicate = function (modelConstructor) {
     });
 };
 // exporting syncClasses for testing outbox.test.ts
-export var syncClasses;
-var userClasses;
-var dataStoreClasses;
-var storageClasses;
+export let syncClasses;
+let userClasses;
+let dataStoreClasses;
+let storageClasses;
 /**
  * Maps a model to its related models for memoization/immutability.
  */
-var modelInstanceAssociationsMap = new WeakMap();
+const modelInstanceAssociationsMap = new WeakMap();
 /**
  * Describes whether and to what a model is attached for lazy loading purposes.
  */
@@ -125,7 +122,7 @@ var ModelAttachment;
  * If `Deatched`, the model's lazy properties will only ever return properties
  * from memory provided at construction time.
  */
-var attachedModelInstances = new WeakMap();
+const attachedModelInstances = new WeakMap();
 /**
  * Registers a model instance against a data source (DataStore, API, or
  * Detached/None).
@@ -139,7 +136,7 @@ var attachedModelInstances = new WeakMap();
  */
 export function attached(result, attachment) {
     if (Array.isArray(result)) {
-        result.map(function (record) { return attached(record, attachment); });
+        result.map(record => attached(record, attachment));
     }
     else {
         result && attachedModelInstances.set(result, attachment);
@@ -153,69 +150,65 @@ export function attached(result, attachment) {
  *
  * @param instance A model instance
  */
-export var getAttachment = function (instance) {
+export const getAttachment = (instance) => {
     return attachedModelInstances.has(instance)
         ? attachedModelInstances.get(instance)
         : ModelAttachment.Detached;
 };
-var initSchema = function (userSchema) {
-    var _a;
+const initSchema = (userSchema) => {
     if (schema !== undefined) {
         console.warn('The schema has already been initialized');
         return userClasses;
     }
     logger.log('validating schema', { schema: userSchema });
     checkSchemaCodegenVersion(userSchema.codegenVersion);
-    var internalUserNamespace = __assign({ name: USER }, userSchema);
+    const internalUserNamespace = {
+        name: USER,
+        ...userSchema,
+    };
     logger.log('DataStore', 'Init models');
     userClasses = createTypeClasses(internalUserNamespace);
     logger.log('DataStore', 'Models initialized');
-    var dataStoreNamespace = getNamespace();
-    var storageNamespace = Storage.getNamespace();
-    var syncNamespace = SyncEngine.getNamespace();
+    const dataStoreNamespace = getNamespace();
+    const storageNamespace = Storage.getNamespace();
+    const syncNamespace = SyncEngine.getNamespace();
     dataStoreClasses = createTypeClasses(dataStoreNamespace);
     storageClasses = createTypeClasses(storageNamespace);
     syncClasses = createTypeClasses(syncNamespace);
     schema = {
-        namespaces: (_a = {},
-            _a[dataStoreNamespace.name] = dataStoreNamespace,
-            _a[internalUserNamespace.name] = internalUserNamespace,
-            _a[storageNamespace.name] = storageNamespace,
-            _a[syncNamespace.name] = syncNamespace,
-            _a),
+        namespaces: {
+            [dataStoreNamespace.name]: dataStoreNamespace,
+            [internalUserNamespace.name]: internalUserNamespace,
+            [storageNamespace.name]: storageNamespace,
+            [syncNamespace.name]: syncNamespace,
+        },
         version: userSchema.version,
         codegenVersion: userSchema.codegenVersion,
     };
-    Object.keys(schema.namespaces).forEach(function (namespace) {
-        var e_1, _a;
-        var _b = __read(establishRelationAndKeys(schema.namespaces[namespace]), 2), relations = _b[0], keys = _b[1];
+    Object.keys(schema.namespaces).forEach(namespace => {
+        const [relations, keys] = establishRelationAndKeys(schema.namespaces[namespace]);
         schema.namespaces[namespace].relationships = relations;
         schema.namespaces[namespace].keys = keys;
-        var modelAssociations = new Map();
-        Object.values(schema.namespaces[namespace].models).forEach(function (model) {
-            var e_2, _a, e_3, _b;
-            var connectedModels = [];
+        const modelAssociations = new Map();
+        Object.values(schema.namespaces[namespace].models).forEach(model => {
+            const connectedModels = [];
             Object.values(model.fields)
-                .filter(function (field) {
-                return field.association &&
-                    field.association.connectionType === 'BELONGS_TO' &&
-                    field.type.model !== model.name;
-            })
-                .forEach(function (field) {
-                return connectedModels.push(field.type.model);
-            });
+                .filter(field => field.association &&
+                field.association.connectionType === 'BELONGS_TO' &&
+                field.type.model !== model.name)
+                .forEach(field => connectedModels.push(field.type.model));
             modelAssociations.set(model.name, connectedModels);
             // Precompute model info (such as pk fields) so that downstream schema consumers
             // (such as predicate builders) don't have to reach back into "DataStore" space
             // to go looking for it.
-            Object.values(model.fields).forEach(function (field) {
-                var relatedModel = userClasses[field.type.model];
+            Object.values(model.fields).forEach(field => {
+                const relatedModel = userClasses[field.type.model];
                 if (isModelConstructor(relatedModel)) {
                     Object.defineProperty(field.type, 'modelConstructor', {
-                        get: function () {
-                            var relatedModelDefinition = getModelDefinition(relatedModel);
+                        get: () => {
+                            const relatedModelDefinition = getModelDefinition(relatedModel);
                             if (!relatedModelDefinition)
-                                throw new Error("Could not find model definition for " + relatedModel.name);
+                                throw new Error(`Could not find model definition for ${relatedModel.name}`);
                             return {
                                 builder: relatedModel,
                                 schema: relatedModelDefinition,
@@ -228,44 +221,27 @@ var initSchema = function (userSchema) {
             // compatibility with legacy/pre-PK codegen for lazy loading to inject
             // index fields into the model definition.
             // definition.cloudFields = { ...definition.fields };
-            var indexes = schema.namespaces[namespace].relationships[model.name].indexes;
-            var indexFields = new Set();
-            try {
-                for (var indexes_1 = __values(indexes), indexes_1_1 = indexes_1.next(); !indexes_1_1.done; indexes_1_1 = indexes_1.next()) {
-                    var index = indexes_1_1.value;
-                    try {
-                        for (var _c = (e_3 = void 0, __values(index[1])), _d = _c.next(); !_d.done; _d = _c.next()) {
-                            var indexField = _d.value;
-                            indexFields.add(indexField);
-                        }
-                    }
-                    catch (e_3_1) { e_3 = { error: e_3_1 }; }
-                    finally {
-                        try {
-                            if (_d && !_d.done && (_b = _c.return)) _b.call(_c);
-                        }
-                        finally { if (e_3) throw e_3.error; }
-                    }
+            const indexes = schema.namespaces[namespace].relationships[model.name].indexes;
+            const indexFields = new Set();
+            for (const index of indexes) {
+                for (const indexField of index[1]) {
+                    indexFields.add(indexField);
                 }
             }
-            catch (e_2_1) { e_2 = { error: e_2_1 }; }
-            finally {
-                try {
-                    if (indexes_1_1 && !indexes_1_1.done && (_a = indexes_1.return)) _a.call(indexes_1);
-                }
-                finally { if (e_2) throw e_2.error; }
-            }
-            model.allFields = __assign(__assign({}, Object.fromEntries(__spread(indexFields.values()).map(function (name) { return [
-                name,
-                {
-                    name: name,
-                    type: 'ID',
-                    isArray: false,
-                },
-            ]; }))), model.fields);
+            model.allFields = {
+                ...Object.fromEntries([...indexFields.values()].map(name => [
+                    name,
+                    {
+                        name,
+                        type: 'ID',
+                        isArray: false,
+                    },
+                ])),
+                ...model.fields,
+            };
         });
-        var result = new Map();
-        var count = 1000;
+        const result = new Map();
+        let count = 1000;
         while (true && count > 0) {
             if (modelAssociations.size === 0) {
                 break;
@@ -274,23 +250,13 @@ var initSchema = function (userSchema) {
             if (count === 0) {
                 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()) {
-                    var modelName = _d.value;
-                    var parents = modelAssociations.get(modelName);
-                    if (parents === null || parents === void 0 ? void 0 : parents.every(function (x) { return result.has(x); })) {
-                        result.set(modelName, parents);
-                    }
+            for (const modelName of Array.from(modelAssociations.keys())) {
+                const parents = modelAssociations.get(modelName);
+                if (parents?.every(x => result.has(x))) {
+                    result.set(modelName, parents);
                 }
             }
-            catch (e_1_1) { e_1 = { error: e_1_1 }; }
-            finally {
-                try {
-                    if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
-                }
-                finally { if (e_1) throw e_1.error; }
-            }
-            Array.from(result.keys()).forEach(function (x) { return modelAssociations.delete(x); });
+            Array.from(result.keys()).forEach(x => modelAssociations.delete(x));
         }
         schema.namespaces[namespace].modelTopologicalOrdering = result;
     });
@@ -305,9 +271,9 @@ var initSchema = function (userSchema) {
  * Currently this only needs to be called in `start()` and `clear()` because
  * all other functions will call start first.
  */
-var checkSchemaInitialized = function () {
+const checkSchemaInitialized = () => {
     if (schema === undefined) {
-        var message = 'Schema is not initialized. DataStore will not function as expected. This could happen if you have multiple versions of DataStore installed. Please see https://docs.amplify.aws/lib/troubleshooting/upgrading/q/platform/js/#check-for-duplicate-versions';
+        const message = 'Schema is not initialized. DataStore will not function as expected. This could happen if you have multiple versions of DataStore installed. Please see https://docs.amplify.aws/lib/troubleshooting/upgrading/q/platform/js/#check-for-duplicate-versions';
         logger.error(message);
         throw new Error(message);
     }
@@ -330,36 +296,34 @@ var checkSchemaInitialized = function () {
  *
  * @param codegenVersion schema codegenVersion
  */
-var checkSchemaCodegenVersion = function (codegenVersion) {
-    var majorVersion = 3;
-    var minorVersion = 2;
-    var isValid = false;
+const checkSchemaCodegenVersion = (codegenVersion) => {
+    const majorVersion = 3;
+    const minorVersion = 2;
+    let isValid = false;
     try {
-        var versionParts = codegenVersion.split('.');
-        var _a = __read(versionParts, 4), major = _a[0], minor = _a[1], patch = _a[2], patchrevision = _a[3];
+        const versionParts = codegenVersion.split('.');
+        const [major, minor, patch, patchrevision] = versionParts;
         isValid = Number(major) === majorVersion && Number(minor) >= minorVersion;
     }
     catch (err) {
-        console.log("Error parsing codegen version: " + codegenVersion + "\n" + 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. " +
+        const 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 clazz = createModelClass(modelDefinition);
+const createTypeClasses = namespace => {
+    const classes = {};
+    Object.entries(namespace.models).forEach(([modelName, modelDefinition]) => {
+        const 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 clazz = createNonModelClass(typeDefinition);
+    Object.entries(namespace.nonModels || {}).forEach(([typeName, typeDefinition]) => {
+        const clazz = createNonModelClass(typeDefinition);
         classes[typeName] = clazz;
     });
     return classes;
@@ -369,37 +333,37 @@ var createTypeClasses = function (namespace) {
  * the model visible to the consuming app -- in case the app doesn't have
  * metadata fields (_version, _deleted, etc.) exposed on the model itself.
  */
-var instancesMetadata = new WeakSet();
+const instancesMetadata = new WeakSet();
 function modelInstanceCreator(modelConstructor, init) {
     instancesMetadata.add(init);
     return new modelConstructor(init);
 }
-var validateModelFields = function (modelDefinition) { return function (k, v) {
-    var fieldDefinition = modelDefinition.fields[k];
+const validateModelFields = (modelDefinition) => (k, v) => {
+    const fieldDefinition = modelDefinition.fields[k];
     if (fieldDefinition !== undefined) {
-        var type_1 = fieldDefinition.type, isRequired_1 = fieldDefinition.isRequired, isArrayNullable = fieldDefinition.isArrayNullable, name_1 = fieldDefinition.name, isArray = fieldDefinition.isArray;
-        var timestamps = isSchemaModelWithAttributes(modelDefinition)
+        const { type, isRequired, isArrayNullable, name, isArray } = fieldDefinition;
+        const timestamps = isSchemaModelWithAttributes(modelDefinition)
             ? getTimestampFields(modelDefinition)
             : {};
-        var isTimestampField = !!timestamps[name_1];
-        if (((!isArray && isRequired_1) || (isArray && !isArrayNullable)) &&
+        const isTimestampField = !!timestamps[name];
+        if (((!isArray && isRequired) || (isArray && !isArrayNullable)) &&
             !isTimestampField &&
             (v === null || v === undefined)) {
-            throw new Error("Field " + name_1 + " is required");
+            throw new Error(`Field ${name} is required`);
         }
         if (isSchemaModelWithAttributes(modelDefinition) &&
             !isIdManaged(modelDefinition)) {
-            var keys = extractPrimaryKeyFieldNames(modelDefinition);
+            const keys = extractPrimaryKeyFieldNames(modelDefinition);
             if (keys.includes(k) && v === '') {
-                logger.error(errorMessages.idEmptyString, { k: k, value: v });
+                logger.error(errorMessages.idEmptyString, { k, value: v });
                 throw new Error(errorMessages.idEmptyString);
             }
         }
-        if (isGraphQLScalarType(type_1)) {
-            var jsType_1 = GraphQLScalarType.getJSType(type_1);
-            var validateScalar_1 = GraphQLScalarType.getValidationFunction(type_1);
-            if (type_1 === 'AWSJSON') {
-                if (typeof v === jsType_1) {
+        if (isGraphQLScalarType(type)) {
+            const jsType = GraphQLScalarType.getJSType(type);
+            const validateScalar = GraphQLScalarType.getValidationFunction(type);
+            if (type === 'AWSJSON') {
+                if (typeof v === jsType) {
                     return;
                 }
                 if (typeof v === 'string') {
@@ -408,96 +372,94 @@ var validateModelFields = function (modelDefinition) { return function (k, v) {
                         return;
                     }
                     catch (error) {
-                        throw new Error("Field " + name_1 + " is an invalid JSON object. " + v);
+                        throw new Error(`Field ${name} is an invalid JSON object. ${v}`);
                     }
                 }
             }
             if (isArray) {
-                var errorTypeText = jsType_1;
-                if (!isRequired_1) {
-                    errorTypeText = jsType_1 + " | null | undefined";
+                let errorTypeText = jsType;
+                if (!isRequired) {
+                    errorTypeText = `${jsType} | null | undefined`;
                 }
                 if (!Array.isArray(v) && !isArrayNullable) {
-                    throw new Error("Field " + name_1 + " should be of type [" + errorTypeText + "], " + typeof v + " received. " + v);
+                    throw new Error(`Field ${name} should be of type [${errorTypeText}], ${typeof v} received. ${v}`);
                 }
                 if (!isNullOrUndefined(v) &&
-                    v.some(function (e) {
-                        return isNullOrUndefined(e) ? isRequired_1 : typeof e !== jsType_1;
-                    })) {
-                    var elemTypes = v
-                        .map(function (e) { return (e === null ? 'null' : typeof e); })
+                    v.some(e => isNullOrUndefined(e) ? isRequired : typeof e !== jsType)) {
+                    const elemTypes = v
+                        .map(e => (e === null ? 'null' : typeof e))
                         .join(',');
-                    throw new Error("All elements in the " + name_1 + " array should be of type " + errorTypeText + ", [" + elemTypes + "] received. " + v);
+                    throw new Error(`All elements in the ${name} array should be of type ${errorTypeText}, [${elemTypes}] received. ${v}`);
                 }
-                if (validateScalar_1 && !isNullOrUndefined(v)) {
-                    var validationStatus = v.map(function (e) {
+                if (validateScalar && !isNullOrUndefined(v)) {
+                    const validationStatus = v.map(e => {
                         if (!isNullOrUndefined(e)) {
-                            return validateScalar_1(e);
+                            return validateScalar(e);
                         }
-                        else if (isNullOrUndefined(e) && !isRequired_1) {
+                        else if (isNullOrUndefined(e) && !isRequired) {
                             return true;
                         }
                         else {
                             return false;
                         }
                     });
-                    if (!validationStatus.every(function (s) { return s; })) {
-                        throw new Error("All elements in the " + name_1 + " array should be of type " + type_1 + ", validation failed for one or more elements. " + v);
+                    if (!validationStatus.every(s => s)) {
+                        throw new Error(`All elements in the ${name} array should be of type ${type}, validation failed for one or more elements. ${v}`);
                     }
                 }
             }
-            else if (!isRequired_1 && v === undefined) {
+            else if (!isRequired && v === undefined) {
                 return;
             }
-            else if (typeof v !== jsType_1 && v !== null) {
-                throw new Error("Field " + name_1 + " should be of type " + jsType_1 + ", " + typeof v + " received. " + v);
+            else if (typeof v !== jsType && v !== null) {
+                throw new Error(`Field ${name} should be of type ${jsType}, ${typeof v} received. ${v}`);
             }
             else if (!isNullOrUndefined(v) &&
-                validateScalar_1 &&
-                !validateScalar_1(v) // TODO: why never, TS ... why ...
+                validateScalar &&
+                !validateScalar(v) // TODO: why never, TS ... why ...
             ) {
-                throw new Error("Field " + name_1 + " should be of type " + type_1 + ", validation failed. " + v);
+                throw new Error(`Field ${name} should be of type ${type}, validation failed. ${v}`);
             }
         }
-        else if (isNonModelFieldType(type_1)) {
+        else if (isNonModelFieldType(type)) {
             // do not check non model fields if undefined or null
             if (!isNullOrUndefined(v)) {
-                var subNonModelDefinition_1 = schema.namespaces.user.nonModels[type_1.nonModel];
-                var modelValidator_1 = validateModelFields(subNonModelDefinition_1);
+                const subNonModelDefinition = schema.namespaces.user.nonModels[type.nonModel];
+                const modelValidator = validateModelFields(subNonModelDefinition);
                 if (isArray) {
-                    var errorTypeText = type_1.nonModel;
-                    if (!isRequired_1) {
-                        errorTypeText = type_1.nonModel + " | null | undefined";
+                    let errorTypeText = type.nonModel;
+                    if (!isRequired) {
+                        errorTypeText = `${type.nonModel} | null | undefined`;
                     }
                     if (!Array.isArray(v)) {
-                        throw new Error("Field " + name_1 + " should be of type [" + errorTypeText + "], " + typeof v + " received. " + v);
+                        throw new Error(`Field ${name} should be of type [${errorTypeText}], ${typeof v} received. ${v}`);
                     }
-                    v.forEach(function (item) {
-                        if ((isNullOrUndefined(item) && isRequired_1) ||
+                    v.forEach(item => {
+                        if ((isNullOrUndefined(item) && isRequired) ||
                             (typeof item !== 'object' && typeof item !== 'undefined')) {
-                            throw new Error("All elements in the " + name_1 + " array should be of type " + type_1.nonModel + ", [" + typeof item + "] received. " + item);
+                            throw new Error(`All elements in the ${name} array should be of type ${type.nonModel}, [${typeof item}] received. ${item}`);
                         }
                         if (!isNullOrUndefined(item)) {
-                            Object.keys(subNonModelDefinition_1.fields).forEach(function (subKey) {
-                                modelValidator_1(subKey, item[subKey]);
+                            Object.keys(subNonModelDefinition.fields).forEach(subKey => {
+                                modelValidator(subKey, item[subKey]);
                             });
                         }
                     });
                 }
                 else {
                     if (typeof v !== 'object') {
-                        throw new Error("Field " + name_1 + " should be of type " + type_1.nonModel + ", " + typeof v + " recieved. " + v);
+                        throw new Error(`Field ${name} should be of type ${type.nonModel}, ${typeof v} recieved. ${v}`);
                     }
-                    Object.keys(subNonModelDefinition_1.fields).forEach(function (subKey) {
-                        modelValidator_1(subKey, v[subKey]);
+                    Object.keys(subNonModelDefinition.fields).forEach(subKey => {
+                        modelValidator(subKey, v[subKey]);
                     });
                 }
             }
         }
     }
-}; };
-var castInstanceType = function (modelDefinition, k, v) {
-    var _a = modelDefinition.fields[k] || {}, isArray = _a.isArray, type = _a.type;
+};
+const castInstanceType = (modelDefinition, k, v) => {
+    const { isArray, type } = modelDefinition.fields[k] || {};
     // attempt to parse stringified JSON
     if (typeof v === 'string' &&
         (isArray ||
@@ -507,7 +469,7 @@ var castInstanceType = function (modelDefinition, k, v) {
         try {
             return JSON.parse(v);
         }
-        catch (_b) {
+        catch {
             // if JSON is invalid, don't throw and let modelValidator handle it
         }
     }
@@ -522,7 +484,7 @@ var castInstanceType = function (modelDefinition, k, v) {
  * an instance of a Model. This can be used for determining which fields to
  * send to the cloud durnig a CREATE mutation.
  */
-var initPatches = new WeakMap();
+const initPatches = new WeakMap();
 /**
  * Attempts to apply type-aware, casted field values from a given `init`
  * object to the given `draft`.
@@ -531,11 +493,10 @@ var initPatches = new WeakMap();
  * @param modelDefinition The definition describing the target object shape.
  * @param draft The draft to apply field values to.
  */
-var initializeInstance = function (init, modelDefinition, draft) {
-    var modelValidator = validateModelFields(modelDefinition);
-    Object.entries(init).forEach(function (_a) {
-        var _b = __read(_a, 2), k = _b[0], v = _b[1];
-        var parsedValue = castInstanceType(modelDefinition, k, v);
+const initializeInstance = (init, modelDefinition, draft) => {
+    const modelValidator = validateModelFields(modelDefinition);
+    Object.entries(init).forEach(([k, v]) => {
+        const parsedValue = castInstanceType(modelDefinition, k, v);
         modelValidator(k, parsedValue);
         draft[k] = parsedValue;
     });
@@ -559,104 +520,90 @@ var initializeInstance = function (init, modelDefinition, draft) {
  * @param modelDefinition Definition for the draft. Used to discover all fields.
  * @param draft The instance draft to apply normalizations to.
  */
-var normalize = function (modelDefinition, draft) {
-    var e_4, _a;
-    try {
-        for (var _b = __values(Object.keys(modelDefinition.fields)), _c = _b.next(); !_c.done; _c = _b.next()) {
-            var k = _c.value;
-            if (draft[k] === undefined)
-                draft[k] = null;
-        }
-    }
-    catch (e_4_1) { e_4 = { error: e_4_1 }; }
-    finally {
-        try {
-            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
-        }
-        finally { if (e_4) throw e_4.error; }
+const normalize = (modelDefinition, draft) => {
+    for (const k of Object.keys(modelDefinition.fields)) {
+        if (draft[k] === undefined)
+            draft[k] = null;
     }
 };
-var createModelClass = function (modelDefinition) {
-    var e_5, _a;
-    var clazz = /** @class */ (function () {
-        function Model(init) {
+const createModelClass = (modelDefinition) => {
+    const clazz = class Model {
+        constructor(init) {
             // we create a base instance first so we can distinguish which fields were explicitly
             // set by customer code versus those set by normalization. only those fields
             // which are explicitly set by customers should be part of create mutations.
-            var patches = [];
-            var baseInstance = produce(this, function (draft) {
+            let patches = [];
+            const baseInstance = produce(this, (draft) => {
                 initializeInstance(init, modelDefinition, draft);
                 // model is initialized inside a DataStore component (e.g. by Sync Engine, Storage Engine, etc.)
-                var isInternallyInitialized = instancesMetadata.has(init);
-                var modelInstanceMetadata = isInternallyInitialized
+                const isInternallyInitialized = instancesMetadata.has(init);
+                const modelInstanceMetadata = isInternallyInitialized
                     ? init
                     : {};
-                var _id = modelInstanceMetadata.id;
+                const { id: _id } = modelInstanceMetadata;
                 if (isIdManaged(modelDefinition)) {
-                    var isInternalModel = _id !== null && _id !== undefined;
-                    var id = isInternalModel
+                    const isInternalModel = _id !== null && _id !== undefined;
+                    const id = isInternalModel
                         ? _id
                         : modelDefinition.syncable
-                            ? uuid4()
+                            ? amplifyUuid()
                             : ulid();
                     draft.id = id;
                 }
                 else if (isIdOptionallyManaged(modelDefinition)) {
                     // only auto-populate if the id was not provided
-                    draft.id = draft.id || uuid4();
+                    draft.id =
+                        draft.id || amplifyUuid();
                 }
                 if (!isInternallyInitialized) {
                     checkReadOnlyPropertyOnCreate(draft, modelDefinition);
                 }
-                var _version = modelInstanceMetadata._version, _lastChangedAt = modelInstanceMetadata._lastChangedAt, _deleted = modelInstanceMetadata._deleted;
+                const { _version, _lastChangedAt, _deleted } = modelInstanceMetadata;
                 if (modelDefinition.syncable) {
                     draft._version = _version;
                     draft._lastChangedAt = _lastChangedAt;
                     draft._deleted = _deleted;
                 }
-            }, function (p) { return (patches = p); });
+            }, p => (patches = p));
             // now that we have a list of patches that encapsulate the explicit, customer-provided
             // fields, we can normalize. patches from normalization are ignored, because the changes
             // are only create to provide a consistent view of the data for fields pre/post sync
             // where possible. (not all fields can be normalized pre-sync, because they're generally
             // "cloud managed" fields, like createdAt and updatedAt.)
-            var normalized = produce(baseInstance, function (draft) {
-                return normalize(modelDefinition, draft);
-            });
+            const normalized = produce(baseInstance, (draft) => normalize(modelDefinition, draft));
             initPatches.set(normalized, patches);
             return normalized;
         }
-        Model.copyOf = function (source, fn) {
-            var modelConstructor = Object.getPrototypeOf(source || {}).constructor;
+        static copyOf(source, fn) {
+            const modelConstructor = Object.getPrototypeOf(source || {}).constructor;
             if (!isValidModelConstructor(modelConstructor)) {
-                var msg = 'The source object is not a valid model';
-                logger.error(msg, { source: source });
+                const msg = 'The source object is not a valid model';
+                logger.error(msg, { source });
                 throw new Error(msg);
             }
-            var patches = [];
-            var model = produce(source, function (draft) {
+            let patches = [];
+            const model = produce(source, draft => {
                 fn(draft);
-                var keyNames = extractPrimaryKeyFieldNames(modelDefinition);
+                const keyNames = extractPrimaryKeyFieldNames(modelDefinition);
                 // Keys are immutable
-                keyNames.forEach(function (key) {
+                keyNames.forEach(key => {
                     if (draft[key] !== source[key]) {
-                        logger.warn("copyOf() does not update PK fields. The '" + key + "' update is being ignored.", { source: source });
+                        logger.warn(`copyOf() does not update PK fields. The '${key}' update is being ignored.`, { source });
                     }
                     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 parsedValue = castInstanceType(modelDefinition, k, v);
+                const modelValidator = validateModelFields(modelDefinition);
+                Object.entries(draft).forEach(([k, v]) => {
+                    const parsedValue = castInstanceType(modelDefinition, k, v);
                     modelValidator(k, parsedValue);
                 });
                 normalize(modelDefinition, draft);
-            }, function (p) { return (patches = p); });
-            var hasExistingPatches = modelPatchesMap.has(source);
+            }, p => (patches = p));
+            const hasExistingPatches = modelPatchesMap.has(source);
             if (patches.length || hasExistingPatches) {
                 if (hasExistingPatches) {
-                    var _a = __read(modelPatchesMap.get(source), 2), existingPatches = _a[0], existingSource = _a[1];
-                    var mergedPatches = mergePatches(existingSource, existingPatches, patches);
+                    const [existingPatches, existingSource] = modelPatchesMap.get(source);
+                    const mergedPatches = mergePatches(existingSource, existingPatches, patches);
                     modelPatchesMap.set(model, [mergedPatches, existingSource]);
                     checkReadOnlyPropertyOnUpdate(mergedPatches, modelDefinition);
                 }
@@ -675,38 +622,35 @@ var createModelClass = function (modelDefinition) {
                 modelPatchesMap.set(model, [[], source]);
             }
             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.
-        Model.fromJSON = function (json) {
-            var _this = this;
+        static fromJSON(json) {
             if (Array.isArray(json)) {
-                return json.map(function (init) { return _this.fromJSON(init); });
+                return json.map(init => this.fromJSON(init));
             }
-            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];
+            const instance = modelInstanceCreator(clazz, json);
+            const modelValidator = validateModelFields(modelDefinition);
+            Object.entries(instance).forEach(([k, v]) => {
                 modelValidator(k, v);
             });
             return attached(instance, ModelAttachment.DataStore);
-        };
-        return Model;
-    }());
+        }
+    };
     clazz[immerable] = true;
     Object.defineProperty(clazz, 'name', { value: modelDefinition.name });
     // Add getters/setters for relationship fields.
     //  getter - for lazy loading
     //  setter - for FK management
-    var allModelRelationships = ModelRelationship.allFrom({
+    const allModelRelationships = ModelRelationship.allFrom({
         builder: clazz,
         schema: modelDefinition,
         pkField: extractPrimaryKeyFieldNames(modelDefinition),
     });
-    var _loop_1 = function (relationship) {
-        var field = relationship.field;
+    for (const relationship of allModelRelationships) {
+        const field = relationship.field;
         Object.defineProperty(clazz.prototype, modelDefinition.fields[field].name, {
-            set: function (model) {
+            set(model) {
                 if (!(typeof model === 'object' || typeof model === 'undefined'))
                     return;
                 // if model is undefined or null, the connection should be removed
@@ -715,38 +659,38 @@ var createModelClass = function (modelDefinition) {
                     // 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 || {})
+                        const 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 });
+                            const msg = `Value passed to ${modelDefinition.name}.${field} is not a valid instance of a model`;
+                            logger.error(msg, { 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 });
+                            const msg = `Value passed to ${modelDefinition.name}.${field} is not an instance of ${relationship.remoteModelConstructor.name}`;
+                            logger.error(msg, { model });
                             throw new Error(msg);
                         }
                     }
                 }
                 // if the relationship can be managed automagically, set the FK's
                 if (relationship.isComplete) {
-                    for (var i = 0; i < relationship.localJoinFields.length; i++) {
-                        this[relationship.localJoinFields[i]] = model === null || model === void 0 ? void 0 : model[relationship.remoteJoinFields[i]];
+                    for (let i = 0; i < relationship.localJoinFields.length; i++) {
+                        this[relationship.localJoinFields[i]] =
+                            model?.[relationship.remoteJoinFields[i]];
                     }
-                    var instanceMemos = modelInstanceAssociationsMap.has(this)
+                    const instanceMemos = modelInstanceAssociationsMap.has(this)
                         ? modelInstanceAssociationsMap.get(this)
                         : modelInstanceAssociationsMap.set(this, {}).get(this);
                     instanceMemos[field] = model || undefined;
                 }
             },
-            get: function () {
-                var _this = this;
+            get() {
                 /**
                  * Bucket for holding related models instances specific to `this` instance.
                  */
-                var instanceMemos = modelInstanceAssociationsMap.has(this)
+                const instanceMemos = modelInstanceAssociationsMap.has(this)
                     ? modelInstanceAssociationsMap.get(this)
                     : modelInstanceAssociationsMap.set(this, {}).get(this);
                 // if the memos already has a result for this field, we'll use it.
@@ -760,14 +704,12 @@ var createModelClass = function (modelDefinition) {
                         // of the relationship metadata, we DO NOT AWAIT resolution. we want to
                         // drop the promise into the memo's synchronously, eliminating the chance
                         // for a race.
-                        var resultPromise = instance.query(relationship.remoteModelConstructor, function (base) {
-                            return base.and(function (q) {
-                                return relationship.remoteJoinFields.map(function (field, index) {
-                                    // TODO: anything we can use instead of `any` here?
-                                    return q[field].eq(_this[relationship.localJoinFields[index]]);
-                                });
+                        const resultPromise = instance.query(relationship.remoteModelConstructor, base => base.and(q => {
+                            return relationship.remoteJoinFields.map((field, index) => {
+                                // TODO: anything we can use instead of `any` here?
+                                return q[field].eq(this[relationship.localJoinFields[index]]);
                             });
-                        });
+                        }));
                         // results in hand, how we return them to the caller depends on the relationship type.
                         if (relationship.type === 'HAS_MANY') {
                             // collections should support async iteration, even though we don't
@@ -778,10 +720,13 @@ var createModelClass = function (modelDefinition) {
                             // non-collections should only ever return 1 value *or nothing*.
                             // if we have more than 1 record, something's amiss. it's not our job
                             // pick a result for the customer. it's our job to say "something's wrong."
-                            instanceMemos[field] = resultPromise.then(function (rows) {
+                            instanceMemos[field] = resultPromise.then(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");
+                                    const err = new Error(`
+									Data integrity error.
+									Too many records found for a HAS_ONE/BELONGS_TO field '${modelDefinition.name}.${field}'
+								`);
                                     console.error(err);
                                     throw err;
                                 }
@@ -806,40 +751,21 @@ var createModelClass = function (modelDefinition) {
                 return instanceMemos[field];
             },
         });
-    };
-    try {
-        for (var allModelRelationships_1 = __values(allModelRelationships), allModelRelationships_1_1 = allModelRelationships_1.next(); !allModelRelationships_1_1.done; allModelRelationships_1_1 = allModelRelationships_1.next()) {
-            var relationship = allModelRelationships_1_1.value;
-            _loop_1(relationship);
-        }
-    }
-    catch (e_5_1) { e_5 = { error: e_5_1 }; }
-    finally {
-        try {
-            if (allModelRelationships_1_1 && !allModelRelationships_1_1.done && (_a = allModelRelationships_1.return)) _a.call(allModelRelationships_1);
-        }
-        finally { if (e_5) throw e_5.error; }
     }
     return clazz;
 };
 /**
  * An eventually loaded related model instance.
  */
-var AsyncItem = /** @class */ (function (_super) {
-    __extends(AsyncItem, _super);
-    function AsyncItem() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    return AsyncItem;
-}(Promise));
-export { AsyncItem };
+export class AsyncItem extends Promise {
+}
 /**
  * A collection of related model instances.
  *
  * This collection can be async-iterated or turned directly into an array using `toArray()`.
  */
-var AsyncCollection = /** @class */ (function () {
-    function AsyncCollection(values) {
+export class AsyncCollection {
+    constructor(values) {
         this.values = values;
     }
     /**
@@ -853,39 +779,28 @@ var AsyncCollection = /** @class */ (function () {
      *
      * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/for-await...of
      */
-    AsyncCollection.prototype[Symbol.asyncIterator] = function () {
-        var _this = this;
-        var values;
-        var index = 0;
+    [Symbol.asyncIterator]() {
+        let values;
+        let index = 0;
         return {
-            next: function () { return __awaiter(_this, void 0, void 0, function () {
-                var result;
-                return __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,
-                                }];
-                    }
-                });
-            }); },
+            next: async () => {
+                if (!values)
+                    values = await this.values;
+                if (index < values.length) {
+                    const result = {
+                        value: values[index],
+                        done: false,
+                    };
+                    index++;
+                    return result;
+                }
+                return {
+                    value: null,
+                    done: true,
+                };
+            },
         };
-    };
+    }
     /**
      * Turns the collection into an array, up to the amount specified in `max` param.
      *
@@ -894,90 +809,50 @@ var AsyncCollection = /** @class */ (function () {
      * const first100 = await collection.toArray({max: 100});
      * ```
      */
-    AsyncCollection.prototype.toArray = function (_a) {
-        var _b = (_a === void 0 ? {} : _a).max, max = _b === void 0 ? Number.MAX_SAFE_INTEGER : _b;
-        var e_6, _c;
-        return __awaiter(this, void 0, void 0, function () {
-            var output, i, _d, _e, element, e_6_1;
-            return __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 = __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_6_1 = _f.sent();
-                        e_6 = { error: e_6_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_6) throw e_6.error;
-                        return [7 /*endfinally*/];
-                    case 11: return [7 /*endfinally*/];
-                    case 12: return [2 /*return*/, output];
-                }
-            });
-        });
-    };
-    return AsyncCollection;
-}());
-export { AsyncCollection };
-var checkReadOnlyPropertyOnCreate = function (draft, modelDefinition) {
-    var modelKeys = Object.keys(draft);
-    var fields = modelDefinition.fields;
-    modelKeys.forEach(function (key) {
+    async toArray({ max = Number.MAX_SAFE_INTEGER, } = {}) {
+        const output = [];
+        let i = 0;
+        for await (const element of this) {
+            if (i < max) {
+                output.push(element);
+                i++;
+            }
+            else {
+                break;
+            }
+        }
+        return output;
+    }
+}
+const checkReadOnlyPropertyOnCreate = (draft, modelDefinition) => {
+    const modelKeys = Object.keys(draft);
+    const { fields } = modelDefinition;
+    modelKeys.forEach(key => {
         if (fields[key] && fields[key].isReadOnly) {
-            throw new Error(key + " is read-only.");
+            throw new Error(`${key} is read-only.`);
         }
     });
 };
-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];
+const checkReadOnlyPropertyOnUpdate = (patches, modelDefinition) => {
+    const patchArray = patches.map(p => [p.path[0], p.value]);
+    const { fields } = modelDefinition;
+    patchArray.forEach(([key, val]) => {
         if (!val || !fields[key])
             return;
         if (fields[key].isReadOnly) {
-            throw new Error(key + " is read-only.");
+            throw new Error(`${key} is read-only.`);
         }
     });
 };
-var createNonModelClass = function (typeDefinition) {
-    var clazz = /** @class */ (function () {
-        function Model(init) {
-            var instance = produce(this, function (draft) {
+const createNonModelClass = (typeDefinition) => {
+    const clazz = class Model {
+        constructor(init) {
+            const instance = produce(this, (draft) => {
                 initializeInstance(init, typeDefinition, draft);
             });
             return instance;
         }
-        return Model;
-    }());
+    };
     clazz[immerable] = true;
     Object.defineProperty(clazz, 'name', { value: typeDefinition.name });
     registerNonModelClass(clazz);
@@ -987,15 +862,15 @@ function isQueryOne(obj) {
     return typeof obj === 'string';
 }
 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 }));
+    const { localModel, modelConstructor, remoteModel } = conflictData;
+    const { _version } = remoteModel;
+    return modelInstanceCreator(modelConstructor, { ...localModel, _version });
 }
 function defaultErrorHandler(error) {
     logger.warn(error);
 }
 function getModelConstructorByModelName(namespaceName, modelName) {
-    var result;
+    let result;
     switch (namespaceName) {
         case DATASTORE:
             result = dataStoreClasses[modelName];
@@ -1010,13 +885,13 @@ function getModelConstructorByModelName(namespaceName, modelName) {
             result = storageClasses[modelName];
             break;
         default:
-            throw new Error("Invalid namespace: " + namespaceName);
+            throw new Error(`Invalid namespace: ${namespaceName}`);
     }
     if (isValidModelConstructor(result)) {
         return result;
     }
     else {
-        var msg = "Model name is not valid for namespace. modelName: " + modelName + ", namespace: " + namespaceName;
+        const msg = `Model name is not valid for namespace. modelName: ${modelName}, namespace: ${namespaceName}`;
         logger.error(msg);
         throw new Error(msg);
     }
@@ -1033,54 +908,31 @@ function getModelConstructorByModelName(namespaceName, modelName) {
  * @param storage Storage adapter containing the metadata.
  * @param version The expected schema version.
  */
-function checkSchemaVersion(storage, version) {
-    return __awaiter(this, void 0, void 0, function () {
-        var Setting, modelDefinition;
-        var _this = this;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    Setting = dataStoreClasses.Setting;
-                    modelDefinition = schema.namespaces[DATASTORE].models.Setting;
-                    return [4 /*yield*/, storage.runExclusive(function (s) { return __awaiter(_this, void 0, void 0, function () {
-                            var _a, schemaVersionSetting, storedValue;
-                            return __generator(this, function (_b) {
-                                switch (_b.label) {
-                                    case 0: return [4 /*yield*/, s.query(Setting, ModelPredicateCreator.createFromAST(modelDefinition, {
-                                            and: { key: { eq: SETTING_SCHEMA_VERSION } },
-                                        }), { page: 0, limit: 1 })];
-                                    case 1:
-                                        _a = __read.apply(void 0, [_b.sent(), 1]), schemaVersionSetting = _a[0];
-                                        if (!(schemaVersionSetting !== undefined &&
-                                            schemaVersionSetting.value !== undefined)) return [3 /*break*/, 4];
-                                        storedValue = JSON.parse(schemaVersionSetting.value);
-                                        if (!(storedValue !== version)) return [3 /*break*/, 3];
-                                        return [4 /*yield*/, s.clear(false)];
-                                    case 2:
-                                        _b.sent();
-                                        _b.label = 3;
-                                    case 3: return [3 /*break*/, 6];
-                                    case 4: return [4 /*yield*/, s.save(modelInstanceCreator(Setting, {
-                                            key: SETTING_SCHEMA_VERSION,
-                                            value: JSON.stringify(version),
-                                        }))];
-                                    case 5:
-                                        _b.sent();
-                                        _b.label = 6;
-                                    case 6: return [2 /*return*/];
-                                }
-                            });
-                        }); })];
-                case 1:
-                    _a.sent();
-                    return [2 /*return*/];
+async function checkSchemaVersion(storage, version) {
+    const Setting = dataStoreClasses.Setting;
+    const modelDefinition = schema.namespaces[DATASTORE].models.Setting;
+    await storage.runExclusive(async (s) => {
+        const [schemaVersionSetting] = await s.query(Setting, ModelPredicateCreator.createFromAST(modelDefinition, {
+            and: { key: { eq: SETTING_SCHEMA_VERSION } },
+        }), { page: 0, limit: 1 });
+        if (schemaVersionSetting !== undefined &&
+            schemaVersionSetting.value !== undefined) {
+            const storedValue = JSON.parse(schemaVersionSetting.value);
+            if (storedValue !== version) {
+                await s.clear(false);
             }
-        });
+        }
+        else {
+            await s.save(modelInstanceCreator(Setting, {
+                key: SETTING_SCHEMA_VERSION,
+                value: JSON.stringify(version),
+            }));
+        }
     });
 }
-var syncSubscription;
+let syncSubscription;
 function getNamespace() {
-    var namespace = {
+    const namespace = {
         name: DATASTORE,
         relationships: {},
         enums: {},
@@ -1125,11 +977,9 @@ var DataStoreState;
 })(DataStoreState || (DataStoreState = {}));
 // TODO: How can we get rid of the non-null assertions?
 // https://github.com/aws-amplify/amplify-js/pull/10477/files#r1007363485
-var DataStore = /** @class */ (function () {
-    function DataStore() {
-        var _this = this;
+class DataStore {
+    constructor() {
         // reference to configured category instances. Used for preserving SSR context
-        this.Auth = Auth;
         this.InternalAPI = InternalAPI;
         this.Cache = Cache;
         // Non-null assertions (bang operator) have been added to most of these properties
@@ -1142,9 +992,7 @@ var DataStore = /** @class */ (function () {
         this.syncPredicates = new WeakMap();
         // object that gets passed to descendent classes. Allows us to pass these down by reference
         this.amplifyContext = {
-            Auth: this.Auth,
             InternalAPI: this.InternalAPI,
-            Cache: this.Cache,
         };
         /**
          * **IMPORTANT!**
@@ -1192,422 +1040,322 @@ var DataStore = /** @class */ (function () {
          * 3. If `this.amplifyConfig.aws_appsync_graphqlEndpoint` contains a URL,
          * attaches a sync engine, starts it, and subscribes.
          */
-        this.start = function () { return __awaiter(_this, void 0, void 0, function () {
-            var _this = this;
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.runningProcesses
-                        .add(function () { return __awaiter(_this, void 0, void 0, function () {
-                        var aws_appsync_graphqlEndpoint, _a, fullSyncIntervalInMilliseconds;
-                        var _this = this;
-                        return __generator(this, function (_b) {
-                            switch (_b.label) {
-                                case 0:
-                                    this.state = DataStoreState.Starting;
-                                    if (!(this.initialized === undefined)) return [3 /*break*/, 1];
-                                    logger.debug('Starting DataStore');
-                                    this.initialized = new Promise(function (res, rej) {
-                                        _this.initResolve = res;
-                                        _this.initReject = rej;
-                                    });
-                                    return [3 /*break*/, 3];
-                                case 1: return [4 /*yield*/, this.initialized];
-                                case 2:
-                                    _b.sent();
-                                    return [2 /*return*/];
-                                case 3:
-                                    this.storage = new Storage(schema, namespaceResolver, getModelConstructorByModelName, modelInstanceCreator, this.storageAdapter, this.sessionId);
-                                    return [4 /*yield*/, this.storage.init()];
-                                case 4:
-                                    _b.sent();
-                                    checkSchemaInitialized();
-                                    return [4 /*yield*/, checkSchemaVersion(this.storage, schema.version)];
-                                case 5:
-                                    _b.sent();
-                                    aws_appsync_graphqlEndpoint = this.amplifyConfig.aws_appsync_graphqlEndpoint;
-                                    if (!aws_appsync_graphqlEndpoint) return [3 /*break*/, 7];
-                                    logger.debug('GraphQL endpoint available', aws_appsync_graphqlEndpoint);
-                                    _a = this;
-                                    return [4 /*yield*/, this.processSyncExpressions()];
-                                case 6:
-                                    _a.syncPredicates = _b.sent();
-                                    this.sync = new SyncEngine(schema, namespaceResolver, syncClasses, userClasses, this.storage, modelInstanceCreator, this.conflictHandler, this.errorHandler, this.syncPredicates, this.amplifyConfig, this.authModeStrategy, this.amplifyContext, this.connectivityMonitor);
-                                    fullSyncIntervalInMilliseconds = this.fullSyncInterval * 1000 * 60;
-                                    syncSubscription = this.sync
-                                        .start({ fullSyncInterval: fullSyncIntervalInMilliseconds })
-                                        .subscribe({
-                                        next: function (_a) {
-                                            var type = _a.type, data = _a.data;
-                                            // In Node, we need to wait for queries to be synced to prevent returning empty arrays.
-                                            // In the Browser, we can begin returning data once subscriptions are in place.
-                                            var readyType = isNode
-                                                ? ControlMessage.SYNC_ENGINE_SYNC_QUERIES_READY
-                                                : ControlMessage.SYNC_ENGINE_STORAGE_SUBSCRIBED;
-                                            if (type === readyType) {
-                                                _this.initResolve();
-                                            }
-                                            Hub.dispatch('datastore', {
-                                                event: type,
-                                                data: data,
-                                            });
-                                        },
-                                        error: function (err) {
-                                            logger.warn('Sync error', err);
-                                            _this.initReject();
-                                        },
-                                    });
-                                    return [3 /*break*/, 8];
-                                case 7:
-                                    logger.warn("Data won't be synchronized. No GraphQL endpoint configured. Did you forget `Amplify.configure(awsconfig)`?", {
-                                        config: this.amplifyConfig,
-                                    });
-                                    this.initResolve();
-                                    _b.label = 8;
-                                case 8: return [4 /*yield*/, this.initialized];
-                                case 9:
-                                    _b.sent();
-                                    this.state = DataStoreState.Running;
-                                    return [2 /*return*/];
-                            }
-                        });
-                    }); }, 'datastore start')
-                        .catch(this.handleAddProcError('DataStore.start()'))];
-            });
-        }); };
-        this.query = function (modelConstructor, identifierOrCriteria, paginationProducer) { return __awaiter(_this, void 0, void 0, function () {
-            var _this = this;
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.runningProcesses
-                        .add(function () { return __awaiter(_this, void 0, void 0, function () {
-                        var result, msg, modelDefinition, pagination, keyFields, msg, predicate, predicate, seedPredicate, predicate, returnOne;
-                        var _a;
-                        var _b;
-                        return __generator(this, function (_c) {
-                            switch (_c.label) {
-                                case 0: return [4 /*yield*/, this.start()];
-                                case 1:
-                                    _c.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';
-                                        logger.error(msg, { modelConstructor: modelConstructor });
-                                        throw new Error(msg);
-                                    }
-                                    if (typeof identifierOrCriteria === 'string') {
-                                        if (paginationProducer !== undefined) {
-                                            logger.warn('Pagination is ignored when querying by id');
-                                        }
-                                    }
-                                    modelDefinition = getModelDefinition(modelConstructor);
-                                    if (!modelDefinition) {
-                                        throw new Error('Invalid model definition provided!');
-                                    }
-                                    pagination = this.processPagination(modelDefinition, paginationProducer);
-                                    keyFields = extractPrimaryKeyFieldNames(modelDefinition);
-                                    if (!isQueryOne(identifierOrCriteria)) return [3 /*break*/, 3];
-                                    if (keyFields.length > 1) {
-                                        msg = errorMessages.queryByPkWithCompositeKeyPresent;
-                                        logger.error(msg, { keyFields: keyFields });
-                                        throw new Error(msg);
-                                    }
-                                    predicate = ModelPredicateCreator.createFromFlatEqualities(modelDefinition, (_a = {}, _a[keyFields[0]] = identifierOrCriteria, _a));
-                                    return [4 /*yield*/, this.storage.query(modelConstructor, predicate, pagination)];
-                                case 2:
-                                    result = _c.sent();
-                                    return [3 /*break*/, 9];
-                                case 3:
-                                    if (!isIdentifierObject(identifierOrCriteria, modelDefinition)) return [3 /*break*/, 5];
-                                    predicate = ModelPredicateCreator.createForPk(modelDefinition, identifierOrCriteria);
-                                    return [4 /*yield*/, this.storage.query(modelConstructor, predicate, pagination)];
-                                case 4:
-                                    result = _c.sent();
-                                    return [3 /*break*/, 9];
-                                case 5:
-                                    if (!(!identifierOrCriteria ||
-                                        isPredicatesAll(identifierOrCriteria))) return [3 /*break*/, 7];
-                                    return [4 /*yield*/, ((_b = this.storage) === null || _b === void 0 ? void 0 : _b.query(modelConstructor, undefined, pagination))];
-                                case 6:
-                                    result = _c.sent();
-                                    return [3 /*break*/, 9];
-                                case 7:
-                                    seedPredicate = recursivePredicateFor({
-                                        builder: modelConstructor,
-                                        schema: modelDefinition,
-                                        pkField: extractPrimaryKeyFieldNames(modelDefinition),
-                                    });
-                                    predicate = internals(identifierOrCriteria(seedPredicate));
-                                    return [4 /*yield*/, predicate.fetch(this.storage)];
-                                case 8:
-                                    result = (_c.sent());
-                                    result = inMemoryPagination(result, pagination);
-                                    _c.label = 9;
-                                case 9:
-                                    returnOne = isQueryOne(identifierOrCriteria) ||
-                                        isIdentifierObject(identifierOrCriteria, modelDefinition);
-                                    return [2 /*return*/, attached(returnOne ? result[0] : result, ModelAttachment.DataStore)];
+        this.start = async () => {
+            return this.runningProcesses
+                .add(async () => {
+                this.state = DataStoreState.Starting;
+                if (this.initialized === undefined) {
+                    logger.debug('Starting DataStore');
+                    this.initialized = new Promise((res, rej) => {
+                        this.initResolve = res;
+                        this.initReject = rej;
+                    });
+                }
+                else {
+                    await this.initialized;
+                    return;
+                }
+                this.storage = new Storage(schema, namespaceResolver, getModelConstructorByModelName, modelInstanceCreator, this.storageAdapter, this.sessionId);
+                await this.storage.init();
+                checkSchemaInitialized();
+                await checkSchemaVersion(this.storage, schema.version);
+                const { aws_appsync_graphqlEndpoint } = this.amplifyConfig;
+                if (aws_appsync_graphqlEndpoint) {
+                    logger.debug('GraphQL endpoint available', aws_appsync_graphqlEndpoint);
+                    this.syncPredicates = await this.processSyncExpressions();
+                    this.sync = new SyncEngine(schema, namespaceResolver, syncClasses, userClasses, this.storage, modelInstanceCreator, this.conflictHandler, this.errorHandler, this.syncPredicates, this.amplifyConfig, this.authModeStrategy, this.amplifyContext, this.connectivityMonitor);
+                    const fullSyncIntervalInMilliseconds = this.fullSyncInterval * 1000 * 60; // fullSyncInterval from param is in minutes
+                    syncSubscription = this.sync
+                        .start({ fullSyncInterval: fullSyncIntervalInMilliseconds })
+                        .subscribe({
+                        next: ({ type, data }) => {
+                            // In the Browser, we can begin returning data once subscriptions are in place.
+                            const readyType = isBrowser()
+                                ? ControlMessage.SYNC_ENGINE_STORAGE_SUBSCRIBED
+                                : ControlMessage.SYNC_ENGINE_SYNC_QUERIES_READY;
+                            if (type === readyType) {
+                                this.initResolve();
                             }
+                            Hub.dispatch('datastore', {
+                                event: type,
+                                data,
+                            });
+                        },
+                        error: err => {
+                            logger.warn('Sync error', err);
+                            this.initReject();
+                        },
+                    });
+                }
+                else {
+                    logger.warn("Data won't be synchronized. No GraphQL endpoint configured. Did you forget `Amplify.configure(awsconfig)`?", {
+                        config: this.amplifyConfig,
+                    });
+                    this.initResolve();
+                }
+                await this.initialized;
+                this.state = DataStoreState.Running;
+            }, 'datastore start')
+                .catch(this.handleAddProcError('DataStore.start()'));
+        };
+        this.query = async (modelConstructor, identifierOrCriteria, paginationProducer) => {
+            return this.runningProcesses
+                .add(async () => {
+                await this.start();
+                let result;
+                if (!this.storage) {
+                    throw new Error('No storage to query');
+                }
+                //#region Input validation
+                if (!isValidModelConstructor(modelConstructor)) {
+                    const msg = 'Constructor is not for a valid model';
+                    logger.error(msg, { modelConstructor });
+                    throw new Error(msg);
+                }
+                if (typeof identifierOrCriteria === 'string') {
+                    if (paginationProducer !== undefined) {
+                        logger.warn('Pagination is ignored when querying by id');
+                    }
+                }
+                const modelDefinition = getModelDefinition(modelConstructor);
+                if (!modelDefinition) {
+                    throw new Error('Invalid model definition provided!');
+                }
+                const pagination = this.processPagination(modelDefinition, paginationProducer);
+                const keyFields = extractPrimaryKeyFieldNames(modelDefinition);
+                if (isQueryOne(identifierOrCriteria)) {
+                    if (keyFields.length > 1) {
+                        const msg = errorMessages.queryByPkWithCompositeKeyPresent;
+                        logger.error(msg, { keyFields });
+                        throw new Error(msg);
+                    }
+                    const predicate = ModelPredicateCreator.createFromFlatEqualities(modelDefinition, { [keyFields[0]]: identifierOrCriteria });
+                    result = await this.storage.query(modelConstructor, predicate, pagination);
+                }
+                else {
+                    // Object is being queried using object literal syntax
+                    if (isIdentifierObject(identifierOrCriteria, modelDefinition)) {
+                        const predicate = ModelPredicateCreator.createForPk(modelDefinition, identifierOrCriteria);
+                        result = await this.storage.query(modelConstructor, predicate, pagination);
+                    }
+                    else if (!identifierOrCriteria ||
+                        isPredicatesAll(identifierOrCriteria)) {
+                        result = await this.storage?.query(modelConstructor, undefined, pagination);
+                    }
+                    else {
+                        const seedPredicate = recursivePredicateFor({
+                            builder: modelConstructor,
+                            schema: modelDefinition,
+                            pkField: extractPrimaryKeyFieldNames(modelDefinition),
                         });
-                    }); }, 'datastore query')
-                        .catch(this.handleAddProcError('DataStore.query()'))];
-            });
-        }); };
-        this.save = function (model, condition) { return __awaiter(_this, void 0, void 0, function () {
-            var _this = this;
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.runningProcesses
-                        .add(function () { return __awaiter(_this, void 0, void 0, function () {
-                        var updatedPatchesTuple, initPatchesTuple, patchesTuple, modelConstructor, msg, modelDefinition, modelMeta, producedCondition, _a, savedModel;
-                        var _this = this;
-                        return __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');
-                                    }
-                                    updatedPatchesTuple = modelPatchesMap.get(model);
-                                    initPatchesTuple = initPatches.has(model)
-                                        ? [initPatches.get(model), {}]
-                                        : undefined;
-                                    patchesTuple = updatedPatchesTuple || initPatchesTuple;
-                                    modelConstructor = model ? model.constructor : undefined;
-                                    if (!isValidModelConstructor(modelConstructor)) {
-                                        msg = 'Object is not an instance of a valid model';
-                                        logger.error(msg, { model: model });
-                                        throw new Error(msg);
-                                    }
-                                    modelDefinition = getModelDefinition(modelConstructor);
-                                    if (!modelDefinition) {
-                                        throw new Error('Model Definition could not be found for model');
-                                    }
-                                    modelMeta = {
-                                        builder: modelConstructor,
-                                        schema: modelDefinition,
-                                        pkField: extractPrimaryKeyFieldNames(modelDefinition),
-                                    };
-                                    return [4 /*yield*/, this.storage.runExclusive(function (s) { return __awaiter(_this, void 0, void 0, function () {
-                                            var nonHasManyRelationships, nonHasManyRelationships_1, nonHasManyRelationships_1_1, relationship, queryObject, related, e_7_1;
-                                            var e_7, _a;
-                                            var _b;
-                                            return __generator(this, function (_c) {
-                                                switch (_c.label) {
-                                                    case 0:
-                                                        nonHasManyRelationships = 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 = __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, 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_7_1 = _c.sent();
-                                                        e_7 = { error: e_7_1 };
-                                                        return [3 /*break*/, 8];
-                                                    case 7:
-                                                        try {
-                                                            if (nonHasManyRelationships_1_1 && !nonHasManyRelationships_1_1.done && (_a = nonHasManyRelationships_1.return)) _a.call(nonHasManyRelationships_1);
-                                                        }
-                                                        finally { if (e_7) throw e_7.error; }
-                                                        return [7 /*endfinally*/];
-                                                    case 8: return [2 /*return*/];
-                                                }
-                                            });
-                                        }); })];
-                                case 2:
-                                    _b.sent();
-                                    producedCondition = condition
-                                        ? internals(condition(predicateFor(modelMeta))).toStoragePredicate()
-                                        : undefined;
-                                    return [4 /*yield*/, this.storage.runExclusive(function (s) { return __awaiter(_this, void 0, void 0, function () {
-                                            var saved;
-                                            return __generator(this, function (_a) {
-                                                switch (_a.label) {
-                                                    case 0: return [4 /*yield*/, s.save(model, producedCondition, undefined, patchesTuple)];
-                                                    case 1:
-                                                        saved = _a.sent();
-                                                        return [2 /*return*/, s.query(modelConstructor, ModelPredicateCreator.createForPk(modelDefinition, model))];
-                                                }
-                                            });
-                                        }); })];
-                                case 3:
-                                    _a = __read.apply(void 0, [_b.sent(), 1]), savedModel = _a[0];
-                                    return [2 /*return*/, attached(savedModel, ModelAttachment.DataStore)];
+                        const predicate = internals(identifierOrCriteria(seedPredicate));
+                        result = (await predicate.fetch(this.storage));
+                        result = inMemoryPagination(result, pagination);
+                    }
+                }
+                //#endregion
+                const returnOne = isQueryOne(identifierOrCriteria) ||
+                    isIdentifierObject(identifierOrCriteria, modelDefinition);
+                return attached(returnOne ? result[0] : result, ModelAttachment.DataStore);
+            }, 'datastore query')
+                .catch(this.handleAddProcError('DataStore.query()'));
+        };
+        this.save = async (model, condition) => {
+            return this.runningProcesses
+                .add(async () => {
+                await this.start();
+                if (!this.storage) {
+                    throw new Error('No storage to save to');
+                }
+                // Immer patches for constructing a correct update mutation input
+                // Allows us to only include changed fields for updates
+                const updatedPatchesTuple = modelPatchesMap.get(model);
+                // Immer patches for initial object construction. These are used if
+                // there are no `update` patches under the assumption we're performing
+                // a CREATE and wish to send only explicitly specified fields to the cloud.
+                const initPatchesTuple = initPatches.has(model)
+                    ? [initPatches.get(model), {}]
+                    : undefined;
+                // favor update patches over init/create patches, because init patches
+                // are ALWAYS present, whereas update patches are only present if copyOf
+                // was used to create the instance.
+                const patchesTuple = updatedPatchesTuple || initPatchesTuple;
+                const modelConstructor = model ? model.constructor : undefined;
+                if (!isValidModelConstructor(modelConstructor)) {
+                    const msg = 'Object is not an instance of a valid model';
+                    logger.error(msg, { model });
+                    throw new Error(msg);
+                }
+                const modelDefinition = getModelDefinition(modelConstructor);
+                if (!modelDefinition) {
+                    throw new Error('Model Definition could not be found for model');
+                }
+                const modelMeta = {
+                    builder: modelConstructor,
+                    schema: modelDefinition,
+                    pkField: extractPrimaryKeyFieldNames(modelDefinition),
+                };
+                await this.storage.runExclusive(async (s) => {
+                    // no enforcement for HAS_MANY on save, because the ~related~ entities
+                    // hold the FK in that case.
+                    const nonHasManyRelationships = ModelRelationship.allFrom(modelMeta).filter(r => r.type === 'BELONGS_TO');
+                    for (const relationship of nonHasManyRelationships) {
+                        const queryObject = relationship.createRemoteQueryObject(model);
+                        if (queryObject !== null) {
+                            const related = await s.query(relationship.remoteModelConstructor, ModelPredicateCreator.createFromFlatEqualities(relationship.remoteDefinition, queryObject));
+                            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`,
+                                    `"${relationship.remoteDefinition?.name}", you must save it independently first.`,
+                                ].join(' '));
                             }
-                        });
-                    }); }, 'datastore save')
-                        .catch(this.handleAddProcError('DataStore.save()'))];
-            });
-        }); };
-        this.setConflictHandler = function (config) {
-            var configDataStore = config.DataStore;
-            var conflictHandlerIsDefault = function () {
-                return _this.conflictHandler === defaultConflictHandler;
-            };
+                        }
+                    }
+                });
+                const producedCondition = condition
+                    ? internals(condition(predicateFor(modelMeta))).toStoragePredicate()
+                    : undefined;
+                const [savedModel] = await this.storage.runExclusive(async (s) => {
+                    const saved = await s.save(model, producedCondition, undefined, patchesTuple);
+                    return s.query(modelConstructor, ModelPredicateCreator.createForPk(modelDefinition, model));
+                });
+                return attached(savedModel, ModelAttachment.DataStore);
+            }, 'datastore save')
+                .catch(this.handleAddProcError('DataStore.save()'));
+        };
+        this.setConflictHandler = (config) => {
+            const { DataStore: configDataStore } = config;
+            const conflictHandlerIsDefault = () => this.conflictHandler === defaultConflictHandler;
             if (configDataStore && configDataStore.conflictHandler) {
                 return configDataStore.conflictHandler;
             }
             if (conflictHandlerIsDefault() && config.conflictHandler) {
                 return config.conflictHandler;
             }
-            return _this.conflictHandler || defaultConflictHandler;
+            return this.conflictHandler || defaultConflictHandler;
         };
-        this.setErrorHandler = function (config) {
-            var configDataStore = config.DataStore;
-            var errorHandlerIsDefault = function () {
-                return _this.errorHandler === defaultErrorHandler;
-            };
+        this.setErrorHandler = (config) => {
+            const { DataStore: configDataStore } = config;
+            const errorHandlerIsDefault = () => this.errorHandler === defaultErrorHandler;
             if (configDataStore && configDataStore.errorHandler) {
                 return configDataStore.errorHandler;
             }
             if (errorHandlerIsDefault() && config.errorHandler) {
                 return config.errorHandler;
             }
-            return _this.errorHandler || defaultErrorHandler;
+            return this.errorHandler || defaultErrorHandler;
         };
-        this.delete = function (modelOrConstructor, identifierOrCriteria) { return __awaiter(_this, void 0, void 0, function () {
-            var _this = this;
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.runningProcesses
-                        .add(function () { return __awaiter(_this, void 0, void 0, function () {
-                        var condition, msg, modelConstructor, msg, modelDefinition, keyFields, msg, msg, _a, deleted, model, modelConstructor, msg, modelDefinition, pkPredicate, msg, _b, _c, deleted;
-                        var _d;
-                        return __generator(this, function (_e) {
-                            switch (_e.label) {
-                                case 0: return [4 /*yield*/, this.start()];
-                                case 1:
-                                    _e.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 });
-                                        throw new Error(msg);
-                                    }
-                                    if (!isValidModelConstructor(modelOrConstructor)) return [3 /*break*/, 3];
-                                    modelConstructor = modelOrConstructor;
-                                    if (!identifierOrCriteria) {
-                                        msg = 'Id to delete or criteria required. Do you want to delete all? Pass Predicates.ALL';
-                                        logger.error(msg, { identifierOrCriteria: identifierOrCriteria });
-                                        throw new Error(msg);
-                                    }
-                                    modelDefinition = getModelDefinition(modelConstructor);
-                                    if (!modelDefinition) {
-                                        throw new Error('Could not find model definition for modelConstructor.');
-                                    }
-                                    if (typeof identifierOrCriteria === 'string') {
-                                        keyFields = extractPrimaryKeyFieldNames(modelDefinition);
-                                        if (keyFields.length > 1) {
-                                            msg = errorMessages.deleteByPkWithCompositeKeyPresent;
-                                            logger.error(msg, { keyFields: keyFields });
-                                            throw new Error(msg);
-                                        }
-                                        condition = ModelPredicateCreator.createFromFlatEqualities(modelDefinition, (_d = {}, _d[keyFields[0]] = identifierOrCriteria, _d));
-                                    }
-                                    else {
-                                        if (isIdentifierObject(identifierOrCriteria, modelDefinition)) {
-                                            condition = ModelPredicateCreator.createForPk(modelDefinition, identifierOrCriteria);
-                                        }
-                                        else {
-                                            condition = internals(identifierOrCriteria(predicateFor({
-                                                builder: modelConstructor,
-                                                schema: modelDefinition,
-                                                pkField: extractPrimaryKeyFieldNames(modelDefinition),
-                                            }))).toStoragePredicate();
-                                        }
-                                        if (!condition ||
-                                            !ModelPredicateCreator.isValidPredicate(condition)) {
-                                            msg = 'Criteria required. Do you want to delete all? Pass Predicates.ALL';
-                                            logger.error(msg, { condition: condition });
-                                            throw new Error(msg);
-                                        }
-                                    }
-                                    return [4 /*yield*/, this.storage.delete(modelConstructor, condition)];
-                                case 2:
-                                    _a = __read.apply(void 0, [_e.sent(), 1]), deleted = _a[0];
-                                    return [2 /*return*/, attached(deleted, ModelAttachment.DataStore)];
-                                case 3:
-                                    model = modelOrConstructor;
-                                    modelConstructor = Object.getPrototypeOf(model || {})
-                                        .constructor;
-                                    if (!isValidModelConstructor(modelConstructor)) {
-                                        msg = 'Object is not an instance of a valid model';
-                                        logger.error(msg, { model: model });
-                                        throw new Error(msg);
-                                    }
-                                    modelDefinition = getModelDefinition(modelConstructor);
-                                    if (!modelDefinition) {
-                                        throw new Error('Could not find model definition for modelConstructor.');
-                                    }
-                                    pkPredicate = ModelPredicateCreator.createForPk(modelDefinition, model);
-                                    if (identifierOrCriteria) {
-                                        if (typeof identifierOrCriteria !== 'function') {
-                                            msg = 'Invalid criteria';
-                                            logger.error(msg, { identifierOrCriteria: identifierOrCriteria });
-                                            throw new Error(msg);
-                                        }
-                                        condition = internals(identifierOrCriteria(predicateFor({
-                                            builder: modelConstructor,
-                                            schema: modelDefinition,
-                                            pkField: extractPrimaryKeyFieldNames(modelDefinition),
-                                        }))).toStoragePredicate();
-                                    }
-                                    else {
-                                        condition = pkPredicate;
-                                    }
-                                    return [4 /*yield*/, this.storage.delete(model, condition)];
-                                case 4:
-                                    _b = __read.apply(void 0, [_e.sent(), 1]), _c = __read(_b[0], 1), deleted = _c[0];
-                                    return [2 /*return*/, attached(deleted, ModelAttachment.DataStore)];
-                            }
-                        });
-                    }); }, 'datastore delete')
-                        .catch(this.handleAddProcError('DataStore.delete()'))];
-            });
-        }); };
-        this.observe = function (modelOrConstructor, identifierOrCriteria) {
-            var executivePredicate;
-            var modelConstructor = modelOrConstructor && isValidModelConstructor(modelOrConstructor)
+        this.delete = async (modelOrConstructor, identifierOrCriteria) => {
+            return this.runningProcesses
+                .add(async () => {
+                await this.start();
+                if (!this.storage) {
+                    throw new Error('No storage to delete from');
+                }
+                let condition;
+                if (!modelOrConstructor) {
+                    const msg = 'Model or Model Constructor required';
+                    logger.error(msg, { modelOrConstructor });
+                    throw new Error(msg);
+                }
+                if (isValidModelConstructor(modelOrConstructor)) {
+                    const modelConstructor = modelOrConstructor;
+                    if (!identifierOrCriteria) {
+                        const msg = 'Id to delete or criteria required. Do you want to delete all? Pass Predicates.ALL';
+                        logger.error(msg, { identifierOrCriteria });
+                        throw new Error(msg);
+                    }
+                    const modelDefinition = getModelDefinition(modelConstructor);
+                    if (!modelDefinition) {
+                        throw new Error('Could not find model definition for modelConstructor.');
+                    }
+                    if (typeof identifierOrCriteria === 'string') {
+                        const keyFields = extractPrimaryKeyFieldNames(modelDefinition);
+                        if (keyFields.length > 1) {
+                            const msg = errorMessages.deleteByPkWithCompositeKeyPresent;
+                            logger.error(msg, { keyFields });
+                            throw new Error(msg);
+                        }
+                        condition = ModelPredicateCreator.createFromFlatEqualities(modelDefinition, { [keyFields[0]]: identifierOrCriteria });
+                    }
+                    else {
+                        if (isIdentifierObject(identifierOrCriteria, modelDefinition)) {
+                            condition = ModelPredicateCreator.createForPk(modelDefinition, identifierOrCriteria);
+                        }
+                        else {
+                            condition = internals(identifierOrCriteria(predicateFor({
+                                builder: modelConstructor,
+                                schema: modelDefinition,
+                                pkField: extractPrimaryKeyFieldNames(modelDefinition),
+                            }))).toStoragePredicate();
+                        }
+                        if (!condition ||
+                            !ModelPredicateCreator.isValidPredicate(condition)) {
+                            const msg = 'Criteria required. Do you want to delete all? Pass Predicates.ALL';
+                            logger.error(msg, { condition });
+                            throw new Error(msg);
+                        }
+                    }
+                    const [deleted] = await this.storage.delete(modelConstructor, condition);
+                    return attached(deleted, ModelAttachment.DataStore);
+                }
+                else {
+                    const model = modelOrConstructor;
+                    const modelConstructor = Object.getPrototypeOf(model || {})
+                        .constructor;
+                    if (!isValidModelConstructor(modelConstructor)) {
+                        const msg = 'Object is not an instance of a valid model';
+                        logger.error(msg, { model });
+                        throw new Error(msg);
+                    }
+                    const modelDefinition = getModelDefinition(modelConstructor);
+                    if (!modelDefinition) {
+                        throw new Error('Could not find model definition for modelConstructor.');
+                    }
+                    const pkPredicate = ModelPredicateCreator.createForPk(modelDefinition, model);
+                    if (identifierOrCriteria) {
+                        if (typeof identifierOrCriteria !== 'function') {
+                            const msg = 'Invalid criteria';
+                            logger.error(msg, { identifierOrCriteria });
+                            throw new Error(msg);
+                        }
+                        condition = internals(identifierOrCriteria(predicateFor({
+                            builder: modelConstructor,
+                            schema: modelDefinition,
+                            pkField: extractPrimaryKeyFieldNames(modelDefinition),
+                        }))).toStoragePredicate();
+                    }
+                    else {
+                        condition = pkPredicate;
+                    }
+                    const [[deleted]] = await this.storage.delete(model, condition);
+                    return attached(deleted, ModelAttachment.DataStore);
+                }
+            }, 'datastore delete')
+                .catch(this.handleAddProcError('DataStore.delete()'));
+        };
+        this.observe = (modelOrConstructor, identifierOrCriteria) => {
+            let executivePredicate;
+            const modelConstructor = modelOrConstructor && isValidModelConstructor(modelOrConstructor)
                 ? modelOrConstructor
                 : undefined;
             if (modelOrConstructor && modelConstructor === undefined) {
-                var model = modelOrConstructor;
-                var modelConstructor_1 = model && Object.getPrototypeOf(model).constructor;
-                if (isValidModelConstructor(modelConstructor_1)) {
+                const model = modelOrConstructor;
+                const modelConstructor = model && Object.getPrototypeOf(model).constructor;
+                if (isValidModelConstructor(modelConstructor)) {
                     if (identifierOrCriteria) {
                         logger.warn('idOrCriteria is ignored when using a model instance', {
-                            model: model,
-                            identifierOrCriteria: identifierOrCriteria,
+                            model,
+                            identifierOrCriteria,
                         });
                     }
-                    return _this.observe(modelConstructor_1, model.id);
+                    return this.observe(modelConstructor, model.id);
                 }
                 else {
-                    var msg = 'The model is not an instance of a PersistentModelConstructor';
-                    logger.error(msg, { model: model });
+                    const msg = 'The model is not an instance of a PersistentModelConstructor';
+                    logger.error(msg, { model });
                     throw new Error(msg);
                 }
             }
@@ -1615,110 +1363,86 @@ var DataStore = /** @class */ (function () {
             if (identifierOrCriteria &&
                 modelConstructor &&
                 isIdentifierObject(identifierOrCriteria, getModelDefinition(modelConstructor))) {
-                var msg = errorMessages.observeWithObjectLiteral;
+                const msg = errorMessages.observeWithObjectLiteral;
                 logger.error(msg, { objectLiteral: identifierOrCriteria });
                 throw new Error(msg);
             }
             if (identifierOrCriteria !== undefined && modelConstructor === undefined) {
-                var msg = 'Cannot provide criteria without a modelConstructor';
+                const msg = 'Cannot provide criteria without a modelConstructor';
                 logger.error(msg, identifierOrCriteria);
                 throw new Error(msg);
             }
             if (modelConstructor && !isValidModelConstructor(modelConstructor)) {
-                var msg = 'Constructor is not for a valid model';
-                logger.error(msg, { modelConstructor: modelConstructor });
+                const msg = 'Constructor is not for a valid model';
+                logger.error(msg, { modelConstructor });
                 throw new Error(msg);
             }
             if (modelConstructor && typeof identifierOrCriteria === 'string') {
-                var buildIdPredicate = function (seed) { return seed.id.eq(identifierOrCriteria); };
+                const buildIdPredicate = seed => seed.id.eq(identifierOrCriteria);
                 executivePredicate = internals(buildIdPredicate(buildSeedPredicate(modelConstructor)));
             }
             else if (modelConstructor && typeof identifierOrCriteria === 'function') {
                 executivePredicate = internals(identifierOrCriteria(buildSeedPredicate(modelConstructor)));
             }
-            return new Observable(function (observer) {
-                var source;
-                _this.runningProcesses
-                    .add(function () { return __awaiter(_this, void 0, void 0, function () {
-                    var _this = this;
-                    return __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
-                                source = this.storage.observe(modelConstructor)
-                                    .filter(function (_a) {
-                                    var model = _a.model;
-                                    return namespaceResolver(model) === USER;
-                                })
-                                    .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, _a;
-                                                return __generator(this, function (_b) {
-                                                    switch (_b.label) {
-                                                        case 0:
-                                                            message = item;
-                                                            if (!(item.opType !== 'DELETE')) return [3 /*break*/, 2];
-                                                            modelDefinition = getModelDefinition(item.model);
-                                                            keyFields = extractPrimaryKeyFieldNames(modelDefinition);
-                                                            primaryKeysAndValues = extractPrimaryKeysAndValues(item.element, keyFields);
-                                                            return [4 /*yield*/, this.query(item.model, primaryKeysAndValues)];
-                                                        case 1:
-                                                            freshElement = _b.sent();
-                                                            message = __assign(__assign({}, message), { element: freshElement });
-                                                            _b.label = 2;
-                                                        case 2:
-                                                            _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*/];
-                                                    }
-                                                });
-                                            }); }, 'datastore observe message handler');
-                                    },
-                                    error: function (err) { return observer.error(err); },
-                                    complete: function () { return observer.complete(); },
-                                });
-                                return [2 /*return*/];
-                        }
+            return new Observable(observer => {
+                let source;
+                this.runningProcesses
+                    .add(async () => {
+                    await this.start();
+                    // Filter the events returned by Storage according to namespace,
+                    // append original element data, and subscribe to the observable
+                    source = this.storage.observe(modelConstructor)
+                        .pipe(filter(({ model }) => namespaceResolver(model) === USER))
+                        .subscribe({
+                        next: item => this.runningProcesses.isOpen &&
+                            this.runningProcesses.add(async () => {
+                                // the `element` doesn't necessarily contain all item details or
+                                // have related records attached consistently with that of a query()
+                                // result item. for consistency, we attach them here.
+                                let message = item;
+                                // as long as we're not dealing with a DELETE, we need to fetch a fresh
+                                // item from storage to ensure it's fully populated.
+                                if (item.opType !== 'DELETE') {
+                                    const modelDefinition = getModelDefinition(item.model);
+                                    const keyFields = extractPrimaryKeyFieldNames(modelDefinition);
+                                    const primaryKeysAndValues = extractPrimaryKeysAndValues(item.element, keyFields);
+                                    const freshElement = await this.query(item.model, primaryKeysAndValues);
+                                    message = {
+                                        ...message,
+                                        element: freshElement,
+                                    };
+                                }
+                                if (!executivePredicate ||
+                                    (await executivePredicate.matches(message.element))) {
+                                    observer.next(message);
+                                }
+                            }, 'datastore observe message handler'),
+                        error: err => observer.error(err),
+                        complete: () => observer.complete(),
                     });
-                }); }, 'datastore observe observable initialization')
-                    .catch(_this.handleAddProcError('DataStore.observe()'))
-                    .catch(function (error) {
+                }, 'datastore observe observable initialization')
+                    .catch(this.handleAddProcError('DataStore.observe()'))
+                    .catch(error => {
                     observer.error(error);
                 });
                 // 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 (source) {
-                            source.unsubscribe();
-                        }
-                        return [2 /*return*/];
-                    });
-                }); }, 'DataStore.observe() cleanup');
+                return this.runningProcesses.addCleaner(async () => {
+                    if (source) {
+                        source.unsubscribe();
+                    }
+                }, 'DataStore.observe() cleanup');
             });
         };
-        this.observeQuery = function (model, criteria, options) {
-            return new Observable(function (observer) {
-                var items = new Map();
-                var itemsChanged = new Map();
-                var deletedItemIds = [];
-                var handle;
+        this.observeQuery = (model, criteria, options) => {
+            return new Observable(observer => {
+                const items = new Map();
+                const itemsChanged = new Map();
+                let deletedItemIds = [];
+                let handle;
                 // let predicate: ModelPredicate<T> | undefined;
-                var executivePredicate;
+                let executivePredicate;
                 /**
                  * As the name suggests, this geneates a snapshot in the form of
                  * 	`{items: T[], isSynced: boolean}`
@@ -1729,20 +1453,20 @@ var DataStore = /** @class */ (function () {
                  *
                  * Refer to `generateSnapshot` and `emitSnapshot` for more details.
                  */
-                var generateAndEmitSnapshot = function () {
-                    var snapshot = generateSnapshot();
+                const generateAndEmitSnapshot = () => {
+                    const snapshot = generateSnapshot();
                     emitSnapshot(snapshot);
                 };
                 // a mechanism to return data after X amount of seconds OR after the
                 // "limit" (itemsChanged >= this.syncPageSize) has been reached, whichever comes first
-                var limitTimerRace = new DeferredCallbackResolver({
+                const limitTimerRace = new DeferredCallbackResolver({
                     callback: generateAndEmitSnapshot,
                     errorHandler: observer.error,
                     maxInterval: 2000,
                 });
-                var sort = (options || {}).sort;
-                var sortOptions = sort ? { sort: sort } : undefined;
-                var modelDefinition = getModelDefinition(model);
+                const { sort } = options || {};
+                const sortOptions = sort ? { sort } : undefined;
+                const modelDefinition = getModelDefinition(model);
                 if (!modelDefinition) {
                     throw new Error('Could not find model definition.');
                 }
@@ -1752,94 +1476,66 @@ var DataStore = /** @class */ (function () {
                 else if (isPredicatesAll(criteria)) {
                     executivePredicate = undefined;
                 }
-                _this.runningProcesses
-                    .add(function () { return __awaiter(_this, void 0, void 0, function () {
-                    var err_1;
-                    var _this = this;
-                    return __generator(this, function (_a) {
-                        switch (_a.label) {
-                            case 0:
-                                _a.trys.push([0, 2, , 3]);
-                                return [4 /*yield*/, this.query(model, criteria, sortOptions)];
-                            case 1:
-                                // first, query and return any locally-available records
-                                (_a.sent()).forEach(function (item) {
-                                    var itemModelDefinition = getModelDefinition(model);
-                                    var idOrPk = getIdentifierValue(itemModelDefinition, item);
-                                    items.set(idOrPk, item);
-                                });
-                                // Observe the model and send a stream of updates (debounced).
-                                // We need to post-filter results instead of passing criteria through
-                                // to have visibility into items that move from in-set to out-of-set.
-                                // 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;
-                                    return _this.runningProcesses.isOpen &&
-                                        _this.runningProcesses.add(function () { return __awaiter(_this, void 0, void 0, function () {
-                                            var itemModelDefinition, idOrPk, _a, isSynced, limit;
-                                            var _b, _c;
-                                            return __generator(this, function (_d) {
-                                                switch (_d.label) {
-                                                    case 0:
-                                                        itemModelDefinition = getModelDefinition(model);
-                                                        idOrPk = 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();
-                                return [3 /*break*/, 3];
-                            case 2:
-                                err_1 = _a.sent();
-                                observer.error(err_1);
-                                return [3 /*break*/, 3];
-                            case 3: return [2 /*return*/];
-                        }
-                    });
-                }); }, 'datastore observequery startup')
-                    .catch(_this.handleAddProcError('DataStore.observeQuery()'))
-                    .catch(function (error) {
+                this.runningProcesses
+                    .add(async () => {
+                    try {
+                        // first, query and return any locally-available records
+                        (await this.query(model, criteria, sortOptions)).forEach(item => {
+                            const itemModelDefinition = getModelDefinition(model);
+                            const idOrPk = getIdentifierValue(itemModelDefinition, item);
+                            items.set(idOrPk, item);
+                        });
+                        // Observe the model and send a stream of updates (debounced).
+                        // We need to post-filter results instead of passing criteria through
+                        // to have visibility into items that move from in-set to out-of-set.
+                        // We need to explicitly remove those items from the existing snapshot.
+                        handle = this.observe(model).subscribe(({ element, model, opType }) => this.runningProcesses.isOpen &&
+                            this.runningProcesses.add(async () => {
+                                const itemModelDefinition = getModelDefinition(model);
+                                const idOrPk = getIdentifierValue(itemModelDefinition, element);
+                                if (executivePredicate &&
+                                    !(await executivePredicate.matches(element))) {
+                                    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);
+                                }
+                                const isSynced = this.sync?.getModelSyncedStatus(model) ?? false;
+                                const limit = itemsChanged.size - deletedItemIds.length >=
+                                    this.syncPageSize;
+                                if (limit || isSynced) {
+                                    limitTimerRace.resolve();
+                                }
+                                // kicks off every subsequent race as results sync down
+                                limitTimerRace.start();
+                            }, 'handle observeQuery observed event'));
+                        // returns a set of initial/locally-available results
+                        generateAndEmitSnapshot();
+                    }
+                    catch (err) {
+                        observer.error(err);
+                    }
+                }, 'datastore observequery startup')
+                    .catch(this.handleAddProcError('DataStore.observeQuery()'))
+                    .catch(error => {
                     observer.error(error);
                 });
                 /**
@@ -1848,27 +1544,29 @@ var DataStore = /** @class */ (function () {
                  *
                  * SIDE EFFECT: The shared `items` collection is recreated.
                  */
-                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()));
+                const generateSnapshot = () => {
+                    const isSynced = this.sync?.getModelSyncedStatus(model) ?? false;
+                    const itemsArray = [
+                        ...Array.from(items.values()),
+                        ...Array.from(itemsChanged.values()),
+                    ];
                     items.clear();
-                    itemsArray.forEach(function (item) {
-                        var itemModelDefinition = getModelDefinition(model);
-                        var idOrPk = getIdentifierValue(itemModelDefinition, item);
+                    itemsArray.forEach(item => {
+                        const itemModelDefinition = getModelDefinition(model);
+                        const idOrPk = getIdentifierValue(itemModelDefinition, item);
                         items.set(idOrPk, item);
                     });
                     // remove deleted items from the final result set
-                    deletedItemIds.forEach(function (idOrPk) { return items.delete(idOrPk); });
-                    var snapshot = Array.from(items.values());
+                    deletedItemIds.forEach(idOrPk => items.delete(idOrPk));
+                    const snapshot = Array.from(items.values());
                     // we sort after we merge the snapshots (items, itemsChanged)
                     // otherwise, the merge may not
-                    if (options === null || options === void 0 ? void 0 : options.sort) {
+                    if (options?.sort) {
                         sortItems(snapshot);
                     }
                     return {
                         items: snapshot,
-                        isSynced: isSynced,
+                        isSynced,
                     };
                 };
                 /**
@@ -1879,7 +1577,7 @@ var DataStore = /** @class */ (function () {
                  *
                  * @param snapshot The generated items data to emit.
                  */
-                var emitSnapshot = function (snapshot) {
+                const emitSnapshot = (snapshot) => {
                     // send the generated snapshot to the primary subscription.
                     // NOTE: This observer's handler *could* be async ...
                     observer.next(snapshot);
@@ -1893,12 +1591,12 @@ var DataStore = /** @class */ (function () {
                  *
                  * @param itemsToSort A array of model type.
                  */
-                var sortItems = function (itemsToSort) {
-                    var modelDefinition = getModelDefinition(model);
-                    var pagination = _this.processPagination(modelDefinition, options);
-                    var sortPredicates = ModelSortPredicateCreator.getPredicates(pagination.sort);
+                const sortItems = (itemsToSort) => {
+                    const modelDefinition = getModelDefinition(model);
+                    const pagination = this.processPagination(modelDefinition, options);
+                    const sortPredicates = ModelSortPredicateCreator.getPredicates(pagination.sort);
                     if (sortPredicates.length) {
-                        var compareFn = sortCompareFunction(sortPredicates);
+                        const compareFn = sortCompareFunction(sortPredicates);
                         itemsToSort.sort(compareFn);
                     }
                 };
@@ -1910,87 +1608,90 @@ var DataStore = /** @class */ (function () {
                  *
                  * @param payload The payload from the Hub event.
                  */
-                var hubCallback = function (_a) {
-                    var payload = _a.payload;
-                    var _b;
-                    var event = payload.event, data = payload.data;
+                const hubCallback = ({ payload }) => {
+                    const { event, data } = payload;
                     if (event === ControlMessage.SYNC_ENGINE_MODEL_SYNCED &&
-                        ((_b = data === null || data === void 0 ? void 0 : data.model) === null || _b === void 0 ? void 0 : _b.name) === model.name) {
+                        data?.model?.name === model.name) {
                         generateAndEmitSnapshot();
-                        Hub.remove('datastore', hubCallback);
+                        hubRemove();
                     }
                 };
-                Hub.listen('datastore', hubCallback);
-                return _this.runningProcesses.addCleaner(function () { return __awaiter(_this, void 0, void 0, function () {
-                    return __generator(this, function (_a) {
-                        if (handle) {
-                            handle.unsubscribe();
-                        }
-                        return [2 /*return*/];
-                    });
-                }); }, 'datastore observequery cleaner');
+                const hubRemove = Hub.listen('datastore', hubCallback);
+                return this.runningProcesses.addCleaner(async () => {
+                    if (handle) {
+                        handle.unsubscribe();
+                    }
+                }, 'datastore observequery cleaner');
             });
         };
-        this.configure = function (config) {
-            if (config === void 0) { config = {}; }
-            _this.amplifyContext.Auth = _this.Auth;
-            _this.amplifyContext.InternalAPI = _this.InternalAPI;
-            _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);
-            _this.conflictHandler = _this.setConflictHandler(config);
-            _this.errorHandler = _this.setErrorHandler(config);
-            var authModeStrategyType = (configDataStore && configDataStore.authModeStrategyType) ||
+        this.configure = (config = {}) => {
+            this.amplifyContext.InternalAPI = this.InternalAPI;
+            const { DataStore: configDataStore, authModeStrategyType: configAuthModeStrategyType, conflictHandler: configConflictHandler, errorHandler: configErrorHandler, maxRecordsToSync: configMaxRecordsToSync, syncPageSize: configSyncPageSize, fullSyncInterval: configFullSyncInterval, syncExpressions: configSyncExpressions, authProviders: configAuthProviders, storageAdapter: configStorageAdapter, ...configFromAmplify } = config;
+            const currentAppSyncConfig = Amplify.getConfig().API?.GraphQL;
+            const appSyncConfig = {
+                aws_appsync_graphqlEndpoint: currentAppSyncConfig?.endpoint,
+                aws_appsync_authenticationType: currentAppSyncConfig?.defaultAuthMode,
+                aws_appsync_region: currentAppSyncConfig?.region,
+                aws_appsync_apiKey: currentAppSyncConfig?.apiKey,
+            };
+            this.amplifyConfig = {
+                ...this.amplifyConfig,
+                ...configFromAmplify,
+                ...(currentAppSyncConfig && appSyncConfig),
+            };
+            this.conflictHandler = this.setConflictHandler(config);
+            this.errorHandler = this.setErrorHandler(config);
+            const authModeStrategyType = (configDataStore && configDataStore.authModeStrategyType) ||
                 configAuthModeStrategyType ||
                 AuthModeStrategyType.DEFAULT;
             switch (authModeStrategyType) {
                 case AuthModeStrategyType.MULTI_AUTH:
-                    _this.authModeStrategy = multiAuthStrategy(_this.amplifyContext);
+                    this.authModeStrategy = multiAuthStrategy(this.amplifyContext);
                     break;
                 case AuthModeStrategyType.DEFAULT:
-                    _this.authModeStrategy = defaultAuthStrategy;
+                    this.authModeStrategy = defaultAuthStrategy;
                     break;
                 default:
-                    _this.authModeStrategy = defaultAuthStrategy;
+                    this.authModeStrategy = defaultAuthStrategy;
                     break;
             }
             // store on config object, so that Sync, Subscription, and Mutation processors can have access
-            _this.amplifyConfig.authProviders =
+            this.amplifyConfig.authProviders =
                 (configDataStore && configDataStore.authProviders) || configAuthProviders;
-            _this.syncExpressions =
+            this.syncExpressions =
                 (configDataStore && configDataStore.syncExpressions) ||
                     configSyncExpressions ||
-                    _this.syncExpressions;
-            _this.maxRecordsToSync =
+                    this.syncExpressions;
+            this.maxRecordsToSync =
                 (configDataStore && configDataStore.maxRecordsToSync) ||
                     configMaxRecordsToSync ||
-                    _this.maxRecordsToSync ||
+                    this.maxRecordsToSync ||
                     10000;
             // store on config object, so that Sync, Subscription, and Mutation processors can have access
-            _this.amplifyConfig.maxRecordsToSync = _this.maxRecordsToSync;
-            _this.syncPageSize =
+            this.amplifyConfig.maxRecordsToSync = this.maxRecordsToSync;
+            this.syncPageSize =
                 (configDataStore && configDataStore.syncPageSize) ||
                     configSyncPageSize ||
-                    _this.syncPageSize ||
+                    this.syncPageSize ||
                     1000;
             // store on config object, so that Sync, Subscription, and Mutation processors can have access
-            _this.amplifyConfig.syncPageSize = _this.syncPageSize;
-            _this.fullSyncInterval =
+            this.amplifyConfig.syncPageSize = this.syncPageSize;
+            this.fullSyncInterval =
                 (configDataStore && configDataStore.fullSyncInterval) ||
                     configFullSyncInterval ||
-                    _this.fullSyncInterval ||
+                    this.fullSyncInterval ||
                     24 * 60; // 1 day
-            _this.storageAdapter =
+            this.storageAdapter =
                 (configDataStore && configDataStore.storageAdapter) ||
                     configStorageAdapter ||
-                    _this.storageAdapter ||
+                    this.storageAdapter ||
                     undefined;
-            _this.sessionId = _this.retrieveSessionId();
+            this.sessionId = this.retrieveSessionId();
         };
     }
-    DataStore.prototype.getModuleName = function () {
+    getModuleName() {
         return 'DataStore';
-    };
+    }
     /**
      * Builds a function to capture `BackgroundManagerNotOpenError`'s to produce friendlier,
      * more instructive errors for customers.
@@ -1998,19 +1699,18 @@ var DataStore = /** @class */ (function () {
      * @param operation The name of the operation (usually a Datastore method) the customer
      * tried to call.
      */
-    DataStore.prototype.handleAddProcError = function (operation) {
-        var _this = this;
+    handleAddProcError(operation) {
         /**
          * If the tested error is a `BackgroundManagerNotOpenError`, it will be captured
          * and replaced with a friendlier message that instructs the App Developer.
          *
          * @param err An error to test.
          */
-        var handler = function (err) {
+        const handler = (err) => {
             if (err.message.startsWith('BackgroundManagerNotOpenError')) {
                 throw new Error([
-                    "DataStoreStateError: Tried to execute `" + operation + "` while DataStore was \"" + _this.state + "\".",
-                    "This can only be done while DataStore is \"Started\" or \"Stopped\". To remedy:",
+                    `DataStoreStateError: Tried to execute \`${operation}\` while DataStore was "${this.state}".`,
+                    `This can only be done while DataStore is "Started" or "Stopped". To remedy:`,
                     'Ensure all calls to `stop()` and `clear()` have completed first.',
                     'If this is not possible, retry the operation until it succeeds.',
                 ].join('\n'));
@@ -2020,7 +1720,7 @@ var DataStore = /** @class */ (function () {
             }
         };
         return handler;
-    };
+    }
     /**
      * Clears all data from storage and removes all data, schema info, other
      * initialization details, and then stops DataStore.
@@ -2029,83 +1729,49 @@ var DataStore = /** @class */ (function () {
      * by explicitiliy calling `start()` or any method that implicitly starts
      * DataStore, such as `query()`, `save()`, or `delete()`.
      */
-    DataStore.prototype.clear = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        checkSchemaInitialized();
-                        this.state = DataStoreState.Clearing;
-                        return [4 /*yield*/, this.runningProcesses.close()];
-                    case 1:
-                        _a.sent();
-                        if (!(this.storage === undefined)) return [3 /*break*/, 3];
-                        // connect to storage so that it can be cleared without fully starting DataStore
-                        this.storage = new Storage(schema, namespaceResolver, getModelConstructorByModelName, modelInstanceCreator, this.storageAdapter, this.sessionId);
-                        return [4 /*yield*/, this.storage.init()];
-                    case 2:
-                        _a.sent();
-                        _a.label = 3;
-                    case 3:
-                        if (syncSubscription && !syncSubscription.closed) {
-                            syncSubscription.unsubscribe();
-                        }
-                        if (!this.sync) return [3 /*break*/, 5];
-                        return [4 /*yield*/, this.sync.stop()];
-                    case 4:
-                        _a.sent();
-                        _a.label = 5;
-                    case 5: return [4 /*yield*/, this.storage.clear()];
-                    case 6:
-                        _a.sent();
-                        this.initialized = undefined; // Should re-initialize when start() is called.
-                        this.storage = undefined;
-                        this.sync = undefined;
-                        this.syncPredicates = new WeakMap();
-                        return [4 /*yield*/, this.runningProcesses.open()];
-                    case 7:
-                        _a.sent();
-                        this.state = DataStoreState.NotRunning;
-                        return [2 /*return*/];
-                }
-            });
-        });
-    };
+    async clear() {
+        checkSchemaInitialized();
+        this.state = DataStoreState.Clearing;
+        await this.runningProcesses.close();
+        if (this.storage === undefined) {
+            // connect to storage so that it can be cleared without fully starting DataStore
+            this.storage = new Storage(schema, namespaceResolver, getModelConstructorByModelName, modelInstanceCreator, this.storageAdapter, this.sessionId);
+            await this.storage.init();
+        }
+        if (syncSubscription && !syncSubscription.closed) {
+            syncSubscription.unsubscribe();
+        }
+        if (this.sync) {
+            await this.sync.stop();
+        }
+        await this.storage.clear();
+        this.initialized = undefined; // Should re-initialize when start() is called.
+        this.storage = undefined;
+        this.sync = undefined;
+        this.syncPredicates = new WeakMap();
+        await this.runningProcesses.open();
+        this.state = DataStoreState.NotRunning;
+    }
     /**
      * Stops all DataStore sync activities.
      *
      * TODO: "Waits for graceful termination of
      * running queries and terminates subscriptions."
      */
-    DataStore.prototype.stop = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        this.state = DataStoreState.Stopping;
-                        return [4 /*yield*/, this.runningProcesses.close()];
-                    case 1:
-                        _a.sent();
-                        if (syncSubscription && !syncSubscription.closed) {
-                            syncSubscription.unsubscribe();
-                        }
-                        if (!this.sync) return [3 /*break*/, 3];
-                        return [4 /*yield*/, this.sync.stop()];
-                    case 2:
-                        _a.sent();
-                        _a.label = 3;
-                    case 3:
-                        this.initialized = undefined; // Should re-initialize when start() is called.
-                        this.sync = undefined;
-                        return [4 /*yield*/, this.runningProcesses.open()];
-                    case 4:
-                        _a.sent();
-                        this.state = DataStoreState.NotRunning;
-                        return [2 /*return*/];
-                }
-            });
-        });
-    };
+    async stop() {
+        this.state = DataStoreState.Stopping;
+        await this.runningProcesses.close();
+        if (syncSubscription && !syncSubscription.closed) {
+            syncSubscription.unsubscribe();
+        }
+        if (this.sync) {
+            await this.sync.stop();
+        }
+        this.initialized = undefined; // Should re-initialize when start() is called.
+        this.sync = undefined;
+        await this.runningProcesses.open();
+        this.state = DataStoreState.NotRunning;
+    }
     /**
      * Validates given pagination input from a query and creates a pagination
      * argument for use against the storage layer.
@@ -2113,9 +1779,9 @@ var DataStore = /** @class */ (function () {
      * @param modelDefinition
      * @param paginationProducer
      */
-    DataStore.prototype.processPagination = function (modelDefinition, paginationProducer) {
-        var sortPredicate;
-        var _a = paginationProducer || {}, limit = _a.limit, page = _a.page, sort = _a.sort;
+    processPagination(modelDefinition, paginationProducer) {
+        let sortPredicate;
+        const { limit, page, sort } = paginationProducer || {};
         if (limit === undefined && page === undefined && sort === undefined) {
             return undefined;
         }
@@ -2142,83 +1808,55 @@ var DataStore = /** @class */ (function () {
             sortPredicate = ModelSortPredicateCreator.createFromExisting(modelDefinition, sort);
         }
         return {
-            limit: limit,
-            page: page,
+            limit,
+            page,
             sort: sortPredicate,
         };
-    };
+    }
     /**
      * Examines the configured `syncExpressions` and produces a WeakMap of
      * SchemaModel -> predicate to use during sync.
      */
-    DataStore.prototype.processSyncExpressions = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var syncPredicates;
-            var _this = this;
-            return __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 () {
-                                var _a, modelConstructor, conditionProducer, modelDefinition, condition, predicate;
-                                return __generator(this, function (_b) {
-                                    switch (_b.label) {
-                                        case 0: return [4 /*yield*/, syncExpression];
-                                        case 1:
-                                            _a = _b.sent(), modelConstructor = _a.modelConstructor, conditionProducer = _a.conditionProducer;
-                                            modelDefinition = getModelDefinition(modelConstructor);
-                                            return [4 /*yield*/, this.unwrapPromise(conditionProducer)];
-                                        case 2:
-                                            condition = _b.sent();
-                                            if (isPredicatesAll(condition)) {
-                                                return [2 /*return*/, [modelDefinition, null]];
-                                            }
-                                            predicate = internals(condition(predicateFor({
-                                                builder: modelConstructor,
-                                                schema: modelDefinition,
-                                                pkField: extractPrimaryKeyFieldNames(modelDefinition),
-                                            }))).toStoragePredicate();
-                                            return [2 /*return*/, [modelDefinition, predicate]];
-                                    }
-                                });
-                            }); }))];
-                    case 1:
-                        syncPredicates = _a.sent();
-                        return [2 /*return*/, this.weakMapFromEntries(syncPredicates)];
-                }
-            });
-        });
-    };
-    DataStore.prototype.unwrapPromise = function (conditionProducer) {
-        return __awaiter(this, void 0, void 0, function () {
-            var condition, error_1;
-            return __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 || conditionProducer];
-                    case 2:
-                        error_1 = _a.sent();
-                        if (error_1 instanceof TypeError) {
-                            return [2 /*return*/, conditionProducer];
-                        }
-                        throw error_1;
-                    case 3: return [2 /*return*/];
-                }
-            });
-        });
-    };
-    DataStore.prototype.weakMapFromEntries = function (entries) {
-        return entries.reduce(function (map, _a) {
-            var _b = __read(_a, 2), modelDefinition = _b[0], predicate = _b[1];
+    async processSyncExpressions() {
+        if (!this.syncExpressions || !this.syncExpressions.length) {
+            return new WeakMap();
+        }
+        const syncPredicates = await Promise.all(this.syncExpressions.map(async (syncExpression) => {
+            const { modelConstructor, conditionProducer } = await syncExpression;
+            const modelDefinition = getModelDefinition(modelConstructor);
+            // conditionProducer is either a predicate, e.g. (c) => c.field.eq(1)
+            // OR a function/promise that returns a predicate
+            const condition = await this.unwrapPromise(conditionProducer);
+            if (isPredicatesAll(condition)) {
+                return [modelDefinition, null];
+            }
+            const predicate = internals(condition(predicateFor({
+                builder: modelConstructor,
+                schema: modelDefinition,
+                pkField: extractPrimaryKeyFieldNames(modelDefinition),
+            }))).toStoragePredicate();
+            return [modelDefinition, predicate];
+        }));
+        return this.weakMapFromEntries(syncPredicates);
+    }
+    async unwrapPromise(conditionProducer) {
+        try {
+            const condition = await conditionProducer();
+            return condition || conditionProducer;
+        }
+        catch (error) {
+            if (error instanceof TypeError) {
+                return conditionProducer;
+            }
+            throw error;
+        }
+    }
+    weakMapFromEntries(entries) {
+        return entries.reduce((map, [modelDefinition, predicate]) => {
             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.");
+                const { name } = modelDefinition;
+                logger.warn(`You can only utilize one Sync Expression per model.
+          Subsequent sync expressions for the ${name} model will be ignored.`);
                 return map;
             }
             if (predicate) {
@@ -2226,27 +1864,30 @@ var DataStore = /** @class */ (function () {
             }
             return map;
         }, new WeakMap());
-    };
+    }
     /**
      * A session ID to allow CMS to open databases against multiple apps.
      * This session ID is only expected be set by AWS Amplify Studio.
      */
-    DataStore.prototype.retrieveSessionId = function () {
+    retrieveSessionId() {
         try {
-            var sessionId = sessionStorage.getItem('datastoreSessionId');
+            const sessionId = sessionStorage.getItem('datastoreSessionId');
             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];
-                return sessionId + "-" + appSyncId;
+                const { aws_appsync_graphqlEndpoint } = this.amplifyConfig;
+                const appSyncUrl = aws_appsync_graphqlEndpoint.split('/')[2];
+                const [appSyncId] = appSyncUrl.split('.');
+                return `${sessionId}-${appSyncId}`;
             }
         }
-        catch (_b) { }
+        catch { }
         return undefined;
-    };
-    return DataStore;
-}());
-var instance = new DataStore();
-Amplify.register(instance);
+    }
+}
+const instance = new DataStore();
+instance.configure({});
+Hub.listen('core', capsule => {
+    if (capsule.payload.event === 'configure') {
+        instance.configure({});
+    }
+});
 export { DataStore as DataStoreClass, initSchema, instance as DataStore };
-//# sourceMappingURL=datastore.js.map