remult 3.3.18 → 3.3.19-next.2

package/src/data-providers/indexed-db-data-provider.js

@@ -0,0 +1,1387 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IndexedDbDataProvider = exports.IndexedDbIndexBuilder = void 0;
+exports.idbPrefetchFromFilter = idbPrefetchFromFilter;
+var tslib_1 = require("tslib");
+var filter_consumer_bridge_to_sql_request_js_1 = require("../filter/filter-consumer-bridge-to-sql-request.js");
+var RepositoryImplementation_js_1 = require("../remult3/RepositoryImplementation.js");
+var array_entity_data_provider_js_1 = require("./array-entity-data-provider.js");
+var IndexedDbIndexBuilder = /** @class */ (function () {
+    function IndexedDbIndexBuilder() {
+        //@internal
+        this.entries = [];
+    }
+    IndexedDbIndexBuilder.prototype.ensureIndexes = function (entity, indexes) {
+        this.entries.push({ entity: entity, indexes: tslib_1.__spreadArray([], tslib_1.__read(indexes), false) });
+        return this;
+    };
+    return IndexedDbIndexBuilder;
+}());
+exports.IndexedDbIndexBuilder = IndexedDbIndexBuilder;
+var IDB_KEYS_STORE = '__remult_keys';
+var IDB_DEK_ID = 'dek';
+var IDB_ENC = '_enc';
+var IDB_IV = '_iv';
+var IndexedDbDataProvider = /** @class */ (function () {
+    function IndexedDbDataProvider(dbName, options) {
+        if (dbName === void 0) { dbName = 'remult'; }
+        this.dbName = dbName;
+        //@internal
+        this.declaredIndexes = [];
+        //@internal
+        this.tail = Promise.resolve();
+        this.encrypt = (options === null || options === void 0 ? void 0 : options.encrypt) === true;
+        this.customGetKey = options === null || options === void 0 ? void 0 : options.getEncryptionKey;
+        if (this.encrypt && !(typeof crypto !== 'undefined' && crypto.subtle)) {
+            throw new Error('Web Crypto API is required when IndexedDB encryption is enabled');
+        }
+        if (options === null || options === void 0 ? void 0 : options.indexes) {
+            var builder = new IndexedDbIndexBuilder();
+            options.indexes(builder);
+            this.declaredIndexes = builder.entries;
+        }
+    }
+    IndexedDbDataProvider.prototype.getEntityDataProvider = function (entity) {
+        return new IndexedDbEntityDataProvider(this, entity);
+    };
+    IndexedDbDataProvider.prototype.transaction = function (action) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, action(this)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    IndexedDbDataProvider.prototype.ensureSchema = function (entities) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.enqueue(function () { return _this.ensureStores(entities); })];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    IndexedDbDataProvider.prototype.close = function () {
+        var _a;
+        (_a = this.db) === null || _a === void 0 ? void 0 : _a.close();
+        this.db = undefined;
+    };
+    //@internal
+    IndexedDbDataProvider.prototype.enqueue = function (fn) {
+        var run = this.tail.then(fn, fn);
+        this.tail = run.then(function () { }, function () { });
+        return run;
+    };
+    //@internal
+    IndexedDbDataProvider.prototype.runWithRows = function (entity, where, what) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return tslib_1.__generator(this, function (_a) {
+                return [2 /*return*/, this.enqueue(function () { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                        var rows;
+                        return tslib_1.__generator(this, function (_a) {
+                            switch (_a.label) {
+                                case 0: return [4 /*yield*/, this.ensureStores([entity])];
+                                case 1:
+                                    _a.sent();
+                                    return [4 /*yield*/, this.loadRows(entity, where)];
+                                case 2:
+                                    rows = _a.sent();
+                                    return [2 /*return*/, what(new array_entity_data_provider_js_1.ArrayEntityDataProvider(entity, function () { return rows; }))];
+                            }
+                        });
+                    }); })];
+            });
+        });
+    };
+    //@internal
+    IndexedDbDataProvider.prototype.fetchRows = function (entity, where) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return tslib_1.__generator(this, function (_a) {
+                return [2 /*return*/, this.enqueue(function () { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                        return tslib_1.__generator(this, function (_a) {
+                            switch (_a.label) {
+                                case 0: return [4 /*yield*/, this.ensureStores([entity])];
+                                case 1:
+                                    _a.sent();
+                                    return [2 /*return*/, this.loadRows(entity, where)];
+                            }
+                        });
+                    }); })];
+            });
+        });
+    };
+    //@internal
+    IndexedDbDataProvider.prototype.loadRows = function (entity, where) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var storeName, prefetch, rows, _a, dek, names;
+            return tslib_1.__generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        storeName = storeNameOf(entity);
+                        return [4 /*yield*/, idbPrefetchFromFilter(entity, where, this.storeIndexes(storeName))];
+                    case 1:
+                        prefetch = _b.sent();
+                        this.lastFetch = prefetch;
+                        if (!(prefetch.type === 'all')) return [3 /*break*/, 3];
+                        return [4 /*yield*/, this.getAll(storeName)];
+                    case 2:
+                        _a = _b.sent();
+                        return [3 /*break*/, 5];
+                    case 3: return [4 /*yield*/, this.fetchOps(storeName, entity, prefetch.type === 'or' ? prefetch.parts : [prefetch])];
+                    case 4:
+                        _a = _b.sent();
+                        _b.label = 5;
+                    case 5:
+                        rows = _a;
+                        if (!this.encrypt)
+                            return [2 /*return*/, rows];
+                        return [4 /*yield*/, this.loadDek()];
+                    case 6:
+                        dek = _b.sent();
+                        return [4 /*yield*/, (0, filter_consumer_bridge_to_sql_request_js_1.dbNamesOf)(entity, function (x) { return x; })];
+                    case 7:
+                        names = _b.sent();
+                        return [2 /*return*/, Promise.all(rows.map(function (row) { return decryptJson(storeName, row, entity, names, dek); }))];
+                }
+            });
+        });
+    };
+    //@internal
+    IndexedDbDataProvider.prototype.storeIndexes = function (storeName) {
+        var db = this.db;
+        if (!(db === null || db === void 0 ? void 0 : db.objectStoreNames.contains(storeName)))
+            return [];
+        var store = db.transaction(storeName).objectStore(storeName);
+        var names = store.indexNames;
+        var result = [];
+        for (var i = 0; i < names.length; i++) {
+            var name_1 = names[i];
+            result.push({
+                name: name_1,
+                keyPath: store.index(name_1).keyPath,
+            });
+        }
+        return result;
+    };
+    //@internal
+    IndexedDbDataProvider.prototype.indexesFor = function (entity) {
+        return this.declaredIndexes
+            .filter(function (e) { return e.entity === entity.entityType; })
+            .flatMap(function (e) { return e.indexes; });
+    };
+    //@internal
+    IndexedDbDataProvider.prototype.ensureStores = function (entities) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var wanted, db, needsKeyStore, needsUpgrade, nextVersion;
+            var _this = this;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, Promise.all(entities.map(function (entity) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                            var keyPath;
+                            var _a;
+                            return tslib_1.__generator(this, function (_b) {
+                                switch (_b.label) {
+                                    case 0: return [4 /*yield*/, keyPathOf(entity)];
+                                    case 1:
+                                        keyPath = _b.sent();
+                                        _a = {
+                                            name: storeNameOf(entity),
+                                            keyPath: keyPath,
+                                            autoIncrement: (0, RepositoryImplementation_js_1.isAutoIncrement)(entity.idMetadata.field)
+                                        };
+                                        return [4 /*yield*/, resolveIndexDefs(entity, this.indexesFor(entity), keyPath)];
+                                    case 2: return [2 /*return*/, (_a.indexes = _b.sent(),
+                                            _a)];
+                                }
+                            });
+                        }); }))];
+                    case 1:
+                        wanted = _a.sent();
+                        return [4 /*yield*/, this.open()];
+                    case 2:
+                        db = _a.sent();
+                        needsKeyStore = this.usesKeyStore() && !db.objectStoreNames.contains(IDB_KEYS_STORE);
+                        needsUpgrade = needsKeyStore ||
+                            wanted.some(function (w) {
+                                if (!db.objectStoreNames.contains(w.name))
+                                    return true;
+                                var existing = _this.storeIndexes(w.name).map(function (i) { return i.name; });
+                                return w.indexes.some(function (idx) { return !existing.includes(idx.name); });
+                            });
+                        if (!needsUpgrade)
+                            return [2 /*return*/];
+                        nextVersion = db.version + 1;
+                        this.forget(db);
+                        db.close();
+                        return [4 /*yield*/, this.open(nextVersion, function (upgradeDb, tx) {
+                                var e_1, _a, e_2, _b;
+                                if (_this.usesKeyStore() &&
+                                    !upgradeDb.objectStoreNames.contains(IDB_KEYS_STORE)) {
+                                    upgradeDb.createObjectStore(IDB_KEYS_STORE, { keyPath: 'id' });
+                                }
+                                try {
+                                    for (var wanted_1 = tslib_1.__values(wanted), wanted_1_1 = wanted_1.next(); !wanted_1_1.done; wanted_1_1 = wanted_1.next()) {
+                                        var _c = wanted_1_1.value, name_2 = _c.name, keyPath = _c.keyPath, autoIncrement = _c.autoIncrement, indexes = _c.indexes;
+                                        var store = upgradeDb.objectStoreNames.contains(name_2)
+                                            ? tx.objectStore(name_2)
+                                            : upgradeDb.createObjectStore(name_2, { keyPath: keyPath, autoIncrement: autoIncrement });
+                                        try {
+                                            for (var indexes_1 = (e_2 = void 0, tslib_1.__values(indexes)), indexes_1_1 = indexes_1.next(); !indexes_1_1.done; indexes_1_1 = indexes_1.next()) {
+                                                var idx = indexes_1_1.value;
+                                                if (!store.indexNames.contains(idx.name)) {
+                                                    store.createIndex(idx.name, idx.keyPath);
+                                                }
+                                            }
+                                        }
+                                        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                                        finally {
+                                            try {
+                                                if (indexes_1_1 && !indexes_1_1.done && (_b = indexes_1.return)) _b.call(indexes_1);
+                                            }
+                                            finally { if (e_2) throw e_2.error; }
+                                        }
+                                    }
+                                }
+                                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                                finally {
+                                    try {
+                                        if (wanted_1_1 && !wanted_1_1.done && (_a = wanted_1.return)) _a.call(wanted_1);
+                                    }
+                                    finally { if (e_1) throw e_1.error; }
+                                }
+                            })];
+                    case 3:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    //@internal
+    IndexedDbDataProvider.prototype.usesKeyStore = function () {
+        return this.encrypt && !this.customGetKey;
+    };
+    //@internal
+    IndexedDbDataProvider.prototype.loadDek = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var key_1, existing, generated, key;
+            var _this = this;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (this.dek)
+                            return [2 /*return*/, this.dek];
+                        if (!this.customGetKey) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.customGetKey()];
+                    case 1:
+                        key_1 = _a.sent();
+                        this.dek = key_1;
+                        return [2 /*return*/, key_1];
+                    case 2: return [4 /*yield*/, this.withStore(IDB_KEYS_STORE, 'readonly', function (s) {
+                            return idbReq(s.get(IDB_DEK_ID));
+                        })];
+                    case 3:
+                        existing = _a.sent();
+                        if (existing === null || existing === void 0 ? void 0 : existing.key) {
+                            this.dek = existing.key;
+                            return [2 /*return*/, existing.key];
+                        }
+                        return [4 /*yield*/, crypto.subtle.generateKey({ name: 'AES-GCM', length: 256 }, false, ['encrypt', 'decrypt'])];
+                    case 4:
+                        generated = _a.sent();
+                        return [4 /*yield*/, this.withStore(IDB_KEYS_STORE, 'readwrite', function (s) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                                var rec, e_3, again;
+                                return tslib_1.__generator(this, function (_a) {
+                                    switch (_a.label) {
+                                        case 0: return [4 /*yield*/, idbReq(s.get(IDB_DEK_ID))];
+                                        case 1:
+                                            rec = _a.sent();
+                                            if (rec === null || rec === void 0 ? void 0 : rec.key)
+                                                return [2 /*return*/, rec.key];
+                                            _a.label = 2;
+                                        case 2:
+                                            _a.trys.push([2, 4, , 7]);
+                                            return [4 /*yield*/, idbReq(s.add({ id: IDB_DEK_ID, key: generated }))];
+                                        case 3:
+                                            _a.sent();
+                                            return [2 /*return*/, generated];
+                                        case 4:
+                                            e_3 = _a.sent();
+                                            if (!((e_3 === null || e_3 === void 0 ? void 0 : e_3.name) === 'ConstraintError')) return [3 /*break*/, 6];
+                                            return [4 /*yield*/, idbReq(s.get(IDB_DEK_ID))];
+                                        case 5:
+                                            again = _a.sent();
+                                            if (!(again === null || again === void 0 ? void 0 : again.key))
+                                                throw new Error('Failed to load IndexedDB encryption key');
+                                            return [2 /*return*/, again.key];
+                                        case 6: throw e_3;
+                                        case 7: return [2 /*return*/];
+                                    }
+                                });
+                            }); })];
+                    case 5:
+                        key = _a.sent();
+                        this.dek = key;
+                        return [2 /*return*/, key];
+                }
+            });
+        });
+    };
+    //@internal
+    IndexedDbDataProvider.prototype.plaintextDbNames = function (entity) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var names, set, _a, _b, f, _c, _d, def, keys, _loop_1, keys_1, keys_1_1, key;
+            var e_4, _e, e_5, _f, e_6, _g;
+            return tslib_1.__generator(this, function (_h) {
+                switch (_h.label) {
+                    case 0: return [4 /*yield*/, (0, filter_consumer_bridge_to_sql_request_js_1.dbNamesOf)(entity, function (x) { return x; })];
+                    case 1:
+                        names = _h.sent();
+                        set = new Set();
+                        try {
+                            for (_a = tslib_1.__values(entity.idMetadata.fields), _b = _a.next(); !_b.done; _b = _a.next()) {
+                                f = _b.value;
+                                set.add(names.$dbNameOf(f));
+                            }
+                        }
+                        catch (e_4_1) { e_4 = { error: e_4_1 }; }
+                        finally {
+                            try {
+                                if (_b && !_b.done && (_e = _a.return)) _e.call(_a);
+                            }
+                            finally { if (e_4) throw e_4.error; }
+                        }
+                        try {
+                            for (_c = tslib_1.__values(this.indexesFor(entity)), _d = _c.next(); !_d.done; _d = _c.next()) {
+                                def = _d.value;
+                                keys = Array.isArray(def) ? tslib_1.__spreadArray([], tslib_1.__read(def), false) : [def];
+                                _loop_1 = function (key) {
+                                    var field = tslib_1.__spreadArray([], tslib_1.__read(entity.fields), false).find(function (f) { return f.key === key; });
+                                    if (field)
+                                        set.add(names.$dbNameOf(field));
+                                };
+                                try {
+                                    for (keys_1 = (e_6 = void 0, tslib_1.__values(keys)), keys_1_1 = keys_1.next(); !keys_1_1.done; keys_1_1 = keys_1.next()) {
+                                        key = keys_1_1.value;
+                                        _loop_1(key);
+                                    }
+                                }
+                                catch (e_6_1) { e_6 = { error: e_6_1 }; }
+                                finally {
+                                    try {
+                                        if (keys_1_1 && !keys_1_1.done && (_g = keys_1.return)) _g.call(keys_1);
+                                    }
+                                    finally { if (e_6) throw e_6.error; }
+                                }
+                            }
+                        }
+                        catch (e_5_1) { e_5 = { error: e_5_1 }; }
+                        finally {
+                            try {
+                                if (_d && !_d.done && (_f = _c.return)) _f.call(_c);
+                            }
+                            finally { if (e_5) throw e_5.error; }
+                        }
+                        return [2 /*return*/, set];
+                }
+            });
+        });
+    };
+    //@internal
+    IndexedDbDataProvider.prototype.forget = function (db) {
+        if (this.db === db)
+            this.db = undefined;
+    };
+    //@internal
+    IndexedDbDataProvider.prototype.open = function (version, upgrade) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var _a;
+            var _this = this;
+            return tslib_1.__generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (this.db && version == null)
+                            return [2 /*return*/, this.db];
+                        _a = this;
+                        return [4 /*yield*/, new Promise(function (resolve, reject) {
+                                var request = version == null
+                                    ? indexedDB.open(_this.dbName)
+                                    : indexedDB.open(_this.dbName, version);
+                                request.onerror = function () { return reject(request.error); };
+                                request.onupgradeneeded = function () {
+                                    return upgrade === null || upgrade === void 0 ? void 0 : upgrade(request.result, request.transaction);
+                                };
+                                request.onsuccess = function () {
+                                    var db = request.result;
+                                    var forget = function () { return _this.forget(db); };
+                                    db.onclose = forget;
+                                    db.onversionchange = function () {
+                                        db.close();
+                                        forget();
+                                    };
+                                    resolve(db);
+                                };
+                            })];
+                    case 1:
+                        _a.db = _b.sent();
+                        return [2 /*return*/, this.db];
+                }
+            });
+        });
+    };
+    //@internal
+    IndexedDbDataProvider.prototype.getAll = function (storeName, range) {
+        return this.withStore(storeName, 'readonly', function (store) {
+            return idbReq(range ? store.getAll(range) : store.getAll());
+        });
+    };
+    //@internal
+    IndexedDbDataProvider.prototype.fetchOps = function (storeName, entity, ops) {
+        var _this = this;
+        return this.withStore(storeName, 'readonly', function (store) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+            var idKey, seen, rows, _loop_2, ops_1, ops_1_1, op, e_7_1;
+            var e_7, _a;
+            return tslib_1.__generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        idKey = entity.idMetadata.fields[0].key;
+                        seen = new Set();
+                        rows = [];
+                        _loop_2 = function (op) {
+                            var source, chunk, _c, _d, chunk_1, chunk_1_1, row, k;
+                            var e_8, _e;
+                            return tslib_1.__generator(this, function (_f) {
+                                switch (_f.label) {
+                                    case 0:
+                                        source = op.index ? store.index(op.index) : store;
+                                        if (!(op.type === 'keys')) return [3 /*break*/, 5];
+                                        if (!op.index) return [3 /*break*/, 2];
+                                        return [4 /*yield*/, Promise.all(op.keys.map(function (key) { return idbReq(source.getAll(key)); }))];
+                                    case 1:
+                                        _d = (_f.sent()).flat();
+                                        return [3 /*break*/, 4];
+                                    case 2: return [4 /*yield*/, Promise.all(op.keys.map(function (key) { return idbReq(store.get(key)); }))];
+                                    case 3:
+                                        _d = _f.sent();
+                                        _f.label = 4;
+                                    case 4:
+                                        _c = _d;
+                                        return [3 /*break*/, 7];
+                                    case 5: return [4 /*yield*/, idbReq(source.getAll(op.range))];
+                                    case 6:
+                                        _c = _f.sent();
+                                        _f.label = 7;
+                                    case 7:
+                                        chunk = _c;
+                                        try {
+                                            for (chunk_1 = (e_8 = void 0, tslib_1.__values(chunk)), chunk_1_1 = chunk_1.next(); !chunk_1_1.done; chunk_1_1 = chunk_1.next()) {
+                                                row = chunk_1_1.value;
+                                                if (row == null)
+                                                    continue;
+                                                k = JSON.stringify(row[idKey]);
+                                                if (seen.has(k))
+                                                    continue;
+                                                seen.add(k);
+                                                rows.push(row);
+                                            }
+                                        }
+                                        catch (e_8_1) { e_8 = { error: e_8_1 }; }
+                                        finally {
+                                            try {
+                                                if (chunk_1_1 && !chunk_1_1.done && (_e = chunk_1.return)) _e.call(chunk_1);
+                                            }
+                                            finally { if (e_8) throw e_8.error; }
+                                        }
+                                        return [2 /*return*/];
+                                }
+                            });
+                        };
+                        _b.label = 1;
+                    case 1:
+                        _b.trys.push([1, 6, 7, 8]);
+                        ops_1 = tslib_1.__values(ops), ops_1_1 = ops_1.next();
+                        _b.label = 2;
+                    case 2:
+                        if (!!ops_1_1.done) return [3 /*break*/, 5];
+                        op = ops_1_1.value;
+                        return [5 /*yield**/, _loop_2(op)];
+                    case 3:
+                        _b.sent();
+                        _b.label = 4;
+                    case 4:
+                        ops_1_1 = ops_1.next();
+                        return [3 /*break*/, 2];
+                    case 5: return [3 /*break*/, 8];
+                    case 6:
+                        e_7_1 = _b.sent();
+                        e_7 = { error: e_7_1 };
+                        return [3 /*break*/, 8];
+                    case 7:
+                        try {
+                            if (ops_1_1 && !ops_1_1.done && (_a = ops_1.return)) _a.call(ops_1);
+                        }
+                        finally { if (e_7) throw e_7.error; }
+                        return [7 /*endfinally*/];
+                    case 8: return [2 /*return*/, rows];
+                }
+            });
+        }); });
+    };
+    //@internal
+    IndexedDbDataProvider.prototype.withStore = function (storeName, mode, op) {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            var tx = _this.db.transaction(storeName, mode);
+            var result;
+            var opErr;
+            tx.oncomplete = function () {
+                if (opErr)
+                    reject(opErr);
+                else
+                    resolve(result);
+            };
+            tx.onabort = function () { return reject(opErr !== null && opErr !== void 0 ? opErr : tx.error); };
+            tx.onerror = function () { return reject(opErr !== null && opErr !== void 0 ? opErr : tx.error); };
+            Promise.resolve(op(tx.objectStore(storeName))).then(function (r) {
+                result = r;
+            }, function (e) {
+                opErr = e;
+                try {
+                    tx.abort();
+                }
+                catch (_a) {
+                    /* already aborted */
+                }
+            });
+        });
+    };
+    return IndexedDbDataProvider;
+}());
+exports.IndexedDbDataProvider = IndexedDbDataProvider;
+var IndexedDbEntityDataProvider = /** @class */ (function () {
+    function IndexedDbEntityDataProvider(provider, entity) {
+        this.provider = provider;
+        this.entity = entity;
+    }
+    IndexedDbEntityDataProvider.prototype.find = function (options) {
+        return this.provider.runWithRows(this.entity, options === null || options === void 0 ? void 0 : options.where, function (dp) {
+            return dp.find(options);
+        });
+    };
+    IndexedDbEntityDataProvider.prototype.count = function (where) {
+        return this.provider.runWithRows(this.entity, where, function (dp) { return dp.count(where); });
+    };
+    IndexedDbEntityDataProvider.prototype.groupBy = function (options) {
+        return this.provider.runWithRows(this.entity, options === null || options === void 0 ? void 0 : options.where, function (dp) {
+            return dp.groupBy(options);
+        });
+    };
+    IndexedDbEntityDataProvider.prototype.insert = function (data) {
+        var _this = this;
+        return this.provider.enqueue(function () { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+            var helper, names, auto, idName, rows, storeName, dek, _a, keep, _b, keys, i, toWrite, _c;
+            var _this = this;
+            return tslib_1.__generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0: return [4 /*yield*/, this.provider.ensureStores([this.entity])];
+                    case 1:
+                        _d.sent();
+                        helper = new array_entity_data_provider_js_1.ArrayEntityDataProvider(this.entity, function () { return []; });
+                        return [4 /*yield*/, helper.init()];
+                    case 2:
+                        names = _d.sent();
+                        auto = (0, RepositoryImplementation_js_1.isAutoIncrement)(this.entity.idMetadata.field);
+                        idName = names.$dbNameOf(this.entity.idMetadata.field);
+                        rows = data.map(function (row) {
+                            var json = helper.translateToJson(row, names);
+                            helper.verifyThatRowHasAllNotNullColumns(json, names);
+                            if (auto)
+                                delete json[idName];
+                            return json;
+                        });
+                        storeName = storeNameOf(this.entity);
+                        if (!this.provider.encrypt) return [3 /*break*/, 4];
+                        return [4 /*yield*/, this.provider.loadDek()];
+                    case 3:
+                        _a = _d.sent();
+                        return [3 /*break*/, 5];
+                    case 4:
+                        _a = undefined;
+                        _d.label = 5;
+                    case 5:
+                        dek = _a;
+                        if (!dek) return [3 /*break*/, 7];
+                        return [4 /*yield*/, this.provider.plaintextDbNames(this.entity)];
+                    case 6:
+                        _b = _d.sent();
+                        return [3 /*break*/, 8];
+                    case 7:
+                        _b = undefined;
+                        _d.label = 8;
+                    case 8:
+                        keep = _b;
+                        if (!(dek && auto)) return [3 /*break*/, 10];
+                        return [4 /*yield*/, this.provider.withStore(storeName, 'readwrite', function (store) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                                var allocated, i, _a, _b;
+                                return tslib_1.__generator(this, function (_c) {
+                                    switch (_c.label) {
+                                        case 0:
+                                            allocated = [];
+                                            i = 0;
+                                            _c.label = 1;
+                                        case 1:
+                                            if (!(i < rows.length)) return [3 /*break*/, 4];
+                                            _b = (_a = allocated).push;
+                                            return [4 /*yield*/, idbReq(store.add({}))];
+                                        case 2:
+                                            _b.apply(_a, [_c.sent()]);
+                                            _c.label = 3;
+                                        case 3:
+                                            i++;
+                                            return [3 /*break*/, 1];
+                                        case 4: return [2 /*return*/, allocated];
+                                    }
+                                });
+                            }); })];
+                    case 9:
+                        keys = _d.sent();
+                        for (i = 0; i < rows.length; i++) {
+                            rows[i][idName] = keys[i];
+                        }
+                        _d.label = 10;
+                    case 10:
+                        if (!dek) return [3 /*break*/, 12];
+                        return [4 /*yield*/, Promise.all(rows.map(function (json) {
+                                return encryptJson(storeName, json, keep, keyFromRow(_this.entity, names, json), dek);
+                            }))];
+                    case 11:
+                        _c = _d.sent();
+                        return [3 /*break*/, 13];
+                    case 12:
+                        _c = rows;
+                        _d.label = 13;
+                    case 13:
+                        toWrite = _c;
+                        return [4 /*yield*/, this.provider.withStore(storeName, 'readwrite', function (store) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                                var i, key, e_9;
+                                var _a;
+                                return tslib_1.__generator(this, function (_b) {
+                                    switch (_b.label) {
+                                        case 0:
+                                            i = 0;
+                                            _b.label = 1;
+                                        case 1:
+                                            if (!(i < toWrite.length)) return [3 /*break*/, 9];
+                                            _b.label = 2;
+                                        case 2:
+                                            _b.trys.push([2, 7, , 8]);
+                                            if (!(dek && auto)) return [3 /*break*/, 4];
+                                            return [4 /*yield*/, idbReq(store.put(toWrite[i]))];
+                                        case 3:
+                                            _b.sent();
+                                            return [3 /*break*/, 6];
+                                        case 4: return [4 /*yield*/, idbReq(store.add(toWrite[i]))];
+                                        case 5:
+                                            key = _b.sent();
+                                            if (auto)
+                                                rows[i][idName] = (_a = rows[i][idName]) !== null && _a !== void 0 ? _a : key;
+                                            _b.label = 6;
+                                        case 6: return [3 /*break*/, 8];
+                                        case 7:
+                                            e_9 = _b.sent();
+                                            if ((e_9 === null || e_9 === void 0 ? void 0 : e_9.name) === 'ConstraintError')
+                                                throw Error('id already exists');
+                                            throw e_9;
+                                        case 8:
+                                            i++;
+                                            return [3 /*break*/, 1];
+                                        case 9: return [2 /*return*/];
+                                    }
+                                });
+                            }); })];
+                    case 14:
+                        _d.sent();
+                        return [2 /*return*/, rows.map(function (json) { return helper.translateFromJson(json, names); })];
+                }
+            });
+        }); });
+    };
+    IndexedDbEntityDataProvider.prototype.update = function (id, data) {
+        var _this = this;
+        return this.provider.enqueue(function () { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+            var helper, names, key, storeName, existingRaw, dek, _a, existing, _b, json, keys, _c, _d, f, newKey, toWrite, _e, _f, _g;
+            var e_10, _h;
+            var _this = this;
+            return tslib_1.__generator(this, function (_j) {
+                switch (_j.label) {
+                    case 0: return [4 /*yield*/, this.provider.ensureStores([this.entity])];
+                    case 1:
+                        _j.sent();
+                        helper = new array_entity_data_provider_js_1.ArrayEntityDataProvider(this.entity, function () { return []; });
+                        return [4 /*yield*/, helper.init()];
+                    case 2:
+                        names = _j.sent();
+                        key = toIdbKey(this.entity, id);
+                        storeName = storeNameOf(this.entity);
+                        return [4 /*yield*/, this.provider.withStore(storeName, 'readonly', function (store) { return idbReq(store.get(key)); })];
+                    case 3:
+                        existingRaw = _j.sent();
+                        if (existingRaw == null)
+                            throw new Error("Couldn't find row with id \"".concat(id, "\" in entity \"").concat(this.entity.key, "\" to update"));
+                        if (!this.provider.encrypt) return [3 /*break*/, 5];
+                        return [4 /*yield*/, this.provider.loadDek()];
+                    case 4:
+                        _a = _j.sent();
+                        return [3 /*break*/, 6];
+                    case 5:
+                        _a = undefined;
+                        _j.label = 6;
+                    case 6:
+                        dek = _a;
+                        if (!dek) return [3 /*break*/, 8];
+                        return [4 /*yield*/, decryptJson(storeName, existingRaw, this.entity, names, dek)];
+                    case 7:
+                        _b = _j.sent();
+                        return [3 /*break*/, 9];
+                    case 8:
+                        _b = existingRaw;
+                        _j.label = 9;
+                    case 9:
+                        existing = _b;
+                        json = tslib_1.__assign({}, existing);
+                        keys = Object.keys(data);
+                        try {
+                            for (_c = tslib_1.__values(this.entity.fields), _d = _c.next(); !_d.done; _d = _c.next()) {
+                                f = _d.value;
+                                if (!(0, filter_consumer_bridge_to_sql_request_js_1.isDbReadonly)(f, names) && keys.includes(f.key)) {
+                                    json[names.$dbNameOf(f)] = f.valueConverter.toJson(data[f.key]);
+                                }
+                            }
+                        }
+                        catch (e_10_1) { e_10 = { error: e_10_1 }; }
+                        finally {
+                            try {
+                                if (_d && !_d.done && (_h = _c.return)) _h.call(_c);
+                            }
+                            finally { if (e_10) throw e_10.error; }
+                        }
+                        helper.verifyThatRowHasAllNotNullColumns(json, names);
+                        newKey = keyFromRow(this.entity, names, json);
+                        if (!dek) return [3 /*break*/, 12];
+                        _f = encryptJson;
+                        _g = [storeName,
+                            json];
+                        return [4 /*yield*/, this.provider.plaintextDbNames(this.entity)];
+                    case 10: return [4 /*yield*/, _f.apply(void 0, _g.concat([_j.sent(), newKey,
+                            dek]))];
+                    case 11:
+                        _e = _j.sent();
+                        return [3 /*break*/, 13];
+                    case 12:
+                        _e = json;
+                        _j.label = 13;
+                    case 13:
+                        toWrite = _e;
+                        return [4 /*yield*/, this.provider.withStore(storeName, 'readwrite', function (store) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                                var conflict;
+                                return tslib_1.__generator(this, function (_a) {
+                                    switch (_a.label) {
+                                        case 0:
+                                            if (!!idbKeysEqual(key, newKey)) return [3 /*break*/, 3];
+                                            return [4 /*yield*/, idbReq(store.get(newKey))];
+                                        case 1:
+                                            conflict = _a.sent();
+                                            if (conflict != null)
+                                                throw Error('id already exists');
+                                            return [4 /*yield*/, idbReq(store.delete(key))];
+                                        case 2:
+                                            _a.sent();
+                                            _a.label = 3;
+                                        case 3: return [4 /*yield*/, idbReq(store.put(toWrite))];
+                                        case 4:
+                                            _a.sent();
+                                            return [2 /*return*/];
+                                    }
+                                });
+                            }); })];
+                    case 14:
+                        _j.sent();
+                        return [2 /*return*/, helper.translateFromJson(json, names)];
+                }
+            });
+        }); });
+    };
+    IndexedDbEntityDataProvider.prototype.delete = function (ids) {
+        var _this = this;
+        if (ids.length === 0)
+            return Promise.resolve();
+        return this.provider.enqueue(function () { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+            var _this = this;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.provider.ensureStores([this.entity])];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/, this.provider.withStore(storeNameOf(this.entity), 'readwrite', function (store) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                                var ids_1, ids_1_1, id, key, existing, e_11_1;
+                                var e_11, _a;
+                                return tslib_1.__generator(this, function (_b) {
+                                    switch (_b.label) {
+                                        case 0:
+                                            _b.trys.push([0, 6, 7, 8]);
+                                            ids_1 = tslib_1.__values(ids), ids_1_1 = ids_1.next();
+                                            _b.label = 1;
+                                        case 1:
+                                            if (!!ids_1_1.done) return [3 /*break*/, 5];
+                                            id = ids_1_1.value;
+                                            key = toIdbKey(this.entity, id);
+                                            return [4 /*yield*/, idbReq(store.get(key))];
+                                        case 2:
+                                            existing = _b.sent();
+                                            if (existing == null)
+                                                throw new Error("Couldn't find row with id \"".concat(id, "\" in entity \"").concat(this.entity.key, "\" to delete"));
+                                            return [4 /*yield*/, idbReq(store.delete(key))];
+                                        case 3:
+                                            _b.sent();
+                                            _b.label = 4;
+                                        case 4:
+                                            ids_1_1 = ids_1.next();
+                                            return [3 /*break*/, 1];
+                                        case 5: return [3 /*break*/, 8];
+                                        case 6:
+                                            e_11_1 = _b.sent();
+                                            e_11 = { error: e_11_1 };
+                                            return [3 /*break*/, 8];
+                                        case 7:
+                                            try {
+                                                if (ids_1_1 && !ids_1_1.done && (_a = ids_1.return)) _a.call(ids_1);
+                                            }
+                                            finally { if (e_11) throw e_11.error; }
+                                            return [7 /*endfinally*/];
+                                        case 8: return [2 /*return*/];
+                                    }
+                                });
+                            }); })];
+                }
+            });
+        }); });
+    };
+    return IndexedDbEntityDataProvider;
+}());
+function storeNameOf(entity) {
+    return entity.dbName;
+}
+//@internal
+function idbPrefetchFromFilter(entity_1, where_1) {
+    return tslib_1.__awaiter(this, arguments, void 0, function (entity, where, indexes) {
+        var names, c, r, ordered, ordered_1, ordered_1_1, idx, r;
+        var e_12, _a;
+        if (indexes === void 0) { indexes = []; }
+        return tslib_1.__generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    if (!where)
+                        return [2 /*return*/, { type: 'all' }];
+                    return [4 /*yield*/, (0, filter_consumer_bridge_to_sql_request_js_1.dbNamesOf)(entity, function (x) { return x; })];
+                case 1:
+                    names = _b.sent();
+                    if (entity.idMetadata.fields.length === 1) {
+                        c = new IdbPrefetchCollector(entity.idMetadata.fields[0]);
+                        where.__applyToConsumer(c);
+                        r = c.result();
+                        if (r.type !== 'all')
+                            return [2 /*return*/, r];
+                    }
+                    ordered = tslib_1.__spreadArray([], tslib_1.__read(indexes), false).sort(function (a, b) { return pathLen(b.keyPath) - pathLen(a.keyPath); });
+                    try {
+                        for (ordered_1 = tslib_1.__values(ordered), ordered_1_1 = ordered_1.next(); !ordered_1_1.done; ordered_1_1 = ordered_1.next()) {
+                            idx = ordered_1_1.value;
+                            r = prefetchForIndex(entity, names, where, idx);
+                            if (r.type !== 'all')
+                                return [2 /*return*/, withIndex(r, idx.name)];
+                        }
+                    }
+                    catch (e_12_1) { e_12 = { error: e_12_1 }; }
+                    finally {
+                        try {
+                            if (ordered_1_1 && !ordered_1_1.done && (_a = ordered_1.return)) _a.call(ordered_1);
+                        }
+                        finally { if (e_12) throw e_12.error; }
+                    }
+                    return [2 /*return*/, { type: 'all' }];
+            }
+        });
+    });
+}
+function prefetchForIndex(entity, names, where, idx) {
+    var path = Array.isArray(idx.keyPath) ? idx.keyPath : [idx.keyPath];
+    if (path.length === 1) {
+        var field = fieldByDbName(entity, names, path[0]);
+        if (!field)
+            return { type: 'all' };
+        var c = new IdbPrefetchCollector(field);
+        where.__applyToConsumer(c);
+        return c.result();
+    }
+    var parts = path.map(function (dbName) {
+        var field = fieldByDbName(entity, names, dbName);
+        if (!field)
+            return { type: 'all' };
+        var c = new IdbPrefetchCollector(field);
+        where.__applyToConsumer(c);
+        return c.result();
+    });
+    if (parts.every(function (p) { return p.type === 'keys'; })) {
+        return {
+            type: 'keys',
+            keys: cartesian(parts.map(function (p) { return p.keys; })),
+        };
+    }
+    var last = parts[parts.length - 1];
+    var prefix = parts.slice(0, -1);
+    if (last.type === 'range' &&
+        prefix.every(function (p) { return p.type === 'keys' && p.keys.length === 1; })) {
+        var pre = prefix.map(function (p) { return p.keys[0]; });
+        var r = last.range;
+        try {
+            if (r.lower !== undefined && r.upper !== undefined)
+                return {
+                    type: 'range',
+                    range: IDBKeyRange.bound(tslib_1.__spreadArray(tslib_1.__spreadArray([], tslib_1.__read(pre), false), [r.lower], false), tslib_1.__spreadArray(tslib_1.__spreadArray([], tslib_1.__read(pre), false), [r.upper], false), r.lowerOpen, r.upperOpen),
+                };
+            if (r.lower !== undefined)
+                return {
+                    type: 'range',
+                    range: IDBKeyRange.lowerBound(tslib_1.__spreadArray(tslib_1.__spreadArray([], tslib_1.__read(pre), false), [r.lower], false), r.lowerOpen),
+                };
+            if (r.upper !== undefined)
+                return {
+                    type: 'range',
+                    range: IDBKeyRange.upperBound(tslib_1.__spreadArray(tslib_1.__spreadArray([], tslib_1.__read(pre), false), [r.upper], false), r.upperOpen),
+                };
+        }
+        catch (_a) {
+            return { type: 'keys', keys: [] };
+        }
+    }
+    return { type: 'all' };
+}
+function withIndex(prefetch, index) {
+    if (prefetch.type === 'all')
+        return prefetch;
+    if (prefetch.type === 'or')
+        return { type: 'or', parts: prefetch.parts.map(function (p) { return (tslib_1.__assign(tslib_1.__assign({}, p), { index: index })); }) };
+    return tslib_1.__assign(tslib_1.__assign({}, prefetch), { index: index });
+}
+function pathLen(keyPath) {
+    return Array.isArray(keyPath) ? keyPath.length : 1;
+}
+function fieldByDbName(entity, names, dbName) {
+    var e_13, _a;
+    try {
+        for (var _b = tslib_1.__values(entity.fields), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var f = _c.value;
+            if (names.$dbNameOf(f) === dbName)
+                return f;
+        }
+    }
+    catch (e_13_1) { e_13 = { error: e_13_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_13) throw e_13.error; }
+    }
+}
+function cartesian(lists) {
+    var e_14, _a;
+    var acc = [[]];
+    var _loop_3 = function (list) {
+        acc = acc.flatMap(function (prefix) { return list.map(function (v) { return tslib_1.__spreadArray(tslib_1.__spreadArray([], tslib_1.__read(prefix), false), [v], false); }); });
+    };
+    try {
+        for (var lists_1 = tslib_1.__values(lists), lists_1_1 = lists_1.next(); !lists_1_1.done; lists_1_1 = lists_1.next()) {
+            var list = lists_1_1.value;
+            _loop_3(list);
+        }
+    }
+    catch (e_14_1) { e_14 = { error: e_14_1 }; }
+    finally {
+        try {
+            if (lists_1_1 && !lists_1_1.done && (_a = lists_1.return)) _a.call(lists_1);
+        }
+        finally { if (e_14) throw e_14.error; }
+    }
+    return acc;
+}
+var IdbPrefetchCollector = /** @class */ (function () {
+    function IdbPrefetchCollector(idField) {
+        this.idField = idField;
+        this.cannotNarrow = false;
+    }
+    IdbPrefetchCollector.prototype.result = function () {
+        if (this.cannotNarrow)
+            return { type: 'all' };
+        var andOp = this.andOp();
+        if (this.keys && andOp)
+            return andOp;
+        if (this.orOps)
+            return mergeOps(this.orOps);
+        return andOp !== null && andOp !== void 0 ? andOp : { type: 'all' };
+    };
+    IdbPrefetchCollector.prototype.hasIdConstraint = function () {
+        return this.keys != null || this.hasBounds || this.orOps != null;
+    };
+    Object.defineProperty(IdbPrefetchCollector.prototype, "hasBounds", {
+        get: function () {
+            return this.lower != null || this.upper != null;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    IdbPrefetchCollector.prototype.andOp = function () {
+        if (this.keys) {
+            if (!this.hasBounds)
+                return { type: 'keys', keys: this.keys };
+            try {
+                var range_1 = this.toKeyRange();
+                return {
+                    type: 'keys',
+                    keys: this.keys.filter(function (k) { return range_1.includes(k); }),
+                };
+            }
+            catch (_a) {
+                return { type: 'keys', keys: [] };
+            }
+        }
+        if (!this.hasBounds)
+            return undefined;
+        try {
+            return { type: 'range', range: this.toKeyRange() };
+        }
+        catch (_b) {
+            return { type: 'keys', keys: [] };
+        }
+    };
+    IdbPrefetchCollector.prototype.toKeyRange = function () {
+        if (this.lower && this.upper)
+            return IDBKeyRange.bound(this.lower.value, this.upper.value, this.lower.open, this.upper.open);
+        if (this.lower)
+            return IDBKeyRange.lowerBound(this.lower.value, this.lower.open);
+        return IDBKeyRange.upperBound(this.upper.value, this.upper.open);
+    };
+    IdbPrefetchCollector.prototype.isId = function (col) {
+        return col.key === this.idField.key;
+    };
+    IdbPrefetchCollector.prototype.toKey = function (col, val) {
+        return col.valueConverter.toJson(val);
+    };
+    IdbPrefetchCollector.prototype.intersectKeys = function (vals) {
+        if (!this.keys)
+            this.keys = tslib_1.__spreadArray([], tslib_1.__read(vals), false);
+        else
+            this.keys = this.keys.filter(function (k) {
+                return vals.some(function (v) { return idbKeysEqual(k, v); });
+            });
+    };
+    IdbPrefetchCollector.prototype.addLower = function (value, open) {
+        if (!this.lower)
+            this.lower = { value: value, open: open };
+        else if (value > this.lower.value)
+            this.lower = { value: value, open: open };
+        else if (value === this.lower.value)
+            this.lower = { value: value, open: this.lower.open || open };
+    };
+    IdbPrefetchCollector.prototype.addUpper = function (value, open) {
+        if (!this.upper)
+            this.upper = { value: value, open: open };
+        else if (value < this.upper.value)
+            this.upper = { value: value, open: open };
+        else if (value === this.upper.value)
+            this.upper = { value: value, open: this.upper.open || open };
+    };
+    IdbPrefetchCollector.prototype.isEqualTo = function (col, val) {
+        if (this.isId(col))
+            this.intersectKeys([this.toKey(col, val)]);
+    };
+    IdbPrefetchCollector.prototype.isIn = function (col, val) {
+        var _this = this;
+        if (this.isId(col))
+            this.intersectKeys(val.map(function (v) { return _this.toKey(col, v); }));
+    };
+    IdbPrefetchCollector.prototype.isGreaterThan = function (col, val) {
+        if (this.isId(col))
+            this.addLower(this.toKey(col, val), true);
+    };
+    IdbPrefetchCollector.prototype.isGreaterOrEqualTo = function (col, val) {
+        if (this.isId(col))
+            this.addLower(this.toKey(col, val), false);
+    };
+    IdbPrefetchCollector.prototype.isLessThan = function (col, val) {
+        if (this.isId(col))
+            this.addUpper(this.toKey(col, val), true);
+    };
+    IdbPrefetchCollector.prototype.isLessOrEqualTo = function (col, val) {
+        if (this.isId(col))
+            this.addUpper(this.toKey(col, val), false);
+    };
+    IdbPrefetchCollector.prototype.or = function (orElements) {
+        var _this = this;
+        var results = orElements.map(function (el) {
+            var c = new IdbPrefetchCollector(_this.idField);
+            el.__applyToConsumer(c);
+            return c.result();
+        });
+        if (results.some(function (r) { return r.type === 'all'; }))
+            return;
+        var ops = results.flatMap(function (r) {
+            return r.type === 'or' ? r.parts : r.type === 'all' ? [] : [r];
+        });
+        this.orOps = this.orOps ? tslib_1.__spreadArray(tslib_1.__spreadArray([], tslib_1.__read(this.orOps), false), tslib_1.__read(ops), false) : ops;
+    };
+    IdbPrefetchCollector.prototype.not = function (filter) {
+        var c = new IdbPrefetchCollector(this.idField);
+        filter.__applyToConsumer(c);
+        if (c.cannotNarrow || c.hasIdConstraint())
+            this.cannotNarrow = true;
+    };
+    IdbPrefetchCollector.prototype.isNull = function (col) {
+        if (this.isId(col))
+            this.cannotNarrow = true;
+    };
+    IdbPrefetchCollector.prototype.isNotNull = function (col) {
+        if (this.isId(col))
+            this.cannotNarrow = true;
+    };
+    IdbPrefetchCollector.prototype.isDifferentFrom = function (_col, _val) { };
+    IdbPrefetchCollector.prototype.containsCaseInsensitive = function (_col, _val) { };
+    IdbPrefetchCollector.prototype.notContainsCaseInsensitive = function (_col, _val) { };
+    IdbPrefetchCollector.prototype.startsWithCaseInsensitive = function (_col, _val) { };
+    IdbPrefetchCollector.prototype.endsWithCaseInsensitive = function (_col, _val) { };
+    IdbPrefetchCollector.prototype.custom = function (_key, _customItem) {
+        this.cannotNarrow = true;
+    };
+    IdbPrefetchCollector.prototype.databaseCustom = function (_databaseCustom) {
+        this.cannotNarrow = true;
+    };
+    return IdbPrefetchCollector;
+}());
+function mergeOps(ops) {
+    var e_15, _a;
+    var _b, _c;
+    var keyGroups = new Map();
+    var ranges = [];
+    try {
+        for (var ops_2 = tslib_1.__values(ops), ops_2_1 = ops_2.next(); !ops_2_1.done; ops_2_1 = ops_2.next()) {
+            var op = ops_2_1.value;
+            if (op.type === 'keys') {
+                var k = (_b = op.index) !== null && _b !== void 0 ? _b : '';
+                keyGroups.set(k, tslib_1.__spreadArray(tslib_1.__spreadArray([], tslib_1.__read(((_c = keyGroups.get(k)) !== null && _c !== void 0 ? _c : [])), false), tslib_1.__read(op.keys), false));
+            }
+            else
+                ranges.push(op);
+        }
+    }
+    catch (e_15_1) { e_15 = { error: e_15_1 }; }
+    finally {
+        try {
+            if (ops_2_1 && !ops_2_1.done && (_a = ops_2.return)) _a.call(ops_2);
+        }
+        finally { if (e_15) throw e_15.error; }
+    }
+    var parts = tslib_1.__spreadArray(tslib_1.__spreadArray([], tslib_1.__read(tslib_1.__spreadArray([], tslib_1.__read(keyGroups.entries()), false).map(function (_a) {
+        var _b = tslib_1.__read(_a, 2), index = _b[0], keys = _b[1];
+        return (tslib_1.__assign({ type: 'keys', keys: keys.filter(function (k, i) { return keys.findIndex(function (x) { return idbKeysEqual(x, k); }) === i; }) }, (index ? { index: index } : {})));
+    })), false), tslib_1.__read(ranges), false);
+    if (parts.length === 1)
+        return parts[0];
+    return { type: 'or', parts: parts };
+}
+function resolveIndexDefs(entity, defs, storeKeyPath) {
+    return tslib_1.__awaiter(this, void 0, void 0, function () {
+        var names, result, seen, pk, defs_1, defs_1_1, def, keys, keyPath, path, name_3;
+        var e_16, _a;
+        return tslib_1.__generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    if (defs.length === 0)
+                        return [2 /*return*/, []];
+                    return [4 /*yield*/, (0, filter_consumer_bridge_to_sql_request_js_1.dbNamesOf)(entity, function (x) { return x; })];
+                case 1:
+                    names = _b.sent();
+                    result = [];
+                    seen = new Set();
+                    pk = JSON.stringify(storeKeyPath);
+                    try {
+                        for (defs_1 = tslib_1.__values(defs), defs_1_1 = defs_1.next(); !defs_1_1.done; defs_1_1 = defs_1.next()) {
+                            def = defs_1_1.value;
+                            keys = Array.isArray(def) ? tslib_1.__spreadArray([], tslib_1.__read(def), false) : [def];
+                            keyPath = keys.map(function (key) {
+                                var field = tslib_1.__spreadArray([], tslib_1.__read(entity.fields), false).find(function (f) { return f.key === key; });
+                                if (!field)
+                                    throw new Error("IndexedDB index field \"".concat(key, "\" not found on entity \"").concat(entity.key, "\""));
+                                return names.$dbNameOf(field);
+                            });
+                            path = keyPath.length === 1 ? keyPath[0] : keyPath;
+                            if (JSON.stringify(path) === pk)
+                                continue;
+                            name_3 = keyPath.join('_');
+                            if (seen.has(name_3))
+                                continue;
+                            seen.add(name_3);
+                            result.push({ name: name_3, keyPath: path });
+                        }
+                    }
+                    catch (e_16_1) { e_16 = { error: e_16_1 }; }
+                    finally {
+                        try {
+                            if (defs_1_1 && !defs_1_1.done && (_a = defs_1.return)) _a.call(defs_1);
+                        }
+                        finally { if (e_16) throw e_16.error; }
+                    }
+                    return [2 /*return*/, result];
+            }
+        });
+    });
+}
+function keyPathOf(entity) {
+    return tslib_1.__awaiter(this, void 0, void 0, function () {
+        var names, fields;
+        return tslib_1.__generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, (0, filter_consumer_bridge_to_sql_request_js_1.dbNamesOf)(entity, function (x) { return x; })];
+                case 1:
+                    names = _a.sent();
+                    fields = entity.idMetadata.fields;
+                    if (fields.length === 1)
+                        return [2 /*return*/, names.$dbNameOf(fields[0])];
+                    return [2 /*return*/, fields.map(function (f) { return names.$dbNameOf(f); })];
+            }
+        });
+    });
+}
+function toIdbKey(entity, id) {
+    var fields = entity.idMetadata.fields;
+    if (fields.length === 1)
+        return fields[0].valueConverter.toJson(id);
+    var values = typeof id === 'object' && id !== null
+        ? id
+        : Object.fromEntries(String(id)
+            .split(',')
+            .map(function (part, i) { return [
+            fields[i].key,
+            fields[i].valueConverter.fromJson(part),
+        ]; }));
+    return fields.map(function (f) { return f.valueConverter.toJson(values[f.key]); });
+}
+function keyFromRow(entity, names, row) {
+    var fields = entity.idMetadata.fields;
+    if (fields.length === 1)
+        return row[names.$dbNameOf(fields[0])];
+    return fields.map(function (f) { return row[names.$dbNameOf(f)]; });
+}
+function idbKeysEqual(a, b) {
+    return JSON.stringify(a) === JSON.stringify(b);
+}
+function idbReq(request) {
+    return new Promise(function (resolve, reject) {
+        request.onsuccess = function () { return resolve(request.result); };
+        request.onerror = function () { return reject(request.error); };
+    });
+}
+function encAad(storeName, id) {
+    return new TextEncoder().encode(storeName + '\0' + JSON.stringify(id));
+}
+function asBufferSource(value, label) {
+    if (value instanceof Uint8Array || value instanceof ArrayBuffer)
+        return value;
+    throw new Error("Failed to decrypt IndexedDB row: missing ".concat(label));
+}
+function encryptJson(storeName, json, plaintext, idbKey, dek) {
+    return tslib_1.__awaiter(this, void 0, void 0, function () {
+        var stored, payload, _a, _b, k, iv, _c, _d;
+        var e_17, _e;
+        return tslib_1.__generator(this, function (_f) {
+            switch (_f.label) {
+                case 0:
+                    stored = {};
+                    payload = {};
+                    try {
+                        for (_a = tslib_1.__values(Object.keys(json)), _b = _a.next(); !_b.done; _b = _a.next()) {
+                            k = _b.value;
+                            if (k === IDB_ENC || k === IDB_IV)
+                                continue;
+                            if (plaintext.has(k))
+                                stored[k] = json[k];
+                            else
+                                payload[k] = json[k];
+                        }
+                    }
+                    catch (e_17_1) { e_17 = { error: e_17_1 }; }
+                    finally {
+                        try {
+                            if (_b && !_b.done && (_e = _a.return)) _e.call(_a);
+                        }
+                        finally { if (e_17) throw e_17.error; }
+                    }
+                    iv = crypto.getRandomValues(new Uint8Array(12));
+                    _c = stored;
+                    _d = IDB_ENC;
+                    return [4 /*yield*/, crypto.subtle.encrypt({
+                            name: 'AES-GCM',
+                            iv: iv,
+                            additionalData: encAad(storeName, idbKey),
+                        }, dek, new TextEncoder().encode(JSON.stringify(payload)))];
+                case 1:
+                    _c[_d] = _f.sent();
+                    stored[IDB_IV] = iv;
+                    return [2 /*return*/, stored];
+            }
+        });
+    });
+}
+function decryptJson(storeName, row, entity, names, dek) {
+    return tslib_1.__awaiter(this, void 0, void 0, function () {
+        var idbKey, plain, payload, result, e_18;
+        var _a;
+        return tslib_1.__generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    if (row == null || row[IDB_ENC] == null)
+                        return [2 /*return*/, row];
+                    idbKey = keyFromRow(entity, names, row);
+                    _b.label = 1;
+                case 1:
+                    _b.trys.push([1, 3, , 4]);
+                    return [4 /*yield*/, crypto.subtle.decrypt({
+                            name: 'AES-GCM',
+                            iv: asBufferSource(row[IDB_IV], IDB_IV),
+                            additionalData: encAad(storeName, idbKey),
+                        }, dek, asBufferSource(row[IDB_ENC], IDB_ENC))];
+                case 2:
+                    plain = _b.sent();
+                    payload = JSON.parse(new TextDecoder().decode(plain));
+                    result = tslib_1.__assign(tslib_1.__assign({}, row), payload);
+                    delete result[IDB_ENC];
+                    delete result[IDB_IV];
+                    return [2 /*return*/, result];
+                case 3:
+                    e_18 = _b.sent();
+                    if ((_a = e_18 === null || e_18 === void 0 ? void 0 : e_18.message) === null || _a === void 0 ? void 0 : _a.startsWith('Failed to decrypt IndexedDB row'))
+                        throw e_18;
+                    throw new Error("Failed to decrypt IndexedDB row in \"".concat(storeName, "\""));
+                case 4: return [2 /*return*/];
+            }
+        });
+    });
+}