remult 0.22.2 → 0.22.3

package/src/shared-tests/db-tests.db-tests.js

@@ -2377,3 +2377,67 @@ db_tests_setup_1.testAll('test relation to number id', function (_a) {
         });
     });
 }, false, { exclude: [db_tests_setup_1.TestDbs.mongo, db_tests_setup_1.TestDbs.mongoNoTrans] });
+db_tests_setup_1.testAll('test relation to string id', function (_a) {
+    var createEntity = _a.createEntity;
+    return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+        var category, task, catRepo, taskRepo, cat, _b, _c, _d;
+        return tslib_1.__generator(this, function (_e) {
+            switch (_e.label) {
+                case 0:
+                    category = /** @class */ (function () {
+                        function class_12() {
+                            this.id = '';
+                            this.name = '';
+                        }
+                        return class_12;
+                    }());
+                    DecoratorReplacer_1.describeClass(category, remult3_1.Entity('rel_ID_string_categories', { allowApiCrud: true }), {
+                        id: remult3_1.Fields.cuid(),
+                        name: remult3_1.Fields.string(),
+                    });
+                    task = /** @class */ (function () {
+                        function class_13() {
+                            this.id = 0;
+                            this.title = '';
+                        }
+                        return class_13;
+                    }());
+                    DecoratorReplacer_1.describeClass(task, remult3_1.Entity('rel_ID_string_task', { allowApiCrud: true }), {
+                        id: remult3_1.Fields.autoIncrement(),
+                        title: remult3_1.Fields.string(),
+                        category: remult3_1.Field(function () { return category; }),
+                    });
+                    return [4 /*yield*/, createEntity(category)];
+                case 1:
+                    catRepo = _e.sent();
+                    return [4 /*yield*/, createEntity(task)];
+                case 2:
+                    taskRepo = _e.sent();
+                    return [4 /*yield*/, catRepo.insert([{ name: 'cat0' }, { name: 'cat1' }])];
+                case 3:
+                    cat = _e.sent();
+                    return [4 /*yield*/, taskRepo.insert([
+                            { title: 't1', category: cat[0] },
+                            { title: 't2', category: cat[0] },
+                            { title: 't3', category: cat[1] },
+                        ])];
+                case 4:
+                    _e.sent();
+                    expect(taskRepo.fields.category.valueConverter.fieldTypeInDb).toBeUndefined();
+                    _b = expect;
+                    return [4 /*yield*/, taskRepo.count({ category: cat[0] })];
+                case 5:
+                    _b.apply(void 0, [_e.sent()]).toBe(2);
+                    _c = expect;
+                    return [4 /*yield*/, taskRepo.count({ category: cat[1] })];
+                case 6:
+                    _c.apply(void 0, [_e.sent()]).toBe(1);
+                    _d = expect;
+                    return [4 /*yield*/, taskRepo.count({ category: { $id: cat[0].id } })];
+                case 7:
+                    _d.apply(void 0, [_e.sent()]).toBe(2);
+                    return [2 /*return*/];
+            }
+        });
+    });
+}, false, { exclude: [db_tests_setup_1.TestDbs.mongo, db_tests_setup_1.TestDbs.mongoNoTrans] });

package/{esm/core/src/valueConverters.d.ts → valueConverters.d.ts}

@@ -1,13 +1,12 @@
-import { ValueConverter } from "./column-interfaces";
-export declare class ValueConverters {
-    static readonly Date: ValueConverter<Date>;
-    static readonly DateOnly: ValueConverter<Date>;
-    static readonly DateOnlyString: ValueConverter<Date>;
-    static readonly Boolean: ValueConverter<Boolean>;
-    static readonly Number: ValueConverter<number>;
-    static readonly String: ValueConverter<String>;
-    static readonly Integer: ValueConverter<number>;
-    static readonly Default: Required<ValueConverter<any>>;
-    static readonly JsonString: ValueConverter<any>;
-    static readonly JsonValue: ValueConverter<any>;
-}
+import { ValueConverter } from "./src/column-interfaces";
+export declare class ValueConverters {
+    static readonly Date: ValueConverter<Date>;
+    static readonly DateOnly: ValueConverter<Date>;
+    static readonly DateOnlyString: ValueConverter<Date>;
+    static readonly Boolean: ValueConverter<Boolean>;
+    static readonly Number: ValueConverter<number>;
+    static readonly Integer: ValueConverter<number>;
+    static readonly Default: ValueConverter<any>;
+    static readonly JsonString: ValueConverter<any>;
+    static readonly JsonValue: ValueConverter<any>;
+}

