@epam/uui-db 4.8.0-beta.0 → 4.8.2

package/index.js

@@ -381,10 +381,10 @@ function __classPrivateFieldIn(state, receiver) {
 /***/ (function(module, exports, __webpack_require__) {
 
 "use strict";
-
-Object.defineProperty(exports, "__esModule", { value: true });
-var tslib_1 = __webpack_require__(/*! tslib */ "../node_modules/tslib/tslib.es6.js");
-(0, tslib_1.__exportStar)(__webpack_require__(/*! ./src */ "./src/index.ts"), exports);
+
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = __webpack_require__(/*! tslib */ "../node_modules/tslib/tslib.es6.js");
+(0, tslib_1.__exportStar)(__webpack_require__(/*! ./src */ "./src/index.ts"), exports);
 
 
 /***/ }),
@@ -397,81 +397,81 @@ var tslib_1 = __webpack_require__(/*! tslib */ "../node_modules/tslib/tslib.es6.
 /***/ (function(module, exports, __webpack_require__) {
 
 "use strict";
-
-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) {
-        this.tables = tables;
-        this.viewCache = new Map();
-        /* Views (cached db projections) */
-        this.valueAbsent = Symbol("ValueAbsent");
-        if (reusedCache) {
-            this.viewCache = new Map(reusedCache);
-        }
-        else {
-            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);
-        mutate(clone);
-        return clone;
-    };
-    Db.prototype.with = function (patch) {
-        return this.update(function (db) {
-            (0, utils_1.objectKeys)(db.tables).forEach(function (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);
-        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);
-        if (!cacheItem) {
-            cacheItem = {
-                dependencies: this.valueAbsent,
-                currentValue: this.valueAbsent,
-                computedOnDb: this.valueAbsent,
-            };
-            cache.set(key, cacheItem);
-        }
-        var shouldUpdate = this !== cacheItem.computedOnDb;
-        var dependencies = this.valueAbsent;
-        if (view.getDependencies) {
-            var compare = view.compareDependencies || utils_1.defaultCompareViewDependencies;
-            dependencies = view.getDependencies(this, params);
-            shouldUpdate = !compare(cacheItem.dependencies, dependencies);
-        }
-        var previousValue = cacheItem.currentValue;
-        if (shouldUpdate) {
-            cacheItem.dependencies = dependencies;
-            var newValue = view.compute(this, params, dependencies);
-            cacheItem.computedOnDb = this;
-            var compareResults = view.compareResults || lodash_isequal_1.default;
-            if (!compareResults(previousValue, newValue)) {
-                if (view.traceDiff) {
-                    console.debug((0, utils_1.difference)(previousValue, newValue));
-                }
-                cacheItem.currentValue = newValue;
-            }
-        }
-        return cacheItem.currentValue;
-    };
-    return Db;
-}());
-exports.Db = Db;
+
+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) {
+        this.tables = tables;
+        this.viewCache = new Map();
+        /* Views (cached db projections) */
+        this.valueAbsent = Symbol("ValueAbsent");
+        if (reusedCache) {
+            this.viewCache = new Map(reusedCache);
+        }
+        else {
+            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);
+        mutate(clone);
+        return clone;
+    };
+    Db.prototype.with = function (patch) {
+        return this.update(function (db) {
+            (0, utils_1.objectKeys)(db.tables).forEach(function (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);
+        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);
+        if (!cacheItem) {
+            cacheItem = {
+                dependencies: this.valueAbsent,
+                currentValue: this.valueAbsent,
+                computedOnDb: this.valueAbsent,
+            };
+            cache.set(key, cacheItem);
+        }
+        var shouldUpdate = this !== cacheItem.computedOnDb;
+        var dependencies = this.valueAbsent;
+        if (view.getDependencies) {
+            var compare = view.compareDependencies || utils_1.defaultCompareViewDependencies;
+            dependencies = view.getDependencies(this, params);
+            shouldUpdate = !compare(cacheItem.dependencies, dependencies);
+        }
+        var previousValue = cacheItem.currentValue;
+        if (shouldUpdate) {
+            cacheItem.dependencies = dependencies;
+            var newValue = view.compute(this, params, dependencies);
+            cacheItem.computedOnDb = this;
+            var compareResults = view.compareResults || lodash_isequal_1.default;
+            if (!compareResults(previousValue, newValue)) {
+                if (view.traceDiff) {
+                    console.debug((0, utils_1.difference)(previousValue, newValue));
+                }
+                cacheItem.currentValue = newValue;
+            }
+        }
+        return cacheItem.currentValue;
+    };
+    return Db;
+}());
+exports.Db = Db;
 
 
 /***/ }),
