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

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

@@ -1,97 +1,3 @@
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
-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.");
-};
-var __read = (this && this.__read) || function (o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-};
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 import * as idb from 'idb';
@@ -99,7 +5,7 @@ import { isPredicateObj, isPredicateGroup, OpType, QueryOne, } from '../../types
 import { isPrivateMode, traverseModel, validatePredicate, inMemoryPagination, keysEqual, getStorename, isSafariCompatabilityMode, } from '../../util';
 import { StorageAdapterBase } from './StorageAdapterBase';
 import { ConsoleLogger } from '@aws-amplify/core';
-var logger = new ConsoleLogger('DataStore');
+const logger = new ConsoleLogger('DataStore');
 /**
  * The point after which queries composed of multiple simple OR conditions
  * should scan-and-filter instead of individual queries for each condition.
@@ -121,14 +27,13 @@ var logger = new ConsoleLogger('DataStore');
  * etc...
  *
  */
-var MULTI_OR_CONDITION_SCAN_BREAKPOINT = 7;
+const MULTI_OR_CONDITION_SCAN_BREAKPOINT = 7;
 //
-var DB_VERSION = 3;
-var IndexedDBAdapter = /** @class */ (function (_super) {
-    __extends(IndexedDBAdapter, _super);
-    function IndexedDBAdapter() {
-        var _this = _super !== null && _super.apply(this, arguments) || this;
-        _this.safariCompatabilityMode = false;
+const DB_VERSION = 3;
+class IndexedDBAdapter extends StorageAdapterBase {
+    constructor() {
+        super(...arguments);
+        this.safariCompatabilityMode = false;
         /**
          * Checks the given path against the browser's IndexedDB implementation for
          * necessary compatibility transformations, applying those transforms if needed.
@@ -137,43 +42,22 @@ var IndexedDBAdapter = /** @class */ (function (_super) {
          * @returns An array or string, depending on and given key,
          * that is ensured to be compatible with the IndexedDB implementation's nuances.
          */
-        _this.canonicalKeyPath = function (keyArr) {
-            if (_this.safariCompatabilityMode) {
+        this.canonicalKeyPath = (keyArr) => {
+            if (this.safariCompatabilityMode) {
                 return keyArr.length > 1 ? keyArr : keyArr[0];
             }
             return keyArr;
         };
-        return _this;
         //#endregion
     }
     // checks are called by StorageAdapterBase class
-    IndexedDBAdapter.prototype.preSetUpChecks = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.checkPrivate()];
-                    case 1:
-                        _a.sent();
-                        return [4 /*yield*/, this.setSafariCompatabilityMode()];
-                    case 2:
-                        _a.sent();
-                        return [2 /*return*/];
-                }
-            });
-        });
-    };
-    IndexedDBAdapter.prototype.preOpCheck = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.checkPrivate()];
-                    case 1:
-                        _a.sent();
-                        return [2 /*return*/];
-                }
-            });
-        });
-    };
+    async preSetUpChecks() {
+        await this.checkPrivate();
+        await this.setSafariCompatabilityMode();
+    }
+    async preOpCheck() {
+        await this.checkPrivate();
+    }
     /**
      * Initialize IndexedDB database
      * Create new DB if one doesn't exist
@@ -183,559 +67,245 @@ var IndexedDBAdapter = /** @class */ (function (_super) {
      *
      * @returns IDB Database instance
      */
-    IndexedDBAdapter.prototype.initDb = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var _this = this;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, idb.openDB(this.dbName, DB_VERSION, {
-                            upgrade: function (db, oldVersion, newVersion, txn) { return __awaiter(_this, void 0, void 0, function () {
-                                var _a, _b, storeName, origStore, tmpName, _c, namespaceName, modelName, modelInCurrentSchema, newStore, cursor, count, e_1_1, error_1;
-                                var e_1, _d;
-                                var _this = this;
-                                return __generator(this, function (_e) {
-                                    switch (_e.label) {
-                                        case 0:
-                                            // create new database
-                                            if (oldVersion === 0) {
-                                                Object.keys(this.schema.namespaces).forEach(function (namespaceName) {
-                                                    var namespace = _this.schema.namespaces[namespaceName];
-                                                    Object.keys(namespace.models).forEach(function (modelName) {
-                                                        var storeName = getStorename(namespaceName, modelName);
-                                                        _this.createObjectStoreForModel(db, namespaceName, storeName, modelName);
-                                                    });
-                                                });
-                                                return [2 /*return*/];
-                                            }
-                                            if (!((oldVersion === 1 || oldVersion === 2) && newVersion === 3)) return [3 /*break*/, 16];
-                                            _e.label = 1;
-                                        case 1:
-                                            _e.trys.push([1, 14, , 15]);
-                                            _e.label = 2;
-                                        case 2:
-                                            _e.trys.push([2, 11, 12, 13]);
-                                            _a = __values(txn.objectStoreNames), _b = _a.next();
-                                            _e.label = 3;
-                                        case 3:
-                                            if (!!_b.done) return [3 /*break*/, 10];
-                                            storeName = _b.value;
-                                            origStore = txn.objectStore(storeName);
-                                            tmpName = "tmp_".concat(storeName);
-                                            origStore.name = tmpName;
-                                            _c = this.getNamespaceAndModelFromStorename(storeName), namespaceName = _c.namespaceName, modelName = _c.modelName;
-                                            modelInCurrentSchema = modelName in this.schema.namespaces[namespaceName].models;
-                                            if (!modelInCurrentSchema) {
-                                                // delete original
-                                                db.deleteObjectStore(tmpName);
-                                                return [3 /*break*/, 9];
-                                            }
-                                            newStore = this.createObjectStoreForModel(db, namespaceName, storeName, modelName);
-                                            return [4 /*yield*/, origStore.openCursor()];
-                                        case 4:
-                                            cursor = _e.sent();
-                                            count = 0;
-                                            _e.label = 5;
-                                        case 5:
-                                            if (!(cursor && cursor.value)) return [3 /*break*/, 8];
-                                            // we don't pass key, since they are all new entries in the new store
-                                            return [4 /*yield*/, newStore.put(cursor.value)];
-                                        case 6:
-                                            // we don't pass key, since they are all new entries in the new store
-                                            _e.sent();
-                                            return [4 /*yield*/, cursor.continue()];
-                                        case 7:
-                                            cursor = _e.sent();
-                                            count++;
-                                            return [3 /*break*/, 5];
-                                        case 8:
-                                            // delete original
-                                            db.deleteObjectStore(tmpName);
-                                            logger.debug("".concat(count, " ").concat(storeName, " records migrated"));
-                                            _e.label = 9;
-                                        case 9:
-                                            _b = _a.next();
-                                            return [3 /*break*/, 3];
-                                        case 10: return [3 /*break*/, 13];
-                                        case 11:
-                                            e_1_1 = _e.sent();
-                                            e_1 = { error: e_1_1 };
-                                            return [3 /*break*/, 13];
-                                        case 12:
-                                            try {
-                                                if (_b && !_b.done && (_d = _a.return)) _d.call(_a);
-                                            }
-                                            finally { if (e_1) throw e_1.error; }
-                                            return [7 /*endfinally*/];
-                                        case 13:
-                                            // add new models created after IndexedDB, but before migration
-                                            // this case may happen when a user has not opened an app for
-                                            // some time and a new model is added during that time
-                                            Object.keys(this.schema.namespaces).forEach(function (namespaceName) {
-                                                var namespace = _this.schema.namespaces[namespaceName];
-                                                var objectStoreNames = new Set(txn.objectStoreNames);
-                                                Object.keys(namespace.models)
-                                                    .map(function (modelName) {
-                                                    return [modelName, getStorename(namespaceName, modelName)];
-                                                })
-                                                    .filter(function (_a) {
-                                                    var _b = __read(_a, 2), storeName = _b[1];
-                                                    return !objectStoreNames.has(storeName);
-                                                })
-                                                    .forEach(function (_a) {
-                                                    var _b = __read(_a, 2), modelName = _b[0], storeName = _b[1];
-                                                    _this.createObjectStoreForModel(db, namespaceName, storeName, modelName);
-                                                });
-                                            });
-                                            return [3 /*break*/, 15];
-                                        case 14:
-                                            error_1 = _e.sent();
-                                            logger.error('Error migrating IndexedDB data', error_1);
-                                            txn.abort();
-                                            throw error_1;
-                                        case 15: return [2 /*return*/];
-                                        case 16: return [2 /*return*/];
-                                    }
-                                });
-                            }); },
-                        })];
-                    case 1: return [2 /*return*/, _a.sent()];
+    async initDb() {
+        return await idb.openDB(this.dbName, DB_VERSION, {
+            upgrade: async (db, oldVersion, newVersion, txn) => {
+                // create new database
+                if (oldVersion === 0) {
+                    Object.keys(this.schema.namespaces).forEach(namespaceName => {
+                        const namespace = this.schema.namespaces[namespaceName];
+                        Object.keys(namespace.models).forEach(modelName => {
+                            const storeName = getStorename(namespaceName, modelName);
+                            this.createObjectStoreForModel(db, namespaceName, storeName, modelName);
+                        });
+                    });
+                    return;
                 }
-            });
-        });
-    };
-    IndexedDBAdapter.prototype._get = function (storeOrStoreName, keyArr) {
-        return __awaiter(this, void 0, void 0, function () {
-            var index, storeName, store, result;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (typeof storeOrStoreName === 'string') {
-                            storeName = storeOrStoreName;
-                            index = this.db.transaction(storeName, 'readonly').store.index('byPk');
-                        }
-                        else {
-                            store = storeOrStoreName;
-                            index = store.index('byPk');
+                // migrate existing database to latest schema
+                if ((oldVersion === 1 || oldVersion === 2) && newVersion === 3) {
+                    try {
+                        for (const storeName of txn.objectStoreNames) {
+                            const origStore = txn.objectStore(storeName);
+                            // rename original store
+                            const tmpName = `tmp_${storeName}`;
+                            origStore.name = tmpName;
+                            const { namespaceName, modelName } = this.getNamespaceAndModelFromStorename(storeName);
+                            const modelInCurrentSchema = modelName in this.schema.namespaces[namespaceName].models;
+                            if (!modelInCurrentSchema) {
+                                // delete original
+                                db.deleteObjectStore(tmpName);
+                                continue;
+                            }
+                            const newStore = this.createObjectStoreForModel(db, namespaceName, storeName, modelName);
+                            let cursor = await origStore.openCursor();
+                            let count = 0;
+                            // Copy data from original to new
+                            while (cursor && cursor.value) {
+                                // we don't pass key, since they are all new entries in the new store
+                                await newStore.put(cursor.value);
+                                cursor = await cursor.continue();
+                                count++;
+                            }
+                            // delete original
+                            db.deleteObjectStore(tmpName);
+                            logger.debug(`${count} ${storeName} records migrated`);
                         }
-                        return [4 /*yield*/, index.get(this.canonicalKeyPath(keyArr))];
-                    case 1:
-                        result = _a.sent();
-                        return [2 /*return*/, result];
-                }
-            });
-        });
-    };
-    IndexedDBAdapter.prototype.clear = function () {
-        var _a;
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0: return [4 /*yield*/, this.checkPrivate()];
-                    case 1:
-                        _b.sent();
-                        (_a = this.db) === null || _a === void 0 ? void 0 : _a.close();
-                        return [4 /*yield*/, idb.deleteDB(this.dbName)];
-                    case 2:
-                        _b.sent();
-                        this.db = undefined;
-                        this.initPromise = undefined;
-                        return [2 /*return*/];
-                }
-            });
-        });
-    };
-    IndexedDBAdapter.prototype.save = function (model, condition) {
-        var _a, e_2, _b, _c;
-        return __awaiter(this, void 0, void 0, function () {
-            var _d, storeName, set, connectionStoreNames, modelKeyValues, tx, store, fromDB, result, _loop_1, this_1, _e, connectionStoreNames_1, connectionStoreNames_1_1, e_2_1;
-            return __generator(this, function (_f) {
-                switch (_f.label) {
-                    case 0: return [4 /*yield*/, this.checkPrivate()];
-                    case 1:
-                        _f.sent();
-                        _d = this.saveMetadata(model), storeName = _d.storeName, set = _d.set, connectionStoreNames = _d.connectionStoreNames, modelKeyValues = _d.modelKeyValues;
-                        tx = this.db.transaction(__spreadArray([storeName], __read(Array.from(set.values())), false), 'readwrite');
-                        store = tx.objectStore(storeName);
-                        return [4 /*yield*/, this._get(store, modelKeyValues)];
-                    case 2:
-                        fromDB = _f.sent();
-                        this.validateSaveCondition(condition, fromDB);
-                        result = [];
-                        _f.label = 3;
-                    case 3:
-                        _f.trys.push([3, 9, 10, 15]);
-                        _loop_1 = function () {
-                            var resItem, storeName_1, item, instance, keys, store_1, itemKeyValues, fromDB_1, opType, key;
-                            return __generator(this, function (_g) {
-                                switch (_g.label) {
-                                    case 0:
-                                        _c = connectionStoreNames_1_1.value;
-                                        _e = false;
-                                        _g.label = 1;
-                                    case 1:
-                                        _g.trys.push([1, , 6, 7]);
-                                        resItem = _c;
-                                        storeName_1 = resItem.storeName, item = resItem.item, instance = resItem.instance, keys = resItem.keys;
-                                        store_1 = tx.objectStore(storeName_1);
-                                        itemKeyValues = keys.map(function (key) { return item[key]; });
-                                        return [4 /*yield*/, this_1._get(store_1, itemKeyValues)];
-                                    case 2:
-                                        fromDB_1 = _g.sent();
-                                        opType = fromDB_1 ? OpType.UPDATE : OpType.INSERT;
-                                        if (!(keysEqual(itemKeyValues, modelKeyValues) ||
-                                            opType === OpType.INSERT)) return [3 /*break*/, 5];
-                                        return [4 /*yield*/, store_1
-                                                .index('byPk')
-                                                .getKey(this_1.canonicalKeyPath(itemKeyValues))];
-                                    case 3:
-                                        key = _g.sent();
-                                        return [4 /*yield*/, store_1.put(item, key)];
-                                    case 4:
-                                        _g.sent();
-                                        result.push([instance, opType]);
-                                        _g.label = 5;
-                                    case 5: return [3 /*break*/, 7];
-                                    case 6:
-                                        _e = true;
-                                        return [7 /*endfinally*/];
-                                    case 7: return [2 /*return*/];
-                                }
+                        // add new models created after IndexedDB, but before migration
+                        // this case may happen when a user has not opened an app for
+                        // some time and a new model is added during that time
+                        Object.keys(this.schema.namespaces).forEach(namespaceName => {
+                            const namespace = this.schema.namespaces[namespaceName];
+                            const objectStoreNames = new Set(txn.objectStoreNames);
+                            Object.keys(namespace.models)
+                                .map(modelName => {
+                                return [modelName, getStorename(namespaceName, modelName)];
+                            })
+                                .filter(([, storeName]) => !objectStoreNames.has(storeName))
+                                .forEach(([modelName, storeName]) => {
+                                this.createObjectStoreForModel(db, namespaceName, storeName, modelName);
                             });
-                        };
-                        this_1 = this;
-                        _e = true, connectionStoreNames_1 = __asyncValues(connectionStoreNames);
-                        _f.label = 4;
-                    case 4: return [4 /*yield*/, connectionStoreNames_1.next()];
-                    case 5:
-                        if (!(connectionStoreNames_1_1 = _f.sent(), _a = connectionStoreNames_1_1.done, !_a)) return [3 /*break*/, 8];
-                        return [5 /*yield**/, _loop_1()];
-                    case 6:
-                        _f.sent();
-                        _f.label = 7;
-                    case 7: return [3 /*break*/, 4];
-                    case 8: return [3 /*break*/, 15];
-                    case 9:
-                        e_2_1 = _f.sent();
-                        e_2 = { error: e_2_1 };
-                        return [3 /*break*/, 15];
-                    case 10:
-                        _f.trys.push([10, , 13, 14]);
-                        if (!(!_e && !_a && (_b = connectionStoreNames_1.return))) return [3 /*break*/, 12];
-                        return [4 /*yield*/, _b.call(connectionStoreNames_1)];
-                    case 11:
-                        _f.sent();
-                        _f.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 [4 /*yield*/, tx.done];
-                    case 16:
-                        _f.sent();
-                        return [2 /*return*/, result];
-                }
-            });
-        });
-    };
-    IndexedDBAdapter.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: return [4 /*yield*/, this.checkPrivate()];
-                    case 1:
-                        _b.sent();
-                        _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 record, filtered, all;
-                                return __generator(this, function (_a) {
-                                    switch (_a.label) {
-                                        case 0:
-                                            if (!queryByKey) return [3 /*break*/, 2];
-                                            return [4 /*yield*/, this.getByKey(storeName, queryByKey)];
-                                        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) return [3 /*break*/, 6];
-                                            return [4 /*yield*/, this.getAll(storeName)];
-                                        case 5:
-                                            all = _a.sent();
-                                            return [2 /*return*/, this.inMemoryPagination(all, pagination)];
-                                        case 6:
-                                            if (hasPagination) {
-                                                return [2 /*return*/, this.enginePagination(storeName, pagination)];
-                                            }
-                                            return [2 /*return*/, this.getAll(storeName)];
-                                    }
-                                });
-                            }); })()];
-                    case 2:
-                        records = (_b.sent());
-                        return [4 /*yield*/, this.load(namespaceName, modelConstructor.name, records)];
-                    case 3: return [2 /*return*/, _b.sent()];
-                }
-            });
-        });
-    };
-    IndexedDBAdapter.prototype.queryOne = function (modelConstructor, firstOrLast) {
-        if (firstOrLast === void 0) { firstOrLast = QueryOne.FIRST; }
-        return __awaiter(this, void 0, void 0, function () {
-            var storeName, cursor, result;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.checkPrivate()];
-                    case 1:
-                        _a.sent();
-                        storeName = this.getStorenameForModel(modelConstructor);
-                        return [4 /*yield*/, this.db
-                                .transaction([storeName], 'readonly')
-                                .objectStore(storeName)
-                                .openCursor(undefined, firstOrLast === QueryOne.FIRST ? 'next' : 'prev')];
-                    case 2:
-                        cursor = _a.sent();
-                        result = cursor ? cursor.value : undefined;
-                        return [2 /*return*/, result && this.modelInstanceCreator(modelConstructor, result)];
+                        });
+                    }
+                    catch (error) {
+                        logger.error('Error migrating IndexedDB data', error);
+                        txn.abort();
+                        throw error;
+                    }
+                    return;
                 }
