remult 0.14.6 → 0.14.7

package/src/remult3/RepositoryImplementation.js

@@ -1,12 +1,16 @@
-import { CompoundIdField, LookupColumn, makeTitle } from '../column';
-import { allEntities, Remult, isBackend, queryConfig as queryConfig, setControllerSettings } from "../context";
-import { entityFilterToJson, Filter } from "../filter/filter-interfaces";
-import { Sort } from "../sort";
-import { v4 as uuid } from 'uuid';
-import { ValueConverters } from "../../valueConverters";
-import { filterHelper } from "../filter/filter-interfaces";
-import { assign } from "../../assign";
-let classValidatorValidate = undefined;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ControllerBase = exports.EntityBase = exports.Entity = exports.BuildEntity = exports.decorateColumnSettings = exports.storableMember = exports.Field = exports.getValueList = exports.ValueListInfo = exports.ValueListFieldType = exports.isAutoIncrement = exports.Fields = exports.FieldType = exports.columnDefsImpl = exports.buildCaption = exports.CaptionTransformer = exports.getEntityRef = exports.FieldRefImplementation = exports.controllerRefImpl = exports.getControllerRef = exports.getFields = exports.rowHelperImplementation = exports.createOldEntity = exports.columnsOfType = exports.getEntityKey = exports.getEntitySettings = exports.entityInfo_key = exports.entityInfo = exports.__updateEntityBasedOnWhere = exports.RepositoryImplementation = void 0;
+var tslib_1 = require("tslib");
+var column_1 = require("../column");
+var context_1 = require("../context");
+var filter_interfaces_1 = require("../filter/filter-interfaces");
+var sort_1 = require("../sort");
+var uuid_1 = require("uuid");
+var valueConverters_1 = require("../../valueConverters");
+var filter_interfaces_2 = require("../filter/filter-interfaces");
+var assign_1 = require("../../assign");
+var classValidatorValidate = undefined;
 // import("class-validator".toString())
 //     .then((v) => {
 //         classValidatorValidate = (item, ref) => {
@@ -24,8 +28,8 @@ let classValidatorValidate = undefined;
 //     })
 //     .catch(() => {
 //     });
-export class RepositoryImplementation {
-    constructor(entity, remult, dataProvider) {
+var RepositoryImplementation = /** @class */ (function () {
+    function RepositoryImplementation(entity, remult, dataProvider) {
         this.entity = entity;
         this.remult = remult;
         this.dataProvider = dataProvider;
@@ -33,353 +37,627 @@ export class RepositoryImplementation {
         this.cache = new Map();
         this._info = createOldEntity(entity, remult);
     }
-    async createAfterFilter(orderBy, lastRow) {
-        let values = new Map();
-        for (const s of Sort.translateOrderByToSort(this.metadata, orderBy).Segments) {
-            let existingVal = lastRow[s.field.key];
-            // if (typeof existingVal !== "string" && typeof existingVal !== "number") {
-            // }
-            // else {
-            //     let ei = getEntitySettings(s.field.valueType, false);
-            //     if (ei) {
-            //         existingVal = await this.remult.repo(s.field.valueType).findId(existingVal);
-            //     }
-            // }
-            values.set(s.field.key, existingVal);
-        }
-        let r = { $or: [] };
-        let equalToColumn = [];
-        for (const s of Sort.translateOrderByToSort(this.metadata, orderBy).Segments) {
-            let ff = new filterHelper(s.field);
-            let f = {};
-            for (const c of equalToColumn) {
-                f[c.key] = values.get(c.key);
-            }
-            equalToColumn.push(s.field);
-            if (s.isDescending) {
-                f[s.field.key] = { $lt: values.get(s.field.key) };
-            }
-            else
-                f[s.field.key] = { $gt: values.get(s.field.key) };
-            r.$or.push(f);
-        }
-        return r;
-    }
-    get edp() {
-        return this.__edp ? this.__edp : this.__edp = this.dataProvider.getEntityDataProvider(this.metadata);
-    }
-    getCachedById(id) {
+    RepositoryImplementation.prototype.createAfterFilter = function (orderBy, lastRow) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var values, _a, _b, s, existingVal, r, equalToColumn, _c, _d, s, ff, f, equalToColumn_1, equalToColumn_1_1, c;
+            var e_1, _e, e_2, _f, e_3, _g;
+            return tslib_1.__generator(this, function (_h) {
+                values = new Map();
+                try {
+                    for (_a = tslib_1.__values(sort_1.Sort.translateOrderByToSort(this.metadata, orderBy).Segments), _b = _a.next(); !_b.done; _b = _a.next()) {
+                        s = _b.value;
+                        existingVal = lastRow[s.field.key];
+                        // if (typeof existingVal !== "string" && typeof existingVal !== "number") {
+                        // }
+                        // else {
+                        //     let ei = getEntitySettings(s.field.valueType, false);
+                        //     if (ei) {
+                        //         existingVal = await this.remult.repo(s.field.valueType).findId(existingVal);
+                        //     }
+                        // }
+                        values.set(s.field.key, existingVal);
+                    }
+                }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (_b && !_b.done && (_e = _a.return)) _e.call(_a);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                }
+                r = { $or: [] };
+                equalToColumn = [];
+                try {
+                    for (_c = tslib_1.__values(sort_1.Sort.translateOrderByToSort(this.metadata, orderBy).Segments), _d = _c.next(); !_d.done; _d = _c.next()) {
+                        s = _d.value;
+                        ff = new filter_interfaces_2.filterHelper(s.field);
+                        f = {};
+                        try {
+                            for (equalToColumn_1 = (e_3 = void 0, tslib_1.__values(equalToColumn)), equalToColumn_1_1 = equalToColumn_1.next(); !equalToColumn_1_1.done; equalToColumn_1_1 = equalToColumn_1.next()) {
+                                c = equalToColumn_1_1.value;
+                                f[c.key] = values.get(c.key);
+                            }
+                        }
+                        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+                        finally {
+                            try {
+                                if (equalToColumn_1_1 && !equalToColumn_1_1.done && (_g = equalToColumn_1.return)) _g.call(equalToColumn_1);
+                            }
+                            finally { if (e_3) throw e_3.error; }
+                        }
+                        equalToColumn.push(s.field);
+                        if (s.isDescending) {
+                            f[s.field.key] = { $lt: values.get(s.field.key) };
+                        }
+                        else
+                            f[s.field.key] = { $gt: values.get(s.field.key) };
+                        r.$or.push(f);
+                    }
+                }
+                catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                finally {
+                    try {
+                        if (_d && !_d.done && (_f = _c.return)) _f.call(_c);
+                    }
+                    finally { if (e_2) throw e_2.error; }
+                }
+                return [2 /*return*/, r];
+            });
+        });
+    };
+    Object.defineProperty(RepositoryImplementation.prototype, "edp", {
+        get: function () {
+            return this.__edp ? this.__edp : this.__edp = this.dataProvider.getEntityDataProvider(this.metadata);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    RepositoryImplementation.prototype.getCachedById = function (id) {
         id = id + '';
         this.getCachedByIdAsync(id);
-        let r = this.idCache.get(id);
+        var r = this.idCache.get(id);
         if (r instanceof Promise)
             return undefined;
         return r;
-    }
-    async getCachedByIdAsync(id) {
-        id = id + '';
-        let r = this.idCache.get(id);
-        if (r instanceof Promise)
-            return await r;
-        if (this.idCache.has(id)) {
-            return r;
-        }
-        this.idCache.set(id, undefined);
-        let row = this.findId(id).then(row => {
-            if (row === undefined) {
-                r = null;
-            }
-            else
-                r = row;
-            this.idCache.set(id, r);
-            return r;
+    };
+    RepositoryImplementation.prototype.getCachedByIdAsync = function (id) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var r, row;
+            var _this = this;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        id = id + '';
+                        r = this.idCache.get(id);
+                        if (!(r instanceof Promise)) return [3 /*break*/, 2];
+                        return [4 /*yield*/, r];
+                    case 1: return [2 /*return*/, _a.sent()];
+                    case 2:
+                        if (this.idCache.has(id)) {
+                            return [2 /*return*/, r];
+                        }
+                        this.idCache.set(id, undefined);
+                        row = this.findId(id).then(function (row) {
+                            if (row === undefined) {
+                                r = null;
+                            }
+                            else
+                                r = row;
+                            _this.idCache.set(id, r);
+                            return r;
+                        });
+                        this.idCache.set(id, row);
+                        return [4 /*yield*/, row];
+                    case 3: return [2 /*return*/, _a.sent()];
+                }
+            });
         });
-        this.idCache.set(id, row);
-        return await row;
-    }
-    addToCache(item) {
+    };
+    RepositoryImplementation.prototype.addToCache = function (item) {
         if (item)
             this.idCache.set(this.getEntityRef(item).getId() + '', item);
-    }
-    get metadata() { return this._info; }
+    };
+    Object.defineProperty(RepositoryImplementation.prototype, "metadata", {
+        get: function () { return this._info; },
+        enumerable: false,
+        configurable: true
+    });
     ;
-    addEventListener(listener) {
+    RepositoryImplementation.prototype.addEventListener = function (listener) {
+        var _this = this;
         if (!this.listeners)
             this.listeners = [];
         this.listeners.push(listener);
-        return () => {
-            this.listeners.splice(this.listeners.indexOf(listener), 1);
+        return function () {
+            _this.listeners.splice(_this.listeners.indexOf(listener), 1);
         };
-    }
-    query(options) {
+    };
+    RepositoryImplementation.prototype.query = function (options) {
         return new QueryResultImpl(options, this);
-    }
-    getEntityRef(entity) {
-        let x = entity[entityMember];
+    };
+    RepositoryImplementation.prototype.getEntityRef = function (entity) {
+        var x = entity[entityMember];
         if (!x) {
             x = new rowHelperImplementation(this._info, entity, this, this.edp, this.remult, true);
             Object.defineProperty(entity, entityMember, {
-                get: () => x
+                get: function () { return x; }
             });
             x.saveOriginalData();
         }
         return x;
-    }
-    async delete(item) {
-        if (typeof item === "string" || typeof item === "number")
-            return this.edp.delete(item);
-        else {
-            return this.getRefForExistingRow(item, undefined).delete();
-        }
-    }
-    async insert(entity) {
-        if (Array.isArray(entity)) {
-            let r = [];
-            for (const item of entity) {
-                r.push(await this.insert(item));
-            }
-            return r;
-        }
-        else {
-            let ref = getEntityRef(entity, false);
-            if (ref) {
-                if (!ref.isNew())
-                    throw "Item is not new";
-                return await ref.save();
-            }
-            else {
-                return await this.getEntityRef(this.create(entity)).save();
-            }
-        }
-    }
-    async update(id, entity) {
-        let ref = this.getRefForExistingRow(entity, id);
-        return (await ref.save());
-    }
-    getRefForExistingRow(entity, id) {
-        let ref = getEntityRef(entity, false);
+    };
+    RepositoryImplementation.prototype.delete = function (item) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                if (typeof item === "string" || typeof item === "number")
+                    return [2 /*return*/, this.edp.delete(item)];
+                else {
+                    return [2 /*return*/, this.getRefForExistingRow(item, undefined).delete()];
+                }
+                return [2 /*return*/];
+            });
+        });
+    };
+    RepositoryImplementation.prototype.insert = function (entity) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var r, entity_1, entity_1_1, item, _a, _b, e_4_1, ref;
+            var e_4, _c;
+            return tslib_1.__generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        if (!Array.isArray(entity)) return [3 /*break*/, 9];
+                        r = [];
+                        _d.label = 1;
+                    case 1:
+                        _d.trys.push([1, 6, 7, 8]);
+                        entity_1 = tslib_1.__values(entity), entity_1_1 = entity_1.next();
+                        _d.label = 2;
+                    case 2:
+                        if (!!entity_1_1.done) return [3 /*break*/, 5];
+                        item = entity_1_1.value;
+                        _b = (_a = r).push;
+                        return [4 /*yield*/, this.insert(item)];
+                    case 3:
+                        _b.apply(_a, [_d.sent()]);
+                        _d.label = 4;
+                    case 4:
+                        entity_1_1 = entity_1.next();
+                        return [3 /*break*/, 2];
+                    case 5: return [3 /*break*/, 8];
+                    case 6:
+                        e_4_1 = _d.sent();
+                        e_4 = { error: e_4_1 };
+                        return [3 /*break*/, 8];
+                    case 7:
+                        try {
+                            if (entity_1_1 && !entity_1_1.done && (_c = entity_1.return)) _c.call(entity_1);
+                        }
+                        finally { if (e_4) throw e_4.error; }
+                        return [7 /*endfinally*/];
+                    case 8: return [2 /*return*/, r];
+                    case 9:
+                        ref = getEntityRef(entity, false);
+                        if (!ref) return [3 /*break*/, 11];
+                        if (!ref.isNew())
+                            throw "Item is not new";
+                        return [4 /*yield*/, ref.save()];
+                    case 10: return [2 /*return*/, _d.sent()];
+                    case 11: return [4 /*yield*/, this.getEntityRef(this.create(entity)).save()];
+                    case 12: return [2 /*return*/, _d.sent()];
+                }
+            });
+        });
+    };
+    RepositoryImplementation.prototype.update = function (id, entity) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var ref;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        ref = this.getRefForExistingRow(entity, id);
+                        return [4 /*yield*/, ref.save()];
+                    case 1: return [2 /*return*/, (_a.sent())];
+                }
+            });
+        });
+    };
+    RepositoryImplementation.prototype.getRefForExistingRow = function (entity, id) {
+        var e_5, _a;
+        var ref = getEntityRef(entity, false);
         if (!ref) {
-            const instance = new this.entity(this.remult);
-            for (const field of this.fieldsOf(entity)) {
-                instance[field.key] = entity[field.key];
+            var instance = new this.entity(this.remult);
+            try {
+                for (var _b = tslib_1.__values(this.fieldsOf(entity)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var field = _c.value;
+                    instance[field.key] = entity[field.key];
+                }
+            }
+            catch (e_5_1) { e_5 = { error: e_5_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                }
+                finally { if (e_5) throw e_5.error; }
             }
-            let row = new rowHelperImplementation(this._info, instance, this, this.edp, this.remult, false);
+            var row_1 = new rowHelperImplementation(this._info, instance, this, this.edp, this.remult, false);
             if (id)
-                row.id = id;
+                row_1.id = id;
             else
-                row.id = row.getId();
-            ref = row;
+                row_1.id = row_1.getId();
+            ref = row_1;
             Object.defineProperty(instance, entityMember, {
-                get: () => row
+                get: function () { return row_1; }
             });
         }
         return ref;
-    }
-    async save(entity) {
-        if (Array.isArray(entity)) {
-            return Promise.all(entity.map(x => this.save(x)));
-        }
-        else {
-            let ref = getEntityRef(entity, false);
-            if (ref)
-                return await ref.save();
-            else if (entity instanceof EntityBase) {
-                return await this.getEntityRef(entity).save();
-            }
-            else {
-                let id = entity[this.metadata.idMetadata.field.key];
-                if (id === undefined)
-                    return this.insert(entity);
-                return this.update(id, entity);
+    };
+    RepositoryImplementation.prototype.save = function (entity) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var ref, id;
+            var _this = this;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!Array.isArray(entity)) return [3 /*break*/, 1];
+                        return [2 /*return*/, Promise.all(entity.map(function (x) { return _this.save(x); }))];
+                    case 1:
+                        ref = getEntityRef(entity, false);
+                        if (!ref) return [3 /*break*/, 3];
+                        return [4 /*yield*/, ref.save()];
+                    case 2: return [2 /*return*/, _a.sent()];
+                    case 3:
+                        if (!(entity instanceof EntityBase)) return [3 /*break*/, 5];
+                        return [4 /*yield*/, this.getEntityRef(entity).save()];
+                    case 4: return [2 /*return*/, _a.sent()];
+                    case 5:
+                        id = entity[this.metadata.idMetadata.field.key];
+                        if (id === undefined)
+                            return [2 /*return*/, this.insert(entity)];
+                        return [2 /*return*/, this.update(id, entity)];
+                }
+            });
+        });
+    };
+    RepositoryImplementation.prototype.find = function (options) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            function loadManyToOne(repo, toLoad) {
+                return tslib_1.__awaiter(this, void 0, void 0, function () {
+                    var rows, rows_1, rows_1_1, r;
+                    var _a, e_8, _b;
+                    return tslib_1.__generator(this, function (_c) {
+                        switch (_c.label) {
+                            case 0: return [4 /*yield*/, repo.find({ where: (_a = repo.metadata.idMetadata).getIdFilter.apply(_a, tslib_1.__spread(toLoad)) })];
+                            case 1:
+                                rows = _c.sent();
+                                try {
+                                    for (rows_1 = tslib_1.__values(rows), rows_1_1 = rows_1.next(); !rows_1_1.done; rows_1_1 = rows_1.next()) {
+                                        r = rows_1_1.value;
+                                        repo.addToCache(r);
+                                    }
+                                }
+                                catch (e_8_1) { e_8 = { error: e_8_1 }; }
+                                finally {
+                                    try {
+                                        if (rows_1_1 && !rows_1_1.done && (_b = rows_1.return)) _b.call(rows_1);
+                                    }
+                                    finally { if (e_8) throw e_8.error; }
+                                }
+                                return [2 /*return*/];
+                        }
+                    });
+                });
             }