@@ -484,213 +484,213 @@ exports.Db = Db;
 /***/ (function(module, exports, __webpack_require__) {
 
 "use strict";
-
-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;
-        this.blank = blank;
-        this.log = [];
-        this.autoSave = true;
-        this.savedPoint = 0;
-        this.throttleSaveMs = 1000;
-        /* Update subscriptions (aka live views) */
-        this.lastSubscriptionId = 1;
-        this.subscriptions = new Map();
-        this.updateHandlers = [];
-        /* 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) {
-                e.returnValue = false;
-                return false;
-            }
-        };
-        this.loaders = [];
-        this.db = blank;
-        this.base = blank;
-        this.tempIdMap = new tempIds_1.TempIdMap(blank);
-        this.idMap = this.tempIdMap;
-        window.addEventListener('beforeunload', this.handleBeforeUnload);
-    }
-    /** Saves all committed patches. Useful only if autoSave is off. */
-    DbRef.prototype.save = function () {
-        return this.enqueueSave();
-    };
-    DbRef.prototype.getAutoSave = function () {
-        return this.autoSave;
-    };
-    DbRef.prototype.setAutoSave = function (val) {
-        if (this.autoSave != val) {
-            this.autoSave = val;
-            this.autoSave && this.enqueueSave();
-            this.update();
-        }
-    };
-    DbRef.prototype.revert = function () {
-        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) {
-        return Promise.resolve({ submit: {} });
-    };
-    /* Db Update logic */
-    DbRef.prototype.commit = function (patch) {
-        var 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.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) {
-            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,
-            };
-            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);
-            patchAndDependencies = (0, patchHelpers_1.mergeEntityPatches)(tables, (0, patchHelpers_1.unionPatches)([patchAndDependencies, updatedPatch, dependentEntityPatches]));
-        });
-        return patchAndDependencies;
-    };
-    DbRef.prototype.commitFetch = function (patch) {
-        patch = this.tempIdMap.serverToClientPatch(patch);
-        this.rebase(this.base.with(patch));
-        this.update();
-    };
-    DbRef.prototype.rebase = function (newBase) {
-        this.base = newBase;
-        this.db = newBase;
-        for (var 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);
-        cumulativePatch = this.tempIdMap.clientToServerPatch(cumulativePatch);
-        return cumulativePatch;
-    };
-    DbRef.prototype.applyResponse = function (response, newSavedPoint) {
-        this.tempIdMap.appendServerMapping(response);
-        var 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) {
-                subscription.currentParams = params;
-                subscription.currentValue = _this.db.runView(view, params);
-                return subscription.currentValue;
-            },
-            currentParams: null,
-            currentValue: null,
-            onUpdate: onUpdate,
-            unsubscribe: function () { _this.subscriptions.delete(id); },
-        };
-        subscription.update(params);
-        this.subscriptions.set(id, subscription);
-        return subscription;
-    };
-    DbRef.prototype.onUpdate = function (handler) {
-        this.subscribe({
-            compute: function (db) { return db; },
-            compareResults: function (a, b) { return a === b; },
-        }, null, handler);
-    };
-    DbRef.prototype.update = function () {
-        this.subscriptions.forEach(function (subscription) {
-            var previousValue = subscription.currentValue;
-            subscription.update(subscription.currentParams);
-            if (subscription.currentValue !== previousValue && subscription.onUpdate) {
-                subscription.onUpdate(subscription.currentValue);
-            }
-        });
-    };
-    DbRef.prototype.onSaveError = function (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);
-        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);
-        this.loaders.push(loader);
-        return loader;
-    };
-    DbRef.prototype.reload = function () {
-        this.loaders = [];
-    };
-    return DbRef;
-}());
-exports.DbRef = DbRef;
+
+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;
+        this.blank = blank;
+        this.log = [];
+        this.autoSave = true;
+        this.savedPoint = 0;
+        this.throttleSaveMs = 1000;
+        /* Update subscriptions (aka live views) */
+        this.lastSubscriptionId = 1;
+        this.subscriptions = new Map();
+        this.updateHandlers = [];
+        /* 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) {
+                e.returnValue = false;
+                return false;
+            }
+        };
+        this.loaders = [];
+        this.db = blank;
+        this.base = blank;
+        this.tempIdMap = new tempIds_1.TempIdMap(blank);
+        this.idMap = this.tempIdMap;
+        window.addEventListener('beforeunload', this.handleBeforeUnload);
+    }
+    /** Saves all committed patches. Useful only if autoSave is off. */
+    DbRef.prototype.save = function () {
+        return this.enqueueSave();
+    };
+    DbRef.prototype.getAutoSave = function () {
+        return this.autoSave;
+    };
+    DbRef.prototype.setAutoSave = function (val) {
+        if (this.autoSave != val) {
+            this.autoSave = val;
+            this.autoSave && this.enqueueSave();
+            this.update();
+        }
+    };
+    DbRef.prototype.revert = function () {
+        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) {
+        return Promise.resolve({ submit: {} });
+    };
+    /* Db Update logic */
+    DbRef.prototype.commit = function (patch) {
+        var 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.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) {
+            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,
+            };
+            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);
+            patchAndDependencies = (0, patchHelpers_1.mergeEntityPatches)(tables, (0, patchHelpers_1.unionPatches)([patchAndDependencies, updatedPatch, dependentEntityPatches]));
+        });
+        return patchAndDependencies;
+    };
+    DbRef.prototype.commitFetch = function (patch) {
+        patch = this.tempIdMap.serverToClientPatch(patch);
+        this.rebase(this.base.with(patch));
+        this.update();
+    };
+    DbRef.prototype.rebase = function (newBase) {
+        this.base = newBase;
+        this.db = newBase;
+        for (var 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);
+        cumulativePatch = this.tempIdMap.clientToServerPatch(cumulativePatch);
+        return cumulativePatch;
+    };
+    DbRef.prototype.applyResponse = function (response, newSavedPoint) {
+        this.tempIdMap.appendServerMapping(response);
+        var 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) {
+                subscription.currentParams = params;
+                subscription.currentValue = _this.db.runView(view, params);
+                return subscription.currentValue;
+            },
+            currentParams: null,
+            currentValue: null,
+            onUpdate: onUpdate,
+            unsubscribe: function () { _this.subscriptions.delete(id); },
+        };
+        subscription.update(params);
+        this.subscriptions.set(id, subscription);
+        return subscription;
+    };
+    DbRef.prototype.onUpdate = function (handler) {
+        this.subscribe({
+            compute: function (db) { return db; },
+            compareResults: function (a, b) { return a === b; },
+        }, null, handler);
+    };
+    DbRef.prototype.update = function () {
+        this.subscriptions.forEach(function (subscription) {
+            var previousValue = subscription.currentValue;
+            subscription.update(subscription.currentParams);
+            if (subscription.currentValue !== previousValue && subscription.onUpdate) {
+                subscription.onUpdate(subscription.currentValue);
+            }
+        });
+    };
+    DbRef.prototype.onSaveError = function (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);
+        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);
+        this.loaders.push(loader);
+        return loader;
+    };
+    DbRef.prototype.reload = function () {
+        this.loaders = [];
+    };
+    return DbRef;
+}());
+exports.DbRef = DbRef;
 
 
 /***/ }),