-            });
+            },
         });
-    };
-    IndexedDBAdapter.prototype.batchSave = function (modelConstructor, items) {
-        return __awaiter(this, void 0, void 0, function () {
-            var modelName, namespaceName, storeName, result, txn, store, _loop_2, this_2, items_1, items_1_1, item, e_3_1;
-            var e_3, _a;
-            var _this = this;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0: return [4 /*yield*/, this.checkPrivate()];
-                    case 1:
-                        _b.sent();
-                        if (items.length === 0) {
-                            return [2 /*return*/, []];
-                        }
-                        modelName = modelConstructor.name;
-                        namespaceName = this.namespaceResolver(modelConstructor);
-                        storeName = this.getStorenameForModel(modelConstructor);
-                        result = [];
-                        txn = this.db.transaction(storeName, 'readwrite');
-                        store = txn.store;
-                        _loop_2 = function (item) {
-                            var model, connectedModels, keyValues, _deleted, index, key, instance;
-                            return __generator(this, function (_c) {
-                                switch (_c.label) {
-                                    case 0:
-                                        model = this_2.modelInstanceCreator(modelConstructor, item);
-                                        connectedModels = traverseModel(modelName, model, this_2.schema.namespaces[namespaceName], this_2.modelInstanceCreator, this_2.getModelConstructorByModelName);
-                                        keyValues = this_2.getIndexKeyValuesFromModel(model);
-                                        _deleted = item._deleted;
-                                        index = store.index('byPk');
-                                        return [4 /*yield*/, index.getKey(this_2.canonicalKeyPath(keyValues))];
-                                    case 1:
-                                        key = _c.sent();
-                                        if (!!_deleted) return [3 /*break*/, 3];
-                                        instance = connectedModels.find(function (_a) {
-                                            var instance = _a.instance;
-                                            var instanceKeyValues = _this.getIndexKeyValuesFromModel(instance);
-                                            return keysEqual(instanceKeyValues, keyValues);
-                                        }).instance;
-                                        result.push([
-                                            instance,
-                                            key ? OpType.UPDATE : OpType.INSERT,
-                                        ]);
-                                        return [4 /*yield*/, store.put(instance, key)];
-                                    case 2:
-                                        _c.sent();
-                                        return [3 /*break*/, 5];
-                                    case 3:
-                                        result.push([item, OpType.DELETE]);
-                                        if (!key) return [3 /*break*/, 5];
-                                        return [4 /*yield*/, store.delete(key)];
-                                    case 4:
-                                        _c.sent();
-                                        _c.label = 5;
-                                    case 5: return [2 /*return*/];
-                                }
-                            });
-                        };
-                        this_2 = this;
-                        _b.label = 2;
-                    case 2:
-                        _b.trys.push([2, 7, 8, 9]);
-                        items_1 = __values(items), items_1_1 = items_1.next();
-                        _b.label = 3;
-                    case 3:
-                        if (!!items_1_1.done) return [3 /*break*/, 6];
-                        item = items_1_1.value;
-                        return [5 /*yield**/, _loop_2(item)];
-                    case 4:
-                        _b.sent();
-                        _b.label = 5;
-                    case 5:
-                        items_1_1 = items_1.next();
-                        return [3 /*break*/, 3];
-                    case 6: return [3 /*break*/, 9];
-                    case 7:
-                        e_3_1 = _b.sent();
-                        e_3 = { error: e_3_1 };
-                        return [3 /*break*/, 9];
-                    case 8:
-                        try {
-                            if (items_1_1 && !items_1_1.done && (_a = items_1.return)) _a.call(items_1);
-                        }
-                        finally { if (e_3) throw e_3.error; }
-                        return [7 /*endfinally*/];
-                    case 9: return [4 /*yield*/, txn.done];
-                    case 10:
-                        _b.sent();
-                        return [2 /*return*/, result];
+    }
+    async _get(storeOrStoreName, keyArr) {
+        let index;
+        if (typeof storeOrStoreName === 'string') {
+            const storeName = storeOrStoreName;
+            index = this.db.transaction(storeName, 'readonly').store.index('byPk');
+        }
+        else {
+            const store = storeOrStoreName;
+            index = store.index('byPk');
+        }
+        const result = await index.get(this.canonicalKeyPath(keyArr));
+        return result;
+    }
+    async clear() {
+        await this.checkPrivate();
+        this.db?.close();
+        await idb.deleteDB(this.dbName);
+        this.db = undefined;
+        this.initPromise = undefined;
+    }
+    async save(model, condition) {
+        await this.checkPrivate();
+        const { storeName, set, connectionStoreNames, modelKeyValues } = this.saveMetadata(model);
+        const tx = this.db.transaction([storeName, ...Array.from(set.values())], 'readwrite');
+        const store = tx.objectStore(storeName);
+        const fromDB = await this._get(store, modelKeyValues);
+        this.validateSaveCondition(condition, fromDB);
+        const result = [];
+        for await (const resItem of connectionStoreNames) {
+            const { storeName, item, instance, keys } = resItem;
+            const store = tx.objectStore(storeName);
+            const itemKeyValues = keys.map(key => item[key]);
+            const fromDB = await this._get(store, itemKeyValues);
+            const opType = fromDB ? OpType.UPDATE : OpType.INSERT;
+            if (keysEqual(itemKeyValues, modelKeyValues) ||
+                opType === OpType.INSERT) {
+                const key = await store
+                    .index('byPk')
+                    .getKey(this.canonicalKeyPath(itemKeyValues));
+                await store.put(item, key);
+                result.push([instance, opType]);
+            }
+        }
+        await tx.done;
+        return result;
+    }
+    async query(modelConstructor, predicate, pagination) {
+        await this.checkPrivate();
+        const { storeName, namespaceName, queryByKey, predicates, hasSort, hasPagination, } = this.queryMetadata(modelConstructor, predicate, pagination);
+        const records = (await (async () => {
+            //
+            // NOTE: @svidgen explored removing this and letting query() take care of automatic
+            // index leveraging. This would eliminate some amount of very similar code.
+            // But, getAll is slightly slower than get()
+            //
+            // On Chrome:
+            //   ~700ms vs ~1175ms per 10k reads.
+            //
+            // You can (and should) check my work here:
+            // 	https://gist.github.com/svidgen/74e55d573b19c3e5432b1b5bdf0f4d96
+            //
+            if (queryByKey) {
+                const record = await this.getByKey(storeName, queryByKey);
+                return record ? [record] : [];
+            }
+            if (predicates) {
+                const filtered = await this.filterOnPredicate(storeName, predicates);
+                return this.inMemoryPagination(filtered, pagination);
+            }
+            if (hasSort) {
+                const all = await this.getAll(storeName);
+                return this.inMemoryPagination(all, pagination);
+            }
+            if (hasPagination) {
+                return this.enginePagination(storeName, pagination);
+            }
+            return this.getAll(storeName);
+        })());
+        return await this.load(namespaceName, modelConstructor.name, records);
+    }
+    async queryOne(modelConstructor, firstOrLast = QueryOne.FIRST) {
+        await this.checkPrivate();
+        const storeName = this.getStorenameForModel(modelConstructor);
+        const cursor = await this.db
+            .transaction([storeName], 'readonly')
+            .objectStore(storeName)
+            .openCursor(undefined, firstOrLast === QueryOne.FIRST ? 'next' : 'prev');
+        const result = cursor ? cursor.value : undefined;
+        return result && this.modelInstanceCreator(modelConstructor, result);
+    }
+    async batchSave(modelConstructor, items) {
+        await this.checkPrivate();
+        if (items.length === 0) {
+            return [];
+        }
+        const modelName = modelConstructor.name;
+        const namespaceName = this.namespaceResolver(modelConstructor);
+        const storeName = this.getStorenameForModel(modelConstructor);
+        const result = [];
+        const txn = this.db.transaction(storeName, 'readwrite');
+        const store = txn.store;
+        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 keyValues = this.getIndexKeyValuesFromModel(model);
+            const { _deleted } = item;
+            const index = store.index('byPk');
+            const key = await index.getKey(this.canonicalKeyPath(keyValues));
+            if (!_deleted) {
+                const { instance } = connectedModels.find(({ instance }) => {
+                    const instanceKeyValues = this.getIndexKeyValuesFromModel(instance);
+                    return keysEqual(instanceKeyValues, keyValues);
+                });
+                result.push([
+                    instance,
+                    key ? OpType.UPDATE : OpType.INSERT,
+                ]);
+                await store.put(instance, key);
+            }
+            else {
+                result.push([item, OpType.DELETE]);
+                if (key) {
+                    await store.delete(key);
                 }
-            });
+            }
+        }
+        await txn.done;
+        return result;
+    }
+    async deleteItem(deleteQueue) {
+        const connectionStoreNames = deleteQueue.map(({ storeName }) => {
+            return storeName;
         });
-    };
-    IndexedDBAdapter.prototype.deleteItem = function (deleteQueue) {
-        var _a, e_4, _b, _c, _d, e_5, _e, _f;
-        return __awaiter(this, void 0, void 0, function () {
-            var connectionStoreNames, tx, _g, _h, _j, deleteItem, storeName, items, store, _k, items_2, items_2_1, item, key, keyValues, itemKey, e_5_1, e_4_1;
-            return __generator(this, function (_l) {
-                switch (_l.label) {
-                    case 0:
-                        connectionStoreNames = deleteQueue.map(function (_a) {
-                            var storeName = _a.storeName;
-                            return storeName;
-                        });
-                        tx = this.db.transaction(__spreadArray([], __read(connectionStoreNames), false), 'readwrite');
-                        _l.label = 1;
-                    case 1:
-                        _l.trys.push([1, 28, 29, 34]);
-                        _g = true, _h = __asyncValues(deleteQueue);
-                        _l.label = 2;
-                    case 2: return [4 /*yield*/, _h.next()];
-                    case 3:
-                        if (!(_j = _l.sent(), _a = _j.done, !_a)) return [3 /*break*/, 27];
-                        _c = _j.value;
-                        _g = false;
-                        _l.label = 4;
-                    case 4:
-                        _l.trys.push([4, , 25, 26]);
-                        deleteItem = _c;
-                        storeName = deleteItem.storeName, items = deleteItem.items;
-                        store = tx.objectStore(storeName);
-                        _l.label = 5;
-                    case 5:
-                        _l.trys.push([5, 18, 19, 24]);
-                        _k = true, items_2 = (e_5 = void 0, __asyncValues(items));
-                        _l.label = 6;
-                    case 6: return [4 /*yield*/, items_2.next()];
-                    case 7:
-                        if (!(items_2_1 = _l.sent(), _d = items_2_1.done, !_d)) return [3 /*break*/, 17];
-                        _f = items_2_1.value;
-                        _k = false;
-                        _l.label = 8;
-                    case 8:
-                        _l.trys.push([8, , 15, 16]);
-                        item = _f;
-                        if (!item) return [3 /*break*/, 14];
-                        key = void 0;
-                        if (!(typeof item === 'object')) return [3 /*break*/, 10];
-                        keyValues = this.getIndexKeyValuesFromModel(item);
-                        return [4 /*yield*/, store
-                                .index('byPk')
-                                .getKey(this.canonicalKeyPath(keyValues))];
-                    case 9:
-                        key = _l.sent();
-                        return [3 /*break*/, 12];
-                    case 10:
-                        itemKey = item.toString();
-                        return [4 /*yield*/, store.index('byPk').getKey(itemKey)];
-                    case 11:
-                        key = _l.sent();
-                        _l.label = 12;
-                    case 12:
-                        if (!(key !== undefined)) return [3 /*break*/, 14];
-                        return [4 /*yield*/, store.delete(key)];
-                    case 13:
-                        _l.sent();
-                        _l.label = 14;
-                    case 14: return [3 /*break*/, 16];
-                    case 15:
-                        _k = true;
-                        return [7 /*endfinally*/];
-                    case 16: return [3 /*break*/, 6];
-                    case 17: return [3 /*break*/, 24];
-                    case 18:
-                        e_5_1 = _l.sent();
-                        e_5 = { error: e_5_1 };
-                        return [3 /*break*/, 24];
-                    case 19:
-                        _l.trys.push([19, , 22, 23]);
-                        if (!(!_k && !_d && (_e = items_2.return))) return [3 /*break*/, 21];
-                        return [4 /*yield*/, _e.call(items_2)];
-                    case 20:
-                        _l.sent();
-                        _l.label = 21;
-                    case 21: return [3 /*break*/, 23];
-                    case 22:
-                        if (e_5) throw e_5.error;
-                        return [7 /*endfinally*/];
-                    case 23: return [7 /*endfinally*/];
-                    case 24: return [3 /*break*/, 26];
-                    case 25:
-                        _g = true;
-                        return [7 /*endfinally*/];
-                    case 26: return [3 /*break*/, 2];
-                    case 27: return [3 /*break*/, 34];
-                    case 28:
-                        e_4_1 = _l.sent();
-                        e_4 = { error: e_4_1 };
-                        return [3 /*break*/, 34];
-                    case 29:
-                        _l.trys.push([29, , 32, 33]);
-                        if (!(!_g && !_a && (_b = _h.return))) return [3 /*break*/, 31];
-                        return [4 /*yield*/, _b.call(_h)];
-                    case 30:
-                        _l.sent();
-                        _l.label = 31;
-                    case 31: return [3 /*break*/, 33];
-                    case 32:
-                        if (e_4) throw e_4.error;
-                        return [7 /*endfinally*/];
-                    case 33: return [7 /*endfinally*/];
-                    case 34: return [2 /*return*/];
+        const tx = this.db.transaction([...connectionStoreNames], 'readwrite');
+        for await (const deleteItem of deleteQueue) {
+            const { storeName, items } = deleteItem;
+            const store = tx.objectStore(storeName);
+            for await (const item of items) {
+                if (item) {
+                    let key;
+                    if (typeof item === 'object') {
+                        const keyValues = this.getIndexKeyValuesFromModel(item);
+                        key = await store
+                            .index('byPk')
+                            .getKey(this.canonicalKeyPath(keyValues));
+                    }
+                    else {
+                        const itemKey = item.toString();
+                        key = await store.index('byPk').getKey(itemKey);
+                    }
+                    if (key !== undefined) {
+                        await store.delete(key);
+                    }
                 }
-            });
-        });
-    };
+            }
+        }
+    }
     //#region platform-specific helper methods
