remult 3.3.18 → 3.3.19-next.1

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

@@ -0,0 +1,1048 @@
+"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 IndexedDbDataProvider = /** @class */ (function () {
+    function IndexedDbDataProvider(dbName, options) {
+        if (dbName === void 0) { dbName = 'remult'; }
+        this.dbName = dbName;
+        //@internal
+        this.declaredIndexes = [];
+        //@internal
+        this.tail = Promise.resolve();
+        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, ops;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        storeName = storeNameOf(entity);
+                        return [4 /*yield*/, idbPrefetchFromFilter(entity, where, this.storeIndexes(storeName))];
+                    case 1:
+                        prefetch = _a.sent();
+                        this.lastFetch = prefetch;
+                        if (prefetch.type === 'all')
+                            return [2 /*return*/, this.getAll(storeName)];
+                        ops = prefetch.type === 'or' ? prefetch.parts : [prefetch];
+                        return [2 /*return*/, this.fetchOps(storeName, entity, ops)];
+                }
+            });
+        });
+    };
+    //@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, 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();
+                        needsUpgrade = 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;
+                                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.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_1, ops_1, ops_1_1, op, e_3_1;
+            var e_3, _a;
+            return tslib_1.__generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        idKey = entity.idMetadata.fields[0].key;
+                        seen = new Set();
+                        rows = [];
+                        _loop_1 = function (op) {
+                            var source, chunk, _c, _d, chunk_1, chunk_1_1, row, k;
+                            var e_4, _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_4 = 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_4_1) { e_4 = { error: e_4_1 }; }
+                                        finally {
+                                            try {
+                                                if (chunk_1_1 && !chunk_1_1.done && (_e = chunk_1.return)) _e.call(chunk_1);
+                                            }
+                                            finally { if (e_4) throw e_4.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_1(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_3_1 = _b.sent();
+                        e_3 = { error: e_3_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_3) throw e_3.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;
+            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();
+                        helper = new array_entity_data_provider_js_1.ArrayEntityDataProvider(this.entity, function () { return []; });
+                        return [4 /*yield*/, helper.init()];
+                    case 2:
+                        names = _a.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;
+                        });
+                        return [2 /*return*/, this.provider.withStore(storeNameOf(this.entity), 'readwrite', function (store) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                                var result, rows_1, rows_1_1, json, key, e_5, e_6_1;
+                                var e_6, _a;
+                                var _b;
+                                return tslib_1.__generator(this, function (_c) {
+                                    switch (_c.label) {
+                                        case 0:
+                                            result = [];
+                                            _c.label = 1;
+                                        case 1:
+                                            _c.trys.push([1, 9, 10, 11]);
+                                            rows_1 = tslib_1.__values(rows), rows_1_1 = rows_1.next();
+                                            _c.label = 2;
+                                        case 2:
+                                            if (!!rows_1_1.done) return [3 /*break*/, 8];
+                                            json = rows_1_1.value;
+                                            _c.label = 3;
+                                        case 3:
+                                            _c.trys.push([3, 5, , 6]);
+                                            return [4 /*yield*/, idbReq(store.add(json))];
+                                        case 4:
+                                            key = _c.sent();
+                                            if (auto)
+                                                json[idName] = (_b = json[idName]) !== null && _b !== void 0 ? _b : key;
+                                            return [3 /*break*/, 6];
+                                        case 5:
+                                            e_5 = _c.sent();
+                                            if ((e_5 === null || e_5 === void 0 ? void 0 : e_5.name) === 'ConstraintError')
+                                                throw Error('id already exists');
+                                            throw e_5;
+                                        case 6:
+                                            result.push(helper.translateFromJson(json, names));
+                                            _c.label = 7;
+                                        case 7:
+                                            rows_1_1 = rows_1.next();
+                                            return [3 /*break*/, 2];
+                                        case 8: return [3 /*break*/, 11];
+                                        case 9:
+                                            e_6_1 = _c.sent();
+                                            e_6 = { error: e_6_1 };
+                                            return [3 /*break*/, 11];
+                                        case 10:
+                                            try {
+                                                if (rows_1_1 && !rows_1_1.done && (_a = rows_1.return)) _a.call(rows_1);
+                                            }
+                                            finally { if (e_6) throw e_6.error; }
+                                            return [7 /*endfinally*/];
+                                        case 11: return [2 /*return*/, result];
+                                    }
+                                });
+                            }); })];
+                }
+            });
+        }); });
+    };
+    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;
+            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();
+                        helper = new array_entity_data_provider_js_1.ArrayEntityDataProvider(this.entity, function () { return []; });
+                        return [4 /*yield*/, helper.init()];
+                    case 2:
+                        names = _a.sent();
+                        key = toIdbKey(this.entity, id);
+                        return [2 /*return*/, this.provider.withStore(storeNameOf(this.entity), 'readwrite', function (store) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                                var existing, json, keys, _a, _b, f, newKey, conflict;
+                                var e_7, _c;
+                                return tslib_1.__generator(this, function (_d) {
+                                    switch (_d.label) {
+                                        case 0: return [4 /*yield*/, idbReq(store.get(key))];
+                                        case 1:
+                                            existing = _d.sent();
+                                            if (existing == null)
+                                                throw new Error("Couldn't find row with id \"".concat(id, "\" in entity \"").concat(this.entity.key, "\" to update"));
+                                            json = tslib_1.__assign({}, existing);
+                                            keys = Object.keys(data);
+                                            try {
+                                                for (_a = tslib_1.__values(this.entity.fields), _b = _a.next(); !_b.done; _b = _a.next()) {
+                                                    f = _b.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_7_1) { e_7 = { error: e_7_1 }; }
+                                            finally {
+                                                try {
+                                                    if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
+                                                }
+                                                finally { if (e_7) throw e_7.error; }
+                                            }
+                                            helper.verifyThatRowHasAllNotNullColumns(json, names);
+                                            newKey = keyFromRow(this.entity, names, json);
+                                            if (!!idbKeysEqual(key, newKey)) return [3 /*break*/, 4];
+                                            return [4 /*yield*/, idbReq(store.get(newKey))];
+                                        case 2:
+                                            conflict = _d.sent();
+                                            if (conflict != null)
+                                                throw Error('id already exists');
+                                            return [4 /*yield*/, idbReq(store.delete(key))];
+                                        case 3:
+                                            _d.sent();
+                                            _d.label = 4;
+                                        case 4: return [4 /*yield*/, idbReq(store.put(json))];
+                                        case 5:
+                                            _d.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_8_1;
+                                var e_8, _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_8_1 = _b.sent();
+                                            e_8 = { error: e_8_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_8) throw e_8.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_9, _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_9_1) { e_9 = { error: e_9_1 }; }
+                    finally {
+                        try {
+                            if (ordered_1_1 && !ordered_1_1.done && (_a = ordered_1.return)) _a.call(ordered_1);
+                        }
+                        finally { if (e_9) throw e_9.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_10, _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_10_1) { e_10 = { error: e_10_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_10) throw e_10.error; }
+    }
+}
+function cartesian(lists) {
+    var e_11, _a;
+    var acc = [[]];
+    var _loop_2 = 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_2(list);
+        }
+    }
+    catch (e_11_1) { e_11 = { error: e_11_1 }; }
+    finally {
+        try {
+            if (lists_1_1 && !lists_1_1.done && (_a = lists_1.return)) _a.call(lists_1);
+        }
+        finally { if (e_11) throw e_11.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_12, _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_12_1) { e_12 = { error: e_12_1 }; }
+    finally {
+        try {
+            if (ops_2_1 && !ops_2_1.done && (_a = ops_2.return)) _a.call(ops_2);
+        }
+        finally { if (e_12) throw e_12.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_13, _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_13_1) { e_13 = { error: e_13_1 }; }
+                    finally {
+                        try {
+                            if (defs_1_1 && !defs_1_1.done && (_a = defs_1.return)) _a.call(defs_1);
+                        }
+                        finally { if (e_13) throw e_13.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); };
+    });
+}