@aws-amplify/datastore 5.0.1-api-v6-models.c1977f8.0 → 5.0.1-api-v6-models.891fe0d.0

package/lib-esm/storage/storage.js

@@ -1,88 +1,3 @@
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
-var __read = (this && this.__read) || function (o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-};
-var __values = (this && this.__values) || function(o) {
-    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
-    if (m) return m.call(o);
-    if (o && typeof o.length === "number") return {
-        next: function () {
-            if (o && i >= o.length) o = void 0;
-            return { value: o && o[i++], done: !o };
-        }
-    };
-    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
-};
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 import { filter, map, Subject } from 'rxjs';
@@ -93,9 +8,9 @@ import { getIdentifierValue } from '../sync/utils';
 import getDefaultAdapter from './adapter/getDefaultAdapter';
 import { Mutex } from '@aws-amplify/core/internals/utils';
 import { ConsoleLogger } from '@aws-amplify/core';
-var logger = new ConsoleLogger('DataStore');
-var StorageClass = /** @class */ (function () {
-    function StorageClass(schema, namespaceResolver, getModelConstructorByModelName, modelInstanceCreator, adapter, sessionId) {
+const logger = new ConsoleLogger('DataStore');
+class StorageClass {
+    constructor(schema, namespaceResolver, getModelConstructorByModelName, modelInstanceCreator, adapter, sessionId) {
         this.schema = schema;
         this.namespaceResolver = namespaceResolver;
         this.getModelConstructorByModelName = getModelConstructorByModelName;
@@ -105,8 +20,8 @@ var StorageClass = /** @class */ (function () {
         this.adapter = this.adapter || getDefaultAdapter();
         this.pushStream = new Subject();
     }
-    StorageClass.getNamespace = function () {
-        var namespace = {
+    static getNamespace() {
+        const namespace = {
             name: STORAGE,
             relationships: {},
             enums: {},
@@ -114,196 +29,138 @@ var StorageClass = /** @class */ (function () {
             nonModels: {},
         };
         return namespace;
-    };
-    StorageClass.prototype.init = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var resolve, reject;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (!(this.initialized !== undefined)) return [3 /*break*/, 2];
-                        return [4 /*yield*/, this.initialized];
-                    case 1:
-                        _a.sent();
-                        return [2 /*return*/];
-                    case 2:
-                        logger.debug('Starting Storage');
-                        this.initialized = new Promise(function (res, rej) {
-                            resolve = res;
-                            reject = rej;
-                        });
-                        this.adapter.setUp(this.schema, this.namespaceResolver, this.modelInstanceCreator, this.getModelConstructorByModelName, this.sessionId).then(resolve, reject);
-                        return [4 /*yield*/, this.initialized];
-                    case 3:
-                        _a.sent();
-                        return [2 /*return*/];
-                }
-            });
-        });
-    };
-    StorageClass.prototype.save = function (model, condition, mutator, patchesTuple) {
-        return __awaiter(this, void 0, void 0, function () {
-            var result;
-            var _this = this;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.init()];
-                    case 1:
-                        _a.sent();
-                        if (!this.adapter) {
-                            throw new Error('Storage adapter is missing');
-                        }
-                        return [4 /*yield*/, this.adapter.save(model, condition)];
-                    case 2:
-                        result = _a.sent();
-                        result.forEach(function (r) {
-                            var _a = __read(r, 2), savedElement = _a[0], opType = _a[1];
-                            // truthy when save is called by the Merger
-                            var syncResponse = !!mutator;
-                            var updateMutationInput;
-                            // don't attempt to calc mutation input when storage.save
-                            // is called by Merger, i.e., when processing an AppSync response
-                            if ((opType === OpType.UPDATE || opType === OpType.INSERT) &&
-                                !syncResponse) {
-                                //
-                                // TODO: LOOK!!!
-                                // the `model` used here is in effect regardless of what model
-                                // comes back from adapter.save().
-                                // Prior to fix, SQLite adapter had been returning two models
-                                // of different types, resulting in invalid outbox entries.
-                                //
-                                // the bug is essentially fixed in SQLite adapter.
-                                // leaving as-is, because it's currently unclear whether anything
-                                // depends on this remaining as-is.
-                                //
-                                updateMutationInput = _this.getChangedFieldsInput(model, savedElement, patchesTuple);
-                                // // an update without changed user fields
-                                // => don't create mutationEvent
-                                if (updateMutationInput === null) {
-                                    return result;
-                                }
-                            }
-                            var element = updateMutationInput || savedElement;
-                            var modelConstructor = Object.getPrototypeOf(savedElement)
-                                .constructor;
-                            _this.pushStream.next({
-                                model: modelConstructor,
-                                opType: opType,
-                                element: element,
-                                mutator: mutator,
-                                condition: (condition &&
-                                    ModelPredicateCreator.getPredicates(condition, false)) ||
-                                    null,
-                                savedElement: savedElement,
-                            });
-                        });
-                        return [2 /*return*/, result];
-                }
-            });
-        });
-    };
-    StorageClass.prototype.delete = function (modelOrModelConstructor, condition, mutator) {
-        return __awaiter(this, void 0, void 0, function () {
-            var models, deleted, modelConstructor, namespaceName, modelDefinition, modelIds;
-            var _a;
-            var _this = this;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0: return [4 /*yield*/, this.init()];
-                    case 1:
-                        _b.sent();
-                        if (!this.adapter) {
-                            throw new Error('Storage adapter is missing');
-                        }
-                        return [4 /*yield*/, this.adapter.delete(modelOrModelConstructor, condition)];
-                    case 2:
-                        _a = __read.apply(void 0, [_b.sent(), 2]), models = _a[0], deleted = _a[1];
-                        modelConstructor = isModelConstructor(modelOrModelConstructor)
-                            ? modelOrModelConstructor
-                            : Object.getPrototypeOf(modelOrModelConstructor || {})
-                                .constructor;
-                        namespaceName = this.namespaceResolver(modelConstructor);
-                        modelDefinition = this.schema.namespaces[namespaceName].models[modelConstructor.name];
-                        modelIds = new Set(models.map(function (model) {
-                            var modelId = getIdentifierValue(modelDefinition, model);
-                            return modelId;
-                        }));
-                        if (!isModelConstructor(modelOrModelConstructor) &&
-                            !Array.isArray(deleted)) {
-                            deleted = [deleted];
-                        }
-                        deleted.forEach(function (model) {
-                            var modelConstructor = Object.getPrototypeOf(model)
-                                .constructor;
-                            var theCondition;
-                            if (!isModelConstructor(modelOrModelConstructor)) {
-                                var modelId = getIdentifierValue(modelDefinition, model);
-                                theCondition = modelIds.has(modelId)
-                                    ? ModelPredicateCreator.getPredicates(condition, false)
-                                    : undefined;
-                            }
-                            _this.pushStream.next({
-                                model: modelConstructor,
-                                opType: OpType.DELETE,
-                                element: model,
-                                mutator: mutator,
-                                condition: theCondition || null,
-                            });
-                        });
-                        return [2 /*return*/, [models, deleted]];
-                }
-            });
+    }
+    async init() {
+        if (this.initialized !== undefined) {
+            await this.initialized;
+            return;
+        }
+        logger.debug('Starting Storage');
+        let resolve;
+        let reject;
+        this.initialized = new Promise((res, rej) => {
+            resolve = res;
+            reject = rej;
         });
-    };
-    StorageClass.prototype.query = function (modelConstructor, predicate, pagination) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.init()];
-                    case 1:
-                        _a.sent();
-                        if (!this.adapter) {
-                            throw new Error('Storage adapter is missing');
-                        }
-                        return [4 /*yield*/, this.adapter.query(modelConstructor, predicate, pagination)];
-                    case 2: return [2 /*return*/, _a.sent()];
+        this.adapter.setUp(this.schema, this.namespaceResolver, this.modelInstanceCreator, this.getModelConstructorByModelName, this.sessionId).then(resolve, reject);
+        await this.initialized;
+    }
+    async save(model, condition, mutator, patchesTuple) {
+        await this.init();
+        if (!this.adapter) {
+            throw new Error('Storage adapter is missing');
+        }
+        const result = await this.adapter.save(model, condition);
+        result.forEach(r => {
+            const [savedElement, opType] = r;
+            // truthy when save is called by the Merger
+            const syncResponse = !!mutator;
+            let updateMutationInput;
+            // don't attempt to calc mutation input when storage.save
+            // is called by Merger, i.e., when processing an AppSync response
+            if ((opType === OpType.UPDATE || opType === OpType.INSERT) &&
+                !syncResponse) {
+                //
+                // TODO: LOOK!!!
+                // the `model` used here is in effect regardless of what model
+                // comes back from adapter.save().
+                // Prior to fix, SQLite adapter had been returning two models
+                // of different types, resulting in invalid outbox entries.
+                //
+                // the bug is essentially fixed in SQLite adapter.
+                // leaving as-is, because it's currently unclear whether anything
+                // depends on this remaining as-is.
+                //
+                updateMutationInput = this.getChangedFieldsInput(model, savedElement, patchesTuple);
+                // // an update without changed user fields
+                // => don't create mutationEvent
+                if (updateMutationInput === null) {
+                    return result;
                 }
+            }
+            const element = updateMutationInput || savedElement;
+            const modelConstructor = Object.getPrototypeOf(savedElement)
+                .constructor;
+            this.pushStream.next({
+                model: modelConstructor,
+                opType,
+                element,
+                mutator,
+                condition: (condition &&
+                    ModelPredicateCreator.getPredicates(condition, false)) ||
+                    null,
+                savedElement,
             });
         });
-    };
-    StorageClass.prototype.queryOne = function (modelConstructor, firstOrLast) {
-        if (firstOrLast === void 0) { firstOrLast = QueryOne.FIRST; }
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.init()];
-                    case 1:
-                        _a.sent();
-                        if (!this.adapter) {
-                            throw new Error('Storage adapter is missing');
-                        }
-                        return [4 /*yield*/, this.adapter.queryOne(modelConstructor, firstOrLast)];
-                    case 2: return [2 /*return*/, _a.sent()];
-                }
+        return result;
+    }
+    async delete(modelOrModelConstructor, condition, mutator) {
+        await this.init();
+        if (!this.adapter) {
+            throw new Error('Storage adapter is missing');
+        }
+        let models;
+        let deleted;
+        [models, deleted] = await this.adapter.delete(modelOrModelConstructor, condition);
+        const modelConstructor = isModelConstructor(modelOrModelConstructor)
+            ? modelOrModelConstructor
+            : Object.getPrototypeOf(modelOrModelConstructor || {})
+                .constructor;
+        const namespaceName = this.namespaceResolver(modelConstructor);
+        const modelDefinition = this.schema.namespaces[namespaceName].models[modelConstructor.name];
+        const modelIds = new Set(models.map(model => {
+            const modelId = getIdentifierValue(modelDefinition, model);
+            return modelId;
+        }));
+        if (!isModelConstructor(modelOrModelConstructor) &&
+            !Array.isArray(deleted)) {
+            deleted = [deleted];
+        }
+        deleted.forEach(model => {
+            const modelConstructor = Object.getPrototypeOf(model)
+                .constructor;
+            let theCondition;
+            if (!isModelConstructor(modelOrModelConstructor)) {
+                const modelId = getIdentifierValue(modelDefinition, model);
+                theCondition = modelIds.has(modelId)
+                    ? ModelPredicateCreator.getPredicates(condition, false)
+                    : undefined;
+            }
+            this.pushStream.next({
+                model: modelConstructor,
+                opType: OpType.DELETE,
+                element: model,
+                mutator,
+                condition: theCondition || null,
             });
         });
-    };
-    StorageClass.prototype.observe = function (modelConstructor, predicate, skipOwn) {
-        var listenToAll = !modelConstructor;
-        var _a = (predicate && ModelPredicateCreator.getPredicates(predicate, false)) ||
-            {}, predicates = _a.predicates, type = _a.type;
-        var result = this.pushStream
-            .pipe(filter(function (_a) {
-            var mutator = _a.mutator;
+        return [models, deleted];
+    }
+    async query(modelConstructor, predicate, pagination) {
+        await this.init();
+        if (!this.adapter) {
+            throw new Error('Storage adapter is missing');
+        }
+        return await this.adapter.query(modelConstructor, predicate, pagination);
+    }
+    async queryOne(modelConstructor, firstOrLast = QueryOne.FIRST) {
+        await this.init();
+        if (!this.adapter) {
+            throw new Error('Storage adapter is missing');
+        }
+        return await this.adapter.queryOne(modelConstructor, firstOrLast);
+    }
+    observe(modelConstructor, predicate, skipOwn) {
+        const listenToAll = !modelConstructor;
+        const { predicates, type } = (predicate && ModelPredicateCreator.getPredicates(predicate, false)) ||
+            {};
+        let result = this.pushStream
+            .pipe(filter(({ mutator }) => {
             return !skipOwn || mutator !== skipOwn;
         }))
-            .pipe(map(function (_a) {
-            var _mutator = _a.mutator, message = __rest(_a, ["mutator"]);
-            return message;
-        }));
+            .pipe(map(({ mutator: _mutator, ...message }) => message));
         if (!listenToAll) {
-            result = result.pipe(filter(function (_a) {
-                var model = _a.model, element = _a.element;
+            result = result.pipe(filter(({ model, element }) => {
                 if (modelConstructor !== model) {
                     return false;
                 }
@@ -314,171 +171,93 @@ var StorageClass = /** @class */ (function () {
             }));
         }
         return result;
-    };
-    StorageClass.prototype.clear = function (completeObservable) {
-        if (completeObservable === void 0) { completeObservable = true; }
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        this.initialized = undefined;
-                        if (!this.adapter) {
-                            throw new Error('Storage adapter is missing');
-                        }
-                        return [4 /*yield*/, this.adapter.clear()];
-                    case 1:
-                        _a.sent();
-                        if (completeObservable) {
-                            this.pushStream.complete();
-                        }
-                        return [2 /*return*/];
-                }
-            });
-        });
-    };
-    StorageClass.prototype.batchSave = function (modelConstructor, items, mutator) {
-        return __awaiter(this, void 0, void 0, function () {
-            var result;
-            var _this = this;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.init()];
-                    case 1:
-                        _a.sent();
-                        if (!this.adapter) {
-                            throw new Error('Storage adapter is missing');
-                        }
-                        return [4 /*yield*/, this.adapter.batchSave(modelConstructor, items)];
-                    case 2:
-                        result = _a.sent();
-                        result.forEach(function (_a) {
-                            var _b = __read(_a, 2), element = _b[0], opType = _b[1];
-                            _this.pushStream.next({
-                                model: modelConstructor,
-                                opType: opType,
-                                element: element,
-                                mutator: mutator,
-                                condition: null,
-                            });
-                        });
-                        return [2 /*return*/, result];
-                }
+    }
+    async clear(completeObservable = true) {
+        this.initialized = undefined;
+        if (!this.adapter) {
+            throw new Error('Storage adapter is missing');
+        }
+        await this.adapter.clear();
+        if (completeObservable) {
+            this.pushStream.complete();
+        }
+    }
+    async batchSave(modelConstructor, items, mutator) {
+        await this.init();
+        if (!this.adapter) {
+            throw new Error('Storage adapter is missing');
+        }
+        const result = await this.adapter.batchSave(modelConstructor, items);
+        result.forEach(([element, opType]) => {
+            this.pushStream.next({
+                model: modelConstructor,
+                opType,
+                element,
+                mutator,
+                condition: null,
             });
         });
-    };
+        return result;
+    }
     // returns null if no user fields were changed (determined by value comparison)
-    StorageClass.prototype.getChangedFieldsInput = function (model, originalElement, patchesTuple) {
-        var e_1, _a;
-        var _b;
-        var containsPatches = patchesTuple && patchesTuple.length;
+    getChangedFieldsInput(model, originalElement, patchesTuple) {
+        const containsPatches = patchesTuple && patchesTuple.length;
         if (!containsPatches) {
             return null;
         }
-        var _c = __read(patchesTuple, 2), patches = _c[0], source = _c[1];
-        var updatedElement = {};
+        const [patches, source] = patchesTuple;
+        const updatedElement = {};
         // extract array of updated fields from patches
-        var updatedFields = (patches.map(function (patch) { return patch.path && patch.path[0]; }));
+        const updatedFields = (patches.map(patch => patch.path && patch.path[0]));
         // check model def for association and replace with targetName if exists
-        var modelConstructor = Object.getPrototypeOf(model)
+        const modelConstructor = Object.getPrototypeOf(model)
             .constructor;
-        var namespace = this.namespaceResolver(modelConstructor);
-        var fields = this.schema.namespaces[namespace].models[modelConstructor.name].fields;
-        var _d = ((_b = this.schema.namespaces[namespace].keys) === null || _b === void 0 ? void 0 : _b[modelConstructor.name]) || {}, primaryKey = _d.primaryKey, _e = _d.compositeKeys, compositeKeys = _e === void 0 ? [] : _e;
+        const namespace = this.namespaceResolver(modelConstructor);
+        const { fields } = this.schema.namespaces[namespace].models[modelConstructor.name];
+        const { primaryKey, compositeKeys = [] } = this.schema.namespaces[namespace].keys?.[modelConstructor.name] || {};
         // set original values for these fields
-        updatedFields.forEach(function (field) {
-            var e_2, _a, e_3, _b, e_4, _c, e_5, _d, e_6, _e;
-            var _f;
-            var targetNames = isTargetNameAssociation((_f = fields[field]) === null || _f === void 0 ? void 0 : _f.association);
+        updatedFields.forEach((field) => {
+            const targetNames = isTargetNameAssociation(fields[field]?.association);
             if (Array.isArray(targetNames)) {
-                try {
-                    // if field refers to a belongsTo relation, use the target field instead
-                    for (var targetNames_1 = __values(targetNames), targetNames_1_1 = targetNames_1.next(); !targetNames_1_1.done; targetNames_1_1 = targetNames_1.next()) {
-                        var targetName = targetNames_1_1.value;
-                        // check field values by value. Ignore unchanged fields
-                        if (!valuesEqual(source[targetName], originalElement[targetName])) {
-                            // if the field was updated to 'undefined', replace with 'null' for compatibility with JSON and GraphQL
-                            updatedElement[targetName] =
-                                originalElement[targetName] === undefined
-                                    ? null
-                                    : originalElement[targetName];
-                            try {
-                                for (var compositeKeys_1 = (e_3 = void 0, __values(compositeKeys)), compositeKeys_1_1 = compositeKeys_1.next(); !compositeKeys_1_1.done; compositeKeys_1_1 = compositeKeys_1.next()) {
-                                    var fieldSet = compositeKeys_1_1.value;
-                                    // include all of the fields that comprise the composite key
-                                    if (fieldSet.has(targetName)) {
-                                        try {
-                                            for (var fieldSet_1 = (e_4 = void 0, __values(fieldSet)), fieldSet_1_1 = fieldSet_1.next(); !fieldSet_1_1.done; fieldSet_1_1 = fieldSet_1.next()) {
-                                                var compositeField = fieldSet_1_1.value;
-                                                updatedElement[compositeField] =
-                                                    originalElement[compositeField];
-                                            }
-                                        }
-                                        catch (e_4_1) { e_4 = { error: e_4_1 }; }
-                                        finally {
-                                            try {
-                                                if (fieldSet_1_1 && !fieldSet_1_1.done && (_c = fieldSet_1.return)) _c.call(fieldSet_1);
-                                            }
-                                            finally { if (e_4) throw e_4.error; }
-                                        }
-                                    }
-                                }
-                            }
-                            catch (e_3_1) { e_3 = { error: e_3_1 }; }
-                            finally {
-                                try {
-                                    if (compositeKeys_1_1 && !compositeKeys_1_1.done && (_b = compositeKeys_1.return)) _b.call(compositeKeys_1);
+                // if field refers to a belongsTo relation, use the target field instead
+                for (const targetName of targetNames) {
+                    // check field values by value. Ignore unchanged fields
+                    if (!valuesEqual(source[targetName], originalElement[targetName])) {
+                        // if the field was updated to 'undefined', replace with 'null' for compatibility with JSON and GraphQL
+                        updatedElement[targetName] =
+                            originalElement[targetName] === undefined
+                                ? null
+                                : originalElement[targetName];
+                        for (const fieldSet of compositeKeys) {
+                            // include all of the fields that comprise the composite key
+                            if (fieldSet.has(targetName)) {
+                                for (const compositeField of fieldSet) {
+                                    updatedElement[compositeField] =
+                                        originalElement[compositeField];
                                 }
-                                finally { if (e_3) throw e_3.error; }
                             }
                         }
                     }
                 }
-                catch (e_2_1) { e_2 = { error: e_2_1 }; }
-                finally {
-                    try {
-                        if (targetNames_1_1 && !targetNames_1_1.done && (_a = targetNames_1.return)) _a.call(targetNames_1);
-                    }
-                    finally { if (e_2) throw e_2.error; }
-                }
             }
             else {
                 // Backwards compatibility pre-CPK
                 // if field refers to a belongsTo relation, use the target field instead
-                var key = targetNames || field;
+                const key = targetNames || field;
                 // check field values by value. Ignore unchanged fields
                 if (!valuesEqual(source[key], originalElement[key])) {
                     // if the field was updated to 'undefined', replace with 'null' for compatibility with JSON and GraphQL
                     updatedElement[key] =
                         originalElement[key] === undefined ? null : originalElement[key];
-                    try {
-                        for (var compositeKeys_2 = __values(compositeKeys), compositeKeys_2_1 = compositeKeys_2.next(); !compositeKeys_2_1.done; compositeKeys_2_1 = compositeKeys_2.next()) {
-                            var fieldSet = compositeKeys_2_1.value;
-                            // include all of the fields that comprise the composite key
-                            if (fieldSet.has(key)) {
-                                try {
-                                    for (var fieldSet_2 = (e_6 = void 0, __values(fieldSet)), fieldSet_2_1 = fieldSet_2.next(); !fieldSet_2_1.done; fieldSet_2_1 = fieldSet_2.next()) {
-                                        var compositeField = fieldSet_2_1.value;
-                                        updatedElement[compositeField] =
-                                            originalElement[compositeField];
-                                    }
-                                }
-                                catch (e_6_1) { e_6 = { error: e_6_1 }; }
-                                finally {
-                                    try {
-                                        if (fieldSet_2_1 && !fieldSet_2_1.done && (_e = fieldSet_2.return)) _e.call(fieldSet_2);
-                                    }
-                                    finally { if (e_6) throw e_6.error; }
-                                }
+                    for (const fieldSet of compositeKeys) {
+                        // include all of the fields that comprise the composite key
+                        if (fieldSet.has(key)) {
+                            for (const compositeField of fieldSet) {
+                                updatedElement[compositeField] =
+                                    originalElement[compositeField];
                             }
                         }
                     }
-                    catch (e_5_1) { e_5 = { error: e_5_1 }; }
-                    finally {
-                        try {
-                            if (compositeKeys_2_1 && !compositeKeys_2_1.done && (_d = compositeKeys_2.return)) _d.call(compositeKeys_2);
-                        }
-                        finally { if (e_5) throw e_5.error; }
-                    }
                 }
             }
         });
@@ -488,107 +267,65 @@ var StorageClass = /** @class */ (function () {
         }
         // include field(s) from custom PK if one is specified for the model
         if (primaryKey && primaryKey.length) {
-            try {
-                for (var primaryKey_1 = __values(primaryKey), primaryKey_1_1 = primaryKey_1.next(); !primaryKey_1_1.done; primaryKey_1_1 = primaryKey_1.next()) {
-                    var pkField = primaryKey_1_1.value;
-                    updatedElement[pkField] = originalElement[pkField];
-                }
-            }
-            catch (e_1_1) { e_1 = { error: e_1_1 }; }
-            finally {
-                try {
-                    if (primaryKey_1_1 && !primaryKey_1_1.done && (_a = primaryKey_1.return)) _a.call(primaryKey_1);
-                }
-                finally { if (e_1) throw e_1.error; }
+            for (const pkField of primaryKey) {
+                updatedElement[pkField] = originalElement[pkField];
             }
         }
-        var id = originalElement.id, _version = originalElement._version, _lastChangedAt = originalElement._lastChangedAt, _deleted = originalElement._deleted;
+        const { id, _version, _lastChangedAt, _deleted } = originalElement;
         // For update mutations we only want to send fields with changes
         // and the required internal fields
-        return __assign(__assign({}, updatedElement), { id: id, _version: _version, _lastChangedAt: _lastChangedAt, _deleted: _deleted });
-    };
-    return StorageClass;
-}());
-var ExclusiveStorage = /** @class */ (function () {
-    function ExclusiveStorage(schema, namespaceResolver, getModelConstructorByModelName, modelInstanceCreator, adapter, sessionId) {
+        return {
+            ...updatedElement,
+            id,
+            _version,
+            _lastChangedAt,
+            _deleted,
+        };
+    }
+}
+class ExclusiveStorage {
+    constructor(schema, namespaceResolver, getModelConstructorByModelName, modelInstanceCreator, adapter, sessionId) {
         this.mutex = new Mutex();
         this.storage = new StorageClass(schema, namespaceResolver, getModelConstructorByModelName, modelInstanceCreator, adapter, sessionId);
     }
-    ExclusiveStorage.prototype.runExclusive = function (fn) {
+    runExclusive(fn) {
         return this.mutex.runExclusive(fn.bind(this, this.storage));
-    };
-    ExclusiveStorage.prototype.save = function (model, condition, mutator, patchesTuple) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.runExclusive(function (storage) {
-                        return storage.save(model, condition, mutator, patchesTuple);
-                    })];
-            });
-        });
-    };
-    ExclusiveStorage.prototype.delete = function (modelOrModelConstructor, condition, mutator) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.runExclusive(function (storage) {
-                        if (isModelConstructor(modelOrModelConstructor)) {
-                            var modelConstructor = modelOrModelConstructor;
-                            return storage.delete(modelConstructor, condition, mutator);
-                        }
-                        else {
-                            var model = modelOrModelConstructor;
-                            return storage.delete(model, condition, mutator);
-                        }
-                    })];
-            });
-        });
-    };
-    ExclusiveStorage.prototype.query = function (modelConstructor, predicate, pagination) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.runExclusive(function (storage) {
-                        return storage.query(modelConstructor, predicate, pagination);
-                    })];
-            });
-        });
-    };
-    ExclusiveStorage.prototype.queryOne = function (modelConstructor, firstOrLast) {
-        if (firstOrLast === void 0) { firstOrLast = QueryOne.FIRST; }
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.runExclusive(function (storage) {
-                        return storage.queryOne(modelConstructor, firstOrLast);
-                    })];
-            });
+    }
+    async save(model, condition, mutator, patchesTuple) {
+        return this.runExclusive(storage => storage.save(model, condition, mutator, patchesTuple));
+    }
+    async delete(modelOrModelConstructor, condition, mutator) {
+        return this.runExclusive(storage => {
+            if (isModelConstructor(modelOrModelConstructor)) {
+                const modelConstructor = modelOrModelConstructor;
+                return storage.delete(modelConstructor, condition, mutator);
+            }
+            else {
+                const model = modelOrModelConstructor;
+                return storage.delete(model, condition, mutator);
+            }
         });
-    };
-    ExclusiveStorage.getNamespace = function () {
+    }
+    async query(modelConstructor, predicate, pagination) {
+        return this.runExclusive(storage => storage.query(modelConstructor, predicate, pagination));
+    }
+    async queryOne(modelConstructor, firstOrLast = QueryOne.FIRST) {
+        return this.runExclusive(storage => storage.queryOne(modelConstructor, firstOrLast));
+    }
+    static getNamespace() {
         return StorageClass.getNamespace();
-    };
-    ExclusiveStorage.prototype.observe = function (modelConstructor, predicate, skipOwn) {
+    }
+    observe(modelConstructor, predicate, skipOwn) {
         return this.storage.observe(modelConstructor, predicate, skipOwn);
-    };
-    ExclusiveStorage.prototype.clear = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.runExclusive(function (storage) { return storage.clear(); })];
-                    case 1:
-                        _a.sent();
-                        return [2 /*return*/];
-                }
-            });
-        });
-    };
-    ExclusiveStorage.prototype.batchSave = function (modelConstructor, items) {
+    }
+    async clear() {
+        await this.runExclusive(storage => storage.clear());
+    }
+    batchSave(modelConstructor, items) {
         return this.storage.batchSave(modelConstructor, items);
-    };
-    ExclusiveStorage.prototype.init = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.storage.init()];
-            });
-        });
-    };
-    return ExclusiveStorage;
-}());
+    }
+    async init() {
+        return this.storage.init();
+    }
+}
 export { ExclusiveStorage };