package/valueConverters.js

@@ -0,0 +1,168 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValueConverters = void 0;
+var tslib_1 = require("tslib");
+var inputTypes_1 = require("./inputTypes");
+var ValueConverters = /** @class */ (function () {
+    function ValueConverters() {
+    }
+    ValueConverters.Date = {
+        toJson: function (val) {
+            if (!val)
+                return '';
+            if (typeof (val) === "string")
+                val = new Date(val);
+            if (val instanceof Date) {
+                return val.toISOString();
+            }
+            else {
+                console.log("ToJsonError", val);
+                throw new Error("Expected date but got val");
+            }
+        },
+        fromJson: function (val) {
+            if (val == undefined)
+                return undefined;
+            if (val == '')
+                return undefined;
+            if (val.startsWith('0000-00-00'))
+                return undefined;
+            return new Date(Date.parse(val));
+        },
+        toDb: function (x) { return x; },
+        fromDb: function (x) { return x; },
+        fromInput: function (x) { return ValueConverters.Date.fromJson(x); },
+        toInput: function (x) { return ValueConverters.Date.toJson(x); },
+        displayValue: function (val) {
+            if (!val)
+                return '';
+            return val.toLocaleString();
+        }
+    };
+    ValueConverters.DateOnly = {
+        fromInput: function (x) { return ValueConverters.DateOnly.fromJson(x); },
+        toInput: function (x) { return ValueConverters.DateOnly.toJson(x); },
+        toJson: function (val) {
+            var d = val;
+            if (typeof d === "string" || typeof (d) === "number")
+                d = new Date(d);
+            if (!d || d == null)
+                return null;
+            if (d.getHours() == 0)
+                return new Date(d.valueOf() - d.getTimezoneOffset() * 60000).toISOString().substring(0, 10);
+            else
+                return d.toISOString().substring(0, 10);
+        },
+        fromJson: function (value) {
+            if (!value || value == '' || value == '0000-00-00')
+                return null;
+            var d = new Date(Date.parse(value));
+            d.setMinutes(d.getMinutes() + d.getTimezoneOffset());
+            return d;
+        },
+        inputType: inputTypes_1.InputTypes.date,
+        toDb: function (val) {
+            if (!val)
+                return null;
+            return ValueConverters.DateOnly.fromJson(ValueConverters.DateOnly.toJson(val));
+        } //when using date storage,  the database expects and returns a date local and every where else we reflect on date iso
+        ,
+        fromDb: function (val) {
+            var d = val;
+            if (!d)
+                return null;
+            return val;
+        },
+        fieldTypeInDb: 'date',
+        displayValue: function (value) {
+            if (!value)
+                return '';
+            return value.toLocaleDateString(undefined);
+        }
+    };
+    ValueConverters.DateOnlyString = tslib_1.__assign(tslib_1.__assign({}, ValueConverters.DateOnly), { toDb: function (d) {
+            var val = ValueConverters.DateOnly.toJson(d);
+            if (!val)
+                return undefined;
+            return val.replace(/-/g, '');
+        }, fromDb: function (val) {
+            if (val === null)
+                return null;
+            if (!val)
+                return undefined;
+            return new Date(val.substring(0, 4) + '-' + val.substring(4, 6) + '-' + val.substring(6, 8));
+        } });
+    ValueConverters.Boolean = {
+        toDb: function (val) { return val; },
+        inputType: inputTypes_1.InputTypes.checkbox,
+        fromDb: function (value) {
+            return ValueConverters.Boolean.fromJson(value);
+        },
+        fromJson: function (value) {
+            if (typeof value === "boolean")
+                return value;
+            if (value !== undefined && value !== null) {
+                return value.toString().trim().toLowerCase() == 'true';
+            }
+            return value;
+        },
+        toJson: function (x) { return x; },
+        fromInput: function (x) { return ValueConverters.Boolean.fromJson(x); },
+        toInput: function (x) { return ValueConverters.Boolean.toJson(x); }
+    };
+    ValueConverters.Number = {
+        fromDb: function (value) {
+            if (value === null)
+                return null;
+            if (value !== undefined)
+                return +value;
+            return undefined;
+        },
+        toDb: function (value) { return value; },
+        fromJson: function (value) { return ValueConverters.Number.fromDb(value); },
+        toJson: function (value) { return ValueConverters.Number.toDb(value); },
+        fromInput: function (x, type) {
+            var r = +x;
+            if (!x)
+                return undefined;
+            return r;
+        },
+        toInput: function (x, type) {
+            return x === null || x === void 0 ? void 0 : x.toString();
+        },
+        inputType: inputTypes_1.InputTypes.number
+    };
+    ValueConverters.Integer = tslib_1.__assign(tslib_1.__assign({}, ValueConverters.Number), { toJson: function (value) {
+            var val = ValueConverters.Number.toDb(value);
+            if (!val)
+                return val;
+            return +(+val).toFixed(0);
+        }, toDb: function (value) { return ValueConverters.Integer.toJson(value); }, fieldTypeInDb: 'integer' });
+    ValueConverters.Default = {
+        fromJson: function (x) { return x; },
+        toJson: function (x) { return x; },
+        fromDb: function (x) { return ValueConverters.JsonString.fromDb(x); },
+        toDb: function (x) { return ValueConverters.JsonString.toDb(x); },
+        fromInput: function (x) { return ValueConverters.Default.fromJson(x); },
+        toInput: function (x) { return ValueConverters.Default.toJson(x); }
+    };
+    ValueConverters.JsonString = {
+        fromJson: function (x) { return x; },
+        toJson: function (x) { return x; },
+        fromDb: function (x) { return x == null ? null : x ? JSON.parse(ValueConverters.JsonString.fromJson(x)) : undefined; },
+        toDb: function (x) { return x !== undefined ? x === null ? null : JSON.stringify(ValueConverters.JsonString.toJson(x)) : undefined; },
+        fromInput: function (x) { return ValueConverters.JsonString.fromJson(x); },
+        toInput: function (x) { return ValueConverters.JsonString.toJson(x); }
+    };
+    ValueConverters.JsonValue = {
+        fromJson: function (x) { return x; },
+        toJson: function (x) { return x; },
+        fromDb: function (x) { return x; },
+        toDb: function (x) { return x; },
+        fromInput: function (x) { return ValueConverters.JsonString.fromJson(x); },
+        toInput: function (x) { return ValueConverters.JsonString.toJson(x); },
+        fieldTypeInDb: 'json'
+    };
+    return ValueConverters;
+}());
+exports.ValueConverters = ValueConverters;

