@aws-amplify/datastore 4.0.10 → 4.0.11-unstableV5.4

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

@@ -5,6 +5,28 @@ import { ModelPredicateCreator } from '../../predicates';
 import { isPredicateObj, isPredicateGroup, OpType, QueryOne, } from '../../types';
 import { getIndex, getIndexFromAssociation, isModelConstructor, isPrivateMode, traverseModel, validatePredicate, inMemoryPagination, keysEqual, getStorename, getIndexKeys, extractPrimaryKeyValues, isSafariCompatabilityMode, } from '../../util';
 var logger = new Logger('DataStore');
+/**
+ * The point after which queries composed of multiple simple OR conditions
+ * should scan-and-filter instead of individual queries for each condition.
+ *
+ * At some point, this should be configurable and/or dynamic based on table
+ * size and possibly even on observed average seek latency. For now, it's
+ * based on an manual "binary search" for the breakpoint as measured in the
+ * unit test suite. This isn't necessarily optimal. But, it's at least derived
+ * empirically, rather than theoretically and without any verification!
+ *
+ * REMEMBER! If you run more realistic benchmarks and update this value, update
+ * this comment so the validity and accuracy of future query tuning exercises
+ * can be compared to the methods used to derive the current value. E.g.,
+ *
+ * 1. In browser benchmark > unit test benchmark
+ * 2. Multi-browser benchmark > single browser benchmark
+ * 3. Benchmarks of various table sizes > static table size benchmark
+ *
+ * etc...
+ *
+ */
+var MULTI_OR_CONDITION_SCAN_BREAKPOINT = 7;
 var DB_NAME = 'amplify-datastore';
 var IndexedDBAdapter = /** @class */ (function () {
     function IndexedDBAdapter() {
@@ -501,140 +523,247 @@ var IndexedDBAdapter = /** @class */ (function () {
         }
         return keyValues.length === keyPath.length ? keyValues : undefined;
     };
-    IndexedDBAdapter.prototype.matchingIndex = function (storeName, fieldName, transaction) {
-        var e_4, _a;
-        var store = transaction.objectStore(storeName);
+    /**
+     * Tries to generate an index fetcher for the given predicates. Assumes
+     * that the given predicate conditions are contained by an AND group and
+     * should therefore all match a single record.
+     *
+     * @param storeName The table to query.
+     * @param predicates The predicates to try to AND together.
+     * @param transaction
+     */
+    IndexedDBAdapter.prototype.matchingIndexQueries = function (storeName, predicates, transaction) {
+        var e_4, _a, e_5, _b;
+        var _this = this;
+        // could be expanded later to include `exec()` and a `cardinality` estimate?
+        var queries = [];
+        var predicateIndex = new Map();
         try {
-            for (var _b = __values(store.indexNames), _c = _b.next(); !_c.done; _c = _b.next()) {
-                var name_1 = _c.value;
-                var idx = store.index(name_1);
-                if (idx.keyPath === fieldName) {
-                    return idx;
-                }
+            for (var predicates_1 = __values(predicates), predicates_1_1 = predicates_1.next(); !predicates_1_1.done; predicates_1_1 = predicates_1.next()) {
+                var predicate = predicates_1_1.value;
+                predicateIndex.set(String(predicate.field), predicate);
             }
         }
         catch (e_4_1) { e_4 = { error: e_4_1 }; }
         finally {
             try {
-                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                if (predicates_1_1 && !predicates_1_1.done && (_a = predicates_1.return)) _a.call(predicates_1);
             }
             finally { if (e_4) throw e_4.error; }
         }
+        var store = transaction.objectStore(storeName);
+        var _loop_2 = function (name_1) {
+            var e_6, _a;
+            var idx = store.index(name_1);
+            var keypath = Array.isArray(idx.keyPath) ? idx.keyPath : [idx.keyPath];
+            var matchingPredicateValues = [];
+            try {
+                for (var keypath_1 = (e_6 = void 0, __values(keypath)), keypath_1_1 = keypath_1.next(); !keypath_1_1.done; keypath_1_1 = keypath_1.next()) {
+                    var field = keypath_1_1.value;
+                    var p = predicateIndex.get(field);
+                    if (p) {
+                        matchingPredicateValues.push(String(p.operand));
+                    }
+                    else {
+                        break;
+                    }
+                }
+            }
+            catch (e_6_1) { e_6 = { error: e_6_1 }; }
+            finally {
+                try {
+                    if (keypath_1_1 && !keypath_1_1.done && (_a = keypath_1.return)) _a.call(keypath_1);
+                }
+                finally { if (e_6) throw e_6.error; }
+            }
+            // if we have a matching predicate field for each component of this index,
+            // we can build a query for it. otherwise, we can't.
+            if (matchingPredicateValues.length === keypath.length) {
+                // re-create a transaction, because the transaction used to fetch the
+                // indexes may no longer be active.
+                queries.push(function () {
+                    return _this.db
+                        .transaction(storeName)
+                        .objectStore(storeName)
+                        .index(name_1)
+                        .getAll(_this.canonicalKeyPath(matchingPredicateValues));
+                });
+            }
+        };
+        try {
+            for (var _c = __values(store.indexNames), _d = _c.next(); !_d.done; _d = _c.next()) {
+                var name_1 = _d.value;
+                _loop_2(name_1);
+            }
+        }
+        catch (e_5_1) { e_5 = { error: e_5_1 }; }
+        finally {
+            try {
+                if (_d && !_d.done && (_b = _c.return)) _b.call(_c);
+            }
+            finally { if (e_5) throw e_5.error; }
+        }
+        return queries;
     };
-    IndexedDBAdapter.prototype.filterOnPredicate = function (storeName, predicates) {
+    IndexedDBAdapter.prototype.baseQueryIndex = function (storeName, predicates, transaction) {
         return __awaiter(this, void 0, void 0, function () {
-            var predicateObjs, type, candidateResults, fieldPredicates, txn, predicateIndexes, actualPredicateIndexes, predicateIndex, distinctResults, predicateIndexes_1, predicateIndexes_1_1, predicateIndex, resultGroup, resultGroup_1, resultGroup_1_1, item, e_5_1, filtered;
-            var e_5, _a, e_6, _b;
+            var predicateObjs, type, fieldPredicates, txn, result, groupQueries, objectQueries, indexedQueries;
             var _this = this;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
                     case 0:
                         predicateObjs = predicates.predicates, type = predicates.type;
                         // the predicate objects we care about tend to be nested at least
                         // one level down: `{and: {or: {and: { <the predicates we want> }}}}`
                         // so, we unpack and/or groups until we find a group with more than 1
                         // child OR a child that is not a group (and is therefore a predicate "object").
-                        while (predicateObjs.length === 1 && isPredicateGroup(predicateObjs[0])) {
+                        while (predicateObjs.length === 1 &&
+                            isPredicateGroup(predicateObjs[0]) &&
+                            predicateObjs[0].type !== 'not') {
                             type = predicateObjs[0].type;
                             predicateObjs = predicateObjs[0].predicates;
                         }
-                        fieldPredicates = predicateObjs.filter(function (p) {
-                            return isPredicateObj(p);
+                        fieldPredicates = predicateObjs.filter(function (p) { return isPredicateObj(p) && p.operator === 'eq'; });
+                        txn = transaction || this.db.transaction(storeName);
+                        result = {};
+                        if (!(type === 'or')) return [3 /*break*/, 2];
+                        return [4 /*yield*/, Promise.all(predicateObjs
+                                .filter(function (o) { return isPredicateGroup(o) && o.type === 'and'; })
+                                .map(function (o) {
+                                return _this.baseQueryIndex(storeName, o, txn);
+                            })).then(function (queries) {
+                                return queries
+                                    .filter(function (q) { return q.indexedQueries.length === 1; })
+                                    .map(function (i) { return i.indexedQueries; });
+                            })];
+                    case 1:
+                        groupQueries = _a.sent();
+                        objectQueries = predicateObjs
+                            .filter(function (o) { return isPredicateObj(o); })
+                            .map(function (o) {
+                            return _this.matchingIndexQueries(storeName, [o], txn);
                         });
-                        txn = this.db.transaction(storeName);
-                        predicateIndexes = fieldPredicates.map(function (p) {
-                            return {
-                                predicate: p,
-                                index: _this.matchingIndex(storeName, String(p.field), txn),
+                        indexedQueries = __spread(groupQueries, objectQueries).map(function (q) { return q[0]; })
+                            .filter(function (i) { return i; });
+                        // if, after hunting for base queries, we don't have exactly 1 base query
+                        // for each child group + object, stop trying to optimize. we're not dealing
+                        // with a simple query that fits the intended optimization path.
+                        if (predicateObjs.length > indexedQueries.length) {
+                            result = {
+                                groupType: null,
+                                indexedQueries: [],
                             };
-                        });
-                        // Explicitly wait for txns from index queries to complete before proceding.
-                        // This helps ensure IndexedDB is in a stable, ready state. Else, subseqeuent
-                        // qeuries can sometimes appear to deadlock (at least in FakeIndexedDB).
+                        }
+                        else {
+                            result = {
+                                groupType: 'or',
+                                indexedQueries: indexedQueries,
+                            };
+                        }
+                        return [3 /*break*/, 3];
+                    case 2:
+                        if (type === 'and') {
+                            // our potential indexes or lacks thereof.
+                            // note that we're only optimizing for `eq` right now.
+                            result = {
+                                groupType: type,
+                                indexedQueries: this.matchingIndexQueries(storeName, fieldPredicates, txn),
+                            };
+                        }
+                        else {
+                            result = {
+                                groupType: null,
+                                indexedQueries: [],
+                            };
+                        }
+                        _a.label = 3;
+                    case 3:
+                        if (!!transaction) return [3 /*break*/, 5];
                         return [4 /*yield*/, txn.done];
+                    case 4:
+                        _a.sent();
+                        _a.label = 5;
+                    case 5: return [2 /*return*/, result];
+                }
+            });
+        });
+    };
+    IndexedDBAdapter.prototype.filterOnPredicate = function (storeName, predicates) {
+        return __awaiter(this, void 0, void 0, function () {
+            var predicateObjs, type, _a, groupType, indexedQueries, candidateResults, distinctResults, indexedQueries_1, indexedQueries_1_1, query, resultGroup, resultGroup_1, resultGroup_1_1, item, distinctificationString, e_7_1, filtered;
+            var e_7, _b, e_8, _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        predicateObjs = predicates.predicates, type = predicates.type;
+                        return [4 /*yield*/, this.baseQueryIndex(storeName, predicates)];
                     case 1:
-                        // Explicitly wait for txns from index queries to complete before proceding.
-                        // This helps ensure IndexedDB is in a stable, ready state. Else, subseqeuent
-                        // qeuries can sometimes appear to deadlock (at least in FakeIndexedDB).
-                        _c.sent();
-                        if (!(type === 'and')) return [3 /*break*/, 6];
-                        actualPredicateIndexes = predicateIndexes.filter(function (i) { return i.index && i.predicate.operator === 'eq'; });
-                        if (!(actualPredicateIndexes.length > 0)) return [3 /*break*/, 3];
-                        predicateIndex = actualPredicateIndexes[0];
-                        return [4 /*yield*/, predicateIndex.index.getAll(predicateIndex.predicate.operand)];
+                        _a = _d.sent(), groupType = _a.groupType, indexedQueries = _a.indexedQueries;
+                        if (!(groupType === 'and' && indexedQueries.length > 0)) return [3 /*break*/, 3];
+                        return [4 /*yield*/, indexedQueries[0]()];
                     case 2:
-                        candidateResults = (_c.sent());
-                        return [3 /*break*/, 5];
-                    case 3: return [4 /*yield*/, this.getAll(storeName)];
+                        // each condition must be satsified, we can form a base set with any
+                        // ONE of those conditions and then filter.
+                        candidateResults = _d.sent();
+                        return [3 /*break*/, 14];
+                    case 3:
+                        if (!(groupType === 'or' &&
+                            indexedQueries.length > 0 &&
+                            indexedQueries.length <= MULTI_OR_CONDITION_SCAN_BREAKPOINT)) return [3 /*break*/, 12];
+                        distinctResults = new Map();
+                        _d.label = 4;
                     case 4:
-                        // no usable indexes
-                        candidateResults = (_c.sent());
-                        _c.label = 5;
-                    case 5: return [3 /*break*/, 20];
+                        _d.trys.push([4, 9, 10, 11]);
+                        indexedQueries_1 = __values(indexedQueries), indexedQueries_1_1 = indexedQueries_1.next();
+                        _d.label = 5;
+                    case 5:
+                        if (!!indexedQueries_1_1.done) return [3 /*break*/, 8];
+                        query = indexedQueries_1_1.value;
+                        return [4 /*yield*/, query()];
                     case 6:
-                        if (!(type === 'or')) return [3 /*break*/, 18];
-                        if (!(predicateIndexes.length > 0 &&
-                            predicateIndexes.every(function (i) { return i.index && i.predicate.operator === 'eq'; }))) return [3 /*break*/, 15];
-                        distinctResults = new Map();
-                        _c.label = 7;
-                    case 7:
-                        _c.trys.push([7, 12, 13, 14]);
-                        predicateIndexes_1 = __values(predicateIndexes), predicateIndexes_1_1 = predicateIndexes_1.next();
-                        _c.label = 8;
-                    case 8:
-                        if (!!predicateIndexes_1_1.done) return [3 /*break*/, 11];
-                        predicateIndex = predicateIndexes_1_1.value;
-                        return [4 /*yield*/, predicateIndex.index.getAll(predicateIndex.predicate.operand)];
-                    case 9:
-                        resultGroup = (_c.sent());
+                        resultGroup = _d.sent();
                         try {
-                            for (resultGroup_1 = (e_6 = void 0, __values(resultGroup)), resultGroup_1_1 = resultGroup_1.next(); !resultGroup_1_1.done; resultGroup_1_1 = resultGroup_1.next()) {
+                            for (resultGroup_1 = (e_8 = void 0, __values(resultGroup)), resultGroup_1_1 = resultGroup_1.next(); !resultGroup_1_1.done; resultGroup_1_1 = resultGroup_1.next()) {
                                 item = resultGroup_1_1.value;
-                                // TODO: custom PK
-                                distinctResults.set(item.id, item);
+                                distinctificationString = JSON.stringify(item);
+                                distinctResults.set(distinctificationString, item);
                             }
                         }
-                        catch (e_6_1) { e_6 = { error: e_6_1 }; }
+                        catch (e_8_1) { e_8 = { error: e_8_1 }; }
                         finally {
                             try {
-                                if (resultGroup_1_1 && !resultGroup_1_1.done && (_b = resultGroup_1.return)) _b.call(resultGroup_1);
+                                if (resultGroup_1_1 && !resultGroup_1_1.done && (_c = resultGroup_1.return)) _c.call(resultGroup_1);
                             }
-                            finally { if (e_6) throw e_6.error; }
+                            finally { if (e_8) throw e_8.error; }
                         }
-                        _c.label = 10;
+                        _d.label = 7;
+                    case 7:
+                        indexedQueries_1_1 = indexedQueries_1.next();
+                        return [3 /*break*/, 5];
+                    case 8: return [3 /*break*/, 11];
+                    case 9:
+                        e_7_1 = _d.sent();
+                        e_7 = { error: e_7_1 };
+                        return [3 /*break*/, 11];
                     case 10:
-                        predicateIndexes_1_1 = predicateIndexes_1.next();
-                        return [3 /*break*/, 8];
-                    case 11: return [3 /*break*/, 14];
-                    case 12:
-                        e_5_1 = _c.sent();
-                        e_5 = { error: e_5_1 };
-                        return [3 /*break*/, 14];
-                    case 13:
                         try {
-                            if (predicateIndexes_1_1 && !predicateIndexes_1_1.done && (_a = predicateIndexes_1.return)) _a.call(predicateIndexes_1);
+                            if (indexedQueries_1_1 && !indexedQueries_1_1.done && (_b = indexedQueries_1.return)) _b.call(indexedQueries_1);
                         }
-                        finally { if (e_5) throw e_5.error; }
+                        finally { if (e_7) throw e_7.error; }
                         return [7 /*endfinally*/];
-                    case 14:
+                    case 11:
                         // we could conceivably check for special conditions and return early here.
                         // but, this is simpler and has not yet had a measurable performance impact.
                         candidateResults = Array.from(distinctResults.values());
-                        return [3 /*break*/, 17];
-                    case 15: return [4 /*yield*/, this.getAll(storeName)];
-                    case 16:
-                        // either no usable indexes or not all conditions can use one.
-                        candidateResults = (_c.sent());
-                        _c.label = 17;
-                    case 17: return [3 /*break*/, 20];
-                    case 18: return [4 /*yield*/, this.getAll(storeName)];
-                    case 19:
+                        return [3 /*break*/, 14];
+                    case 12: return [4 /*yield*/, this.getAll(storeName)];
+                    case 13:
                         // nothing intelligent we can do with `not` groups unless or until we start
                         // smashing comparison operators against indexes -- at which point we could
                         // perform some reversal here.
-                        candidateResults = (_c.sent());
-                        _c.label = 20;
-                    case 20:
+                        candidateResults = (_d.sent());
+                        _d.label = 14;
+                    case 14:
                         filtered = predicateObjs
                             ? candidateResults.filter(function (m) { return validatePredicate(m, type, predicateObjs); })
                             : candidateResults;
@@ -815,9 +944,9 @@ var IndexedDBAdapter = /** @class */ (function () {
         });
     };
     IndexedDBAdapter.prototype.deleteItem = function (deleteQueue) {
-        var e_7, _a, e_8, _b;
+        var e_9, _a, e_10, _b;
         return __awaiter(this, void 0, void 0, function () {
-            var connectionStoreNames, tx, _c, _d, deleteItem, storeName, items, store, items_1, items_1_1, item, key, keyValues, itemKey, e_8_1, e_7_1;
+            var connectionStoreNames, tx, _c, _d, deleteItem, storeName, items, store, items_1, items_1_1, item, key, keyValues, itemKey, e_10_1, e_9_1;
             return __generator(this, function (_e) {
                 switch (_e.label) {
                     case 0:
@@ -871,8 +1000,8 @@ var IndexedDBAdapter = /** @class */ (function () {
                     case 12: return [3 /*break*/, 5];
                     case 13: return [3 /*break*/, 20];
                     case 14:
-                        e_8_1 = _e.sent();
-                        e_8 = { error: e_8_1 };
+                        e_10_1 = _e.sent();
+                        e_10 = { error: e_10_1 };
                         return [3 /*break*/, 20];
                     case 15:
                         _e.trys.push([15, , 18, 19]);
@@ -883,14 +1012,14 @@ var IndexedDBAdapter = /** @class */ (function () {
                         _e.label = 17;
                     case 17: return [3 /*break*/, 19];
                     case 18:
-                        if (e_8) throw e_8.error;
+                        if (e_10) throw e_10.error;
                         return [7 /*endfinally*/];
                     case 19: return [7 /*endfinally*/];
                     case 20: return [3 /*break*/, 2];
                     case 21: return [3 /*break*/, 28];
                     case 22:
-                        e_7_1 = _e.sent();
-                        e_7 = { error: e_7_1 };
+                        e_9_1 = _e.sent();
+                        e_9 = { error: e_9_1 };
                         return [3 /*break*/, 28];
                     case 23:
                         _e.trys.push([23, , 26, 27]);
@@ -901,7 +1030,7 @@ var IndexedDBAdapter = /** @class */ (function () {
                         _e.label = 25;
                     case 25: return [3 /*break*/, 27];
                     case 26:
-                        if (e_7) throw e_7.error;
+                        if (e_9) throw e_9.error;
                         return [7 /*endfinally*/];
                     case 27: return [7 /*endfinally*/];
                     case 28: return [2 /*return*/];
@@ -911,9 +1040,9 @@ var IndexedDBAdapter = /** @class */ (function () {
     };
     IndexedDBAdapter.prototype.deleteTraverse = function (relations, models, srcModel, nameSpace, deleteQueue) {
         var relations_1, relations_1_1, models_1, models_1_1, models_2, models_2_1;
-        var e_9, _a, e_10, _b, e_11, _c;
+        var e_11, _a, e_12, _b, e_13, _c;
         return __awaiter(this, void 0, void 0, function () {
-            var rel, relationType, modelName, targetName, targetNames, associatedWith, storeName, _d, model, hasOneIndex, values, recordToDelete, index, values, value, recordToDelete, e_10_1, model, index, keyValues, childrenArray, e_11_1, e_9_1;
+            var rel, relationType, modelName, targetName, targetNames, associatedWith, storeName, _d, model, hasOneIndex, values, recordToDelete, index, values, value, recordToDelete, e_12_1, model, index, keyValues, childrenArray, e_13_1, e_11_1;
             var _this = this;
             return __generator(this, function (_e) {
                 switch (_e.label) {
@@ -997,8 +1126,8 @@ var IndexedDBAdapter = /** @class */ (function () {
                     case 11: return [3 /*break*/, 4];
                     case 12: return [3 /*break*/, 19];
                     case 13:
-                        e_10_1 = _e.sent();
-                        e_10 = { error: e_10_1 };
+                        e_12_1 = _e.sent();
+                        e_12 = { error: e_12_1 };
                         return [3 /*break*/, 19];
                     case 14:
                         _e.trys.push([14, , 17, 18]);
@@ -1009,7 +1138,7 @@ var IndexedDBAdapter = /** @class */ (function () {
                         _e.label = 16;
                     case 16: return [3 /*break*/, 18];
                     case 17:
-                        if (e_10) throw e_10.error;
+                        if (e_12) throw e_12.error;
                         return [7 /*endfinally*/];
                     case 18: return [7 /*endfinally*/];
                     case 19: return [3 /*break*/, 36];
@@ -1044,8 +1173,8 @@ var IndexedDBAdapter = /** @class */ (function () {
                     case 25: return [3 /*break*/, 21];
                     case 26: return [3 /*break*/, 33];
                     case 27:
-                        e_11_1 = _e.sent();
-                        e_11 = { error: e_11_1 };
+                        e_13_1 = _e.sent();
+                        e_13 = { error: e_13_1 };
                         return [3 /*break*/, 33];
                     case 28:
                         _e.trys.push([28, , 31, 32]);
@@ -1056,7 +1185,7 @@ var IndexedDBAdapter = /** @class */ (function () {
                         _e.label = 30;
                     case 30: return [3 /*break*/, 32];
                     case 31:
-                        if (e_11) throw e_11.error;
+                        if (e_13) throw e_13.error;
                         return [7 /*endfinally*/];
                     case 32: return [7 /*endfinally*/];
                     case 33: return [3 /*break*/, 36];
@@ -1067,8 +1196,8 @@ var IndexedDBAdapter = /** @class */ (function () {
                     case 36: return [3 /*break*/, 1];
                     case 37: return [3 /*break*/, 44];
                     case 38:
-                        e_9_1 = _e.sent();
-                        e_9 = { error: e_9_1 };
+                        e_11_1 = _e.sent();
+                        e_11 = { error: e_11_1 };
                         return [3 /*break*/, 44];
                     case 39:
                         _e.trys.push([39, , 42, 43]);
@@ -1079,7 +1208,7 @@ var IndexedDBAdapter = /** @class */ (function () {
                         _e.label = 41;
                     case 41: return [3 /*break*/, 43];
                     case 42:
-                        if (e_9) throw e_9.error;
+                        if (e_11) throw e_11.error;
                         return [7 /*endfinally*/];
                     case 43: return [7 /*endfinally*/];
                     case 44:
@@ -1115,8 +1244,8 @@ var IndexedDBAdapter = /** @class */ (function () {
     };
     IndexedDBAdapter.prototype.batchSave = function (modelConstructor, items) {
         return __awaiter(this, void 0, void 0, function () {
-            var result, storeName, txn, store, _loop_2, this_1, items_2, items_2_1, item, e_12_1;
-            var e_12, _a;
+            var result, storeName, txn, store, _loop_3, this_1, items_2, items_2_1, item, e_14_1;
+            var e_14, _a;
             var _this = this;
             return __generator(this, function (_b) {
                 switch (_b.label) {
@@ -1131,7 +1260,7 @@ var IndexedDBAdapter = /** @class */ (function () {
                         storeName = this.getStorenameForModel(modelConstructor);
                         txn = this.db.transaction(storeName, 'readwrite');
                         store = txn.store;
-                        _loop_2 = function (item) {
+                        _loop_3 = function (item) {
                             var namespaceName, modelName, model, connectedModels, keyValues, _deleted, index, key, instance;
                             return __generator(this, function (_a) {
                                 switch (_a.label) {
@@ -1180,7 +1309,7 @@ var IndexedDBAdapter = /** @class */ (function () {
                     case 3:
                         if (!!items_2_1.done) return [3 /*break*/, 6];
                         item = items_2_1.value;
-                        return [5 /*yield**/, _loop_2(item)];
+                        return [5 /*yield**/, _loop_3(item)];
                     case 4:
                         _b.sent();
                         _b.label = 5;
@@ -1189,14 +1318,14 @@ var IndexedDBAdapter = /** @class */ (function () {
                         return [3 /*break*/, 3];
                     case 6: return [3 /*break*/, 9];
                     case 7:
-                        e_12_1 = _b.sent();
-                        e_12 = { error: e_12_1 };
+                        e_14_1 = _b.sent();
+                        e_14 = { error: e_14_1 };
                         return [3 /*break*/, 9];
                     case 8:
                         try {
                             if (items_2_1 && !items_2_1.done && (_a = items_2.return)) _a.call(items_2);
                         }
-                        finally { if (e_12) throw e_12.error; }
+                        finally { if (e_14) throw e_14.error; }
                         return [7 /*endfinally*/];
                     case 9: return [4 /*yield*/, txn.done];
                     case 10: