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

package/lib-esm/storage/adapter/StorageAdapterBase.js

@@ -1,66 +1,12 @@
-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 __asyncValues = (this && this.__asyncValues) || function (o) {
-    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
-    var m = o[Symbol.asyncIterator], i;
-    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
-    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
-    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
-};
-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.");
-};
 import { ModelPredicateCreator } from '../../predicates';
 import { isPredicateObj, } from '../../types';
 import { getStorename, getIndexKeys, extractPrimaryKeyValues, traverseModel, validatePredicate, isModelConstructor, extractPrimaryKeyFieldNames, } from '../../util';
 import { ModelRelationship } from '../relationship';
 import { ConsoleLogger } from '@aws-amplify/core';
-var logger = new ConsoleLogger('DataStore');
-var DB_NAME = 'amplify-datastore';
-var StorageAdapterBase = /** @class */ (function () {
-    function StorageAdapterBase() {
+const logger = new ConsoleLogger('DataStore');
+const DB_NAME = 'amplify-datastore';
+export class StorageAdapterBase {
+    constructor() {
         this.dbName = DB_NAME;
     }
     /**
@@ -72,117 +18,97 @@ var StorageAdapterBase = /** @class */ (function () {
      * @param getModelConstructorByModelName
      * @param sessionId
      */
-    StorageAdapterBase.prototype.setUp = function (theSchema, namespaceResolver, modelInstanceCreator, getModelConstructorByModelName, sessionId) {
-        return __awaiter(this, void 0, void 0, function () {
-            var _a, error_1;
-            var _this = this;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0: return [4 /*yield*/, this.preSetUpChecks()];
-                    case 1:
-                        _b.sent();
-                        if (!!this.initPromise) return [3 /*break*/, 2];
-                        this.initPromise = new Promise(function (res, rej) {
-                            _this.resolve = res;
-                            _this.reject = rej;
-                        });
-                        return [3 /*break*/, 4];
-                    case 2: return [4 /*yield*/, this.initPromise];
-                    case 3:
-                        _b.sent();
-                        return [2 /*return*/];
-                    case 4:
-                        if (sessionId) {
-                            this.dbName = "".concat(DB_NAME, "-").concat(sessionId);
-                        }
-                        this.schema = theSchema;
-                        this.namespaceResolver = namespaceResolver;
-                        this.modelInstanceCreator = modelInstanceCreator;
-                        this.getModelConstructorByModelName = getModelConstructorByModelName;
-                        _b.label = 5;
-                    case 5:
-                        _b.trys.push([5, 8, , 9]);
-                        if (!!this.db) return [3 /*break*/, 7];
-                        _a = this;
-                        return [4 /*yield*/, this.initDb()];
-                    case 6:
-                        _a.db = _b.sent();
-                        this.resolve();
-                        _b.label = 7;
-                    case 7: return [3 /*break*/, 9];
-                    case 8:
-                        error_1 = _b.sent();
-                        this.reject(error_1);
-                        return [3 /*break*/, 9];
-                    case 9: return [2 /*return*/];
-                }
+    async setUp(theSchema, namespaceResolver, modelInstanceCreator, getModelConstructorByModelName, sessionId) {
+        await this.preSetUpChecks();
+        if (!this.initPromise) {
+            this.initPromise = new Promise((res, rej) => {
+                this.resolve = res;
+                this.reject = rej;
             });
-        });
-    };
+        }
+        else {
+            await this.initPromise;
+            return;
+        }
+        if (sessionId) {
+            this.dbName = `${DB_NAME}-${sessionId}`;
+        }
+        this.schema = theSchema;
+        this.namespaceResolver = namespaceResolver;
+        this.modelInstanceCreator = modelInstanceCreator;
+        this.getModelConstructorByModelName = getModelConstructorByModelName;
+        try {
+            if (!this.db) {
+                this.db = await this.initDb();
+                this.resolve();
+            }
+        }
+        catch (error) {
+            this.reject(error);
+        }
+    }
     /**
      * @param modelConstructor
      * @returns local DB table name
      */
-    StorageAdapterBase.prototype.getStorenameForModel = function (modelConstructor) {
-        var namespace = this.namespaceResolver(modelConstructor);
-        var modelName = modelConstructor.name;
+    getStorenameForModel(modelConstructor) {
+        const namespace = this.namespaceResolver(modelConstructor);
+        const { name: modelName } = modelConstructor;
         return getStorename(namespace, modelName);
-    };
+    }
     /**
      *
      * @param model - instantiated model record
      * @returns the record's primary key values
      */
-    StorageAdapterBase.prototype.getIndexKeyValuesFromModel = function (model) {
-        var modelConstructor = Object.getPrototypeOf(model)
+    getIndexKeyValuesFromModel(model) {
+        const modelConstructor = Object.getPrototypeOf(model)
             .constructor;
-        var namespaceName = this.namespaceResolver(modelConstructor);
-        var keys = getIndexKeys(this.schema.namespaces[namespaceName], modelConstructor.name);
+        const namespaceName = this.namespaceResolver(modelConstructor);
+        const keys = getIndexKeys(this.schema.namespaces[namespaceName], modelConstructor.name);
         return extractPrimaryKeyValues(model, keys);
-    };
+    }
     /**
      * Common metadata for `save` operation
      * used by individual storage adapters
      *
      * @param model
      */
-    StorageAdapterBase.prototype.saveMetadata = function (model) {
-        var _this = this;
-        var modelConstructor = Object.getPrototypeOf(model)
+    saveMetadata(model) {
+        const modelConstructor = Object.getPrototypeOf(model)
             .constructor;
-        var storeName = this.getStorenameForModel(modelConstructor);
-        var namespaceName = this.namespaceResolver(modelConstructor);
-        var connectedModels = traverseModel(modelConstructor.name, model, this.schema.namespaces[namespaceName], this.modelInstanceCreator, this.getModelConstructorByModelName);
-        var set = new Set();
-        var connectionStoreNames = Object.values(connectedModels).map(function (_a) {
-            var modelName = _a.modelName, item = _a.item, instance = _a.instance;
-            var storeName = getStorename(namespaceName, modelName);
+        const storeName = this.getStorenameForModel(modelConstructor);
+        const namespaceName = this.namespaceResolver(modelConstructor);
+        const connectedModels = traverseModel(modelConstructor.name, model, this.schema.namespaces[namespaceName], this.modelInstanceCreator, this.getModelConstructorByModelName);
+        const set = new Set();
+        const connectionStoreNames = Object.values(connectedModels).map(({ modelName, item, instance }) => {
+            const storeName = getStorename(namespaceName, modelName);
             set.add(storeName);
-            var keys = getIndexKeys(_this.schema.namespaces[namespaceName], modelName);
-            return { storeName: storeName, item: item, instance: instance, keys: keys };
+            const keys = getIndexKeys(this.schema.namespaces[namespaceName], modelName);
+            return { storeName, item, instance, keys };
         });
-        var modelKeyValues = this.getIndexKeyValuesFromModel(model);
-        return { storeName: storeName, set: set, connectionStoreNames: connectionStoreNames, modelKeyValues: modelKeyValues };
-    };
+        const modelKeyValues = this.getIndexKeyValuesFromModel(model);
+        return { storeName, set, connectionStoreNames, modelKeyValues };
+    }
     /**
      * Enforces conditional save. Throws if condition is not met.
      * used by individual storage adapters
      *
      * @param model
      */
-    StorageAdapterBase.prototype.validateSaveCondition = function (condition, fromDB) {
+    validateSaveCondition(condition, fromDB) {
         if (!(condition && fromDB)) {
             return;
         }
-        var predicates = ModelPredicateCreator.getPredicates(condition);
-        var _a = predicates, predicateObjs = _a.predicates, type = _a.type;
-        var isValid = validatePredicate(fromDB, type, predicateObjs);
+        const predicates = ModelPredicateCreator.getPredicates(condition);
+        const { predicates: predicateObjs, type } = predicates;
+        const isValid = validatePredicate(fromDB, type, predicateObjs);
         if (!isValid) {
-            var msg = 'Conditional update failed';
+            const msg = 'Conditional update failed';
             logger.error(msg, { model: fromDB, condition: predicateObjs });
             throw new Error(msg);
         }
-    };
+    }
     /**
      * Instantiate models from POJO records returned from the database
      *
@@ -191,29 +117,18 @@ var StorageAdapterBase = /** @class */ (function () {
      * @param records - array of uninstantiated records
      * @returns
      */
-    StorageAdapterBase.prototype.load = function (namespaceName, srcModelName, records) {
-        return __awaiter(this, void 0, void 0, function () {
-            var namespace, relations, connectionStoreNames, modelConstructor;
-            var _this = this;
-            return __generator(this, function (_a) {
-                namespace = this.schema.namespaces[namespaceName];
-                relations = namespace.relationships[srcModelName].relationTypes;
-                connectionStoreNames = relations.map(function (_a) {
-                    var modelName = _a.modelName;
-                    return getStorename(namespaceName, modelName);
-                });
-                modelConstructor = this.getModelConstructorByModelName(namespaceName, srcModelName);
-                if (connectionStoreNames.length === 0) {
-                    return [2 /*return*/, records.map(function (record) {
-                            return _this.modelInstanceCreator(modelConstructor, record);
-                        })];
-                }
-                return [2 /*return*/, records.map(function (record) {
-                        return _this.modelInstanceCreator(modelConstructor, record);
-                    })];
-            });
+    async load(namespaceName, srcModelName, records) {
+        const namespace = this.schema.namespaces[namespaceName];
+        const relations = namespace.relationships[srcModelName].relationTypes;
+        const connectionStoreNames = relations.map(({ modelName }) => {
+            return getStorename(namespaceName, modelName);
         });
-    };
+        const modelConstructor = this.getModelConstructorByModelName(namespaceName, srcModelName);
+        if (connectionStoreNames.length === 0) {
+            return records.map(record => this.modelInstanceCreator(modelConstructor, record));
+        }
+        return records.map(record => this.modelInstanceCreator(modelConstructor, record));
+    }
     /**
      * Extracts operands from a predicate group into an array of key values
      * Used in the query method
@@ -231,40 +146,25 @@ var StorageAdapterBase = /** @class */ (function () {
      * ['abc', 'def']
      * ```
      */
-    StorageAdapterBase.prototype.keyValueFromPredicate = function (predicates, keyPath) {
-        var e_1, _a;
-        var predicateObjs = predicates.predicates;
+    keyValueFromPredicate(predicates, keyPath) {
+        const { predicates: predicateObjs } = predicates;
         if (predicateObjs.length !== keyPath.length) {
             return;
         }
-        var keyValues = [];
-        var _loop_1 = function (key) {
-            var predicateObj = predicateObjs.find(function (p) {
-                // it's a relevant predicate object only if it's an equality
-                // operation for a key field from the key:
-                return isPredicateObj(p) &&
-                    p.field === key &&
-                    p.operator === 'eq' &&
-                    p.operand !== null &&
-                    p.operand !== undefined;
-            });
+        const keyValues = [];
+        for (const key of keyPath) {
+            const predicateObj = predicateObjs.find(p => 
+            // it's a relevant predicate object only if it's an equality
+            // operation for a key field from the key:
+            isPredicateObj(p) &&
+                p.field === key &&
+                p.operator === 'eq' &&
+                p.operand !== null &&
+                p.operand !== undefined);
             predicateObj && keyValues.push(predicateObj.operand);
-        };
-        try {
-            for (var keyPath_1 = __values(keyPath), keyPath_1_1 = keyPath_1.next(); !keyPath_1_1.done; keyPath_1_1 = keyPath_1.next()) {
-                var key = keyPath_1_1.value;
-                _loop_1(key);
-            }
-        }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-        finally {
-            try {
-                if (keyPath_1_1 && !keyPath_1_1.done && (_a = keyPath_1.return)) _a.call(keyPath_1);
-            }
-            finally { if (e_1) throw e_1.error; }
         }
         return keyValues.length === keyPath.length ? keyValues : undefined;
-    };
+    }
     /**
      * Common metadata for `query` operation
      * used by individual storage adapters
@@ -273,23 +173,23 @@ var StorageAdapterBase = /** @class */ (function () {
      * @param predicate
      * @param pagination
      */
-    StorageAdapterBase.prototype.queryMetadata = function (modelConstructor, predicate, pagination) {
-        var storeName = this.getStorenameForModel(modelConstructor);
-        var namespaceName = this.namespaceResolver(modelConstructor);
-        var predicates = predicate && ModelPredicateCreator.getPredicates(predicate);
-        var keyPath = getIndexKeys(this.schema.namespaces[namespaceName], modelConstructor.name);
-        var queryByKey = predicates && this.keyValueFromPredicate(predicates, keyPath);
-        var hasSort = pagination && pagination.sort;
-        var hasPagination = pagination && pagination.limit;
+    queryMetadata(modelConstructor, predicate, pagination) {
+        const storeName = this.getStorenameForModel(modelConstructor);
+        const namespaceName = this.namespaceResolver(modelConstructor);
+        const predicates = predicate && ModelPredicateCreator.getPredicates(predicate);
+        const keyPath = getIndexKeys(this.schema.namespaces[namespaceName], modelConstructor.name);
+        const queryByKey = predicates && this.keyValueFromPredicate(predicates, keyPath);
+        const hasSort = pagination && pagination.sort;
+        const hasPagination = pagination && pagination.limit;
         return {
-            storeName: storeName,
-            namespaceName: namespaceName,
-            queryByKey: queryByKey,
-            predicates: predicates,
-            hasSort: hasSort,
-            hasPagination: hasPagination,
+            storeName,
+            namespaceName,
+            queryByKey,
+            predicates,
+            hasSort,
+            hasPagination,
         };
-    };
+    }
     /**
      * Delete record
      * Cascades to related records (for Has One and Has Many relationships)
@@ -298,90 +198,58 @@ var StorageAdapterBase = /** @class */ (function () {
      * @param condition
      * @returns
      */
-    StorageAdapterBase.prototype.delete = function (modelOrModelConstructor, condition) {
-        return __awaiter(this, void 0, void 0, function () {
-            var deleteQueue, modelConstructor, namespace, models, deletedModels, deletedModels, model, modelConstructor, namespaceName, storeName, keyValues, fromDB, msg, predicates, _a, predicateObjs, type, isValid, msg, deletedModels;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0: return [4 /*yield*/, this.preOpCheck()];
-                    case 1:
-                        _b.sent();
-                        deleteQueue = [];
-                        if (!isModelConstructor(modelOrModelConstructor)) return [3 /*break*/, 9];
-                        modelConstructor = modelOrModelConstructor;
-                        namespace = this.namespaceResolver(modelConstructor);
-                        return [4 /*yield*/, this.query(modelConstructor, condition)];
-                    case 2:
-                        models = _b.sent();
-                        if (!(condition !== undefined)) return [3 /*break*/, 5];
-                        return [4 /*yield*/, this.deleteTraverse(models, modelConstructor, namespace, deleteQueue)];
-                    case 3:
-                        _b.sent();
-                        return [4 /*yield*/, this.deleteItem(deleteQueue)];
-                    case 4:
-                        _b.sent();
-                        deletedModels = deleteQueue.reduce(function (acc, _a) {
-                            var items = _a.items;
-                            return acc.concat(items);
-                        }, []);
-                        return [2 /*return*/, [models, deletedModels]];
-                    case 5: return [4 /*yield*/, this.deleteTraverse(models, modelConstructor, namespace, deleteQueue)];
-                    case 6:
-                        _b.sent();
-                        return [4 /*yield*/, this.deleteItem(deleteQueue)];
-                    case 7:
-                        _b.sent();
-                        deletedModels = deleteQueue.reduce(function (acc, _a) {
-                            var items = _a.items;
-                            return acc.concat(items);
-                        }, []);
-                        return [2 /*return*/, [models, deletedModels]];
-                    case 8: return [3 /*break*/, 16];
-                    case 9:
-                        model = modelOrModelConstructor;
-                        modelConstructor = Object.getPrototypeOf(model)
-                            .constructor;
-                        namespaceName = this.namespaceResolver(modelConstructor);
-                        storeName = this.getStorenameForModel(modelConstructor);
-                        if (!condition) return [3 /*break*/, 12];
-                        keyValues = this.getIndexKeyValuesFromModel(model);
-                        return [4 /*yield*/, this._get(storeName, keyValues)];
-                    case 10:
-                        fromDB = _b.sent();
-                        if (fromDB === undefined) {
-                            msg = 'Model instance not found in storage';
-                            logger.warn(msg, { model: model });
-                            return [2 /*return*/, [[model], []]];
-                        }
-                        predicates = ModelPredicateCreator.getPredicates(condition);
-                        _a = predicates, predicateObjs = _a.predicates, type = _a.type;
-                        isValid = validatePredicate(fromDB, type, predicateObjs);
-                        if (!isValid) {
-                            msg = 'Conditional update failed';
-                            logger.error(msg, { model: fromDB, condition: predicateObjs });
-                            throw new Error(msg);
-                        }
-                        return [4 /*yield*/, this.deleteTraverse([model], modelConstructor, namespaceName, deleteQueue)];
-                    case 11:
-                        _b.sent();
-                        return [3 /*break*/, 14];
-                    case 12: return [4 /*yield*/, this.deleteTraverse([model], modelConstructor, namespaceName, deleteQueue)];
-                    case 13:
-                        _b.sent();
-                        _b.label = 14;
-                    case 14: return [4 /*yield*/, this.deleteItem(deleteQueue)];
-                    case 15:
-                        _b.sent();
-                        deletedModels = deleteQueue.reduce(function (acc, _a) {
-                            var items = _a.items;
-                            return acc.concat(items);
-                        }, []);
-                        return [2 /*return*/, [[model], deletedModels]];
-                    case 16: return [2 /*return*/];
+    async delete(modelOrModelConstructor, condition) {
+        await this.preOpCheck();
+        const deleteQueue = [];
+        if (isModelConstructor(modelOrModelConstructor)) {
+            const modelConstructor = modelOrModelConstructor;
+            const namespace = this.namespaceResolver(modelConstructor);
+            const models = await this.query(modelConstructor, condition);
+            if (condition !== undefined) {
+                await this.deleteTraverse(models, modelConstructor, namespace, deleteQueue);
+                await this.deleteItem(deleteQueue);
+                const deletedModels = deleteQueue.reduce((acc, { items }) => acc.concat(items), []);
+                return [models, deletedModels];
+            }
+            else {
+                await this.deleteTraverse(models, modelConstructor, namespace, deleteQueue);
+                await this.deleteItem(deleteQueue);
+                const deletedModels = deleteQueue.reduce((acc, { items }) => acc.concat(items), []);
+                return [models, deletedModels];
+            }
+        }
+        else {
+            const model = modelOrModelConstructor;
+            const modelConstructor = Object.getPrototypeOf(model)
+                .constructor;
+            const namespaceName = this.namespaceResolver(modelConstructor);
+            const storeName = this.getStorenameForModel(modelConstructor);
+            if (condition) {
+                const keyValues = this.getIndexKeyValuesFromModel(model);
+                const fromDB = await this._get(storeName, keyValues);
+                if (fromDB === undefined) {
+                    const msg = 'Model instance not found in storage';
+                    logger.warn(msg, { model });
+                    return [[model], []];
                 }
-            });
-        });
-    };
+                const predicates = ModelPredicateCreator.getPredicates(condition);
+                const { predicates: predicateObjs, type } = predicates;
+                const isValid = validatePredicate(fromDB, type, predicateObjs);
+                if (!isValid) {
+                    const msg = 'Conditional update failed';
+                    logger.error(msg, { model: fromDB, condition: predicateObjs });
+                    throw new Error(msg);
+                }
+                await this.deleteTraverse([model], modelConstructor, namespaceName, deleteQueue);
+            }
+            else {
+                await this.deleteTraverse([model], modelConstructor, namespaceName, deleteQueue);
+            }
+            await this.deleteItem(deleteQueue);
+            const deletedModels = deleteQueue.reduce((acc, { items }) => acc.concat(items), []);
+            return [[model], deletedModels];
+        }
+    }
     /**
      * Recursively traverse relationship graph and add
      * all Has One and Has Many relations to `deleteQueue` param
@@ -393,115 +261,27 @@ var StorageAdapterBase = /** @class */ (function () {
      * @param namespace
      * @param deleteQueue
      */
-    StorageAdapterBase.prototype.deleteTraverse = function (models, modelConstructor, namespace, deleteQueue) {
-        var _a, models_1, models_1_1;
-        var _b, e_2, _c, _d, _e, e_3, _f, _g;
-        return __awaiter(this, void 0, void 0, function () {
-            var cascadingRelationTypes, model, modelDefinition, modelMeta, relationships, _h, relationships_1, relationships_1_1, r, queryObject, relatedRecords, e_3_1, e_2_1;
-            return __generator(this, function (_j) {
-                switch (_j.label) {
-                    case 0:
-                        cascadingRelationTypes = ['HAS_ONE', 'HAS_MANY'];
-                        _j.label = 1;
-                    case 1:
-                        _j.trys.push([1, 25, 26, 31]);
-                        _a = true, models_1 = __asyncValues(models);
-                        _j.label = 2;
-                    case 2: return [4 /*yield*/, models_1.next()];
-                    case 3:
-                        if (!(models_1_1 = _j.sent(), _b = models_1_1.done, !_b)) return [3 /*break*/, 24];
-                        _d = models_1_1.value;
-                        _a = false;
-                        _j.label = 4;
-                    case 4:
-                        _j.trys.push([4, , 22, 23]);
-                        model = _d;
-                        modelDefinition = this.schema.namespaces[namespace].models[modelConstructor.name];
-                        modelMeta = {
-                            builder: modelConstructor,
-                            schema: modelDefinition,
-                            pkField: extractPrimaryKeyFieldNames(modelDefinition),
-                        };
-                        relationships = ModelRelationship.allFrom(modelMeta).filter(function (r) {
-                            return cascadingRelationTypes.includes(r.type);
-                        });
-                        _j.label = 5;
-                    case 5:
-                        _j.trys.push([5, 15, 16, 21]);
-                        _h = true, relationships_1 = (e_3 = void 0, __asyncValues(relationships));
-                        _j.label = 6;
-                    case 6: return [4 /*yield*/, relationships_1.next()];
-                    case 7:
-                        if (!(relationships_1_1 = _j.sent(), _e = relationships_1_1.done, !_e)) return [3 /*break*/, 14];
-                        _g = relationships_1_1.value;
-                        _h = false;
-                        _j.label = 8;
-                    case 8:
-                        _j.trys.push([8, , 12, 13]);
-                        r = _g;
-                        queryObject = r.createRemoteQueryObject(model);
-                        if (!(queryObject !== null)) return [3 /*break*/, 11];
-                        return [4 /*yield*/, this.query(r.remoteModelConstructor, ModelPredicateCreator.createFromFlatEqualities(r.remoteDefinition, queryObject))];
-                    case 9:
-                        relatedRecords = _j.sent();
-                        return [4 /*yield*/, this.deleteTraverse(relatedRecords, r.remoteModelConstructor, namespace, deleteQueue)];
-                    case 10:
-                        _j.sent();
-                        _j.label = 11;
-                    case 11: return [3 /*break*/, 13];
-                    case 12:
-                        _h = true;
-                        return [7 /*endfinally*/];
-                    case 13: return [3 /*break*/, 6];
-                    case 14: return [3 /*break*/, 21];
-                    case 15:
-                        e_3_1 = _j.sent();
-                        e_3 = { error: e_3_1 };
-                        return [3 /*break*/, 21];
-                    case 16:
-                        _j.trys.push([16, , 19, 20]);
-                        if (!(!_h && !_e && (_f = relationships_1.return))) return [3 /*break*/, 18];
-                        return [4 /*yield*/, _f.call(relationships_1)];
-                    case 17:
-                        _j.sent();
-                        _j.label = 18;
-                    case 18: return [3 /*break*/, 20];
-                    case 19:
-                        if (e_3) throw e_3.error;
-                        return [7 /*endfinally*/];
-                    case 20: return [7 /*endfinally*/];
-                    case 21: return [3 /*break*/, 23];
-                    case 22:
-                        _a = true;
-                        return [7 /*endfinally*/];
-                    case 23: return [3 /*break*/, 2];
-                    case 24: return [3 /*break*/, 31];
-                    case 25:
-                        e_2_1 = _j.sent();
-                        e_2 = { error: e_2_1 };
-                        return [3 /*break*/, 31];
-                    case 26:
-                        _j.trys.push([26, , 29, 30]);
-                        if (!(!_a && !_b && (_c = models_1.return))) return [3 /*break*/, 28];
-                        return [4 /*yield*/, _c.call(models_1)];
-                    case 27:
-                        _j.sent();
-                        _j.label = 28;
-                    case 28: return [3 /*break*/, 30];
-                    case 29:
-                        if (e_2) throw e_2.error;
-                        return [7 /*endfinally*/];
-                    case 30: return [7 /*endfinally*/];
-                    case 31:
-                        deleteQueue.push({
-                            storeName: getStorename(namespace, modelConstructor.name),
-                            items: models,
-                        });
-                        return [2 /*return*/];
+    async deleteTraverse(models, modelConstructor, namespace, deleteQueue) {
+        const cascadingRelationTypes = ['HAS_ONE', 'HAS_MANY'];
+        for await (const model of models) {
+            const modelDefinition = this.schema.namespaces[namespace].models[modelConstructor.name];
+            const modelMeta = {
+                builder: modelConstructor,
+                schema: modelDefinition,
+                pkField: extractPrimaryKeyFieldNames(modelDefinition),
+            };
+            const relationships = ModelRelationship.allFrom(modelMeta).filter(r => cascadingRelationTypes.includes(r.type));
+            for await (const r of relationships) {
+                const queryObject = r.createRemoteQueryObject(model);
+                if (queryObject !== null) {
+                    const relatedRecords = await this.query(r.remoteModelConstructor, ModelPredicateCreator.createFromFlatEqualities(r.remoteDefinition, queryObject));
+                    await this.deleteTraverse(relatedRecords, r.remoteModelConstructor, namespace, deleteQueue);
                 }
-            });
+            }
+        }
+        deleteQueue.push({
+            storeName: getStorename(namespace, modelConstructor.name),
+            items: models,
         });
-    };
-    return StorageAdapterBase;
-}());
-export { StorageAdapterBase };
+    }
+}