remult 0.25.8 → 0.26.0

package/src/filter/filter-interfaces.js

@@ -12,9 +12,129 @@ var Filter = /** @class */ (function () {
     function Filter(apply) {
         this.apply = apply;
     }
-    Filter.createCustom = function (rawFilterTranslator, key) {
+    //@internal
+    Filter.throwErrorIfFilterIsEmpty = function (where, methodName) {
+        if (Filter.isFilterEmpty(where)) {
+            throw {
+                message: "".concat(methodName, ": requires a filter to protect against accidental delete/update of all rows"),
+                httpStatusCode: 400,
+            };
+        }
+    };
+    //@internal
+    Filter.isFilterEmpty = function (where) {
+        var e_1, _a, e_2, _b;
+        if (where.$and) {
+            try {
+                for (var _c = tslib_1.__values(where.$and), _d = _c.next(); !_d.done; _d = _c.next()) {
+                    var a = _d.value;
+                    if (!Filter.isFilterEmpty(a)) {
+                        return false;
+                    }
+                }
+            }
+            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; }
+            }
+        }
+        if (where.$or) {
+            try {
+                for (var _e = tslib_1.__values(where.$or), _f = _e.next(); !_f.done; _f = _e.next()) {
+                    var a = _f.value;
+                    if (Filter.isFilterEmpty(a)) {
+                        return true;
+                    }
+                }
+            }
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            finally {
+                try {
+                    if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+                }
+                finally { if (e_2) throw e_2.error; }
+            }
+            return false;
+        }
+        if (Object.keys(where).filter(function (x) { return !['$or', '$and'].includes(x); }).length == 0) {
+            return true;
+        }
+        return false;
+    };
+    /**
+     * Retrieves precise values for each property in a filter for an entity.
+     * @template entityType The type of the entity being filtered.
+     * @param metadata The metadata of the entity being filtered.
+     * @param filter The filter to analyze.
+     * @returns A promise that resolves to a FilterPreciseValues object containing the precise values for each property.
+     * @example
+     * const preciseValues = await Filter.getPreciseValues(meta, {
+     *   status: { $ne: 'active' },
+     *   $or: [
+     *     { customerId: ["1", "2"] },
+     *     { customerId: "3" }
+     *   ]
+     * });
+     * console.log(preciseValues);
+     * // Output:
+     * // {
+     * //   "customerId": ["1", "2", "3"], // Precise values inferred from the filter
+     * //   "status": undefined,           // Cannot infer precise values for 'status'
+     * // }
+    
+     */
+    Filter.getPreciseValues = function (metadata, filter) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var result;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        result = new preciseValuesCollector();
+                        return [4 /*yield*/, Filter.fromEntityFilter(metadata, filter).__applyToConsumer(result)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/, result.preciseValues];
+                }
+            });
+        });
+    };
+    /**
+     * Retrieves precise values for each property in a filter for an entity.
+     * @template entityType The type of the entity being filtered.
+     * @param metadata The metadata of the entity being filtered.
+     * @param filter The filter to analyze.
+     * @returns A promise that resolves to a FilterPreciseValues object containing the precise values for each property.
+     * @example
+     * const preciseValues = await where.getPreciseValues();
+     * console.log(preciseValues);
+     * // Output:
+     * // {
+     * //   "customerId": ["1", "2", "3"], // Precise values inferred from the filter
+     * //   "status": undefined,           // Cannot infer precise values for 'status'
+     * // }
+    
+     */
+    Filter.prototype.getPreciseValues = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var result;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        result = new preciseValuesCollector();
+                        return [4 /*yield*/, this.__applyToConsumer(result)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/, result.preciseValues];
+                }
+            });
+        });
+    };
+    Filter.createCustom = function (translator, key) {
         if (key === void 0) { key = ''; }
-        var rawFilterInfo = { key: key, rawFilterTranslator: rawFilterTranslator };
+        var rawFilterInfo = { key: key, rawFilterTranslator: translator };
         return Object.assign(function (x) {
             var _a;
             var z = {};
@@ -206,7 +326,6 @@ var Filter = /** @class */ (function () {
             });
         });
     };
