remult 0.21.1 → 0.22.0

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

@@ -0,0 +1,2109 @@
+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);
+}