@@ -703,219 +703,219 @@ exports.DbRef = DbRef;
 /***/ (function(module, exports, __webpack_require__) {
 
 "use strict";
-
-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) {
-        this.schema = schema;
-        this.state = state;
-        this.q = q;
-        if (!state) {
-            var indexes = (schema.indexes || []).map(function (indexDef) {
-                return {
-                    field: indexDef,
-                    map: I.Map(),
-                };
-            });
-            this.state = { pk: I.Map(), indexes: indexes };
-        }
-        if (!q) {
-            this.q = {};
-        }
-    }
-    DbTable.prototype.keyToImmutable = function (id) {
-        if (Array.isArray(id)) {
-            return I.List(id);
-        }
-        else {
-            return id;
-        }
-    };
-    DbTable.prototype.byId = function (id) {
-        return this.state.pk.get(this.keyToImmutable(id));
-    };
-    DbTable.prototype.getId = function (entity) {
-        if (Array.isArray(this.schema.primaryKey)) {
-            return this.schema.primaryKey.map(function (key) { return entity[key]; });
-        }
-        return entity[this.schema.primaryKey];
-    };
-    DbTable.prototype.update = function (mutate) {
-        var 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;
-            if (existing) {
-                updated = (0, tslib_1.__assign)((0, tslib_1.__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 };
-        });
-        var idVal = immutable_1.Seq.Keyed(updates.map(function (entity) { return [entity.immId, entity.updated]; }));
-        var 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) {
-            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];
-                if (update.existing) {
-                    var oldKey = update.existing[index.field];
-                    if (oldKey !== newKey || update.isDeleted) {
-                        newMap = newMap.update(oldKey, function (set) { return set.remove(update.immId); });
-                    }
-                }
-                if (!update.isDeleted) {
-                    newMap = newMap.update(newKey, I.Set(), function (set) { return 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 });
-        });
-        var newState = { pk: newPk, indexes: newIndexes };
-        return this.update(function (t) { return 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) {
-        if (!this.schema.searchBy) {
-            throw new Error("Can't search in the ".concat(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 }); });
-    };
-    /* 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 () {
-        return this.runQuery(this.q).length;
-    };
-    DbTable.prototype.one = function () {
-        return this.runQuery(this.q)[0] || null;
-    };
-    DbTable.prototype.toArray = function () {
-        return this.runQuery(this.q);
-    };
-    DbTable.prototype.map = function (fn) {
-        return this.toArray().map(fn);
-    };
-    /* Query implementation */
-    DbTable.prototype.runQuery = function (q) {
-        var _this = this;
-        var result = null;
-        var filter = q.filter;
-        if (filter) {
-            var indexes = this.state.indexes;
-            // Try to use indexes to fulfill filter conditions
-            for (var n = 0; n < indexes.length; n++) {
-                var 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;
-                    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"]);
-                        if (inCriteria && Array.isArray(inCriteria)) {
-                            conditionValues = inCriteria;
-                        }
-                        else {
-                            restCriteria.in = inCriteria;
-                        }
-                        // Conditions in getPatternPredicate are composed with 'and' logic,
-                        // For now, let's not attempt to handle tricky cases like { in: [1,2] isNull: true }, or { in: [1, null] isNull: false }
-                        // - just leave this to getPatternPredicate.
-                        // Let's just handle the a most common case { isNull: true } - find all null and undefined
-                        if (nullCriteria === true && !conditionValues) {
-                            conditionValues = [null, undefined];
-                        }
-                        else {
-                            restCriteria.in = inCriteria;
-                        }
-                        // Keep other conditions, e.g. { in: [1,2,3], isNull: true } - in works via index, isNull - via filter
-                        if (Object.keys(restCriteria).length > 0) {
-                            rest[index.field] = restCriteria;
-                        }
-                    }
-                    else {
-                        conditionValues = [condition];
-                    }
-                    if (conditionValues) {
-                        result = [];
-                        for (var i = 0; i < conditionValues.length; i++) {
-                            var 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]);
-                                    result.push(item);
-                                }
-                            }
-                        }
-                        filter = Object.keys(rest).length > 0 ? rest : null;
-                        break;
-                    }
-                }
-            }
-        }
-        if (!result) {
-            result = this.state.pk.toArray();
-        }
-        if (filter) {
-            var predicate = (0, uui_core_1.getPatternPredicate)(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]; })); });
-        }
-        if (q.sorting) {
-            var 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;
+
+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) {
+        this.schema = schema;
+        this.state = state;
+        this.q = q;
+        if (!state) {
+            var indexes = (schema.indexes || []).map(function (indexDef) {
+                return {
+                    field: indexDef,
+                    map: I.Map(),
+                };
+            });
+            this.state = { pk: I.Map(), indexes: indexes };
+        }
+        if (!q) {
+            this.q = {};
+        }
+    }
+    DbTable.prototype.keyToImmutable = function (id) {
+        if (Array.isArray(id)) {
+            return I.List(id);
+        }
+        else {
+            return id;
+        }
+    };
+    DbTable.prototype.byId = function (id) {
+        return this.state.pk.get(this.keyToImmutable(id));
+    };
+    DbTable.prototype.getId = function (entity) {
+        if (Array.isArray(this.schema.primaryKey)) {
+            return this.schema.primaryKey.map(function (key) { return entity[key]; });
+        }
+        return entity[this.schema.primaryKey];
+    };
+    DbTable.prototype.update = function (mutate) {
+        var 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;
+            if (existing) {
+                updated = (0, tslib_1.__assign)((0, tslib_1.__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 };
+        });
+        var idVal = immutable_1.Seq.Keyed(updates.map(function (entity) { return [entity.immId, entity.updated]; }));
+        var 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) {
+            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];
+                if (update.existing) {
+                    var oldKey = update.existing[index.field];
+                    if (oldKey !== newKey || update.isDeleted) {
+                        newMap = newMap.update(oldKey, function (set) { return set.remove(update.immId); });
+                    }
+                }
+                if (!update.isDeleted) {
+                    newMap = newMap.update(newKey, I.Set(), function (set) { return 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 });
+        });
+        var newState = { pk: newPk, indexes: newIndexes };
+        return this.update(function (t) { return 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) {
+        if (!this.schema.searchBy) {
+            throw new Error("Can't search in the ".concat(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 }); });
+    };
+    /* 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 () {
+        return this.runQuery(this.q).length;
+    };
+    DbTable.prototype.one = function () {
+        return this.runQuery(this.q)[0] || null;
+    };
+    DbTable.prototype.toArray = function () {
+        return this.runQuery(this.q);
+    };
+    DbTable.prototype.map = function (fn) {
+        return this.toArray().map(fn);
+    };
+    /* Query implementation */
+    DbTable.prototype.runQuery = function (q) {
+        var _this = this;
+        var result = null;
+        var filter = q.filter;
+        if (filter) {
+            var indexes = this.state.indexes;
+            // Try to use indexes to fulfill filter conditions
+            for (var n = 0; n < indexes.length; n++) {
+                var 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;
+                    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"]);
+                        if (inCriteria && Array.isArray(inCriteria)) {
+                            conditionValues = inCriteria;
+                        }
+                        else {
+                            restCriteria.in = inCriteria;
+                        }
+                        // Conditions in getPatternPredicate are composed with 'and' logic,
+                        // For now, let's not attempt to handle tricky cases like { in: [1,2] isNull: true }, or { in: [1, null] isNull: false }
+                        // - just leave this to getPatternPredicate.
+                        // Let's just handle the a most common case { isNull: true } - find all null and undefined
+                        if (nullCriteria === true && !conditionValues) {
+                            conditionValues = [null, undefined];
+                        }
+                        else {
+                            restCriteria.in = inCriteria;
+                        }
+                        // Keep other conditions, e.g. { in: [1,2,3], isNull: true } - in works via index, isNull - via filter
+                        if (Object.keys(restCriteria).length > 0) {
+                            rest[index.field] = restCriteria;
+                        }
+                    }
+                    else {
+                        conditionValues = [condition];
+                    }
+                    if (conditionValues) {
+                        result = [];
+                        for (var i = 0; i < conditionValues.length; i++) {
+                            var 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]);
+                                    result.push(item);
+                                }
+                            }
+                        }
+                        filter = Object.keys(rest).length > 0 ? rest : null;
+                        break;
+                    }
+                }
+            }
+        }
+        if (!result) {
+            result = this.state.pk.toArray();
+        }
+        if (filter) {
+            var 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]; })); });
+        }
+        if (q.sorting) {
+            var 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;
 
 
 /***/ }),