-        }
-    }
-    async find(options) {
-        Remult.onFind(this._info, options);
-        let opt = {};
-        if (!options)
-            options = {};
-        opt = {};
-        if (!options.orderBy || Object.keys(options.orderBy).length === 0) {
-            options.orderBy = this._info.entityInfo.defaultOrderBy;
-        }
-        opt.where = await this.translateWhereToFilter(options.where);
-        opt.orderBy = Sort.translateOrderByToSort(this.metadata, options.orderBy);
-        opt.limit = options.limit;
-        opt.page = options.page;
-        let rawRows = await this.edp.find(opt);
-        let loadFields = undefined;
-        if (options.load)
-            loadFields = options.load(this.metadata.fields);
-        for (const col of this.metadata.fields) {
-            let ei = getEntitySettings(col.valueType, false);
-            if (ei) {
-                let load = !col.options.lazy;
-                if (loadFields !== undefined)
-                    load = loadFields.includes(col);
-                if (load) {
-                    let repo = this.remult.repo(col.valueType);
-                    let toLoad = [];
-                    for (const r of rawRows) {
-                        let val = r[col.key];
-                        if (val !== undefined && val !== null && !toLoad.includes(val) && !repo.idCache.has(val)) {
-                            toLoad.push(val);
+            var opt, _a, rawRows, loadFields, _b, _c, col, ei, load, repo, toLoad, rawRows_1, rawRows_1_1, r, val, e_6_1, result;
+            var e_6, _d, e_7, _e;
+            var _this = this;
+            return tslib_1.__generator(this, function (_f) {
+                switch (_f.label) {
+                    case 0:
+                        context_1.Remult.onFind(this._info, options);
+                        opt = {};
+                        if (!options)
+                            options = {};
+                        opt = {};
+                        if (!options.orderBy || Object.keys(options.orderBy).length === 0) {
+                            options.orderBy = this._info.entityInfo.defaultOrderBy;
                         }
-                    }
-                    if (toLoad.length > 0) {
-                        await loadManyToOne(repo, toLoad);
-                    }
+                        _a = opt;
+                        return [4 /*yield*/, this.translateWhereToFilter(options.where)];
+                    case 1:
+                        _a.where = _f.sent();
+                        opt.orderBy = sort_1.Sort.translateOrderByToSort(this.metadata, options.orderBy);
+                        opt.limit = options.limit;
+                        opt.page = options.page;
+                        return [4 /*yield*/, this.edp.find(opt)];
+                    case 2:
+                        rawRows = _f.sent();
+                        loadFields = undefined;
+                        if (options.load)
+                            loadFields = options.load(this.metadata.fields);
+                        _f.label = 3;
+                    case 3:
+                        _f.trys.push([3, 8, 9, 10]);
+                        _b = tslib_1.__values(this.metadata.fields), _c = _b.next();
+                        _f.label = 4;
+                    case 4:
+                        if (!!_c.done) return [3 /*break*/, 7];
+                        col = _c.value;
+                        ei = getEntitySettings(col.valueType, false);
+                        if (!ei) return [3 /*break*/, 6];
+                        load = !col.options.lazy;
+                        if (loadFields !== undefined)
+                            load = loadFields.includes(col);
+                        if (!load) return [3 /*break*/, 6];
+                        repo = this.remult.repo(col.valueType);
+                        toLoad = [];
+                        try {
+                            for (rawRows_1 = (e_7 = void 0, tslib_1.__values(rawRows)), rawRows_1_1 = rawRows_1.next(); !rawRows_1_1.done; rawRows_1_1 = rawRows_1.next()) {
+                                r = rawRows_1_1.value;
+                                val = r[col.key];
+                                if (val !== undefined && val !== null && !toLoad.includes(val) && !repo.idCache.has(val)) {
+                                    toLoad.push(val);
+                                }
+                            }
+                        }
+                        catch (e_7_1) { e_7 = { error: e_7_1 }; }
+                        finally {
+                            try {
+                                if (rawRows_1_1 && !rawRows_1_1.done && (_e = rawRows_1.return)) _e.call(rawRows_1);
+                            }
+                            finally { if (e_7) throw e_7.error; }
+                        }
+                        if (!(toLoad.length > 0)) return [3 /*break*/, 6];
+                        return [4 /*yield*/, loadManyToOne(repo, toLoad)];
+                    case 5:
+                        _f.sent();
+                        _f.label = 6;
+                    case 6:
+                        _c = _b.next();
+                        return [3 /*break*/, 4];
+                    case 7: return [3 /*break*/, 10];
+                    case 8:
+                        e_6_1 = _f.sent();
+                        e_6 = { error: e_6_1 };
+                        return [3 /*break*/, 10];
+                    case 9:
+                        try {
+                            if (_c && !_c.done && (_d = _b.return)) _d.call(_b);
+                        }
+                        finally { if (e_6) throw e_6.error; }
+                        return [7 /*endfinally*/];
+                    case 10: return [4 /*yield*/, Promise.all(rawRows.map(function (r) { return tslib_1.__awaiter(_this, void 0, void 0, function () { return tslib_1.__generator(this, function (_a) {
+                            switch (_a.label) {
+                                case 0: return [4 /*yield*/, this.mapRawDataToResult(r, loadFields)];
+                                case 1: return [2 /*return*/, _a.sent()];
+                            }
+                        }); }); }))];
+                    case 11:
+                        result = _f.sent();
+                        return [2 /*return*/, result];
                 }
-            }
-        }
-        let result = await Promise.all(rawRows.map(async (r) => await this.mapRawDataToResult(r, loadFields)));
-        return result;
-        async function loadManyToOne(repo, toLoad) {
-            let rows = await repo.find({ where: repo.metadata.idMetadata.getIdFilter(...toLoad) });
-            for (const r of rows) {
-                repo.addToCache(r);
-            }
-        }
-    }
-    async mapRawDataToResult(r, loadFields) {
-        if (!r)
-            return undefined;
-        let x = new this.entity(this.remult);
-        let helper = new rowHelperImplementation(this._info, x, this, this.edp, this.remult, false);
-        Object.defineProperty(x, entityMember, {
-            get: () => helper
+            });
         });
-        await helper.loadDataFrom(r, loadFields);
-        helper.saveOriginalData();
-        return x;
-    }
-    async count(where) {
-        return this.edp.count(await this.translateWhereToFilter(where));
-    }
-    async findFirst(where, options) {
-        if (!options)
-            options = {};
-        if (where) {
-            if (options.where) {
-                let w = options.where;
-                options.where = {
-                    $and: [
-                        w,
-                        where
-                    ]
-                };
-            }
-            else
-                options.where = where;
-        }
-        let r;
-        let cacheInfo;
-        if (options.useCache) {
-            let f = await entityFilterToJson(this.metadata, options.where);
-            let key = JSON.stringify(f);
-            cacheInfo = this.cache.get(key);
-            if (cacheInfo !== undefined) {
-                if (cacheInfo.value && this.getEntityRef(cacheInfo.value).wasDeleted()) {
-                    cacheInfo = undefined;
-                    this.cache.delete(key);
+    };
+    RepositoryImplementation.prototype.mapRawDataToResult = function (r, loadFields) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var x, helper;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!r)
+                            return [2 /*return*/, undefined];
+                        x = new this.entity(this.remult);
+                        helper = new rowHelperImplementation(this._info, x, this, this.edp, this.remult, false);
+                        Object.defineProperty(x, entityMember, {
+                            get: function () { return helper; }
+                        });
+                        return [4 /*yield*/, helper.loadDataFrom(r, loadFields)];
+                    case 1:
+                        _a.sent();
+                        helper.saveOriginalData();
+                        return [2 /*return*/, x];
                 }
-                else
-                    return this.cache.get(key).promise;
-            }
-            else {
-                cacheInfo = {
-                    value: undefined,
-                    promise: undefined
-                };
-                this.cache.set(key, cacheInfo);
-            }
-        }
-        r = this.find({ ...options, limit: 1 }).then(async (items) => {
-            let r = undefined;
-            if (items.length > 0)
-                r = items[0];
-            if (!r && options.createIfNotFound) {
-                r = this.create();
-                if (options.where) {
-                    await __updateEntityBasedOnWhere(this.metadata, options.where, r);
+            });
+        });
+    };
+    RepositoryImplementation.prototype.count = function (where) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var _a, _b;
+            return tslib_1.__generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        _b = (_a = this.edp).count;
+                        return [4 /*yield*/, this.translateWhereToFilter(where)];
+                    case 1: return [2 /*return*/, _b.apply(_a, [_c.sent()])];
                 }
-            }
-            return r;
+            });
         });
-        if (cacheInfo) {
-            cacheInfo.promise = r = r.then(r => {
-                cacheInfo.value = r;
-                return r;
+    };
+    RepositoryImplementation.prototype.findFirst = function (where, options) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var w, r, cacheInfo, f, key;
+            var _this = this;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!options)
+                            options = {};
+                        if (where) {
+                            if (options.where) {
+                                w = options.where;
+                                options.where = {
+                                    $and: [
+                                        w,
+                                        where
+                                    ]
+                                };
+                            }
+                            else
+                                options.where = where;
+                        }
+                        if (!options.useCache) return [3 /*break*/, 2];
+                        return [4 /*yield*/, filter_interfaces_1.entityFilterToJson(this.metadata, options.where)];
+                    case 1:
+                        f = _a.sent();
+                        key = JSON.stringify(f);
+                        cacheInfo = this.cache.get(key);
+                        if (cacheInfo !== undefined) {
+                            if (cacheInfo.value && this.getEntityRef(cacheInfo.value).wasDeleted()) {
+                                cacheInfo = undefined;
+                                this.cache.delete(key);
+                            }
+                            else
+                                return [2 /*return*/, this.cache.get(key).promise];
+                        }
+                        else {
+                            cacheInfo = {
+                                value: undefined,
+                                promise: undefined
+                            };
+                            this.cache.set(key, cacheInfo);
+                        }
+                        _a.label = 2;
+                    case 2:
+                        r = this.find(tslib_1.__assign(tslib_1.__assign({}, options), { limit: 1 })).then(function (items) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                            var r;
+                            return tslib_1.__generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0:
+                                        r = undefined;
+                                        if (items.length > 0)
+                                            r = items[0];
+                                        if (!(!r && options.createIfNotFound)) return [3 /*break*/, 2];
+                                        r = this.create();
+                                        if (!options.where) return [3 /*break*/, 2];
+                                        return [4 /*yield*/, __updateEntityBasedOnWhere(this.metadata, options.where, r)];
+                                    case 1:
+                                        _a.sent();
+                                        _a.label = 2;
+                                    case 2: return [2 /*return*/, r];
+                                }
+                            });
+                        }); });
+                        if (cacheInfo) {
+                            cacheInfo.promise = r = r.then(function (r) {
+                                cacheInfo.value = r;
+                                return r;
+                            });
+                        }
+                        return [2 /*return*/, r];
+                }
             });
-        }
-        return r;
-    }
-    fieldsOf(item) {
-        let keys = Object.keys(item);
-        return this.metadata.fields.toArray().filter(x => keys.includes(x.key));
-    }
-    create(item) {
-        let r = new this.entity(this.remult);
+        });
+    };
+    RepositoryImplementation.prototype.fieldsOf = function (item) {
+        var keys = Object.keys(item);
+        return this.metadata.fields.toArray().filter(function (x) { return keys.includes(x.key); });
+    };
+    RepositoryImplementation.prototype.create = function (item) {
+        var e_9, _a;
+        var r = new this.entity(this.remult);
         if (item)
-            for (const field of this.fieldsOf(item)) {
-                r[field.key] = item[field.key];
+            try {
+                for (var _b = tslib_1.__values(this.fieldsOf(item)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var field = _c.value;
+                    r[field.key] = item[field.key];
+                }
             }
-        let z = this.getEntityRef(r);
-        return r;
-    }
-    async fromJson(json, newRow) {
-        let obj = {};
-        for (const col of this.fieldsOf(json)) {
-            if (json[col.key] !== undefined) {
-                obj[col.key] = col.valueConverter.fromJson(json[col.key]);
+            catch (e_9_1) { e_9 = { error: e_9_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                }
+                finally { if (e_9) throw e_9.error; }
             }
-        }
-        if (newRow) {
-            let r = this.create();
-            let helper = this.getEntityRef(r);
-            await helper.loadDataFrom(obj);
-            return r;
-        }
-        else
-            return this.mapRawDataToResult(obj, undefined);
-    }
-    findId(id, options) {
+        var z = this.getEntityRef(r);
+        return r;
+    };
+    RepositoryImplementation.prototype.fromJson = function (json, newRow) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var obj, _a, _b, col, r, helper;
+            var e_10, _c;
+            return tslib_1.__generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        obj = {};
+                        try {
+                            for (_a = tslib_1.__values(this.fieldsOf(json)), _b = _a.next(); !_b.done; _b = _a.next()) {
+                                col = _b.value;
+                                if (json[col.key] !== undefined) {
+                                    obj[col.key] = col.valueConverter.fromJson(json[col.key]);
+                                }
+                            }
+                        }
+                        catch (e_10_1) { e_10 = { error: e_10_1 }; }
+                        finally {
+                            try {
+                                if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
+                            }
+                            finally { if (e_10) throw e_10.error; }
+                        }
+                        if (!newRow) return [3 /*break*/, 2];
+                        r = this.create();
+                        helper = this.getEntityRef(r);
+                        return [4 /*yield*/, helper.loadDataFrom(obj)];
+                    case 1:
+                        _d.sent();
+                        return [2 /*return*/, r];
+                    case 2: return [2 /*return*/, this.mapRawDataToResult(obj, undefined)];
+                }
+            });
+        });
+    };
+    RepositoryImplementation.prototype.findId = function (id, options) {
         if (id === null || id === undefined)
             return null;
         if (typeof id !== "string" && typeof id !== "number")
             throw new Error("id can be either number or string, but got: " + typeof (id));
-        return this.findFirst({}, {
-            useCache: true,
-            ...options,
-            where: this.metadata.idMetadata.getIdFilter(id),
+        return this.findFirst({}, tslib_1.__assign(tslib_1.__assign({ useCache: true }, options), { where: this.metadata.idMetadata.getIdFilter(id) }));
+    };
+    RepositoryImplementation.prototype.translateWhereToFilter = function (where) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var z, _a, r;
+            var _b;
+            return tslib_1.__generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        if (!(this.metadata.options.backendPrefilter && context_1.isBackend())) return [3 /*break*/, 2];
+                        z = where;
+                        _b = {};
+                        _a = [z];
+                        return [4 /*yield*/, filter_interfaces_1.Filter.resolve(this.metadata.options.backendPrefilter)];
+                    case 1:
+                        where = (_b.$and = _a.concat([
+                            _c.sent()
+                        ]),
+                            _b);
+                        _c.label = 2;
+                    case 2: return [4 /*yield*/, filter_interfaces_1.Filter.fromEntityFilter(this.metadata, where)];
+                    case 3:
+                        r = _c.sent();
+                        if (!(r && !this.dataProvider.supportsCustomFilter)) return [3 /*break*/, 5];
+                        return [4 /*yield*/, filter_interfaces_1.Filter.translateCustomWhere(r, this.metadata, this.remult)];
+                    case 4:
+                        r = _c.sent();
+                        _c.label = 5;
+                    case 5: return [2 /*return*/, r];
+                }
+            });
         });
