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

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

@@ -1,15 +1,12 @@
-import { __asyncValues, __awaiter, __generator, __values } from "tslib";
-// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
-// SPDX-License-Identifier: Apache-2.0
-import { ConsoleLogger as Logger } from '@aws-amplify/core';
 import { ModelPredicateCreator } from '../../predicates';
 import { isPredicateObj, } from '../../types';
 import { getStorename, getIndexKeys, extractPrimaryKeyValues, traverseModel, validatePredicate, isModelConstructor, extractPrimaryKeyFieldNames, } from '../../util';
 import { ModelRelationship } from '../relationship';
-var logger = new Logger('DataStore');
-var DB_NAME = 'amplify-datastore';
-var StorageAdapterBase = /** @class */ (function () {
-    function StorageAdapterBase() {
+import { ConsoleLogger } from '@aws-amplify/core';
+const logger = new ConsoleLogger('DataStore');
+const DB_NAME = 'amplify-datastore';
+export class StorageAdapterBase {
+    constructor() {
         this.dbName = DB_NAME;
     }
     /**
@@ -21,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 = DB_NAME + "-" + 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
      *
@@ -140,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
@@ -180,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
@@ -222,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)
@@ -247,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
@@ -342,98 +261,27 @@ var StorageAdapterBase = /** @class */ (function () {
      * @param namespace
      * @param deleteQueue
      */
-    StorageAdapterBase.prototype.deleteTraverse = function (models, modelConstructor, namespace, deleteQueue) {
-        var models_1, models_1_1;
-        var e_2, _a, e_3, _b;
-        return __awaiter(this, void 0, void 0, function () {
-            var cascadingRelationTypes, model, modelDefinition, modelMeta, relationships, relationships_1, relationships_1_1, r, queryObject, relatedRecords, e_3_1, e_2_1;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        cascadingRelationTypes = ['HAS_ONE', 'HAS_MANY'];
-                        _c.label = 1;
-                    case 1:
-                        _c.trys.push([1, 19, 20, 25]);
-                        models_1 = __asyncValues(models);
-                        _c.label = 2;
-                    case 2: return [4 /*yield*/, models_1.next()];
-                    case 3:
-                        if (!(models_1_1 = _c.sent(), !models_1_1.done)) return [3 /*break*/, 18];
-                        model = models_1_1.value;
-                        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);
-                        });
-                        _c.label = 4;
-                    case 4:
-                        _c.trys.push([4, 11, 12, 17]);
-                        relationships_1 = __asyncValues(relationships);
-                        _c.label = 5;
-                    case 5: return [4 /*yield*/, relationships_1.next()];
-                    case 6:
-                        if (!(relationships_1_1 = _c.sent(), !relationships_1_1.done)) return [3 /*break*/, 10];
-                        r = relationships_1_1.value;
-                        queryObject = r.createRemoteQueryObject(model);
-                        if (!(queryObject !== null)) return [3 /*break*/, 9];
-                        return [4 /*yield*/, this.query(r.remoteModelConstructor, ModelPredicateCreator.createFromFlatEqualities(r.remoteDefinition, queryObject))];
-                    case 7:
-                        relatedRecords = _c.sent();
-                        return [4 /*yield*/, this.deleteTraverse(relatedRecords, r.remoteModelConstructor, namespace, deleteQueue)];
-                    case 8:
-                        _c.sent();
-                        _c.label = 9;
-                    case 9: return [3 /*break*/, 5];
-                    case 10: return [3 /*break*/, 17];
-                    case 11:
-                        e_3_1 = _c.sent();
-                        e_3 = { error: e_3_1 };
-                        return [3 /*break*/, 17];
-                    case 12:
-                        _c.trys.push([12, , 15, 16]);
-                        if (!(relationships_1_1 && !relationships_1_1.done && (_b = relationships_1.return))) return [3 /*break*/, 14];
-                        return [4 /*yield*/, _b.call(relationships_1)];
-                    case 13:
-                        _c.sent();
-                        _c.label = 14;
-                    case 14: return [3 /*break*/, 16];
-                    case 15:
-                        if (e_3) throw e_3.error;
-                        return [7 /*endfinally*/];
-                    case 16: return [7 /*endfinally*/];
-                    case 17: return [3 /*break*/, 2];
-                    case 18: return [3 /*break*/, 25];
-                    case 19:
-                        e_2_1 = _c.sent();
-                        e_2 = { error: e_2_1 };
-                        return [3 /*break*/, 25];
-                    case 20:
-                        _c.trys.push([20, , 23, 24]);
-                        if (!(models_1_1 && !models_1_1.done && (_a = models_1.return))) return [3 /*break*/, 22];
-                        return [4 /*yield*/, _a.call(models_1)];
-                    case 21:
-                        _c.sent();
-                        _c.label = 22;
-                    case 22: return [3 /*break*/, 24];
-                    case 23:
-                        if (e_2) throw e_2.error;
-                        return [7 /*endfinally*/];
-                    case 24: return [7 /*endfinally*/];
-                    case 25:
-                        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 };
-//# sourceMappingURL=StorageAdapterBase.js.map
+    }
+}

package/lib-esm/storage/adapter/getDefaultAdapter/index.js

@@ -1,14 +1,10 @@
-// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
-// SPDX-License-Identifier: Apache-2.0
-import { browserOrNode, isWebWorker } from '@aws-amplify/core';
 import IndexedDBAdapter from '../IndexedDBAdapter';
 import AsyncStorageAdapter from '../AsyncStorageAdapter';
-var getDefaultAdapter = function () {
-    var isBrowser = browserOrNode().isBrowser;
+import { isWebWorker, isBrowser } from '@aws-amplify/core/internals/utils';
+const getDefaultAdapter = () => {
     if ((isBrowser && window.indexedDB) || (isWebWorker() && self.indexedDB)) {
         return IndexedDBAdapter;
     }
     return AsyncStorageAdapter;
 };
 export default getDefaultAdapter;
-//# sourceMappingURL=index.js.map

package/lib-esm/storage/adapter/getDefaultAdapter/index.native.js

@@ -1,6 +1,5 @@
 import AsyncStorageAdapter from '../AsyncStorageAdapter';
-var getDefaultAdapter = function () {
+const getDefaultAdapter = () => {
     return AsyncStorageAdapter;
 };
 export default getDefaultAdapter;
-//# sourceMappingURL=index.native.js.map

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

@@ -1 +1 @@
-//# sourceMappingURL=index.js.map
+export {};