remult 0.14.6 → 0.14.7

package/src/validators.js

@@ -1,33 +1,60 @@
-import { isBackend } from "..";
-export class Validators {
-}
-Validators.required = Object.assign((entity, col, message = undefined) => {
-    if (!col.value || typeof (col.value) === "string" && col.value.trim().length == 0)
-        col.error = message || Validators.required.defaultMessage;
-}, {
-    withMessage: (message) => {
-        return (entity, col) => Validators.required(entity, col, message);
-    },
-    defaultMessage: 'Should not be empty'
-});
-Validators.unique = Object.assign(async (entity, col, message = undefined) => {
-    if (!col.entityRef)
-        throw "unique validation may only work on columns that are attached to an entity";
-    if (col.entityRef.isNew() || col.valueChanged()) {
-        if (await col.entityRef.repository.count({ [col.metadata.key]: col.value }))
-            col.error = message || Validators.unique.defaultMessage;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Validators = void 0;
+var tslib_1 = require("tslib");
+var context_1 = require("./context");
+var Validators = /** @class */ (function () {
+    function Validators() {
     }
-}, {
-    withMessage: (message) => {
-        return (entity, col) => Validators.unique(entity, col, message);
-    },
-    defaultMessage: 'already exists'
-});
-Validators.uniqueOnBackend = Object.assign(async (entity, col, message = undefined) => {
-    if (isBackend())
-        return Validators.unique(entity, col, message);
-}, {
-    withMessage: (message) => {
-        return (entity, col) => Validators.uniqueOnBackend(entity, col, message);
-    }
-});
+    Validators.required = Object.assign(function (entity, col, message) {
+        if (message === void 0) { message = undefined; }
+        if (!col.value || typeof (col.value) === "string" && col.value.trim().length == 0)
+            col.error = message || Validators.required.defaultMessage;
+    }, {
+        withMessage: function (message) {
+            return function (entity, col) { return Validators.required(entity, col, message); };
+        },
+        defaultMessage: 'Should not be empty'
+    });
+    Validators.unique = Object.assign(function (entity, col, message) {
+        if (message === void 0) { message = undefined; }
+        return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+            var _a;
+            return tslib_1.__generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!col.entityRef)
+                            throw "unique validation may only work on columns that are attached to an entity";
+                        if (!(col.entityRef.isNew() || col.valueChanged())) return [3 /*break*/, 2];
+                        return [4 /*yield*/, col.entityRef.repository.count((_a = {}, _a[col.metadata.key] = col.value, _a))];
+                    case 1:
+                        if (_b.sent())
+                            col.error = message || Validators.unique.defaultMessage;
+                        _b.label = 2;
+                    case 2: return [2 /*return*/];
+                }
+            });
+        });
+    }, {
+        withMessage: function (message) {
+            return function (entity, col) { return Validators.unique(entity, col, message); };
+        },
+        defaultMessage: 'already exists'
+    });
+    Validators.uniqueOnBackend = Object.assign(function (entity, col, message) {
+        if (message === void 0) { message = undefined; }
+        return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                if (context_1.isBackend())
+                    return [2 /*return*/, Validators.unique(entity, col, message)];
+                return [2 /*return*/];
+            });
+        });
+    }, {
+        withMessage: function (message) {
+            return function (entity, col) { return Validators.uniqueOnBackend(entity, col, message); };
+        }
+    });
+    return Validators;
+}());
+exports.Validators = Validators;

package/urlBuilder.js