@@ -928,99 +928,99 @@ exports.DbTable = DbTable;
 /***/ (function(module, exports, __webpack_require__) {
 
 "use strict";
-
-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) {
-        this.options = options;
-        this.cache = new Map();
-        this.extractList = (options === null || options === void 0 ? void 0 : options.extractList) || (function (r) { return 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 = {};
-        if (filter) {
-            options.filter = filter;
-        }
-        if (sorting) {
-            options.sorting = sorting;
-        }
-        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);
-        if (!entry) {
-            entry = { options: 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;
-        if (entry.isComplete) {
-            return null;
-        }
-        if (!request.range) {
-            return request;
-        }
-        else {
-            var requestedMax = request.range.from + request.range.count;
-            var 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 } });
-            }
-            else {
-                return null;
-            }
-        }
-    };
-    ListLoadingTracker.prototype.count = function (request) {
-        var entry = this.prepare(request).entry;
-        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;
-        if (response) {
-            var list = this.extractList(response);
-            if (list.count) {
-                entry.maxCount = list.count;
-            }
-            if (!range) {
-                entry.count = list.items.length;
-                entry.maxCount = list.items.length;
-                entry.isComplete = true;
-            }
-            else {
-                var from = (list.from == null) ? range.from : list.from;
-                if (list.items.length > 0) {
-                    entry.count = Math.max(entry.count, from + list.items.length);
-                }
-                if (list.items.length < range.count) {
-                    entry.maxCount = from + list.items.length;
-                    entry.count = entry.maxCount;
-                    entry.isComplete = true;
-                }
-            }
-        }
-        else {
-            if (range) {
-                entry.count = Math.max(entry.count, request.range.from + request.range.count);
-            }
-            else {
-                entry.isComplete = true;
-            }
-        }
-    };
-    return ListLoadingTracker;
-}());
-exports.ListLoadingTracker = ListLoadingTracker;
+
+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) {
+        this.options = options;
+        this.cache = new Map();
+        this.extractList = (options === null || options === void 0 ? void 0 : options.extractList) || (function (r) { return 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 = {};
+        if (filter) {
+            options.filter = filter;
+        }
+        if (sorting) {
+            options.sorting = sorting;
+        }
+        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);
+        if (!entry) {
+            entry = { options: 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;
+        if (entry.isComplete) {
+            return null;
+        }
+        if (!request.range) {
+            return request;
+        }
+        else {
+            var requestedMax = request.range.from + request.range.count;
+            var 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 } });
+            }
+            else {
+                return null;
+            }
+        }
+    };
+    ListLoadingTracker.prototype.count = function (request) {
+        var entry = this.prepare(request).entry;
+        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;
+        if (response) {
+            var list = this.extractList(response);
+            if (list.count) {
+                entry.maxCount = list.count;
+            }
+            if (!range) {
+                entry.count = list.items.length;
+                entry.maxCount = list.items.length;
+                entry.isComplete = true;
+            }
+            else {
+                var from = (list.from == null) ? range.from : list.from;
+                if (list.items.length > 0) {
+                    entry.count = Math.max(entry.count, from + list.items.length);
+                }
+                if (list.items.length < range.count) {
+                    entry.maxCount = from + list.items.length;
+                    entry.count = entry.maxCount;
+                    entry.isComplete = true;
+                }
+            }
+        }
+        else {
+            if (range) {
+                entry.count = Math.max(entry.count, request.range.from + request.range.count);
+            }
+            else {
+                entry.isComplete = true;
+            }
+        }
+    };
+    return ListLoadingTracker;
+}());
+exports.ListLoadingTracker = ListLoadingTracker;
 
 
 /***/ }),