package/esm/angular/interfaces/index.d.ts

@@ -1 +0,0 @@
-export * from './src/public_api';

package/esm/angular/interfaces/index.js

@@ -1 +0,0 @@
-export * from './src/public_api';

package/esm/angular/interfaces/src/column-collection.d.ts

@@ -1,70 +0,0 @@
-import { FieldMetadata, FieldRef, EntityMetadata, ValueListItem, Remult, Repository, EntityOrderBy, EntityFilter } from "remult";
-import { DataControlInfo, DataControlSettings, ValueOrEntityExpression } from "./data-control-interfaces";
-import { FilterHelper } from "./filter-helper";
-export declare class FieldCollection<rowType = any> {
-    currentRow: () => any;
-    private allowUpdate;
-    filterHelper: FilterHelper<rowType>;
-    private showArea;
-    private _getRowColumn;
-    constructor(currentRow: () => any, allowUpdate: () => boolean, filterHelper: FilterHelper<rowType>, showArea: () => boolean, _getRowColumn: (row: rowType, col: FieldMetadata) => FieldRef<any, any>);
-    __showArea(): boolean;
-    __getColumn(map: DataControlSettings, record: any): any;
-    __visible(col: DataControlSettings, row: any): boolean;
-    allowClick(col: DataControlSettings<any, any>, row: any): boolean;
-    getRowColumn<T>(args: {
-        col: DataControlSettings<any>;
-        row: any;
-    }, what: (c: FieldRef<any, any>, row: any) => T): T;
-    __dataControlStyle(map: DataControlSettings): string;
-    private settingsByKey;
-    allowDesignMode: boolean;
-    add(...columns: DataControlInfo<rowType>[]): Promise<void>;
-    add(...columns: string[]): Promise<void>;
-    private doWhenWeHaveContext;
-    private remult;
-    setContext(remult: Remult): void;
-    buildDropDown(s: DataControlSettings): Promise<void>;
-    designMode: boolean;
-    colListChanged(): void;
-    _colListChangeListeners: (() => void)[];
-    onColListChange(action: (() => void)): void;
-    moveCol(col: DataControlSettings, move: number): void;
-    filterRows(col: DataControlSettings): void;
-    clearFilter(col: DataControlSettings): void;
-    _shouldShowFilterDialog(col: DataControlSettings): boolean;
-    deleteCol(col: DataControlSettings): void;
-    addCol(col: DataControlSettings, newCol: DataControlSettings): void;
-    _getEditable(col: DataControlSettings, row: rowType): boolean;
-    _click(col: DataControlSettings, row: any): void;
-    _getColDisplayValue(col: DataControlSettings, row: rowType): any;
-    _getColDataType(col: DataControlSettings): string;
-    _getColumnClass(col: DataControlSettings, row: any): any;
-    _getError(col: DataControlSettings, r: any): any;
-    autoGenerateColumnsBasedOnData(defs: EntityMetadata<any>): void;
-    __changeWidth(col: DataControlSettings, what: number): void;
-    _colValueChanged(col: DataControlSettings, row: any): false | undefined;
-    items: DataControlSettings[];
-    private gridColumns;
-    private nonGridColumns;
-    numOfColumnsInGrid: number;
-    private _lastColumnCount;
-    private _lastNumOfColumnsInGrid;
-    private augmented;
-    augment(augmenter: dataControlAugmenter, s: DataControlSettings): void;
-    private _initColumnsArrays;
-    getGridColumns(augmenter: dataControlAugmenter): DataControlSettings<any, any>[];
-    getNonGridColumns(augmenter: dataControlAugmenter): DataControlSettings<any, any>[];
-}
-export declare function valueOrEntityExpressionToValue<T, entityType>(f: ValueOrEntityExpression<T, entityType>, e: entityType): T;
-/** returns an array of values that can be used in the value list property of a data control object */
-export declare function getEntityValueList<T>(repository: Repository<T>, args?: {
-    idField?: (e: EntityMetadata<T>) => FieldMetadata;
-    captionField?: (e: EntityMetadata<T>) => FieldMetadata;
-    orderBy?: EntityOrderBy<T>;
-    where?: EntityFilter<T>;
-}): Promise<ExtendedValueListItem[]>;
-export interface ExtendedValueListItem extends ValueListItem {
-    entity?: any;
-}
-export declare type dataControlAugmenter = (f: FieldMetadata, op: DataControlSettings) => void;

