@epam/uui-db 4.9.0-alpha.0 → 4.9.0-rc.1

package/index.js

@@ -383,7 +383,7 @@ function __classPrivateFieldIn(state, receiver) {
 "use strict";
 
 Object.defineProperty(exports, "__esModule", { value: true });
-var tslib_1 = __webpack_require__(/*! tslib */ "../node_modules/tslib/tslib.es6.js");
+const tslib_1 = __webpack_require__(/*! tslib */ "../node_modules/tslib/tslib.es6.js");
 (0, tslib_1.__exportStar)(__webpack_require__(/*! ./src */ "./src/index.ts"), exports);
 
 
@@ -400,11 +400,11 @@ var tslib_1 = __webpack_require__(/*! tslib */ "../node_modules/tslib/tslib.es6.
 
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Db = void 0;
-var tslib_1 = __webpack_require__(/*! tslib */ "../node_modules/tslib/tslib.es6.js");
-var utils_1 = __webpack_require__(/*! ./utils */ "./src/utils.ts");
-var lodash_isequal_1 = (0, tslib_1.__importDefault)(__webpack_require__(/*! lodash.isequal */ "lodash.isequal"));
-var Db = /** @class */ (function () {
-    function Db(tables, reusedCache) {
+const tslib_1 = __webpack_require__(/*! tslib */ "../node_modules/tslib/tslib.es6.js");
+const utils_1 = __webpack_require__(/*! ./utils */ "./src/utils.ts");
+const lodash_isequal_1 = (0, tslib_1.__importDefault)(__webpack_require__(/*! lodash.isequal */ "lodash.isequal"));
+class Db {
+    constructor(tables, reusedCache) {
         this.tables = tables;
         this.viewCache = new Map();
         /* Views (cached db projections) */
@@ -416,29 +416,29 @@ var Db = /** @class */ (function () {
             this.viewCache = new Map();
         }
     }
-    Db.prototype.update = function (mutate) {
-        var clone = new this.constructor(this.tables, this.viewCache);
-        clone.tables = (0, tslib_1.__assign)({}, this.tables);
+    update(mutate) {
+        const clone = new this.constructor(this.tables, this.viewCache);
+        clone.tables = Object.assign({}, this.tables);
         mutate(clone);
         return clone;
-    };
-    Db.prototype.with = function (patch) {
-        return this.update(function (db) {
-            (0, utils_1.objectKeys)(db.tables).forEach(function (entityName) {
+    }
+    with(patch) {
+        return this.update(db => {
+            (0, utils_1.objectKeys)(db.tables).forEach(entityName => {
                 if (patch[entityName]) {
                     db.tables[entityName] = db.tables[entityName].with(patch[entityName]);
                 }
             });
         });
-    };
-    Db.prototype.runView = function (view, params) {
-        var cache = this.viewCache.get(view);
+    }
+    runView(view, params) {
+        let cache = this.viewCache.get(view);
         if (!cache) {
             cache = new Map();
             this.viewCache.set(view, cache);
         }
-        var key = view.getKey ? view.getKey(params) : JSON.stringify(params);
-        var cacheItem = cache.get(key);
+        const key = view.getKey ? view.getKey(params) : JSON.stringify(params);
+        let cacheItem = cache.get(key);
         if (!cacheItem) {
             cacheItem = {
                 dependencies: this.valueAbsent,
@@ -447,19 +447,19 @@ var Db = /** @class */ (function () {
             };
             cache.set(key, cacheItem);
         }
-        var shouldUpdate = this !== cacheItem.computedOnDb;
-        var dependencies = this.valueAbsent;
+        let shouldUpdate = this !== cacheItem.computedOnDb;
+        let dependencies = this.valueAbsent;
         if (view.getDependencies) {
-            var compare = view.compareDependencies || utils_1.defaultCompareViewDependencies;
+            const compare = view.compareDependencies || utils_1.defaultCompareViewDependencies;
             dependencies = view.getDependencies(this, params);
             shouldUpdate = !compare(cacheItem.dependencies, dependencies);
         }
-        var previousValue = cacheItem.currentValue;
+        let previousValue = cacheItem.currentValue;
         if (shouldUpdate) {
             cacheItem.dependencies = dependencies;
-            var newValue = view.compute(this, params, dependencies);
+            let newValue = view.compute(this, params, dependencies);
             cacheItem.computedOnDb = this;
-            var compareResults = view.compareResults || lodash_isequal_1.default;
+            let compareResults = view.compareResults || lodash_isequal_1.default;
             if (!compareResults(previousValue, newValue)) {
                 if (view.traceDiff) {
                     console.debug((0, utils_1.difference)(previousValue, newValue));
@@ -468,9 +468,8 @@ var Db = /** @class */ (function () {
             }
         }
         return cacheItem.currentValue;
-    };
-    return Db;
-}());
+    }
+}
 exports.Db = Db;
 
 
@@ -487,18 +486,17 @@ exports.Db = Db;
 
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DbRef = void 0;
-var tslib_1 = __webpack_require__(/*! tslib */ "../node_modules/tslib/tslib.es6.js");
-var patchHelpers_1 = __webpack_require__(/*! ./patchHelpers */ "./src/patchHelpers.ts");
-var tempIds_1 = __webpack_require__(/*! ./tempIds */ "./src/tempIds.tsx");
-var utils_1 = __webpack_require__(/*! ./utils */ "./src/utils.ts");
-var lodash_isempty_1 = (0, tslib_1.__importDefault)(__webpack_require__(/*! lodash.isempty */ "lodash.isempty"));
-var Loader_1 = __webpack_require__(/*! ./Loader */ "./src/Loader.ts");
-var uui_core_1 = __webpack_require__(/*! @epam/uui-core */ "@epam/uui-core");
-var SimpleLoadingTracker_1 = __webpack_require__(/*! ./SimpleLoadingTracker */ "./src/SimpleLoadingTracker.ts");
-var ListLoadingTracker_1 = __webpack_require__(/*! ./ListLoadingTracker */ "./src/ListLoadingTracker.ts");
-var DbRef = /** @class */ (function () {
-    function DbRef(blank) {
-        var _this = this;
+const tslib_1 = __webpack_require__(/*! tslib */ "../node_modules/tslib/tslib.es6.js");
+const patchHelpers_1 = __webpack_require__(/*! ./patchHelpers */ "./src/patchHelpers.ts");
+const tempIds_1 = __webpack_require__(/*! ./tempIds */ "./src/tempIds.tsx");
+const utils_1 = __webpack_require__(/*! ./utils */ "./src/utils.ts");
+const lodash_isempty_1 = (0, tslib_1.__importDefault)(__webpack_require__(/*! lodash.isempty */ "lodash.isempty"));
+const Loader_1 = __webpack_require__(/*! ./Loader */ "./src/Loader.ts");
+const uui_core_1 = __webpack_require__(/*! @epam/uui-core */ "@epam/uui-core");
+const SimpleLoadingTracker_1 = __webpack_require__(/*! ./SimpleLoadingTracker */ "./src/SimpleLoadingTracker.ts");
+const ListLoadingTracker_1 = __webpack_require__(/*! ./ListLoadingTracker */ "./src/ListLoadingTracker.ts");
+class DbRef {
+    constructor(blank) {
         this.blank = blank;
         this.log = [];
         this.autoSave = true;
@@ -511,36 +509,25 @@ var DbRef = /** @class */ (function () {
         /* Error Subscriptions */
         this.saveErrorHandlers = [];
         /* Save scheduling */
-        this.enqueueSave = (0, uui_core_1.batch)(function () { return (0, tslib_1.__awaiter)(_this, void 0, void 0, function () {
-            var cumulativePatch, lastLogEntry, response, error_1;
-            return (0, tslib_1.__generator)(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        cumulativePatch = this.makeCumulativePatch();
-                        lastLogEntry = this.log.length;
-                        if ((0, lodash_isempty_1.default)(cumulativePatch)) {
-                            return [2 /*return*/];
-                        }
-                        _a.label = 1;
-                    case 1:
-                        _a.trys.push([1, 3, , 4]);
-                        return [4 /*yield*/, this.savePatch(cumulativePatch)];
-                    case 2:
-                        response = _a.sent();
-                        this.applyResponse(response, lastLogEntry);
-                        this.update();
-                        return [3 /*break*/, 4];
-                    case 3:
-                        error_1 = _a.sent();
-                        this.saveError(cumulativePatch, error_1);
-                        this.update();
-                        throw error_1;
-                    case 4: return [2 /*return*/];
-                }
-            });
-        }); });
-        this.handleBeforeUnload = function (e) {
-            if (_this.enqueueSave.isBusy) {
+        this.enqueueSave = (0, uui_core_1.batch)(() => (0, tslib_1.__awaiter)(this, void 0, void 0, function* () {
+            const cumulativePatch = this.makeCumulativePatch();
+            const lastLogEntry = this.log.length;
+            if ((0, lodash_isempty_1.default)(cumulativePatch)) {
+                return;
+            }
+            try {
+                const response = yield this.savePatch(cumulativePatch);
+                this.applyResponse(response, lastLogEntry);
+                this.update();
+            }
+            catch (error) {
+                this.saveError(cumulativePatch, error);
+                this.update();
+                throw error;
+            }
+        }));
+        this.handleBeforeUnload = (e) => {
+            if (this.enqueueSave.isBusy) {
                 e.returnValue = false;
                 return false;
             }
@@ -553,143 +540,139 @@ var DbRef = /** @class */ (function () {
         window.addEventListener('beforeunload', this.handleBeforeUnload);
     }
     /** Saves all committed patches. Useful only if autoSave is off. */
-    DbRef.prototype.save = function () {
+    save() {
         return this.enqueueSave();
-    };
-    DbRef.prototype.getAutoSave = function () {
+    }
+    getAutoSave() {
         return this.autoSave;
-    };
-    DbRef.prototype.setAutoSave = function (val) {
+    }
+    setAutoSave(val) {
         if (this.autoSave != val) {
             this.autoSave = val;
             this.autoSave && this.enqueueSave();
             this.update();
         }
-    };
-    DbRef.prototype.revert = function () {
+    }
+    revert() {
         this.db = this.base;
         this.log = this.log.slice(0, this.savedPoint);
         this.update();
-    };
+    }
     /** Concrete DbRef instances should override and implement their save logic in this method */
-    DbRef.prototype.savePatch = function (patch) {
+    savePatch(patch) {
         return Promise.resolve({ submit: {} });
-    };
+    }
     /* Db Update logic */
-    DbRef.prototype.commit = function (patch) {
-        var dbBeforeUpdate = this.db.with(patch);
+    commit(patch) {
+        const dbBeforeUpdate = this.db.with(patch);
         patch = this.beforeUpdate(patch, dbBeforeUpdate.tables, this.db.tables);
         patch = (0, patchHelpers_1.mergeEntityPatches)(this.db.tables, patch);
-        this.log.push({ patch: patch });
+        this.log.push({ patch });
         this.db = this.db.with(patch);
         this.autoSave && this.enqueueSave(null, { throttleMs: this.throttleSaveMs });
         this.update();
-    };
-    DbRef.prototype.beforeUpdate = function (patch, tables, prevTables) {
-        var _this = this;
-        var patchAndDependencies = {};
-        (0, utils_1.objectKeys)(tables).filter(function (entityName) { return patch[entityName] && !tables[entityName].schema.beforeUpdate; }).forEach(function (entityName) {
+    }
+    beforeUpdate(patch, tables, prevTables) {
+        let patchAndDependencies = {};
+        (0, utils_1.objectKeys)(tables).filter(entityName => patch[entityName] && !tables[entityName].schema.beforeUpdate).forEach(entityName => {
             patchAndDependencies[entityName] = patch[entityName];
         });
-        (0, utils_1.objectKeys)(tables).filter(function (entityName) { return patch[entityName] && tables[entityName].schema.beforeUpdate; }).forEach(function (entityName) {
-            var _a;
-            var schema = tables[entityName].schema;
-            var beforeUpdate = schema.beforeUpdate;
-            var context = {
-                clientIdsMap: _this.tempIdMap,
-                schema: schema,
-                tables: tables,
-                prevTables: prevTables,
+        (0, utils_1.objectKeys)(tables).filter(entityName => patch[entityName] && tables[entityName].schema.beforeUpdate).forEach(entityName => {
+            const schema = tables[entityName].schema;
+            const { beforeUpdate } = schema;
+            let context = {
+                clientIdsMap: this.tempIdMap,
+                schema,
+                tables,
+                prevTables,
             };
-            var results = patch[entityName].map(function (e) { return beforeUpdate(e, context); });
-            var updatedPatch = (_a = {}, _a[entityName] = results.map(function (result) { return result.entity; }), _a);
-            var dependentEntityPatchesForUpdate = (0, patchHelpers_1.unionPatches)(results.filter(function (result) { return result.dependentEntities; }).map(function (result) { return result.dependentEntities; }));
-            var dependentEntityPatches = _this.beforeUpdate(dependentEntityPatchesForUpdate, tables, prevTables);
+            const results = patch[entityName].map(e => beforeUpdate(e, context));
+            const updatedPatch = { [entityName]: results.map(result => result.entity) };
+            const dependentEntityPatchesForUpdate = (0, patchHelpers_1.unionPatches)(results.filter(result => result.dependentEntities).map(result => result.dependentEntities));
+            const dependentEntityPatches = this.beforeUpdate(dependentEntityPatchesForUpdate, tables, prevTables);
             patchAndDependencies = (0, patchHelpers_1.mergeEntityPatches)(tables, (0, patchHelpers_1.unionPatches)([patchAndDependencies, updatedPatch, dependentEntityPatches]));
         });
         return patchAndDependencies;
-    };
-    DbRef.prototype.commitFetch = function (patch) {
+    }
+    commitFetch(patch) {
         patch = this.tempIdMap.serverToClientPatch(patch);
         this.rebase(this.base.with(patch));
         this.update();
-    };
-    DbRef.prototype.rebase = function (newBase) {
+    }
+    rebase(newBase) {
         this.base = newBase;
         this.db = newBase;
-        for (var n = this.savedPoint; n < this.log.length; n++) {
+        for (let n = this.savedPoint; n < this.log.length; n++) {
             this.db = this.db.with(this.log[n].patch);
         }
-    };
-    DbRef.prototype.makeCumulativePatch = function () {
-        var lastLogEntry = this.log.length;
-        var logEntriesToSave = this.log.slice(this.savedPoint, lastLogEntry);
-        var cumulativePatch = (0, patchHelpers_1.makeCumulativePatch)(this.db, logEntriesToSave.map(function (t) { return t.patch; }), this.tempIdMap);
+    }
+    makeCumulativePatch() {
+        const lastLogEntry = this.log.length;
+        const logEntriesToSave = this.log.slice(this.savedPoint, lastLogEntry);
+        let cumulativePatch = (0, patchHelpers_1.makeCumulativePatch)(this.db, logEntriesToSave.map(t => t.patch), this.tempIdMap);
         cumulativePatch = this.tempIdMap.clientToServerPatch(cumulativePatch);
         return cumulativePatch;
-    };
-    DbRef.prototype.applyResponse = function (response, newSavedPoint) {
+    }
+    applyResponse(response, newSavedPoint) {
         this.tempIdMap.appendServerMapping(response);
-        var serverPatch = (0, patchHelpers_1.flattenResponse)(response.submit, this.db.tables);
+        let serverPatch = (0, patchHelpers_1.flattenResponse)(response.submit, this.db.tables);
         serverPatch = (0, patchHelpers_1.mergeEntityPatches)(this.db.tables, serverPatch);
         this.savedPoint = newSavedPoint;
         this.base = this.db;
         this.commitFetch(serverPatch);
-    };
-    DbRef.prototype.subscribe = function (view, params, onUpdate) {
-        var _this = this;
-        var id = this.lastSubscriptionId++;
-        var subscription = {
-            update: function (params) {
+    }
+    subscribe(view, params, onUpdate) {
+        const id = this.lastSubscriptionId++;
+        const subscription = {
+            update: (params) => {
                 subscription.currentParams = params;
-                subscription.currentValue = _this.db.runView(view, params);
+                subscription.currentValue = this.db.runView(view, params);
                 return subscription.currentValue;
             },
             currentParams: null,
             currentValue: null,
-            onUpdate: onUpdate,
-            unsubscribe: function () { _this.subscriptions.delete(id); },
+            onUpdate,
+            unsubscribe: () => { this.subscriptions.delete(id); },
         };
         subscription.update(params);
         this.subscriptions.set(id, subscription);
         return subscription;
-    };
-    DbRef.prototype.onUpdate = function (handler) {
+    }
+    onUpdate(handler) {
         this.subscribe({
-            compute: function (db) { return db; },
-            compareResults: function (a, b) { return a === b; },
+            compute: db => db,
+            compareResults: (a, b) => a === b,
         }, null, handler);
-    };
-    DbRef.prototype.update = function () {
-        this.subscriptions.forEach(function (subscription) {
-            var previousValue = subscription.currentValue;
+    }
+    update() {
+        this.subscriptions.forEach(subscription => {
+            const previousValue = subscription.currentValue;
             subscription.update(subscription.currentParams);
             if (subscription.currentValue !== previousValue && subscription.onUpdate) {
                 subscription.onUpdate(subscription.currentValue);
             }
         });
-    };
-    DbRef.prototype.onSaveError = function (handler) {
+    }
+    onSaveError(handler) {
         this.saveErrorHandlers.push(handler);
-    };
-    DbRef.prototype.saveError = function (request, error) {
-        this.saveErrorHandlers.forEach(function (handler) { return handler(request, error); });
-    };
-    DbRef.prototype.makeLoader = function (options) {
-        var loader = new Loader_1.Loader(this, function () { return new SimpleLoadingTracker_1.SimpleLoadingTracker(); }, options);
+    }
+    saveError(request, error) {
+        this.saveErrorHandlers.forEach(handler => handler(request, error));
+    }
+    makeLoader(options) {
+        const loader = new Loader_1.Loader(this, () => new SimpleLoadingTracker_1.SimpleLoadingTracker(), options);
         this.loaders.push(loader);
         return loader;
-    };
-    DbRef.prototype.makeListLoader = function (options) {
-        var loader = new Loader_1.Loader(this, function () { return new ListLoadingTracker_1.ListLoadingTracker(); }, options);
+    }
+    makeListLoader(options) {
+        const loader = new Loader_1.Loader(this, () => new ListLoadingTracker_1.ListLoadingTracker(), options);
         this.loaders.push(loader);
         return loader;
-    };
-    DbRef.prototype.reload = function () {
+    }
+    reload() {
         this.loaders = [];
-    };
-    return DbRef;
-}());
+    }
+}
 exports.DbRef = DbRef;
 
 
@@ -706,151 +689,144 @@ exports.DbRef = DbRef;
 
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DbTable = void 0;
-var tslib_1 = __webpack_require__(/*! tslib */ "../node_modules/tslib/tslib.es6.js");
-var I = (0, tslib_1.__importStar)(__webpack_require__(/*! immutable */ "immutable"));
-var uui_core_1 = __webpack_require__(/*! @epam/uui-core */ "@epam/uui-core");
-var immutable_1 = __webpack_require__(/*! immutable */ "immutable");
-var DbTable = /** @class */ (function () {
-    function DbTable(schema, state, q) {
+const tslib_1 = __webpack_require__(/*! tslib */ "../node_modules/tslib/tslib.es6.js");
+const I = (0, tslib_1.__importStar)(__webpack_require__(/*! immutable */ "immutable"));
+const uui_core_1 = __webpack_require__(/*! @epam/uui-core */ "@epam/uui-core");
+const immutable_1 = __webpack_require__(/*! immutable */ "immutable");
+class DbTable {
+    constructor(schema, state, q) {
         this.schema = schema;
         this.state = state;
         this.q = q;
         if (!state) {
-            var indexes = (schema.indexes || []).map(function (indexDef) {
+            const indexes = (schema.indexes || []).map(indexDef => {
                 return {
                     field: indexDef,
                     map: I.Map(),
                 };
             });
-            this.state = { pk: I.Map(), indexes: indexes };
+            this.state = { pk: I.Map(), indexes };
         }
         if (!q) {
             this.q = {};
         }
     }
-    DbTable.prototype.keyToImmutable = function (id) {
+    keyToImmutable(id) {
         if (Array.isArray(id)) {
             return I.List(id);
         }
         else {
             return id;
         }
-    };
-    DbTable.prototype.byId = function (id) {
+    }
+    byId(id) {
         return this.state.pk.get(this.keyToImmutable(id));
-    };
-    DbTable.prototype.getId = function (entity) {
+    }
+    getId(entity) {
         if (Array.isArray(this.schema.primaryKey)) {
-            return this.schema.primaryKey.map(function (key) { return entity[key]; });
+            return this.schema.primaryKey.map((key) => entity[key]);
         }
         return entity[this.schema.primaryKey];
-    };
-    DbTable.prototype.update = function (mutate) {
-        var clone = new this.constructor(this.schema, this.state, this.q);
+    }
+    update(mutate) {
+        const clone = new this.constructor(this.schema, this.state, this.q);
         mutate(clone);
         return clone;
-    };
+    }
     /* Mutation */
-    DbTable.prototype.with = function (patch) {
-        var _this = this;
-        var updates = patch.map(function (entityPatch) {
-            var id = _this.getId(entityPatch);
-            var immId = _this.keyToImmutable(id);
-            var existing = _this.state.pk.get(immId);
-            var isDeleted = false;
-            var updated = entityPatch;
+    with(patch) {
+        const updates = patch.map(entityPatch => {
+            const id = this.getId(entityPatch);
+            const immId = this.keyToImmutable(id);
+            const existing = this.state.pk.get(immId);
+            let isDeleted = false;
+            let updated = entityPatch;
             if (existing) {
-                updated = (0, tslib_1.__assign)((0, tslib_1.__assign)({}, existing), entityPatch);
-                if (_this.schema.deleteFlag) {
-                    isDeleted = updated[_this.schema.deleteFlag] === true;
+                updated = Object.assign(Object.assign({}, existing), entityPatch);
+                if (this.schema.deleteFlag) {
+                    isDeleted = updated[this.schema.deleteFlag] === true;
                 }
             }
-            return { id: id, immId: immId, patch: entityPatch, existing: existing, updated: updated, isNew: !existing, isDeleted: isDeleted };
+            return { id, immId, patch: entityPatch, existing, updated, isNew: !existing, isDeleted };
         });
-        var idVal = immutable_1.Seq.Keyed(updates.map(function (entity) { return [entity.immId, entity.updated]; }));
-        var newPk = this.state.pk.merge(idVal);
+        const idVal = immutable_1.Seq.Keyed(updates.map(entity => [entity.immId, entity.updated]));
+        let newPk = this.state.pk.merge(idVal);
         // TBD: replace with deleteAll after migrating to immutable 4
-        updates.filter(function (u) { return u.isDeleted; }).forEach(function (u) {
+        updates.filter(u => u.isDeleted).forEach(u => {
             newPk = newPk.delete(u.immId);
         });
-        var newIndexes = this.state.indexes.map(function (index) {
-            var newMap = index.map;
-            var _loop_1 = function (n) {
-                var update = updates[n];
-                var newKey = update.updated[index.field];
+        const newIndexes = this.state.indexes.map(index => {
+            let newMap = index.map;
+            for (let n = 0; n < updates.length; n++) {
+                let update = updates[n];
+                const newKey = update.updated[index.field];
                 if (update.existing) {
-                    var oldKey = update.existing[index.field];
+                    const oldKey = update.existing[index.field];
                     if (oldKey !== newKey || update.isDeleted) {
-                        newMap = newMap.update(oldKey, function (set) { return set.remove(update.immId); });
+                        newMap = newMap.update(oldKey, set => set.remove(update.immId));
                     }
                 }
                 if (!update.isDeleted) {
-                    newMap = newMap.update(newKey, I.Set(), function (set) { return set.add(update.immId); });
+                    newMap = newMap.update(newKey, I.Set(), set => set.add(update.immId));
                 }
-            };
-            for (var n = 0; n < updates.length; n++) {
-                _loop_1(n);
             }
-            return (0, tslib_1.__assign)((0, tslib_1.__assign)({}, index), { map: newMap });
+            return Object.assign(Object.assign({}, index), { map: newMap });
         });
-        var newState = { pk: newPk, indexes: newIndexes };
-        return this.update(function (t) { return t.state = newState; });
-    };
+        const newState = { pk: newPk, indexes: newIndexes };
+        return this.update(t => t.state = newState);
+    }
     /* Query */
-    DbTable.prototype.find = function (filter) {
-        var _this = this;
-        return this.update(function (t) { return t.q = (0, tslib_1.__assign)((0, tslib_1.__assign)({}, t.q), { filter: (0, tslib_1.__assign)((0, tslib_1.__assign)({}, _this.q.filter), filter) }); });
-    };
-    DbTable.prototype.order = function (order) {
-        return this.update(function (t) { return t.q = (0, tslib_1.__assign)((0, tslib_1.__assign)({}, t.q), { sorting: order }); });
-    };
-    DbTable.prototype.orderBy = function (field, direction) {
-        if (direction === void 0) { direction = 'asc'; }
-        return this.update(function (t) { return t.q = (0, tslib_1.__assign)((0, tslib_1.__assign)({}, t.q), { sorting: [{ field: field, direction: direction }] }); });
-    };
-    DbTable.prototype.thenBy = function (field, direction) {
-        return this.update(function (t) { return t.q = (0, tslib_1.__assign)((0, tslib_1.__assign)({}, t.q), { sorting: (0, tslib_1.__spreadArray)((0, tslib_1.__spreadArray)([], t.q.sorting, true), [{ field: field, direction: direction }], false) }); });
-    };
-    DbTable.prototype.search = function (text) {
+    find(filter) {
+        return this.update(t => t.q = Object.assign(Object.assign({}, t.q), { filter: Object.assign(Object.assign({}, this.q.filter), filter) }));
+    }
+    order(order) {
+        return this.update(t => t.q = Object.assign(Object.assign({}, t.q), { sorting: order }));
+    }
+    orderBy(field, direction = 'asc') {
+        return this.update(t => t.q = Object.assign(Object.assign({}, t.q), { sorting: [{ field, direction }] }));
+    }
+    thenBy(field, direction) {
+        return this.update(t => t.q = Object.assign(Object.assign({}, t.q), { sorting: [...t.q.sorting, { field, direction }] }));
+    }
+    search(text) {
         if (!this.schema.searchBy) {
-            throw new Error("Can't search in the ".concat(this.schema.typeName, " table - searchBy is not defined in the schema."));
+            throw new Error(`Can't search in the ${this.schema.typeName} table - searchBy is not defined in the schema.`);
         }
-        return this.update(function (t) { return t.q = (0, tslib_1.__assign)((0, tslib_1.__assign)({}, t.q), { search: text }); });
-    };
+        return this.update(t => t.q = Object.assign(Object.assign({}, t.q), { search: text }));
+    }
     /* Materializing */
-    DbTable.prototype.range = function (from, count) {
-        return this.runQuery((0, tslib_1.__assign)((0, tslib_1.__assign)({}, this.q), { range: { from: from, count: count } }));
-    };
-    DbTable.prototype.count = function () {
+    range(from, count) {
+        return this.runQuery(Object.assign(Object.assign({}, this.q), { range: { from, count } }));
+    }
+    count() {
         return this.runQuery(this.q).length;
-    };
-    DbTable.prototype.one = function () {
+    }
+    one() {
         return this.runQuery(this.q)[0] || null;
-    };
-    DbTable.prototype.toArray = function () {
+    }
+    toArray() {
         return this.runQuery(this.q);
-    };
-    DbTable.prototype.map = function (fn) {
+    }
+    map(fn) {
         return this.toArray().map(fn);
-    };
+    }
     /* Query implementation */
-    DbTable.prototype.runQuery = function (q) {
-        var _this = this;
-        var result = null;
-        var filter = q.filter;
+    runQuery(q) {
+        let result = null;
+        let filter = q.filter;
         if (filter) {
-            var indexes = this.state.indexes;
+            let indexes = this.state.indexes;
             // Try to use indexes to fulfill filter conditions
-            for (var n = 0; n < indexes.length; n++) {
-                var index = indexes[n];
+            for (let n = 0; n < indexes.length; n++) {
+                const index = indexes[n];
                 if (index.field in filter) {
-                    var _a = filter, _b = index.field, condition = _a[_b], rest = (0, tslib_1.__rest)(_a, [typeof _b === "symbol" ? _b : _b + ""]);
-                    var conditionValues = null;
+                    const _a = filter, _b = index.field, condition = _a[_b], rest = (0, tslib_1.__rest)(_a, [typeof _b === "symbol" ? _b : _b + ""]);
+                    let conditionValues = null;
                     if (condition != null && typeof condition === "object") {
                         // Attempt to use index for 'in' and 'isNull' criteria.
                         // We need to be very conservative here, indexed field should work the same way as getPatternPredicate. So
                         // - it's better to leave corner cases to getPatternPredicate
-                        var _c = condition, inCriteria = _c.in, nullCriteria = _c.isNull, restCriteria = (0, tslib_1.__rest)(_c, ["in", "isNull"]);
+                        const _c = condition, { in: inCriteria, isNull: nullCriteria } = _c, restCriteria = (0, tslib_1.__rest)(_c, ["in", "isNull"]);
                         if (inCriteria && Array.isArray(inCriteria)) {
                             conditionValues = inCriteria;
                         }
@@ -877,12 +853,12 @@ var DbTable = /** @class */ (function () {
                     }
                     if (conditionValues) {
                         result = [];
-                        for (var i = 0; i < conditionValues.length; i++) {
-                            var idsSet = index.map.get(conditionValues[i]);
+                        for (let i = 0; i < conditionValues.length; i++) {
+                            const idsSet = index.map.get(conditionValues[i]);
                             if (idsSet) {
-                                var idsArray = idsSet.toArray();
-                                for (var j = 0; j < idsArray.length; j++) {
-                                    var item = this.state.pk.get(idsArray[j]);
+                                const idsArray = idsSet.toArray();
+                                for (let j = 0; j < idsArray.length; j++) {
+                                    const item = this.state.pk.get(idsArray[j]);
                                     result.push(item);
                                 }
                             }
@@ -897,24 +873,23 @@ var DbTable = /** @class */ (function () {
             result = this.state.pk.toArray();
         }
         if (filter) {
-            var predicate = (0, uui_core_1.getPatternPredicate)(q.filter);
+            let predicate = (0, uui_core_1.getFilterPredicate)(q.filter);
             result = result.filter(predicate);
         }
         if (q.search) {
-            var searchFilter_1 = (0, uui_core_1.getSearchFilter)(q.search);
-            result = result.filter(function (item) { return searchFilter_1(_this.schema.searchBy.map(function (field) { return item[field]; })); });
+            let searchFilter = (0, uui_core_1.getSearchFilter)(q.search);
+            result = result.filter(item => searchFilter(this.schema.searchBy.map(field => item[field])));
         }
         if (q.sorting) {
-            var comparer = (0, uui_core_1.getOrderComparer)(q.sorting);
+            let comparer = (0, uui_core_1.getOrderComparer)(q.sorting);
             result = result.sort(comparer);
         }
         if (q.range) {
             result = result.slice(q.range.from, q.range.from + q.range.count);
         }
         return result;
-    };
-    return DbTable;
-}());
+    }
+}
 exports.DbTable = DbTable;
 
 
@@ -931,16 +906,16 @@ exports.DbTable = DbTable;
 
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ListLoadingTracker = void 0;
-var tslib_1 = __webpack_require__(/*! tslib */ "../node_modules/tslib/tslib.es6.js");
-var ListLoadingTracker = /** @class */ (function () {
-    function ListLoadingTracker(options) {
+const tslib_1 = __webpack_require__(/*! tslib */ "../node_modules/tslib/tslib.es6.js");
+class ListLoadingTracker {
+    constructor(options) {
         this.options = options;
         this.cache = new Map();
-        this.extractList = (options === null || options === void 0 ? void 0 : options.extractList) || (function (r) { return r; });
+        this.extractList = (options === null || options === void 0 ? void 0 : options.extractList) || ((r) => r);
     }
-    ListLoadingTracker.prototype.prepare = function (request) {
-        var filter = request.filter, sorting = request.sorting, search = request.search, range = request.range, unknownFields = (0, tslib_1.__rest)(request, ["filter", "sorting", "search", "range"]);
-        var options = {};
+    prepare(request) {
+        const { filter, sorting, search, range } = request, unknownFields = (0, tslib_1.__rest)(request, ["filter", "sorting", "search", "range"]);
+        const options = {};
         if (filter) {
             options.filter = filter;
         }
@@ -950,17 +925,17 @@ var ListLoadingTracker = /** @class */ (function () {
         if (search) {
             options.search = search;
         }
-        var keyObject = (0, tslib_1.__assign)((0, tslib_1.__assign)({}, options), unknownFields);
-        var key = JSON.stringify(keyObject);
-        var entry = this.cache.get(key);
+        let keyObject = Object.assign(Object.assign({}, options), unknownFields);
+        const key = JSON.stringify(keyObject);
+        let entry = this.cache.get(key);
         if (!entry) {
-            entry = { options: options, count: 0, maxCount: null, isComplete: false };
+            entry = { options, count: 0, maxCount: null, isComplete: false };
             this.cache.set(key, entry);
         }
-        return { options: options, range: range, unknownFields: unknownFields, entry: entry };
-    };
-    ListLoadingTracker.prototype.diff = function (request) {
-        var _a = this.prepare(request), options = _a.options, range = _a.range, unknownFields = _a.unknownFields, entry = _a.entry;
+        return { options, range, unknownFields, entry };
+    }
+    diff(request) {
+        const { options, range, unknownFields, entry } = this.prepare(request);
         if (entry.isComplete) {
             return null;
         }
@@ -968,27 +943,27 @@ var ListLoadingTracker = /** @class */ (function () {
             return request;
         }
         else {
-            var requestedMax = request.range.from + request.range.count;
-            var missingCount = requestedMax - entry.count;
+            const requestedMax = request.range.from + request.range.count;
+            let missingCount = requestedMax - entry.count;
             if (entry.maxCount) {
                 missingCount = Math.min(missingCount, entry.maxCount);
             }
             if (missingCount > 0) {
-                return (0, tslib_1.__assign)((0, tslib_1.__assign)((0, tslib_1.__assign)({}, options), unknownFields), { range: { from: entry.count, count: requestedMax - entry.count } });
+                return Object.assign(Object.assign(Object.assign({}, options), unknownFields), { range: { from: entry.count, count: requestedMax - entry.count } });
             }
             else {
                 return null;
             }
         }
-    };
-    ListLoadingTracker.prototype.count = function (request) {
-        var entry = this.prepare(request).entry;
+    }
+    count(request) {
+        const { entry } = this.prepare(request);
         return { knownCount: Math.max(entry.count, entry.maxCount), exactCount: entry.maxCount };
-    };
-    ListLoadingTracker.prototype.append = function (request, response) {
-        var _a = this.prepare(request), options = _a.options, range = _a.range, unknownFields = _a.unknownFields, entry = _a.entry;
+    }
+    append(request, response) {
+        const { options, range, unknownFields, entry } = this.prepare(request);
         if (response) {
-            var list = this.extractList(response);
+            const list = this.extractList(response);
             if (list.count) {
                 entry.maxCount = list.count;
             }
@@ -998,7 +973,7 @@ var ListLoadingTracker = /** @class */ (function () {
                 entry.isComplete = true;
             }
             else {
-                var from = (list.from == null) ? range.from : list.from;
+                const from = (list.from == null) ? range.from : list.from;
                 if (list.items.length > 0) {
                     entry.count = Math.max(entry.count, from + list.items.length);
                 }
@@ -1017,9 +992,8 @@ var ListLoadingTracker = /** @class */ (function () {
                 entry.isComplete = true;
             }
         }
-    };
-    return ListLoadingTracker;
-}());
+    }
+}
 exports.ListLoadingTracker = ListLoadingTracker;
 
 
@@ -1036,25 +1010,24 @@ exports.ListLoadingTracker = ListLoadingTracker;
 
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Loader = void 0;
-var Loader = /** @class */ (function () {
-    function Loader(dbRef, getTracker, options) {
-        var _this = this;
+class Loader {
+    constructor(dbRef, getTracker, options) {
         this.dbRef = dbRef;
         this.getTracker = getTracker;
         this.options = options;
         this.currentRequests = new Set();
-        this.load = function (inputRequest) {
-            var result = {
-                isComplete: _this.loaded.diff(inputRequest) == null,
+        this.load = (inputRequest) => {
+            const result = {
+                isComplete: this.loaded.diff(inputRequest) == null,
                 isLoading: false,
                 request: inputRequest,
-                missing: _this.loadedAndLoading.diff(inputRequest),
+                missing: this.loadedAndLoading.diff(inputRequest),
                 promise: null,
                 reload: null,
             };
-            result.reload = function () {
+            result.reload = () => {
                 result.missing = inputRequest;
-                _this.loadImpl(result);
+                this.loadImpl(result);
             };
             if (result.isComplete) {
                 // Everything requested is already loaded
@@ -1070,12 +1043,12 @@ var Loader = /** @class */ (function () {
                     result.isLoading = true;
                     // There's no good way to tell which of current requests is querying requested data - there actually can be 2 of them.
                     // So we track all running requests, and await all of them in such case.
-                    result.promise = Promise.all(_this.currentRequests.entries()).then(function () { });
+                    result.promise = Promise.all(this.currentRequests.entries()).then(() => { });
                     return result;
                 }
                 else {
                     // Something requested is not loaded, nor being loaded. Need to perform a new request.
-                    _this.loadImpl(result);
+                    this.loadImpl(result);
                     return result;
                 }
             }
@@ -1083,33 +1056,31 @@ var Loader = /** @class */ (function () {
         this.loaded = getTracker();
         this.loadedAndLoading = getTracker();
     }
-    Loader.prototype.loadImpl = function (state) {
-        var _this = this;
+    loadImpl(state) {
         this.loadedAndLoading.append(state.missing);
         state.isLoading = true;
-        var serverRequest = state.missing;
+        let serverRequest = state.missing;
         if (this.options.clientToServerRequest) {
             serverRequest = this.options.clientToServerRequest(serverRequest);
         }
-        state.promise = this.options.api(serverRequest).then(function (result) {
-            _this.loaded.append(state.missing, result);
-            _this.loadedAndLoading.append(state.missing, result);
+        state.promise = this.options.api(serverRequest).then(result => {
+            this.loaded.append(state.missing, result);
+            this.loadedAndLoading.append(state.missing, result);
             state.missing = null;
             state.isLoading = false;
             state.isComplete = true;
             state.promise = Promise.resolve();
-            var flatten = _this.options.convertToPatch(result);
-            _this.options.postProcess && _this.options.postProcess(flatten);
-            _this.dbRef.commitFetch(flatten);
+            const flatten = this.options.convertToPatch(result);
+            this.options.postProcess && this.options.postProcess(flatten);
+            this.dbRef.commitFetch(flatten);
         });
         this.currentRequests.add(state.promise);
-        state.promise.finally(function () {
-            _this.currentRequests.delete(state.promise);
+        state.promise.finally(() => {
+            this.currentRequests.delete(state.promise);
         });
         return state.promise;
-    };
-    return Loader;
-}());
+    }
+}
 exports.Loader = Loader;
 
 
@@ -1126,21 +1097,20 @@ exports.Loader = Loader;
 
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SimpleLoadingTracker = void 0;
-var SimpleLoadingTracker = /** @class */ (function () {
-    function SimpleLoadingTracker() {
+class SimpleLoadingTracker {
+    constructor() {
         this.set = new Set();
     }
-    SimpleLoadingTracker.prototype.getKey = function (request) {
+    getKey(request) {
         return JSON.stringify(request);
-    };
-    SimpleLoadingTracker.prototype.diff = function (request) {
+    }
+    diff(request) {
         return this.set.has(this.getKey(request)) ? null : request;
-    };
-    SimpleLoadingTracker.prototype.append = function (request, result) {
+    }
+    append(request, result) {
         this.set.add(this.getKey(request));
-    };
-    return SimpleLoadingTracker;
-}());
+    }
+}
 exports.SimpleLoadingTracker = SimpleLoadingTracker;
 
 
@@ -1156,7 +1126,7 @@ exports.SimpleLoadingTracker = SimpleLoadingTracker;
 "use strict";
 
 Object.defineProperty(exports, "__esModule", { value: true });
-var tslib_1 = __webpack_require__(/*! tslib */ "../node_modules/tslib/tslib.es6.js");
+const tslib_1 = __webpack_require__(/*! tslib */ "../node_modules/tslib/tslib.es6.js");
 (0, tslib_1.__exportStar)(__webpack_require__(/*! ./types */ "./src/types.ts"), exports);
 (0, tslib_1.__exportStar)(__webpack_require__(/*! ./Db */ "./src/Db.ts"), exports);
 (0, tslib_1.__exportStar)(__webpack_require__(/*! ./DbTable */ "./src/DbTable.ts"), exports);
@@ -1180,42 +1150,38 @@ var tslib_1 = __webpack_require__(/*! tslib */ "../node_modules/tslib/tslib.es6.
 
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getEntityParentDependencies = exports.getParentEntities = exports.hasServerFields = exports.isNew = exports.getId = exports.isClientOnly = exports.makeCumulativePatch = exports.isPatchBlank = exports.flattenResponse = exports.mergeEntityPatches = exports.unionPatches = void 0;
-var tslib_1 = __webpack_require__(/*! tslib */ "../node_modules/tslib/tslib.es6.js");
-var types_1 = __webpack_require__(/*! ./types */ "./src/types.ts");
-var I = (0, tslib_1.__importStar)(__webpack_require__(/*! immutable */ "immutable"));
-var utils_1 = __webpack_require__(/*! ./utils */ "./src/utils.ts");
-var lodash_groupby_1 = (0, tslib_1.__importDefault)(__webpack_require__(/*! lodash.groupby */ "lodash.groupby"));
-var lodash_map_1 = (0, tslib_1.__importDefault)(__webpack_require__(/*! lodash.map */ "lodash.map"));
-var lodash_merge_1 = (0, tslib_1.__importDefault)(__webpack_require__(/*! lodash.merge */ "lodash.merge"));
-var lodash_countby_1 = (0, tslib_1.__importDefault)(__webpack_require__(/*! lodash.countby */ "lodash.countby"));
-var lodash_filter_1 = (0, tslib_1.__importDefault)(__webpack_require__(/*! lodash.filter */ "lodash.filter"));
-var lodash_foreach_1 = (0, tslib_1.__importDefault)(__webpack_require__(/*! lodash.foreach */ "lodash.foreach"));
-var lodash_pick_1 = (0, tslib_1.__importDefault)(__webpack_require__(/*! lodash.pick */ "lodash.pick"));
+const tslib_1 = __webpack_require__(/*! tslib */ "../node_modules/tslib/tslib.es6.js");
+const types_1 = __webpack_require__(/*! ./types */ "./src/types.ts");
+const I = (0, tslib_1.__importStar)(__webpack_require__(/*! immutable */ "immutable"));
+const utils_1 = __webpack_require__(/*! ./utils */ "./src/utils.ts");
+const lodash_groupby_1 = (0, tslib_1.__importDefault)(__webpack_require__(/*! lodash.groupby */ "lodash.groupby"));
+const lodash_map_1 = (0, tslib_1.__importDefault)(__webpack_require__(/*! lodash.map */ "lodash.map"));
+const lodash_merge_1 = (0, tslib_1.__importDefault)(__webpack_require__(/*! lodash.merge */ "lodash.merge"));
+const lodash_countby_1 = (0, tslib_1.__importDefault)(__webpack_require__(/*! lodash.countby */ "lodash.countby"));
+const lodash_filter_1 = (0, tslib_1.__importDefault)(__webpack_require__(/*! lodash.filter */ "lodash.filter"));
+const lodash_foreach_1 = (0, tslib_1.__importDefault)(__webpack_require__(/*! lodash.foreach */ "lodash.foreach"));
+const lodash_pick_1 = (0, tslib_1.__importDefault)(__webpack_require__(/*! lodash.pick */ "lodash.pick"));
 function unionPatches(patches) {
-    var result = {};
-    patches.forEach(function (patch) {
-        (0, utils_1.objectKeys)(patch).forEach(function (tableName) {
-            result[tableName] = result[tableName] ? (0, tslib_1.__spreadArray)((0, tslib_1.__spreadArray)([], result[tableName], true), patch[tableName], true) : patch[tableName];
+    const result = {};
+    patches.forEach(patch => {
+        (0, utils_1.objectKeys)(patch).forEach(tableName => {
+            result[tableName] = result[tableName] ? [...result[tableName], ...patch[tableName]] : patch[tableName];
         });
     });
     return result;
 }
 exports.unionPatches = unionPatches;
 function mergeEntityPatches(tables, patch) {
-    var result = {};
-    (0, utils_1.objectKeys)(patch).forEach(function (key) {
-        var table = tables[key];
-        var groupedEntities = (0, lodash_groupby_1.default)(patch[key], function (item) { return table.getId(item); });
-        var tablePatch = (0, lodash_map_1.default)(groupedEntities, function (entities) {
-            var result = lodash_merge_1.default.apply(void 0, (0, tslib_1.__spreadArray)([{}], entities, false));
+    const result = {};
+    (0, utils_1.objectKeys)(patch).forEach(key => {
+        const table = tables[key];
+        const groupedEntities = (0, lodash_groupby_1.default)(patch[key], item => table.getId(item));
+        const tablePatch = (0, lodash_map_1.default)(groupedEntities, entities => {
+            const result = (0, lodash_merge_1.default)({}, ...entities);
             if (true) {
-                var props = (0, utils_1.objectKeys)(result).filter(function (prop) {
-                    return Object.keys((0, lodash_countby_1.default)(entities.filter(function (entity) {
-                        return entity[prop] !== undefined;
-                    }), function (entity) { return entity[prop]; })).length > 1;
-                });
+                const props = (0, utils_1.objectKeys)(result).filter(prop => Object.keys((0, lodash_countby_1.default)(entities.filter(entity => entity[prop] !== undefined), entity => entity[prop])).length > 1);
                 if (props.length) {
-                    console.warn.apply(console, (0, tslib_1.__spreadArray)(['mergeEntityPatches: Different property values found for the same entity.\nProperty names:\n', props, '\nEntities:\n'], entities, false));
+                    console.warn('mergeEntityPatches: Different property values found for the same entity.\nProperty names:\n', props, '\nEntities:\n', ...entities);
                 }
             }
             return result;
@@ -1227,26 +1193,26 @@ function mergeEntityPatches(tables, patch) {
 exports.mergeEntityPatches = mergeEntityPatches;
 function flattenResponseHelper(result, object, tablesByTypeName) {
     if (Array.isArray(object)) {
-        object.forEach(function (item) { return flattenResponseHelper(result, item, tablesByTypeName); });
+        object.forEach(item => flattenResponseHelper(result, item, tablesByTypeName));
     }
     else if (typeof object === 'object') {
-        var clone = {};
-        var tableKey = void 0;
-        var fields = {};
+        const clone = {};
+        let tableKey;
+        let fields = {};
         if ('__typename' in object) {
-            var table = tablesByTypeName[object.__typename];
+            const table = tablesByTypeName[object.__typename];
             if (table) {
                 tableKey = table.schema.tableName;
                 fields = table.schema.fields;
             }
         }
-        for (var key in object) {
-            var value = object[key];
-            var field = fields[key];
+        for (let key in object) {
+            const value = object[key];
+            const field = fields[key];
             if ((field && !!field.disableFlatten)
                 || typeof value !== 'object'
                 || value === null
-                || (Array.isArray(value) && value.every(function (item) { return typeof item !== 'object'; }))) {
+                || (Array.isArray(value) && value.every(item => typeof item !== 'object'))) {
                 clone[key] = value;
             }
             else {
@@ -1259,35 +1225,35 @@ function flattenResponseHelper(result, object, tablesByTypeName) {
     }
 }
 function flattenResponse(response, tables) {
-    var result = {};
-    var tablesByTypeName = {};
-    Object.values(tables).forEach(function (table) { return tablesByTypeName[table.schema.typeName] = table; });
-    (0, utils_1.objectKeys)(tables).forEach(function (tableName) { return tablesByTypeName; });
-    (0, utils_1.objectKeys)(tables).forEach(function (key) { return result[key] = []; });
+    const result = {};
+    let tablesByTypeName = {};
+    Object.values(tables).forEach(table => tablesByTypeName[table.schema.typeName] = table);
+    (0, utils_1.objectKeys)(tables).forEach(tableName => tablesByTypeName);
+    (0, utils_1.objectKeys)(tables).forEach(key => result[key] = []);
     flattenResponseHelper(result, response, tablesByTypeName);
     return result;
 }
 exports.flattenResponse = flattenResponse;
 function isPatchBlank(patch) {
-    return !(0, utils_1.objectKeys)(patch).some(function (key) { return patch[key].length > 0; });
+    return !(0, utils_1.objectKeys)(patch).some(key => patch[key].length > 0);
 }
 exports.isPatchBlank = isPatchBlank;
 /**
  * Given several patches, creates a new single patch with all fields from all entities in all patches.
  */
 function makeCumulativePatch(updatedDb, patches, clientIdsMap) {
-    var result = {};
-    (0, utils_1.objectKeys)(updatedDb.tables).forEach(function (entityName) {
-        var table = updatedDb.tables[entityName];
-        var schema = table.schema;
-        var ids = I.Set();
-        patches.forEach(function (patch) {
-            var filteredPatch = (patch[entityName] || []).filter(function (entity) { return hasServerFields(entity, schema, clientIdsMap, updatedDb.tables); });
-            ids = ids.union(filteredPatch.map(function (e) { return table.getId(e); }));
+    const result = {};
+    (0, utils_1.objectKeys)(updatedDb.tables).forEach(entityName => {
+        const table = updatedDb.tables[entityName];
+        const schema = table.schema;
+        let ids = I.Set();
+        patches.forEach(patch => {
+            let filteredPatch = (patch[entityName] || []).filter(entity => hasServerFields(entity, schema, clientIdsMap, updatedDb.tables));
+            ids = ids.union(filteredPatch.map(e => table.getId(e)));
         });
-        var entities = ids
-            .map(function (id) { return table.byId(id); })
-            .filter(function (e) { return !isClientOnly(e, schema); })
+        const entities = ids
+            .map(id => table.byId(id))
+            .filter(e => !isClientOnly(e, schema))
             .toArray();
         if (entities.length > 0) {
             result[entityName] = entities;
@@ -1307,43 +1273,43 @@ function getId(entity, schema) {
     if (typeof schema.primaryKey == 'string') {
         return entity[schema.primaryKey];
     }
-    var result = [];
-    (0, lodash_foreach_1.default)((0, lodash_pick_1.default)(entity, schema.primaryKey), function (value) {
+    const result = [];
+    (0, lodash_foreach_1.default)((0, lodash_pick_1.default)(entity, schema.primaryKey), (value) => {
         result.push(value);
     });
     return result;
 }
 exports.getId = getId;
 function isNew(entity, schema, clientIdsMap) {
-    var id = getId(entity, schema);
+    const id = getId(entity, schema);
     return !clientIdsMap.clientToServer(id);
 }
 exports.isNew = isNew;
 function hasServerFields(entity, schema, clientIdsMap, tables) {
-    var fullEntity = (0, tslib_1.__assign)((0, tslib_1.__assign)({}, tables[schema.tableName].byId(entity.id) || {}), entity);
+    const fullEntity = Object.assign(Object.assign({}, tables[schema.tableName].byId(entity.id) || {}), entity);
     if (isClientOnly(fullEntity, schema)) {
         return false;
     }
-    return (0, utils_1.objectKeys)(entity).some(function (fieldName) {
-        var fieldSchema = schema.fields[fieldName];
+    return (0, utils_1.objectKeys)(entity).some(fieldName => {
+        const fieldSchema = schema.fields[fieldName];
         return !fieldSchema || !(fieldSchema.isClientOnly || fieldSchema.isReadOnly || (fieldSchema.isGenerated && !isNew(entity, schema, clientIdsMap)));
     });
 }
 exports.hasServerFields = hasServerFields;
 function getParentEntities(patch, tables) {
-    var dependenciesPatch = {};
-    (0, utils_1.objectKeys)(patch).forEach(function (key) {
-        var table = tables[key];
-        var tableSchema = table.schema;
-        var fields = (0, lodash_filter_1.default)((0, lodash_map_1.default)(tableSchema.fields, function (field, name) { return ((0, tslib_1.__assign)((0, tslib_1.__assign)({}, field), { name: name })); }), function (field) { return field.fk && field.fk.relationType == types_1.DbRelationType.Aggregation; });
-        var tablePatch = patch[key];
-        fields.forEach(function (field) {
-            var tableName = field.fk.tableName, name = field.name;
-            tablePatch.forEach(function (entity) {
-                var actualTableName = (typeof tableName == 'function' ? tableName(entity) : tableName);
-                var dbEntity = table.byId(table.getId(entity));
-                var parentEntity = tables[actualTableName].byId(dbEntity[name]);
-                var idFields = (0, lodash_pick_1.default)(parentEntity, tables[actualTableName].schema.primaryKey);
+    const dependenciesPatch = {};
+    (0, utils_1.objectKeys)(patch).forEach(key => {
+        const table = tables[key];
+        const tableSchema = table.schema;
+        const fields = (0, lodash_filter_1.default)((0, lodash_map_1.default)(tableSchema.fields, (field, name) => (Object.assign(Object.assign({}, field), { name }))), field => field.fk && field.fk.relationType == types_1.DbRelationType.Aggregation);
+        const tablePatch = patch[key];
+        fields.forEach(field => {
+            const { fk: { tableName }, name } = field;
+            tablePatch.forEach(entity => {
+                const actualTableName = (typeof tableName == 'function' ? tableName(entity) : tableName);
+                const dbEntity = table.byId(table.getId(entity));
+                const parentEntity = tables[actualTableName].byId(dbEntity[name]);
+                const idFields = (0, lodash_pick_1.default)(parentEntity, tables[actualTableName].schema.primaryKey);
                 if (parentEntity) {
                     dependenciesPatch[actualTableName] = dependenciesPatch[actualTableName] || [];
                     dependenciesPatch[actualTableName].push(idFields);
@@ -1355,18 +1321,17 @@ function getParentEntities(patch, tables) {
 }
 exports.getParentEntities = getParentEntities;
 function getEntityParentDependencies(entity, entityName, tables) {
-    var _a;
-    var patch = (_a = {}, _a[entityName] = [entity], _a);
-    var resultPatches = [];
+    let patch = { [entityName]: [entity] };
+    const resultPatches = [];
     while (true) {
-        var parents = getParentEntities(patch, tables);
+        let parents = getParentEntities(patch, tables);
         if (isPatchBlank(parents)) {
             break;
         }
         resultPatches.push(parents);
         patch = parents;
     }
-    var result = unionPatches((0, tslib_1.__spreadArray)([patch], resultPatches, true));
+    let result = unionPatches([patch, ...resultPatches]);
     result = mergeEntityPatches(tables, result);
     return result;
 }
@@ -1386,20 +1351,19 @@ exports.getEntityParentDependencies = getEntityParentDependencies;
 
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.useDbView = exports.useDbRef = exports.DbContext = void 0;
-var tslib_1 = __webpack_require__(/*! tslib */ "../node_modules/tslib/tslib.es6.js");
-var react_1 = __webpack_require__(/*! react */ "react");
+const react_1 = __webpack_require__(/*! react */ "react");
 exports.DbContext = (0, react_1.createContext)(null);
 function useDbRef() {
     return (0, react_1.useContext)(exports.DbContext);
 }
 exports.useDbRef = useDbRef;
 function useDbView(fn, params, options) {
-    var dbRef = useDbRef();
-    var _a = (0, react_1.useState)(), state = _a[0], setState = _a[1];
-    var subscription = (0, react_1.useMemo)(function () { return dbRef.subscribe((0, tslib_1.__assign)({ compute: fn }, options), params, setState); }, []);
+    const dbRef = useDbRef();
+    const [state, setState] = (0, react_1.useState)();
+    const subscription = (0, react_1.useMemo)(() => dbRef.subscribe(Object.assign({ compute: fn }, options), params, setState), []);
     subscription.update(params);
-    (0, react_1.useEffect)(function () {
-        return function () { return subscription.unsubscribe(); };
+    (0, react_1.useEffect)(() => {
+        return () => subscription.unsubscribe();
     }, []);
     return subscription.currentValue;
 }
@@ -1419,9 +1383,8 @@ exports.useDbView = useDbView;
 
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TempIdMap = exports.isTempId = exports.getTempId = void 0;
-var tslib_1 = __webpack_require__(/*! tslib */ "../node_modules/tslib/tslib.es6.js");
-var utils_1 = __webpack_require__(/*! ./utils */ "./src/utils.ts");
-var lastTempId = -1;
+const utils_1 = __webpack_require__(/*! ./utils */ "./src/utils.ts");
+let lastTempId = -1;
 function getTempId() {
     return --lastTempId;
 }
@@ -1430,28 +1393,27 @@ function isTempId(val) {
     return typeof val === 'number' && val < 0;
 }
 exports.isTempId = isTempId;
-var TempIdMap = /** @class */ (function () {
-    function TempIdMap(db) {
-        var _this = this;
+class TempIdMap {
+    constructor(db) {
         this.db = db;
         this.serverToClientIds = new Map();
         this.clientToServerIds = new Map();
-        this.clientToServer = function (id) { return _this.clientToServerIds.get(id); };
-        this.serverToClient = function (tableName, id) { return _this.getServerToClientMap(tableName).get(id); };
-        this.clientToServerRequest = function (request) {
-            request = (0, tslib_1.__assign)({}, request);
+        this.clientToServer = (id) => this.clientToServerIds.get(id);
+        this.serverToClient = (tableName, id) => this.getServerToClientMap(tableName).get(id);
+        this.clientToServerRequest = (request) => {
+            request = Object.assign({}, request);
             if (request.filter) {
-                request.filter = _this.clientToServerDataFilter(request.filter);
+                request.filter = this.clientToServerDataFilter(request.filter);
             }
             return request;
         };
-        this.clientToServerDataFilter = function (filter) {
-            filter = (0, tslib_1.__assign)({}, filter);
-            var keys = Object.keys(filter);
+        this.clientToServerDataFilter = (filter) => {
+            filter = Object.assign({}, filter);
+            const keys = Object.keys(filter);
             // I hope that we can rely that there won't be any negative numbers, which are not IDs, in queries.
             // We need to invent better heuristics or a schema otherwise.
-            var clientToServer = function (id) {
-                var found = _this.clientToServer(id);
+            const clientToServer = (id) => {
+                const found = this.clientToServer(id);
                 if (found) {
                     return found;
                 }
@@ -1459,11 +1421,11 @@ var TempIdMap = /** @class */ (function () {
                     return id;
                 }
             };
-            for (var n = 0; n < keys.length; n++) {
-                var key = keys[n];
-                var condition = filter[key];
+            for (let n = 0; n < keys.length; n++) {
+                const key = keys[n];
+                let condition = filter[key];
                 if (condition != null && typeof condition === "object") {
-                    condition = (0, tslib_1.__assign)({}, condition);
+                    condition = Object.assign({}, condition);
                     if ('in' in condition && Array.isArray(condition.in) && condition.in.length) {
                         condition.in = condition.in.map(clientToServer);
                     }
@@ -1476,76 +1438,74 @@ var TempIdMap = /** @class */ (function () {
             return filter;
         };
     }
-    TempIdMap.prototype.copyPatch = function (patch) {
-        var newPatch = (0, tslib_1.__assign)({}, patch);
-        (0, utils_1.objectKeys)(patch).forEach(function (tableName) {
-            var tablePatch = patch[tableName].map(function (entityPatch) { return ((0, tslib_1.__assign)({}, entityPatch)); });
+    copyPatch(patch) {
+        const newPatch = Object.assign({}, patch);
+        (0, utils_1.objectKeys)(patch).forEach(tableName => {
+            let tablePatch = patch[tableName].map(entityPatch => (Object.assign({}, entityPatch)));
             newPatch[tableName] = tablePatch;
         });
         return newPatch;
-    };
+    }
     // Iterate thru every field in every patch for every table, matching certain field criteria. The patch is mutated!
-    TempIdMap.prototype.mapFields = function (patch, filter, callback) {
-        var _this = this;
-        (0, utils_1.objectKeys)(patch).forEach(function (tableName) {
-            var schema = _this.db.tables[tableName].schema;
-            var fields = (0, utils_1.objectKeys)(schema.fields || [])
-                .map(function (fieldName) {
-                var fieldSchema = schema.fields[fieldName];
+    mapFields(patch, filter, callback) {
+        (0, utils_1.objectKeys)(patch).forEach(tableName => {
+            const schema = this.db.tables[tableName].schema;
+            const fields = (0, utils_1.objectKeys)(schema.fields || [])
+                .map(fieldName => {
+                const fieldSchema = schema.fields[fieldName];
                 if (filter(fieldSchema, fieldName)) {
                     return { name: fieldName, schema: fieldSchema };
                 }
             })
-                .filter(function (f) { return !!f; });
+                .filter(f => !!f);
             if (!fields.length) {
                 return;
             }
-            patch[tableName].forEach(function (entityPatch) {
-                for (var n = 0; n < fields.length; n++) {
-                    var field = fields[n];
-                    var fieldValue = entityPatch[field.name];
+            patch[tableName].forEach(entityPatch => {
+                for (let n = 0; n < fields.length; n++) {
+                    const field = fields[n];
+                    const fieldValue = entityPatch[field.name];
                     callback(field.name, field.schema, fieldValue, entityPatch, tableName);
                 }
             });
         });
-    };
-    TempIdMap.prototype.getServerToClientMap = function (tableName) {
-        var existing = this.serverToClientIds.get(tableName);
+    }
+    getServerToClientMap(tableName) {
+        const existing = this.serverToClientIds.get(tableName);
         if (existing) {
             return existing;
         }
         else {
-            var newMap = new Map();
+            const newMap = new Map();
             this.serverToClientIds.set(tableName, newMap);
             return newMap;
         }
-    };
-    TempIdMap.prototype.serverToClientPatch = function (patch) {
-        var _this = this;
+    }
+    serverToClientPatch(patch) {
         patch = this.copyPatch(patch);
         // We map PK in a separate pass, as we need to remap all PKs before re-mapping FKs
-        this.mapFields(patch, function (f) { return f.isGenerated; }, function (fieldName, fieldSchema, fieldValue, entityPatch, tableName) {
-            var clientId = _this.getServerToClientMap(tableName).get(fieldValue);
+        this.mapFields(patch, f => f.isGenerated, (fieldName, fieldSchema, fieldValue, entityPatch, tableName) => {
+            let clientId = this.getServerToClientMap(tableName).get(fieldValue);
             if (!clientId) {
                 clientId = getTempId();
-                _this.clientToServerIds.set(clientId, fieldValue);
-                _this.getServerToClientMap(tableName).set(fieldValue, clientId);
+                this.clientToServerIds.set(clientId, fieldValue);
+                this.getServerToClientMap(tableName).set(fieldValue, clientId);
             }
             entityPatch[fieldName] = clientId;
         });
-        this.mapFields(patch, function (f) { return !!(f.fk || (f.default != null) || f.toClient); }, function (fieldName, fieldSchema, fieldValue, entityPatch, tableName) {
-            var isUndefined = typeof (fieldValue) === 'undefined';
+        this.mapFields(patch, f => !!(f.fk || (f.default != null) || f.toClient), (fieldName, fieldSchema, fieldValue, entityPatch, tableName) => {
+            let isUndefined = typeof (fieldValue) === 'undefined';
             if (fieldSchema.default != null && fieldValue == null) {
                 fieldValue = fieldSchema.default;
                 isUndefined = false;
             }
             if (fieldSchema.fk && fieldValue != null) {
-                var fkTableName = typeof fieldSchema.fk.tableName === 'function' ? fieldSchema.fk.tableName(entityPatch) : fieldSchema.fk.tableName;
-                var clientId = _this.getServerToClientMap(fkTableName).get(fieldValue);
+                const fkTableName = typeof fieldSchema.fk.tableName === 'function' ? fieldSchema.fk.tableName(entityPatch) : fieldSchema.fk.tableName;
+                let clientId = this.getServerToClientMap(fkTableName).get(fieldValue);
                 if (!clientId) {
                     clientId = getTempId();
-                    _this.clientToServerIds.set(clientId, fieldValue);
-                    _this.getServerToClientMap(fkTableName).set(fieldValue, clientId);
+                    this.clientToServerIds.set(clientId, fieldValue);
+                    this.getServerToClientMap(fkTableName).set(fieldValue, clientId);
                 }
                 fieldValue = clientId;
             }
@@ -1557,48 +1517,45 @@ var TempIdMap = /** @class */ (function () {
             }
         });
         return patch;
-    };
-    TempIdMap.prototype.clientToServerPatch = function (patch) {
-        var _this = this;
+    }
+    clientToServerPatch(patch) {
         patch = this.copyPatch(patch);
-        this.mapFields(patch, function (f) { return f.isGenerated || !!f.fk; }, function (fieldName, fieldSchema, fieldValue, entityPatch, tableName) {
+        this.mapFields(patch, f => f.isGenerated || !!f.fk, (fieldName, fieldSchema, fieldValue, entityPatch, tableName) => {
             if (fieldValue != null) {
-                var existingId = _this.clientToServerIds.get(fieldValue);
+                const existingId = this.clientToServerIds.get(fieldValue);
                 if (existingId) {
                     entityPatch[fieldName] = existingId;
                 }
             }
         });
-        this.mapFields(patch, function (f) { return !(f.isClientOnly || f.isReadOnly) && !!f.toServer; }, function (fieldName, fieldSchema, fieldValue, entityPatch, tableName) {
+        this.mapFields(patch, f => !(f.isClientOnly || f.isReadOnly) && !!f.toServer, (fieldName, fieldSchema, fieldValue, entityPatch, tableName) => {
             entityPatch[fieldName] = fieldSchema.toServer(entityPatch[fieldName]);
         });
-        this.mapFields(patch, function (meta) { return meta.isClientOnly || meta.isReadOnly; }, function (fieldName, fieldSchema, fieldValue, entityPatch, tableName) {
+        this.mapFields(patch, meta => meta.isClientOnly || meta.isReadOnly, (fieldName, fieldSchema, fieldValue, entityPatch, tableName) => {
             delete entityPatch[fieldName];
         });
         return patch;
-    };
-    TempIdMap.prototype.appendServerMapping = function (response) {
-        var _this = this;
-        (0, utils_1.objectKeys)(response.submit).forEach(function (tableName) {
-            if (_this.db.tables[tableName]) {
-                var tablePatch = response.submit[tableName];
+    }
+    appendServerMapping(response) {
+        (0, utils_1.objectKeys)(response.submit).forEach(tableName => {
+            if (this.db.tables[tableName]) {
+                const tablePatch = response.submit[tableName];
                 if (tablePatch) {
-                    var serverToClientIds_1 = _this.getServerToClientMap(tableName);
-                    var table_1 = _this.db.tables[tableName];
-                    tablePatch.forEach(function (patch) {
+                    const serverToClientIds = this.getServerToClientMap(tableName);
+                    const table = this.db.tables[tableName];
+                    tablePatch.forEach(patch => {
                         if (isTempId(patch.id)) {
-                            var clientId = patch.id;
-                            var serverId = table_1.getId(patch.payload);
-                            serverToClientIds_1.set(serverId, clientId);
-                            _this.clientToServerIds.set(clientId, serverId);
+                            const clientId = patch.id;
+                            const serverId = table.getId(patch.payload);
+                            serverToClientIds.set(serverId, clientId);
+                            this.clientToServerIds.set(clientId, serverId);
                         }
                     });
                 }
             }
         });
-    };
-    return TempIdMap;
-}());
+    }
+}
 exports.TempIdMap = TempIdMap;
 
 
@@ -1635,20 +1592,17 @@ var DbRelationType;
 
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.difference = exports.defaultCompareViewDependencies = exports.objectKeys = void 0;
-var tslib_1 = __webpack_require__(/*! tslib */ "../node_modules/tslib/tslib.es6.js");
-var shallowequal_1 = (0, tslib_1.__importDefault)(__webpack_require__(/*! shallowequal */ "shallowequal"));
-var lodash_zip_1 = (0, tslib_1.__importDefault)(__webpack_require__(/*! lodash.zip */ "lodash.zip"));
-var lodash_transform_1 = (0, tslib_1.__importDefault)(__webpack_require__(/*! lodash.transform */ "lodash.transform"));
-var lodash_isequal_1 = (0, tslib_1.__importDefault)(__webpack_require__(/*! lodash.isequal */ "lodash.isequal"));
+const tslib_1 = __webpack_require__(/*! tslib */ "../node_modules/tslib/tslib.es6.js");
+const shallowequal_1 = (0, tslib_1.__importDefault)(__webpack_require__(/*! shallowequal */ "shallowequal"));
+const lodash_zip_1 = (0, tslib_1.__importDefault)(__webpack_require__(/*! lodash.zip */ "lodash.zip"));
+const lodash_transform_1 = (0, tslib_1.__importDefault)(__webpack_require__(/*! lodash.transform */ "lodash.transform"));
+const lodash_isequal_1 = (0, tslib_1.__importDefault)(__webpack_require__(/*! lodash.isequal */ "lodash.isequal"));
 // TBD: New typescript would contain better typing for this. Remove this hack after update.
 exports.objectKeys = Object.keys;
 function defaultCompareViewDependencies(prev, next) {
     if (Array.isArray(prev) && Array.isArray(next)) {
         if (prev.length === next.length) {
-            return (0, lodash_zip_1.default)(prev, next).every(function (_a) {
-                var p = _a[0], n = _a[1];
-                return (0, shallowequal_1.default)(p, n);
-            });
+            return (0, lodash_zip_1.default)(prev, next).every(([p, n]) => (0, shallowequal_1.default)(p, n));
         }
         return false;
     }