remult 0.14.7 → 0.14.8

package/esm/src/remult3/RepositoryImplementation.js

@@ -0,0 +1,1806 @@
+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;
+// import("class-validator".toString())
+//     .then((v) => {
+//         classValidatorValidate = (item, ref) => {
+//             return v.validate(item).then(errors => {
+//                 for (const err of errors) {
+//                     for (const key in err.constraints) {
+//                         if (Object.prototype.hasOwnProperty.call(err.constraints, key)) {
+//                             const element = err.constraints[key];
+//                             ref.fields.find(err.property).error = element;
+//                         }
+//                     }
+//                 }
+//             });
+//         }
+//     })
+//     .catch(() => {
+//     });
+export class RepositoryImplementation {
+    constructor(entity, remult, dataProvider) {
+        this.entity = entity;
+        this.remult = remult;
+        this.dataProvider = dataProvider;
+        this.idCache = new Map();
+        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) {
+        id = id + '';
+        this.getCachedByIdAsync(id);
+        let 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;
+        });
+        this.idCache.set(id, row);
+        return await row;
+    }
+    addToCache(item) {
+        if (item)
+            this.idCache.set(this.getEntityRef(item).getId() + '', item);
+    }
+    get metadata() { return this._info; }
+    ;
+    addEventListener(listener) {
+        if (!this.listeners)
+            this.listeners = [];
+        this.listeners.push(listener);
+        return () => {
+            this.listeners.splice(this.listeners.indexOf(listener), 1);
+        };
+    }
+    query(options) {
+        return new QueryResultImpl(options, this);
+    }
+    getEntityRef(entity) {
+        let x = entity[entityMember];
+        if (!x) {
+            x = new rowHelperImplementation(this._info, entity, this, this.edp, this.remult, true);
+            Object.defineProperty(entity, entityMember, {
+                get: () => 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);
+        if (!ref) {
+            const instance = new this.entity(this.remult);
+            for (const field of this.fieldsOf(entity)) {
+                instance[field.key] = entity[field.key];
+            }
+            let row = new rowHelperImplementation(this._info, instance, this, this.edp, this.remult, false);
+            if (id)
+                row.id = id;
+            else
+                row.id = row.getId();
+            ref = row;
+            Object.defineProperty(instance, entityMember, {
+                get: () => row
+            });
+        }
+        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);
+            }
+        }
+    }
+    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);
+                        }
+                    }
+                    if (toLoad.length > 0) {
+                        await loadManyToOne(repo, toLoad);
+                    }
+                }
+            }
+        }
+        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);
+                }
+                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);
+                }
+            }
+            return r;
+        });
+        if (cacheInfo) {
+            cacheInfo.promise = r = r.then(r => {
+                cacheInfo.value = r;
+                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);
+        if (item)
+            for (const field of this.fieldsOf(item)) {
+                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]);
+            }
+        }
+        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) {
+        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),
+        });
+    }
+    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 = () => { };
+    if (w) {
+        w.__applyToConsumer({
+            custom: emptyFunction,
+            databaseCustom: emptyFunction,
+            containsCaseInsensitive: emptyFunction,
+            isDifferentFrom: emptyFunction,
+            isEqualTo: (col, val) => {
+                r[col.key] = val;
+            },
+            isGreaterOrEqualTo: emptyFunction,
+            isGreaterThan: emptyFunction,
+            isIn: emptyFunction,
+            isLessOrEqualTo: emptyFunction,
+            isLessThan: emptyFunction,
+            isNotNull: emptyFunction,
+            isNull: emptyFunction,
+            or: emptyFunction
+        });
+    }
+}
+export const entityInfo = Symbol("entityInfo");
+export const entityInfo_key = Symbol("entityInfo_key");
+const entityMember = Symbol("entityMember");
+export function getEntitySettings(entity, throwError = true) {
+    if (entity === undefined)
+        if (throwError) {
+            throw new Error("Undefined is not an entity :)");
+        }
+        else
+            return undefined;
+    let info = Reflect.getMetadata(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);
+}
+export const columnsOfType = new Map();
+export function createOldEntity(entity, remult) {
+    let r = 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);
+        if (baseCols) {
+            r.unshift(...baseCols.filter(x => !r.find(y => y.key == x.key)));
+        }
+        let 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);
+                    };
+                }
+            }
+        }
+        base = Object.getPrototypeOf(base);
+    }
+    return new EntityFullInfo(prepareColumnInfo(r, remult), info, remult, entity, key);
+}
+class rowHelperBase {
+    constructor(columnsInfo, instance, remult) {
+        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);
+            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;
+                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();
+                                }
+                            }
+                            refImpl._subscribers.reportObserved();
+                        }
+                        return lookup.item;
+                    },
+                    set: (val) => {
+                        lookup.set(val);
+                        this._subscribers?.reportChanged();
+                        if (!refImpl) {
+                            refImpl = this.fields.find(col.key);
+                            if (!refImpl._subscribers) {
+                                refImpl._subscribers = new SubscribableImp();
+                            }
+                        }
+                        refImpl._subscribers.reportChanged();
+                    },
+                    enumerable: true
+                });
+                lookup.set(val);
+            }
+            else {
+            }
+        }
+    }
+    get error() {
+        this._subscribers?.reportObserved();
+        return this._error;
+    }
+    set error(val) {
+        this._error = val;
+        this._subscribers?.reportChanged();
+    }
+    subscribe(listener) {
+        this.initSubscribers();
+        return this._subscribers.subscribe(listener);
+    }
+    initSubscribers() {
+        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);
+                refImpl._subscribers = new SubscribableImp();
+                if (ei && this.remult) {
+                }
+                else {
+                    let val = this.instance[col.key];
+                    Object.defineProperty(this.instance, col.key, {
+                        get: () => {
+                            this._subscribers.reportObserved();
+                            refImpl._subscribers.reportObserved();
+                            return val;
+                        },
+                        set: (value) => {
+                            val = value;
+                            this._subscribers.reportChanged();
+                            refImpl._subscribers.reportChanged();
+                        },
+                        enumerable: true
+                    });
+                }
+            }
+        }
+    }
+    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() {
+        if (!this.hasErrors()) {
+            let 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;
+                    }
+                }
+            }
+            throw error;
+        }
+    }
+    catchSaveErrors(err) {
+        let e = err;
+        if (e instanceof Promise) {
+            return e.then(x => this.catchSaveErrors(x));
+        }
+        if (e.error) {
+            e = e.error;
+        }
+        if (e.message)
+            this.error = e.message;
+        else if (e.Message)
+            this.error = e.Message;
+        else
+            this.error = e;
+        let s = e.modelState;
+        if (!s)
+            s = e.ModelState;
+        if (s) {
+            this.errors = s;
+        }
+        throw err;
+    }
+    __clearErrorsAndReportChanged() {
+        this.errors = undefined;
+        this.error = undefined;
+        this._reportChangedToEntityAndFields();
+    }
+    _reportChangedToEntityAndFields() {
+        if (this._subscribers) {
+            this._subscribers.reportChanged();
+            for (const field of this.fields) {
+                let ref = field;
+                ref._subscribers.reportChanged();
+            }
+        }
+    }
+    hasErrors() {
+        this._subscribers?.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)));
+            }
+            d[col.key] = val;
+        }
+        return d;
+    }
+    saveOriginalData() {
+        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();
+                            }
+                        }
+                    }
+                }
+                result[col.key] = col.valueConverter.toJson(val);
+            }
+        }
+        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]);
+                    }
+                }
+        }
+        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;
+        if (_isNew) {
+            for (const col of info.columnsInfo) {
+                if (col.defaultValue) {
+                    if (typeof col.defaultValue === "function") {
+                        instance[col.key] = col.defaultValue(instance);
+                    }
+                    else if (!instance[col.key])
+                        instance[col.key] = col.defaultValue;
+                }
+            }
+        }
+        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)
+            return this.info.idMetadata.field.getId(this.instance);
+        else
+            return this.instance[this.info.idMetadata.field.key];
+    }
+    wasDeleted() {
+        this._subscribers?.reportObserved();
+        return this._wasDeleted;
+    }
+    undoChanges() {
+        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();
+        });
+        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;
+                }
+            }
+            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);
+                }
+                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;
+                            }
+                        }
+                    }
+                    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);
+                    }
+                }
+                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();
+                }
+                else {
+                    if (loadItems.includes(col))
+                        await lu.waitLoad();
+                }
+            }
+            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() {
+        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);
+                }
+            }
+    }
+    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();
+            }
+        }
+        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);
+            }
+    }
+}
+const controllerColumns = Symbol("controllerColumns");
+function prepareColumnInfo(r, remult) {
+    return r.map(x => decorateColumnSettings(x.settings(remult), remult));
+}
+export function getFields(container, remult) {
+    return getControllerRef(container, remult).fields;
+}
+export function getControllerRef(container, remult) {
+    let 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);
+        while (base != null) {
+            let baseCols = columnsOfType.get(base);
+            if (baseCols) {
+                columnSettings.unshift(...baseCols.filter(x => !columnSettings.find(y => y.key == x.key)));
+            }
+            base = Object.getPrototypeOf(base);
+        }
+        container[controllerColumns] = result = new controllerRefImpl(prepareColumnInfo(columnSettings, 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();
+            }
+        }
+    }
+}
+export class FieldRefImplementation {
+    constructor(settings, metadata, container, helper, rowBase) {
+        this.settings = settings;
+        this.metadata = metadata;
+        this.container = container;
+        this.helper = helper;
+        this.rowBase = rowBase;
+        this.target = this.settings.target;
+        this.entityRef = this.helper;
+    }
+    subscribe(listener) {
+        if (!this._subscribers) {
+            this.rowBase.initSubscribers();
+        }
+        return this._subscribers.subscribe(listener);
+    }
+    valueIsNull() {
+        this.reportObserved();
+        let lu = this.rowBase.lookups.get(this.metadata.key);
+        if (lu) {
+            return lu.id === undefined || lu.id === null;
+        }
+        return this.value === null;
+    }
+    originalValueIsNull() {
+        this.reportObserved();
+        let 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());
+            }
+            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 "";
+    }
+    ;
+    get value() { return this.container[this.metadata.key]; }
+    ;
+    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];
+    }
+    ;
+    rawOriginalValue() {
+        return this.rowBase.originalValues[this.metadata.key];
+    }
+    setId(id) {
+        this.value = id;
+    }
+    getId() {
+        let 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);
+    }
+    ;
+    valueChanged() {
+        this.reportObserved();
+        let val = this.value;
+        let 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);
+                }
+            }
+            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];
+    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
+};
+export function buildCaption(caption, key, remult) {
+    let result;
+    if (typeof (caption) === "function") {
+        if (remult)
+            result = caption(remult);
+    }
+    else if (caption)
+        result = caption;
+    result = CaptionTransformer.transformCaption(remult, key, result);
+    if (result)
+        return result;
+    if (key)
+        return makeTitle(key);
+    return '';
+}
+export class columnDefsImpl {
+    constructor(settings, entityDefs, remult) {
+        this.settings = settings;
+        this.entityDefs = entityDefs;
+        this.options = this.settings;
+        this.target = this.settings.target;
+        this.valueConverter = this.settings.valueConverter;
+        this.allowNull = !!this.settings.allowNull;
+        this.inputType = this.settings.inputType;
+        this.key = this.settings.key;
+        this.valueType = this.settings.valueType;
+        if (settings.serverExpression)
+            this.isServerExpression = true;
+        if (typeof (this.settings.allowApiUpdate) === "boolean")
+            this.readonly = this.settings.allowApiUpdate;
+        if (!this.inputType)
+            this.inputType = this.valueConverter.inputType;
+        this.caption = buildCaption(settings.caption, settings.key, remult);
+    }
+    getDbName() {
+        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);
+                }
+                else
+                    return this.settings.sqlExpression;
+            }
+            return this.settings.dbName;
+        })().then(x => {
+            if (x)
+                return x;
+            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);
+            }
+            else
+                result = this.settings.sqlExpression;
+        }
+        if (result)
+            return result;
+        return this.settings.dbName;
+    }
+    get dbReadOnly() {
+        return this.settings.dbReadOnly;
+    }
+    ;
+}
+class EntityFullInfo {
+    constructor(columnsInfo, entityInfo, remult, entityType, key) {
+        this.columnsInfo = columnsInfo;
+        this.entityInfo = entityInfo;
+        this.remult = remult;
+        this.entityType = entityType;
+        this.key = key;
+        this.options = this.entityInfo;
+        this.idMetadata = {
+            field: undefined,
+            createIdInFilter: (items) => {
+                if (items.length > 0)
+                    return {
+                        $or: items.map(x => this.idMetadata.getIdFilter(getEntityRef(x).getId()))
+                    };
+            },
+            isIdField: (col) => {
+                return col.key == this.idMetadata.field.key;
+            },
+            getIdFilter: (...ids) => {
+                if (this.idMetadata.field instanceof CompoundIdField) {
+                    let field = this.idMetadata.field;
+                    return {
+                        $or: ids.map(x => field.isEqualTo(x))
+                    };
+                }
+                if (ids.length == 1)
+                    return {
+                        [this.idMetadata.field.key]: ids[0]
+                    };
+                else
+                    return {
+                        [this.idMetadata.field.key]: ids
+                    };
+            }
+        };
+        if (this.options.allowApiCrud !== undefined) {
+            if (this.options.allowApiDelete === undefined)
+                this.options.allowApiDelete = this.options.allowApiCrud;
+            if (this.options.allowApiInsert === undefined)
+                this.options.allowApiInsert = this.options.allowApiCrud;
+            if (this.options.allowApiUpdate === undefined)
+                this.options.allowApiUpdate = this.options.allowApiCrud;
+            if (this.options.allowApiRead === undefined)
+                this.options.allowApiRead = this.options.allowApiCrud;
+        }
+        if (this.options.allowApiRead === undefined)
+            this.options.allowApiRead = true;
+        if (!this.key)
+            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));
+        }
+        this.fields = r;
+        this.caption = buildCaption(entityInfo.caption, this.key, remult);
+        if (entityInfo.id) {
+            let r = entityInfo.id(this.fields);
+            if (Array.isArray(r)) {
+                if (r.length > 1)
+                    this.idMetadata.field = new CompoundIdField(...r);
+                else if (r.length == 1)
+                    this.idMetadata.field = r[0];
+            }
+            else
+                this.idMetadata.field = r;
+        }
+        else {
+            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() {
+        if (this.dbNamePromise)
+            return this.dbNamePromise;
+        if (!this.options.sqlExpression) {
+            this.dbNamePromise = Promise.resolve(this.options.dbName);
+        }
+        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);
+            if (r instanceof Promise)
+                this.dbNamePromise = r;
+            else if (r)
+                this.dbNamePromise = Promise.resolve(r);
+        }
+        this.dbNamePromise = this.dbNamePromise.then(x => {
+            if (!x)
+                return this.options.dbName;
+            return x;
+        });
+        return this.dbNamePromise;
+    }
+}
+export function FieldType(...options) {
+    return target => {
+        if (!options) {
+            options = [];
+        }
+        options.splice(0, 0, { valueType: target });
+        Reflect.defineMetadata(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);
+    }
+    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';
+}
+export function ValueListFieldType(...options) {
+    return (type) => {
+        FieldType(o => {
+            o.valueConverter = ValueListInfo.get(type),
+                o.displayValue = (item, val) => val.caption;
+        }, ...options)(type);
+    };
+}
+export class ValueListInfo {
+    constructor(valueListType) {
+        this.valueListType = valueListType;
+        this.byIdMap = new Map();
+        this.values = [];
+        this.isNumeric = false;
+        for (let member in this.valueListType) {
+            let 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);
+                this.byIdMap.set(s.id, s);
+                this.values.push(s);
+            }
+        }
+        if (this.isNumeric) {
+            this.fieldTypeInDb = 'integer';
+        }
+        var options = Reflect.getMetadata(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);
+                    });
+                }
+            }
+            if (this.values.find(s => 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);
+    }
+    static get(type) {
+        let r = typeCache.get(type);
+        if (!r) {
+            r = new ValueListInfo(type);
+            typeCache.set(type, r);
+        }
+        return r;
+    }
+    getValues() {
+        return this.values;
+    }
+    byId(key) {
+        if (this.isNumeric)
+            key = +key;
+        return this.byIdMap.get(key);
+    }
+    fromJson(val) {
+        return this.byId(val);
+    }
+    toJson(val) {
+        if (!val)
+            return undefined;
+        return val.id;
+    }
+    fromDb(val) {
+        return this.fromJson(val);
+    }
+    toDb(val) {
+        return this.toJson(val);
+    }
+    toInput(val, inputType) {
+        return this.toJson(val);
+    }
+    fromInput(val, inputType) {
+        return this.fromJson(val);
+    }
+    displayValue(val) {
+        if (!val)
+            return '';
+        return val.caption;
+    }
+}
+const typeCache = new Map();
+export function getValueList(type) {
+    {
+        const fr = type?.metadata?.valueType;
+        if (fr)
+            return ValueListInfo.get(fr).getValues();
+    }
+    {
+        const fr = type?.valueType;
+        if (fr)
+            return ValueListInfo.get(fr).getValues();
+    }
+    return ValueListInfo.get(type).getValues();
+}
+/**Decorates fields that should be used as fields.
+ * for more info see: [Field Types](https://remult.dev/docs/field-types.html)
+ *
+ * FieldOptions can be set in two ways:
+ * @example
+ * // as an object
+ * @Fields.string({ includeInApi:false })
+ * title='';
+ * @example
+ * // as an arrow function that receives `remult` as a parameter
+ * @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);
+            if (!r.valueType && valueType) {
+                r.valueType = valueType();
+            }
+            if (!r.key) {
+                r.key = key;
+            }
+            if (!r.dbName)
+                r.dbName = r.key;
+            let type = r.valueType;
+            if (!type) {
+                type = Reflect.getMetadata("design:type", target, key);
+                r.valueType = type;
+            }
+            if (!r.target)
+                r.target = target;
+            return r;
+        };
+        let names = columnsOfType.get(target.constructor);
+        if (!names) {
+            names = [];
+            columnsOfType.set(target.constructor, names);
+        }
+        let set = names.find(x => x.key == key);
+        if (!set)
+            names.push({
+                key,
+                settings: factory,
+            });
+        else {
+            let prev = set.settings;
+            set.settings = (c) => {
+                let prevO = prev(c);
+                let curr = factory(c);
+                return Object.assign(prevO, curr);
+            };
+        }
+    };
+}
+export const 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);
+        }
+    }
+    return r;
+}
+export function decorateColumnSettings(settings, remult) {
+    if (settings.valueType) {
+        let settingsOnTypeLevel = Reflect.getMetadata(storableMember, settings.valueType);
+        if (settingsOnTypeLevel) {
+            settings = {
+                ...buildOptions(settingsOnTypeLevel, remult),
+                ...settings
+            };
+        }
+    }
+    if (settings.valueType == String) {
+        let x = settings;
+        if (!settings.valueConverter)
+            x.valueConverter = {
+                toJson: x => x,
+                fromJson: x => x
+            };
+    }
+    if (settings.valueType == Number) {
+        let x = settings;
+        if (!settings.valueConverter)
+            x.valueConverter = ValueConverters.Number;
+    }
+    if (settings.valueType == Date) {
+        let x = settings;
+        if (!settings.valueConverter) {
+            x.valueConverter = ValueConverters.Date;
+        }
+    }
+    if (settings.valueType == Boolean) {
+        let x = settings;
+        if (!x.valueConverter)
+            x.valueConverter = ValueConverters.Boolean;
+    }
+    if (!settings.valueConverter) {
+        let ei = getEntitySettings(settings.valueType, false);
+        if (ei) {
+            settings.valueConverter = {
+                toDb: x => x,
+                fromDb: x => x
+            };
+        }
+        else
+            settings.valueConverter = ValueConverters.Default;
+    }
+    if (!settings.valueConverter.toJson) {
+        settings.valueConverter.toJson = x => x;
+    }
+    if (!settings.valueConverter.fromJson) {
+        settings.valueConverter.fromJson = x => x;
+    }
+    if (!settings.valueConverter.toDb) {
+        settings.valueConverter.toDb = x => settings.valueConverter.toJson(x);
+    }
+    if (!settings.valueConverter.fromDb) {
+        settings.valueConverter.fromDb = x => settings.valueConverter.fromJson(x);
+    }
+    if (!settings.valueConverter.toInput) {
+        settings.valueConverter.toInput = x => settings.valueConverter.toJson(x);
+    }
+    if (!settings.valueConverter.fromInput) {
+        settings.valueConverter.fromInput = x => settings.valueConverter.fromJson(x);
+    }
+    return settings;
+}
+export function BuildEntity(c, key, fields, ...options) {
+    Entity(key, ...options)(c);
+    for (const fieldKey in fields) {
+        if (Object.prototype.hasOwnProperty.call(fields, fieldKey)) {
+            const element = fields[fieldKey];
+            element(c.prototype, fieldKey);
+        }
+    }
+}
+/**Decorates classes that should be used as entities.
+ * Receives a key and an array of EntityOptions.
+ * @example
+ * import { Entity, Fields } from "remult";
+ * @Entity("tasks", {
+ *    allowApiCrud: true
+ * })
+ * export class Task {
+ *    @Fields.uuid()
+ *    id!: string;
+ *    @Fields.string()
+ *    title = '';
+ *    @Fields.boolean()
+ *    completed = false;
+ * }
+ * @note
+ * EntityOptions can be set in two ways:
+ * @example
+ * // as an object
+ * @Entity("tasks",{ allowApiCrud:true })
+ * @example
+ * // 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) {
+            if (Object.prototype.hasOwnProperty.call(target, customFilterMember)) {
+                const element = target[customFilterMember];
+                if (element?.customFilterInfo?.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);
+                }
+            }
+            let base = Object.getPrototypeOf(target);
+            if (base) {
+                let baseFactory = getEntitySettings(base, false);
+                if (baseFactory) {
+                    let opt = baseFactory(remult);
+                    if (opt) {
+                        r = {
+                            ...opt,
+                            ...r
+                        };
+                    }
+                }
+            }
+            return r;
+        };
+        allEntities.push(target);
+        setControllerSettings(target, { key });
+        Reflect.defineMetadata(entityInfo, factory, target);
+        Reflect.defineMetadata(entityInfo_key, key, target);
+        return target;
+    };
+}
+export class EntityBase {
+    get _() { return getEntityRef(this); }
+    save() { return this._.save(); }
+    assign(values) {
+        assign(this, values);
+        return this;
+    }
+    delete() { return this._.delete(); }
+    isNew() { return this._.isNew(); }
+    get $() { return this._.fields; }
+}
+export class ControllerBase {
+    constructor(remult) {
+        this.remult = remult;
+    }
+    assign(values) {
+        assign(this, values);
+        return this;
+    }
+    get $() { return getFields(this); }
+    get _() { return getControllerRef(this); }
+}
+class QueryResultImpl {
+    constructor(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
+        });
+    }
+    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
+        });
+        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]() {
+        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");
+                    }
+                }
+            }
+            if (itemIndex < currentPage.items.length)
+                return { value: currentPage.items[itemIndex++], done: false };
+        };
+        return {
+            next: async () => {
+                let r = itStrategy();
+                return r;
+            }
+        };
+    }
+}
+class cacheEntityInfo {
+    constructor() {
+        this.value = {};
+    }
+}
+class SubscribableImp {
+    reportChanged() {
+        if (this._subscribers)
+            this._subscribers.forEach(x => x.reportChanged());
+    }
+    reportObserved() {
+        if (this._subscribers)
+            this._subscribers.forEach(x => x.reportObserved());
+    }
+    subscribe(listener) {
+        let list;
+        if (typeof listener === "function")
+            list = {
+                reportChanged: () => listener(),
+                reportObserved: () => { }
+            };
+        else
+            list = listener;
+        if (!this._subscribers) {
+            this._subscribers = [];
+        }
+        this._subscribers.push(list);
+        return () => this._subscribers = this._subscribers.filter(x => x != list);
+    }
+}