package/esm/angular/interfaces/src/column-collection.js

@@ -1,341 +0,0 @@
-import { getEntityRef } from "remult";
-import { decorateDataSettings, getFieldDefinition } from "./data-control-interfaces";
-import { getEntitySettings } from 'remult/src/remult3';
-export class FieldCollection {
-    currentRow;
-    allowUpdate;
-    filterHelper;
-    showArea;
-    _getRowColumn;
-    constructor(currentRow, allowUpdate, filterHelper, showArea, _getRowColumn) {
-        this.currentRow = currentRow;
-        this.allowUpdate = allowUpdate;
-        this.filterHelper = filterHelper;
-        this.showArea = showArea;
-        this._getRowColumn = _getRowColumn;
-    }
-    __showArea() {
-        return this.showArea();
-    }
-    __getColumn(map, record) {
-        if (!map.field)
-            return undefined;
-        let result;
-        if (record)
-            result = getEntityRef(record).fields.find(getFieldDefinition(map.field));
-        if (!result)
-            result = map.field;
-        return result;
-    }
-    __visible(col, row) {
-        if (col.visible === undefined)
-            return true;
-        return this.getRowColumn({ col, row }, (c, row) => col.visible(row, c));
-    }
-    allowClick(col, row) {
-        if (!col.click)
-            return false;
-        if (!this._getEditable(col, row))
-            return false;
-        if (col.allowClick === undefined) {
-            return true;
-        }
-        return this.getRowColumn({ col, row }, (c, row) => col.allowClick(row, c));
-    }
-    getRowColumn(args, what) {
-        let field;
-        let row = args.row;
-        if (this._getRowColumn && args.col.field && row) {
-            field = this._getRowColumn(row, getFieldDefinition(args.col.field));
-        }
-        if (!field)
-            field = args.col.field;
-        if (!row && field)
-            row = field.container;
-        return what(field, row);
-    }
-    __dataControlStyle(map) {
-        if (map.width && map.width.trim().length > 0) {
-            if ((+map.width).toString() == map.width)
-                return map.width + "px";
-            return map.width;
-        }
-        return undefined;
-    }
-    settingsByKey = {};
-    allowDesignMode;
-    async add(...columns) {
-        var promises = [];
-        for (let c of columns) {
-            if (!c)
-                continue;
-            let s;
-            let x = c;
-            let col = c;
-            let ecol = c;
-            if (!x.field && col.valueConverter || ecol.metadata) {
-                x = {
-                    field: c,
-                };
-            }
-            if (x.field) {
-                decorateDataSettings(x.field, x);
-            }
-            if (x.getValue) {
-                s = x;
-            }
-            {
-                promises.push(this.buildDropDown(x));
-            }
-            this.items.push(x);
-        }
-        await Promise.all(promises);
-        return Promise.resolve();
-    }
-    doWhenWeHaveContext = [];
-    remult;
-    setContext(remult) {
-        this.remult = remult;
-        for (const what of this.doWhenWeHaveContext) {
-            what(remult);
-        }
-    }
-    async buildDropDown(s) {
-        if (s.valueList) {
-            let orig = s.valueList;
-            let result = [];
-            s.valueList = result;
-            if (orig instanceof Array) {
-                for (let item of orig) {
-                    let type = typeof (item);
-                    if (type == "string" || type == "number")
-                        result.push({ id: item, caption: item });
-                    else {
-                        let x = item;
-                        if (x && x.id != undefined) {
-                            result.push(x);
-                        }
-                    }
-                }
-            }
-            else if (typeof orig === "function") {
-                let theFunc = orig;
-                let todo = async (remult) => {
-                    let x = await theFunc(remult);
-                    if (x === undefined)
-                        s.valueList = undefined;
-                    else
-                        result.push(...x);
-                    fixResult(result, s.field);
-                };
-                if (this.remult) {
-                    todo(this.remult);
-                }
-                else
-                    this.doWhenWeHaveContext.push(async (remult) => todo(remult));
-            }
-            else {
-                result.push(...(await orig));
-            }
-            fixResult(result, s.field);
-        }
-        return Promise.resolve();
-    }
-    designMode = false;
-    colListChanged() {
-        this._lastNumOfColumnsInGrid = -1;
-        this._colListChangeListeners.forEach(x => x());
-    }
-    ;
-    _colListChangeListeners = [];
-    onColListChange(action) {
-        this._colListChangeListeners.push(action);
-    }
-    moveCol(col, move) {
-        let currentIndex = this.items.indexOf(col);
-        let newIndex = currentIndex + move;
-        if (newIndex < 0 || newIndex >= this.items.length)
-            return;
-        this.items.splice(currentIndex, 1);
-        this.items.splice(newIndex, 0, col);
-        this.colListChanged();
-    }
-    filterRows(col) {
-        if (col.valueList)
-            col.useContainsFilter = false;
-        this.filterHelper.filterColumn(col.field, false, col.useContainsFilter);
-    }
-    clearFilter(col) {
-        this.filterHelper.filterColumn(col.field, true, false);
-    }
-    _shouldShowFilterDialog(col) {
-        return false;
-    }
-    deleteCol(col) {
-        this.items.splice(this.items.indexOf(col), 1);
-        this.colListChanged();
-    }
-    addCol(col, newCol) {
-        this.items.splice(this.items.indexOf(col) + 1, 0, newCol);
-        this.colListChanged();
-    }
-    _getEditable(col, row) {
-        if (!this.allowUpdate())
-            return false;
-        if (!col.field)
-            return false;
-        if (col.readonly !== undefined)
-            return !valueOrEntityExpressionToValue(col.readonly, row);
-        return true;
-    }
-    _click(col, row) {
-        this.getRowColumn({ col, row }, (c, r) => { col.click(r, c); });
-    }
-    _getColDisplayValue(col, row) {
-        let r;
-        if (col.getValue) {
-            r = this.getRowColumn({ row, col }, (c, r) => col.getValue(r, c));
-        }
-        else if (col.field) {
-            if (col.valueList) {
-                for (let x of col.valueList) {
-                    if (x.id == this.__getColumn(col, row).value)
-                        return x.caption;
-                }
-            }
-            r = this.__getColumn(col, row).displayValue;
-        }
-        return r;
-    }
-    _getColDataType(col) {
-        if (col.inputType)
-            return col.inputType;
-        return "text";
-    }
-    _getColumnClass(col, row) {
-        if (col.cssClass)
-            if (typeof col.cssClass === 'function') {
-                let anyFunc = col.cssClass;
-                return anyFunc(row);
-            }
-            else
-                return col.cssClass;
-        return '';
-    }
-    _getError(col, r) {
-        if (!col.field)
-            return undefined;
-        return this.__getColumn(col, r).error;
-    }
-    autoGenerateColumnsBasedOnData(defs) {
-        if (this.items.length == 0) {
-            if (defs) {
-                for (const c of defs.fields) {
-                    if (!(c.key == 'id' && c.valueType === String))
-                        this.add(c);
-                }
-            }
-        }
-    }
-    __changeWidth(col, what) {
-        let width = col.width;
-        if (!width)
-            width = '50';
-        width = ((+width) + what).toString();
-        col.width = width;
-    }
-    _colValueChanged(col, row) {
-        return this.getRowColumn({ col, row }, (c, row) => {
-            if (col.valueList) {
-                let item = col.valueList.find(x => x.id == c.inputValue);
-                if (item?.entity) {
-                    if (getEntitySettings(getFieldDefinition(col.field).valueType, false))
-                        c.value = item.entity;
-                }
-            }
-            if (!col.valueChange)
-                return false;
-            col.valueChange(row, c);
-        });
-    }
-    items = [];
-    gridColumns;
-    nonGridColumns;
-    numOfColumnsInGrid = 5;
-    _lastColumnCount;
-    _lastNumOfColumnsInGrid;
-    augmented = new Map();
-    augment(augmenter, s) {
-        if (this.augmented.get(s))
-            return;
-        augmenter(getFieldDefinition(s.field), s);
-        this.augmented.set(s, true);
-    }
-    _initColumnsArrays(augmenter) {
-        if (this._lastColumnCount != this.items.length || this._lastNumOfColumnsInGrid != this.numOfColumnsInGrid) {
-            this._lastNumOfColumnsInGrid = this.numOfColumnsInGrid;
-            this._lastColumnCount = this.items.length;
-            this.gridColumns = [];
-            this.nonGridColumns = [];
-            let i = 0;
-            for (let c of this.items) {
-                this.augment(augmenter, c);
-                if (i++ < this._lastNumOfColumnsInGrid)
-                    this.gridColumns.push(c);
-                else
-                    this.nonGridColumns.push(c);
-            }
-        }
-    }
-    getGridColumns(augmenter) {
-        this._initColumnsArrays(augmenter);
-        return this.gridColumns;
-    }
-    getNonGridColumns(augmenter) {
-        this._initColumnsArrays(augmenter);
-        return this.nonGridColumns;
-    }
-}
-export function valueOrEntityExpressionToValue(f, e) {
-    if (typeof f === 'function') {
-        let x = f;
-        return x(e);
-    }
-    return f;
-}
-function fixResult(result, inField) {
-    let field = getFieldDefinition(inField);
-    if (field?.valueType === Number) {
-        result.splice(0, result.length, ...result.map(x => ({ ...x, id: x.id?.toString() })));
-    }
-}
-/** returns an array of values that can be used in the value list property of a data control object */
-export async function getEntityValueList(repository, args) {
-    if (!args) {
-        args = {};
-    }
-    if (!args.idField) {
-        args.idField = x => x.idMetadata.field;
-    }
-    if (!args.captionField) {
-        let idCol = args.idField(repository.metadata);
-        for (const keyInItem of repository.metadata.fields) {
-            if (keyInItem != idCol) {
-                args.captionField = x => x.fields.find(keyInItem);
-                break;
-            }
-        }
-    }
-    let r = (await repository.find({
-        where: args.where,
-        orderBy: args.orderBy,
-        limit: 1000
-    })).map(x => {
-        return {
-            id: repository.getEntityRef(x).fields.find(args.idField(repository.metadata)).value,
-            caption: repository.getEntityRef(x).fields.find(args.captionField(repository.metadata)).value,
-            entity: x
-        };
-    });
-    return r;
-}