@@ -1033,84 +1033,84 @@ exports.ListLoadingTracker = ListLoadingTracker;
 /***/ (function(module, exports, __webpack_require__) {
 
 "use strict";
-
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Loader = void 0;
-var Loader = /** @class */ (function () {
-    function Loader(dbRef, getTracker, options) {
-        var _this = this;
-        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,
-                isLoading: false,
-                request: inputRequest,
-                missing: _this.loadedAndLoading.diff(inputRequest),
-                promise: null,
-                reload: null,
-            };
-            result.reload = function () {
-                result.missing = inputRequest;
-                _this.loadImpl(result);
-            };
-            if (result.isComplete) {
-                // Everything requested is already loaded
-                result.isComplete = true;
-                result.isLoading = false;
-                result.promise = Promise.resolve();
-                return result;
-            }
-            else {
-                if (result.missing == null) {
-                    // Everything requested is either loaded already, or being loaded
-                    result.isComplete = false;
-                    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 () { });
-                    return result;
-                }
-                else {
-                    // Something requested is not loaded, nor being loaded. Need to perform a new request.
-                    _this.loadImpl(result);
-                    return result;
-                }
-            }
-        };
-        this.loaded = getTracker();
-        this.loadedAndLoading = getTracker();
-    }
-    Loader.prototype.loadImpl = function (state) {
-        var _this = this;
-        this.loadedAndLoading.append(state.missing);
-        state.isLoading = true;
-        var 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.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);
-        });
-        this.currentRequests.add(state.promise);
-        state.promise.finally(function () {
-            _this.currentRequests.delete(state.promise);
-        });
-        return state.promise;
-    };
-    return Loader;
-}());
-exports.Loader = Loader;
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Loader = void 0;
+var Loader = /** @class */ (function () {
+    function Loader(dbRef, getTracker, options) {
+        var _this = this;
+        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,
+                isLoading: false,
+                request: inputRequest,
+                missing: _this.loadedAndLoading.diff(inputRequest),
+                promise: null,
+                reload: null,
+            };
+            result.reload = function () {
+                result.missing = inputRequest;
+                _this.loadImpl(result);
+            };
+            if (result.isComplete) {
+                // Everything requested is already loaded
+                result.isComplete = true;
+                result.isLoading = false;
+                result.promise = Promise.resolve();
+                return result;
+            }
+            else {
+                if (result.missing == null) {
+                    // Everything requested is either loaded already, or being loaded
+                    result.isComplete = false;
+                    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 () { });
+                    return result;
+                }
+                else {
+                    // Something requested is not loaded, nor being loaded. Need to perform a new request.
+                    _this.loadImpl(result);
+                    return result;
+                }
+            }
+        };
+        this.loaded = getTracker();
+        this.loadedAndLoading = getTracker();
+    }
+    Loader.prototype.loadImpl = function (state) {
+        var _this = this;
+        this.loadedAndLoading.append(state.missing);
+        state.isLoading = true;
+        var 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.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);
+        });
+        this.currentRequests.add(state.promise);
+        state.promise.finally(function () {
+            _this.currentRequests.delete(state.promise);
+        });
+        return state.promise;
+    };
+    return Loader;
+}());
+exports.Loader = Loader;
 
 
 /***/ }),
@@ -1123,25 +1123,25 @@ exports.Loader = Loader;
 /***/ (function(module, exports, __webpack_require__) {
 
 "use strict";
-
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SimpleLoadingTracker = void 0;
-var SimpleLoadingTracker = /** @class */ (function () {
-    function SimpleLoadingTracker() {
-        this.set = new Set();
-    }
-    SimpleLoadingTracker.prototype.getKey = function (request) {
-        return JSON.stringify(request);
-    };
-    SimpleLoadingTracker.prototype.diff = function (request) {
-        return this.set.has(this.getKey(request)) ? null : request;
-    };
-    SimpleLoadingTracker.prototype.append = function (request, result) {
-        this.set.add(this.getKey(request));
-    };
-    return SimpleLoadingTracker;
-}());
-exports.SimpleLoadingTracker = SimpleLoadingTracker;
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SimpleLoadingTracker = void 0;
+var SimpleLoadingTracker = /** @class */ (function () {
+    function SimpleLoadingTracker() {
+        this.set = new Set();
+    }
+    SimpleLoadingTracker.prototype.getKey = function (request) {
+        return JSON.stringify(request);
+    };
+    SimpleLoadingTracker.prototype.diff = function (request) {
+        return this.set.has(this.getKey(request)) ? null : request;
+    };
+    SimpleLoadingTracker.prototype.append = function (request, result) {
+        this.set.add(this.getKey(request));
+    };
+    return SimpleLoadingTracker;
+}());
+exports.SimpleLoadingTracker = SimpleLoadingTracker;
 
 
 /***/ }),