@@ -1,19 +1,25 @@
-export class UrlBuilder {
-    constructor(url) {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UrlBuilder = void 0;
+var UrlBuilder = /** @class */ (function () {
+    function UrlBuilder(url) {
         this.url = url;
     }
-    add(key, value) {
+    UrlBuilder.prototype.add = function (key, value) {
         if (this.url.indexOf('?') >= 0)
             this.url += '&';
         else
             this.url += '?';
         this.url += encodeURIComponent(key) + '=' + encodeURIComponent(value);
-    }
-    addObject(object, suffix = '') {
+    };
+    UrlBuilder.prototype.addObject = function (object, suffix) {
+        if (suffix === void 0) { suffix = ''; }
         if (object != undefined)
             for (var key in object) {
-                let val = object[key];
+                var val = object[key];
                 this.add(key + suffix, val);
             }
-    }
-}
+    };
+    return UrlBuilder;
+}());
+exports.UrlBuilder = UrlBuilder;

package/valueConverters.js

@@ -1,165 +1,164 @@
-import { InputTypes } from "./inputTypes";
-export class ValueConverters {
-}
-ValueConverters.Date = {
-    toJson: (val) => {
-        if (!val)
-            return '';
-        if (typeof (val) === "string")
-            val = new Date(val);
-        if (val instanceof Date) {
-            return val.toISOString();
+"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();
         }
-        else {
-            console.log("ToJsonError", val);
-            throw new Error("Expected date but got val");
+    };
+    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);
         }
-    },
-    fromJson: (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: x => x,
-    fromDb: x => x,
-    fromInput: x => ValueConverters.Date.fromJson(x),
-    toInput: x => ValueConverters.Date.toJson(x),
-    displayValue: (val) => {
-        if (!val)
-            return '';
-        return val.toLocaleString();
-    }
-};
-ValueConverters.DateOnly = {
-    fromInput: x => ValueConverters.DateOnly.fromJson(x),
-    toInput: x => ValueConverters.DateOnly.toJson(x),
-    toJson: (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: (value) => {
-        if (!value || value == '' || value == '0000-00-00')
-            return null;
-        let d = new Date(Date.parse(value));
-        d.setMinutes(d.getMinutes() + d.getTimezoneOffset());
-        return d;
-    },
-    inputType: InputTypes.date,
-    toDb: (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: (val) => {
-        var d = val;
-        if (!d)
-            return null;
-        return val;
-    },
-    fieldTypeInDb: 'date',
-    displayValue: (value) => {
-        if (!value)
-            return '';
-        return value.toLocaleDateString(undefined);
-    }
-};
-ValueConverters.DateOnlyString = {
-    ...ValueConverters.DateOnly,
-    toDb: (d) => {
-        let val = ValueConverters.DateOnly.toJson(d);
-        if (!val)
-            return undefined;
-        return val.replace(/-/g, '');
-    },
-    fromDb: (val) => {
-        if (!val)
-            return undefined;
-        return new Date(val.substring(0, 4) + '-' + val.substring(4, 6) + '-' + val.substring(6, 8));
-    }
-};
-ValueConverters.Boolean = {
-    toDb: (val) => val,
-    inputType: InputTypes.checkbox,
-    fromDb: (value) => {
-        return ValueConverters.Boolean.fromJson(value);
-    },
-    fromJson: value => {
-        if (typeof value === "boolean")
+    };
+    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)
+                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;
-        if (value !== undefined && value !== null) {
-            return value.toString().trim().toLowerCase() == 'true';
-        }
-        return value;
-    },
-    toJson: x => x,
-    fromInput: x => ValueConverters.Boolean.fromJson(x),
-    toInput: x => ValueConverters.Boolean.toJson(x)
-};
-ValueConverters.Number = {
-    fromDb: value => {
-        if (value !== undefined)
-            return +value;
-        return undefined;
-    },
-    toDb: value => value,
-    fromJson: value => ValueConverters.Number.fromDb(value),
-    toJson: value => ValueConverters.Number.toDb(value),
-    fromInput: (x, type) => {
-        let r = +x;
-        if (!x)
+        },
+        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 !== undefined)
+                return +value;
             return undefined;
-        return r;
-    },
-    toInput: (x, type) => {
-        return x?.toString();
-    },
-    inputType: InputTypes.number
-};
-ValueConverters.Integer = {
-    ...ValueConverters.Number,
-    toJson: value => {
-        let val = ValueConverters.Number.toDb(value);
-        if (!val)
-            return val;
-        return +(+val).toFixed(0);
-    },
-    toDb: value => ValueConverters.Integer.toJson(value),
-    fieldTypeInDb: 'integer'
-};
-ValueConverters.Default = {
-    fromJson: x => x,
-    toJson: x => x,
-    fromDb: x => ValueConverters.JsonString.fromDb(x),
-    toDb: x => ValueConverters.JsonString.toDb(x),
-    fromInput: x => ValueConverters.Default.fromJson(x),
-    toInput: x => ValueConverters.Default.toJson(x)
-};
-ValueConverters.JsonString = {
-    fromJson: x => x,
-    toJson: x => x,
-    fromDb: x => x == null ? null : x ? JSON.parse(ValueConverters.JsonString.fromJson(x)) : undefined,
-    toDb: x => x !== undefined ? x === null ? null : JSON.stringify(ValueConverters.JsonString.toJson(x)) : undefined,
-    fromInput: x => ValueConverters.JsonString.fromJson(x),
-    toInput: x => ValueConverters.JsonString.toJson(x)
-};
-ValueConverters.JsonValue = {
-    fromJson: x => x,
-    toJson: x => x,
-    fromDb: x => x,
-    toDb: x => x,
-    fromInput: x => ValueConverters.JsonString.fromJson(x),
-    toInput: x => ValueConverters.JsonString.toJson(x),
-    fieldTypeInDb: 'json'
-};
+        },
+        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;