-    //@internal
     Filter.prototype.toJson = function () {
         var r = new FilterSerializer();
         this.__applyToConsumer(r);
@@ -317,19 +436,19 @@ var filterHelper = /** @class */ (function () {
     filterHelper.prototype.isNotIn = function (values) {
         var _this = this;
         return new Filter(function (add) {
-            var e_1, _a;
+            var e_3, _a;
             try {
                 for (var values_1 = tslib_1.__values(values), values_1_1 = values_1.next(); !values_1_1.done; values_1_1 = values_1.next()) {
                     var v = values_1_1.value;
                     add.isDifferentFrom(_this.metadata, _this.processVal(v));
                 }
             }
-            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            catch (e_3_1) { e_3 = { error: e_3_1 }; }
             finally {
                 try {
                     if (values_1_1 && !values_1_1.done && (_a = values_1.return)) _a.call(values_1);
                 }
-                finally { if (e_1) throw e_1.error; }
+                finally { if (e_3) throw e_3.error; }
             }
         });
     };
@@ -462,7 +581,7 @@ var AndFilter = /** @class */ (function (_super) {
             filters[_i] = arguments[_i];
         }
         var _this = _super.call(this, function (add) {
-            var e_2, _a;
+            var e_4, _a;
             try {
                 for (var _b = tslib_1.__values(_this.filters), _c = _b.next(); !_c.done; _c = _b.next()) {
                     var iterator = _c.value;
@@ -470,12 +589,12 @@ var AndFilter = /** @class */ (function (_super) {
                         iterator.__applyToConsumer(add);
                 }
             }
-            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            catch (e_4_1) { e_4 = { error: e_4_1 }; }
             finally {
                 try {
                     if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
                 }
-                finally { if (e_2) throw e_2.error; }
+                finally { if (e_4) throw e_4.error; }
             }
         }) || this;
         _this.filters = filters;
@@ -591,17 +710,30 @@ function entityFilterToJson(entityDefs, where) {
 }
 exports.entityFilterToJson = entityFilterToJson;
 function buildFilterFromRequestParameters(entity, filterInfo) {
-    var where = [];
+    var where = {};
+    function addAnd(what) {
+        if (!where.$and) {
+            where.$and = [];
+        }
+        where.$and.push(what);
+    }
+    function addToFilterObject(key, val) {
+        var _a;
+        if (where[key] === undefined)
+            where[key] = val;
+        else {
+            addAnd((_a = {}, _a[key] = val, _a));
+        }
+    }
+    ;
     tslib_1.__spreadArray([], tslib_1.__read(entity.fields), false).forEach(function (col) {
-        var _a, _b;
         function addFilter(operation, theFilter, jsonArray, asString) {
-            var e_3, _a;
+            var e_5, _a;
             if (jsonArray === void 0) { jsonArray = false; }
             if (asString === void 0) { asString = false; }
             var val = filterInfo.get(col.key + operation);
             if (val !== undefined) {
                 var addFilter_1 = function (val) {
-                    var _a;
                     var theVal = val;
                     if (jsonArray) {
                         var arr = void 0;
@@ -618,7 +750,7 @@ function buildFilterFromRequestParameters(entity, filterInfo) {
                     }
                     var f = theFilter(theVal);
                     if (f !== undefined) {
-                        where.push((_a = {}, _a[col.key] = f, _a));
+                        addToFilterObject(col.key, f);
                     }
                 };
                 if (!jsonArray && val instanceof Array) {
@@ -638,12 +770,12 @@ function buildFilterFromRequestParameters(entity, filterInfo) {
                             addFilter_1(x);
                         }
                     }
-                    catch (e_3_1) { e_3 = { error: e_3_1 }; }
+                    catch (e_5_1) { e_5 = { error: e_5_1 }; }
                     finally {
                         try {
                             if (array_1_1 && !array_1_1.done && (_a = array_1.return)) _a.call(array_1);
                         }
-                        finally { if (e_3) throw e_3.error; }
+                        finally { if (e_5) throw e_5.error; }
                     }
                 }
             }
@@ -662,10 +794,10 @@ function buildFilterFromRequestParameters(entity, filterInfo) {
                 case 'y':
                 case 'true':
                 case 'yes':
-                    where.push((_a = {}, _a[col.key] = null, _a));
+                    addToFilterObject(col.key, null);
                     break;
                 default:
-                    where.push((_b = {}, _b[col.key] = { $ne: null }, _b));
+                    addToFilterObject(col.key, { $ne: null });
                     break;
             }
         }
@@ -682,12 +814,19 @@ function buildFilterFromRequestParameters(entity, filterInfo) {
                 });
             }),
         }); });
-        if (or.length == 1)
-            where.push(or[0]);
-        else
-            where.push({
+        if (or.length == 1) {
+            if (!where.$or) {
+                where.$or = or[0].$or;
+            }
+            else {
+                where.$or.push(or[0].$or);
+            }
+        }
+        else {
+            addAnd({
                 $and: or,
             });
+        }
     }
     var _loop_3 = function (key) {
         var element = entity.entityType[key];
@@ -697,10 +836,9 @@ function buildFilterFromRequestParameters(entity, filterInfo) {
             var custom = filterInfo.get(exports.customUrlToken + key);
             if (custom !== undefined) {
                 var addItem_1 = function (item) {
-                    var _a;
                     if (item[customArrayToken] != undefined)
                         item = item[customArrayToken];
-                    where.push((_a = {}, _a[exports.customUrlToken + key] = item, _a));
+                    addToFilterObject(exports.customUrlToken + key, item);
                 };
                 if (Array.isArray(custom)) {
                     custom.forEach(function (item) { return addItem_1(item); });
@@ -713,11 +851,9 @@ function buildFilterFromRequestParameters(entity, filterInfo) {
     for (var key in entity.entityType) {
         _loop_3(key);
     }
-    if (where.length == 1)
-        return where[0];
-    return { $and: where };
+    return where;
     function separateArrayFromInnerArray(val) {
-        var e_4, _a;
+        var e_6, _a;
         if (!Array.isArray(val))
             return [val];
         var nonArray = [], array = [];
@@ -731,12 +867,12 @@ function buildFilterFromRequestParameters(entity, filterInfo) {
                     nonArray.push(v);
             }
         }
-        catch (e_4_1) { e_4 = { error: e_4_1 }; }
+        catch (e_6_1) { e_6 = { error: e_6_1 }; }
         finally {
             try {
                 if (val_1_1 && !val_1_1.done && (_a = val_1.return)) _a.call(val_1);
             }
-            finally { if (e_4) throw e_4.error; }
+            finally { if (e_6) throw e_6.error; }
         }
         array.push(nonArray);
         return array;
@@ -874,5 +1010,149 @@ function __updateEntityBasedOnWhere(entityDefs, where, r) {
     }
 }
 exports.__updateEntityBasedOnWhere = __updateEntityBasedOnWhere;
-// toRaw of default remult threw and exception
-// toRaw didn't respect
+var preciseValuesCollector = /** @class */ (function () {
+    function preciseValuesCollector() {
+        this.rawValues = {};
+        this.preciseValues = new Proxy(this.rawValues, {
+            get: function (target, prop) {
+                if (prop in target) {
+                    var result = target[prop];
+                    if (result.bad)
+                        return undefined;
+                    if (result.values.length > 0) {
+                        var relInfo_1 = (0, relationInfoMember_js_1.getRelationFieldInfo)(result.field);
+                        if (relInfo_1) {
+                            if (relInfo_1.type === 'reference') {
+                                return result.values.map(function (x) {
+                                    return relInfo_1.toRepo.metadata.idMetadata.getIdFilter(x);
+                                });
+                            }
+                            else
+                                throw new Error('Only relations toOne without field are supported.');
+                        }
+                        return result.values;
+                    }
+                }
+                return undefined;
+            },
+        });
+    }
+    preciseValuesCollector.prototype.ok = function (col) {
+        var _a;
+        var val = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            val[_i - 1] = arguments[_i];
+        }
+        var x = this.rawValues[col.key];
+        if (!x) {
+            this.rawValues[col.key] = {
+                field: col,
+                bad: false,
+                values: tslib_1.__spreadArray([], tslib_1.__read(val), false),
+            };
+        }
+        else {
+            (_a = x.values).push.apply(_a, tslib_1.__spreadArray([], tslib_1.__read(val.filter(function (y) { return !x.values.includes(y); })), false));
+        }
+    };
+    preciseValuesCollector.prototype.notOk = function (col) {
+        var x = this.rawValues[col.key];
+        if (!x) {
+            this.rawValues[col.key] = {
+                field: col,
+                bad: true,
+                values: [],
+            };
+        }
+        else {
+            x.bad = true;
+        }
+    };
+    preciseValuesCollector.prototype.or = function (orElements) {
+        var e_7, _a, e_8, _b;
+        var result = orElements.map(function (or) {
+            var x = new preciseValuesCollector();
+            or.__applyToConsumer(x);
+            return x;
+        });
+        try {
+            for (var result_1 = tslib_1.__values(result), result_1_1 = result_1.next(); !result_1_1.done; result_1_1 = result_1.next()) {
+                var or = result_1_1.value;
+                for (var key in or.rawValues) {
+                    if (Object.prototype.hasOwnProperty.call(or.rawValues, key)) {
+                        var element = or.rawValues[key];
+                        if (element) {
+                            if (element.bad)
+                                this.notOk(element.field);
+                            else {
+                                this.ok.apply(this, tslib_1.__spreadArray([element.field], tslib_1.__read(element.values), false));
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        catch (e_7_1) { e_7 = { error: e_7_1 }; }
+        finally {
+            try {
+                if (result_1_1 && !result_1_1.done && (_a = result_1.return)) _a.call(result_1);
+            }
+            finally { if (e_7) throw e_7.error; }
+        }
+        for (var key in this.rawValues) {
+            if (Object.prototype.hasOwnProperty.call(this.rawValues, key)) {
+                try {
+                    for (var result_2 = (e_8 = void 0, tslib_1.__values(result)), result_2_1 = result_2.next(); !result_2_1.done; result_2_1 = result_2.next()) {
+                        var r = result_2_1.value;
+                        var element = r.rawValues[key];
+                        if (!element)
+                            this.notOk(this.rawValues[key].field);
+                    }
+                }
+                catch (e_8_1) { e_8 = { error: e_8_1 }; }
+                finally {
+                    try {
+                        if (result_2_1 && !result_2_1.done && (_b = result_2.return)) _b.call(result_2);
+                    }
+                    finally { if (e_8) throw e_8.error; }
+                }
+            }
+        }
+    };
+    preciseValuesCollector.prototype.isEqualTo = function (col, val) {
+        this.ok(col, val);
+    };
+    preciseValuesCollector.prototype.isDifferentFrom = function (col, val) {
+        this.notOk(col);
+    };
+    preciseValuesCollector.prototype.isNull = function (col) {
+        this.ok(col, null);
+    };
+    preciseValuesCollector.prototype.isNotNull = function (col) {
+        this.notOk(col);
+    };
+    preciseValuesCollector.prototype.isGreaterOrEqualTo = function (col, val) {
+        this.notOk(col);
+    };
+    preciseValuesCollector.prototype.isGreaterThan = function (col, val) {
+        this.notOk(col);
+    };
+    preciseValuesCollector.prototype.isLessOrEqualTo = function (col, val) {
+        this.notOk(col);
+    };
+    preciseValuesCollector.prototype.isLessThan = function (col, val) {
+        this.notOk(col);
+    };
+    preciseValuesCollector.prototype.containsCaseInsensitive = function (col, val) {
+        this.notOk(col);
+    };
+    preciseValuesCollector.prototype.notContainsCaseInsensitive = function (col, val) {
+        this.notOk(col);
+    };
+    preciseValuesCollector.prototype.isIn = function (col, val) {
+        this.ok.apply(this, tslib_1.__spreadArray([col], tslib_1.__read(val), false));
+    };
+    preciseValuesCollector.prototype.custom = function (key, customItem) { };
+    preciseValuesCollector.prototype.databaseCustom = function (databaseCustom) { };
+    return preciseValuesCollector;
+}());

package/src/isOfType.d.ts

@@ -0,0 +1,2 @@
+export declare function isOfType<T>(obj: any, checkMethod: keyof T): obj is T;
+export declare function cast<T>(obj: any, checkMethod: keyof T): T;

package/src/isOfType.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cast = exports.isOfType = void 0;
+function isOfType(obj, checkMethod) {
+    return typeof obj[checkMethod] !== 'undefined';
+}
+exports.isOfType = isOfType;
+function cast(obj, checkMethod) {
+    if (isOfType(obj, checkMethod)) {
+        return obj;
+    }
+    throw new Error("Object is not of type ".concat(checkMethod.toString()));
+}
+exports.cast = cast;

package/src/remult3/Fields.d.ts

@@ -16,7 +16,43 @@ export declare class Fields {
     static createdAt<entityType = any>(...options: (FieldOptions<entityType, Date> | ((options: FieldOptions<entityType, Date>, remult: Remult) => void))[]): ClassFieldDecorator<entityType, Date | undefined>;
     static updatedAt<entityType = any>(...options: (FieldOptions<entityType, Date> | ((options: FieldOptions<entityType, Date>, remult: Remult) => void))[]): ClassFieldDecorator<entityType, Date | undefined>;
     static uuid<entityType = any>(...options: (FieldOptions<entityType, string> | ((options: FieldOptions<entityType, string>, remult: Remult) => void))[]): ClassFieldDecorator<entityType, string | undefined>;
+    /**
+   * A CUID (Collision Resistant Unique Identifier) field.
+   * This id value is determined on the backend on insert, and can't be updated through the API.
+   * The CUID is generated using the `@paralleldrive/cuid2` npm package.
+   */
     static cuid<entityType = any>(...options: (FieldOptions<entityType, string> | ((options: FieldOptions<entityType, string>, remult: Remult) => void))[]): ClassFieldDecorator<entityType, string | undefined>;
+    /**
+   * Defines a field that can hold a value from a specified set of string literals.
+   * @param {() => readonly valueType[]} optionalValues - A function that returns an array of allowed string literals.
+   * @returns {ClassFieldDecorator<entityType, valueType | undefined>} - A class field decorator.
+   *
+   * @example
+   
+   * class MyEntity {
+   *   .@Fields.literal(() => ['open', 'closed', 'frozen', 'in progress'] as const)
+   *   status: 'open' | 'closed' | 'frozen' | 'in progress' = 'open';
+   * }
+   
+   *
+   * // This defines a field `status` in `MyEntity` that can only hold the values 'open', 'closed', 'frozen', or 'in progress'.
+   *
+   * @example
+   * // For better reusability and maintainability:
+   
+   * const statuses = ['open', 'closed', 'frozen', 'in progress'] as const;
+   * type StatusType = typeof statuses[number];
+   *
+   * class MyEntity {
+   *   .@Fields.literal(() => statuses)
+   *   status: StatusType = 'open';
+   * }
+   
+   *
+   * // This approach allows easy management and updates of the allowed values for the `status` field.
+   */
+    static literal<entityType = any, valueType extends string = any>(optionalValues: () => readonly valueType[], ...options: (StringFieldOptions<entityType, valueType> | ((options: StringFieldOptions<entityType, valueType>, remult: Remult) => void))[]): ClassFieldDecorator<entityType, valueType | undefined>;
+    static enum<entityType = any, theEnum = any>(enumType: () => theEnum, ...options: (FieldOptions<entityType, theEnum[keyof theEnum]> | ((options: FieldOptions<entityType, theEnum[keyof theEnum]>, remult: Remult) => void))[]): ClassFieldDecorator<entityType, theEnum[keyof theEnum] | undefined>;
     static string<entityType = any, valueType = string>(...options: (StringFieldOptions<entityType, valueType> | ((options: StringFieldOptions<entityType, valueType>, remult: Remult) => void))[]): ClassFieldDecorator<entityType, valueType | undefined>;
     static boolean<entityType = any>(...options: (FieldOptions<entityType, boolean> | ((options: FieldOptions<entityType, boolean>, remult: Remult) => void))[]): ClassFieldDecorator<entityType, boolean | undefined>;
 }

package/src/remult3/Fields.js

@@ -9,6 +9,10 @@ var RepositoryImplementation_js_1 = require("./RepositoryImplementation.js");
 var validators_js_1 = require("../validators.js");
 var relationInfoMember_js_1 = require("./relationInfoMember.js");
 var remult_static_js_1 = require("../remult-static.js");
+var addValidator_js_1 = require("./addValidator.js");
+var validateNumber = (0, validators_js_1.createValueValidator)(function (x) {
+    return !isNaN(x) && isFinite(x);
+});
 var Fields = /** @class */ (function () {
     function Fields() {
     }
@@ -63,6 +67,7 @@ var Fields = /** @class */ (function () {
         return Field.apply(void 0, tslib_1.__spreadArray([function () { return Number; },
             {
                 valueConverter: valueConverters_js_1.ValueConverters.Integer,
+                validate: validateNumber,
             }], tslib_1.__read(options), false));
     };
     Fields.autoIncrement = function () {
@@ -82,7 +87,9 @@ var Fields = /** @class */ (function () {
         for (var _i = 0; _i < arguments.length; _i++) {
             options[_i] = arguments[_i];
         }
-        return Field.apply(void 0, tslib_1.__spreadArray([function () { return Number; }], tslib_1.__read(options), false));
+        return Field.apply(void 0, tslib_1.__spreadArray([function () { return Number; }, {
+                validate: validateNumber,
+            }], tslib_1.__read(options), false));
     };
     Fields.createdAt = function () {
         var options = [];
@@ -127,6 +134,11 @@ var Fields = /** @class */ (function () {
                 },
             }], tslib_1.__read(options), false));
     };
+    /**
+   * A CUID (Collision Resistant Unique Identifier) field.
+   * This id value is determined on the backend on insert, and can't be updated through the API.
+   * The CUID is generated using the `@paralleldrive/cuid2` npm package.
+   */
     Fields.cuid = function () {
         var options = [];
         for (var _i = 0; _i < arguments.length; _i++) {
@@ -142,6 +154,71 @@ var Fields = /** @class */ (function () {
                 },
             }], tslib_1.__read(options), false));
     };
+    /**
+   * Defines a field that can hold a value from a specified set of string literals.
+   * @param {() => readonly valueType[]} optionalValues - A function that returns an array of allowed string literals.
+   * @returns {ClassFieldDecorator<entityType, valueType | undefined>} - A class field decorator.
+   *
+   * @example
+   
+   * class MyEntity {
+   *   .@Fields.literal(() => ['open', 'closed', 'frozen', 'in progress'] as const)
+   *   status: 'open' | 'closed' | 'frozen' | 'in progress' = 'open';
+   * }
+   
+   *
+   * // This defines a field `status` in `MyEntity` that can only hold the values 'open', 'closed', 'frozen', or 'in progress'.
+   *
+   * @example
+   * // For better reusability and maintainability:
+   
+   * const statuses = ['open', 'closed', 'frozen', 'in progress'] as const;
+   * type StatusType = typeof statuses[number];
+   *
+   * class MyEntity {
+   *   .@Fields.literal(() => statuses)
+   *   status: StatusType = 'open';
+   * }
+   
+   *
+   * // This approach allows easy management and updates of the allowed values for the `status` field.
+   */
+    Fields.literal = function (optionalValues) {
+        var options = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            options[_i - 1] = arguments[_i];
+        }
+        return Fields.string.apply(Fields, tslib_1.__spreadArray([{
+                validate: function (entity, event) { return validators_js_1.Validators.in(optionalValues())(entity, event); }
+            }], tslib_1.__read(options), false));
+    };
+    Fields.enum = function (enumType) {
+        var options = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            options[_i - 1] = arguments[_i];
+        }
+        var valueConverter;
+        return Field.apply(void 0, tslib_1.__spreadArray(tslib_1.__spreadArray([function () {
+                //@ts-ignore
+                return (enumType());
+            },
+            {
+                validate: function (entity, event) { return validators_js_1.Validators.enum(enumType())(entity, event); }
+            }], tslib_1.__read(options), false), [function (options) {
+                if (valueConverter === undefined) {
+                    var enumObj = enumType();
+                    var enumValues = (0, validators_js_1.getEnumValues)(enumObj);
+                    valueConverter = enumValues.find(function (x) { return typeof x === "string"; }) ? valueConverters_js_1.ValueConverters.String : valueConverters_js_1.ValueConverters.Integer;
+                }
+                if (!options.valueConverter) {
+                    options.valueConverter = valueConverter;
+                }
+                else if (!options.valueConverter.fieldTypeInDb) {
+                    //@ts-ignore
+                    options.valueConverter.fieldTypeInDb = valueConverter.fieldTypeInDb;
+                }
+            }], false));
+    };
     Fields.string = function () {
         var options = [];
         for (var _i = 0; _i < arguments.length; _i++) {
@@ -249,13 +326,13 @@ function Field(valueType) {
         var factory = function (remult) {
             var r = (0, RepositoryImplementation_js_1.buildOptions)(options, remult);
             if (r.required) {
-                r.validate = addValidator(r.validate, validators_js_1.Validators.required);
+                r.validate = (0, addValidator_js_1.addValidator)(r.validate, validators_js_1.Validators.required, true);
             }
             if (r.maxLength) {
-                r.validate = addValidator(r.validate, validators_js_1.Validators.maxLength(r.maxLength));
+                r.validate = (0, addValidator_js_1.addValidator)(r.validate, validators_js_1.Validators.maxLength(r.maxLength));
             }
             if (r.minLength) {
-                r.validate = addValidator(r.validate, validators_js_1.Validators.minLength(r.minLength));
+                r.validate = (0, addValidator_js_1.addValidator)(r.validate, validators_js_1.Validators.minLength(r.minLength));
             }
             if (!r.valueType && valueType) {
                 r.valueType = valueType();
@@ -305,18 +382,3 @@ function checkTarget(target) {
         throw new Error("Set the 'experimentalDecorators:true' option in your 'tsconfig' or 'jsconfig' (target undefined)");
 }
 exports.checkTarget = checkTarget;
-function addValidator(validators, newValidator, atStart) {
-    if (atStart === void 0) { atStart = false; }
-    if (!newValidator)
-        return;
-    var newValidators = Array.isArray(newValidator)
-        ? newValidator
-        : [newValidator];
-    var validatorsArray = Array.isArray(validators)
-        ? validators
-        : validators
-            ? [validators]
-            : [];
-    return atStart
-        ? tslib_1.__spreadArray(tslib_1.__spreadArray([], tslib_1.__read(newValidators), false), tslib_1.__read(validatorsArray), false) : tslib_1.__spreadArray(tslib_1.__spreadArray([], tslib_1.__read(validatorsArray), false), tslib_1.__read(newValidators), false);
-}