@michalrakus/x-react-web-lib 1.11.1 → 1.13.0

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.11.1",
+  "version": "1.13.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",

package/lib/components/XUtilsConversions.js

@@ -1,177 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-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.stringAsUI = exports.stringFromUI = void 0;
-var XUtilsCommon_1 = require("../serverApi/XUtilsCommon");
-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;
-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;