custom-class-validator-tools 1.0.54 → 1.1.0

package/dist/src/decorator/validate/is-undefinable-boolean.decorator.js

@@ -1,24 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.IsUndefinableBoolean = void 0;
-const is_empty_1 = require("../../util/is-empty");
 const class_validator_1 = require("class-validator");
-function IsUndefinableBoolean(validationOptions) {
-    return function (object, propertyName) {
-        (0, class_validator_1.registerDecorator)({
-            name: 'IsUndefinableBoolean',
-            target: object.constructor,
-            propertyName: propertyName,
-            options: validationOptions,
-            validator: {
-                validate(value) {
-                    return typeof value === 'boolean' || (0, is_empty_1.isUndefined)(value);
-                },
-                defaultMessage(validationArguments) {
-                    return `${validationArguments?.property} should be boolean or undefined`;
-                },
+const is_empty_1 = require("../../util/is-empty");
+const isUndefinableBoolean = (value) => typeof value === 'boolean' || (0, is_empty_1.isUndefined)(value);
+const IsUndefinableBoolean = (validationOptions) => {
+    return (0, class_validator_1.ValidateBy)({
+        name: 'IsUndefinedBoolean',
+        constraints: [validationOptions],
+        validator: {
+            validate: (value) => isUndefinableBoolean(value),
+            defaultMessage(validationArguments) {
+                return `${validationArguments?.property} should be boolean or undefined`;
             },
-        });
-    };
-}
+        },
+    }, validationOptions);
+};
 exports.IsUndefinableBoolean = IsUndefinableBoolean;

package/dist/src/decorator/validate/is-undefinable-number-string.decorator.d.ts

@@ -1,4 +1,4 @@
 import { ValidationOptions } from 'class-validator';
-export declare function IsUndefinableNumberString(validationOptions?: ValidationOptions & {
+export declare const IsUndefinableNumberString: (validationOptions?: ValidationOptions & {
     isFloat?: boolean;
-}): (object: Object, propertyName: string) => void;
+}) => PropertyDecorator;

package/dist/src/decorator/validate/is-undefinable-number-string.decorator.js

@@ -24,31 +24,29 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.IsUndefinableNumberString = void 0;
-const is_boolean_1 = require("../../util/is-boolean");
-const is_empty_1 = require("../../util/is-empty");
 const class_validator_1 = require("class-validator");
 const FF = __importStar(require("fp-ts/function"));
 const FO = __importStar(require("fp-ts/Option"));
-function IsUndefinableNumberString(validationOptions) {
-    return function (object, propertyName) {
-        (0, class_validator_1.registerDecorator)({
-            name: 'IsUndefinableNumberString',
-            target: object.constructor,
-            propertyName: propertyName,
-            options: validationOptions,
-            validator: {
-                validate(value) {
-                    return FF.pipe(value, FO.fromPredicate(predicate => (0, is_empty_1.isUndefined)(predicate)), FO.fold(() => {
-                        const numberValue = Number(value);
-                        const isNumber = (typeof value === 'string' && value.length > 0 && (0, is_boolean_1.isFalse)(isNaN(numberValue))) || (0, is_empty_1.isUndefined)(value);
-                        return FF.pipe(validationOptions?.isFloat ?? false, FO.fromPredicate(predicate => (0, is_boolean_1.isTrue)(predicate)), FO.fold(() => (0, is_boolean_1.isTrue)(isNumber) && numberValue % 1 === 0, () => (0, is_boolean_1.isTrue)(isNumber)));
-                    }, () => true));
-                },
-                defaultMessage(validationArguments) {
-                    return `${validationArguments?.property} should be number`;
-                },
+const is_boolean_1 = require("../../util/is-boolean");
+const is_empty_1 = require("../../util/is-empty");
+const isUndefinableNumberString = (value, validationOptions) => {
+    if ((0, is_empty_1.isUndefined)(value)) {
+        return true;
+    }
+    const numberValue = +value;
+    const isNumber = (typeof value === 'string' && value.length > 0 && (0, is_boolean_1.isFalse)(isNaN(numberValue))) || (0, is_empty_1.isUndefined)(value);
+    return FF.pipe(validationOptions?.isFloat ?? false, FO.fromPredicate(predicate => (0, is_boolean_1.isTrue)(predicate)), FO.fold(() => (0, is_boolean_1.isTrue)(isNumber) && numberValue % 1 === 0, () => (0, is_boolean_1.isTrue)(isNumber)));
+};
+const IsUndefinableNumberString = (validationOptions) => {
+    return (0, class_validator_1.ValidateBy)({
+        name: 'IsUndefinableNumberString',
+        constraints: [validationOptions],
+        validator: {
+            validate: (value) => isUndefinableNumberString(value, validationOptions),
+            defaultMessage(validationArguments) {
+                return `${validationArguments?.property} should be number or undefined`;
             },
-        });
-    };
-}
+        },
+    }, validationOptions);
+};
 exports.IsUndefinableNumberString = IsUndefinableNumberString;

package/dist/src/decorator/validate/is-undefinable-number.decorator.d.ts

@@ -1,4 +1,4 @@
 import { ValidationOptions } from 'class-validator';
-export declare function IsUndefinableNumber(validationOptions?: ValidationOptions & {
+export declare const IsUndefinableNumber: (validationOptions?: ValidationOptions & {
     isFloat?: boolean;
-}): (object: Object, propertyName: string) => void;
+}) => PropertyDecorator;

package/dist/src/decorator/validate/is-undefinable-number.decorator.js

@@ -24,30 +24,27 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.IsUndefinableNumber = void 0;
-const is_boolean_1 = require("../../util/is-boolean");
-const is_empty_1 = require("../../util/is-empty");
 const class_validator_1 = require("class-validator");
 const FF = __importStar(require("fp-ts/function"));
 const FO = __importStar(require("fp-ts/Option"));
-function IsUndefinableNumber(validationOptions) {
-    return function (object, propertyName) {
-        (0, class_validator_1.registerDecorator)({
-            name: 'IsUndefinableNumber',
-            target: object.constructor,
-            propertyName: propertyName,
-            options: validationOptions,
-            validator: {
-                validate(value) {
-                    return FF.pipe(value, FO.fromPredicate(predicate => (0, is_empty_1.isUndefined)(predicate)), FO.fold(() => {
-                        const isNumber = (typeof value === 'number' && (0, is_boolean_1.isFalse)(isNaN(value))) || (0, is_empty_1.isUndefined)(value);
-                        return FF.pipe(validationOptions?.isFloat ?? false, FO.fromPredicate(predicate => (0, is_boolean_1.isTrue)(predicate)), FO.fold(() => (0, is_boolean_1.isTrue)(isNumber) && value % 1 === 0, () => (0, is_boolean_1.isTrue)(isNumber)));
-                    }, () => true));
-                },
-                defaultMessage(validationArguments) {
-                    return `${validationArguments?.property} should be number or undefined`;
-                },
+const is_boolean_1 = require("../../util/is-boolean");
+const is_empty_1 = require("../../util/is-empty");
+const isUndefinableNumber = (value, validationOptions) => {
+    return FF.pipe(value, FO.fromPredicate(predicate => (0, is_empty_1.isNotUndefined)(predicate)), FO.fold(() => true, () => {
+        const isNumber = typeof value === 'number' && (0, is_boolean_1.isFalse)(isNaN(value));
+        return FF.pipe(validationOptions?.isFloat ?? false, FO.fromPredicate(predicate => (0, is_boolean_1.isTrue)(predicate)), FO.fold(() => (0, is_boolean_1.isTrue)(isNumber) && value % 1 === 0, () => (0, is_boolean_1.isTrue)(isNumber)));
+    }));
+};
+const IsUndefinableNumber = (validationOptions) => {
+    return (0, class_validator_1.ValidateBy)({
+        name: 'IsUndefinableNumber',
+        constraints: [validationOptions],
+        validator: {
+            validate: (value) => isUndefinableNumber(value, validationOptions),
+            defaultMessage(validationArguments) {
+                return `${validationArguments?.property} should be number or null or undefined`;
             },
-        });
-    };
-}
+        },
+    }, validationOptions);
+};
 exports.IsUndefinableNumber = IsUndefinableNumber;

package/dist/src/decorator/validate/is-undefinable-sql-date-string.decorator.d.ts

@@ -1,2 +1,2 @@
 import { ValidationOptions } from 'class-validator';
-export declare function IsUndefinableSQLDateString(validationOptions?: ValidationOptions): (object: Object, propertyName: string) => void;
+export declare const IsUndefinableSQLDateString: (validationOptions?: ValidationOptions) => PropertyDecorator;

package/dist/src/decorator/validate/is-undefinable-sql-date-string.decorator.js

@@ -4,27 +4,22 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.IsUndefinableSQLDateString = void 0;
+const class_validator_1 = require("class-validator");
 const dayjs_1 = __importDefault(require("dayjs"));
 const customParseFormat_1 = __importDefault(require("dayjs/plugin/customParseFormat"));
 const is_empty_1 = require("../../util/is-empty");
-const class_validator_1 = require("class-validator");
 dayjs_1.default.extend(customParseFormat_1.default);
-function IsUndefinableSQLDateString(validationOptions) {
-    return function (object, propertyName) {
-        (0, class_validator_1.registerDecorator)({
-            name: 'IsUndefinableSQLDateString',
-            target: object.constructor,
-            propertyName: propertyName,
-            options: validationOptions,
-            validator: {
-                validate(value) {
-                    return (0, is_empty_1.isUndefined)(value) || (typeof value === 'string' && (0, dayjs_1.default)(value, 'YYYY-MM-DD', true).isValid());
-                },
-                defaultMessage(validationArguments) {
-                    return `${validationArguments?.property} should be YYYY-MM-DD`;
-                },
+const isUndefinableSQLDateString = (value) => (0, is_empty_1.isUndefined)(value) || (typeof value === 'string' && (0, dayjs_1.default)(value, 'YYYY-MM-DD', true).isValid());
+const IsUndefinableSQLDateString = (validationOptions) => {
+    return (0, class_validator_1.ValidateBy)({
+        name: 'IsUndefinableSQLDateString',
+        constraints: [validationOptions],
+        validator: {
+            validate: (value) => isUndefinableSQLDateString(value),
+            defaultMessage(validationArguments) {
+                return `${validationArguments?.property} should be YYYY-MM-DD or undefined`;
             },
-        });
-    };
-}
+        },
+    }, validationOptions);
+};
 exports.IsUndefinableSQLDateString = IsUndefinableSQLDateString;

package/dist/src/decorator/validate/is-undefinable-sql-date-time-string.decorator.d.ts

@@ -1,2 +1,2 @@
 import { ValidationOptions } from 'class-validator';
-export declare function IsUndefinableSQLDateTimeString(validationOptions?: ValidationOptions): (object: Object, propertyName: string) => void;
+export declare const IsUndefinableSQLDateTimeString: (validationOptions?: ValidationOptions) => PropertyDecorator;

package/dist/src/decorator/validate/is-undefinable-sql-date-time-string.decorator.js

@@ -4,27 +4,22 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.IsUndefinableSQLDateTimeString = void 0;
-const is_empty_1 = require("../../util/is-empty");
+const class_validator_1 = require("class-validator");
 const dayjs_1 = __importDefault(require("dayjs"));
 const customParseFormat_1 = __importDefault(require("dayjs/plugin/customParseFormat"));
-const class_validator_1 = require("class-validator");
+const is_empty_1 = require("../../util/is-empty");
 dayjs_1.default.extend(customParseFormat_1.default);
-function IsUndefinableSQLDateTimeString(validationOptions) {
-    return function (object, propertyName) {
-        (0, class_validator_1.registerDecorator)({
-            name: 'IsUndefinableSQLDateTimeString',
-            target: object.constructor,
-            propertyName: propertyName,
-            options: validationOptions,
-            validator: {
-                validate(value) {
-                    return (0, is_empty_1.isUndefined)(value) || (typeof value === 'string' && (0, dayjs_1.default)(value, 'YYYY-MM-DD HH:mm:ss', true).isValid());
-                },
-                defaultMessage(validationArguments) {
-                    return `${validationArguments?.property} should be YYYY-MM-DD hh:mm:ss`;
-                },
+const isUndefinableSqlDateTimeString = (value) => (0, is_empty_1.isUndefined)(value) || (typeof value === 'string' && (0, dayjs_1.default)(value, 'YYYY-MM-DD HH:mm:ss', true).isValid());
+const IsUndefinableSQLDateTimeString = (validationOptions) => {
+    return (0, class_validator_1.ValidateBy)({
+        name: 'IsUndefinableSQLDateTimeString',
+        constraints: [validationOptions],
+        validator: {
+            validate: (value) => isUndefinableSqlDateTimeString(value),
+            defaultMessage(validationArguments) {
+                return `${validationArguments?.property} should be YYYY-MM-DD hh:mm:ss or undefined`;
             },
-        });
-    };
-}
+        },
+    }, validationOptions);
+};
 exports.IsUndefinableSQLDateTimeString = IsUndefinableSQLDateTimeString;

package/dist/src/decorator/validate/is-undefinable-sql-time.decorator.d.ts

@@ -1,4 +1,4 @@
 import { ValidationOptions } from 'class-validator';
-export declare function IsUndefinableSQLTimeString(validationOptions?: ValidationOptions & {
+export declare const IsUndefinableSQLTimeString: (validationOptions?: ValidationOptions & {
     format: 'hh:mm' | 'hh:mm:ss';
-}): (object: Object, propertyName: string) => void;
+}) => PropertyDecorator;

package/dist/src/decorator/validate/is-undefinable-sql-time.decorator.js

@@ -24,34 +24,31 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.IsUndefinableSQLTimeString = void 0;
-const is_empty_1 = require("../../util/is-empty");
+const class_validator_1 = require("class-validator");
 const FF = __importStar(require("fp-ts/function"));
 const FO = __importStar(require("fp-ts/Option"));
-const class_validator_1 = require("class-validator");
-function IsUndefinableSQLTimeString(validationOptions) {
-    return function (object, propertyName) {
-        (0, class_validator_1.registerDecorator)({
-            name: 'IsUndefinableSQLTimeString',
-            target: object.constructor,
-            propertyName: propertyName,
-            options: validationOptions,
-            validator: {
-                validate(value) {
-                    return FF.pipe(value, FO.fromPredicate(refinement => (0, is_empty_1.isUndefined)(refinement)), FO.fold(() => {
-                        return FF.pipe(value, FO.fromPredicate(refinement => typeof refinement === 'string'), FO.fold(() => false, () => {
-                            return FF.pipe(validationOptions?.format, FO.fromPredicate(refinement => refinement === 'hh:mm'), FO.fold(() => {
-                                return RegExp(/^(?:(?:([01]\d|2[0-3]):)?([0-5]\d):)?([0-5]\d)$/).test(value);
-                            }, () => {
-                                return RegExp(/^(0[0-9]|1[0-9]|2[0-3]):[0-5][0-9]$/).test(value);
-                            }));
-                        }));
-                    }, () => true));
-                },
-                defaultMessage(validationArguments) {
-                    return `${validationArguments?.property} should be YYYY-MM-DD hh:mm:ss`;
-                },
+const is_empty_1 = require("../../util/is-empty");
+const isUndefinableSQLTimeString = (value, validationOptions) => {
+    return FF.pipe(value, FO.fromPredicate(refinement => (0, is_empty_1.isUndefined)(refinement)), FO.fold(() => {
+        return FF.pipe(value, FO.fromPredicate(refinement => typeof refinement === 'string'), FO.fold(() => false, () => {
+            return FF.pipe(validationOptions?.format, FO.fromPredicate(refinement => refinement === 'hh:mm'), FO.fold(() => {
+                return RegExp(/^(?:(?:([01]\d|2[0-3]):)?([0-5]\d):)?([0-5]\d)$/).test(value);
+            }, () => {
+                return RegExp(/^(0[0-9]|1[0-9]|2[0-3]):[0-5][0-9]$/).test(value);
+            }));
+        }));
+    }, () => true));
+};
+const IsUndefinableSQLTimeString = (validationOptions) => {
+    return (0, class_validator_1.ValidateBy)({
+        name: 'IsUndefinableSQLTimeString',
+        constraints: [validationOptions],
+        validator: {
+            validate: (value) => isUndefinableSQLTimeString(value, validationOptions),
+            defaultMessage(validationArguments) {
+                return `${validationArguments?.property} should be YYYY-MM-DD ${validationOptions?.format ?? 'hh:mm:ss'} or undefined`;
             },
-        });
-    };
-}
+        },
+    }, validationOptions);
+};
 exports.IsUndefinableSQLTimeString = IsUndefinableSQLTimeString;

package/dist/src/decorator/validate/is-undefinable-string.decorator.d.ts

@@ -1,4 +1,4 @@
 import { ValidationOptions } from 'class-validator';
-export declare function IsUndefinableString(validationOptions?: ValidationOptions & {
+export declare const IsUndefinableString: (validationOptions?: ValidationOptions & {
     blank?: boolean;
-}): (object: Object, propertyName: string) => void;
+}) => PropertyDecorator;

package/dist/src/decorator/validate/is-undefinable-string.decorator.js

@@ -1,26 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.IsUndefinableString = void 0;
+const class_validator_1 = require("class-validator");
 const is_boolean_1 = require("../../util/is-boolean");
 const is_empty_1 = require("../../util/is-empty");
-const class_validator_1 = require("class-validator");
 const string_validator_function_1 = require("./function/string-validator.function");
-function IsUndefinableString(validationOptions) {
-    return function (object, propertyName) {
-        (0, class_validator_1.registerDecorator)({
-            name: 'IsUndefinableString',
-            target: object.constructor,
-            propertyName: propertyName,
-            options: validationOptions,
-            validator: {
-                validate(value) {
-                    return (0, is_boolean_1.isTrue)((0, string_validator_function_1.stringValidator)(value, validationOptions?.blank)) || (0, is_empty_1.isUndefined)(value);
-                },
-                defaultMessage(validationArguments) {
-                    return `${validationArguments?.property} should be string or undefined`;
-                },
+const isUndefinableString = (value, validationOptions) => (0, is_boolean_1.isTrue)((0, string_validator_function_1.stringValidator)(value, validationOptions?.blank)) || (0, is_empty_1.isUndefined)(value);
+const IsUndefinableString = (validationOptions) => {
+    return (0, class_validator_1.ValidateBy)({
+        name: 'IsUndefinableString',
+        constraints: [validationOptions],
+        validator: {
+            validate: (value) => isUndefinableString(value, validationOptions),
+            defaultMessage(validationArguments) {
+                return `${validationArguments?.property} should be string or undefined`;
             },
-        });
-    };
-}
+        },
+    }, validationOptions);
+};
 exports.IsUndefinableString = IsUndefinableString;

package/dist/src/decorator/validate/is-undefinable.decorator.d.ts

@@ -1 +1 @@
-export declare function IsUndefinable(): PropertyDecorator;
+export declare const IsUndefinable: () => PropertyDecorator;

package/dist/src/decorator/validate/is-undefinable.decorator.js

@@ -3,9 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.IsUndefinable = void 0;
 const class_validator_1 = require("class-validator");
 const is_empty_1 = require("../../util/is-empty");
-function IsUndefinable() {
+const IsUndefinable = () => {
     return (0, class_validator_1.ValidateIf)((_, value) => {
         return (0, is_empty_1.isNotUndefined)(value);
     });
-}
+};
 exports.IsUndefinable = IsUndefinable;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "custom-class-validator-tools",
-  "version": "1.0.54",
+  "version": "1.1.0",
   "description": "",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
@@ -19,7 +19,7 @@
   "dependencies": {
     "class-transformer": "^0.5.1",
     "class-validator": "^0.14.0",
-    "dayjs": "1.11.8",
+    "dayjs": "^1.11.10",
     "fp-ts": "^2.11.9"
   },
   "devDependencies": {