@epam/uui-db 4.9.0 → 4.9.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 });
-const 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 });
+const tslib_1 = __webpack_require__(/*! tslib */ "../node_modules/tslib/tslib.es6.js");
+(0, tslib_1.__exportStar)(__webpack_require__(/*! ./src */ "./src/index.ts"), exports);
 
 
 /***/ }),
@@ -397,80 +397,80 @@ const tslib_1 = __webpack_require__(/*! tslib */ "../node_modules/tslib/tslib.es
 /***/ (function(module, exports, __webpack_require__) {
 
 "use strict";
-
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Db = void 0;
-const tslib_1 = __webpack_require__(/*! tslib */ "../node_modules/tslib/tslib.es6.js");
-const utils_1 = __webpack_require__(/*! ./utils */ "./src/utils.ts");
-const lodash_isequal_1 = (0, tslib_1.__importDefault)(__webpack_require__(/*! lodash.isequal */ "lodash.isequal"));
-class Db {
-    constructor(tables, reusedCache) {
-        this.tables = tables;
-        this.viewCache = new Map();
-        /* Views (cached db projections) */
-        this.valueAbsent = Symbol("ValueAbsent");
-        if (reusedCache) {
-            this.viewCache = new Map(reusedCache);
-        }
-        else {
-            this.viewCache = new Map();
-        }
-    }
-    update(mutate) {
-        const clone = new this.constructor(this.tables, this.viewCache);
-        clone.tables = Object.assign({}, this.tables);
-        mutate(clone);
-        return clone;
-    }
-    with(patch) {
-        return this.update(db => {
-            (0, utils_1.objectKeys)(db.tables).forEach(entityName => {
-                if (patch[entityName]) {
-                    db.tables[entityName] = db.tables[entityName].with(patch[entityName]);
-                }
-            });
-        });
-    }
-    runView(view, params) {
-        let cache = this.viewCache.get(view);
-        if (!cache) {
-            cache = new Map();
-            this.viewCache.set(view, cache);
-        }
-        const key = view.getKey ? view.getKey(params) : JSON.stringify(params);
-        let cacheItem = cache.get(key);
-        if (!cacheItem) {
-            cacheItem = {
-                dependencies: this.valueAbsent,
-                currentValue: this.valueAbsent,
-                computedOnDb: this.valueAbsent,
-            };
-            cache.set(key, cacheItem);
-        }
-        let shouldUpdate = this !== cacheItem.computedOnDb;
-        let dependencies = this.valueAbsent;
-        if (view.getDependencies) {
-            const compare = view.compareDependencies || utils_1.defaultCompareViewDependencies;
-            dependencies = view.getDependencies(this, params);
-            shouldUpdate = !compare(cacheItem.dependencies, dependencies);
-        }
-        let previousValue = cacheItem.currentValue;
-        if (shouldUpdate) {
-            cacheItem.dependencies = dependencies;
-            let newValue = view.compute(this, params, dependencies);
-            cacheItem.computedOnDb = this;
-            let 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;
-    }
-}
-exports.Db = Db;
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Db = void 0;
+const tslib_1 = __webpack_require__(/*! tslib */ "../node_modules/tslib/tslib.es6.js");
+const utils_1 = __webpack_require__(/*! ./utils */ "./src/utils.ts");
+const lodash_isequal_1 = (0, tslib_1.__importDefault)(__webpack_require__(/*! lodash.isequal */ "lodash.isequal"));
+class Db {
+    constructor(tables, reusedCache) {
+        this.tables = tables;
+        this.viewCache = new Map();
+        /* Views (cached db projections) */
+        this.valueAbsent = Symbol("ValueAbsent");
+        if (reusedCache) {
+            this.viewCache = new Map(reusedCache);
+        }
+        else {
+            this.viewCache = new Map();
+        }
+    }
+    update(mutate) {
+        const clone = new this.constructor(this.tables, this.viewCache);
+        clone.tables = Object.assign({}, this.tables);
+        mutate(clone);
+        return clone;
+    }
+    with(patch) {
+        return this.update(db => {
+            (0, utils_1.objectKeys)(db.tables).forEach(entityName => {
+                if (patch[entityName]) {
+                    db.tables[entityName] = db.tables[entityName].with(patch[entityName]);
+                }
+            });
+        });
+    }
+    runView(view, params) {
+        let cache = this.viewCache.get(view);
+        if (!cache) {
+            cache = new Map();
+            this.viewCache.set(view, cache);
+        }
+        const key = view.getKey ? view.getKey(params) : JSON.stringify(params);
+        let cacheItem = cache.get(key);
+        if (!cacheItem) {
+            cacheItem = {
+                dependencies: this.valueAbsent,
+                currentValue: this.valueAbsent,
+                computedOnDb: this.valueAbsent,
+            };
+            cache.set(key, cacheItem);
+        }
+        let shouldUpdate = this !== cacheItem.computedOnDb;
+        let dependencies = this.valueAbsent;
+        if (view.getDependencies) {
+            const compare = view.compareDependencies || utils_1.defaultCompareViewDependencies;
+            dependencies = view.getDependencies(this, params);
+            shouldUpdate = !compare(cacheItem.dependencies, dependencies);
+        }
+        let previousValue = cacheItem.currentValue;
+        if (shouldUpdate) {
+            cacheItem.dependencies = dependencies;
+            let newValue = view.compute(this, params, dependencies);
+            cacheItem.computedOnDb = this;
+            let 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;
+    }
+}
+exports.Db = Db;
 
 
 /***/ }),
@@ -483,197 +483,197 @@ exports.Db = Db;
 /***/ (function(module, exports, __webpack_require__) {
 
 "use strict";
-
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DbRef = void 0;
-const tslib_1 = __webpack_require__(/*! tslib */ "../node_modules/tslib/tslib.es6.js");
-const patchHelpers_1 = __webpack_require__(/*! ./patchHelpers */ "./src/patchHelpers.ts");
-const tempIds_1 = __webpack_require__(/*! ./tempIds */ "./src/tempIds.tsx");
-const utils_1 = __webpack_require__(/*! ./utils */ "./src/utils.ts");
-const lodash_isempty_1 = (0, tslib_1.__importDefault)(__webpack_require__(/*! lodash.isempty */ "lodash.isempty"));
-const Loader_1 = __webpack_require__(/*! ./Loader */ "./src/Loader.ts");
-const uui_core_1 = __webpack_require__(/*! @epam/uui-core */ "@epam/uui-core");
-const SimpleLoadingTracker_1 = __webpack_require__(/*! ./SimpleLoadingTracker */ "./src/SimpleLoadingTracker.ts");
-const ListLoadingTracker_1 = __webpack_require__(/*! ./ListLoadingTracker */ "./src/ListLoadingTracker.ts");
-class DbRef {
-    constructor(blank) {
-        this.blank = blank;
-        this.log = [];
-        this.autoSave = true;
-        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)(() => (0, tslib_1.__awaiter)(this, void 0, void 0, function* () {
-            const cumulativePatch = this.makeCumulativePatch();
-            const lastLogEntry = this.log.length;
-            if ((0, lodash_isempty_1.default)(cumulativePatch)) {
-                return;
-            }
-            try {
-                const response = yield this.savePatch(cumulativePatch);
-                this.applyResponse(response, lastLogEntry);
-                this.update();
-            }
-            catch (error) {
-                this.saveError(cumulativePatch, error);
-                this.update();
-                throw error;
-            }
-        }));
-        this.handleBeforeUnload = (e) => {
-            if (this.enqueueSave.isBusy) {
-                e.returnValue = false;
-                return false;
-            }
-        };
-        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. */
-    save() {
-        return this.enqueueSave();
-    }
-    getAutoSave() {
-        return this.autoSave;
-    }
-    setAutoSave(val) {
-        if (this.autoSave != val) {
-            this.autoSave = val;
-            this.autoSave && this.enqueueSave();
-            this.update();
-        }
-    }
-    revert() {
-        this.db = this.base;
-        this.log = this.log.slice(0, this.savedPoint);
-        this.update();
-    }
-    /** Concrete DbRef instances should override and implement their save logic in this method */
-    savePatch(patch) {
-        return Promise.resolve({ submit: {} });
-    }
-    /* Db Update logic */
-    commit(patch) {
-        const dbBeforeUpdate = this.db.with(patch);
-        patch = this.beforeUpdate(patch, dbBeforeUpdate.tables, this.db.tables);
-        patch = (0, patchHelpers_1.mergeEntityPatches)(this.db.tables, patch);
-        this.log.push({ patch });
-        this.db = this.db.with(patch);
-        this.autoSave && this.enqueueSave(null, { throttleMs: this.throttleSaveMs });
-        this.update();
-    }
-    beforeUpdate(patch, tables, prevTables) {
-        let patchAndDependencies = {};
-        (0, utils_1.objectKeys)(tables).filter(entityName => patch[entityName] && !tables[entityName].schema.beforeUpdate).forEach(entityName => {
-            patchAndDependencies[entityName] = patch[entityName];
-        });
-        (0, utils_1.objectKeys)(tables).filter(entityName => patch[entityName] && tables[entityName].schema.beforeUpdate).forEach(entityName => {
-            const schema = tables[entityName].schema;
-            const { beforeUpdate } = schema;
-            let context = {
-                clientIdsMap: this.tempIdMap,
-                schema,
-                tables,
-                prevTables,
-            };
-            const results = patch[entityName].map(e => beforeUpdate(e, context));
-            const updatedPatch = { [entityName]: results.map(result => result.entity) };
-            const dependentEntityPatchesForUpdate = (0, patchHelpers_1.unionPatches)(results.filter(result => result.dependentEntities).map(result => result.dependentEntities));
-            const dependentEntityPatches = this.beforeUpdate(dependentEntityPatchesForUpdate, tables, prevTables);
-            patchAndDependencies = (0, patchHelpers_1.mergeEntityPatches)(tables, (0, patchHelpers_1.unionPatches)([patchAndDependencies, updatedPatch, dependentEntityPatches]));
-        });
-        return patchAndDependencies;
-    }
-    commitFetch(patch) {
-        patch = this.tempIdMap.serverToClientPatch(patch);
-        this.rebase(this.base.with(patch));
-        this.update();
-    }
-    rebase(newBase) {
-        this.base = newBase;
-        this.db = newBase;
-        for (let n = this.savedPoint; n < this.log.length; n++) {
-            this.db = this.db.with(this.log[n].patch);
-        }
-    }
-    makeCumulativePatch() {
-        const lastLogEntry = this.log.length;
-        const logEntriesToSave = this.log.slice(this.savedPoint, lastLogEntry);
-        let cumulativePatch = (0, patchHelpers_1.makeCumulativePatch)(this.db, logEntriesToSave.map(t => t.patch), this.tempIdMap);
-        cumulativePatch = this.tempIdMap.clientToServerPatch(cumulativePatch);
-        return cumulativePatch;
-    }
-    applyResponse(response, newSavedPoint) {
-        this.tempIdMap.appendServerMapping(response);
-        let serverPatch = (0, patchHelpers_1.flattenResponse)(response.submit, this.db.tables);
-        serverPatch = (0, patchHelpers_1.mergeEntityPatches)(this.db.tables, serverPatch);
-        this.savedPoint = newSavedPoint;
-        this.base = this.db;
-        this.commitFetch(serverPatch);
-    }
-    subscribe(view, params, onUpdate) {
-        const id = this.lastSubscriptionId++;
-        const subscription = {
-            update: (params) => {
-                subscription.currentParams = params;
-                subscription.currentValue = this.db.runView(view, params);
-                return subscription.currentValue;
-            },
-            currentParams: null,
-            currentValue: null,
-            onUpdate,
-            unsubscribe: () => { this.subscriptions.delete(id); },
-        };
-        subscription.update(params);
-        this.subscriptions.set(id, subscription);
-        return subscription;
-    }
-    onUpdate(handler) {
-        this.subscribe({
-            compute: db => db,
-            compareResults: (a, b) => a === b,
-        }, null, handler);
-    }
-    update() {
-        this.subscriptions.forEach(subscription => {
-            const previousValue = subscription.currentValue;
-            subscription.update(subscription.currentParams);
-            if (subscription.currentValue !== previousValue && subscription.onUpdate) {
-                subscription.onUpdate(subscription.currentValue);
-            }
-        });
-    }
-    onSaveError(handler) {
-        this.saveErrorHandlers.push(handler);
-    }
-    saveError(request, error) {
-        this.saveErrorHandlers.forEach(handler => handler(request, error));
-    }
-    makeLoader(options) {
-        const loader = new Loader_1.Loader(this, () => new SimpleLoadingTracker_1.SimpleLoadingTracker(), options);
-        this.loaders.push(loader);
-        return loader;
-    }
-    makeListLoader(options) {
-        const loader = new Loader_1.Loader(this, () => new ListLoadingTracker_1.ListLoadingTracker(), options);
-        this.loaders.push(loader);
-        return loader;
-    }
-    reload() {
-        this.loaders = [];
-    }
-}
-exports.DbRef = DbRef;
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DbRef = void 0;
+const tslib_1 = __webpack_require__(/*! tslib */ "../node_modules/tslib/tslib.es6.js");
+const patchHelpers_1 = __webpack_require__(/*! ./patchHelpers */ "./src/patchHelpers.ts");
+const tempIds_1 = __webpack_require__(/*! ./tempIds */ "./src/tempIds.tsx");
+const utils_1 = __webpack_require__(/*! ./utils */ "./src/utils.ts");
+const lodash_isempty_1 = (0, tslib_1.__importDefault)(__webpack_require__(/*! lodash.isempty */ "lodash.isempty"));
+const Loader_1 = __webpack_require__(/*! ./Loader */ "./src/Loader.ts");
+const uui_core_1 = __webpack_require__(/*! @epam/uui-core */ "@epam/uui-core");
+const SimpleLoadingTracker_1 = __webpack_require__(/*! ./SimpleLoadingTracker */ "./src/SimpleLoadingTracker.ts");
+const ListLoadingTracker_1 = __webpack_require__(/*! ./ListLoadingTracker */ "./src/ListLoadingTracker.ts");
+class DbRef {
+    constructor(blank) {
+        this.blank = blank;
+        this.log = [];
+        this.autoSave = true;
+        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)(() => (0, tslib_1.__awaiter)(this, void 0, void 0, function* () {
+            const cumulativePatch = this.makeCumulativePatch();
+            const lastLogEntry = this.log.length;
+            if ((0, lodash_isempty_1.default)(cumulativePatch)) {
+                return;
+            }
+            try {
+                const response = yield this.savePatch(cumulativePatch);
+                this.applyResponse(response, lastLogEntry);
+                this.update();
+            }
+            catch (error) {
+                this.saveError(cumulativePatch, error);
+                this.update();
+                throw error;
+            }
+        }));
+        this.handleBeforeUnload = (e) => {
+            if (this.enqueueSave.isBusy) {
+                e.returnValue = false;
+                return false;
+            }
+        };
+        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. */
+    save() {
+        return this.enqueueSave();
+    }
+    getAutoSave() {
+        return this.autoSave;
+    }
+    setAutoSave(val) {
+        if (this.autoSave != val) {
+            this.autoSave = val;
+            this.autoSave && this.enqueueSave();
+            this.update();
+        }
+    }
+    revert() {
+        this.db = this.base;
+        this.log = this.log.slice(0, this.savedPoint);
+        this.update();
+    }
+    /** Concrete DbRef instances should override and implement their save logic in this method */
+    savePatch(patch) {
+        return Promise.resolve({ submit: {} });
+    }
+    /* Db Update logic */
+    commit(patch) {
+        const dbBeforeUpdate = this.db.with(patch);
+        patch = this.beforeUpdate(patch, dbBeforeUpdate.tables, this.db.tables);
+        patch = (0, patchHelpers_1.mergeEntityPatches)(this.db.tables, patch);
+        this.log.push({ patch });
+        this.db = this.db.with(patch);
+        this.autoSave && this.enqueueSave(null, { throttleMs: this.throttleSaveMs });
+        this.update();
+    }
+    beforeUpdate(patch, tables, prevTables) {
+        let patchAndDependencies = {};
+        (0, utils_1.objectKeys)(tables).filter(entityName => patch[entityName] && !tables[entityName].schema.beforeUpdate).forEach(entityName => {
+            patchAndDependencies[entityName] = patch[entityName];
+        });
+        (0, utils_1.objectKeys)(tables).filter(entityName => patch[entityName] && tables[entityName].schema.beforeUpdate).forEach(entityName => {
+            const schema = tables[entityName].schema;
+            const { beforeUpdate } = schema;
+            let context = {
+                clientIdsMap: this.tempIdMap,
+                schema,
+                tables,
+                prevTables,
+            };
+            const results = patch[entityName].map(e => beforeUpdate(e, context));
+            const updatedPatch = { [entityName]: results.map(result => result.entity) };
+            const dependentEntityPatchesForUpdate = (0, patchHelpers_1.unionPatches)(results.filter(result => result.dependentEntities).map(result => result.dependentEntities));
+            const dependentEntityPatches = this.beforeUpdate(dependentEntityPatchesForUpdate, tables, prevTables);
+            patchAndDependencies = (0, patchHelpers_1.mergeEntityPatches)(tables, (0, patchHelpers_1.unionPatches)([patchAndDependencies, updatedPatch, dependentEntityPatches]));
+        });
+        return patchAndDependencies;
+    }
+    commitFetch(patch) {
+        patch = this.tempIdMap.serverToClientPatch(patch);
+        this.rebase(this.base.with(patch));
+        this.update();
+    }
+    rebase(newBase) {
+        this.base = newBase;
+        this.db = newBase;
+        for (let n = this.savedPoint; n < this.log.length; n++) {
+            this.db = this.db.with(this.log[n].patch);
+        }
+    }
+    makeCumulativePatch() {
+        const lastLogEntry = this.log.length;
+        const logEntriesToSave = this.log.slice(this.savedPoint, lastLogEntry);
+        let cumulativePatch = (0, patchHelpers_1.makeCumulativePatch)(this.db, logEntriesToSave.map(t => t.patch), this.tempIdMap);
+        cumulativePatch = this.tempIdMap.clientToServerPatch(cumulativePatch);
+        return cumulativePatch;
+    }
+    applyResponse(response, newSavedPoint) {
+        this.tempIdMap.appendServerMapping(response);
+        let serverPatch = (0, patchHelpers_1.flattenResponse)(response.submit, this.db.tables);
+        serverPatch = (0, patchHelpers_1.mergeEntityPatches)(this.db.tables, serverPatch);
+        this.savedPoint = newSavedPoint;
+        this.base = this.db;
+        this.commitFetch(serverPatch);
+    }
+    subscribe(view, params, onUpdate) {
+        const id = this.lastSubscriptionId++;
+        const subscription = {
+            update: (params) => {
+                subscription.currentParams = params;
+                subscription.currentValue = this.db.runView(view, params);
+                return subscription.currentValue;
+            },
+            currentParams: null,
+            currentValue: null,
+            onUpdate,
+            unsubscribe: () => { this.subscriptions.delete(id); },
+        };
+        subscription.update(params);
+        this.subscriptions.set(id, subscription);
+        return subscription;
+    }
+    onUpdate(handler) {
+        this.subscribe({
+            compute: db => db,
+            compareResults: (a, b) => a === b,
+        }, null, handler);
+    }
+    update() {
+        this.subscriptions.forEach(subscription => {
+            const previousValue = subscription.currentValue;
+            subscription.update(subscription.currentParams);
+            if (subscription.currentValue !== previousValue && subscription.onUpdate) {
+                subscription.onUpdate(subscription.currentValue);
+            }
+        });
+    }
+    onSaveError(handler) {
+        this.saveErrorHandlers.push(handler);
+    }
+    saveError(request, error) {
+        this.saveErrorHandlers.forEach(handler => handler(request, error));
+    }
+    makeLoader(options) {
+        const loader = new Loader_1.Loader(this, () => new SimpleLoadingTracker_1.SimpleLoadingTracker(), options);
+        this.loaders.push(loader);
+        return loader;
+    }
+    makeListLoader(options) {
+        const loader = new Loader_1.Loader(this, () => new ListLoadingTracker_1.ListLoadingTracker(), options);
+        this.loaders.push(loader);
+        return loader;
+    }
+    reload() {
+        this.loaders = [];
+    }
+}
+exports.DbRef = DbRef;
 
 
 /***/ }),
@@ -686,211 +686,211 @@ exports.DbRef = DbRef;
 /***/ (function(module, exports, __webpack_require__) {
 
 "use strict";
-
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DbTable = void 0;
-const tslib_1 = __webpack_require__(/*! tslib */ "../node_modules/tslib/tslib.es6.js");
-const I = (0, tslib_1.__importStar)(__webpack_require__(/*! immutable */ "immutable"));
-const uui_core_1 = __webpack_require__(/*! @epam/uui-core */ "@epam/uui-core");
-const immutable_1 = __webpack_require__(/*! immutable */ "immutable");
-class DbTable {
-    constructor(schema, state, q) {
-        this.schema = schema;
-        this.state = state;
-        this.q = q;
-        if (!state) {
-            const indexes = (schema.indexes || []).map(indexDef => {
-                return {
-                    field: indexDef,
-                    map: I.Map(),
-                };
-            });
-            this.state = { pk: I.Map(), indexes };
-        }
-        if (!q) {
-            this.q = {};
-        }
-    }
-    keyToImmutable(id) {
-        if (Array.isArray(id)) {
-            return I.List(id);
-        }
-        else {
-            return id;
-        }
-    }
-    byId(id) {
-        return this.state.pk.get(this.keyToImmutable(id));
-    }
-    getId(entity) {
-        if (Array.isArray(this.schema.primaryKey)) {
-            return this.schema.primaryKey.map((key) => entity[key]);
-        }
-        return entity[this.schema.primaryKey];
-    }
-    update(mutate) {
-        const clone = new this.constructor(this.schema, this.state, this.q);
-        mutate(clone);
-        return clone;
-    }
-    /* Mutation */
-    with(patch) {
-        const updates = patch.map(entityPatch => {
-            const id = this.getId(entityPatch);
-            const immId = this.keyToImmutable(id);
-            const existing = this.state.pk.get(immId);
-            let isDeleted = false;
-            let updated = entityPatch;
-            if (existing) {
-                updated = Object.assign(Object.assign({}, existing), entityPatch);
-                if (this.schema.deleteFlag) {
-                    isDeleted = updated[this.schema.deleteFlag] === true;
-                }
-            }
-            return { id, immId, patch: entityPatch, existing, updated, isNew: !existing, isDeleted };
-        });
-        const idVal = immutable_1.Seq.Keyed(updates.map(entity => [entity.immId, entity.updated]));
-        let newPk = this.state.pk.merge(idVal);
-        // TBD: replace with deleteAll after migrating to immutable 4
-        updates.filter(u => u.isDeleted).forEach(u => {
-            newPk = newPk.delete(u.immId);
-        });
-        const newIndexes = this.state.indexes.map(index => {
-            let newMap = index.map;
-            for (let n = 0; n < updates.length; n++) {
-                let update = updates[n];
-                const newKey = update.updated[index.field];
-                if (update.existing) {
-                    const oldKey = update.existing[index.field];
-                    if (oldKey !== newKey || update.isDeleted) {
-                        newMap = newMap.update(oldKey, set => set.remove(update.immId));
-                    }
-                }
-                if (!update.isDeleted) {
-                    newMap = newMap.update(newKey, I.Set(), set => set.add(update.immId));
-                }
-            }
-            return Object.assign(Object.assign({}, index), { map: newMap });
-        });
-        const newState = { pk: newPk, indexes: newIndexes };
-        return this.update(t => t.state = newState);
-    }
-    /* Query */
-    find(filter) {
-        return this.update(t => t.q = Object.assign(Object.assign({}, t.q), { filter: Object.assign(Object.assign({}, this.q.filter), filter) }));
-    }
-    order(order) {
-        return this.update(t => t.q = Object.assign(Object.assign({}, t.q), { sorting: order }));
-    }
-    orderBy(field, direction = 'asc') {
-        return this.update(t => t.q = Object.assign(Object.assign({}, t.q), { sorting: [{ field, direction }] }));
-    }
-    thenBy(field, direction) {
-        return this.update(t => t.q = Object.assign(Object.assign({}, t.q), { sorting: [...t.q.sorting, { field, direction }] }));
-    }
-    search(text) {
-        if (!this.schema.searchBy) {
-            throw new Error(`Can't search in the ${this.schema.typeName} table - searchBy is not defined in the schema.`);
-        }
-        return this.update(t => t.q = Object.assign(Object.assign({}, t.q), { search: text }));
-    }
-    /* Materializing */
-    range(from, count) {
-        return this.runQuery(Object.assign(Object.assign({}, this.q), { range: { from, count } }));
-    }
-    count() {
-        return this.runQuery(this.q).length;
-    }
-    one() {
-        return this.runQuery(this.q)[0] || null;
-    }
-    toArray() {
-        return this.runQuery(this.q);
-    }
-    map(fn) {
-        return this.toArray().map(fn);
-    }
-    /* Query implementation */
-    runQuery(q) {
-        let result = null;
-        let filter = q.filter;
-        if (filter) {
-            let indexes = this.state.indexes;
-            // Try to use indexes to fulfill filter conditions
-            for (let n = 0; n < indexes.length; n++) {
-                const index = indexes[n];
-                if (index.field in filter) {
-                    const _a = filter, _b = index.field, condition = _a[_b], rest = (0, tslib_1.__rest)(_a, [typeof _b === "symbol" ? _b : _b + ""]);
-                    let conditionValues = null;
-                    if (condition != null && typeof condition === "object") {
-                        // Attempt to use index for 'in' and 'isNull' criteria.
-                        // We need to be very conservative here, indexed field should work the same way as getPatternPredicate. So
-                        // - it's better to leave corner cases to getPatternPredicate
-                        const _c = condition, { in: inCriteria, isNull: nullCriteria } = _c, 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 (let i = 0; i < conditionValues.length; i++) {
-                            const idsSet = index.map.get(conditionValues[i]);
-                            if (idsSet) {
-                                const idsArray = idsSet.toArray();
-                                for (let j = 0; j < idsArray.length; j++) {
-                                    const 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) {
-            let predicate = (0, uui_core_1.getFilterPredicate)(q.filter);
-            result = result.filter(predicate);
-        }
-        if (q.search) {
-            let searchFilter = (0, uui_core_1.getSearchFilter)(q.search);
-            result = result.filter(item => searchFilter(this.schema.searchBy.map(field => item[field])));
-        }
-        if (q.sorting) {
-            let comparer = (0, uui_core_1.getOrderComparer)(q.sorting);
-            result = result.sort(comparer);
-        }
-        if (q.range) {
-            result = result.slice(q.range.from, q.range.from + q.range.count);
-        }
-        return result;
-    }
-}
-exports.DbTable = DbTable;
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DbTable = void 0;
+const tslib_1 = __webpack_require__(/*! tslib */ "../node_modules/tslib/tslib.es6.js");
+const I = (0, tslib_1.__importStar)(__webpack_require__(/*! immutable */ "immutable"));
+const uui_core_1 = __webpack_require__(/*! @epam/uui-core */ "@epam/uui-core");
+const immutable_1 = __webpack_require__(/*! immutable */ "immutable");
+class DbTable {
+    constructor(schema, state, q) {
+        this.schema = schema;
+        this.state = state;
+        this.q = q;
+        if (!state) {
+            const indexes = (schema.indexes || []).map(indexDef => {
+                return {
+                    field: indexDef,
+                    map: I.Map(),
+                };
+            });
+            this.state = { pk: I.Map(), indexes };
+        }
+        if (!q) {
+            this.q = {};
+        }
+    }
+    keyToImmutable(id) {
+        if (Array.isArray(id)) {
+            return I.List(id);
+        }
+        else {
+            return id;
+        }
+    }
+    byId(id) {
+        return this.state.pk.get(this.keyToImmutable(id));
+    }
+    getId(entity) {
+        if (Array.isArray(this.schema.primaryKey)) {
+            return this.schema.primaryKey.map((key) => entity[key]);
+        }
+        return entity[this.schema.primaryKey];
+    }
+    update(mutate) {
+        const clone = new this.constructor(this.schema, this.state, this.q);
+        mutate(clone);
+        return clone;
+    }
+    /* Mutation */
+    with(patch) {
+        const updates = patch.map(entityPatch => {
+            const id = this.getId(entityPatch);
+            const immId = this.keyToImmutable(id);
+            const existing = this.state.pk.get(immId);
+            let isDeleted = false;
+            let updated = entityPatch;
+            if (existing) {
+                updated = Object.assign(Object.assign({}, existing), entityPatch);
+                if (this.schema.deleteFlag) {
+                    isDeleted = updated[this.schema.deleteFlag] === true;
+                }
+            }
+            return { id, immId, patch: entityPatch, existing, updated, isNew: !existing, isDeleted };
+        });
+        const idVal = immutable_1.Seq.Keyed(updates.map(entity => [entity.immId, entity.updated]));
+        let newPk = this.state.pk.merge(idVal);
+        // TBD: replace with deleteAll after migrating to immutable 4
+        updates.filter(u => u.isDeleted).forEach(u => {
+            newPk = newPk.delete(u.immId);
+        });
+        const newIndexes = this.state.indexes.map(index => {
+            let newMap = index.map;
+            for (let n = 0; n < updates.length; n++) {
+                let update = updates[n];
+                const newKey = update.updated[index.field];
+                if (update.existing) {
+                    const oldKey = update.existing[index.field];
+                    if (oldKey !== newKey || update.isDeleted) {
+                        newMap = newMap.update(oldKey, set => set.remove(update.immId));
+                    }
+                }
+                if (!update.isDeleted) {
+                    newMap = newMap.update(newKey, I.Set(), set => set.add(update.immId));
+                }
+            }
+            return Object.assign(Object.assign({}, index), { map: newMap });
+        });
+        const newState = { pk: newPk, indexes: newIndexes };
+        return this.update(t => t.state = newState);
+    }
+    /* Query */
+    find(filter) {
+        return this.update(t => t.q = Object.assign(Object.assign({}, t.q), { filter: Object.assign(Object.assign({}, this.q.filter), filter) }));
+    }
+    order(order) {
+        return this.update(t => t.q = Object.assign(Object.assign({}, t.q), { sorting: order }));
+    }
+    orderBy(field, direction = 'asc') {
+        return this.update(t => t.q = Object.assign(Object.assign({}, t.q), { sorting: [{ field, direction }] }));
+    }
+    thenBy(field, direction) {
+        return this.update(t => t.q = Object.assign(Object.assign({}, t.q), { sorting: [...t.q.sorting, { field, direction }] }));
+    }
+    search(text) {
+        if (!this.schema.searchBy) {
+            throw new Error(`Can't search in the ${this.schema.typeName} table - searchBy is not defined in the schema.`);
+        }
+        return this.update(t => t.q = Object.assign(Object.assign({}, t.q), { search: text }));
+    }
+    /* Materializing */
+    range(from, count) {
+        return this.runQuery(Object.assign(Object.assign({}, this.q), { range: { from, count } }));
+    }
+    count() {
+        return this.runQuery(this.q).length;
+    }
+    one() {
+        return this.runQuery(this.q)[0] || null;
+    }
+    toArray() {
+        return this.runQuery(this.q);
+    }
+    map(fn) {
+        return this.toArray().map(fn);
+    }
+    /* Query implementation */
+    runQuery(q) {
+        let result = null;
+        let filter = q.filter;
+        if (filter) {
+            let indexes = this.state.indexes;
+            // Try to use indexes to fulfill filter conditions
+            for (let n = 0; n < indexes.length; n++) {
+                const index = indexes[n];
+                if (index.field in filter) {
+                    const _a = filter, _b = index.field, condition = _a[_b], rest = (0, tslib_1.__rest)(_a, [typeof _b === "symbol" ? _b : _b + ""]);
+                    let conditionValues = null;
+                    if (condition != null && typeof condition === "object") {
+                        // Attempt to use index for 'in' and 'isNull' criteria.
+                        // We need to be very conservative here, indexed field should work the same way as getPatternPredicate. So
+                        // - it's better to leave corner cases to getPatternPredicate
+                        const _c = condition, { in: inCriteria, isNull: nullCriteria } = _c, 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 (let i = 0; i < conditionValues.length; i++) {
+                            const idsSet = index.map.get(conditionValues[i]);
+                            if (idsSet) {
+                                const idsArray = idsSet.toArray();
+                                for (let j = 0; j < idsArray.length; j++) {
+                                    const 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) {
+            let predicate = (0, uui_core_1.getFilterPredicate)(q.filter);
+            result = result.filter(predicate);
+        }
+        if (q.search) {
+            let searchFilter = (0, uui_core_1.getSearchFilter)(q.search);
+            result = result.filter(item => searchFilter(this.schema.searchBy.map(field => item[field])));
+        }
+        if (q.sorting) {
+            let comparer = (0, uui_core_1.getOrderComparer)(q.sorting);
+            result = result.sort(comparer);
+        }
+        if (q.range) {
+            result = result.slice(q.range.from, q.range.from + q.range.count);
+        }
+        return result;
+    }
+}
+exports.DbTable = DbTable;
 
 
 /***/ }),
@@ -903,98 +903,98 @@ exports.DbTable = DbTable;
 /***/ (function(module, exports, __webpack_require__) {
 
 "use strict";
-
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ListLoadingTracker = void 0;
-const tslib_1 = __webpack_require__(/*! tslib */ "../node_modules/tslib/tslib.es6.js");
-class ListLoadingTracker {
-    constructor(options) {
-        this.options = options;
-        this.cache = new Map();
-        this.extractList = (options === null || options === void 0 ? void 0 : options.extractList) || ((r) => r);
-    }
-    prepare(request) {
-        const { filter, sorting, search, range } = request, unknownFields = (0, tslib_1.__rest)(request, ["filter", "sorting", "search", "range"]);
-        const options = {};
-        if (filter) {
-            options.filter = filter;
-        }
-        if (sorting) {
-            options.sorting = sorting;
-        }
-        if (search) {
-            options.search = search;
-        }
-        let keyObject = Object.assign(Object.assign({}, options), unknownFields);
-        const key = JSON.stringify(keyObject);
-        let entry = this.cache.get(key);
-        if (!entry) {
-            entry = { options, count: 0, maxCount: null, isComplete: false };
-            this.cache.set(key, entry);
-        }
-        return { options, range, unknownFields, entry };
-    }
-    diff(request) {
-        const { options, range, unknownFields, entry } = this.prepare(request);
-        if (entry.isComplete) {
-            return null;
-        }
-        if (!request.range) {
-            return request;
-        }
-        else {
-            const requestedMax = request.range.from + request.range.count;
-            let missingCount = requestedMax - entry.count;
-            if (entry.maxCount) {
-                missingCount = Math.min(missingCount, entry.maxCount);
-            }
-            if (missingCount > 0) {
-                return Object.assign(Object.assign(Object.assign({}, options), unknownFields), { range: { from: entry.count, count: requestedMax - entry.count } });
-            }
-            else {
-                return null;
-            }
-        }
-    }
-    count(request) {
-        const { entry } = this.prepare(request);
-        return { knownCount: Math.max(entry.count, entry.maxCount), exactCount: entry.maxCount };
-    }
-    append(request, response) {
-        const { options, range, unknownFields, entry } = this.prepare(request);
-        if (response) {
-            const 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 {
-                const 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;
-            }
-        }
-    }
-}
-exports.ListLoadingTracker = ListLoadingTracker;
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ListLoadingTracker = void 0;
+const tslib_1 = __webpack_require__(/*! tslib */ "../node_modules/tslib/tslib.es6.js");
+class ListLoadingTracker {
+    constructor(options) {
+        this.options = options;
+        this.cache = new Map();
+        this.extractList = (options === null || options === void 0 ? void 0 : options.extractList) || ((r) => r);
+    }
+    prepare(request) {
+        const { filter, sorting, search, range } = request, unknownFields = (0, tslib_1.__rest)(request, ["filter", "sorting", "search", "range"]);
+        const options = {};
+        if (filter) {
+            options.filter = filter;
+        }
+        if (sorting) {
+            options.sorting = sorting;
+        }
+        if (search) {
+            options.search = search;
+        }
+        let keyObject = Object.assign(Object.assign({}, options), unknownFields);
+        const key = JSON.stringify(keyObject);
+        let entry = this.cache.get(key);
+        if (!entry) {
+            entry = { options, count: 0, maxCount: null, isComplete: false };
+            this.cache.set(key, entry);
+        }
+        return { options, range, unknownFields, entry };
+    }
+    diff(request) {
+        const { options, range, unknownFields, entry } = this.prepare(request);
+        if (entry.isComplete) {
+            return null;
+        }
+        if (!request.range) {
+            return request;
+        }
+        else {
+            const requestedMax = request.range.from + request.range.count;
+            let missingCount = requestedMax - entry.count;
+            if (entry.maxCount) {
+                missingCount = Math.min(missingCount, entry.maxCount);
+            }
+            if (missingCount > 0) {
+                return Object.assign(Object.assign(Object.assign({}, options), unknownFields), { range: { from: entry.count, count: requestedMax - entry.count } });
+            }
+            else {
+                return null;
+            }
+        }
+    }
+    count(request) {
+        const { entry } = this.prepare(request);
+        return { knownCount: Math.max(entry.count, entry.maxCount), exactCount: entry.maxCount };
+    }
+    append(request, response) {
+        const { options, range, unknownFields, entry } = this.prepare(request);
+        if (response) {
+            const 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 {
+                const 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;
+            }
+        }
+    }
+}
+exports.ListLoadingTracker = ListLoadingTracker;
 
 
 /***/ }),
@@ -1007,81 +1007,81 @@ exports.ListLoadingTracker = ListLoadingTracker;
 /***/ (function(module, exports, __webpack_require__) {
 
 "use strict";
-
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Loader = void 0;
-class Loader {
-    constructor(dbRef, getTracker, options) {
-        this.dbRef = dbRef;
-        this.getTracker = getTracker;
-        this.options = options;
-        this.currentRequests = new Set();
-        this.load = (inputRequest) => {
-            const result = {
-                isComplete: this.loaded.diff(inputRequest) == null,
-                isLoading: false,
-                request: inputRequest,
-                missing: this.loadedAndLoading.diff(inputRequest),
-                promise: null,
-                reload: null,
-            };
-            result.reload = () => {
-                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(() => { });
-                    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();
-    }
-    loadImpl(state) {
-        this.loadedAndLoading.append(state.missing);
-        state.isLoading = true;
-        let serverRequest = state.missing;
-        if (this.options.clientToServerRequest) {
-            serverRequest = this.options.clientToServerRequest(serverRequest);
-        }
-        state.promise = this.options.api(serverRequest).then(result => {
-            this.loaded.append(state.missing, result);
-            this.loadedAndLoading.append(state.missing, result);
-            state.missing = null;
-            state.isLoading = false;
-            state.isComplete = true;
-            state.promise = Promise.resolve();
-            const flatten = this.options.convertToPatch(result);
-            this.options.postProcess && this.options.postProcess(flatten);
-            this.dbRef.commitFetch(flatten);
-        });
-        this.currentRequests.add(state.promise);
-        state.promise.finally(() => {
-            this.currentRequests.delete(state.promise);
-        });
-        return state.promise;
-    }
-}
-exports.Loader = Loader;
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Loader = void 0;
+class Loader {
+    constructor(dbRef, getTracker, options) {
+        this.dbRef = dbRef;
+        this.getTracker = getTracker;
+        this.options = options;
+        this.currentRequests = new Set();
+        this.load = (inputRequest) => {
+            const result = {
+                isComplete: this.loaded.diff(inputRequest) == null,
+                isLoading: false,
+                request: inputRequest,
+                missing: this.loadedAndLoading.diff(inputRequest),
+                promise: null,
+                reload: null,
+            };
+            result.reload = () => {
+                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(() => { });
+                    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();
+    }
+    loadImpl(state) {
+        this.loadedAndLoading.append(state.missing);
+        state.isLoading = true;
+        let serverRequest = state.missing;
+        if (this.options.clientToServerRequest) {
+            serverRequest = this.options.clientToServerRequest(serverRequest);
+        }
+        state.promise = this.options.api(serverRequest).then(result => {
+            this.loaded.append(state.missing, result);
+            this.loadedAndLoading.append(state.missing, result);
+            state.missing = null;
+            state.isLoading = false;
+            state.isComplete = true;
+            state.promise = Promise.resolve();
+            const flatten = this.options.convertToPatch(result);
+            this.options.postProcess && this.options.postProcess(flatten);
+            this.dbRef.commitFetch(flatten);
+        });
+        this.currentRequests.add(state.promise);
+        state.promise.finally(() => {
+            this.currentRequests.delete(state.promise);
+        });
+        return state.promise;
+    }
+}
+exports.Loader = Loader;
 
 
 /***/ }),
@@ -1094,24 +1094,24 @@ exports.Loader = Loader;
 /***/ (function(module, exports, __webpack_require__) {
 
 "use strict";
-
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SimpleLoadingTracker = void 0;
-class SimpleLoadingTracker {
-    constructor() {
-        this.set = new Set();
-    }
-    getKey(request) {
-        return JSON.stringify(request);
-    }
-    diff(request) {
-        return this.set.has(this.getKey(request)) ? null : request;
-    }
-    append(request, result) {
-        this.set.add(this.getKey(request));
-    }
-}
-exports.SimpleLoadingTracker = SimpleLoadingTracker;
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SimpleLoadingTracker = void 0;
+class SimpleLoadingTracker {
+    constructor() {
+        this.set = new Set();
+    }
+    getKey(request) {
+        return JSON.stringify(request);
+    }
+    diff(request) {
+        return this.set.has(this.getKey(request)) ? null : request;
+    }
+    append(request, result) {
+        this.set.add(this.getKey(request));
+    }
+}
+exports.SimpleLoadingTracker = SimpleLoadingTracker;
 
 
 /***/ }),
@@ -1124,17 +1124,17 @@ exports.SimpleLoadingTracker = SimpleLoadingTracker;
 /***/ (function(module, exports, __webpack_require__) {
 
 "use strict";
-
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = __webpack_require__(/*! tslib */ "../node_modules/tslib/tslib.es6.js");
-(0, tslib_1.__exportStar)(__webpack_require__(/*! ./types */ "./src/types.ts"), exports);
-(0, tslib_1.__exportStar)(__webpack_require__(/*! ./Db */ "./src/Db.ts"), exports);
-(0, tslib_1.__exportStar)(__webpack_require__(/*! ./DbTable */ "./src/DbTable.ts"), exports);
-(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 });
+const tslib_1 = __webpack_require__(/*! tslib */ "../node_modules/tslib/tslib.es6.js");
+(0, tslib_1.__exportStar)(__webpack_require__(/*! ./types */ "./src/types.ts"), exports);
+(0, tslib_1.__exportStar)(__webpack_require__(/*! ./Db */ "./src/Db.ts"), exports);
+(0, tslib_1.__exportStar)(__webpack_require__(/*! ./DbTable */ "./src/DbTable.ts"), exports);
+(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);
 
 
 /***/ }),
@@ -1147,195 +1147,195 @@ const tslib_1 = __webpack_require__(/*! tslib */ "../node_modules/tslib/tslib.es
 /***/ (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;
-const tslib_1 = __webpack_require__(/*! tslib */ "../node_modules/tslib/tslib.es6.js");
-const types_1 = __webpack_require__(/*! ./types */ "./src/types.ts");
-const I = (0, tslib_1.__importStar)(__webpack_require__(/*! immutable */ "immutable"));
-const utils_1 = __webpack_require__(/*! ./utils */ "./src/utils.ts");
-const lodash_groupby_1 = (0, tslib_1.__importDefault)(__webpack_require__(/*! lodash.groupby */ "lodash.groupby"));
-const lodash_map_1 = (0, tslib_1.__importDefault)(__webpack_require__(/*! lodash.map */ "lodash.map"));
-const lodash_merge_1 = (0, tslib_1.__importDefault)(__webpack_require__(/*! lodash.merge */ "lodash.merge"));
-const lodash_countby_1 = (0, tslib_1.__importDefault)(__webpack_require__(/*! lodash.countby */ "lodash.countby"));
-const lodash_filter_1 = (0, tslib_1.__importDefault)(__webpack_require__(/*! lodash.filter */ "lodash.filter"));
-const lodash_foreach_1 = (0, tslib_1.__importDefault)(__webpack_require__(/*! lodash.foreach */ "lodash.foreach"));
-const lodash_pick_1 = (0, tslib_1.__importDefault)(__webpack_require__(/*! lodash.pick */ "lodash.pick"));
-function unionPatches(patches) {
-    const result = {};
-    patches.forEach(patch => {
-        (0, utils_1.objectKeys)(patch).forEach(tableName => {
-            result[tableName] = result[tableName] ? [...result[tableName], ...patch[tableName]] : patch[tableName];
-        });
-    });
-    return result;
-}
-exports.unionPatches = unionPatches;
-function mergeEntityPatches(tables, patch) {
-    const result = {};
-    (0, utils_1.objectKeys)(patch).forEach(key => {
-        const table = tables[key];
-        const groupedEntities = (0, lodash_groupby_1.default)(patch[key], item => table.getId(item));
-        const tablePatch = (0, lodash_map_1.default)(groupedEntities, entities => {
-            const result = (0, lodash_merge_1.default)({}, ...entities);
-            if (true) {
-                const props = (0, utils_1.objectKeys)(result).filter(prop => Object.keys((0, lodash_countby_1.default)(entities.filter(entity => entity[prop] !== undefined), entity => entity[prop])).length > 1);
-                if (props.length) {
-                    console.warn('mergeEntityPatches: Different property values found for the same entity.\nProperty names:\n', props, '\nEntities:\n', ...entities);
-                }
-            }
-            return result;
-        });
-        result[key] = tablePatch;
-    });
-    return result;
-}
-exports.mergeEntityPatches = mergeEntityPatches;
-function flattenResponseHelper(result, object, tablesByTypeName) {
-    if (Array.isArray(object)) {
-        object.forEach(item => flattenResponseHelper(result, item, tablesByTypeName));
-    }
-    else if (typeof object === 'object') {
-        const clone = {};
-        let tableKey;
-        let fields = {};
-        if ('__typename' in object) {
-            const table = tablesByTypeName[object.__typename];
-            if (table) {
-                tableKey = table.schema.tableName;
-                fields = table.schema.fields;
-            }
-        }
-        for (let key in object) {
-            const value = object[key];
-            const field = fields[key];
-            if ((field && !!field.disableFlatten)
-                || typeof value !== 'object'
-                || value === null
-                || (Array.isArray(value) && value.every(item => typeof item !== 'object'))) {
-                clone[key] = value;
-            }
-            else {
-                flattenResponseHelper(result, value, tablesByTypeName);
-            }
-        }
-        if (tableKey) {
-            result[tableKey].push(clone);
-        }
-    }
-}
-function flattenResponse(response, tables) {
-    const result = {};
-    let tablesByTypeName = {};
-    Object.values(tables).forEach(table => tablesByTypeName[table.schema.typeName] = table);
-    (0, utils_1.objectKeys)(tables).forEach(tableName => tablesByTypeName);
-    (0, utils_1.objectKeys)(tables).forEach(key => result[key] = []);
-    flattenResponseHelper(result, response, tablesByTypeName);
-    return result;
-}
-exports.flattenResponse = flattenResponse;
-function isPatchBlank(patch) {
-    return !(0, utils_1.objectKeys)(patch).some(key => patch[key].length > 0);
-}
-exports.isPatchBlank = isPatchBlank;
-/**
- * Given several patches, creates a new single patch with all fields from all entities in all patches.
- */
-function makeCumulativePatch(updatedDb, patches, clientIdsMap) {
-    const result = {};
-    (0, utils_1.objectKeys)(updatedDb.tables).forEach(entityName => {
-        const table = updatedDb.tables[entityName];
-        const schema = table.schema;
-        let ids = I.Set();
-        patches.forEach(patch => {
-            let filteredPatch = (patch[entityName] || []).filter(entity => hasServerFields(entity, schema, clientIdsMap, updatedDb.tables));
-            ids = ids.union(filteredPatch.map(e => table.getId(e)));
-        });
-        const entities = ids
-            .map(id => table.byId(id))
-            .filter(e => !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];
-    }
-    const result = [];
-    (0, lodash_foreach_1.default)((0, lodash_pick_1.default)(entity, schema.primaryKey), (value) => {
-        result.push(value);
-    });
-    return result;
-}
-exports.getId = getId;
-function isNew(entity, schema, clientIdsMap) {
-    const id = getId(entity, schema);
-    return !clientIdsMap.clientToServer(id);
-}
-exports.isNew = isNew;
-function hasServerFields(entity, schema, clientIdsMap, tables) {
-    const fullEntity = Object.assign(Object.assign({}, tables[schema.tableName].byId(entity.id) || {}), entity);
-    if (isClientOnly(fullEntity, schema)) {
-        return false;
-    }
-    return (0, utils_1.objectKeys)(entity).some(fieldName => {
-        const fieldSchema = schema.fields[fieldName];
-        return !fieldSchema || !(fieldSchema.isClientOnly || fieldSchema.isReadOnly || (fieldSchema.isGenerated && !isNew(entity, schema, clientIdsMap)));
-    });
-}
-exports.hasServerFields = hasServerFields;
-function getParentEntities(patch, tables) {
-    const dependenciesPatch = {};
-    (0, utils_1.objectKeys)(patch).forEach(key => {
-        const table = tables[key];
-        const tableSchema = table.schema;
-        const fields = (0, lodash_filter_1.default)((0, lodash_map_1.default)(tableSchema.fields, (field, name) => (Object.assign(Object.assign({}, field), { name }))), field => field.fk && field.fk.relationType == types_1.DbRelationType.Aggregation);
-        const tablePatch = patch[key];
-        fields.forEach(field => {
-            const { fk: { tableName }, name } = field;
-            tablePatch.forEach(entity => {
-                const actualTableName = (typeof tableName == 'function' ? tableName(entity) : tableName);
-                const dbEntity = table.byId(table.getId(entity));
-                const parentEntity = tables[actualTableName].byId(dbEntity[name]);
-                const idFields = (0, lodash_pick_1.default)(parentEntity, tables[actualTableName].schema.primaryKey);
-                if (parentEntity) {
-                    dependenciesPatch[actualTableName] = dependenciesPatch[actualTableName] || [];
-                    dependenciesPatch[actualTableName].push(idFields);
-                }
-            });
-        });
-    });
-    return dependenciesPatch;
-}
-exports.getParentEntities = getParentEntities;
-function getEntityParentDependencies(entity, entityName, tables) {
-    let patch = { [entityName]: [entity] };
-    const resultPatches = [];
-    while (true) {
-        let parents = getParentEntities(patch, tables);
-        if (isPatchBlank(parents)) {
-            break;
-        }
-        resultPatches.push(parents);
-        patch = parents;
-    }
-    let result = unionPatches([patch, ...resultPatches]);
-    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;
+const tslib_1 = __webpack_require__(/*! tslib */ "../node_modules/tslib/tslib.es6.js");
+const types_1 = __webpack_require__(/*! ./types */ "./src/types.ts");
+const I = (0, tslib_1.__importStar)(__webpack_require__(/*! immutable */ "immutable"));
+const utils_1 = __webpack_require__(/*! ./utils */ "./src/utils.ts");
+const lodash_groupby_1 = (0, tslib_1.__importDefault)(__webpack_require__(/*! lodash.groupby */ "lodash.groupby"));
+const lodash_map_1 = (0, tslib_1.__importDefault)(__webpack_require__(/*! lodash.map */ "lodash.map"));
+const lodash_merge_1 = (0, tslib_1.__importDefault)(__webpack_require__(/*! lodash.merge */ "lodash.merge"));
+const lodash_countby_1 = (0, tslib_1.__importDefault)(__webpack_require__(/*! lodash.countby */ "lodash.countby"));
+const lodash_filter_1 = (0, tslib_1.__importDefault)(__webpack_require__(/*! lodash.filter */ "lodash.filter"));
+const lodash_foreach_1 = (0, tslib_1.__importDefault)(__webpack_require__(/*! lodash.foreach */ "lodash.foreach"));
+const lodash_pick_1 = (0, tslib_1.__importDefault)(__webpack_require__(/*! lodash.pick */ "lodash.pick"));
+function unionPatches(patches) {
+    const result = {};
+    patches.forEach(patch => {
+        (0, utils_1.objectKeys)(patch).forEach(tableName => {
+            result[tableName] = result[tableName] ? [...result[tableName], ...patch[tableName]] : patch[tableName];
+        });
+    });
+    return result;
+}
+exports.unionPatches = unionPatches;
+function mergeEntityPatches(tables, patch) {
+    const result = {};
+    (0, utils_1.objectKeys)(patch).forEach(key => {
+        const table = tables[key];
+        const groupedEntities = (0, lodash_groupby_1.default)(patch[key], item => table.getId(item));
+        const tablePatch = (0, lodash_map_1.default)(groupedEntities, entities => {
+            const result = (0, lodash_merge_1.default)({}, ...entities);
+            if (true) {
+                const props = (0, utils_1.objectKeys)(result).filter(prop => Object.keys((0, lodash_countby_1.default)(entities.filter(entity => entity[prop] !== undefined), entity => entity[prop])).length > 1);
+                if (props.length) {
+                    console.warn('mergeEntityPatches: Different property values found for the same entity.\nProperty names:\n', props, '\nEntities:\n', ...entities);
+                }
+            }
+            return result;
+        });
+        result[key] = tablePatch;
+    });
+    return result;
+}
+exports.mergeEntityPatches = mergeEntityPatches;
+function flattenResponseHelper(result, object, tablesByTypeName) {
+    if (Array.isArray(object)) {
+        object.forEach(item => flattenResponseHelper(result, item, tablesByTypeName));
+    }
+    else if (typeof object === 'object') {
+        const clone = {};
+        let tableKey;
+        let fields = {};
+        if ('__typename' in object) {
+            const table = tablesByTypeName[object.__typename];
+            if (table) {
+                tableKey = table.schema.tableName;
+                fields = table.schema.fields;
+            }
+        }
+        for (let key in object) {
+            const value = object[key];
+            const field = fields[key];
+            if ((field && !!field.disableFlatten)
+                || typeof value !== 'object'
+                || value === null
+                || (Array.isArray(value) && value.every(item => typeof item !== 'object'))) {
+                clone[key] = value;
+            }
+            else {
+                flattenResponseHelper(result, value, tablesByTypeName);
+            }
+        }
+        if (tableKey) {
+            result[tableKey].push(clone);
+        }
+    }
+}
+function flattenResponse(response, tables) {
+    const result = {};
+    let tablesByTypeName = {};
+    Object.values(tables).forEach(table => tablesByTypeName[table.schema.typeName] = table);
+    (0, utils_1.objectKeys)(tables).forEach(tableName => tablesByTypeName);
+    (0, utils_1.objectKeys)(tables).forEach(key => result[key] = []);
+    flattenResponseHelper(result, response, tablesByTypeName);
+    return result;
+}
+exports.flattenResponse = flattenResponse;
+function isPatchBlank(patch) {
+    return !(0, utils_1.objectKeys)(patch).some(key => patch[key].length > 0);
+}
+exports.isPatchBlank = isPatchBlank;
+/**
+ * Given several patches, creates a new single patch with all fields from all entities in all patches.
+ */
+function makeCumulativePatch(updatedDb, patches, clientIdsMap) {
+    const result = {};
+    (0, utils_1.objectKeys)(updatedDb.tables).forEach(entityName => {
+        const table = updatedDb.tables[entityName];
+        const schema = table.schema;
+        let ids = I.Set();
+        patches.forEach(patch => {
+            let filteredPatch = (patch[entityName] || []).filter(entity => hasServerFields(entity, schema, clientIdsMap, updatedDb.tables));
+            ids = ids.union(filteredPatch.map(e => table.getId(e)));
+        });
+        const entities = ids
+            .map(id => table.byId(id))
+            .filter(e => !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];
+    }
+    const result = [];
+    (0, lodash_foreach_1.default)((0, lodash_pick_1.default)(entity, schema.primaryKey), (value) => {
+        result.push(value);
+    });
+    return result;
+}
+exports.getId = getId;
+function isNew(entity, schema, clientIdsMap) {
+    const id = getId(entity, schema);
+    return !clientIdsMap.clientToServer(id);
+}
+exports.isNew = isNew;
+function hasServerFields(entity, schema, clientIdsMap, tables) {
+    const fullEntity = Object.assign(Object.assign({}, tables[schema.tableName].byId(entity.id) || {}), entity);
+    if (isClientOnly(fullEntity, schema)) {
+        return false;
+    }
+    return (0, utils_1.objectKeys)(entity).some(fieldName => {
+        const fieldSchema = schema.fields[fieldName];
+        return !fieldSchema || !(fieldSchema.isClientOnly || fieldSchema.isReadOnly || (fieldSchema.isGenerated && !isNew(entity, schema, clientIdsMap)));
+    });
+}
+exports.hasServerFields = hasServerFields;
+function getParentEntities(patch, tables) {
+    const dependenciesPatch = {};
+    (0, utils_1.objectKeys)(patch).forEach(key => {
+        const table = tables[key];
+        const tableSchema = table.schema;
+        const fields = (0, lodash_filter_1.default)((0, lodash_map_1.default)(tableSchema.fields, (field, name) => (Object.assign(Object.assign({}, field), { name }))), field => field.fk && field.fk.relationType == types_1.DbRelationType.Aggregation);
+        const tablePatch = patch[key];
+        fields.forEach(field => {
+            const { fk: { tableName }, name } = field;
+            tablePatch.forEach(entity => {
+                const actualTableName = (typeof tableName == 'function' ? tableName(entity) : tableName);
+                const dbEntity = table.byId(table.getId(entity));
+                const parentEntity = tables[actualTableName].byId(dbEntity[name]);
+                const idFields = (0, lodash_pick_1.default)(parentEntity, tables[actualTableName].schema.primaryKey);
+                if (parentEntity) {
+                    dependenciesPatch[actualTableName] = dependenciesPatch[actualTableName] || [];
+                    dependenciesPatch[actualTableName].push(idFields);
+                }
+            });
+        });
+    });
+    return dependenciesPatch;
+}
+exports.getParentEntities = getParentEntities;
+function getEntityParentDependencies(entity, entityName, tables) {
+    let patch = { [entityName]: [entity] };
+    const resultPatches = [];
+    while (true) {
+        let parents = getParentEntities(patch, tables);
+        if (isPatchBlank(parents)) {
+            break;
+        }
+        resultPatches.push(parents);
+        patch = parents;
+    }
+    let result = unionPatches([patch, ...resultPatches]);
+    result = mergeEntityPatches(tables, result);
+    return result;
+}
+exports.getEntityParentDependencies = getEntityParentDependencies;
 
 
 /***/ }),
@@ -1348,26 +1348,26 @@ exports.getEntityParentDependencies = getEntityParentDependencies;
 /***/ (function(module, exports, __webpack_require__) {
 
 "use strict";
-
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.useDbView = exports.useDbRef = exports.DbContext = void 0;
-const react_1 = __webpack_require__(/*! react */ "react");
-exports.DbContext = (0, react_1.createContext)(null);
-function useDbRef() {
-    return (0, react_1.useContext)(exports.DbContext);
-}
-exports.useDbRef = useDbRef;
-function useDbView(fn, params, options) {
-    const dbRef = useDbRef();
-    const [state, setState] = (0, react_1.useState)();
-    const subscription = (0, react_1.useMemo)(() => dbRef.subscribe(Object.assign({ compute: fn }, options), params, setState), []);
-    subscription.update(params);
-    (0, react_1.useEffect)(() => {
-        return () => subscription.unsubscribe();
-    }, []);
-    return subscription.currentValue;
-}
-exports.useDbView = useDbView;
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useDbView = exports.useDbRef = exports.DbContext = void 0;
+const react_1 = __webpack_require__(/*! react */ "react");
+exports.DbContext = (0, react_1.createContext)(null);
+function useDbRef() {
+    return (0, react_1.useContext)(exports.DbContext);
+}
+exports.useDbRef = useDbRef;
+function useDbView(fn, params, options) {
+    const dbRef = useDbRef();
+    const [state, setState] = (0, react_1.useState)();
+    const subscription = (0, react_1.useMemo)(() => dbRef.subscribe(Object.assign({ compute: fn }, options), params, setState), []);
+    subscription.update(params);
+    (0, react_1.useEffect)(() => {
+        return () => subscription.unsubscribe();
+    }, []);
+    return subscription.currentValue;
+}
+exports.useDbView = useDbView;
 
 
 /***/ }),
@@ -1380,183 +1380,183 @@ exports.useDbView = useDbView;
 /***/ (function(module, exports, __webpack_require__) {
 
 "use strict";
-
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TempIdMap = exports.isTempId = exports.getTempId = void 0;
-const utils_1 = __webpack_require__(/*! ./utils */ "./src/utils.ts");
-let lastTempId = -1;
-function getTempId() {
-    return --lastTempId;
-}
-exports.getTempId = getTempId;
-function isTempId(val) {
-    return typeof val === 'number' && val < 0;
-}
-exports.isTempId = isTempId;
-class TempIdMap {
-    constructor(db) {
-        this.db = db;
-        this.serverToClientIds = new Map();
-        this.clientToServerIds = new Map();
-        this.clientToServer = (id) => this.clientToServerIds.get(id);
-        this.serverToClient = (tableName, id) => this.getServerToClientMap(tableName).get(id);
-        this.clientToServerRequest = (request) => {
-            request = Object.assign({}, request);
-            if (request.filter) {
-                request.filter = this.clientToServerDataFilter(request.filter);
-            }
-            return request;
-        };
-        this.clientToServerDataFilter = (filter) => {
-            filter = Object.assign({}, filter);
-            const keys = Object.keys(filter);
-            // I hope that we can rely that there won't be any negative numbers, which are not IDs, in queries.
-            // We need to invent better heuristics or a schema otherwise.
-            const clientToServer = (id) => {
-                const found = this.clientToServer(id);
-                if (found) {
-                    return found;
-                }
-                else {
-                    return id;
-                }
-            };
-            for (let n = 0; n < keys.length; n++) {
-                const key = keys[n];
-                let condition = filter[key];
-                if (condition != null && typeof condition === "object") {
-                    condition = Object.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;
-        };
-    }
-    copyPatch(patch) {
-        const newPatch = Object.assign({}, patch);
-        (0, utils_1.objectKeys)(patch).forEach(tableName => {
-            let tablePatch = patch[tableName].map(entityPatch => (Object.assign({}, entityPatch)));
-            newPatch[tableName] = tablePatch;
-        });
-        return newPatch;
-    }
-    // Iterate thru every field in every patch for every table, matching certain field criteria. The patch is mutated!
-    mapFields(patch, filter, callback) {
-        (0, utils_1.objectKeys)(patch).forEach(tableName => {
-            const schema = this.db.tables[tableName].schema;
-            const fields = (0, utils_1.objectKeys)(schema.fields || [])
-                .map(fieldName => {
-                const fieldSchema = schema.fields[fieldName];
-                if (filter(fieldSchema, fieldName)) {
-                    return { name: fieldName, schema: fieldSchema };
-                }
-            })
-                .filter(f => !!f);
-            if (!fields.length) {
-                return;
-            }
-            patch[tableName].forEach(entityPatch => {
-                for (let n = 0; n < fields.length; n++) {
-                    const field = fields[n];
-                    const fieldValue = entityPatch[field.name];
-                    callback(field.name, field.schema, fieldValue, entityPatch, tableName);
-                }
-            });
-        });
-    }
-    getServerToClientMap(tableName) {
-        const existing = this.serverToClientIds.get(tableName);
-        if (existing) {
-            return existing;
-        }
-        else {
-            const newMap = new Map();
-            this.serverToClientIds.set(tableName, newMap);
-            return newMap;
-        }
-    }
-    serverToClientPatch(patch) {
-        patch = this.copyPatch(patch);
-        // We map PK in a separate pass, as we need to remap all PKs before re-mapping FKs
-        this.mapFields(patch, f => f.isGenerated, (fieldName, fieldSchema, fieldValue, entityPatch, tableName) => {
-            let clientId = this.getServerToClientMap(tableName).get(fieldValue);
-            if (!clientId) {
-                clientId = getTempId();
-                this.clientToServerIds.set(clientId, fieldValue);
-                this.getServerToClientMap(tableName).set(fieldValue, clientId);
-            }
-            entityPatch[fieldName] = clientId;
-        });
-        this.mapFields(patch, f => !!(f.fk || (f.default != null) || f.toClient), (fieldName, fieldSchema, fieldValue, entityPatch, tableName) => {
-            let isUndefined = typeof (fieldValue) === 'undefined';
-            if (fieldSchema.default != null && fieldValue == null) {
-                fieldValue = fieldSchema.default;
-                isUndefined = false;
-            }
-            if (fieldSchema.fk && fieldValue != null) {
-                const fkTableName = typeof fieldSchema.fk.tableName === 'function' ? fieldSchema.fk.tableName(entityPatch) : fieldSchema.fk.tableName;
-                let clientId = this.getServerToClientMap(fkTableName).get(fieldValue);
-                if (!clientId) {
-                    clientId = getTempId();
-                    this.clientToServerIds.set(clientId, fieldValue);
-                    this.getServerToClientMap(fkTableName).set(fieldValue, clientId);
-                }
-                fieldValue = clientId;
-            }
-            if (!isUndefined && fieldSchema.toClient) {
-                fieldValue = fieldSchema.toClient(fieldValue);
-            }
-            if (!isUndefined) {
-                entityPatch[fieldName] = fieldValue;
-            }
-        });
-        return patch;
-    }
-    clientToServerPatch(patch) {
-        patch = this.copyPatch(patch);
-        this.mapFields(patch, f => f.isGenerated || !!f.fk, (fieldName, fieldSchema, fieldValue, entityPatch, tableName) => {
-            if (fieldValue != null) {
-                const existingId = this.clientToServerIds.get(fieldValue);
-                if (existingId) {
-                    entityPatch[fieldName] = existingId;
-                }
-            }
-        });
-        this.mapFields(patch, f => !(f.isClientOnly || f.isReadOnly) && !!f.toServer, (fieldName, fieldSchema, fieldValue, entityPatch, tableName) => {
-            entityPatch[fieldName] = fieldSchema.toServer(entityPatch[fieldName]);
-        });
-        this.mapFields(patch, meta => meta.isClientOnly || meta.isReadOnly, (fieldName, fieldSchema, fieldValue, entityPatch, tableName) => {
-            delete entityPatch[fieldName];
-        });
-        return patch;
-    }
-    appendServerMapping(response) {
-        (0, utils_1.objectKeys)(response.submit).forEach(tableName => {
-            if (this.db.tables[tableName]) {
-                const tablePatch = response.submit[tableName];
-                if (tablePatch) {
-                    const serverToClientIds = this.getServerToClientMap(tableName);
-                    const table = this.db.tables[tableName];
-                    tablePatch.forEach(patch => {
-                        if (isTempId(patch.id)) {
-                            const clientId = patch.id;
-                            const serverId = table.getId(patch.payload);
-                            serverToClientIds.set(serverId, clientId);
-                            this.clientToServerIds.set(clientId, serverId);
-                        }
-                    });
-                }
-            }
-        });
-    }
-}
-exports.TempIdMap = TempIdMap;
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TempIdMap = exports.isTempId = exports.getTempId = void 0;
+const utils_1 = __webpack_require__(/*! ./utils */ "./src/utils.ts");
+let lastTempId = -1;
+function getTempId() {
+    return --lastTempId;
+}
+exports.getTempId = getTempId;
+function isTempId(val) {
+    return typeof val === 'number' && val < 0;
+}
+exports.isTempId = isTempId;
+class TempIdMap {
+    constructor(db) {
+        this.db = db;
+        this.serverToClientIds = new Map();
+        this.clientToServerIds = new Map();
+        this.clientToServer = (id) => this.clientToServerIds.get(id);
+        this.serverToClient = (tableName, id) => this.getServerToClientMap(tableName).get(id);
+        this.clientToServerRequest = (request) => {
+            request = Object.assign({}, request);
+            if (request.filter) {
+                request.filter = this.clientToServerDataFilter(request.filter);
+            }
+            return request;
+        };
+        this.clientToServerDataFilter = (filter) => {
+            filter = Object.assign({}, filter);
+            const keys = Object.keys(filter);
+            // I hope that we can rely that there won't be any negative numbers, which are not IDs, in queries.
+            // We need to invent better heuristics or a schema otherwise.
+            const clientToServer = (id) => {
+                const found = this.clientToServer(id);
+                if (found) {
+                    return found;
+                }
+                else {
+                    return id;
+                }
+            };
+            for (let n = 0; n < keys.length; n++) {
+                const key = keys[n];
+                let condition = filter[key];
+                if (condition != null && typeof condition === "object") {
+                    condition = Object.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;
+        };
+    }
+    copyPatch(patch) {
+        const newPatch = Object.assign({}, patch);
+        (0, utils_1.objectKeys)(patch).forEach(tableName => {
+            let tablePatch = patch[tableName].map(entityPatch => (Object.assign({}, entityPatch)));
+            newPatch[tableName] = tablePatch;
+        });
+        return newPatch;
+    }
+    // Iterate thru every field in every patch for every table, matching certain field criteria. The patch is mutated!
+    mapFields(patch, filter, callback) {
+        (0, utils_1.objectKeys)(patch).forEach(tableName => {
+            const schema = this.db.tables[tableName].schema;
+            const fields = (0, utils_1.objectKeys)(schema.fields || [])
+                .map(fieldName => {
+                const fieldSchema = schema.fields[fieldName];
+                if (filter(fieldSchema, fieldName)) {
+                    return { name: fieldName, schema: fieldSchema };
+                }
+            })
+                .filter(f => !!f);
+            if (!fields.length) {
+                return;
+            }
+            patch[tableName].forEach(entityPatch => {
+                for (let n = 0; n < fields.length; n++) {
+                    const field = fields[n];
+                    const fieldValue = entityPatch[field.name];
+                    callback(field.name, field.schema, fieldValue, entityPatch, tableName);
+                }
+            });
+        });
+    }
+    getServerToClientMap(tableName) {
+        const existing = this.serverToClientIds.get(tableName);
+        if (existing) {
+            return existing;
+        }
+        else {
+            const newMap = new Map();
+            this.serverToClientIds.set(tableName, newMap);
+            return newMap;
+        }
+    }
+    serverToClientPatch(patch) {
+        patch = this.copyPatch(patch);
+        // We map PK in a separate pass, as we need to remap all PKs before re-mapping FKs
+        this.mapFields(patch, f => f.isGenerated, (fieldName, fieldSchema, fieldValue, entityPatch, tableName) => {
+            let clientId = this.getServerToClientMap(tableName).get(fieldValue);
+            if (!clientId) {
+                clientId = getTempId();
+                this.clientToServerIds.set(clientId, fieldValue);
+                this.getServerToClientMap(tableName).set(fieldValue, clientId);
+            }
+            entityPatch[fieldName] = clientId;
+        });
+        this.mapFields(patch, f => !!(f.fk || (f.default != null) || f.toClient), (fieldName, fieldSchema, fieldValue, entityPatch, tableName) => {
+            let isUndefined = typeof (fieldValue) === 'undefined';
+            if (fieldSchema.default != null && fieldValue == null) {
+                fieldValue = fieldSchema.default;
+                isUndefined = false;
+            }
+            if (fieldSchema.fk && fieldValue != null) {
+                const fkTableName = typeof fieldSchema.fk.tableName === 'function' ? fieldSchema.fk.tableName(entityPatch) : fieldSchema.fk.tableName;
+                let clientId = this.getServerToClientMap(fkTableName).get(fieldValue);
+                if (!clientId) {
+                    clientId = getTempId();
+                    this.clientToServerIds.set(clientId, fieldValue);
+                    this.getServerToClientMap(fkTableName).set(fieldValue, clientId);
+                }
+                fieldValue = clientId;
+            }
+            if (!isUndefined && fieldSchema.toClient) {
+                fieldValue = fieldSchema.toClient(fieldValue);
+            }
+            if (!isUndefined) {
+                entityPatch[fieldName] = fieldValue;
+            }
+        });
+        return patch;
+    }
+    clientToServerPatch(patch) {
+        patch = this.copyPatch(patch);
+        this.mapFields(patch, f => f.isGenerated || !!f.fk, (fieldName, fieldSchema, fieldValue, entityPatch, tableName) => {
+            if (fieldValue != null) {
+                const existingId = this.clientToServerIds.get(fieldValue);
+                if (existingId) {
+                    entityPatch[fieldName] = existingId;
+                }
+            }
+        });
+        this.mapFields(patch, f => !(f.isClientOnly || f.isReadOnly) && !!f.toServer, (fieldName, fieldSchema, fieldValue, entityPatch, tableName) => {
+            entityPatch[fieldName] = fieldSchema.toServer(entityPatch[fieldName]);
+        });
+        this.mapFields(patch, meta => meta.isClientOnly || meta.isReadOnly, (fieldName, fieldSchema, fieldValue, entityPatch, tableName) => {
+            delete entityPatch[fieldName];
+        });
+        return patch;
+    }
+    appendServerMapping(response) {
+        (0, utils_1.objectKeys)(response.submit).forEach(tableName => {
+            if (this.db.tables[tableName]) {
+                const tablePatch = response.submit[tableName];
+                if (tablePatch) {
+                    const serverToClientIds = this.getServerToClientMap(tableName);
+                    const table = this.db.tables[tableName];
+                    tablePatch.forEach(patch => {
+                        if (isTempId(patch.id)) {
+                            const clientId = patch.id;
+                            const serverId = table.getId(patch.payload);
+                            serverToClientIds.set(serverId, clientId);
+                            this.clientToServerIds.set(clientId, serverId);
+                        }
+                    });
+                }
+            }
+        });
+    }
+}
+exports.TempIdMap = TempIdMap;
 
 
 /***/ }),
@@ -1569,14 +1569,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 = {}));
 
 
 /***/ }),
@@ -1589,43 +1589,43 @@ var DbRelationType;
 /***/ (function(module, exports, __webpack_require__) {
 
 "use strict";
-
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.difference = exports.defaultCompareViewDependencies = exports.objectKeys = void 0;
-const tslib_1 = __webpack_require__(/*! tslib */ "../node_modules/tslib/tslib.es6.js");
-const shallowequal_1 = (0, tslib_1.__importDefault)(__webpack_require__(/*! shallowequal */ "shallowequal"));
-const lodash_zip_1 = (0, tslib_1.__importDefault)(__webpack_require__(/*! lodash.zip */ "lodash.zip"));
-const lodash_transform_1 = (0, tslib_1.__importDefault)(__webpack_require__(/*! lodash.transform */ "lodash.transform"));
-const lodash_isequal_1 = (0, tslib_1.__importDefault)(__webpack_require__(/*! lodash.isequal */ "lodash.isequal"));
-// TBD: New typescript would contain better typing for this. Remove this hack after update.
-exports.objectKeys = Object.keys;
-function defaultCompareViewDependencies(prev, next) {
-    if (Array.isArray(prev) && Array.isArray(next)) {
-        if (prev.length === next.length) {
-            return (0, lodash_zip_1.default)(prev, next).every(([p, n]) => (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;
+const tslib_1 = __webpack_require__(/*! tslib */ "../node_modules/tslib/tslib.es6.js");
+const shallowequal_1 = (0, tslib_1.__importDefault)(__webpack_require__(/*! shallowequal */ "shallowequal"));
+const lodash_zip_1 = (0, tslib_1.__importDefault)(__webpack_require__(/*! lodash.zip */ "lodash.zip"));
+const lodash_transform_1 = (0, tslib_1.__importDefault)(__webpack_require__(/*! lodash.transform */ "lodash.transform"));
+const lodash_isequal_1 = (0, tslib_1.__importDefault)(__webpack_require__(/*! lodash.isequal */ "lodash.isequal"));
+// TBD: New typescript would contain better typing for this. Remove this hack after update.
+exports.objectKeys = Object.keys;
+function defaultCompareViewDependencies(prev, next) {
+    if (Array.isArray(prev) && Array.isArray(next)) {
+        if (prev.length === next.length) {
+            return (0, lodash_zip_1.default)(prev, next).every(([p, n]) => (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;
 
 
 /***/ }),
@@ -1637,7 +1637,7 @@ exports.difference = difference;
 /*! no static exports found */
 /***/ (function(module, exports, __webpack_require__) {
 
-module.exports = __webpack_require__(/*! /Users/Aliaksei_Manetau/WebstormProjects/uui/uui-db/index.tsx */"./index.tsx");
+module.exports = __webpack_require__(/*! D:\dev\UUI-main\uui-db\index.tsx */"./index.tsx");
 
 
 /***/ }),