@michalrakus/x-react-web-lib 1.12.0 → 1.14.0

package/lib/serverApi/XUtilsConversions.js

@@ -0,0 +1,330 @@
+"use strict";
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertValue = exports.convertObject = exports.AsUIType = exports.booleanAsUIText = exports.intervalAsUI = exports.intervalFromUI = exports.datetimeFormatUI = exports.dateFormatCalendar = exports.dateFormatUI = exports.timeFromModel = exports.datetimeAsUI = exports.dateAsUI = exports.dateFromModel = exports.numberFromModel = exports.numberAsUI = exports.numberFromUI = exports.stringAsDB = exports.stringAsUI = exports.stringFromUI = void 0;
+var XUtilsCommon_1 = require("./XUtilsCommon");
+var XLocale_1 = require("../components/XLocale");
+var XUtilsMetadataCommon_1 = require("./XUtilsMetadataCommon");
+function stringFromUI(stringValue) {
+    var value;
+    if (stringValue === '') {
+        value = null;
+    }
+    else {
+        value = stringValue;
+    }
+    return value;
+}
+exports.stringFromUI = stringFromUI;
+function stringAsUI(value) {
+    return value !== null ? value : "";
+}
+exports.stringAsUI = stringAsUI;
+// aby sme sa vyhli sql injection problemu - tam kde je problematicke pouzivat klasicke params
+function stringAsDB(value) {
+    return value !== null ? "'".concat(value.replaceAll("'", "''"), "'") : "NULL";
+}
+exports.stringAsDB = stringAsDB;
+function numberFromUI(stringValue) {
+    var value;
+    if (stringValue === '') {
+        value = null;
+    }
+    else {
+        value = parseInt(stringValue, 10);
+    }
+    return value;
+}
+exports.numberFromUI = numberFromUI;
+function numberAsUI(value, fractionDigits) {
+    if (fractionDigits === undefined) {
+        fractionDigits = 2; // default
+    }
+    if (value !== null) {
+        return value.toLocaleString('de-DE', { style: 'decimal', minimumFractionDigits: fractionDigits, maximumFractionDigits: fractionDigits });
+    }
+    else {
+        return "";
+    }
+}
+exports.numberAsUI = numberAsUI;
+// v modeli na klientovi by mal byt vzdy number, teraz je tam niekedy string (z json-u zo servera) a niekedy number (z komponentu)
+// provizorne zatial takato konverzia
+function numberFromModel(value) {
+    var numberValue = null;
+    if (typeof value === 'string') {
+        numberValue = parseFloat(value);
+    }
+    else if (typeof value === 'number') {
+        numberValue = value;
+    }
+    return numberValue;
+}
+exports.numberFromModel = numberFromModel;
+// v modeli na klientovi by mal byt vzdy Date, teraz je tam niekedy string (z json-u zo servera) a niekedy Date (z komponentu)
+// provizorne zatial takato konverzia
+function dateFromModel(value) {
+    var dateValue = null;
+    if (typeof value === 'string') {
+        dateValue = new Date(value);
+    }
+    else if (typeof value === 'object' && value instanceof Date) {
+        dateValue = value;
+    }
+    return dateValue;
+}
+exports.dateFromModel = dateFromModel;
+function dateAsUI(value) {
+    if (value !== null) {
+        return (0, XUtilsCommon_1.dateFormat)(value, dateFormatUI());
+    }
+    else {
+        return "";
+    }
+}
+exports.dateAsUI = dateAsUI;
+function datetimeAsUI(value) {
+    if (value !== null) {
+        return (0, XUtilsCommon_1.dateFormat)(value, datetimeFormatUI());
+    }
+    else {
+        return "";
+    }
+}
+exports.datetimeAsUI = datetimeAsUI;
+// provizorne zatial takato konverzia
+function timeFromModel(value) {
+    var timeValue = null;
+    if (typeof value === 'string') {
+        // ak prichadza cas priamo z databazy, pride '19:30:00'
+        // ak prichadza reloadnuty objekt (napr. cez webservis saveRow), pride '2021-06-07 19:30:00'
+        var rowDataCasStr = value;
+        if (rowDataCasStr.length < 10) {
+            // mame '19:30:00' -> pridame hociaky rok aby sme skonvertovali na validny Date
+            rowDataCasStr = '1970-01-01 ' + rowDataCasStr;
+        }
+        // na safari nefunguje konverzia new Date('2021-06-07 19:30:00') - vrati NaN
+        // preto string prehodime na '2021-06-07T19:30:00+01:00'
+        // 19:30:00 je cas z timezony Central Europe (taka je nastavena na nodejs)), preto oznacime tento cas touto timezonou
+        // (spravne riesenie je posielat time cez json vzdy vo formate '2021-06-07T18:30:00Z', v tomto formate chodia aj datetime atributy)
+        rowDataCasStr = rowDataCasStr.replace(' ', 'T');
+        if (!rowDataCasStr.endsWith('Z') && rowDataCasStr.indexOf('+') === -1) {
+            rowDataCasStr += '+01:00'; // Central Europe timezone
+        }
+        timeValue = new Date(rowDataCasStr);
+    }
+    else if (typeof value === 'object' && value instanceof Date) {
+        timeValue = value;
+    }
+    return timeValue;
+}
+exports.timeFromModel = timeFromModel;
+function dateFormatUI() {
+    return "dd.mm.yyyy";
+}
+exports.dateFormatUI = dateFormatUI;
+function dateFormatCalendar() {
+    return "dd.mm.yy";
+}
+exports.dateFormatCalendar = dateFormatCalendar;
+function datetimeFormatUI() {
+    return "dd.mm.yyyy HH:MM:ss";
+}
+exports.datetimeFormatUI = datetimeFormatUI;
+function intervalFromUI(valueString) {
+    // convert e.target.value (e.g. 10:29) into IPostgresInterval (e.g. {hours: 10, minutes: 29})
+    // if stringValue is invalid, returns undefined
+    var valueInterval = undefined;
+    if (valueString === '') {
+        valueInterval = null;
+    }
+    else {
+        var posColon = valueString.indexOf(':');
+        if (posColon === -1) {
+            var minutes = parseInt(valueString);
+            if (!isNaN(minutes)) {
+                var hours = Math.floor(minutes / 60);
+                minutes = minutes - (hours * 60);
+                valueInterval = { hours: hours, minutes: minutes };
+            }
+        }
+        else {
+            var hours = parseInt(valueString.substring(0, posColon));
+            var minutes = parseInt(valueString.substring(posColon + 1));
+            if (!isNaN(hours) && !isNaN(minutes)) {
+                if (minutes >= 60) {
+                    var hoursFromMinutes = Math.floor(minutes / 60);
+                    hours += hoursFromMinutes;
+                    minutes = minutes - (hoursFromMinutes * 60);
+                }
+                valueInterval = { hours: hours, minutes: minutes };
+            }
+        }
+    }
+    return valueInterval;
+}
+exports.intervalFromUI = intervalFromUI;
+function intervalAsUI(valueInterval) {
+    var _a, _b;
+    // conversion e.g. {hours: 10, minutes: 29} => '10:29'
+    var valueString;
+    if (valueInterval !== null) {
+        var hours = (_a = valueInterval.hours) !== null && _a !== void 0 ? _a : 0;
+        var minutes = (_b = valueInterval.minutes) !== null && _b !== void 0 ? _b : 0;
+        //const seconds: number = value.seconds ?? 0;
+        if (valueInterval.days) {
+            hours += valueInterval.days * 24;
+        }
+        valueString = "".concat(hours.toString(), ":").concat(minutes.toString().padStart(2, '0'));
+    }
+    else {
+        valueString = ''; // null
+    }
+    return valueString;
+}
+exports.intervalAsUI = intervalAsUI;
+function booleanAsUIText(value) {
+    if (value !== null) {
+        return value ? (0, XLocale_1.xLocaleOption)('yes') : (0, XLocale_1.xLocaleOption)('no');
+    }
+    else {
+        return "";
+    }
+}
+exports.booleanAsUIText = booleanAsUIText;
+var AsUIType;
+(function (AsUIType) {
+    AsUIType[AsUIType["Form"] = 1] = "Form";
+    AsUIType[AsUIType["Text"] = 2] = "Text"; // reporty - boolean sa konvertuje na ano/nie
+})(AsUIType = exports.AsUIType || (exports.AsUIType = {}));
+/**
+ * converts values of object
+ *
+ * @param entity
+ * @param object
+ * @param fromModel
+ * @param asUI
+ */
+function convertObject(entity, object, fromModel, asUI) {
+    var e_1, _a, e_2, _b;
+    var xEntity = XUtilsMetadataCommon_1.XUtilsMetadataCommon.getXEntity(entity);
+    try {
+        for (var _c = __values(Object.entries(object)), _d = _c.next(); !_d.done; _d = _c.next()) {
+            var _e = __read(_d.value, 2), field = _e[0], value = _e[1];
+            var xField = XUtilsMetadataCommon_1.XUtilsMetadataCommon.getXFieldBase(xEntity, field);
+            if (xField) {
+                object[field] = convertValue(xField, value, fromModel, asUI);
+            }
+            else {
+                // nenasli sme medzi fieldami, skusime hladat xAssoc
+                var xAssoc = XUtilsMetadataCommon_1.XUtilsMetadataCommon.getXAssocBase(xEntity, field);
+                if (xAssoc) {
+                    if (value) {
+                        if (xAssoc.relationType === "many-to-one" || xAssoc.relationType === "one-to-one") {
+                            convertObject(xAssoc.entityName, value, fromModel, asUI);
+                        }
+                        else if (xAssoc.relationType === "one-to-many" || xAssoc.relationType === "many-to-many") {
+                            if (!Array.isArray(value)) {
+                                throw "Unexpected error: entity ".concat(entity, " - field ").concat(field, " is expected to be array");
+                            }
+                            try {
+                                for (var value_1 = (e_2 = void 0, __values(value)), value_1_1 = value_1.next(); !value_1_1.done; value_1_1 = value_1.next()) {
+                                    var valueItem = value_1_1.value;
+                                    convertObject(xAssoc.entityName, valueItem, fromModel, asUI);
+                                }
+                            }
+                            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                            finally {
+                                try {
+                                    if (value_1_1 && !value_1_1.done && (_b = value_1.return)) _b.call(value_1);
+                                }
+                                finally { if (e_2) throw e_2.error; }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+}
+exports.convertObject = convertObject;
+function convertValue(xField, value, fromModel, asUI) {
+    if (xField.type === "decimal") {
+        if (fromModel) {
+            value = numberFromModel(value);
+        }
+        if (asUI) {
+            value = numberAsUI(value, xField.scale);
+        }
+    }
+    else if (xField.type === "date") {
+        if (fromModel) {
+            value = dateFromModel(value);
+        }
+        if (asUI) {
+            value = dateAsUI(value);
+        }
+    }
+    else if (xField.type === "datetime") {
+        if (fromModel) {
+            value = dateFromModel(value);
+        }
+        if (asUI) {
+            value = datetimeAsUI(value);
+        }
+    }
+    else if (xField.type === "interval") {
+        // konverziu z modelu (json objekt-u) netreba
+        if (asUI) {
+            value = intervalAsUI(value);
+        }
+    }
+    else if (xField.type === "boolean") {
+        // konverziu z modelu (json objekt-u) netreba
+        // pre AsUIType.Form ponechame typ boolean (spracujeme neskor)
+        if (asUI === AsUIType.Text) {
+            value = booleanAsUIText(value);
+        }
+    }
+    else {
+        // vsetko ostatne
+        if (asUI) {
+            value = value ? value.toString() : "";
+        }
+    }
+    return value;
+}
+exports.convertValue = convertValue;

package/lib/serverApi/XUtilsMetadataCommon.d.ts

@@ -0,0 +1,30 @@
+import { XAssoc, XEntity, XEntityMap, XField, XRelationType } from "./XEntityMetadata";
+/**
+ * spolocna funkcionalita pre entity metadata vyuzivana na frontend-e aj backend-e
+ * vznikla na zaklade XEntityMetadataService
+ * tato funkcionalita by este mohla ist do tried XEntity, XField
+ */
+export declare class XUtilsMetadataCommon {
+    private static xEntityMap;
+    static getXEntityMap(): XEntityMap | undefined;
+    static setXEntityMap(xEntityMap: XEntityMap): void;
+    static getXEntity(entity: string): XEntity;
+    static getXFieldBase(xEntity: XEntity, field: string): XField | undefined;
+    static getXField(xEntity: XEntity, field: string): XField;
+    static getXFieldByPath(xEntity: XEntity, path: string): XField;
+    static getXFieldByPathStr(entity: string, path: string): XField;
+    static getXAssocBase(xEntity: XEntity, assocField: string): XAssoc | undefined;
+    static getXAssocByPath(xEntity: XEntity, path: string): XAssoc;
+    static getLastXAssocByPath(xEntity: XEntity, path: string): XAssoc;
+    static getXAssocToOne(xEntity: XEntity, assocField: string): XAssoc;
+    static getXAssocToMany(xEntity: XEntity, assocField: string): XAssoc;
+    static getXAssocToOneByAssocEntity(xEntity: XEntity, assocEntityName: string): XAssoc;
+    static getXAssocToManyByAssocEntity(xEntity: XEntity, assocEntityName: string): XAssoc;
+    static getXEntityForAssocToOne(xEntity: XEntity, assocField: string): XEntity;
+    static getXEntityForAssocToMany(xEntity: XEntity, assocField: string): XEntity;
+    static getXFieldList(xEntity: XEntity): XField[];
+    static getXAssocList(xEntity: XEntity, relationTypeList?: XRelationType[]): XAssoc[];
+    private static getXAssoc;
+    private static getXAssocByAssocEntity;
+    private static getXEntityForAssoc;
+}

package/lib/serverApi/XUtilsMetadataCommon.js

@@ -0,0 +1,208 @@
+"use strict";
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.XUtilsMetadataCommon = void 0;
+var XUtilsCommon_1 = require("./XUtilsCommon");
+/**
+ * spolocna funkcionalita pre entity metadata vyuzivana na frontend-e aj backend-e
+ * vznikla na zaklade XEntityMetadataService
+ * tato funkcionalita by este mohla ist do tried XEntity, XField
+ */
+var XUtilsMetadataCommon = /** @class */ (function () {
+    function XUtilsMetadataCommon() {
+    }
+    XUtilsMetadataCommon.getXEntityMap = function () {
+        return XUtilsMetadataCommon.xEntityMap;
+    };
+    XUtilsMetadataCommon.setXEntityMap = function (xEntityMap) {
+        XUtilsMetadataCommon.xEntityMap = xEntityMap;
+    };
+    XUtilsMetadataCommon.getXEntity = function (entity) {
+        if (!XUtilsMetadataCommon.xEntityMap) {
+            throw "Unexpected error: XUtilsMetadataCommon.xEntityMap not initialised. Call XUtilsMetadataCommon.setXEntityMap first.";
+        }
+        var xEntity = XUtilsMetadataCommon.xEntityMap[entity];
+        if (xEntity === undefined) {
+            throw "Entity ".concat(entity, " was not found in entity metadata");
+        }
+        return xEntity;
+    };
+    XUtilsMetadataCommon.getXFieldBase = function (xEntity, field) {
+        // TODO - pozor, vo fieldMap su aj asociacie, trebalo by zmenit vytvaranie metadat tak aby tam tie asociacie neboli
+        return xEntity.fieldMap[field];
+    };
+    XUtilsMetadataCommon.getXField = function (xEntity, field) {
+        var xField = XUtilsMetadataCommon.getXFieldBase(xEntity, field);
+        if (xField === undefined) {
+            throw "Field ".concat(field, " was not found in entity ").concat(xEntity.name);
+        }
+        return xField;
+    };
+    XUtilsMetadataCommon.getXFieldByPath = function (xEntity, path) {
+        var _a = __read(XUtilsCommon_1.XUtilsCommon.getFieldAndRestPath(path), 2), field = _a[0], restPath = _a[1];
+        if (restPath === null) {
+            return XUtilsMetadataCommon.getXField(xEntity, field);
+        }
+        else {
+            var xAssoc = XUtilsMetadataCommon.getXAssoc(xEntity, field);
+            var xAssocEntity = XUtilsMetadataCommon.getXEntity(xAssoc.entityName);
+            return XUtilsMetadataCommon.getXFieldByPath(xAssocEntity, restPath);
+        }
+    };
+    XUtilsMetadataCommon.getXFieldByPathStr = function (entity, path) {
+        return XUtilsMetadataCommon.getXFieldByPath(XUtilsMetadataCommon.getXEntity(entity), path);
+    };
+    XUtilsMetadataCommon.getXAssocBase = function (xEntity, assocField) {
+        return xEntity.assocMap[assocField];
+    };
+    XUtilsMetadataCommon.getXAssocByPath = function (xEntity, path) {
+        var _a = __read(XUtilsCommon_1.XUtilsCommon.getFieldAndRestPath(path), 2), field = _a[0], restPath = _a[1];
+        if (restPath === null) {
+            return XUtilsMetadataCommon.getXAssoc(xEntity, field);
+        }
+        else {
+            var xAssoc = XUtilsMetadataCommon.getXAssoc(xEntity, field);
+            var xAssocEntity = XUtilsMetadataCommon.getXEntity(xAssoc.entityName);
+            return XUtilsMetadataCommon.getXAssocByPath(xAssocEntity, restPath);
+        }
+    };
+    // for path assoc1.assoc2.field returns assoc2 (last assoc before field)
+    XUtilsMetadataCommon.getLastXAssocByPath = function (xEntity, path) {
+        var pathToAssoc = XUtilsCommon_1.XUtilsCommon.getPathToAssoc(path);
+        return XUtilsMetadataCommon.getXAssocByPath(xEntity, pathToAssoc);
+    };
+    XUtilsMetadataCommon.getXAssocToOne = function (xEntity, assocField) {
+        return XUtilsMetadataCommon.getXAssoc(xEntity, assocField, ["many-to-one", "one-to-one"]);
+    };
+    XUtilsMetadataCommon.getXAssocToMany = function (xEntity, assocField) {
+        return XUtilsMetadataCommon.getXAssoc(xEntity, assocField, ["one-to-many", "many-to-many"]);
+    };
+    XUtilsMetadataCommon.getXAssocToOneByAssocEntity = function (xEntity, assocEntityName) {
+        return XUtilsMetadataCommon.getXAssocByAssocEntity(xEntity, assocEntityName, ["many-to-one", "one-to-one"]);
+    };
+    XUtilsMetadataCommon.getXAssocToManyByAssocEntity = function (xEntity, assocEntityName) {
+        return XUtilsMetadataCommon.getXAssocByAssocEntity(xEntity, assocEntityName, ["one-to-many", "many-to-many"]);
+    };
+    XUtilsMetadataCommon.getXEntityForAssocToOne = function (xEntity, assocField) {
+        return XUtilsMetadataCommon.getXEntityForAssoc(XUtilsMetadataCommon.getXAssocToOne(xEntity, assocField));
+    };
+    XUtilsMetadataCommon.getXEntityForAssocToMany = function (xEntity, assocField) {
+        return XUtilsMetadataCommon.getXEntityForAssoc(XUtilsMetadataCommon.getXAssocToMany(xEntity, assocField));
+    };
+    XUtilsMetadataCommon.getXFieldList = function (xEntity) {
+        var e_1, _a;
+        var xFieldList = [];
+        try {
+            for (var _b = __values(Object.entries(xEntity.fieldMap)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var _d = __read(_c.value, 2), key = _d[0], xField = _d[1];
+                // assoc fieldy sa nachadzaju aj v xEntity.fieldMap ako typ number (netusim preco), preto ich vyfiltrujeme
+                if (xEntity.assocMap[xField.name] === undefined) {
+                    xFieldList.push(xField);
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        return xFieldList;
+    };
+    XUtilsMetadataCommon.getXAssocList = function (xEntity, relationTypeList) {
+        var e_2, _a;
+        //const xAssocList: XAssoc[] = Array.from(xEntity.assocMap, (v: XAssoc, k: string) => v);
+        var xAssocList = [];
+        try {
+            for (var _b = __values(Object.entries(xEntity.assocMap)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var _d = __read(_c.value, 2), key = _d[0], xAssoc = _d[1];
+                if (relationTypeList === undefined || relationTypeList.includes(xAssoc.relationType)) {
+                    xAssocList.push(xAssoc);
+                }
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+        return xAssocList;
+    };
+    XUtilsMetadataCommon.getXAssoc = function (xEntity, assocField, relationTypeList) {
+        var xAssoc = XUtilsMetadataCommon.getXAssocBase(xEntity, assocField);
+        if (xAssoc === undefined) {
+            throw "Assoc ".concat(assocField, " was not found in entity = ").concat(xEntity.name);
+        }
+        // relationTypeList is optional and is only for check (not to get some unwanted type of assoc)
+        if (relationTypeList !== undefined && !relationTypeList.includes(xAssoc.relationType)) {
+            throw "Assoc ".concat(assocField, " in entity ").concat(xEntity.name, " is of type ").concat(xAssoc.relationType, " and required type is ").concat(JSON.stringify(relationTypeList));
+        }
+        return xAssoc;
+    };
+    XUtilsMetadataCommon.getXAssocByAssocEntity = function (xEntity, assocEntityName, relationTypeList) {
+        var e_3, _a;
+        var xAssocFound = undefined;
+        try {
+            for (var _b = __values(Object.entries(xEntity.assocMap)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var _d = __read(_c.value, 2), key = _d[0], xAssoc = _d[1];
+                if (xAssoc.entityName === assocEntityName) {
+                    if (xAssocFound === undefined) {
+                        xAssocFound = xAssoc;
+                    }
+                    else {
+                        throw "In entity ".concat(xEntity.name, " found more then 1 assoc for assocEntityName = ").concat(assocEntityName);
+                    }
+                }
+            }
+        }
+        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_3) throw e_3.error; }
+        }
+        if (xAssocFound === undefined) {
+            throw "Assoc for assocEntityName = ".concat(assocEntityName, " not found in entity ").concat(xEntity.name);
+        }
+        // relationTypeList is optional and is only for check (not to get some unwanted type of assoc)
+        if (relationTypeList !== undefined && !relationTypeList.includes(xAssocFound.relationType)) {
+            throw "Assoc for assocEntityName = ".concat(assocEntityName, " in entity ").concat(xEntity.name, " is of type ").concat(xAssocFound.relationType, " and required type is ").concat(JSON.stringify(relationTypeList));
+        }
+        return xAssocFound;
+    };
+    XUtilsMetadataCommon.getXEntityForAssoc = function (xAssoc) {
+        return XUtilsMetadataCommon.getXEntity(xAssoc.entityName);
+    };
+    return XUtilsMetadataCommon;
+}());
+exports.XUtilsMetadataCommon = XUtilsMetadataCommon;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@michalrakus/x-react-web-lib",
-  "version": "1.12.0",
+  "version": "1.14.0",
   "description": "",
   "scripts": {
     "clean": "rimraf lib",
@@ -28,7 +28,7 @@
     "@testing-library/react": "^14.0.0",
     "@testing-library/user-event": "^14.4.3",
     "@types/jest": "^29.5.0",
-    "@types/lodash": "^4.14.191",
+    "@types/lodash": "^4.14.202",
     "@types/node": "^18.15.3",
     "@types/react": "^18.0.28",
     "@types/react-dom": "^18.0.11",