remult 0.22.2 → 0.22.3

package/esm/core/src/remult3/RepositoryImplementation.js

@@ -1,2109 +0,0 @@
-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 { createId } from '@paralleldrive/cuid2';
-import { ValueConverters } from "../valueConverters";
-import { filterHelper } from "../filter/filter-interfaces";
-import { assign } from "../../assign";
-import { remult as defaultRemult } from "../remult-proxy";
-//import { remult } from "../remult-proxy";
-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 {
-    entity;
-    remult;
-    dataProvider;
-    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;
-    }
-    _info;
-    __edp;
-    get edp() {
-        return this.__edp ? this.__edp : this.__edp = this.dataProvider.getEntityDataProvider(this.metadata);
-    }
-    constructor(entity, remult, dataProvider) {
-        this.entity = entity;
-        this.remult = remult;
-        this.dataProvider = dataProvider;
-        this._info = createOldEntity(entity, remult);
-    }
-    idCache = new Map();
-    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;
-    }
-    //TODO2 - Used to prevent unnecessary many to one relations
-    addToCache(item) {
-        if (item)
-            this.idCache.set(this.getEntityRef(item).getId() + '', item);
-    }
-    get metadata() { return this._info; }
-    ;
-    listeners;
-    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) {
-            this.fixTypes(entity);
-            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();
-            }
-        }
-    }
-    get fields() {
-        return this.metadata.fields;
-    }
-    async validate(entity, ...fields) {
-        {
-            let ref = getEntityRef(entity, false);
-            if (!ref)
-                ref = this.getEntityRef({ ...entity });
-            if (!fields || fields.length === 0) {
-                return await ref.validate();
-            }
-            else {
-                ref.__clearErrorsAndReportChanged();
-                let hasError = false;
-                for (const f of fields) {
-                    if (!await ref.fields.find(f).validate())
-                        hasError = true;
-                }
-                if (!hasError)
-                    return undefined;
-                return ref.buildErrorInfoObject();
-            }
-        }
-    }
-    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];
-            }
-            this.fixTypes(instance);
-            let row = new rowHelperImplementation(this._info, instance, this, this.edp, this.remult, false);
-            if (typeof (id) === "object")
-                id = this.metadata.idMetadata.getId(id);
-            if (id) {
-                row.id = id;
-                row.originalId = 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 = this.metadata.idMetadata.getId(entity);
-                if (id === undefined)
-                    return this.insert(entity);
-                return this.update(id, entity);
-            }
-        }
-    }
-    liveQuery(options) {
-        if (!options)
-            options = {};
-        return {
-            subscribe: (l) => {
-                let listener = l;
-                if (typeof l === "function") {
-                    listener = {
-                        next: l,
-                        complete: () => { },
-                        error: () => { }
-                    };
-                }
-                listener.error ??= () => { };
-                listener.complete ??= () => { };
-                return this.remult.liveQuerySubscriber.subscribe(this, options, listener);
-            }
-        };
-    }
-    async find(options, skipOrderByAndLimit = false) {
-        Remult.onFind(this._info, options);
-        if (!options)
-            options = {};
-        let opt = await this.buildEntityDataProviderFindOptions(options);
-        if (skipOrderByAndLimit) {
-            delete opt.orderBy;
-            delete opt.limit;
-        }
-        let rawRows = await this.edp.find(opt);
-        let result = await this.loadManyToOneForManyRows(rawRows, options.load);
-        return result;
-    }
-    async buildEntityDataProviderFindOptions(options) {
-        let opt = {};
-        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;
-        return opt;
-    }
-    async fromJsonArray(jsonItems, load) {
-        return this.loadManyToOneForManyRows(jsonItems.map(row => {
-            let result = {};
-            for (const col of this.metadata.fields.toArray()) {
-                result[col.key] = col.valueConverter.fromJson(row[col.key]);
-            }
-            return result;
-        }), load);
-    }
-    async loadManyToOneForManyRows(rawRows, load) {
-        let loadFields = undefined;
-        if (load)
-            loadFields = 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);
-                    }
-                }
-            }
-        }
-        async function loadManyToOne(repo, toLoad) {
-            let rows = await repo.find({ where: repo.metadata.idMetadata.getIdFilter(...toLoad) }, true);
-            for (const r of rows) {
-                repo.addToCache(r);
-            }
-        }
-        let result = await Promise.all(rawRows.map(async (r) => await this.mapRawDataToResult(r, loadFields)));
-        return result;
-    }
-    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;
-    }
-    toJson(item) {
-        if (Array.isArray(item))
-            return item.map(x => this.toJson(x));
-        return this.getEntityRef(item).toApiJson(true);
-    }
-    fromJson(json, newRow) {
-        if (json === null || json === undefined)
-            return json;
-        if (Array.isArray(json))
-            return json.map(item => this.fromJson(item));
-        let result = new this.entity(this.remult);
-        for (const col of this.fieldsOf(json)) {
-            let ei = getEntitySettings(col.valueType, false);
-            if (ei) {
-                result[col.key] = this.remult.repo(col.valueType).fromJson(json[col.key]);
-            }
-            else {
-                if (json[col.key] !== undefined) {
-                    result[col.key] = col.valueConverter.fromJson(json[col.key]);
-                }
-            }
-        }
-        this.fixTypes(result);
-        if (newRow) {
-            return this.create(result);
-        }
-        else {
-            let row = new rowHelperImplementation(this._info, result, this, this.edp, this.remult, false);
-            Object.defineProperty(result, entityMember, {
-                get: () => row
-            });
-            row.saveOriginalData();
-            return result;
-        }
-    }
-    async count(where) {
-        return this.edp.count(await this.translateWhereToFilter(where));
-    }
-    cache = new Map();
-    async findFirst(where, options, skipOrderByAndLimit = false) {
-        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 }, skipOrderByAndLimit).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];
-            }
-            this.fixTypes(r);
-        }
-        let z = this.getEntityRef(r);
-        return r;
-    }
-    async fixTypes(item) {
-        for (const field of this.fieldsOf(item)) {
-            const val = item[field.key];
-            if (val !== null && val !== undefined) {
-                if (field.valueType === Date && !(val instanceof Date))
-                    item[field.key] = field.valueConverter.fromJson(field.valueConverter.toJson(val));
-                else
-                    for (const [type, typeName] of [[String, "string"], [Number, "number"], [Boolean, "boolean"]]) {
-                        if (field.valueType === type && typeof val !== typeName)
-                            item[field.key] = field.valueConverter.fromJson(field.valueConverter.toJson(val));
-                    }
-            }
-        }
-        return item;
-    }
-    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),
-        }, true);
-    }
-    /* @internal*/
-    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.isProxy) {
-            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 {
-    columnsInfo;
-    instance;
-    remult;
-    _error;
-    get error() {
-        this._subscribers?.reportObserved();
-        return this._error;
-    }
-    set error(val) {
-        this._error = val;
-        this._subscribers?.reportChanged();
-    }
-    constructor(columnsInfo, instance, remult) {
-        this.columnsInfo = columnsInfo;
-        this.instance = instance;
-        this.remult = remult;
-        {
-            let fac = remult;
-            if (fac != null && fac.remultFactory) {
-                remult = fac.remultFactory();
-            }
-        }
-        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 {
-            }
-        }
-    }
-    _subscribers;
-    subscribe(listener) {
-        this.initSubscribers();
-        return this._subscribers.subscribe(listener);
-    }
-    _isLoading = false;
-    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();
-    }
-    lookups = new Map();
-    async waitLoad() {
-        await Promise.all([...this.lookups.values()].map(x => x.waitLoad()));
-    }
-    errors;
-    __assertValidity() {
-        if (!this.hasErrors())
-            throw this.buildErrorInfoObject();
-    }
-    buildErrorInfoObject() {
-        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;
-                }
-            }
-        }
-        return 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;
-    }
-    originalValues = {};
-    saveOriginalData() {
-        this.originalValues = this.copyDataToObject();
-        this.saveMoreOriginalData();
-    }
-    saveMoreOriginalData() {
-    }
-    async validate() {
-        this.__clearErrorsAndReportChanged();
-        if (classValidatorValidate)
-            await classValidatorValidate(this.instance, this);
-        await this.__performColumnAndEntityValidations();
-        let r = this.hasErrors();
-        if (!this.hasErrors())
-            return this.buildErrorInfoObject();
-        else
-            return undefined;
-    }
-    async __validateEntity() {
-        this.__clearErrorsAndReportChanged();
-        if (classValidatorValidate)
-            await classValidatorValidate(this.instance, this);
-        await this.__performColumnAndEntityValidations();
-        this.__assertValidity();
-    }
-    async __performColumnAndEntityValidations() {
-    }
-    toApiJson(includeRelatedEntities = false) {
-        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)
-                    if (includeRelatedEntities)
-                        val = lu.toJson();
-                    else
-                        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 {
-    info;
-    repository;
-    edp;
-    _isNew;
-    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.metadata = info;
-        if (_isNew) {
-            for (const col of info.columnsInfo) {
-                if (col.defaultValue && instance[col.key] === undefined) {
-                    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); }
-    metadata;
-    getId() {
-        return this.info.idMetadata.getId(this.instance);
-    }
-    saveMoreOriginalData() {
-        this.originalId = this.getId();
-    }
-    _wasDeleted = false;
-    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;
-    }
-    _columns;
-    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;
-    }
-    _saving = false;
-    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;
-            let isNew = this.isNew();
-            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);
-                if (this.repository.listeners)
-                    for (const listener of this.repository.listeners.filter(x => x.saved)) {
-                        await listener.saved(this.instance, isNew);
-                    }
-                await this.repository.remult.liveQueryPublisher.itemChanged(this.repository.metadata.key, [{ id: this.getId(), oldId: this.getOriginalId(), deleted: false }]);
-                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);
-                }
-            await this.repository.remult.liveQueryPublisher.itemChanged(this.repository.metadata.key, [{ id: this.getId(), oldId: this.getOriginalId(), deleted: true }]);
-            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();
-        this.id = this.getId();
-    }
-    id;
-    originalId;
-    getOriginalId() {
-        return this.originalId;
-    }
-    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, remultArg) {
-    const remultVar = remultArg || defaultRemult;
-    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, remultVar), container, remultVar);
-    }
-    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();
-            }
-        }
-    }
-    fields;
-}
-export class FieldRefImplementation {
-    settings;
-    metadata;
-    container;
-    helper;
-    rowBase;
-    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;
-    }
-    _subscribers;
-    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;
-    }
-    target;
-    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));
-    }
-    entityRef;
-    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 {
-    settings;
-    entityDefs;
-    remult;
-    constructor(settings, entityDefs, remult) {
-        this.settings = settings;
-        this.entityDefs = entityDefs;
-        this.remult = remult;
-        this.options = this.settings;
-        this.target = this.settings.target;
-        this.valueConverter = this.settings.valueConverter;
-        this.allowNull = !!this.settings.allowNull;
-        this.valueType = this.settings.valueType;
-        this.key = this.settings.key;
-        this.inputType = this.settings.inputType;
-        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);
-    }
-    apiUpdateAllowed(item) {
-        if (this.options.allowApiUpdate === undefined)
-            return true;
-        return this.remult.isAllowedForInstance(item, this.options.allowApiUpdate);
-    }
-    displayValue(item) {
-        return this.entityDefs.getEntityMetadataWithoutBreakingTheEntity(item).fields.find(this.key).displayValue;
-    }
-    get includedInApi() {
-        if (this.options.includeInApi === undefined)
-            return true;
-        return this.remult.isAllowed(this.options.includeInApi); //TODO 2- consolidate other code paths to go through here
-    }
-    toInput(value, inputType) {
-        return this.valueConverter.toInput(value, inputType);
-    }
-    fromInput(inputValue, inputType) {
-        return this.valueConverter.fromInput(inputValue, inputType);
-    }
-    async getDbName() {
-        try {
-            if (this.settings.sqlExpression) {
-                let result;
-                if (typeof this.settings.sqlExpression === "function") {
-                    result = await this.settings.sqlExpression(this.entityDefs);
-                }
-                else
-                    result = this.settings.sqlExpression;
-                if (!result)
-                    return this.settings.dbName;
-                return result;
-            }
-            return this.settings.dbName;
-        }
-        finally {
-        }
-    }
-    options;
-    target;
-    readonly;
-    valueConverter;
-    allowNull;
-    caption;
-    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;
-    }
-    inputType;
-    key;
-    get dbReadOnly() {
-        return this.settings.dbReadOnly;
-    }
-    ;
-    isServerExpression;
-    valueType;
-}
-class EntityFullInfo {
-    columnsInfo;
-    entityInfo;
-    remult;
-    entityType;
-    key;
-    options;
-    constructor(columnsInfo, entityInfo, remult, entityType, key) {
-        this.columnsInfo = columnsInfo;
-        this.entityInfo = entityInfo;
-        this.remult = remult;
-        this.entityType = entityType;
-        this.key = key;
-        this.options = entityInfo;
-        if (this.options.allowApiCrud !== undefined) {
-            let crud;
-            if ((typeof this.options.allowApiCrud) === "function")
-                crud = (_, remult) => this.options.allowApiCrud(remult);
-            else
-                crud = this.options.allowApiCrud;
-            if (this.options.allowApiDelete === undefined)
-                this.options.allowApiDelete = crud;
-            if (this.options.allowApiInsert === undefined)
-                this.options.allowApiInsert = crud;
-            if (this.options.allowApiUpdate === undefined)
-                this.options.allowApiUpdate = crud;
-            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];
-        }
-    }
-    apiUpdateAllowed(item) {
-        if (this.options.allowApiUpdate === undefined)
-            return false;
-        return !item ? this.remult.isAllowedForInstance(undefined, this.options.allowApiUpdate) : this.getEntityMetadataWithoutBreakingTheEntity(item).apiUpdateAllowed;
-    }
-    get apiReadAllowed() {
-        if (this.options.allowApiRead === undefined)
-            return true; //TODO2 - consider that this default may be confusing, since it's different from all others.
-        return this.remult.isAllowed(this.options.allowApiRead);
-    }
-    apiDeleteAllowed(item) {
-        if (this.options.allowApiDelete === undefined)
-            return false;
-        return !item ? this.remult.isAllowedForInstance(undefined, this.options.allowApiDelete) : this.getEntityMetadataWithoutBreakingTheEntity(item).apiDeleteAllowed;
-    }
-    apiInsertAllowed(item) {
-        if (this.options.allowApiUpdate === undefined)
-            return false;
-        return !item ? this.remult.isAllowedForInstance(undefined, this.options.allowApiInsert) : this.getEntityMetadataWithoutBreakingTheEntity(item).apiInsertAllowed;
-    }
-    getEntityMetadataWithoutBreakingTheEntity(item) {
-        let result = getEntityRef(item, false);
-        if (result)
-            return result;
-        return this.remult.repo(this.entityType).getEntityRef({ ...item });
-    }
-    dbNamePromise;
-    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);
-            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;
-    }
-    idMetadata = {
-        getId: item => {
-            if (this.idMetadata.field instanceof CompoundIdField)
-                return this.idMetadata.field.getId(item);
-            else
-                return item[this.idMetadata.field.key];
-        },
-        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
-                };
-        }
-    };
-    fields;
-    dbName;
-    caption;
-}
-export function FieldType(...options) {
-    return (target, context) => {
-        if (!options) {
-            options = [];
-        }
-        options.splice(0, 0, { valueType: target });
-        Reflect.defineMetadata(storableMember, options, target);
-        return target;
-    };
-}
-export class Fields {
-    /**
-     * Stored as a JSON.stringify - to store as json use Fields.json
-    */
-    static object(...options) {
-        return Field(undefined, ...options);
-    }
-    static json(...options) {
-        return Field(undefined, {
-            valueConverter: {
-                fieldTypeInDb: "json"
-            }
-        }, ...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 createdAt(...options) {
-        return Field(() => Date, {
-            allowApiUpdate: false,
-            saving: (_, ref) => {
-                if (getEntityRef(_).isNew())
-                    ref.value = new Date();
-            }
-        }, ...options);
-    }
-    static updatedAt(...options) {
-        return Field(() => Date, {
-            allowApiUpdate: false,
-            saving: (_, ref) => {
-                ref.value = new Date();
-            }
-        }, ...options);
-    }
-    static uuid(...options) {
-        return Field(() => String, {
-            allowApiUpdate: false,
-            defaultValue: () => uuid(),
-            saving: (_, r) => {
-                if (!r.value)
-                    r.value = uuid();
-            }
-        }, ...options);
-    }
-    static cuid(...options) {
-        return Field(() => String, {
-            allowApiUpdate: false,
-            defaultValue: () => createId(),
-            saving: (_, r) => {
-                if (!r.value)
-                    r.value = createId();
-            }
-        }, ...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, context) => {
-        FieldType(o => {
-            o.valueConverter = ValueListInfo.get(type),
-                o.displayValue = (item, val) => val?.caption;
-        }, ...options)(type, context);
-    };
-}
-export class ValueListInfo {
-    valueListType;
-    static get(type) {
-        let r = typeCache.get(type);
-        if (!r) {
-            r = new ValueListInfo(type);
-            typeCache.set(type, r);
-        }
-        return r;
-    }
-    byIdMap = new Map();
-    values = [];
-    isNumeric = false;
-    constructor(valueListType) {
-        this.valueListType = valueListType;
-        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);
-    }
-    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;
-    }
-    fieldTypeInDb;
-    inputType;
-}
-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, 
-    //@ts-ignore
-    context, c) => {
-        const key = typeof context === "string" ? context : context.name.toString();
-        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 = ValueConverters.String;
-    }
-    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;
-}
-//[ ] YONI - in Typescript 5 I do get the name of the class, what would we like to change because of that?
-/**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, 
-    //@ts-ignore
-    info) => {
-        for (const rawFilterMember in target) {
-            if (Object.prototype.hasOwnProperty.call(target, rawFilterMember)) {
-                const element = target[rawFilterMember];
-                if (element?.rawFilterInfo?.rawFilterTranslator) {
-                    if (!element.rawFilterInfo.key)
-                        element.rawFilterInfo.key = rawFilterMember;
-                }
-            }
-        }
-        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 IdEntity extends EntityBase {
-    @Fields.uuid()
-    id;
-}
-export class ControllerBase {
-    remult;
-    constructor(remult) {
-        this.remult = remult || defaultRemult;
-    }
-    assign(values) {
-        assign(this, values);
-        return this;
-    }
-    get $() { return getFields(this, this.remult); }
-    get _() { return getControllerRef(this, this.remult); }
-}
-class QueryResultImpl {
-    options;
-    repo;
-    constructor(options, repo) {
-        this.options = options;
-        this.repo = repo;
-        if (!this.options)
-            this.options = {};
-        if (!this.options.pageSize) {
-            this.options.pageSize = queryConfig.defaultPageSize;
-        }
-    }
-    _count = undefined;
-    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 {
-    value = {};
-    promise;
-}
-class SubscribableImp {
-    reportChanged() {
-        if (this._subscribers)
-            this._subscribers.forEach(x => x.reportChanged());
-    }
-    reportObserved() {
-        if (this._subscribers)
-            this._subscribers.forEach(x => x.reportObserved());
-    }
-    _subscribers;
-    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);
-    }
-}
-export function getEntityMetadata(entity) {
-    if (entity.metadata)
-        return entity.metadata;
-    const settings = getEntitySettings(entity, false);
-    if (settings) {
-        return defaultRemult.repo(entity).metadata;
-    }
-    return entity;
-}
-export function getRepository(entity) {
-    const settings = getEntitySettings(entity, false);
-    if (settings) {
-        return defaultRemult.repo(entity);
-    }
-    return entity;
-}
-export function Field1(valueType) {
-    return (target, context) => { };
-}
-export function createdAt() {
-    return Field1(() => Date);
-}