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

package/lib-esm/predicates/sort.js

@@ -1,20 +1,18 @@
-var ModelSortPredicateCreator = /** @class */ (function () {
-    function ModelSortPredicateCreator() {
-    }
-    ModelSortPredicateCreator.createPredicateBuilder = function (modelDefinition) {
-        var modelName = modelDefinition.name;
-        var fieldNames = new Set(Object.keys(modelDefinition.fields));
-        var handler;
-        var predicate = new Proxy({}, (handler = {
-            get: function (_target, propertyKey, receiver) {
-                var field = propertyKey;
+class ModelSortPredicateCreator {
+    static createPredicateBuilder(modelDefinition) {
+        const { name: modelName } = modelDefinition;
+        const fieldNames = new Set(Object.keys(modelDefinition.fields));
+        let handler;
+        const predicate = new Proxy({}, (handler = {
+            get(_target, propertyKey, receiver) {
+                const field = propertyKey;
                 if (!fieldNames.has(field)) {
-                    throw new Error("Invalid field for model. field: " + field + ", model: " + modelName);
+                    throw new Error(`Invalid field for model. field: ${String(field)}, model: ${modelName}`);
                 }
-                var result = function (sortDirection) {
-                    var _a;
-                    (_a = ModelSortPredicateCreator.sortPredicateGroupsMap
-                        .get(receiver)) === null || _a === void 0 ? void 0 : _a.push({ field: field, sortDirection: sortDirection });
+                const result = (sortDirection) => {
+                    ModelSortPredicateCreator.sortPredicateGroupsMap
+                        .get(receiver)
+                        ?.push({ field, sortDirection });
                     return receiver;
                 };
                 return result;
@@ -22,33 +20,30 @@ var ModelSortPredicateCreator = /** @class */ (function () {
         }));
         ModelSortPredicateCreator.sortPredicateGroupsMap.set(predicate, []);
         return predicate;
-    };
-    ModelSortPredicateCreator.isValidPredicate = function (predicate) {
+    }
+    static isValidPredicate(predicate) {
         return ModelSortPredicateCreator.sortPredicateGroupsMap.has(predicate);
-    };
-    ModelSortPredicateCreator.getPredicates = function (predicate, throwOnInvalid) {
-        if (throwOnInvalid === void 0) { throwOnInvalid = true; }
+    }
+    static getPredicates(predicate, throwOnInvalid = true) {
         if (throwOnInvalid &&
             !ModelSortPredicateCreator.isValidPredicate(predicate)) {
             throw new Error('The predicate is not valid');
         }
-        var predicateGroup = ModelSortPredicateCreator.sortPredicateGroupsMap.get(predicate);
+        const predicateGroup = ModelSortPredicateCreator.sortPredicateGroupsMap.get(predicate);
         if (predicateGroup) {
             return predicateGroup;
         }
         else {
             throw new Error('Predicate group not found');
         }
-    };
+    }
     // transforms cb-style predicate into Proxy
-    ModelSortPredicateCreator.createFromExisting = function (modelDefinition, existing) {
+    static createFromExisting(modelDefinition, existing) {
         if (!existing || !modelDefinition) {
             return undefined;
         }
         return existing(ModelSortPredicateCreator.createPredicateBuilder(modelDefinition));
-    };
-    ModelSortPredicateCreator.sortPredicateGroupsMap = new WeakMap();
-    return ModelSortPredicateCreator;
-}());
+    }
+}
+ModelSortPredicateCreator.sortPredicateGroupsMap = new WeakMap();
 export { ModelSortPredicateCreator };
-//# sourceMappingURL=sort.js.map

package/lib-esm/ssr/index.js

@@ -1,7 +1,7 @@
 // Helper for converting JSON back into DataStore models (while respecting IDs)
 export function deserializeModel(Model, init) {
     if (Array.isArray(init)) {
-        return init.map(function (init) { return deserializeModel(Model, init); });
+        return init.map(init => deserializeModel(Model, init));
     }
     // `fromJSON` is intentionally hidden from types as a "private" method (though it exists on the instance)
     // @ts-ignore Property 'fromJSON' does not exist on type 'PersistentModelConstructor<T>'.ts(2339)
@@ -11,4 +11,3 @@ export function deserializeModel(Model, init) {
 export function serializeModel(model) {
     return JSON.parse(JSON.stringify(model));
 }
-//# sourceMappingURL=index.js.map

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

@@ -1,26 +1,13 @@
-import { __asyncValues, __awaiter, __extends, __generator, __values } from "tslib";
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 import AsyncStorageDatabase from './AsyncStorageDatabase';
 import { OpType, QueryOne, } from '../../types';
 import { DEFAULT_PRIMARY_KEY_VALUE_SEPARATOR, traverseModel, validatePredicate, inMemoryPagination, keysEqual, getStorename, getIndexKeys, } from '../../util';
 import { StorageAdapterBase } from './StorageAdapterBase';
-var AsyncStorageAdapter = /** @class */ (function (_super) {
-    __extends(AsyncStorageAdapter, _super);
-    function AsyncStorageAdapter() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
+export class AsyncStorageAdapter extends StorageAdapterBase {
     // no-ops for this adapter
-    AsyncStorageAdapter.prototype.preSetUpChecks = function () {
-        return __awaiter(this, void 0, void 0, function () { return __generator(this, function (_a) {
-            return [2 /*return*/];
-        }); });
-    };
-    AsyncStorageAdapter.prototype.preOpCheck = function () {
-        return __awaiter(this, void 0, void 0, function () { return __generator(this, function (_a) {
-            return [2 /*return*/];
-        }); });
-    };
+    async preSetUpChecks() { }
+    async preOpCheck() { }
     /**
      * Open AsyncStorage database
      * Create new DB if one doesn't exist
@@ -29,325 +16,114 @@ var AsyncStorageAdapter = /** @class */ (function (_super) {
      *
      * @returns AsyncStorageDatabase instance
      */
-    AsyncStorageAdapter.prototype.initDb = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var db;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        db = new AsyncStorageDatabase();
-                        return [4 /*yield*/, db.init()];
-                    case 1:
-                        _a.sent();
-                        return [2 /*return*/, db];
-                }
-            });
-        });
-    };
-    AsyncStorageAdapter.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.db.clear()];
-                    case 1:
-                        _a.sent();
-                        this.db = undefined;
-                        this.initPromise = undefined;
-                        return [2 /*return*/];
-                }
-            });
-        });
-    };
-    AsyncStorageAdapter.prototype.batchSave = function (modelConstructor, items) {
-        return __awaiter(this, void 0, void 0, function () {
-            var modelName, namespaceName, storeName, keys, batch, _loop_1, this_1, items_1, items_1_1, item;
-            var e_1, _a;
-            var _this = this;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        if (items.length === 0) {
-                            return [2 /*return*/, []];
-                        }
-                        modelName = modelConstructor.name;
-                        namespaceName = this.namespaceResolver(modelConstructor);
-                        storeName = getStorename(namespaceName, modelName);
-                        keys = getIndexKeys(this.schema.namespaces[namespaceName], modelName);
-                        batch = [];
-                        _loop_1 = function (item) {
-                            var model = this_1.modelInstanceCreator(modelConstructor, item);
-                            var connectedModels = traverseModel(modelName, model, this_1.schema.namespaces[namespaceName], this_1.modelInstanceCreator, this_1.getModelConstructorByModelName);
-                            var keyValuesPath = this_1.getIndexKeyValuesPath(model);
-                            var instance = connectedModels.find(function (_a) {
-                                var instance = _a.instance;
-                                var instanceKeyValuesPath = _this.getIndexKeyValuesPath(instance);
-                                return keysEqual([instanceKeyValuesPath], [keyValuesPath]);
-                            }).instance;
-                            batch.push(instance);
-                        };
-                        this_1 = this;
-                        try {
-                            for (items_1 = __values(items), items_1_1 = items_1.next(); !items_1_1.done; items_1_1 = items_1.next()) {
-                                item = items_1_1.value;
-                                _loop_1(item);
-                            }
-                        }
-                        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-                        finally {
-                            try {
-                                if (items_1_1 && !items_1_1.done && (_a = items_1.return)) _a.call(items_1);
-                            }
-                            finally { if (e_1) throw e_1.error; }
-                        }
-                        return [4 /*yield*/, this.db.batchSave(storeName, batch, keys)];
-                    case 1: return [2 /*return*/, _b.sent()];
-                }
-            });
-        });
-    };
-    AsyncStorageAdapter.prototype._get = function (storeName, keyArr) {
-        return __awaiter(this, void 0, void 0, function () {
-            var itemKeyValuesPath;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        itemKeyValuesPath = keyArr.join(DEFAULT_PRIMARY_KEY_VALUE_SEPARATOR);
-                        return [4 /*yield*/, this.db.get(itemKeyValuesPath, storeName)];
-                    case 1: return [2 /*return*/, _a.sent()];
-                }
-            });
-        });
-    };
-    AsyncStorageAdapter.prototype.save = function (model, condition) {
-        var e_2, _a;
-        return __awaiter(this, void 0, void 0, function () {
-            var _b, storeName, connectionStoreNames, modelKeyValues, fromDB, result, connectionStoreNames_1, connectionStoreNames_1_1, resItem, storeName_1, item, instance, keys, itemKeyValues, fromDB_1, opType, e_2_1;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        _b = this.saveMetadata(model), storeName = _b.storeName, connectionStoreNames = _b.connectionStoreNames, modelKeyValues = _b.modelKeyValues;
-                        return [4 /*yield*/, this._get(storeName, modelKeyValues)];
-                    case 1:
-                        fromDB = _c.sent();
-                        this.validateSaveCondition(condition, fromDB);
-                        result = [];
-                        _c.label = 2;
-                    case 2:
-                        _c.trys.push([2, 9, 10, 15]);
-                        connectionStoreNames_1 = __asyncValues(connectionStoreNames);
-                        _c.label = 3;
-                    case 3: return [4 /*yield*/, connectionStoreNames_1.next()];
-                    case 4:
-                        if (!(connectionStoreNames_1_1 = _c.sent(), !connectionStoreNames_1_1.done)) return [3 /*break*/, 8];
-                        resItem = connectionStoreNames_1_1.value;
-                        storeName_1 = resItem.storeName, item = resItem.item, instance = resItem.instance, keys = resItem.keys;
-                        itemKeyValues = keys.map(function (key) { return item[key]; });
-                        return [4 /*yield*/, this._get(storeName_1, itemKeyValues)];
-                    case 5:
-                        fromDB_1 = _c.sent();
-                        opType = fromDB_1 ? OpType.UPDATE : OpType.INSERT;
-                        if (!(keysEqual(itemKeyValues, modelKeyValues) ||
-                            opType === OpType.INSERT)) return [3 /*break*/, 7];
-                        return [4 /*yield*/, this.db.save(item, storeName_1, keys, itemKeyValues.join(DEFAULT_PRIMARY_KEY_VALUE_SEPARATOR))];
-                    case 6:
-                        _c.sent();
-                        result.push([instance, opType]);
-                        _c.label = 7;
-                    case 7: return [3 /*break*/, 3];
-                    case 8: return [3 /*break*/, 15];
-                    case 9:
-                        e_2_1 = _c.sent();
-                        e_2 = { error: e_2_1 };
-                        return [3 /*break*/, 15];
-                    case 10:
-                        _c.trys.push([10, , 13, 14]);
-                        if (!(connectionStoreNames_1_1 && !connectionStoreNames_1_1.done && (_a = connectionStoreNames_1.return))) return [3 /*break*/, 12];
-                        return [4 /*yield*/, _a.call(connectionStoreNames_1)];
-                    case 11:
-                        _c.sent();
-                        _c.label = 12;
-                    case 12: return [3 /*break*/, 14];
-                    case 13:
-                        if (e_2) throw e_2.error;
-                        return [7 /*endfinally*/];
-                    case 14: return [7 /*endfinally*/];
-                    case 15: return [2 /*return*/, result];
-                }
-            });
-        });
-    };
-    AsyncStorageAdapter.prototype.query = function (modelConstructor, predicate, pagination) {
-        return __awaiter(this, void 0, void 0, function () {
-            var _a, storeName, namespaceName, queryByKey, predicates, hasSort, hasPagination, records;
-            var _this = this;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        _a = this.queryMetadata(modelConstructor, predicate, pagination), storeName = _a.storeName, namespaceName = _a.namespaceName, queryByKey = _a.queryByKey, predicates = _a.predicates, hasSort = _a.hasSort, hasPagination = _a.hasPagination;
-                        return [4 /*yield*/, (function () { return __awaiter(_this, void 0, void 0, function () {
-                                var keyValues, record, filtered, all;
-                                return __generator(this, function (_a) {
-                                    switch (_a.label) {
-                                        case 0:
-                                            if (!queryByKey) return [3 /*break*/, 2];
-                                            keyValues = queryByKey.join(DEFAULT_PRIMARY_KEY_VALUE_SEPARATOR);
-                                            return [4 /*yield*/, this.getByKey(storeName, keyValues)];
-                                        case 1:
-                                            record = _a.sent();
-                                            return [2 /*return*/, record ? [record] : []];
-                                        case 2:
-                                            if (!predicates) return [3 /*break*/, 4];
-                                            return [4 /*yield*/, this.filterOnPredicate(storeName, predicates)];
-                                        case 3:
-                                            filtered = _a.sent();
-                                            return [2 /*return*/, this.inMemoryPagination(filtered, pagination)];
-                                        case 4:
-                                            if (!(hasSort || hasPagination)) return [3 /*break*/, 6];
-                                            return [4 /*yield*/, this.getAll(storeName)];
-                                        case 5:
-                                            all = _a.sent();
-                                            return [2 /*return*/, this.inMemoryPagination(all, pagination)];
-                                        case 6: return [2 /*return*/, this.getAll(storeName)];
-                                    }
-                                });
-                            }); })()];
-                    case 1:
-                        records = (_b.sent());
-                        return [4 /*yield*/, this.load(namespaceName, modelConstructor.name, records)];
-                    case 2: return [2 /*return*/, _b.sent()];
-                }
-            });
-        });
-    };
-    AsyncStorageAdapter.prototype.getByKey = function (storeName, keyValuePath) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.db.get(keyValuePath, storeName)];
-                    case 1: return [2 /*return*/, _a.sent()];
-                }
-            });
-        });
-    };
-    AsyncStorageAdapter.prototype.getAll = function (storeName) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.db.getAll(storeName)];
-                    case 1: return [2 /*return*/, _a.sent()];
-                }
-            });
-        });
-    };
-    AsyncStorageAdapter.prototype.filterOnPredicate = function (storeName, predicates) {
-        return __awaiter(this, void 0, void 0, function () {
-            var predicateObjs, type, all, filtered;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        predicateObjs = predicates.predicates, type = predicates.type;
-                        return [4 /*yield*/, this.getAll(storeName)];
-                    case 1:
-                        all = _a.sent();
-                        filtered = predicateObjs
-                            ? all.filter(function (m) { return validatePredicate(m, type, predicateObjs); })
-                            : all;
-                        return [2 /*return*/, filtered];
-                }
+    async initDb() {
+        const db = new AsyncStorageDatabase();
+        await db.init();
+        return db;
+    }
+    async clear() {
+        await this.db.clear();
+        this.db = undefined;
+        this.initPromise = undefined;
+    }
+    async batchSave(modelConstructor, items) {
+        if (items.length === 0) {
+            return [];
+        }
+        const modelName = modelConstructor.name;
+        const namespaceName = this.namespaceResolver(modelConstructor);
+        const storeName = getStorename(namespaceName, modelName);
+        const keys = getIndexKeys(this.schema.namespaces[namespaceName], modelName);
+        const batch = [];
+        for (const item of items) {
+            const model = this.modelInstanceCreator(modelConstructor, item);
+            const connectedModels = traverseModel(modelName, model, this.schema.namespaces[namespaceName], this.modelInstanceCreator, this.getModelConstructorByModelName);
+            const keyValuesPath = this.getIndexKeyValuesPath(model);
+            const { instance } = connectedModels.find(({ instance }) => {
+                const instanceKeyValuesPath = this.getIndexKeyValuesPath(instance);
+                return keysEqual([instanceKeyValuesPath], [keyValuesPath]);
             });
-        });
-    };
-    AsyncStorageAdapter.prototype.inMemoryPagination = function (records, pagination) {
+            batch.push(instance);
+        }
+        return await this.db.batchSave(storeName, batch, keys);
+    }
+    async _get(storeName, keyArr) {
+        const itemKeyValuesPath = keyArr.join(DEFAULT_PRIMARY_KEY_VALUE_SEPARATOR);
+        return await this.db.get(itemKeyValuesPath, storeName);
+    }
+    async save(model, condition) {
+        const { storeName, connectionStoreNames, modelKeyValues } = this.saveMetadata(model);
+        const fromDB = await this._get(storeName, modelKeyValues);
+        this.validateSaveCondition(condition, fromDB);
+        const result = [];
+        for await (const resItem of connectionStoreNames) {
+            const { storeName, item, instance, keys } = resItem;
+            const itemKeyValues = keys.map(key => item[key]);
+            const fromDB = await this._get(storeName, itemKeyValues);
+            const opType = fromDB ? OpType.UPDATE : OpType.INSERT;
+            if (keysEqual(itemKeyValues, modelKeyValues) ||
+                opType === OpType.INSERT) {
+                await this.db.save(item, storeName, keys, itemKeyValues.join(DEFAULT_PRIMARY_KEY_VALUE_SEPARATOR));
+                result.push([instance, opType]);
+            }
+        }
+        return result;
+    }
+    async query(modelConstructor, predicate, pagination) {
+        const { storeName, namespaceName, queryByKey, predicates, hasSort, hasPagination, } = this.queryMetadata(modelConstructor, predicate, pagination);
+        const records = (await (async () => {
+            if (queryByKey) {
+                const keyValues = queryByKey.join(DEFAULT_PRIMARY_KEY_VALUE_SEPARATOR);
+                const record = await this.getByKey(storeName, keyValues);
+                return record ? [record] : [];
+            }
+            if (predicates) {
+                const filtered = await this.filterOnPredicate(storeName, predicates);
+                return this.inMemoryPagination(filtered, pagination);
+            }
+            if (hasSort || hasPagination) {
+                const all = await this.getAll(storeName);
+                return this.inMemoryPagination(all, pagination);
+            }
+            return this.getAll(storeName);
+        })());
+        return await this.load(namespaceName, modelConstructor.name, records);
+    }
+    async getByKey(storeName, keyValuePath) {
+        return await this.db.get(keyValuePath, storeName);
+    }
+    async getAll(storeName) {
+        return await this.db.getAll(storeName);
+    }
+    async filterOnPredicate(storeName, predicates) {
+        const { predicates: predicateObjs, type } = predicates;
+        const all = await this.getAll(storeName);
+        const filtered = predicateObjs
+            ? all.filter(m => validatePredicate(m, type, predicateObjs))
+            : all;
+        return filtered;
+    }
+    inMemoryPagination(records, pagination) {
         return inMemoryPagination(records, pagination);
-    };
-    AsyncStorageAdapter.prototype.queryOne = function (modelConstructor, firstOrLast) {
-        if (firstOrLast === void 0) { firstOrLast = QueryOne.FIRST; }
-        return __awaiter(this, void 0, void 0, function () {
-            var storeName, result;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        storeName = this.getStorenameForModel(modelConstructor);
-                        return [4 /*yield*/, this.db.getOne(firstOrLast, storeName)];
-                    case 1:
-                        result = _a.sent();
-                        return [2 /*return*/, result && this.modelInstanceCreator(modelConstructor, result)];
-                }
-            });
-        });
-    };
-    AsyncStorageAdapter.prototype.deleteItem = function (deleteQueue) {
-        var e_3, _a, e_4, _b;
-        return __awaiter(this, void 0, void 0, function () {
-            var _c, _d, deleteItem, storeName, items, items_2, items_2_1, item, keyValuesPath, e_4_1, e_3_1;
-            return __generator(this, function (_e) {
-                switch (_e.label) {
-                    case 0:
-                        _e.trys.push([0, 17, 18, 23]);
-                        _c = __asyncValues(deleteQueue);
-                        _e.label = 1;
-                    case 1: return [4 /*yield*/, _c.next()];
-                    case 2:
-                        if (!(_d = _e.sent(), !_d.done)) return [3 /*break*/, 16];
-                        deleteItem = _d.value;
-                        storeName = deleteItem.storeName, items = deleteItem.items;
-                        _e.label = 3;
-                    case 3:
-                        _e.trys.push([3, 9, 10, 15]);
-                        items_2 = __asyncValues(items);
-                        _e.label = 4;
-                    case 4: return [4 /*yield*/, items_2.next()];
-                    case 5:
-                        if (!(items_2_1 = _e.sent(), !items_2_1.done)) return [3 /*break*/, 8];
-                        item = items_2_1.value;
-                        if (!item) return [3 /*break*/, 7];
-                        if (!(typeof item === 'object')) return [3 /*break*/, 7];
-                        keyValuesPath = this.getIndexKeyValuesPath(item);
-                        return [4 /*yield*/, this.db.delete(keyValuesPath, storeName)];
-                    case 6:
-                        _e.sent();
-                        _e.label = 7;
-                    case 7: return [3 /*break*/, 4];
-                    case 8: return [3 /*break*/, 15];
-                    case 9:
-                        e_4_1 = _e.sent();
-                        e_4 = { error: e_4_1 };
-                        return [3 /*break*/, 15];
-                    case 10:
-                        _e.trys.push([10, , 13, 14]);
-                        if (!(items_2_1 && !items_2_1.done && (_b = items_2.return))) return [3 /*break*/, 12];
-                        return [4 /*yield*/, _b.call(items_2)];
-                    case 11:
-                        _e.sent();
-                        _e.label = 12;
-                    case 12: return [3 /*break*/, 14];
-                    case 13:
-                        if (e_4) throw e_4.error;
-                        return [7 /*endfinally*/];
-                    case 14: return [7 /*endfinally*/];
-                    case 15: return [3 /*break*/, 1];
-                    case 16: return [3 /*break*/, 23];
-                    case 17:
-                        e_3_1 = _e.sent();
-                        e_3 = { error: e_3_1 };
-                        return [3 /*break*/, 23];
-                    case 18:
-                        _e.trys.push([18, , 21, 22]);
-                        if (!(_d && !_d.done && (_a = _c.return))) return [3 /*break*/, 20];
-                        return [4 /*yield*/, _a.call(_c)];
-                    case 19:
-                        _e.sent();
-                        _e.label = 20;
-                    case 20: return [3 /*break*/, 22];
-                    case 21:
-                        if (e_3) throw e_3.error;
-                        return [7 /*endfinally*/];
-                    case 22: return [7 /*endfinally*/];
-                    case 23: return [2 /*return*/];
+    }
+    async queryOne(modelConstructor, firstOrLast = QueryOne.FIRST) {
+        const storeName = this.getStorenameForModel(modelConstructor);
+        const result = await this.db.getOne(firstOrLast, storeName);
+        return result && this.modelInstanceCreator(modelConstructor, result);
+    }
+    async deleteItem(deleteQueue) {
+        for await (const deleteItem of deleteQueue) {
+            const { storeName, items } = deleteItem;
+            for await (const item of items) {
+                if (item) {
+                    if (typeof item === 'object') {
+                        const keyValuesPath = this.getIndexKeyValuesPath(item);
+                        await this.db.delete(keyValuesPath, storeName);
+                    }
                 }
-            });
-        });
-    };
+            }
+        }
+    }
     //#region platform-specific helper methods
     /**
      * Retrieves concatenated primary key values from a model
@@ -355,11 +131,8 @@ var AsyncStorageAdapter = /** @class */ (function (_super) {
      * @param model
      * @returns
      */
-    AsyncStorageAdapter.prototype.getIndexKeyValuesPath = function (model) {
+    getIndexKeyValuesPath(model) {
         return this.getIndexKeyValuesFromModel(model).join(DEFAULT_PRIMARY_KEY_VALUE_SEPARATOR);
-    };
-    return AsyncStorageAdapter;
-}(StorageAdapterBase));
-export { AsyncStorageAdapter };
+    }
+}
 export default new AsyncStorageAdapter();
-//# sourceMappingURL=AsyncStorageAdapter.js.map