-    IndexedDBAdapter.prototype.checkPrivate = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var isPrivate;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, isPrivateMode().then(function (isPrivate) {
-                            return isPrivate;
-                        })];
-                    case 1:
-                        isPrivate = _a.sent();
-                        if (isPrivate) {
-                            logger.error("IndexedDB not supported in this browser's private mode");
-                            return [2 /*return*/, Promise.reject("IndexedDB not supported in this browser's private mode")];
-                        }
-                        else {
-                            return [2 /*return*/, Promise.resolve()];
-                        }
-                        return [2 /*return*/];
-                }
-            });
+    async checkPrivate() {
+        const isPrivate = await isPrivateMode().then(isPrivate => {
+            return isPrivate;
         });
-    };
+        if (isPrivate) {
+            logger.error("IndexedDB not supported in this browser's private mode");
+            return Promise.reject("IndexedDB not supported in this browser's private mode");
+        }
+        else {
+            return Promise.resolve();
+        }
+    }
     /**
      * Whether the browser's implementation of IndexedDB is coercing single-field
      * indexes to a scalar key.
@@ -746,62 +316,35 @@ var IndexedDBAdapter = /** @class */ (function (_super) {
      * See PR description for reference:
      * https://github.com/aws-amplify/amplify-js/pull/10527
      */
-    IndexedDBAdapter.prototype.setSafariCompatabilityMode = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var _a;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        _a = this;
-                        return [4 /*yield*/, isSafariCompatabilityMode()];
-                    case 1:
-                        _a.safariCompatabilityMode = _b.sent();
-                        if (this.safariCompatabilityMode === true) {
-                            logger.debug('IndexedDB Adapter is running in Safari Compatability Mode');
-                        }
-                        return [2 /*return*/];
-                }
-            });
-        });
-    };
-    IndexedDBAdapter.prototype.getNamespaceAndModelFromStorename = function (storeName) {
-        var _a = __read(storeName.split('_')), namespaceName = _a[0], modelNameArr = _a.slice(1);
+    async setSafariCompatabilityMode() {
+        this.safariCompatabilityMode = await isSafariCompatabilityMode();
+        if (this.safariCompatabilityMode === true) {
+            logger.debug('IndexedDB Adapter is running in Safari Compatability Mode');
+        }
+    }
+    getNamespaceAndModelFromStorename(storeName) {
+        const [namespaceName, ...modelNameArr] = storeName.split('_');
         return {
-            namespaceName: namespaceName,
+            namespaceName,
             modelName: modelNameArr.join('_'),
         };
-    };
-    IndexedDBAdapter.prototype.createObjectStoreForModel = function (db, namespaceName, storeName, modelName) {
-        var store = db.createObjectStore(storeName, {
+    }
+    createObjectStoreForModel(db, namespaceName, storeName, modelName) {
+        const store = db.createObjectStore(storeName, {
             autoIncrement: true,
         });
-        var indexes = this.schema.namespaces[namespaceName].relationships[modelName].indexes;
-        indexes.forEach(function (_a) {
-            var _b = __read(_a, 3), idxName = _b[0], keyPath = _b[1], options = _b[2];
+        const { indexes } = this.schema.namespaces[namespaceName].relationships[modelName];
+        indexes.forEach(([idxName, keyPath, options]) => {
             store.createIndex(idxName, keyPath, options);
         });
         return store;
-    };
-    IndexedDBAdapter.prototype.getByKey = function (storeName, keyValue) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this._get(storeName, keyValue)];
-                    case 1: return [2 /*return*/, _a.sent()];
-                }
-            });
-        });
-    };
-    IndexedDBAdapter.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()];
-                }
-            });
-        });
-    };
+    }
+    async getByKey(storeName, keyValue) {
+        return await this._get(storeName, keyValue);
+    }
+    async getAll(storeName) {
+        return await this.db.getAll(storeName);
+    }
     /**
      * Tries to generate an index fetcher for the given predicates. Assumes
      * that the given predicate conditions are contained by an AND group and
@@ -811,295 +354,191 @@ var IndexedDBAdapter = /** @class */ (function (_super) {
      * @param predicates The predicates to try to AND together.
      * @param transaction
      */
-    IndexedDBAdapter.prototype.matchingIndexQueries = function (storeName, predicates, transaction) {
-        var e_6, _a, e_7, _b;
-        var _this = this;
+    matchingIndexQueries(storeName, predicates, transaction) {
         // could be expanded later to include `exec()` and a `cardinality` estimate?
-        var queries = [];
-        var predicateIndex = new Map();
-        try {
-            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_6_1) { e_6 = { error: e_6_1 }; }
-        finally {
-            try {
-                if (predicates_1_1 && !predicates_1_1.done && (_a = predicates_1.return)) _a.call(predicates_1);
-            }
-            finally { if (e_6) throw e_6.error; }
+        const queries = [];
+        const predicateIndex = new Map();
+        for (const predicate of predicates) {
+            predicateIndex.set(String(predicate.field), predicate);
         }
-        var store = transaction.objectStore(storeName);
-        var _loop_3 = function (name_1) {
-            var e_8, _e;
-            var idx = store.index(name_1);
-            var keypath = Array.isArray(idx.keyPath) ? idx.keyPath : [idx.keyPath];
-            var matchingPredicateValues = [];
-            try {
-                for (var keypath_1 = (e_8 = 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 && p.operand !== null && p.operand !== undefined) {
-                        matchingPredicateValues.push(p.operand);
-                    }
-                    else {
-                        break;
-                    }
+        const store = transaction.objectStore(storeName);
+        for (const name of store.indexNames) {
+            const idx = store.index(name);
+            const keypath = Array.isArray(idx.keyPath) ? idx.keyPath : [idx.keyPath];
+            const matchingPredicateValues = [];
+            for (const field of keypath) {
+                const p = predicateIndex.get(field);
+                if (p && p.operand !== null && p.operand !== undefined) {
+                    matchingPredicateValues.push(p.operand);
                 }
-            }
-            catch (e_8_1) { e_8 = { error: e_8_1 }; }
-            finally {
-                try {
-                    if (keypath_1_1 && !keypath_1_1.done && (_e = keypath_1.return)) _e.call(keypath_1);
+                else {
+                    break;
                 }
-                finally { if (e_8) throw e_8.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_3(name_1);
+                queries.push(() => this.db
+                    .transaction(storeName)
+                    .objectStore(storeName)
+                    .index(name)
+                    .getAll(this.canonicalKeyPath(matchingPredicateValues)));
             }
         }
-        catch (e_7_1) { e_7 = { error: e_7_1 }; }
-        finally {
-            try {
-                if (_d && !_d.done && (_b = _c.return)) _b.call(_c);
+        return queries;
+    }
+    async baseQueryIndex(storeName, predicates, transaction) {
+        let { predicates: predicateObjs, type } = predicates;
+        // 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]) &&
+            predicateObjs[0].type !== 'not') {
+            type = predicateObjs[0].type;
+            predicateObjs = predicateObjs[0].predicates;
+        }
+        const fieldPredicates = predicateObjs.filter(p => isPredicateObj(p) && p.operator === 'eq');
+        // several sub-queries could occur here. explicitly start a txn here to avoid
+        // opening/closing multiple txns.
+        const txn = transaction || this.db.transaction(storeName);
+        let result = {};
+        // `or` conditions, if usable, need to generate multiple queries. this is unlike
+        // `and` conditions, which should just be combined.
+        if (type === 'or') {
+            /**
+             * Base queries for each child group.
+             *
+             * For each child group, if it's an AND condition that results in a single
+             * subordinate "base query", we can use it. if it's any more complicated
+             * than that, it's not a simple join condition we want to use.
+             */
+            const groupQueries = await Promise.all(predicateObjs
+                .filter(o => isPredicateGroup(o) && o.type === 'and')
+                .map(o => this.baseQueryIndex(storeName, o, txn))).then(queries => queries
+                .filter(q => q.indexedQueries.length === 1)
+                .map(i => i.indexedQueries));
+            /**
+             * Base queries for each simple child "object" (field condition).
+             */
+            const objectQueries = predicateObjs
+                .filter(o => isPredicateObj(o))
+                .map(o => this.matchingIndexQueries(storeName, [o], txn));
+            const indexedQueries = [...groupQueries, ...objectQueries]
+                .map(q => q[0])
+                .filter(i => 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: [],
+                };
+            }
+            else {
+                result = {
+                    groupType: 'or',
+                    indexedQueries,
+                };
             }
-            finally { if (e_7) throw e_7.error; }
         }
-        return queries;
-    };
-    IndexedDBAdapter.prototype.baseQueryIndex = function (storeName, predicates, transaction) {
-        return __awaiter(this, void 0, void 0, function () {
-            var predicateObjs, type, fieldPredicates, txn, result, groupQueries, objectQueries, indexedQueries;
-            var _this = this;
-            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]) &&
-                            predicateObjs[0].type !== 'not') {
-                            type = predicateObjs[0].type;
-                            predicateObjs = predicateObjs[0].predicates;
-                        }
-                        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);
-                        });
-                        indexedQueries = __spreadArray(__spreadArray([], __read(groupQueries), false), __read(objectQueries), false).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: [],
-                            };
-                        }
-                        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_9_1, filtered;
-            var e_9, _b, e_10, _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:
-                        _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:
-                        // 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:
-                        _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:
-                        resultGroup = _d.sent();
-                        try {
-                            for (resultGroup_1 = (e_10 = 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;
-                                distinctificationString = JSON.stringify(item);
-                                distinctResults.set(distinctificationString, item);
-                            }
-                        }
-                        catch (e_10_1) { e_10 = { error: e_10_1 }; }
-                        finally {
-                            try {
-                                if (resultGroup_1_1 && !resultGroup_1_1.done && (_c = resultGroup_1.return)) _c.call(resultGroup_1);
-                            }
-                            finally { if (e_10) throw e_10.error; }
-                        }
-                        _d.label = 7;
-                    case 7:
-                        indexedQueries_1_1 = indexedQueries_1.next();
-                        return [3 /*break*/, 5];
-                    case 8: return [3 /*break*/, 11];
-                    case 9:
-                        e_9_1 = _d.sent();
-                        e_9 = { error: e_9_1 };
-                        return [3 /*break*/, 11];
-                    case 10:
-                        try {
-                            if (indexedQueries_1_1 && !indexedQueries_1_1.done && (_b = indexedQueries_1.return)) _b.call(indexedQueries_1);
-                        }
-                        finally { if (e_9) throw e_9.error; }
-                        return [7 /*endfinally*/];
-                    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*/, 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 = (_d.sent());
-                        _d.label = 14;
-                    case 14:
-                        filtered = predicateObjs
-                            ? candidateResults.filter(function (m) { return validatePredicate(m, type, predicateObjs); })
-                            : candidateResults;
-                        return [2 /*return*/, filtered];
+        else 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: [],
+            };
+        }
+        // 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).
+        // (Unless we were *given* the transaction -- we'll assume the parent handles it.)
+        if (!transaction)
+            await txn.done;
+        return result;
+    }
+    async filterOnPredicate(storeName, predicates) {
+        const { predicates: predicateObjs, type } = predicates;
+        const { groupType, indexedQueries } = await this.baseQueryIndex(storeName, predicates);
+        // where we'll accumulate candidate results, which will be filtered at the end.
+        let candidateResults;
+        // semi-naive implementation:
+        if (groupType === 'and' && indexedQueries.length > 0) {
+            // each condition must be satsified, we can form a base set with any
+            // ONE of those conditions and then filter.
+            candidateResults = await indexedQueries[0]();
+        }
+        else if (groupType === 'or' &&
+            indexedQueries.length > 0 &&
+            indexedQueries.length <= MULTI_OR_CONDITION_SCAN_BREAKPOINT) {
+            // NOTE: each condition implies a potentially distinct set. we only benefit
+            // from using indexes here if EVERY condition uses an index. if any one
+            // index requires a table scan, we gain nothing from the indexes.
+            // NOTE: results must be DISTINCT-ified if we leverage indexes.
+            const distinctResults = new Map();
+            for (const query of indexedQueries) {
+                const resultGroup = await query();
+                for (const item of resultGroup) {
+                    const distinctificationString = JSON.stringify(item);
+                    distinctResults.set(distinctificationString, item);
                 }
-            });
-        });
-    };
-    IndexedDBAdapter.prototype.inMemoryPagination = function (records, pagination) {
+            }
+            // 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());
+        }
+        else {
+            // 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 = await this.getAll(storeName);
+        }
+        const filtered = predicateObjs
+            ? candidateResults.filter(m => validatePredicate(m, type, predicateObjs))
+            : candidateResults;
+        return filtered;
+    }
+    inMemoryPagination(records, pagination) {
         return inMemoryPagination(records, pagination);
-    };
-    IndexedDBAdapter.prototype.enginePagination = function (storeName, pagination) {
-        return __awaiter(this, void 0, void 0, function () {
-            var result, _a, page, _b, limit, initialRecord, cursor, pageResults, hasLimit;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        if (!pagination) return [3 /*break*/, 7];
-                        _a = pagination.page, page = _a === void 0 ? 0 : _a, _b = pagination.limit, limit = _b === void 0 ? 0 : _b;
-                        initialRecord = Math.max(0, page * limit) || 0;
-                        return [4 /*yield*/, this.db
-                                .transaction(storeName)
-                                .objectStore(storeName)
-                                .openCursor()];
-                    case 1:
-                        cursor = _c.sent();
-                        if (!(cursor && initialRecord > 0)) return [3 /*break*/, 3];
-                        return [4 /*yield*/, cursor.advance(initialRecord)];
-                    case 2:
-                        _c.sent();
-                        _c.label = 3;
-                    case 3:
-                        pageResults = [];
-                        hasLimit = typeof limit === 'number' && limit > 0;
-                        _c.label = 4;
-                    case 4:
-                        if (!(cursor && cursor.value)) return [3 /*break*/, 6];
-                        pageResults.push(cursor.value);
-                        if (hasLimit && pageResults.length === limit) {
-                            return [3 /*break*/, 6];
-                        }
-                        return [4 /*yield*/, cursor.continue()];
-                    case 5:
-                        cursor = _c.sent();
-                        return [3 /*break*/, 4];
-                    case 6:
-                        result = pageResults;
-                        return [3 /*break*/, 9];
-                    case 7: return [4 /*yield*/, this.db.getAll(storeName)];
-                    case 8:
-                        result = (_c.sent());
-                        _c.label = 9;
-                    case 9: return [2 /*return*/, result];
+    }
+    async enginePagination(storeName, pagination) {
+        let result;
+        if (pagination) {
+            const { page = 0, limit = 0 } = pagination;
+            const initialRecord = Math.max(0, page * limit) || 0;
+            let cursor = await this.db
+                .transaction(storeName)
+                .objectStore(storeName)
+                .openCursor();
+            if (cursor && initialRecord > 0) {
+                await cursor.advance(initialRecord);
+            }
+            const pageResults = [];
+            const hasLimit = typeof limit === 'number' && limit > 0;
+            while (cursor && cursor.value) {
+                pageResults.push(cursor.value);
+                if (hasLimit && pageResults.length === limit) {
+                    break;
                 }
-            });
-        });
-    };
-    return IndexedDBAdapter;
-}(StorageAdapterBase));
+                cursor = await cursor.continue();
+            }
+            result = pageResults;
+        }
+        else {
+            result = await this.db.getAll(storeName);
+        }
+        return result;
+    }
+}
 export default new IndexedDBAdapter();