@@ -1154,17 +1154,17 @@ exports.SimpleLoadingTracker = SimpleLoadingTracker;
 /***/ (function(module, exports, __webpack_require__) {
 
 "use strict";
-
-Object.defineProperty(exports, "__esModule", { value: true });
-var 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);
-(0, tslib_1.__exportStar)(__webpack_require__(/*! ./DbRef */ "./src/DbRef.ts"), exports);
-(0, tslib_1.__exportStar)(__webpack_require__(/*! ./tempIds */ "./src/tempIds.tsx"), exports);
-(0, tslib_1.__exportStar)(__webpack_require__(/*! ./utils */ "./src/utils.ts"), exports);
-(0, tslib_1.__exportStar)(__webpack_require__(/*! ./patchHelpers */ "./src/patchHelpers.ts"), exports);
-(0, tslib_1.__exportStar)(__webpack_require__(/*! ./reactHooks */ "./src/reactHooks.ts"), exports);
+
+Object.defineProperty(exports, "__esModule", { value: true });
+var 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);
+(0, tslib_1.__exportStar)(__webpack_require__(/*! ./DbRef */ "./src/DbRef.ts"), exports);
+(0, tslib_1.__exportStar)(__webpack_require__(/*! ./tempIds */ "./src/tempIds.tsx"), exports);
+(0, tslib_1.__exportStar)(__webpack_require__(/*! ./utils */ "./src/utils.ts"), exports);
+(0, tslib_1.__exportStar)(__webpack_require__(/*! ./patchHelpers */ "./src/patchHelpers.ts"), exports);
+(0, tslib_1.__exportStar)(__webpack_require__(/*! ./reactHooks */ "./src/reactHooks.ts"), exports);
 
 
 /***/ }),
@@ -1177,200 +1177,200 @@ var tslib_1 = __webpack_require__(/*! tslib */ "../node_modules/tslib/tslib.es6.
 /***/ (function(module, exports, __webpack_require__) {
 
 "use strict";
-
-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"));
-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];
-        });
-    });
-    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));
-            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;
-                });
-                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));
-                }
-            }
-            return result;
-        });
-        result[key] = tablePatch;
-    });
-    return result;
-}
-exports.mergeEntityPatches = mergeEntityPatches;
-function flattenResponseHelper(result, object, tablesByTypeName) {
-    if (Array.isArray(object)) {
-        object.forEach(function (item) { return flattenResponseHelper(result, item, tablesByTypeName); });
-    }
-    else if (typeof object === 'object') {
-        var clone = {};
-        var tableKey = void 0;
-        var fields = {};
-        if ('__typename' in object) {
-            var 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];
-            if ((field && !!field.disableFlatten)
-                || typeof value !== 'object'
-                || value === null
-                || (Array.isArray(value) && value.every(function (item) { return typeof item !== 'object'; }))) {
-                clone[key] = value;
-            }
-            else {
-                flattenResponseHelper(result, value, tablesByTypeName);
-            }
-        }
-        if (tableKey) {
-            result[tableKey].push(clone);
-        }
-    }
-}
-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] = []; });
-    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; });
-}
-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); }));
-        });
-        var entities = ids
-            .map(function (id) { return table.byId(id); })
-            .filter(function (e) { return !isClientOnly(e, schema); })
-            .toArray();
-        if (entities.length > 0) {
-            result[entityName] = entities;
-        }
-    });
-    return result;
-}
-exports.makeCumulativePatch = makeCumulativePatch;
-function isClientOnly(entity, schema) {
-    if (typeof schema.isClientOnly === 'function') {
-        return schema.isClientOnly(entity);
-    }
-    return !!schema.isClientOnly;
-}
-exports.isClientOnly = isClientOnly;
-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) {
-        result.push(value);
-    });
-    return result;
-}
-exports.getId = getId;
-function isNew(entity, schema, clientIdsMap) {
-    var 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);
-    if (isClientOnly(fullEntity, schema)) {
-        return false;
-    }
-    return (0, utils_1.objectKeys)(entity).some(function (fieldName) {
-        var 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);
-                if (parentEntity) {
-                    dependenciesPatch[actualTableName] = dependenciesPatch[actualTableName] || [];
-                    dependenciesPatch[actualTableName].push(idFields);
-                }
-            });
-        });
-    });
-    return dependenciesPatch;
-}
-exports.getParentEntities = getParentEntities;
-function getEntityParentDependencies(entity, entityName, tables) {
-    var _a;
-    var patch = (_a = {}, _a[entityName] = [entity], _a);
-    var resultPatches = [];
-    while (true) {
-        var parents = getParentEntities(patch, tables);
-        if (isPatchBlank(parents)) {
-            break;
-        }
-        resultPatches.push(parents);
-        patch = parents;
-    }
-    var result = unionPatches((0, tslib_1.__spreadArray)([patch], resultPatches, true));
-    result = mergeEntityPatches(tables, result);
-    return result;
-}
-exports.getEntityParentDependencies = getEntityParentDependencies;
+
+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"));
+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];
+        });
+    });
+    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));
+            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;
+                });
+                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));
+                }
+            }
+            return result;
+        });
+        result[key] = tablePatch;
+    });
+    return result;
+}
+exports.mergeEntityPatches = mergeEntityPatches;
+function flattenResponseHelper(result, object, tablesByTypeName) {
+    if (Array.isArray(object)) {
+        object.forEach(function (item) { return flattenResponseHelper(result, item, tablesByTypeName); });
+    }
+    else if (typeof object === 'object') {
+        var clone = {};
+        var tableKey = void 0;
+        var fields = {};
+        if ('__typename' in object) {
+            var 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];
+            if ((field && !!field.disableFlatten)
+                || typeof value !== 'object'
+                || value === null
+                || (Array.isArray(value) && value.every(function (item) { return typeof item !== 'object'; }))) {
+                clone[key] = value;
+            }
+            else {
+                flattenResponseHelper(result, value, tablesByTypeName);
+            }
+        }
+        if (tableKey) {
+            result[tableKey].push(clone);
+        }
+    }
+}
+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] = []; });
+    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; });
+}
+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); }));
+        });
+        var entities = ids
+            .map(function (id) { return table.byId(id); })
+            .filter(function (e) { return !isClientOnly(e, schema); })
+            .toArray();
+        if (entities.length > 0) {
+            result[entityName] = entities;
+        }
+    });
+    return result;
+}
+exports.makeCumulativePatch = makeCumulativePatch;
+function isClientOnly(entity, schema) {
+    if (typeof schema.isClientOnly === 'function') {
+        return schema.isClientOnly(entity);
+    }
+    return !!schema.isClientOnly;
+}
+exports.isClientOnly = isClientOnly;
+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) {
+        result.push(value);
+    });
+    return result;
+}
+exports.getId = getId;
+function isNew(entity, schema, clientIdsMap) {
+    var 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);
+    if (isClientOnly(fullEntity, schema)) {
+        return false;
+    }
+    return (0, utils_1.objectKeys)(entity).some(function (fieldName) {
+        var 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);
+                if (parentEntity) {
+                    dependenciesPatch[actualTableName] = dependenciesPatch[actualTableName] || [];
+                    dependenciesPatch[actualTableName].push(idFields);
+                }
+            });
+        });
+    });
+    return dependenciesPatch;
+}
+exports.getParentEntities = getParentEntities;
+function getEntityParentDependencies(entity, entityName, tables) {
+    var _a;
+    var patch = (_a = {}, _a[entityName] = [entity], _a);
+    var resultPatches = [];
+    while (true) {
+        var parents = getParentEntities(patch, tables);
+        if (isPatchBlank(parents)) {
+            break;
+        }
+        resultPatches.push(parents);
+        patch = parents;
+    }
+    var result = unionPatches((0, tslib_1.__spreadArray)([patch], resultPatches, true));
+    result = mergeEntityPatches(tables, result);
+    return result;
+}
+exports.getEntityParentDependencies = getEntityParentDependencies;
 
 
 /***/ }),