-    }
-    async translateWhereToFilter(where) {
-        if (this.metadata.options.backendPrefilter && isBackend()) {
-            let z = where;
-            where = {
-                $and: [
-                    z, await Filter.resolve(this.metadata.options.backendPrefilter)
-                ]
-            };
-        }
-        let r = await Filter.fromEntityFilter(this.metadata, where);
-        if (r && !this.dataProvider.supportsCustomFilter) {
-            r = await Filter.translateCustomWhere(r, this.metadata, this.remult);
-        }
-        return r;
-    }
-}
-export function __updateEntityBasedOnWhere(entityDefs, where, r) {
-    let w = Filter.fromEntityFilter(entityDefs, where);
-    const emptyFunction = () => { };
+    };
+    return RepositoryImplementation;
+}());
+exports.RepositoryImplementation = RepositoryImplementation;
+function __updateEntityBasedOnWhere(entityDefs, where, r) {
+    var w = filter_interfaces_1.Filter.fromEntityFilter(entityDefs, where);
+    var emptyFunction = function () { };
     if (w) {
         w.__applyToConsumer({
             custom: emptyFunction,
             databaseCustom: emptyFunction,
             containsCaseInsensitive: emptyFunction,
             isDifferentFrom: emptyFunction,
-            isEqualTo: (col, val) => {
+            isEqualTo: function (col, val) {
                 r[col.key] = val;
             },
             isGreaterOrEqualTo: emptyFunction,
@@ -393,178 +671,276 @@ export function __updateEntityBasedOnWhere(entityDefs, where, r) {
         });
     }
 }
-export const entityInfo = Symbol("entityInfo");
-export const entityInfo_key = Symbol("entityInfo_key");
-const entityMember = Symbol("entityMember");
-export function getEntitySettings(entity, throwError = true) {
+exports.__updateEntityBasedOnWhere = __updateEntityBasedOnWhere;
+exports.entityInfo = Symbol("entityInfo");
+exports.entityInfo_key = Symbol("entityInfo_key");
+var entityMember = Symbol("entityMember");
+function getEntitySettings(entity, throwError) {
+    if (throwError === void 0) { throwError = true; }
     if (entity === undefined)
         if (throwError) {
             throw new Error("Undefined is not an entity :)");
         }
         else
             return undefined;
-    let info = Reflect.getMetadata(entityInfo, entity);
+    var info = Reflect.getMetadata(exports.entityInfo, entity);
     if (!info && throwError)
         throw new Error(entity.prototype.constructor.name + " is not a known entity, did you forget to set @Entity() or did you forget to add the '@' before the call to Entity?");
     return info;
 }
-export function getEntityKey(entity) {
-    return Reflect.getMetadata(entityInfo_key, entity);
+exports.getEntitySettings = getEntitySettings;
+function getEntityKey(entity) {
+    return Reflect.getMetadata(exports.entityInfo_key, entity);
 }
-export const columnsOfType = new Map();
-export function createOldEntity(entity, remult) {
-    let r = columnsOfType.get(entity);
+exports.getEntityKey = getEntityKey;
+exports.columnsOfType = new Map();
+function createOldEntity(entity, remult) {
+    var _this = this;
+    var r = exports.columnsOfType.get(entity);
     if (!r)
-        columnsOfType.set(entity, r = []);
-    let info = getEntitySettings(entity)(remult);
-    let key = getEntityKey(entity);
-    let base = Object.getPrototypeOf(entity);
-    while (base != null) {
-        let baseCols = columnsOfType.get(base);
+        exports.columnsOfType.set(entity, r = []);
+    var info = getEntitySettings(entity)(remult);
+    var key = getEntityKey(entity);
+    var base = Object.getPrototypeOf(entity);
+    var _loop_1 = function () {
+        var e_11, _a;
+        var baseCols = exports.columnsOfType.get(base);
         if (baseCols) {
-            r.unshift(...baseCols.filter(x => !r.find(y => y.key == x.key)));
+            r.unshift.apply(r, tslib_1.__spread(baseCols.filter(function (x) { return !r.find(function (y) { return y.key == x.key; }); })));
         }
-        let baseSettingsFactory = getEntitySettings(base, false);
+        var baseSettingsFactory = getEntitySettings(base, false);
         if (baseSettingsFactory) {
-            let baseSettings = baseSettingsFactory(remult);
-            info = { ...baseSettings, ...info };
-            let functions = ["saving", "saved", "deleting", "deleted", "validation"];
-            for (const key of functions) {
-                if (baseSettings[key] && baseSettings[key] !== info[key]) {
-                    let x = info[key];
-                    info[key] = async (a, b) => {
-                        await x(a, b);
-                        await baseSettings[key](a, b);
-                    };
+            var baseSettings_1 = baseSettingsFactory(remult);
+            info = tslib_1.__assign(tslib_1.__assign({}, baseSettings_1), info);
+            var functions = ["saving", "saved", "deleting", "deleted", "validation"];
+            var _loop_2 = function (key_1) {
+                if (baseSettings_1[key_1] && baseSettings_1[key_1] !== info[key_1]) {
+                    var x_1 = info[key_1];
+                    info[key_1] = function (a, b) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                        return tslib_1.__generator(this, function (_a) {
+                            switch (_a.label) {
+                                case 0: return [4 /*yield*/, x_1(a, b)];
+                                case 1:
+                                    _a.sent();
+                                    return [4 /*yield*/, baseSettings_1[key_1](a, b)];
+                                case 2:
+                                    _a.sent();
+                                    return [2 /*return*/];
+                            }
+                        });
+                    }); };
                 }
+            };
+            try {
+                for (var _b = (e_11 = void 0, tslib_1.__values(functions)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var key_1 = _c.value;
+                    _loop_2(key_1);
+                }
+            }
+            catch (e_11_1) { e_11 = { error: e_11_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                }
+                finally { if (e_11) throw e_11.error; }
             }
         }
         base = Object.getPrototypeOf(base);
+    };
+    while (base != null) {
+        _loop_1();
     }
     return new EntityFullInfo(prepareColumnInfo(r, remult), info, remult, entity, key);
 }
-class rowHelperBase {
-    constructor(columnsInfo, instance, remult) {
+exports.createOldEntity = createOldEntity;
+var rowHelperBase = /** @class */ (function () {
+    function rowHelperBase(columnsInfo, instance, remult) {
+        var e_12, _a;
+        var _this = this;
         this.columnsInfo = columnsInfo;
         this.instance = instance;
         this.remult = remult;
         this._isLoading = false;
         this.lookups = new Map();
         this.originalValues = {};
-        for (const col of columnsInfo) {
-            let ei = getEntitySettings(col.valueType, false);
+        var _loop_3 = function (col) {
+            var ei = getEntitySettings(col.valueType, false);
             if (ei && remult) {
-                let lookup = new LookupColumn(remult.repo(col.valueType), undefined);
-                this.lookups.set(col.key, lookup);
-                let val = instance[col.key];
-                let refImpl;
+                var lookup_1 = new column_1.LookupColumn(remult.repo(col.valueType), undefined);
+                this_1.lookups.set(col.key, lookup_1);
+                var val = instance[col.key];
+                var refImpl_1;
                 Object.defineProperty(instance, col.key, {
-                    get: () => {
-                        if (this._subscribers) {
-                            this._subscribers.reportObserved();
-                            if (!refImpl) {
-                                refImpl = this.fields.find(col.key);
-                                if (!refImpl._subscribers) {
-                                    refImpl._subscribers = new SubscribableImp();
+                    get: function () {
+                        if (_this._subscribers) {
+                            _this._subscribers.reportObserved();
+                            if (!refImpl_1) {
+                                refImpl_1 = _this.fields.find(col.key);
+                                if (!refImpl_1._subscribers) {
+                                    refImpl_1._subscribers = new SubscribableImp();
                                 }
                             }
-                            refImpl._subscribers.reportObserved();
+                            refImpl_1._subscribers.reportObserved();
                         }
-                        return lookup.item;
+                        return lookup_1.item;
                     },
-                    set: (val) => {
-                        lookup.set(val);
-                        this._subscribers?.reportChanged();
-                        if (!refImpl) {
-                            refImpl = this.fields.find(col.key);
-                            if (!refImpl._subscribers) {
-                                refImpl._subscribers = new SubscribableImp();
+                    set: function (val) {
+                        var _a;
+                        lookup_1.set(val);
+                        (_a = _this._subscribers) === null || _a === void 0 ? void 0 : _a.reportChanged();
+                        if (!refImpl_1) {
+                            refImpl_1 = _this.fields.find(col.key);
+                            if (!refImpl_1._subscribers) {
+                                refImpl_1._subscribers = new SubscribableImp();
                             }
                         }
-                        refImpl._subscribers.reportChanged();
+                        refImpl_1._subscribers.reportChanged();
                     },
                     enumerable: true
                 });
-                lookup.set(val);
+                lookup_1.set(val);
             }
             else {
             }
+        };
+        var this_1 = this;
+        try {
+            for (var columnsInfo_1 = tslib_1.__values(columnsInfo), columnsInfo_1_1 = columnsInfo_1.next(); !columnsInfo_1_1.done; columnsInfo_1_1 = columnsInfo_1.next()) {
+                var col = columnsInfo_1_1.value;
+                _loop_3(col);
+            }
         }
-    }
-    get error() {
-        this._subscribers?.reportObserved();
-        return this._error;
-    }
-    set error(val) {
-        this._error = val;
-        this._subscribers?.reportChanged();
-    }
-    subscribe(listener) {
+        catch (e_12_1) { e_12 = { error: e_12_1 }; }
+        finally {
+            try {
+                if (columnsInfo_1_1 && !columnsInfo_1_1.done && (_a = columnsInfo_1.return)) _a.call(columnsInfo_1);
+            }
+            finally { if (e_12) throw e_12.error; }
+        }
+    }
+    Object.defineProperty(rowHelperBase.prototype, "error", {
+        get: function () {
+            var _a;
+            (_a = this._subscribers) === null || _a === void 0 ? void 0 : _a.reportObserved();
+            return this._error;
+        },
+        set: function (val) {
+            var _a;
+            this._error = val;
+            (_a = this._subscribers) === null || _a === void 0 ? void 0 : _a.reportChanged();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    rowHelperBase.prototype.subscribe = function (listener) {
         this.initSubscribers();
         return this._subscribers.subscribe(listener);
-    }
-    initSubscribers() {
+    };
+    rowHelperBase.prototype.initSubscribers = function () {
+        var e_13, _a;
+        var _this = this;
         if (!this._subscribers) {
             this._subscribers = new SubscribableImp();
             ;
-            for (const col of this.columnsInfo) {
-                let ei = getEntitySettings(col.valueType, false);
-                let refImpl = this.fields.find(col.key);
+            var _loop_4 = function (col) {
+                var ei = getEntitySettings(col.valueType, false);
+                var refImpl = this_2.fields.find(col.key);
                 refImpl._subscribers = new SubscribableImp();
-                if (ei && this.remult) {
+                if (ei && this_2.remult) {
                 }
                 else {
-                    let val = this.instance[col.key];
-                    Object.defineProperty(this.instance, col.key, {
-                        get: () => {
-                            this._subscribers.reportObserved();
+                    var val_1 = this_2.instance[col.key];
+                    Object.defineProperty(this_2.instance, col.key, {
+                        get: function () {
+                            _this._subscribers.reportObserved();
                             refImpl._subscribers.reportObserved();
-                            return val;
+                            return val_1;
                         },
-                        set: (value) => {
-                            val = value;
-                            this._subscribers.reportChanged();
+                        set: function (value) {
+                            val_1 = value;
+                            _this._subscribers.reportChanged();
                             refImpl._subscribers.reportChanged();
                         },
                         enumerable: true
                     });
                 }
+            };
+            var this_2 = this;
+            try {
+                for (var _b = tslib_1.__values(this.columnsInfo), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var col = _c.value;
+                    _loop_4(col);
+                }
+            }
+            catch (e_13_1) { e_13 = { error: e_13_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                }
+                finally { if (e_13) throw e_13.error; }
             }
         }
-    }
-    get isLoading() {
-        this._subscribers?.reportObserved();
-        return this._isLoading;
-    }
-    set isLoading(val) {
-        this._isLoading = val;
-        this._subscribers?.reportChanged();
-    }
-    async waitLoad() {
-        await Promise.all([...this.lookups.values()].map(x => x.waitLoad()));
-    }
-    __assertValidity() {
+    };
+    Object.defineProperty(rowHelperBase.prototype, "isLoading", {
+        get: function () {
+            var _a;
+            (_a = this._subscribers) === null || _a === void 0 ? void 0 : _a.reportObserved();
+            return this._isLoading;
+        },
+        set: function (val) {
+            var _a;
+            this._isLoading = val;
+            (_a = this._subscribers) === null || _a === void 0 ? void 0 : _a.reportChanged();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    rowHelperBase.prototype.waitLoad = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, Promise.all(tslib_1.__spread(this.lookups.values()).map(function (x) { return x.waitLoad(); }))];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    rowHelperBase.prototype.__assertValidity = function () {
+        var e_14, _a;
         if (!this.hasErrors()) {
-            let error = {
+            var error = {
                 modelState: Object.assign({}, this.errors),
                 message: this.error
             };
             if (!error.message) {
-                for (const col of this.columnsInfo) {
-                    if (this.errors[col.key]) {
-                        error.message = this.fields[col.key].metadata.caption + ": " + this.errors[col.key];
-                        this.error = error.message;
-                        break;
+                try {
+                    for (var _b = tslib_1.__values(this.columnsInfo), _c = _b.next(); !_c.done; _c = _b.next()) {
+                        var col = _c.value;
+                        if (this.errors[col.key]) {
+                            error.message = this.fields[col.key].metadata.caption + ": " + this.errors[col.key];
+                            this.error = error.message;
+                            break;
+                        }
                     }
                 }
+                catch (e_14_1) { e_14 = { error: e_14_1 }; }
+                finally {
+                    try {
+                        if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                    }
+                    finally { if (e_14) throw e_14.error; }
+                }
             }
             throw error;
         }
-    }
-    catchSaveErrors(err) {
-        let e = err;
+    };
+    rowHelperBase.prototype.catchSaveErrors = function (err) {
+        var _this = this;
+        var e = err;
         if (e instanceof Promise) {
-            return e.then(x => this.catchSaveErrors(x));
+            return e.then(function (x) { return _this.catchSaveErrors(x); });
         }
         if (e.error) {
             e = e.error;
@@ -575,386 +951,836 @@ class rowHelperBase {
             this.error = e.Message;
         else
             this.error = e;
-        let s = e.modelState;
+        var s = e.modelState;
         if (!s)
             s = e.ModelState;
         if (s) {
             this.errors = s;
         }
         throw err;
-    }
-    __clearErrorsAndReportChanged() {
+    };
+    rowHelperBase.prototype.__clearErrorsAndReportChanged = function () {
         this.errors = undefined;
         this.error = undefined;
         this._reportChangedToEntityAndFields();
-    }
-    _reportChangedToEntityAndFields() {
+    };
+    rowHelperBase.prototype._reportChangedToEntityAndFields = function () {
+        var e_15, _a;
         if (this._subscribers) {
             this._subscribers.reportChanged();
-            for (const field of this.fields) {
-                let ref = field;
-                ref._subscribers.reportChanged();
+            try {
+                for (var _b = tslib_1.__values(this.fields), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var field = _c.value;
+                    var ref = field;
+                    ref._subscribers.reportChanged();
+                }
+            }
+            catch (e_15_1) { e_15 = { error: e_15_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                }
+                finally { if (e_15) throw e_15.error; }
             }
         }
-    }
-    hasErrors() {
-        this._subscribers?.reportObserved();
+    };
+    rowHelperBase.prototype.hasErrors = function () {
+        var _a;
+        (_a = this._subscribers) === null || _a === void 0 ? void 0 : _a.reportObserved();
         return !!!this.error && this.errors == undefined;
-    }
-    copyDataToObject() {
-        let d = {};
-        for (const col of this.columnsInfo) {
-            let lu = this.lookups.get(col.key);
-            let val = undefined;
-            if (lu)
-                val = lu.id;
-            else
-                val = this.instance[col.key];
-            if (val !== undefined) {
-                val = col.valueConverter.toJson(val);
-                if (val !== undefined && val !== null)
-                    val = col.valueConverter.fromJson(JSON.parse(JSON.stringify(val)));
+    };
+    rowHelperBase.prototype.copyDataToObject = function () {
+        var e_16, _a;
+        var d = {};
+        try {
+            for (var _b = tslib_1.__values(this.columnsInfo), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var col = _c.value;
+                var lu = this.lookups.get(col.key);
+                var val = undefined;
+                if (lu)
+                    val = lu.id;
+                else
+                    val = this.instance[col.key];
+                if (val !== undefined) {
+                    val = col.valueConverter.toJson(val);
+                    if (val !== undefined && val !== null)
+                        val = col.valueConverter.fromJson(JSON.parse(JSON.stringify(val)));
+                }
+                d[col.key] = val;
+            }
+        }
+        catch (e_16_1) { e_16 = { error: e_16_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
             }
-            d[col.key] = val;
+            finally { if (e_16) throw e_16.error; }
         }
         return d;
-    }
-    saveOriginalData() {
+    };
+    rowHelperBase.prototype.saveOriginalData = function () {
         this.originalValues = this.copyDataToObject();
-    }
-    async validate() {
-        this.__clearErrorsAndReportChanged();
-        if (classValidatorValidate)
-            await classValidatorValidate(this.instance, this);
-        await this.__performColumnAndEntityValidations();
-        let r = this.hasErrors();
-        return r;
-    }
-    async __validateEntity() {
-        this.__clearErrorsAndReportChanged();
-        if (classValidatorValidate)
-            await classValidatorValidate(this.instance, this);
-        await this.__performColumnAndEntityValidations();
-        this.__assertValidity();
-    }
-    async __performColumnAndEntityValidations() {
-    }
-    toApiJson() {
-        let result = {};
-        for (const col of this.columnsInfo) {
-            if (!this.remult || col.includeInApi === undefined || this.remult.isAllowed(col.includeInApi)) {
-                let val;
-                let lu = this.lookups.get(col.key);
-                if (lu)
-                    val = lu.id;
-                else {
-                    val = this.instance[col.key];
-                    if (!this.remult) {
-                        if (val) {
-                            let eo = getEntitySettings(val.constructor, false);
-                            if (eo) {
-                                val = getEntityRef(val).getId();
+    };
+    rowHelperBase.prototype.validate = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var r;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this.__clearErrorsAndReportChanged();
+                        if (!classValidatorValidate) return [3 /*break*/, 2];
+                        return [4 /*yield*/, classValidatorValidate(this.instance, this)];
+                    case 1:
+                        _a.sent();
+                        _a.label = 2;
+                    case 2: return [4 /*yield*/, this.__performColumnAndEntityValidations()];
+                    case 3:
+                        _a.sent();
+                        r = this.hasErrors();
+                        return [2 /*return*/, r];
+                }
+            });
+        });
+    };
+    rowHelperBase.prototype.__validateEntity = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this.__clearErrorsAndReportChanged();
+                        if (!classValidatorValidate) return [3 /*break*/, 2];
+                        return [4 /*yield*/, classValidatorValidate(this.instance, this)];
+                    case 1:
+                        _a.sent();
+                        _a.label = 2;
+                    case 2: return [4 /*yield*/, this.__performColumnAndEntityValidations()];
+                    case 3:
+                        _a.sent();
+                        this.__assertValidity();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    rowHelperBase.prototype.__performColumnAndEntityValidations = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                return [2 /*return*/];
+            });
+        });
+    };
+    rowHelperBase.prototype.toApiJson = function () {
+        var e_17, _a;
+        var result = {};
+        try {
+            for (var _b = tslib_1.__values(this.columnsInfo), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var col = _c.value;
+                if (!this.remult || col.includeInApi === undefined || this.remult.isAllowed(col.includeInApi)) {
+                    var val = void 0;
+                    var lu = this.lookups.get(col.key);
+                    if (lu)
+                        val = lu.id;
+                    else {
+                        val = this.instance[col.key];
+                        if (!this.remult) {
+                            if (val) {
+                                var eo = getEntitySettings(val.constructor, false);
+                                if (eo) {
+                                    val = getEntityRef(val).getId();
+                                }
                             }
                         }
                     }
+                    result[col.key] = col.valueConverter.toJson(val);
                 }
-                result[col.key] = col.valueConverter.toJson(val);
             }
         }
+        catch (e_17_1) { e_17 = { error: e_17_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_17) throw e_17.error; }
+        }
         return result;
-    }
-    async _updateEntityBasedOnApi(body) {
-        let keys = Object.keys(body);
-        for (const col of this.columnsInfo) {
-            if (keys.includes(col.key))
-                if (col.includeInApi === undefined || this.remult.isAllowed(col.includeInApi)) {
-                    if (!this.remult || col.allowApiUpdate === undefined || this.remult.isAllowedForInstance(this.instance, col.allowApiUpdate)) {
-                        let lu = this.lookups.get(col.key);
-                        if (lu)
-                            lu.id = body[col.key];
-                        else
-                            this.instance[col.key] = col.valueConverter.fromJson(body[col.key]);
-                    }
+    };
+    rowHelperBase.prototype._updateEntityBasedOnApi = function (body) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var keys, _a, _b, col, lu;
+            var e_18, _c;
+            return tslib_1.__generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        keys = Object.keys(body);
+                        try {
+                            for (_a = tslib_1.__values(this.columnsInfo), _b = _a.next(); !_b.done; _b = _a.next()) {
+                                col = _b.value;
+                                if (keys.includes(col.key))
+                                    if (col.includeInApi === undefined || this.remult.isAllowed(col.includeInApi)) {
+                                        if (!this.remult || col.allowApiUpdate === undefined || this.remult.isAllowedForInstance(this.instance, col.allowApiUpdate)) {
+                                            lu = this.lookups.get(col.key);
+                                            if (lu)
+                                                lu.id = body[col.key];
+                                            else
+                                                this.instance[col.key] = col.valueConverter.fromJson(body[col.key]);
+                                        }
+                                    }
+                            }
+                        }
+                        catch (e_18_1) { e_18 = { error: e_18_1 }; }
+                        finally {
+                            try {
+                                if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
+                            }
+                            finally { if (e_18) throw e_18.error; }
+                        }
+                        return [4 /*yield*/, Promise.all(tslib_1.__spread(this.fields).map(function (x) { return x.load(); }))];
+                    case 1:
+                        _d.sent();
+                        return [2 /*return*/];
                 }
-        }
-        await Promise.all([...this.fields].map(x => x.load()));
-    }
-}
-export class rowHelperImplementation extends rowHelperBase {
-    constructor(info, instance, repository, edp, remult, _isNew) {
-        super(info.columnsInfo, instance, remult);
-        this.info = info;
-        this.repository = repository;
-        this.edp = edp;
-        this._isNew = _isNew;
-        this._wasDeleted = false;
-        this._saving = false;
-        this.metadata = info;
+            });
+        });
+    };
+    return rowHelperBase;
+}());
+var rowHelperImplementation = /** @class */ (function (_super) {
+    tslib_1.__extends(rowHelperImplementation, _super);
+    function rowHelperImplementation(info, instance, repository, edp, remult, _isNew) {
+        var e_19, _a;
+        var _this = _super.call(this, info.columnsInfo, instance, remult) || this;
+        _this.info = info;
+        _this.repository = repository;
+        _this.edp = edp;
+        _this._isNew = _isNew;
+        _this._wasDeleted = false;
+        _this._saving = false;
+        _this.metadata = info;
         if (_isNew) {
-            for (const col of info.columnsInfo) {
-                if (col.defaultValue) {
-                    if (typeof col.defaultValue === "function") {
-                        instance[col.key] = col.defaultValue(instance);
+            try {
+                for (var _b = tslib_1.__values(info.columnsInfo), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var col = _c.value;
+                    if (col.defaultValue) {
+                        if (typeof col.defaultValue === "function") {
+                            instance[col.key] = col.defaultValue(instance);
+                        }
+                        else if (!instance[col.key])
+                            instance[col.key] = col.defaultValue;
                     }
-                    else if (!instance[col.key])
-                        instance[col.key] = col.defaultValue;
                 }
             }
+            catch (e_19_1) { e_19 = { error: e_19_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                }
+                finally { if (e_19) throw e_19.error; }
+            }
         }
-        if (this.info.options.entityRefInit)
-            this.info.options.entityRefInit(this, instance);
-        if (Remult.entityRefInit)
-            Remult.entityRefInit(this, instance);
-    }
-    get apiUpdateAllowed() { return this.remult.isAllowedForInstance(this.instance, this.metadata.options.allowApiUpdate); }
-    get apiDeleteAllowed() { return this.remult.isAllowedForInstance(this.instance, this.metadata.options.allowApiDelete); }
-    get apiInsertAllowed() { return this.remult.isAllowedForInstance(this.instance, this.metadata.options.allowApiInsert); }
-    getId() {
-        if (this.info.idMetadata.field instanceof CompoundIdField)
+        if (_this.info.options.entityRefInit)
+            _this.info.options.entityRefInit(_this, instance);
+        if (context_1.Remult.entityRefInit)
+            context_1.Remult.entityRefInit(_this, instance);
+        return _this;
+    }
+    Object.defineProperty(rowHelperImplementation.prototype, "apiUpdateAllowed", {
+        get: function () { return this.remult.isAllowedForInstance(this.instance, this.metadata.options.allowApiUpdate); },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(rowHelperImplementation.prototype, "apiDeleteAllowed", {
+        get: function () { return this.remult.isAllowedForInstance(this.instance, this.metadata.options.allowApiDelete); },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(rowHelperImplementation.prototype, "apiInsertAllowed", {
+        get: function () { return this.remult.isAllowedForInstance(this.instance, this.metadata.options.allowApiInsert); },
+        enumerable: false,
+        configurable: true
+    });
+    rowHelperImplementation.prototype.getId = function () {
+        if (this.info.idMetadata.field instanceof column_1.CompoundIdField)
             return this.info.idMetadata.field.getId(this.instance);
         else
             return this.instance[this.info.idMetadata.field.key];
-    }
-    wasDeleted() {
-        this._subscribers?.reportObserved();
+    };
+    rowHelperImplementation.prototype.wasDeleted = function () {
+        var _a;
+        (_a = this._subscribers) === null || _a === void 0 ? void 0 : _a.reportObserved();
         return this._wasDeleted;
-    }
-    undoChanges() {
+    };
+    rowHelperImplementation.prototype.undoChanges = function () {
         this.loadDataFrom(this.originalValues);
         this.__clearErrorsAndReportChanged();
-    }
-    async reload() {
-        await this.edp.find({ where: this.getIdFilter() }).then(async (newData) => {
-            await this.loadDataFrom(newData[0]);
-            this.saveOriginalData();
+    };
+    rowHelperImplementation.prototype.reload = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.edp.find({ where: this.getIdFilter() }).then(function (newData) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                            return tslib_1.__generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0: return [4 /*yield*/, this.loadDataFrom(newData[0])];
+                                    case 1:
+                                        _a.sent();
+                                        this.saveOriginalData();
+                                        return [2 /*return*/];
+                                }
+                            });
+                        }); })];
+                    case 1:
+                        _a.sent();
+                        this._reportChangedToEntityAndFields();
+                        return [2 /*return*/, this.instance];
+                }
+            });
         });
-        this._reportChangedToEntityAndFields();
-        return this.instance;
-    }
-    get fields() {
-        if (!this._columns) {
-            let _items = [];
-            let r = {
-                find: (c) => r[typeof c === "string" ? c : c.key],
-                [Symbol.iterator]: () => _items[Symbol.iterator](),
-                toArray: () => _items
-            };
-            for (const c of this.info.columnsInfo) {
-                _items.push(r[c.key] = new FieldRefImplementation(c, this.info.fields[c.key], this.instance, this, this));
-            }
-            this._columns = r;
-        }
-        return this._columns;
-    }
-    async save() {
-        try {
-            if (this._saving)
-                throw new Error("cannot save while entity is already saving");
-            this._saving = true;
-            if (this.wasDeleted())
-                throw new Error("cannot save a deleted row");
-            this.isLoading = true;
-            await this.__validateEntity();
-            let doNotSave = false;
-            for (const col of this.fields) {
-                if (col.metadata.options.saving)
-                    await col.metadata.options.saving(this.instance, col);
-            }
-            if (this.info.entityInfo.saving) {
-                await this.info.entityInfo.saving(this.instance, () => doNotSave = true);
-            }
-            this.__assertValidity();
-            let d = this.copyDataToObject();
-            let ignoreKeys = [];
-            for (const field of this.metadata.fields) {
-                if (field.dbReadOnly) {
-                    d[field.key] = undefined;
-                    ignoreKeys.push(field.key);
-                    let f = this.fields.find(field);
-                    f.value = f.originalValue;
+    };
+    Object.defineProperty(rowHelperImplementation.prototype, "fields", {
+        get: function () {
+            var _a, e_20, _b;
+            if (!this._columns) {
+                var _items_1 = [];
+                var r_1 = (_a = {
+                        find: function (c) { return r_1[typeof c === "string" ? c : c.key]; }
+                    },
+                    _a[Symbol.iterator] = function () { return _items_1[Symbol.iterator](); },
+                    _a.toArray = function () { return _items_1; },
+                    _a);
+                try {
+                    for (var _c = tslib_1.__values(this.info.columnsInfo), _d = _c.next(); !_d.done; _d = _c.next()) {
+                        var c = _d.value;
+                        _items_1.push(r_1[c.key] = new FieldRefImplementation(c, this.info.fields[c.key], this.instance, this, this));
+                    }
                 }
-            }
-            if (this.info.idMetadata.field instanceof CompoundIdField)
-                delete (d.id);
-            let updatedRow;
-            try {
-                this._subscribers?.reportChanged();
-                if (this.isNew()) {
-                    updatedRow = await this.edp.insert(d);
+                catch (e_20_1) { e_20 = { error: e_20_1 }; }
+                finally {
+                    try {
+                        if (_d && !_d.done && (_b = _c.return)) _b.call(_c);
+                    }
+                    finally { if (e_20) throw e_20.error; }
                 }
-                else {
-                    let changesOnly = {};
-                    let wasChanged = false;
-                    for (const key in d) {
-                        if (Object.prototype.hasOwnProperty.call(d, key)) {
-                            const element = d[key];
-                            if (this.fields.find(key).valueChanged() && !ignoreKeys.includes(key)) {
-                                changesOnly[key] = element;
-                                wasChanged = true;
+                this._columns = r_1;
+            }
+            return this._columns;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    rowHelperImplementation.prototype.save = function () {
+        var _a;
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var doNotSave_1, _b, _c, col, e_21_1, d, ignoreKeys, _d, _e, field, f, updatedRow, changesOnly, wasChanged, key, element, err_1;
+            var e_21, _f, e_22, _g;
+            return tslib_1.__generator(this, function (_h) {
+                switch (_h.label) {
+                    case 0:
+                        _h.trys.push([0, , 25, 26]);
+                        if (this._saving)
+                            throw new Error("cannot save while entity is already saving");
+                        this._saving = true;
+                        if (this.wasDeleted())
+                            throw new Error("cannot save a deleted row");
+                        this.isLoading = true;
+                        return [4 /*yield*/, this.__validateEntity()];
+                    case 1:
+                        _h.sent();
+                        doNotSave_1 = false;
+                        _h.label = 2;
+                    case 2:
+                        _h.trys.push([2, 7, 8, 9]);
+                        _b = tslib_1.__values(this.fields), _c = _b.next();
+                        _h.label = 3;
+                    case 3:
+                        if (!!_c.done) return [3 /*break*/, 6];
+                        col = _c.value;
+                        if (!col.metadata.options.saving) return [3 /*break*/, 5];
+                        return [4 /*yield*/, col.metadata.options.saving(this.instance, col)];
+                    case 4:
+                        _h.sent();
+                        _h.label = 5;
+                    case 5:
+                        _c = _b.next();
+                        return [3 /*break*/, 3];
+                    case 6: return [3 /*break*/, 9];
+                    case 7:
+                        e_21_1 = _h.sent();
+                        e_21 = { error: e_21_1 };
+                        return [3 /*break*/, 9];
+                    case 8:
+                        try {
+                            if (_c && !_c.done && (_f = _b.return)) _f.call(_b);
+                        }
+                        finally { if (e_21) throw e_21.error; }
+                        return [7 /*endfinally*/];
+                    case 9:
+                        if (!this.info.entityInfo.saving) return [3 /*break*/, 11];
+                        return [4 /*yield*/, this.info.entityInfo.saving(this.instance, function () { return doNotSave_1 = true; })];
+                    case 10:
+                        _h.sent();
+                        _h.label = 11;
+                    case 11:
+                        this.__assertValidity();
+                        d = this.copyDataToObject();
+                        ignoreKeys = [];
+                        try {
+                            for (_d = tslib_1.__values(this.metadata.fields), _e = _d.next(); !_e.done; _e = _d.next()) {
+                                field = _e.value;
+                                if (field.dbReadOnly) {
+                                    d[field.key] = undefined;
+                                    ignoreKeys.push(field.key);
+                                    f = this.fields.find(field);
+                                    f.value = f.originalValue;
+                                }
                             }
                         }
-                    }
-                    if (!wasChanged)
-                        return this.instance;
-                    if (doNotSave) {
-                        updatedRow = (await this.edp.find({ where: this.getIdFilter() }))[0];
-                    }
-                    else {
-                        updatedRow = await this.edp.update(this.id, changesOnly);
-                    }
+                        catch (e_22_1) { e_22 = { error: e_22_1 }; }
+                        finally {
+                            try {
+                                if (_e && !_e.done && (_g = _d.return)) _g.call(_d);
+                            }
+                            finally { if (e_22) throw e_22.error; }
+                        }
+                        if (this.info.idMetadata.field instanceof column_1.CompoundIdField)
+                            delete (d.id);
+                        updatedRow = void 0;
+                        _h.label = 12;
+                    case 12:
+                        _h.trys.push([12, 22, , 24]);
+                        (_a = this._subscribers) === null || _a === void 0 ? void 0 : _a.reportChanged();
+                        if (!this.isNew()) return [3 /*break*/, 14];
+                        return [4 /*yield*/, this.edp.insert(d)];
+                    case 13:
+                        updatedRow = _h.sent();
+                        return [3 /*break*/, 18];
+                    case 14:
+                        changesOnly = {};
+                        wasChanged = false;
+                        for (key in d) {
+                            if (Object.prototype.hasOwnProperty.call(d, key)) {
+                                element = d[key];
+                                if (this.fields.find(key).valueChanged() && !ignoreKeys.includes(key)) {
+                                    changesOnly[key] = element;
+                                    wasChanged = true;
+                                }
+                            }
+                        }
+                        if (!wasChanged)
+                            return [2 /*return*/, this.instance];
+                        if (!doNotSave_1) return [3 /*break*/, 16];
+                        return [4 /*yield*/, this.edp.find({ where: this.getIdFilter() })];
+                    case 15:
+                        updatedRow = (_h.sent())[0];
+                        return [3 /*break*/, 18];
+                    case 16: return [4 /*yield*/, this.edp.update(this.id, changesOnly)];
+                    case 17:
+                        updatedRow = _h.sent();
+                        _h.label = 18;
+                    case 18: return [4 /*yield*/, this.loadDataFrom(updatedRow)];
+                    case 19:
+                        _h.sent();
+                        if (!this.info.entityInfo.saved) return [3 /*break*/, 21];
+                        return [4 /*yield*/, this.info.entityInfo.saved(this.instance)];
+                    case 20:
+                        _h.sent();
+                        _h.label = 21;
+                    case 21:
+                        this.saveOriginalData();
+                        this._isNew = false;
+                        return [2 /*return*/, this.instance];
+                    case 22:
+                        err_1 = _h.sent();
+                        return [4 /*yield*/, this.catchSaveErrors(err_1)];
+                    case 23:
+                        _h.sent();
+                        return [3 /*break*/, 24];
+                    case 24: return [3 /*break*/, 26];
+                    case 25:
+                        this.isLoading = false;
+                        this._reportChangedToEntityAndFields();
+                        this._saving = false;
+                        return [7 /*endfinally*/];
+                    case 26: return [2 /*return*/];
                 }
-                await this.loadDataFrom(updatedRow);
-                if (this.info.entityInfo.saved)
-                    await this.info.entityInfo.saved(this.instance);
-                this.saveOriginalData();
-                this._isNew = false;
-                return this.instance;
-            }
-            catch (err) {
-                await this.catchSaveErrors(err);
-            }
-        }
-        finally {
-            this.isLoading = false;
-            this._reportChangedToEntityAndFields();
-            this._saving = false;
-        }
-    }
-    getIdFilter() {
-        return Filter.fromEntityFilter(this.metadata, this.repository.metadata.idMetadata.getIdFilter(this.id));
-    }
-    async delete() {
-        this.__clearErrorsAndReportChanged();
-        if (this.info.entityInfo.deleting)
-            await this.info.entityInfo.deleting(this.instance);
-        this.__assertValidity();
-        try {
-            await this.edp.delete(this.id);
-            if (this.info.entityInfo.deleted)
-                await this.info.entityInfo.deleted(this.instance);
-            if (this.repository.listeners)
-                for (const listener of this.repository.listeners.filter(x => x.deleted)) {
-                    await listener.deleted(this.instance);
-                }
-            this._wasDeleted = true;
-        }
-        catch (err) {
-            await this.catchSaveErrors(err);
-        }
-    }
-    async loadDataFrom(data, loadItems) {
-        for (const col of this.info.fields) {
-            let lu = this.lookups.get(col.key);
-            if (lu) {
-                lu.id = data[col.key];
-                if (loadItems === undefined) {
-                    if (!col.options.lazy)
-                        await lu.waitLoad();
+            });
+        });
+    };
+    rowHelperImplementation.prototype.getIdFilter = function () {
+        return filter_interfaces_1.Filter.fromEntityFilter(this.metadata, this.repository.metadata.idMetadata.getIdFilter(this.id));
+    };
+    rowHelperImplementation.prototype.delete = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var _a, _b, listener, e_23_1, err_2;
+            var e_23, _c;
+            return tslib_1.__generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        this.__clearErrorsAndReportChanged();
+                        if (!this.info.entityInfo.deleting) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.info.entityInfo.deleting(this.instance)];
+                    case 1:
+                        _d.sent();
+                        _d.label = 2;
+                    case 2:
+                        this.__assertValidity();
+                        _d.label = 3;
+                    case 3:
+                        _d.trys.push([3, 15, , 17]);
+                        return [4 /*yield*/, this.edp.delete(this.id)];
+                    case 4:
+                        _d.sent();
+                        if (!this.info.entityInfo.deleted) return [3 /*break*/, 6];
+                        return [4 /*yield*/, this.info.entityInfo.deleted(this.instance)];
+                    case 5:
+                        _d.sent();
+                        _d.label = 6;
+                    case 6:
+                        if (!this.repository.listeners) return [3 /*break*/, 14];
+                        _d.label = 7;
+                    case 7:
+                        _d.trys.push([7, 12, 13, 14]);
+                        _a = tslib_1.__values(this.repository.listeners.filter(function (x) { return x.deleted; })), _b = _a.next();
+                        _d.label = 8;
+                    case 8:
+                        if (!!_b.done) return [3 /*break*/, 11];
+                        listener = _b.value;
+                        return [4 /*yield*/, listener.deleted(this.instance)];
+                    case 9:
+                        _d.sent();
+                        _d.label = 10;
+                    case 10:
+                        _b = _a.next();
+                        return [3 /*break*/, 8];
+                    case 11: return [3 /*break*/, 14];
+                    case 12:
+                        e_23_1 = _d.sent();
+                        e_23 = { error: e_23_1 };
+                        return [3 /*break*/, 14];
+                    case 13:
+                        try {
+                            if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
+                        }
+                        finally { if (e_23) throw e_23.error; }
+                        return [7 /*endfinally*/];
+                    case 14:
+                        this._wasDeleted = true;
+                        return [3 /*break*/, 17];
+                    case 15:
+                        err_2 = _d.sent();
+                        return [4 /*yield*/, this.catchSaveErrors(err_2)];
+                    case 16:
+                        _d.sent();
+                        return [3 /*break*/, 17];
+                    case 17: return [2 /*return*/];
                 }
-                else {
-                    if (loadItems.includes(col))
-                        await lu.waitLoad();
+            });
+        });
+    };
+    rowHelperImplementation.prototype.loadDataFrom = function (data, loadItems) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var _a, _b, col, lu, e_24_1;
+            var e_24, _c;
+            return tslib_1.__generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        _d.trys.push([0, 10, 11, 12]);
+                        _a = tslib_1.__values(this.info.fields), _b = _a.next();
+                        _d.label = 1;
+                    case 1:
+                        if (!!_b.done) return [3 /*break*/, 9];
+                        col = _b.value;
+                        lu = this.lookups.get(col.key);
+                        if (!lu) return [3 /*break*/, 7];
+                        lu.id = data[col.key];
+                        if (!(loadItems === undefined)) return [3 /*break*/, 4];
+                        if (!!col.options.lazy) return [3 /*break*/, 3];
+                        return [4 /*yield*/, lu.waitLoad()];
+                    case 2:
+                        _d.sent();
+                        _d.label = 3;
+                    case 3: return [3 /*break*/, 6];
+                    case 4:
+                        if (!loadItems.includes(col)) return [3 /*break*/, 6];
+                        return [4 /*yield*/, lu.waitLoad()];
+                    case 5:
+                        _d.sent();
+                        _d.label = 6;
+                    case 6: return [3 /*break*/, 8];
+                    case 7:
+                        this.instance[col.key] = data[col.key];
+                        _d.label = 8;
+                    case 8:
+                        _b = _a.next();
+                        return [3 /*break*/, 1];
+                    case 9: return [3 /*break*/, 12];
+                    case 10:
+                        e_24_1 = _d.sent();
+                        e_24 = { error: e_24_1 };
+                        return [3 /*break*/, 12];
+                    case 11:
+                        try {
+                            if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
+                        }
+                        finally { if (e_24) throw e_24.error; }
+                        return [7 /*endfinally*/];
+                    case 12: return [4 /*yield*/, this.calcServerExpression()];
+                    case 13:
+                        _d.sent();
+                        if (this.repository.metadata.idMetadata.field instanceof column_1.CompoundIdField) {
+                            this.id = this.repository.metadata.idMetadata.field.getId(this.instance);
+                        }
+                        else
+                            this.id = data[this.repository.metadata.idMetadata.field.key];
+                        return [2 /*return*/];
                 }
-            }
-            else
-                this.instance[col.key] = data[col.key];
-        }
-        await this.calcServerExpression();
-        if (this.repository.metadata.idMetadata.field instanceof CompoundIdField) {
-            this.id = this.repository.metadata.idMetadata.field.getId(this.instance);
-        }
-        else
-            this.id = data[this.repository.metadata.idMetadata.field.key];
-    }
-    getOriginalId() {
+            });
+        });
+    };
+    rowHelperImplementation.prototype.getOriginalId = function () {
         return this.id;
-    }
-    async calcServerExpression() {
-        if (isBackend())
-            for (const col of this.info.columnsInfo) {
-                if (col.serverExpression) {
-                    this.instance[col.key] = await col.serverExpression(this.instance);
+    };
+    rowHelperImplementation.prototype.calcServerExpression = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var _a, _b, col, _c, _d, e_25_1;
+            var e_25, _e;
+            return tslib_1.__generator(this, function (_f) {
+                switch (_f.label) {
+                    case 0:
+                        if (!context_1.isBackend()) return [3 /*break*/, 8];
+                        _f.label = 1;
+                    case 1:
+                        _f.trys.push([1, 6, 7, 8]);
+                        _a = tslib_1.__values(this.info.columnsInfo), _b = _a.next();
+                        _f.label = 2;
+                    case 2:
+                        if (!!_b.done) return [3 /*break*/, 5];
+                        col = _b.value;
+                        if (!col.serverExpression) return [3 /*break*/, 4];
+                        _c = this.instance;
+                        _d = col.key;
+                        return [4 /*yield*/, col.serverExpression(this.instance)];
+                    case 3:
+                        _c[_d] = _f.sent();
+                        _f.label = 4;
+                    case 4:
+                        _b = _a.next();
+                        return [3 /*break*/, 2];
+                    case 5: return [3 /*break*/, 8];
+                    case 6:
+                        e_25_1 = _f.sent();
+                        e_25 = { error: e_25_1 };
+                        return [3 /*break*/, 8];
+                    case 7:
+                        try {
+                            if (_b && !_b.done && (_e = _a.return)) _e.call(_a);
+                        }
+                        finally { if (e_25) throw e_25.error; }
+                        return [7 /*endfinally*/];
+                    case 8: return [2 /*return*/];
                 }
-            }
-    }
-    isNew() {
-        this._subscribers?.reportObserved();
-        return this._isNew;
-    }
-    wasChanged() {
-        this._subscribers?.reportObserved();
-        for (const col of this.fields) {
-            if (col.valueChanged())
-                return true;
-        }
-        return false;
-    }
-    async __performColumnAndEntityValidations() {
-        for (const c of this.columnsInfo) {
-            if (c.validate) {
-                let col = new FieldRefImplementation(c, this.info.fields[c.key], this.instance, this, this);
-                await col.__performValidation();
+            });
+        });
+    };
+    rowHelperImplementation.prototype.isNew = function () {
+        var _a;
+        (_a = this._subscribers) === null || _a === void 0 ? void 0 : _a.reportObserved();
+        return this._isNew;
+    };
+    rowHelperImplementation.prototype.wasChanged = function () {
+        var e_26, _a;
+        var _b;
+        (_b = this._subscribers) === null || _b === void 0 ? void 0 : _b.reportObserved();
+        try {
+            for (var _c = tslib_1.__values(this.fields), _d = _c.next(); !_d.done; _d = _c.next()) {
+                var col = _d.value;
+                if (col.valueChanged())
+                    return true;
             }
         }
-        if (this.info.entityInfo.validation)
-            await this.info.entityInfo.validation(this.instance, this);
-        if (this.repository.listeners)
-            for (const listener of this.repository.listeners.filter(x => x.validating)) {
-                await listener.validating(this.instance);
+        catch (e_26_1) { e_26 = { error: e_26_1 }; }
+        finally {
+            try {
+                if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
             }
-    }
-}
-const controllerColumns = Symbol("controllerColumns");
+            finally { if (e_26) throw e_26.error; }
+        }
+        return false;
+    };
+    rowHelperImplementation.prototype.__performColumnAndEntityValidations = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var _a, _b, c, col, e_27_1, _c, _d, listener, e_28_1;
+            var e_27, _e, e_28, _f;
+            return tslib_1.__generator(this, function (_g) {
+                switch (_g.label) {
+                    case 0:
+                        _g.trys.push([0, 5, 6, 7]);
+                        _a = tslib_1.__values(this.columnsInfo), _b = _a.next();
+                        _g.label = 1;
+                    case 1:
+                        if (!!_b.done) return [3 /*break*/, 4];
+                        c = _b.value;
+                        if (!c.validate) return [3 /*break*/, 3];
+                        col = new FieldRefImplementation(c, this.info.fields[c.key], this.instance, this, this);
+                        return [4 /*yield*/, col.__performValidation()];
+                    case 2:
+                        _g.sent();
+                        _g.label = 3;
+                    case 3:
+                        _b = _a.next();
+                        return [3 /*break*/, 1];
+                    case 4: return [3 /*break*/, 7];
+                    case 5:
+                        e_27_1 = _g.sent();
+                        e_27 = { error: e_27_1 };
+                        return [3 /*break*/, 7];
+                    case 6:
+                        try {
+                            if (_b && !_b.done && (_e = _a.return)) _e.call(_a);
+                        }
+                        finally { if (e_27) throw e_27.error; }
+                        return [7 /*endfinally*/];
+                    case 7:
+                        if (!this.info.entityInfo.validation) return [3 /*break*/, 9];
+                        return [4 /*yield*/, this.info.entityInfo.validation(this.instance, this)];
+                    case 8:
+                        _g.sent();
+                        _g.label = 9;
+                    case 9:
+                        if (!this.repository.listeners) return [3 /*break*/, 17];
+                        _g.label = 10;
+                    case 10:
+                        _g.trys.push([10, 15, 16, 17]);
+                        _c = tslib_1.__values(this.repository.listeners.filter(function (x) { return x.validating; })), _d = _c.next();
+                        _g.label = 11;
+                    case 11:
+                        if (!!_d.done) return [3 /*break*/, 14];
+                        listener = _d.value;
+                        return [4 /*yield*/, listener.validating(this.instance)];
+                    case 12:
+                        _g.sent();
+                        _g.label = 13;
+                    case 13:
+                        _d = _c.next();
+                        return [3 /*break*/, 11];
+                    case 14: return [3 /*break*/, 17];
+                    case 15:
+                        e_28_1 = _g.sent();
+                        e_28 = { error: e_28_1 };
+                        return [3 /*break*/, 17];
+                    case 16:
+                        try {
+                            if (_d && !_d.done && (_f = _c.return)) _f.call(_c);
+                        }
+                        finally { if (e_28) throw e_28.error; }
+                        return [7 /*endfinally*/];
+                    case 17: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    return rowHelperImplementation;
+}(rowHelperBase));
+exports.rowHelperImplementation = rowHelperImplementation;
+var controllerColumns = Symbol("controllerColumns");
 function prepareColumnInfo(r, remult) {
-    return r.map(x => decorateColumnSettings(x.settings(remult), remult));
+    return r.map(function (x) { return decorateColumnSettings(x.settings(remult), remult); });
 }
-export function getFields(container, remult) {
+function getFields(container, remult) {
     return getControllerRef(container, remult).fields;
 }
-export function getControllerRef(container, remult) {
-    let result = container[controllerColumns];
+exports.getFields = getFields;
+function getControllerRef(container, remult) {
+    var result = container[controllerColumns];
     if (!result)
         result = container[entityMember];
     if (!result) {
-        let columnSettings = columnsOfType.get(container.constructor);
-        if (!columnSettings)
-            columnsOfType.set(container.constructor, columnSettings = []);
-        let base = Object.getPrototypeOf(container.constructor);
+        var columnSettings_1 = exports.columnsOfType.get(container.constructor);
+        if (!columnSettings_1)
+            exports.columnsOfType.set(container.constructor, columnSettings_1 = []);
+        var base = Object.getPrototypeOf(container.constructor);
         while (base != null) {
-            let baseCols = columnsOfType.get(base);
+            var baseCols = exports.columnsOfType.get(base);
             if (baseCols) {
-                columnSettings.unshift(...baseCols.filter(x => !columnSettings.find(y => y.key == x.key)));
+                columnSettings_1.unshift.apply(columnSettings_1, tslib_1.__spread(baseCols.filter(function (x) { return !columnSettings_1.find(function (y) { return y.key == x.key; }); })));
             }
             base = Object.getPrototypeOf(base);
         }
-        container[controllerColumns] = result = new controllerRefImpl(prepareColumnInfo(columnSettings, remult), container, remult);
+        container[controllerColumns] = result = new controllerRefImpl(prepareColumnInfo(columnSettings_1, remult), container, remult);
     }
     return result;
 }
-export class controllerRefImpl extends rowHelperBase {
-    constructor(columnsInfo, instance, remult) {
-        super(columnsInfo, instance, remult);
-        let _items = [];
-        let r = {
-            find: (c) => r[typeof c === "string" ? c : c.key],
-            [Symbol.iterator]: () => _items[Symbol.iterator](),
-            toArray: () => _items
-        };
-        for (const col of columnsInfo) {
-            _items.push(r[col.key] = new FieldRefImplementation(col, new columnDefsImpl(col, undefined, remult), instance, undefined, this));
-        }
-        this.fields = r;
-    }
-    async __performColumnAndEntityValidations() {
-        for (const col of this.fields) {
-            if (col instanceof FieldRefImplementation) {
-                await col.__performValidation();
+exports.getControllerRef = getControllerRef;
+var controllerRefImpl = /** @class */ (function (_super) {
+    tslib_1.__extends(controllerRefImpl, _super);
+    function controllerRefImpl(columnsInfo, instance, remult) {
+        var _a, e_29, _b;
+        var _this = _super.call(this, columnsInfo, instance, remult) || this;
+        var _items = [];
+        var r = (_a = {
+                find: function (c) { return r[typeof c === "string" ? c : c.key]; }
+            },
+            _a[Symbol.iterator] = function () { return _items[Symbol.iterator](); },
+            _a.toArray = function () { return _items; },
+            _a);
+        try {
+            for (var columnsInfo_2 = tslib_1.__values(columnsInfo), columnsInfo_2_1 = columnsInfo_2.next(); !columnsInfo_2_1.done; columnsInfo_2_1 = columnsInfo_2.next()) {
+                var col = columnsInfo_2_1.value;
+                _items.push(r[col.key] = new FieldRefImplementation(col, new columnDefsImpl(col, undefined, remult), instance, undefined, _this));
             }
         }
-    }
-}
-export class FieldRefImplementation {
-    constructor(settings, metadata, container, helper, rowBase) {
+        catch (e_29_1) { e_29 = { error: e_29_1 }; }
+        finally {
+            try {
+                if (columnsInfo_2_1 && !columnsInfo_2_1.done && (_b = columnsInfo_2.return)) _b.call(columnsInfo_2);
+            }
+            finally { if (e_29) throw e_29.error; }
+        }
+        _this.fields = r;
+        return _this;
+    }
+    controllerRefImpl.prototype.__performColumnAndEntityValidations = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var _a, _b, col, e_30_1;
+            var e_30, _c;
+            return tslib_1.__generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        _d.trys.push([0, 5, 6, 7]);
+                        _a = tslib_1.__values(this.fields), _b = _a.next();
+                        _d.label = 1;
+                    case 1:
+                        if (!!_b.done) return [3 /*break*/, 4];
+                        col = _b.value;
+                        if (!(col instanceof FieldRefImplementation)) return [3 /*break*/, 3];
+                        return [4 /*yield*/, col.__performValidation()];
+                    case 2:
+                        _d.sent();
+                        _d.label = 3;
+                    case 3:
+                        _b = _a.next();
+                        return [3 /*break*/, 1];
+                    case 4: return [3 /*break*/, 7];
+                    case 5:
+                        e_30_1 = _d.sent();
+                        e_30 = { error: e_30_1 };
+                        return [3 /*break*/, 7];
+                    case 6:
+                        try {
+                            if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
+                        }
+                        finally { if (e_30) throw e_30.error; }
+                        return [7 /*endfinally*/];
+                    case 7: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    return controllerRefImpl;
+}(rowHelperBase));
+exports.controllerRefImpl = controllerRefImpl;
+var FieldRefImplementation = /** @class */ (function () {
+    function FieldRefImplementation(settings, metadata, container, helper, rowBase) {
         this.settings = settings;
         this.metadata = metadata;
         this.container = container;
@@ -963,166 +1789,249 @@ export class FieldRefImplementation {
         this.target = this.settings.target;
         this.entityRef = this.helper;
     }
-    subscribe(listener) {
+    FieldRefImplementation.prototype.subscribe = function (listener) {
         if (!this._subscribers) {
             this.rowBase.initSubscribers();
         }
         return this._subscribers.subscribe(listener);
-    }
-    valueIsNull() {
+    };
+    FieldRefImplementation.prototype.valueIsNull = function () {
         this.reportObserved();
-        let lu = this.rowBase.lookups.get(this.metadata.key);
+        var lu = this.rowBase.lookups.get(this.metadata.key);
         if (lu) {
             return lu.id === undefined || lu.id === null;
         }
         return this.value === null;
-    }
-    originalValueIsNull() {
+    };
+    FieldRefImplementation.prototype.originalValueIsNull = function () {
         this.reportObserved();
-        let lu = this.rowBase.lookups.get(this.metadata.key);
+        var lu = this.rowBase.lookups.get(this.metadata.key);
         return this.rawOriginalValue() === null;
-    }
-    async load() {
-        let lu = this.rowBase.lookups.get(this.metadata.key);
-        if (lu) {
-            if (this.valueChanged()) {
-                await lu.waitLoadOf(this.rawOriginalValue());
+    };
+    FieldRefImplementation.prototype.load = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var lu;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        lu = this.rowBase.lookups.get(this.metadata.key);
+                        if (!lu) return [3 /*break*/, 4];
+                        if (!this.valueChanged()) return [3 /*break*/, 2];
+                        return [4 /*yield*/, lu.waitLoadOf(this.rawOriginalValue())];
+                    case 1:
+                        _a.sent();
+                        _a.label = 2;
+                    case 2: return [4 /*yield*/, lu.waitLoad()];
+                    case 3: return [2 /*return*/, _a.sent()];
+                    case 4: return [2 /*return*/, this.value];
+                }
+            });
+        });
+    };
+    FieldRefImplementation.prototype.reportObserved = function () {
+        var _a, _b;
+        (_a = this._subscribers) === null || _a === void 0 ? void 0 : _a.reportObserved();
+        (_b = this.rowBase._subscribers) === null || _b === void 0 ? void 0 : _b.reportObserved();
+    };
+    FieldRefImplementation.prototype.reportChanged = function () {
+        var _a, _b;
+        (_a = this._subscribers) === null || _a === void 0 ? void 0 : _a.reportChanged();
+        (_b = this.rowBase._subscribers) === null || _b === void 0 ? void 0 : _b.reportChanged();
+    };
+    Object.defineProperty(FieldRefImplementation.prototype, "error", {
+        get: function () {
+            this.reportObserved();
+            if (!this.rowBase.errors)
+                return undefined;
+            return this.rowBase.errors[this.metadata.key];
+        },
+        set: function (error) {
+            if (!this.rowBase.errors)
+                this.rowBase.errors = {};
+            this.rowBase.errors[this.metadata.key] = error;
+            this.reportChanged();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(FieldRefImplementation.prototype, "displayValue", {
+        get: function () {
+            this.reportObserved();
+            if (this.value != undefined) {
+                if (this.settings.displayValue)
+                    return this.settings.displayValue(this.container, this.value);
+                else if (this.metadata.valueConverter.displayValue)
+                    return this.metadata.valueConverter.displayValue(this.value);
+                else
+                    return this.value.toString();
             }
-            return await lu.waitLoad();
-        }
-        return this.value;
-    }
-    reportObserved() {
-        this._subscribers?.reportObserved();
-        this.rowBase._subscribers?.reportObserved();
-    }
-    reportChanged() {
-        this._subscribers?.reportChanged();
-        this.rowBase._subscribers?.reportChanged();
-    }
-    get error() {
-        this.reportObserved();
-        if (!this.rowBase.errors)
-            return undefined;
-        return this.rowBase.errors[this.metadata.key];
-    }
-    set error(error) {
-        if (!this.rowBase.errors)
-            this.rowBase.errors = {};
-        this.rowBase.errors[this.metadata.key] = error;
-        this.reportChanged();
-    }
-    get displayValue() {
-        this.reportObserved();
-        if (this.value != undefined) {
-            if (this.settings.displayValue)
-                return this.settings.displayValue(this.container, this.value);
-            else if (this.metadata.valueConverter.displayValue)
-                return this.metadata.valueConverter.displayValue(this.value);
-            else
-                return this.value.toString();
-        }
-        return "";
-    }
+            return "";
+        },
+        enumerable: false,
+        configurable: true
+    });
     ;
-    get value() { return this.container[this.metadata.key]; }
+    Object.defineProperty(FieldRefImplementation.prototype, "value", {
+        get: function () { return this.container[this.metadata.key]; },
+        set: function (value) { this.container[this.metadata.key] = value; },
+        enumerable: false,
+        configurable: true
+    });
     ;
-    set value(value) { this.container[this.metadata.key] = value; }
     ;
-    get originalValue() {
-        this.reportObserved();
-        let lu = this.rowBase.lookups.get(this.metadata.key);
-        if (lu)
-            return lu.get(this.rawOriginalValue());
-        return this.rowBase.originalValues[this.metadata.key];
-    }
+    Object.defineProperty(FieldRefImplementation.prototype, "originalValue", {
+        get: function () {
+            this.reportObserved();
+            var lu = this.rowBase.lookups.get(this.metadata.key);
+            if (lu)
+                return lu.get(this.rawOriginalValue());
+            return this.rowBase.originalValues[this.metadata.key];
+        },
+        enumerable: false,
+        configurable: true
+    });
     ;
-    rawOriginalValue() {
+    FieldRefImplementation.prototype.rawOriginalValue = function () {
         return this.rowBase.originalValues[this.metadata.key];
-    }
-    setId(id) {
+    };
+    FieldRefImplementation.prototype.setId = function (id) {
         this.value = id;
-    }
-    getId() {
-        let lu = this.rowBase.lookups.get(this.metadata.key);
+    };
+    FieldRefImplementation.prototype.getId = function () {
+        var lu = this.rowBase.lookups.get(this.metadata.key);
         if (lu)
             return lu.id != undefined ? lu.id : null;
         return this.value;
-    }
-    get inputValue() {
-        this.reportObserved();
-        let lu = this.rowBase.lookups.get(this.metadata.key);
-        if (lu)
-            return lu.id != undefined ? lu.id.toString() : null;
-        return this.metadata.valueConverter.toInput(this.value, this.settings.inputType);
-    }
-    set inputValue(val) {
-        let lu = this.rowBase.lookups.get(this.metadata.key);
-        if (lu) {
-            lu.setId(val);
-        }
-        else
-            this.value = this.metadata.valueConverter.fromInput(val, this.settings.inputType);
-    }
+    };
+    Object.defineProperty(FieldRefImplementation.prototype, "inputValue", {
+        get: function () {
+            this.reportObserved();
+            var lu = this.rowBase.lookups.get(this.metadata.key);
+            if (lu)
+                return lu.id != undefined ? lu.id.toString() : null;
+            return this.metadata.valueConverter.toInput(this.value, this.settings.inputType);
+        },
+        set: function (val) {
+            var lu = this.rowBase.lookups.get(this.metadata.key);
+            if (lu) {
+                lu.setId(val);
+            }
+            else
+                this.value = this.metadata.valueConverter.fromInput(val, this.settings.inputType);
+        },
+        enumerable: false,
+        configurable: true
+    });
     ;
-    valueChanged() {
+    FieldRefImplementation.prototype.valueChanged = function () {
         this.reportObserved();
-        let val = this.value;
-        let lu = this.rowBase.lookups.get(this.metadata.key);
+        var val = this.value;
+        var lu = this.rowBase.lookups.get(this.metadata.key);
         if (lu) {
             val = lu.id;
         }
         return JSON.stringify(this.metadata.valueConverter.toJson(this.rowBase.originalValues[this.metadata.key])) != JSON.stringify(this.metadata.valueConverter.toJson(val));
-    }
-    async __performValidation() {
-        try {
-            let x = typeof (this.settings.validate);
-            if (Array.isArray(this.settings.validate)) {
-                for (const v of this.settings.validate) {
-                    await v(this.container, this);
+    };
+    FieldRefImplementation.prototype.__performValidation = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var x, _a, _b, v, e_31_1, error_1;
+            var e_31, _c;
+            return tslib_1.__generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        _d.trys.push([0, 12, , 13]);
+                        x = typeof (this.settings.validate);
+                        if (!Array.isArray(this.settings.validate)) return [3 /*break*/, 9];
+                        _d.label = 1;
+                    case 1:
+                        _d.trys.push([1, 6, 7, 8]);
+                        _a = tslib_1.__values(this.settings.validate), _b = _a.next();
+                        _d.label = 2;
+                    case 2:
+                        if (!!_b.done) return [3 /*break*/, 5];
+                        v = _b.value;
+                        return [4 /*yield*/, v(this.container, this)];
+                    case 3:
+                        _d.sent();
+                        _d.label = 4;
+                    case 4:
+                        _b = _a.next();
+                        return [3 /*break*/, 2];
+                    case 5: return [3 /*break*/, 8];
+                    case 6:
+                        e_31_1 = _d.sent();
+                        e_31 = { error: e_31_1 };
+                        return [3 /*break*/, 8];
+                    case 7:
+                        try {
+                            if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
+                        }
+                        finally { if (e_31) throw e_31.error; }
+                        return [7 /*endfinally*/];
+                    case 8: return [3 /*break*/, 11];
+                    case 9:
+                        if (!(typeof this.settings.validate === 'function')) return [3 /*break*/, 11];
+                        return [4 /*yield*/, this.settings.validate(this.container, this)];
+                    case 10:
+                        _d.sent();
+                        _d.label = 11;
+                    case 11: return [3 /*break*/, 13];
+                    case 12:
+                        error_1 = _d.sent();
+                        if (typeof error_1 === "string")
+                            this.error = error_1;
+                        else
+                            this.error = error_1.message;
+                        return [3 /*break*/, 13];
+                    case 13: return [2 /*return*/];
                 }
-            }
-            else if (typeof this.settings.validate === 'function')
-                await this.settings.validate(this.container, this);
-        }
-        catch (error) {
-            if (typeof error === "string")
-                this.error = error;
-            else
-                this.error = error.message;
-        }
-    }
-    async validate() {
-        await this.__performValidation();
-        return !!!this.error;
-    }
-}
-export function getEntityRef(entity, throwException = true) {
-    let x = entity[entityMember];
+            });
+        });
+    };
+    FieldRefImplementation.prototype.validate = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.__performValidation()];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/, !!!this.error];
+                }
+            });
+        });
+    };
+    return FieldRefImplementation;
+}());
+exports.FieldRefImplementation = FieldRefImplementation;
+function getEntityRef(entity, throwException) {
+    if (throwException === void 0) { throwException = true; }
+    var x = entity[entityMember];
     if (!x && throwException)
         throw new Error("item " + entity.constructor.name + " was not initialized using a context");
     return x;
 }
-export const CaptionTransformer = {
-    transformCaption: (remult, key, caption) => caption
+exports.getEntityRef = getEntityRef;
+exports.CaptionTransformer = {
+    transformCaption: function (remult, key, caption) { return caption; }
 };
-export function buildCaption(caption, key, remult) {
-    let result;
+function buildCaption(caption, key, remult) {
+    var result;
     if (typeof (caption) === "function") {
         if (remult)
             result = caption(remult);
     }
     else if (caption)
         result = caption;
-    result = CaptionTransformer.transformCaption(remult, key, result);
+    result = exports.CaptionTransformer.transformCaption(remult, key, result);
     if (result)
         return result;
     if (key)
-        return makeTitle(key);
+        return column_1.makeTitle(key);
     return '';
 }
-export class columnDefsImpl {
-    constructor(settings, entityDefs, remult) {
+exports.buildCaption = buildCaption;
+var columnDefsImpl = /** @class */ (function () {
+    function columnDefsImpl(settings, entityDefs, remult) {
         this.settings = settings;
         this.entityDefs = entityDefs;
         this.options = this.settings;
@@ -1140,45 +2049,60 @@ export class columnDefsImpl {
             this.inputType = this.valueConverter.inputType;
         this.caption = buildCaption(settings.caption, settings.key, remult);
     }
-    getDbName() {
+    columnDefsImpl.prototype.getDbName = function () {
+        var _this = this;
         if (this.dbNamePromise)
             return this.dbNamePromise;
-        this.dbNamePromise = (async () => {
-            if (this.settings.sqlExpression) {
-                if (typeof this.settings.sqlExpression === "function") {
-                    return this.settings.sqlExpression(this.entityDefs);
+        this.dbNamePromise = (function () { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                if (this.settings.sqlExpression) {
+                    if (typeof this.settings.sqlExpression === "function") {
+                        return [2 /*return*/, this.settings.sqlExpression(this.entityDefs)];
+                    }
+                    else
+                        return [2 /*return*/, this.settings.sqlExpression];
                 }
-                else
-                    return this.settings.sqlExpression;
-            }
-            return this.settings.dbName;
-        })().then(x => {
+                return [2 /*return*/, this.settings.dbName];
+            });
+        }); })().then(function (x) {
             if (x)
                 return x;
-            return this.settings.dbName;
+            return _this.settings.dbName;
         });
         return this.dbNamePromise;
-    }
-    get dbName() {
-        let result;
-        if (this.settings.sqlExpression) {
-            if (typeof this.settings.sqlExpression === "function") {
-                result = this.settings.sqlExpression(this.entityDefs);
+    };
+    Object.defineProperty(columnDefsImpl.prototype, "dbName", {
+        get: function () {
+            var result;
+            if (this.settings.sqlExpression) {
+                if (typeof this.settings.sqlExpression === "function") {
+                    result = this.settings.sqlExpression(this.entityDefs);
+                }
+                else
+                    result = this.settings.sqlExpression;
             }
-            else
-                result = this.settings.sqlExpression;
-        }
-        if (result)
-            return result;
-        return this.settings.dbName;
-    }
-    get dbReadOnly() {
-        return this.settings.dbReadOnly;
-    }
+            if (result)
+                return result;
+            return this.settings.dbName;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(columnDefsImpl.prototype, "dbReadOnly", {
+        get: function () {
+            return this.settings.dbReadOnly;
+        },
+        enumerable: false,
+        configurable: true
+    });
     ;
-}
-class EntityFullInfo {
-    constructor(columnsInfo, entityInfo, remult, entityType, key) {
+    return columnDefsImpl;
+}());
+exports.columnDefsImpl = columnDefsImpl;
+var EntityFullInfo = /** @class */ (function () {
+    function EntityFullInfo(columnsInfo, entityInfo, remult, entityType, key) {
+        var _a, e_32, _b;
+        var _this = this;
         this.columnsInfo = columnsInfo;
         this.entityInfo = entityInfo;
         this.remult = remult;
@@ -1187,30 +2111,35 @@ class EntityFullInfo {
         this.options = this.entityInfo;
         this.idMetadata = {
             field: undefined,
-            createIdInFilter: (items) => {
+            createIdInFilter: function (items) {
                 if (items.length > 0)
                     return {
-                        $or: items.map(x => this.idMetadata.getIdFilter(getEntityRef(x).getId()))
+                        $or: items.map(function (x) { return _this.idMetadata.getIdFilter(getEntityRef(x).getId()); })
                     };
             },
-            isIdField: (col) => {
-                return col.key == this.idMetadata.field.key;
+            isIdField: function (col) {
+                return col.key == _this.idMetadata.field.key;
             },
-            getIdFilter: (...ids) => {
-                if (this.idMetadata.field instanceof CompoundIdField) {
-                    let field = this.idMetadata.field;
+            getIdFilter: function () {
+                var _a, _b;
+                var ids = [];
+                for (var _i = 0; _i < arguments.length; _i++) {
+                    ids[_i] = arguments[_i];
+                }
+                if (_this.idMetadata.field instanceof column_1.CompoundIdField) {
+                    var field_1 = _this.idMetadata.field;
                     return {
-                        $or: ids.map(x => field.isEqualTo(x))
+                        $or: ids.map(function (x) { return field_1.isEqualTo(x); })
                     };
                 }
                 if (ids.length == 1)
-                    return {
-                        [this.idMetadata.field.key]: ids[0]
-                    };
+                    return _a = {},
+                        _a[_this.idMetadata.field.key] = ids[0],
+                        _a;
                 else
-                    return {
-                        [this.idMetadata.field.key]: ids
-                    };
+                    return _b = {},
+                        _b[_this.idMetadata.field.key] = ids,
+                        _b;
             }
         };
         if (this.options.allowApiCrud !== undefined) {
@@ -1229,14 +2158,25 @@ class EntityFullInfo {
             this.key = entityType.name;
         if (!entityInfo.dbName)
             entityInfo.dbName = this.key;
-        let _items = [];
-        let r = {
-            find: (c) => r[typeof c === "string" ? c : c.key],
-            [Symbol.iterator]: () => _items[Symbol.iterator](),
-            toArray: () => _items
-        };
-        for (const x of columnsInfo) {
-            _items.push(r[x.key] = new columnDefsImpl(x, this, remult));
+        var _items = [];
+        var r = (_a = {
+                find: function (c) { return r[typeof c === "string" ? c : c.key]; }
+            },
+            _a[Symbol.iterator] = function () { return _items[Symbol.iterator](); },
+            _a.toArray = function () { return _items; },
+            _a);
+        try {
+            for (var columnsInfo_3 = tslib_1.__values(columnsInfo), columnsInfo_3_1 = columnsInfo_3.next(); !columnsInfo_3_1.done; columnsInfo_3_1 = columnsInfo_3.next()) {
+                var x = columnsInfo_3_1.value;
+                _items.push(r[x.key] = new columnDefsImpl(x, this, remult));
+            }
+        }
+        catch (e_32_1) { e_32 = { error: e_32_1 }; }
+        finally {
+            try {
+                if (columnsInfo_3_1 && !columnsInfo_3_1.done && (_b = columnsInfo_3.return)) _b.call(columnsInfo_3);
+            }
+            finally { if (e_32) throw e_32.error; }
         }
         this.fields = r;
         this.caption = buildCaption(entityInfo.caption, this.key, remult);
@@ -1247,14 +2187,31 @@ class EntityFullInfo {
             if (this.fields["id"])
                 this.idMetadata.field = this.fields["id"];
             else
-                this.idMetadata.field = [...this.fields][0];
-        }
-    }
-    get apiUpdateAllowed() { return this.remult.isAllowedForInstance(undefined, this.options.allowApiUpdate); }
-    get apiReadAllowed() { return this.remult.isAllowed(this.options.allowApiRead); }
-    get apiDeleteAllowed() { return this.remult.isAllowedForInstance(undefined, this.options.allowApiDelete); }
-    get apiInsertAllowed() { return this.remult.isAllowedForInstance(undefined, this.options.allowApiInsert); }
-    getDbName() {
+                this.idMetadata.field = tslib_1.__spread(this.fields)[0];
+        }
+    }
+    Object.defineProperty(EntityFullInfo.prototype, "apiUpdateAllowed", {
+        get: function () { return this.remult.isAllowedForInstance(undefined, this.options.allowApiUpdate); },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(EntityFullInfo.prototype, "apiReadAllowed", {
+        get: function () { return this.remult.isAllowed(this.options.allowApiRead); },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(EntityFullInfo.prototype, "apiDeleteAllowed", {
+        get: function () { return this.remult.isAllowedForInstance(undefined, this.options.allowApiDelete); },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(EntityFullInfo.prototype, "apiInsertAllowed", {
+        get: function () { return this.remult.isAllowedForInstance(undefined, this.options.allowApiInsert); },
+        enumerable: false,
+        configurable: true
+    });
+    EntityFullInfo.prototype.getDbName = function () {
+        var _this = this;
         if (this.dbNamePromise)
             return this.dbNamePromise;
         if (!this.options.sqlExpression) {
@@ -1263,96 +2220,151 @@ class EntityFullInfo {
         if (typeof this.options.sqlExpression === "string")
             this.dbNamePromise = Promise.resolve(this.options.sqlExpression);
         else if (typeof this.options.sqlExpression === "function") {
-            let r = this.options.sqlExpression(this.fields);
+            var r = this.options.sqlExpression(this.fields);
             if (r instanceof Promise)
                 this.dbNamePromise = r;
             else if (r)
                 this.dbNamePromise = Promise.resolve(r);
         }
-        this.dbNamePromise = this.dbNamePromise.then(x => {
+        this.dbNamePromise = this.dbNamePromise.then(function (x) {
             if (!x)
-                return this.options.dbName;
+                return _this.options.dbName;
             return x;
         });
         return this.dbNamePromise;
-    }
-}
-export function FieldType(...options) {
-    return target => {
+    };
+    return EntityFullInfo;
+}());
+function FieldType() {
+    var options = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        options[_i] = arguments[_i];
+    }
+    return function (target) {
         if (!options) {
             options = [];
         }
         options.splice(0, 0, { valueType: target });
-        Reflect.defineMetadata(storableMember, options, target);
+        Reflect.defineMetadata(exports.storableMember, options, target);
         return target;
     };
 }
-export class Fields {
-    static object(...options) {
-        return Field(undefined, ...options);
-    }
-    static dateOnly(...options) {
-        return Field(() => Date, {
-            valueConverter: ValueConverters.DateOnly
-        }, ...options);
-    }
-    static date(...options) {
-        return Field(() => Date, ...options);
-    }
-    static integer(...options) {
-        return Field(() => Number, {
-            valueConverter: ValueConverters.Integer
-        }, ...options);
-    }
-    static autoIncrement(...options) {
-        return Field(() => Number, {
-            allowApiUpdate: false,
-            dbReadOnly: true,
-            valueConverter: { ...ValueConverters.Integer, fieldTypeInDb: 'autoincrement' }
-        }, ...options);
+exports.FieldType = FieldType;
+var Fields = /** @class */ (function () {
+    function Fields() {
     }
-    static number(...options) {
-        return Field(() => Number, ...options);
-    }
-    static uuid(...options) {
-        return Field(() => String, {
-            allowApiUpdate: false,
-            defaultValue: () => uuid()
-        }, ...options);
-    }
-    static string(...options) {
-        return Field(() => String, ...options);
-    }
-    static boolean(...options) {
-        return Field(() => Boolean, ...options);
-    }
-}
-export function isAutoIncrement(f) {
-    return f.options.valueConverter?.fieldTypeInDb === 'autoincrement';
+    Fields.object = function () {
+        var options = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            options[_i] = arguments[_i];
+        }
+        return Field.apply(void 0, tslib_1.__spread([undefined], options));
+    };
+    Fields.dateOnly = function () {
+        var options = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            options[_i] = arguments[_i];
+        }
+        return Field.apply(void 0, tslib_1.__spread([function () { return Date; }, {
+                valueConverter: valueConverters_1.ValueConverters.DateOnly
+            }], options));
+    };
+    Fields.date = function () {
+        var options = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            options[_i] = arguments[_i];
+        }
+        return Field.apply(void 0, tslib_1.__spread([function () { return Date; }], options));
+    };
+    Fields.integer = function () {
+        var options = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            options[_i] = arguments[_i];
+        }
+        return Field.apply(void 0, tslib_1.__spread([function () { return Number; }, {
+                valueConverter: valueConverters_1.ValueConverters.Integer
+            }], options));
+    };
+    Fields.autoIncrement = function () {
+        var options = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            options[_i] = arguments[_i];
+        }
+        return Field.apply(void 0, tslib_1.__spread([function () { return Number; }, {
+                allowApiUpdate: false,
+                dbReadOnly: true,
+                valueConverter: tslib_1.__assign(tslib_1.__assign({}, valueConverters_1.ValueConverters.Integer), { fieldTypeInDb: 'autoincrement' })
+            }], options));
+    };
+    Fields.number = function () {
+        var options = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            options[_i] = arguments[_i];
+        }
+        return Field.apply(void 0, tslib_1.__spread([function () { return Number; }], options));
+    };
+    Fields.uuid = function () {
+        var options = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            options[_i] = arguments[_i];
+        }
+        return Field.apply(void 0, tslib_1.__spread([function () { return String; }, {
+                allowApiUpdate: false,
+                defaultValue: function () { return uuid_1.v4(); }
+            }], options));
+    };
+    Fields.string = function () {
+        var options = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            options[_i] = arguments[_i];
+        }
+        return Field.apply(void 0, tslib_1.__spread([function () { return String; }], options));
+    };
+    Fields.boolean = function () {
+        var options = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            options[_i] = arguments[_i];
+        }
+        return Field.apply(void 0, tslib_1.__spread([function () { return Boolean; }], options));
+    };
+    return Fields;
+}());
+exports.Fields = Fields;
+function isAutoIncrement(f) {
+    var _a;
+    return ((_a = f.options.valueConverter) === null || _a === void 0 ? void 0 : _a.fieldTypeInDb) === 'autoincrement';
 }
-export function ValueListFieldType(...options) {
-    return (type) => {
-        FieldType(o => {
-            o.valueConverter = ValueListInfo.get(type),
-                o.displayValue = (item, val) => val.caption;
-        }, ...options)(type);
+exports.isAutoIncrement = isAutoIncrement;
+function ValueListFieldType() {
+    var options = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        options[_i] = arguments[_i];
+    }
+    return function (type) {
+        FieldType.apply(void 0, tslib_1.__spread([function (o) {
+                o.valueConverter = ValueListInfo.get(type),
+                    o.displayValue = function (item, val) { return val.caption; };
+            }], options))(type);
     };
 }
-export class ValueListInfo {
-    constructor(valueListType) {
+exports.ValueListFieldType = ValueListFieldType;
+var ValueListInfo = /** @class */ (function () {
+    function ValueListInfo(valueListType) {
+        var e_33, _a, _b;
+        var _this = this;
         this.valueListType = valueListType;
         this.byIdMap = new Map();
         this.values = [];
         this.isNumeric = false;
-        for (let member in this.valueListType) {
-            let s = this.valueListType[member];
+        for (var member in this.valueListType) {
+            var s = this.valueListType[member];
             if (s instanceof this.valueListType) {
                 if (s.id === undefined)
                     s.id = member;
                 if (typeof s.id === 'number')
                     this.isNumeric = true;
                 if (s.caption === undefined)
-                    s.caption = makeTitle(s.id !== undefined ? s.id.toString() : member);
+                    s.caption = column_1.makeTitle(s.id !== undefined ? s.id.toString() : member);
                 this.byIdMap.set(s.id, s);
                 this.values.push(s);
             }
@@ -1360,81 +2372,95 @@ export class ValueListInfo {
         if (this.isNumeric) {
             this.fieldTypeInDb = 'integer';
         }
-        var options = Reflect.getMetadata(storableMember, this.valueListType);
+        var options = Reflect.getMetadata(exports.storableMember, this.valueListType);
         if (options) {
-            for (const op of options) {
-                if (op?.getValues) {
-                    this.values.splice(0, this.values.length, ...op.getValues());
-                    this.byIdMap.clear();
-                    this.values.forEach(s => {
-                        if (s.caption === undefined && s.id !== undefined)
-                            s.caption = makeTitle(s.id);
-                        this.byIdMap.set(s.id, s);
-                    });
+            try {
+                for (var options_1 = tslib_1.__values(options), options_1_1 = options_1.next(); !options_1_1.done; options_1_1 = options_1.next()) {
+                    var op = options_1_1.value;
+                    if (op === null || op === void 0 ? void 0 : op.getValues) {
+                        (_b = this.values).splice.apply(_b, tslib_1.__spread([0, this.values.length], op.getValues()));
+                        this.byIdMap.clear();
+                        this.values.forEach(function (s) {
+                            if (s.caption === undefined && s.id !== undefined)
+                                s.caption = column_1.makeTitle(s.id);
+                            _this.byIdMap.set(s.id, s);
+                        });
+                    }
+                }
+            }
+            catch (e_33_1) { e_33 = { error: e_33_1 }; }
+            finally {
+                try {
+                    if (options_1_1 && !options_1_1.done && (_a = options_1.return)) _a.call(options_1);
                 }
+                finally { if (e_33) throw e_33.error; }
             }
-            if (this.values.find(s => s.id === undefined))
-                throw new Error(`ValueType ${this.valueListType} has values without an id`);
+            if (this.values.find(function (s) { return s.id === undefined; }))
+                throw new Error("ValueType " + this.valueListType + " has values without an id");
         }
         else
-            throw new Error(`ValueType not yet initialized, did you forget to call @ValueListFieldType on ` + valueListType);
+            throw new Error("ValueType not yet initialized, did you forget to call @ValueListFieldType on " + valueListType);
     }
-    static get(type) {
-        let r = typeCache.get(type);
+    ValueListInfo.get = function (type) {
+        var r = typeCache.get(type);
         if (!r) {
             r = new ValueListInfo(type);
             typeCache.set(type, r);
         }
         return r;
-    }
-    getValues() {
+    };
+    ValueListInfo.prototype.getValues = function () {
         return this.values;
-    }
-    byId(key) {
+    };
+    ValueListInfo.prototype.byId = function (key) {
         if (this.isNumeric)
             key = +key;
         return this.byIdMap.get(key);
-    }
-    fromJson(val) {
+    };
+    ValueListInfo.prototype.fromJson = function (val) {
         return this.byId(val);
-    }
-    toJson(val) {
+    };
+    ValueListInfo.prototype.toJson = function (val) {
         if (!val)
             return undefined;
         return val.id;
-    }
-    fromDb(val) {
+    };
+    ValueListInfo.prototype.fromDb = function (val) {
         return this.fromJson(val);
-    }
-    toDb(val) {
+    };
+    ValueListInfo.prototype.toDb = function (val) {
         return this.toJson(val);
-    }
-    toInput(val, inputType) {
+    };
+    ValueListInfo.prototype.toInput = function (val, inputType) {
         return this.toJson(val);
-    }
-    fromInput(val, inputType) {
+    };
+    ValueListInfo.prototype.fromInput = function (val, inputType) {
         return this.fromJson(val);
-    }
-    displayValue(val) {
+    };
+    ValueListInfo.prototype.displayValue = function (val) {
         if (!val)
             return '';
         return val.caption;
-    }
-}
-const typeCache = new Map();
-export function getValueList(type) {
+    };
+    return ValueListInfo;
+}());
+exports.ValueListInfo = ValueListInfo;
+var typeCache = new Map();
+function getValueList(type) {
+    var _a, _b, _c;
     {
-        const fr = type?.metadata?.valueType;
+        var fr = (_b = (_a = type) === null || _a === void 0 ? void 0 : _a.metadata) === null || _b === void 0 ? void 0 : _b.valueType;
         if (fr)
             return ValueListInfo.get(fr).getValues();
     }
     {
-        const fr = type?.valueType;
+        var fr = (_c = type) === null || _c === void 0 ? void 0 : _c.valueType;
         if (fr)
             return ValueListInfo.get(fr).getValues();
     }
     return ValueListInfo.get(type).getValues();
 }
+exports.getValueList = getValueList;
 /**Decorates fields that should be used as fields.
  * for more info see: [Field Types](https://remult.dev/docs/field-types.html)
  *
@@ -1448,10 +2474,14 @@ export function getValueList(type) {
  * @Fields.string((options,remult) => options.includeInApi = true)
  * title='';
  */
-export function Field(valueType, ...options) {
-    return (target, key, c) => {
-        let factory = (remult) => {
-            let r = buildOptions(options, remult);
+function Field(valueType) {
+    var options = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        options[_i - 1] = arguments[_i];
+    }
+    return function (target, key, c) {
+        var factory = function (remult) {
+            var r = buildOptions(options, remult);
             if (!r.valueType && valueType) {
                 r.valueType = valueType();
             }
@@ -1460,7 +2490,7 @@ export function Field(valueType, ...options) {
             }
             if (!r.dbName)
                 r.dbName = r.key;
-            let type = r.valueType;
+            var type = r.valueType;
             if (!type) {
                 type = Reflect.getMetadata("design:type", target, key);
                 r.valueType = type;
@@ -1469,114 +2499,129 @@ export function Field(valueType, ...options) {
                 r.target = target;
             return r;
         };
-        let names = columnsOfType.get(target.constructor);
+        var names = exports.columnsOfType.get(target.constructor);
         if (!names) {
             names = [];
-            columnsOfType.set(target.constructor, names);
+            exports.columnsOfType.set(target.constructor, names);
         }
-        let set = names.find(x => x.key == key);
+        var set = names.find(function (x) { return x.key == key; });
         if (!set)
             names.push({
-                key,
+                key: key,
                 settings: factory,
             });
         else {
-            let prev = set.settings;
-            set.settings = (c) => {
-                let prevO = prev(c);
-                let curr = factory(c);
+            var prev_1 = set.settings;
+            set.settings = function (c) {
+                var prevO = prev_1(c);
+                var curr = factory(c);
                 return Object.assign(prevO, curr);
             };
         }
     };
 }
-export const storableMember = Symbol("storableMember");
+exports.Field = Field;
+exports.storableMember = Symbol("storableMember");
 function buildOptions(options, remult) {
-    let r = {};
-    for (const o of options) {
-        if (o) {
-            if (typeof o === "function")
-                o(r, remult);
-            else
-                Object.assign(r, o);
+    var e_34, _a;
+    var r = {};
+    try {
+        for (var options_2 = tslib_1.__values(options), options_2_1 = options_2.next(); !options_2_1.done; options_2_1 = options_2.next()) {
+            var o = options_2_1.value;
+            if (o) {
+                if (typeof o === "function")
+                    o(r, remult);
+                else
+                    Object.assign(r, o);
+            }
         }
     }
+    catch (e_34_1) { e_34 = { error: e_34_1 }; }
+    finally {
+        try {
+            if (options_2_1 && !options_2_1.done && (_a = options_2.return)) _a.call(options_2);
+        }
+        finally { if (e_34) throw e_34.error; }
+    }
     return r;
 }
-export function decorateColumnSettings(settings, remult) {
+function decorateColumnSettings(settings, remult) {
     if (settings.valueType) {
-        let settingsOnTypeLevel = Reflect.getMetadata(storableMember, settings.valueType);
+        var settingsOnTypeLevel = Reflect.getMetadata(exports.storableMember, settings.valueType);
         if (settingsOnTypeLevel) {
-            settings = {
-                ...buildOptions(settingsOnTypeLevel, remult),
-                ...settings
-            };
+            settings = tslib_1.__assign(tslib_1.__assign({}, buildOptions(settingsOnTypeLevel, remult)), settings);
         }
     }
     if (settings.valueType == String) {
-        let x = settings;
+        var x = settings;
         if (!settings.valueConverter)
             x.valueConverter = {
-                toJson: x => x,
-                fromJson: x => x
+                toJson: function (x) { return x; },
+                fromJson: function (x) { return x; }
             };
     }
     if (settings.valueType == Number) {
-        let x = settings;
+        var x = settings;
         if (!settings.valueConverter)
-            x.valueConverter = ValueConverters.Number;
+            x.valueConverter = valueConverters_1.ValueConverters.Number;
     }
     if (settings.valueType == Date) {
-        let x = settings;
+        var x = settings;
         if (!settings.valueConverter) {
-            x.valueConverter = ValueConverters.Date;
+            x.valueConverter = valueConverters_1.ValueConverters.Date;
         }
     }
     if (settings.valueType == Boolean) {
-        let x = settings;
+        var x = settings;
         if (!x.valueConverter)
-            x.valueConverter = ValueConverters.Boolean;
+            x.valueConverter = valueConverters_1.ValueConverters.Boolean;
     }
     if (!settings.valueConverter) {
-        let ei = getEntitySettings(settings.valueType, false);
+        var ei = getEntitySettings(settings.valueType, false);
         if (ei) {
             settings.valueConverter = {
-                toDb: x => x,
-                fromDb: x => x
+                toDb: function (x) { return x; },
+                fromDb: function (x) { return x; }
             };
         }
         else
-            settings.valueConverter = ValueConverters.Default;
+            settings.valueConverter = valueConverters_1.ValueConverters.Default;
     }
     if (!settings.valueConverter.toJson) {
-        settings.valueConverter.toJson = x => x;
+        settings.valueConverter.toJson = function (x) { return x; };
     }
     if (!settings.valueConverter.fromJson) {
-        settings.valueConverter.fromJson = x => x;
+        settings.valueConverter.fromJson = function (x) { return x; };
     }
     if (!settings.valueConverter.toDb) {
-        settings.valueConverter.toDb = x => settings.valueConverter.toJson(x);
+        settings.valueConverter.toDb = function (x) { return settings.valueConverter.toJson(x); };
     }
     if (!settings.valueConverter.fromDb) {
-        settings.valueConverter.fromDb = x => settings.valueConverter.fromJson(x);
+        settings.valueConverter.fromDb = function (x) { return settings.valueConverter.fromJson(x); };
     }
     if (!settings.valueConverter.toInput) {
-        settings.valueConverter.toInput = x => settings.valueConverter.toJson(x);
+        settings.valueConverter.toInput = function (x) { return settings.valueConverter.toJson(x); };
     }
     if (!settings.valueConverter.fromInput) {
-        settings.valueConverter.fromInput = x => settings.valueConverter.fromJson(x);
+        settings.valueConverter.fromInput = function (x) { return settings.valueConverter.fromJson(x); };
     }
     return settings;
 }
-export function BuildEntity(c, key, fields, ...options) {
-    Entity(key, ...options)(c);
-    for (const fieldKey in fields) {
+exports.decorateColumnSettings = decorateColumnSettings;
+function BuildEntity(c, key, fields) {
+    var options = [];
+    for (var _i = 3; _i < arguments.length; _i++) {
+        options[_i - 3] = arguments[_i];
+    }
+    Entity.apply(void 0, tslib_1.__spread([key], options))(c);
+    for (var fieldKey in fields) {
         if (Object.prototype.hasOwnProperty.call(fields, fieldKey)) {
-            const element = fields[fieldKey];
+            var element = fields[fieldKey];
             element(c.prototype, fieldKey);
         }
     }
 }
+exports.BuildEntity = BuildEntity;
 /**Decorates classes that should be used as entities.
  * Receives a key and an array of EntityOptions.
  * @example
@@ -1601,191 +2646,321 @@ export function BuildEntity(c, key, fields, ...options) {
  * // as an arrow function that receives `remult` as a parameter
  * @Entity("tasks", (options,remult) => options.allowApiCrud = true)
  */
-export function Entity(key, ...options) {
-    return target => {
-        for (const customFilterMember in target) {
+function Entity(key) {
+    var options = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        options[_i - 1] = arguments[_i];
+    }
+    return function (target) {
+        var _a;
+        for (var customFilterMember in target) {
             if (Object.prototype.hasOwnProperty.call(target, customFilterMember)) {
-                const element = target[customFilterMember];
-                if (element?.customFilterInfo?.customFilterTranslator) {
+                var element = target[customFilterMember];
+                if ((_a = element === null || element === void 0 ? void 0 : element.customFilterInfo) === null || _a === void 0 ? void 0 : _a.customFilterTranslator) {
                     if (!element.customFilterInfo.key)
                         element.customFilterInfo.key = customFilterMember;
                 }
             }
         }
-        let factory = remult => {
-            let r = {};
-            for (const o of options) {
-                if (o) {
-                    if (typeof o === "function")
-                        o(r, remult);
-                    else
-                        Object.assign(r, o);
+        var factory = function (remult) {
+            var e_35, _a;
+            var r = {};
+            try {
+                for (var options_3 = tslib_1.__values(options), options_3_1 = options_3.next(); !options_3_1.done; options_3_1 = options_3.next()) {
+                    var o = options_3_1.value;
+                    if (o) {
+                        if (typeof o === "function")
+                            o(r, remult);
+                        else
+                            Object.assign(r, o);
+                    }
                 }
             }
-            let base = Object.getPrototypeOf(target);
+            catch (e_35_1) { e_35 = { error: e_35_1 }; }
+            finally {
+                try {
+                    if (options_3_1 && !options_3_1.done && (_a = options_3.return)) _a.call(options_3);
+                }
+                finally { if (e_35) throw e_35.error; }
+            }
+            var base = Object.getPrototypeOf(target);
             if (base) {
-                let baseFactory = getEntitySettings(base, false);
+                var baseFactory = getEntitySettings(base, false);
                 if (baseFactory) {
-                    let opt = baseFactory(remult);
+                    var opt = baseFactory(remult);
                     if (opt) {
-                        r = {
-                            ...opt,
-                            ...r
-                        };
+                        r = tslib_1.__assign(tslib_1.__assign({}, opt), r);
                     }
                 }
             }
             return r;
         };
-        allEntities.push(target);
-        setControllerSettings(target, { key });
-        Reflect.defineMetadata(entityInfo, factory, target);
-        Reflect.defineMetadata(entityInfo_key, key, target);
+        context_1.allEntities.push(target);
+        context_1.setControllerSettings(target, { key: key });
+        Reflect.defineMetadata(exports.entityInfo, factory, target);
+        Reflect.defineMetadata(exports.entityInfo_key, key, target);
         return target;
     };
 }
-export class EntityBase {
-    get _() { return getEntityRef(this); }
-    save() { return this._.save(); }
-    assign(values) {
-        assign(this, values);
+exports.Entity = Entity;
+var EntityBase = /** @class */ (function () {
+    function EntityBase() {
+    }
+    Object.defineProperty(EntityBase.prototype, "_", {
+        get: function () { return getEntityRef(this); },
+        enumerable: false,
+        configurable: true
+    });
+    EntityBase.prototype.save = function () { return this._.save(); };
+    EntityBase.prototype.assign = function (values) {
+        assign_1.assign(this, values);
         return this;
-    }
-    delete() { return this._.delete(); }
-    isNew() { return this._.isNew(); }
-    get $() { return this._.fields; }
-}
-export class ControllerBase {
-    constructor(remult) {
+    };
+    EntityBase.prototype.delete = function () { return this._.delete(); };
+    EntityBase.prototype.isNew = function () { return this._.isNew(); };
+    Object.defineProperty(EntityBase.prototype, "$", {
+        get: function () { return this._.fields; },
+        enumerable: false,
+        configurable: true
+    });
+    return EntityBase;
+}());
+exports.EntityBase = EntityBase;
+var ControllerBase = /** @class */ (function () {
+    function ControllerBase(remult) {
         this.remult = remult;
     }
-    assign(values) {
-        assign(this, values);
+    ControllerBase.prototype.assign = function (values) {
+        assign_1.assign(this, values);
         return this;
-    }
-    get $() { return getFields(this); }
-    get _() { return getControllerRef(this); }
-}
-class QueryResultImpl {
-    constructor(options, repo) {
+    };
+    Object.defineProperty(ControllerBase.prototype, "$", {
+        get: function () { return getFields(this); },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ControllerBase.prototype, "_", {
+        get: function () { return getControllerRef(this); },
+        enumerable: false,
+        configurable: true
+    });
+    return ControllerBase;
+}());
+exports.ControllerBase = ControllerBase;
+var QueryResultImpl = /** @class */ (function () {
+    function QueryResultImpl(options, repo) {
         this.options = options;
         this.repo = repo;
         this._count = undefined;
         if (!this.options)
             this.options = {};
         if (!this.options.pageSize) {
-            this.options.pageSize = queryConfig.defaultPageSize;
-        }
-    }
-    async getPage(page) {
-        if (page < 1)
-            page = 1;
-        return this.repo.find({
-            where: this.options.where,
-            orderBy: this.options.orderBy,
-            limit: this.options.pageSize,
-            page: page,
-            load: this.options.load
+            this.options.pageSize = context_1.queryConfig.defaultPageSize;
+        }
+    }
+    QueryResultImpl.prototype.getPage = function (page) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                if (page < 1)
+                    page = 1;
+                return [2 /*return*/, this.repo.find({
+                        where: this.options.where,
+                        orderBy: this.options.orderBy,
+                        limit: this.options.pageSize,
+                        page: page,
+                        load: this.options.load
+                    })];
+            });
         });
-    }
-    async count() {
-        if (this._count === undefined)
-            this._count = await this.repo.count(this.options.where);
-        return this._count;
-    }
-    async forEach(what) {
-        let i = 0;
-        for await (const x of this) {
-            await what(x);
-            i++;
-        }
-        return i;
-    }
-    async paginator(pNextPageFilter) {
-        this.options.orderBy = Sort.createUniqueEntityOrderBy(this.repo.metadata, this.options.orderBy);
-        let items = await this.repo.find({
-            where: { $and: [this.options.where, pNextPageFilter] },
-            orderBy: this.options.orderBy,
-            limit: this.options.pageSize,
-            load: this.options.load
+    };
+    QueryResultImpl.prototype.count = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var _a;
+            return tslib_1.__generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!(this._count === undefined)) return [3 /*break*/, 2];
+                        _a = this;
+                        return [4 /*yield*/, this.repo.count(this.options.where)];
+                    case 1:
+                        _a._count = _b.sent();
+                        _b.label = 2;
+                    case 2: return [2 /*return*/, this._count];
+                }
+            });
         });
-        let nextPage = undefined;
-        let hasNextPage = items.length == this.options.pageSize;
-        if (hasNextPage) {
-            let nextPageFilter = await this.repo.createAfterFilter(this.options.orderBy, items[items.length - 1]);
-            nextPage = () => this.paginator(nextPageFilter);
-        }
-        return {
-            count: () => this.count(),
-            hasNextPage,
-            items,
-            nextPage
-        };
-    }
-    [Symbol.asyncIterator]() {
+    };
+    QueryResultImpl.prototype.forEach = function (what) {
+        var e_36, _a;
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var i, _b, _c, x, e_36_1;
+            return tslib_1.__generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        i = 0;
+                        _d.label = 1;
+                    case 1:
+                        _d.trys.push([1, 7, 8, 13]);
+                        _b = tslib_1.__asyncValues(this);
+                        _d.label = 2;
+                    case 2: return [4 /*yield*/, _b.next()];
+                    case 3:
+                        if (!(_c = _d.sent(), !_c.done)) return [3 /*break*/, 6];
+                        x = _c.value;
+                        return [4 /*yield*/, what(x)];
+                    case 4:
+                        _d.sent();
+                        i++;
+                        _d.label = 5;
+                    case 5: return [3 /*break*/, 2];
+                    case 6: return [3 /*break*/, 13];
+                    case 7:
+                        e_36_1 = _d.sent();
+                        e_36 = { error: e_36_1 };
+                        return [3 /*break*/, 13];
+                    case 8:
+                        _d.trys.push([8, , 11, 12]);
+                        if (!(_c && !_c.done && (_a = _b.return))) return [3 /*break*/, 10];
+                        return [4 /*yield*/, _a.call(_b)];
+                    case 9:
+                        _d.sent();
+                        _d.label = 10;
+                    case 10: return [3 /*break*/, 12];
+                    case 11:
+                        if (e_36) throw e_36.error;
+                        return [7 /*endfinally*/];
+                    case 12: return [7 /*endfinally*/];
+                    case 13: return [2 /*return*/, i];
+                }
+            });
+        });
+    };
+    QueryResultImpl.prototype.paginator = function (pNextPageFilter) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var items, nextPage, hasNextPage, nextPageFilter_1;
+            var _this = this;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this.options.orderBy = sort_1.Sort.createUniqueEntityOrderBy(this.repo.metadata, this.options.orderBy);
+                        return [4 /*yield*/, this.repo.find({
+                                where: { $and: [this.options.where, pNextPageFilter] },
+                                orderBy: this.options.orderBy,
+                                limit: this.options.pageSize,
+                                load: this.options.load
+                            })];
+                    case 1:
+                        items = _a.sent();
+                        nextPage = undefined;
+                        hasNextPage = items.length == this.options.pageSize;
+                        if (!hasNextPage) return [3 /*break*/, 3];
+                        return [4 /*yield*/, this.repo.createAfterFilter(this.options.orderBy, items[items.length - 1])];
+                    case 2:
+                        nextPageFilter_1 = _a.sent();
+                        nextPage = function () { return _this.paginator(nextPageFilter_1); };
+                        _a.label = 3;
+                    case 3: return [2 /*return*/, {
+                            count: function () { return _this.count(); },
+                            hasNextPage: hasNextPage,
+                            items: items,
+                            nextPage: nextPage
+                        }];
+                }
+            });
+        });
+    };
+    QueryResultImpl.prototype[Symbol.asyncIterator] = function () {
+        var _this = this;
         if (!this.options.where) {
             this.options.where = {};
         }
-        let ob = this.options.orderBy;
-        this.options.orderBy = Sort.createUniqueEntityOrderBy(this.repo.metadata, ob);
-        let itemIndex = -1;
-        let currentPage = undefined;
-        let itStrategy;
-        let j = 0;
-        itStrategy = async () => {
-            if (this.options.progress) {
-                this.options.progress.progress(j++ / await this.count());
-            }
-            if (currentPage === undefined || itemIndex == currentPage.items.length) {
-                if (currentPage && !currentPage.hasNextPage)
-                    return { value: undefined, done: true };
-                let prev = currentPage;
-                if (currentPage)
-                    currentPage = await currentPage.nextPage();
-                else
-                    currentPage = await this.paginator();
-                itemIndex = 0;
-                if (currentPage.items.length == 0) {
-                    return { value: undefined, done: true };
-                }
-                else {
-                    if (prev?.items.length > 0) {
-                        if (this.repo.getEntityRef(prev.items[0]).getId() == this.repo.getEntityRef(currentPage.items[0]).getId())
-                            throw new Error("pagination failure, returned same first row");
-                    }
+        var ob = this.options.orderBy;
+        this.options.orderBy = sort_1.Sort.createUniqueEntityOrderBy(this.repo.metadata, ob);
+        var itemIndex = -1;
+        var currentPage = undefined;
+        var itStrategy;
+        var j = 0;
+        itStrategy = function () { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+            var _a, _b, _c, prev;
+            return tslib_1.__generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        if (!this.options.progress) return [3 /*break*/, 2];
+                        _b = (_a = this.options.progress).progress;
+                        _c = j++;
+                        return [4 /*yield*/, this.count()];
+                    case 1:
+                        _b.apply(_a, [_c / (_d.sent())]);
+                        _d.label = 2;
+                    case 2:
+                        if (!(currentPage === undefined || itemIndex == currentPage.items.length)) return [3 /*break*/, 7];
+                        if (currentPage && !currentPage.hasNextPage)
+                            return [2 /*return*/, { value: undefined, done: true }];
+                        prev = currentPage;
+                        if (!currentPage) return [3 /*break*/, 4];
+                        return [4 /*yield*/, currentPage.nextPage()];
+                    case 3:
+                        currentPage = _d.sent();
+                        return [3 /*break*/, 6];
+                    case 4: return [4 /*yield*/, this.paginator()];
+                    case 5:
+                        currentPage = _d.sent();
+                        _d.label = 6;
+                    case 6:
+                        itemIndex = 0;
+                        if (currentPage.items.length == 0) {
+                            return [2 /*return*/, { value: undefined, done: true }];
+                        }
+                        else {
+                            if ((prev === null || prev === void 0 ? void 0 : prev.items.length) > 0) {
+                                if (this.repo.getEntityRef(prev.items[0]).getId() == this.repo.getEntityRef(currentPage.items[0]).getId())
+                                    throw new Error("pagination failure, returned same first row");
+                            }
+                        }
+                        _d.label = 7;
+                    case 7:
+                        if (itemIndex < currentPage.items.length)
+                            return [2 /*return*/, { value: currentPage.items[itemIndex++], done: false }];
+                        return [2 /*return*/];
                 }
-            }
-            if (itemIndex < currentPage.items.length)
-                return { value: currentPage.items[itemIndex++], done: false };
-        };
+            });
+        }); };
         return {
-            next: async () => {
-                let r = itStrategy();
-                return r;
-            }
+            next: function () { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                var r;
+                return tslib_1.__generator(this, function (_a) {
+                    r = itStrategy();
+                    return [2 /*return*/, r];
+                });
+            }); }
         };
-    }
-}
-class cacheEntityInfo {
-    constructor() {
+    };
+    return QueryResultImpl;
+}());
+var cacheEntityInfo = /** @class */ (function () {
+    function cacheEntityInfo() {
         this.value = {};
     }
-}
-class SubscribableImp {
-    reportChanged() {
-        if (this._subscribers)
-            this._subscribers.forEach(x => x.reportChanged());
+    return cacheEntityInfo;
+}());
+var SubscribableImp = /** @class */ (function () {
+    function SubscribableImp() {
     }
-    reportObserved() {
+    SubscribableImp.prototype.reportChanged = function () {
         if (this._subscribers)
-            this._subscribers.forEach(x => x.reportObserved());
-    }
-    subscribe(listener) {
-        let list;
+            this._subscribers.forEach(function (x) { return x.reportChanged(); });
+    };
+    SubscribableImp.prototype.reportObserved = function () {
+        if (this._subscribers)
+            this._subscribers.forEach(function (x) { return x.reportObserved(); });
+    };
+    SubscribableImp.prototype.subscribe = function (listener) {
+        var _this = this;
+        var list;
         if (typeof listener === "function")
             list = {
-                reportChanged: () => listener(),
-                reportObserved: () => { }
+                reportChanged: function () { return listener(); },
+                reportObserved: function () { }
             };
         else
             list = listener;
@@ -1793,6 +2968,7 @@ class SubscribableImp {
             this._subscribers = [];
         }
         this._subscribers.push(list);
-        return () => this._subscribers = this._subscribers.filter(x => x != list);
-    }
-}
+        return function () { return _this._subscribers = _this._subscribers.filter(function (x) { return x != list; }); };
+    };
+    return SubscribableImp;
+}());