@@ -1383,27 +1383,27 @@ exports.getEntityParentDependencies = getEntityParentDependencies;
 /***/ (function(module, exports, __webpack_require__) {
 
 "use strict";
-
-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");
-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); }, []);
-    subscription.update(params);
-    (0, react_1.useEffect)(function () {
-        return function () { return subscription.unsubscribe(); };
-    }, []);
-    return subscription.currentValue;
-}
-exports.useDbView = useDbView;
+
+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");
+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); }, []);
+    subscription.update(params);
+    (0, react_1.useEffect)(function () {
+        return function () { return subscription.unsubscribe(); };
+    }, []);
+    return subscription.currentValue;
+}
+exports.useDbView = useDbView;
 
 
 /***/ }),
@@ -1416,190 +1416,190 @@ exports.useDbView = useDbView;
 /***/ (function(module, exports, __webpack_require__) {
 
 "use strict";
-
-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;
-function getTempId() {
-    return --lastTempId;
-}
-exports.getTempId = getTempId;
-function isTempId(val) {
-    return typeof val === 'number' && val < 0;
-}
-exports.isTempId = isTempId;
-var TempIdMap = /** @class */ (function () {
-    function TempIdMap(db) {
-        var _this = this;
-        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);
-            if (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);
-            // 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);
-                if (found) {
-                    return found;
-                }
-                else {
-                    return id;
-                }
-            };
-            for (var n = 0; n < keys.length; n++) {
-                var key = keys[n];
-                var condition = filter[key];
-                if (condition != null && typeof condition === "object") {
-                    condition = (0, tslib_1.__assign)({}, condition);
-                    if ('in' in condition && Array.isArray(condition.in) && condition.in.length) {
-                        condition.in = condition.in.map(clientToServer);
-                    }
-                }
-                else {
-                    condition = clientToServer(condition);
-                }
-                filter[key] = condition;
-            }
-            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)); });
-            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];
-                if (filter(fieldSchema, fieldName)) {
-                    return { name: fieldName, schema: fieldSchema };
-                }
-            })
-                .filter(function (f) { return !!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];
-                    callback(field.name, field.schema, fieldValue, entityPatch, tableName);
-                }
-            });
-        });
-    };
-    TempIdMap.prototype.getServerToClientMap = function (tableName) {
-        var existing = this.serverToClientIds.get(tableName);
-        if (existing) {
-            return existing;
-        }
-        else {
-            var newMap = new Map();
-            this.serverToClientIds.set(tableName, newMap);
-            return newMap;
-        }
-    };
-    TempIdMap.prototype.serverToClientPatch = function (patch) {
-        var _this = this;
-        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);
-            if (!clientId) {
-                clientId = getTempId();
-                _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';
-            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);
-                if (!clientId) {
-                    clientId = getTempId();
-                    _this.clientToServerIds.set(clientId, fieldValue);
-                    _this.getServerToClientMap(fkTableName).set(fieldValue, clientId);
-                }
-                fieldValue = clientId;
-            }
-            if (!isUndefined && fieldSchema.toClient) {
-                fieldValue = fieldSchema.toClient(fieldValue);
-            }
-            if (!isUndefined) {
-                entityPatch[fieldName] = fieldValue;
-            }
-        });
-        return patch;
-    };
-    TempIdMap.prototype.clientToServerPatch = function (patch) {
-        var _this = this;
-        patch = this.copyPatch(patch);
-        this.mapFields(patch, function (f) { return f.isGenerated || !!f.fk; }, function (fieldName, fieldSchema, fieldValue, entityPatch, tableName) {
-            if (fieldValue != null) {
-                var 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) {
-            entityPatch[fieldName] = fieldSchema.toServer(entityPatch[fieldName]);
-        });
-        this.mapFields(patch, function (meta) { return meta.isClientOnly || meta.isReadOnly; }, function (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];
-                if (tablePatch) {
-                    var serverToClientIds_1 = _this.getServerToClientMap(tableName);
-                    var table_1 = _this.db.tables[tableName];
-                    tablePatch.forEach(function (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);
-                        }
-                    });
-                }
-            }
-        });
-    };
-    return TempIdMap;
-}());
-exports.TempIdMap = TempIdMap;
+
+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;
+function getTempId() {
+    return --lastTempId;
+}
+exports.getTempId = getTempId;
+function isTempId(val) {
+    return typeof val === 'number' && val < 0;
+}
+exports.isTempId = isTempId;
+var TempIdMap = /** @class */ (function () {
+    function TempIdMap(db) {
+        var _this = this;
+        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);
+            if (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);
+            // 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);
+                if (found) {
+                    return found;
+                }
+                else {
+                    return id;
+                }
+            };
+            for (var n = 0; n < keys.length; n++) {
+                var key = keys[n];
+                var condition = filter[key];
+                if (condition != null && typeof condition === "object") {
+                    condition = (0, tslib_1.__assign)({}, condition);
+                    if ('in' in condition && Array.isArray(condition.in) && condition.in.length) {
+                        condition.in = condition.in.map(clientToServer);
+                    }
+                }
+                else {
+                    condition = clientToServer(condition);
+                }
+                filter[key] = condition;
+            }
+            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)); });
+            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];
+                if (filter(fieldSchema, fieldName)) {
+                    return { name: fieldName, schema: fieldSchema };
+                }
+            })
+                .filter(function (f) { return !!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];
+                    callback(field.name, field.schema, fieldValue, entityPatch, tableName);
+                }
+            });
+        });
+    };
+    TempIdMap.prototype.getServerToClientMap = function (tableName) {
+        var existing = this.serverToClientIds.get(tableName);
+        if (existing) {
+            return existing;
+        }
+        else {
+            var newMap = new Map();
+            this.serverToClientIds.set(tableName, newMap);
+            return newMap;
+        }
+    };
+    TempIdMap.prototype.serverToClientPatch = function (patch) {
+        var _this = this;
+        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);
+            if (!clientId) {
+                clientId = getTempId();
+                _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';
+            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);
+                if (!clientId) {
+                    clientId = getTempId();
+                    _this.clientToServerIds.set(clientId, fieldValue);
+                    _this.getServerToClientMap(fkTableName).set(fieldValue, clientId);
+                }
+                fieldValue = clientId;
+            }
+            if (!isUndefined && fieldSchema.toClient) {
+                fieldValue = fieldSchema.toClient(fieldValue);
+            }
+            if (!isUndefined) {
+                entityPatch[fieldName] = fieldValue;
+            }
+        });
+        return patch;
+    };
+    TempIdMap.prototype.clientToServerPatch = function (patch) {
+        var _this = this;
+        patch = this.copyPatch(patch);
+        this.mapFields(patch, function (f) { return f.isGenerated || !!f.fk; }, function (fieldName, fieldSchema, fieldValue, entityPatch, tableName) {
+            if (fieldValue != null) {
+                var 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) {
+            entityPatch[fieldName] = fieldSchema.toServer(entityPatch[fieldName]);
+        });
+        this.mapFields(patch, function (meta) { return meta.isClientOnly || meta.isReadOnly; }, function (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];
+                if (tablePatch) {
+                    var serverToClientIds_1 = _this.getServerToClientMap(tableName);
+                    var table_1 = _this.db.tables[tableName];
+                    tablePatch.forEach(function (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);
+                        }
+                    });
+                }
+            }
+        });
+    };
+    return TempIdMap;
+}());
+exports.TempIdMap = TempIdMap;
 
 
 /***/ }),
@@ -1612,14 +1612,14 @@ exports.TempIdMap = TempIdMap;
 /***/ (function(module, exports, __webpack_require__) {
 
 "use strict";
-
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DbRelationType = void 0;
-var DbRelationType;
-(function (DbRelationType) {
-    DbRelationType[DbRelationType["Aggregation"] = 0] = "Aggregation";
-    DbRelationType[DbRelationType["Association"] = 1] = "Association";
-})(DbRelationType = exports.DbRelationType || (exports.DbRelationType = {}));
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DbRelationType = void 0;
+var DbRelationType;
+(function (DbRelationType) {
+    DbRelationType[DbRelationType["Aggregation"] = 0] = "Aggregation";
+    DbRelationType[DbRelationType["Association"] = 1] = "Association";
+})(DbRelationType = exports.DbRelationType || (exports.DbRelationType = {}));
 
 
 /***/ }),
@@ -1632,46 +1632,46 @@ var DbRelationType;
 /***/ (function(module, exports, __webpack_require__) {
 
 "use strict";
-
-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"));
-// 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 false;
-    }
-    return (0, shallowequal_1.default)(prev, next);
-}
-exports.defaultCompareViewDependencies = defaultCompareViewDependencies;
-/**
- * Deep diff between two object, using lodash
- * @param  {Object} object Object compared
- * @param  {Object} base   Object to compare with
- * @return {Object}        Return a new object who represent the diff
- */
-function difference(object, base) {
-    function changes(object, base) {
-        return (0, lodash_transform_1.default)(object, function (result, value, key) {
-            if (!(0, lodash_isequal_1.default)(value, base[key])) {
-                result[key] = (typeof value === "object" && typeof base[key] === "object") ? changes(value, base[key]) : value;
-            }
-        });
-    }
-    return changes(object, base);
-}
-exports.difference = difference;
+
+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"));
+// 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 false;
+    }
+    return (0, shallowequal_1.default)(prev, next);
+}
+exports.defaultCompareViewDependencies = defaultCompareViewDependencies;
+/**
+ * Deep diff between two object, using lodash
+ * @param  {Object} object Object compared
+ * @param  {Object} base   Object to compare with
+ * @return {Object}        Return a new object who represent the diff
+ */
+function difference(object, base) {
+    function changes(object, base) {
+        return (0, lodash_transform_1.default)(object, function (result, value, key) {
+            if (!(0, lodash_isequal_1.default)(value, base[key])) {
+                result[key] = (typeof value === "object" && typeof base[key] === "object") ? changes(value, base[key]) : value;
+            }
+        });
+    }
+    return changes(object, base);
+}
+exports.difference = difference;
 
 
 /***/ }),
@@ -1683,7 +1683,7 @@ exports.difference = difference;
 /*! no static exports found */
 /***/ (function(module, exports, __webpack_require__) {
 
-module.exports = __webpack_require__(/*! C:\Users\Aliaksei_Manetau\WebstormProjects\uui\uui-db\index.tsx */"./index.tsx");
+module.exports = __webpack_require__(/*! /Users/Aliaksei_Manetau/WebstormProjects/uui/uui-db/index.tsx */"./index.tsx");
 
 
 /***/ }),