custom-class-validator-tools 1.0.55 → 1.1.0

package/dist/index.d.ts

@@ -6,6 +6,7 @@ export * from './src/decorator/transform/number-to-boolean.decorator';
 export * from './src/decorator/transform/string-to-boolean.decorator';
 export * from './src/decorator/validate/is-not-empty-bigint-string.decorator';
 export * from './src/decorator/validate/is-not-empty-bigint.decorator';
+export * from './src/decorator/validate/is-not-empty-boolean-number.decorator';
 export * from './src/decorator/validate/is-not-empty-boolean-string.decorator';
 export * from './src/decorator/validate/is-not-empty-boolean.decorator';
 export * from './src/decorator/validate/is-not-empty-number-string.decorator';
@@ -15,6 +16,7 @@ export * from './src/decorator/validate/is-not-empty-sql-date-time-string.decora
 export * from './src/decorator/validate/is-not-empty-sql-time-string.decorator';
 export * from './src/decorator/validate/is-not-empty-string.decorator';
 export * from './src/decorator/validate/is-nullable-bigint.decorator';
+export * from './src/decorator/validate/is-nullable-boolean-number.decorator';
 export * from './src/decorator/validate/is-nullable-boolean-string.decorator';
 export * from './src/decorator/validate/is-nullable-boolean.decorator';
 export * from './src/decorator/validate/is-nullable-number-string.decorator';
@@ -27,6 +29,7 @@ export * from './src/decorator/validate/is-nullable.decorator';
 export * from './src/decorator/validate/is-optional-bigint.decorator';
 export * from './src/decorator/validate/is-optional-boolean-string.decorator';
 export * from './src/decorator/validate/is-optional-boolean.decorator';
+export * from './src/decorator/validate/is-optional-number-boolean.decorator';
 export * from './src/decorator/validate/is-optional-number-string.decorator';
 export * from './src/decorator/validate/is-optional-number.decorator';
 export * from './src/decorator/validate/is-optional-sql-date-string.decorator';
@@ -34,6 +37,7 @@ export * from './src/decorator/validate/is-optional-sql-date-time-string.decorat
 export * from './src/decorator/validate/is-optional-sql-time-string.decorator';
 export * from './src/decorator/validate/is-optional-string.decorator';
 export * from './src/decorator/validate/is-undefinable-bigint.decorator';
+export * from './src/decorator/validate/is-undefinable-boolean-number.decorator';
 export * from './src/decorator/validate/is-undefinable-boolean-string.decorator';
 export * from './src/decorator/validate/is-undefinable-boolean.decorator';
 export * from './src/decorator/validate/is-undefinable-number-string.decorator';

package/dist/index.js

@@ -23,6 +23,7 @@ __exportStar(require("./src/decorator/transform/number-to-boolean.decorator"), e
 __exportStar(require("./src/decorator/transform/string-to-boolean.decorator"), exports);
 __exportStar(require("./src/decorator/validate/is-not-empty-bigint-string.decorator"), exports);
 __exportStar(require("./src/decorator/validate/is-not-empty-bigint.decorator"), exports);
+__exportStar(require("./src/decorator/validate/is-not-empty-boolean-number.decorator"), exports);
 __exportStar(require("./src/decorator/validate/is-not-empty-boolean-string.decorator"), exports);
 __exportStar(require("./src/decorator/validate/is-not-empty-boolean.decorator"), exports);
 __exportStar(require("./src/decorator/validate/is-not-empty-number-string.decorator"), exports);
@@ -32,6 +33,7 @@ __exportStar(require("./src/decorator/validate/is-not-empty-sql-date-time-string
 __exportStar(require("./src/decorator/validate/is-not-empty-sql-time-string.decorator"), exports);
 __exportStar(require("./src/decorator/validate/is-not-empty-string.decorator"), exports);
 __exportStar(require("./src/decorator/validate/is-nullable-bigint.decorator"), exports);
+__exportStar(require("./src/decorator/validate/is-nullable-boolean-number.decorator"), exports);
 __exportStar(require("./src/decorator/validate/is-nullable-boolean-string.decorator"), exports);
 __exportStar(require("./src/decorator/validate/is-nullable-boolean.decorator"), exports);
 __exportStar(require("./src/decorator/validate/is-nullable-number-string.decorator"), exports);
@@ -44,6 +46,7 @@ __exportStar(require("./src/decorator/validate/is-nullable.decorator"), exports)
 __exportStar(require("./src/decorator/validate/is-optional-bigint.decorator"), exports);
 __exportStar(require("./src/decorator/validate/is-optional-boolean-string.decorator"), exports);
 __exportStar(require("./src/decorator/validate/is-optional-boolean.decorator"), exports);
+__exportStar(require("./src/decorator/validate/is-optional-number-boolean.decorator"), exports);
 __exportStar(require("./src/decorator/validate/is-optional-number-string.decorator"), exports);
 __exportStar(require("./src/decorator/validate/is-optional-number.decorator"), exports);
 __exportStar(require("./src/decorator/validate/is-optional-sql-date-string.decorator"), exports);
@@ -51,6 +54,7 @@ __exportStar(require("./src/decorator/validate/is-optional-sql-date-time-string.
 __exportStar(require("./src/decorator/validate/is-optional-sql-time-string.decorator"), exports);
 __exportStar(require("./src/decorator/validate/is-optional-string.decorator"), exports);
 __exportStar(require("./src/decorator/validate/is-undefinable-bigint.decorator"), exports);
+__exportStar(require("./src/decorator/validate/is-undefinable-boolean-number.decorator"), exports);
 __exportStar(require("./src/decorator/validate/is-undefinable-boolean-string.decorator"), exports);
 __exportStar(require("./src/decorator/validate/is-undefinable-boolean.decorator"), exports);
 __exportStar(require("./src/decorator/validate/is-undefinable-number-string.decorator"), exports);

package/dist/src/decorator/validate/is-not-empty-bigint-string.decorator.d.ts

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

package/dist/src/decorator/validate/is-not-empty-bigint-string.decorator.js

@@ -24,26 +24,23 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.IsNotEmptyBigIntString = void 0;
+const class_validator_1 = require("class-validator");
 const FE = __importStar(require("fp-ts/Either"));
 const FF = __importStar(require("fp-ts/function"));
 const FO = __importStar(require("fp-ts/Option"));
-const class_validator_1 = require("class-validator");
-function IsNotEmptyBigIntString(validationOptions) {
-    return function (object, propertyName) {
-        (0, class_validator_1.registerDecorator)({
-            name: 'IsNotEmptyBitIntString',
-            target: object.constructor,
-            propertyName: propertyName,
-            options: validationOptions,
-            validator: {
-                validate(value) {
-                    return FF.pipe(value, FO.fromPredicate(refinement => typeof refinement === 'string' && refinement.length > 0), FO.map(notNullString => FF.pipe(FE.tryCatch(() => BigInt(notNullString), () => false), FE.fold(left => left, () => true))), FO.fold(() => false, right => right));
-                },
-                defaultMessage(validationArguments) {
-                    return `${validationArguments?.property} should be bigint string`;
-                },
+const isNotEmptyBigIntString = (value) => {
+    return FF.pipe(value, FO.fromPredicate(refinement => typeof refinement === 'string' && refinement.length > 0), FO.map(notNullString => FF.pipe(FE.tryCatch(() => BigInt(notNullString), () => false), FE.fold(left => left, () => true))), FO.fold(() => false, right => right));
+};
+const IsNotEmptyBigIntString = (validationOptions) => {
+    return (0, class_validator_1.ValidateBy)({
+        name: 'IsNotEmptyBitIntString',
+        constraints: [validationOptions],
+        validator: {
+            validate: (value) => isNotEmptyBigIntString(value),
+            defaultMessage(validationArguments) {
+                return `${validationArguments?.property} should be bigint string`;
             },
-        });
-    };
-}
+        },
+    }, validationOptions);
+};
 exports.IsNotEmptyBigIntString = IsNotEmptyBigIntString;

package/dist/src/decorator/validate/is-not-empty-bigint.decorator.d.ts

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

package/dist/src/decorator/validate/is-not-empty-bigint.decorator.js

@@ -2,22 +2,17 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.IsNotEmptyBigInt = void 0;
 const class_validator_1 = require("class-validator");
-function IsNotEmptyBigInt(validationOptions) {
-    return function (object, propertyName) {
-        (0, class_validator_1.registerDecorator)({
-            name: 'IsNotEmptyBigInt',
-            target: object.constructor,
-            propertyName: propertyName,
-            options: validationOptions,
-            validator: {
-                validate(value) {
-                    return typeof value === 'bigint';
-                },
-                defaultMessage(validationArguments) {
-                    return `${validationArguments?.property} should be bigint`;
-                },
+const isNotEmptyBigInt = (value) => typeof value === 'bigint';
+const IsNotEmptyBigInt = (validationOptions) => {
+    return (0, class_validator_1.ValidateBy)({
+        name: 'IsNotEmptyBigInt',
+        constraints: [validationOptions],
+        validator: {
+            validate: (value) => isNotEmptyBigInt(value),
+            defaultMessage(validationArguments) {
+                return `${validationArguments?.property} should be bigint`;
             },
-        });
-    };
-}
+        },
+    }, validationOptions);
+};
 exports.IsNotEmptyBigInt = IsNotEmptyBigInt;

package/dist/src/decorator/validate/is-not-empty-boolean-number.decorator.d.ts

@@ -0,0 +1,4 @@
+import { ValidationOptions } from 'class-validator';
+export declare const IsNotEmptyBooleanNumber: (validationOptions?: ValidationOptions & {
+    strict?: boolean;
+}) => PropertyDecorator;

package/dist/src/decorator/validate/is-not-empty-boolean-number.decorator.js

@@ -0,0 +1,51 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IsNotEmptyBooleanNumber = void 0;
+const class_validator_1 = require("class-validator");
+const FF = __importStar(require("fp-ts/function"));
+const FO = __importStar(require("fp-ts/Option"));
+const is_boolean_1 = require("../../util/is-boolean");
+const strictValues = [1, 0];
+const isNotEmptyBooleanNumber = (value, validationOptions) => {
+    return FF.pipe(value, FO.fromNullable, FO.map(notEmptyValue => {
+        return FF.pipe(notEmptyValue, FO.fromPredicate(predicate => typeof predicate === 'number' && (0, is_boolean_1.isFalse)(isNaN(predicate))), FO.map(numberValue => {
+            return FF.pipe(validationOptions?.strict ?? true, FO.fromPredicate(predicate => (0, is_boolean_1.isTrue)(predicate)), FO.fold(() => true, () => strictValues.includes(numberValue)));
+        }), FO.fold(() => false, right => right));
+    }), FO.fold(() => false, right => right));
+};
+const IsNotEmptyBooleanNumber = (validationOptions) => {
+    return (0, class_validator_1.ValidateBy)({
+        name: 'IsNotEmptyBooleanNumber',
+        constraints: [validationOptions],
+        validator: {
+            validate: (value) => isNotEmptyBooleanNumber(value, validationOptions),
+            defaultMessage(validationArguments) {
+                return `${validationArguments?.property} should be boolean number`;
+            },
+        },
+    }, validationOptions);
+};
+exports.IsNotEmptyBooleanNumber = IsNotEmptyBooleanNumber;

package/dist/src/decorator/validate/is-not-empty-boolean-string.decorator.d.ts

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

package/dist/src/decorator/validate/is-not-empty-boolean-string.decorator.js

@@ -2,22 +2,19 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.IsNotEmptyBooleanString = void 0;
 const class_validator_1 = require("class-validator");
-function IsNotEmptyBooleanString(validationOptions) {
-    return function (object, propertyName) {
-        (0, class_validator_1.registerDecorator)({
-            name: 'INotEmptyBooleanString',
-            target: object.constructor,
-            propertyName: propertyName,
-            options: validationOptions,
-            validator: {
-                validate(value) {
-                    return typeof value === 'string' && value.length > 0 && ['true', 'false'].includes(value);
-                },
-                defaultMessage(validationArguments) {
-                    return `${validationArguments?.property} should be boolean`;
-                },
+const isNotEmptyBooleanString = (value) => {
+    return typeof value === 'string' && value.length > 0 && ['true', 'false'].includes(value);
+};
+const IsNotEmptyBooleanString = (validationOptions) => {
+    return (0, class_validator_1.ValidateBy)({
+        name: 'IsNotEmptyBooleanString',
+        constraints: [validationOptions],
+        validator: {
+            validate: (value) => isNotEmptyBooleanString(value),
+            defaultMessage(validationArguments) {
+                return `${validationArguments?.property} should be boolean string`;
             },
-        });
-    };
-}
+        },
+    }, validationOptions);
+};
 exports.IsNotEmptyBooleanString = IsNotEmptyBooleanString;

package/dist/src/decorator/validate/is-not-empty-boolean.decorator.d.ts

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

package/dist/src/decorator/validate/is-not-empty-boolean.decorator.js

@@ -2,22 +2,17 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.IsNotEmptyBoolean = void 0;
 const class_validator_1 = require("class-validator");
-function IsNotEmptyBoolean(validationOptions) {
-    return function (object, propertyName) {
-        (0, class_validator_1.registerDecorator)({
-            name: 'IsNotEmptyBoolean',
-            target: object.constructor,
-            propertyName: propertyName,
-            options: validationOptions,
-            validator: {
-                validate(value) {
-                    return typeof value === 'boolean';
-                },
-                defaultMessage(validationArguments) {
-                    return `${validationArguments?.property} should be boolean`;
-                },
+const isNotEmptyBoolean = (value) => typeof value === 'boolean';
+const IsNotEmptyBoolean = (validationOptions) => {
+    return (0, class_validator_1.ValidateBy)({
+        name: 'IsNotEmptyBoolean',
+        constraints: [validationOptions],
+        validator: {
+            validate: (value) => isNotEmptyBoolean(value),
+            defaultMessage(validationArguments) {
+                return `${validationArguments?.property} should be boolean`;
             },
-        });
-    };
-}
+        },
+    }, validationOptions);
+};
 exports.IsNotEmptyBoolean = IsNotEmptyBoolean;

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

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

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

@@ -24,31 +24,27 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.IsNotEmptyNumberString = void 0;
-const is_boolean_1 = require("../../util/is-boolean");
-const is_boolean_2 = require("../../util/is-boolean");
 const class_validator_1 = require("class-validator");
 const FF = __importStar(require("fp-ts/function"));
 const FO = __importStar(require("fp-ts/Option"));
-function IsNotEmptyNumberString(validationOptions) {
-    return function (object, propertyName) {
-        (0, class_validator_1.registerDecorator)({
-            name: 'IsNotEmptyNumberString',
-            target: object.constructor,
-            propertyName: propertyName,
-            options: validationOptions,
-            validator: {
-                validate(value) {
-                    const numberValue = Number(value);
-                    const isNumber = typeof value === 'string' && value.length > 0 && (0, is_boolean_2.isFalse)(isNaN(numberValue));
-                    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, () => {
-                        return (0, is_boolean_1.isTrue)(isNumber);
-                    }));
-                },
-                defaultMessage(validationArguments) {
-                    return `${validationArguments?.property} sould be number string`;
-                },
+const is_boolean_1 = require("../../util/is-boolean");
+const isNotEmptyNumberString = (value, validationOptions) => {
+    const numberValue = Number(value);
+    const isNumber = typeof value === 'string' && value.length > 0 && (0, is_boolean_1.isFalse)(isNaN(numberValue));
+    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, () => {
+        return (0, is_boolean_1.isTrue)(isNumber);
+    }));
+};
+const IsNotEmptyNumberString = (validationOptions) => {
+    return (0, class_validator_1.ValidateBy)({
+        name: 'IsNotEmptyNumberString',
+        constraints: [validationOptions],
+        validator: {
+            validate: (value) => isNotEmptyNumberString(value, validationOptions),
+            defaultMessage(validationArguments) {
+                return `${validationArguments?.property} should be number string`;
             },
-        });
-    };
-}
+        },
+    }, validationOptions);
+};
 exports.IsNotEmptyNumberString = IsNotEmptyNumberString;

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

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

package/dist/src/decorator/validate/is-not-empty-number.decorator.js

@@ -24,28 +24,24 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.IsNotEmptyNumber = void 0;
-const is_boolean_1 = require("../../util/is-boolean");
+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");
-const is_boolean_2 = require("../../util/is-boolean");
-function IsNotEmptyNumber(validationOptions) {
-    return function (object, propertyName) {
-        (0, class_validator_1.registerDecorator)({
-            name: 'IsNotEmptyNumber',
-            target: object.constructor,
-            propertyName: propertyName,
-            options: validationOptions,
-            validator: {
-                validate(value) {
-                    const isNumber = typeof value === 'number' && (0, is_boolean_2.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)));
-                },
-                defaultMessage(validationArguments) {
-                    return `${validationArguments?.property} should be number`;
-                },
+const is_boolean_1 = require("../../util/is-boolean");
+const isNotEmptyNumber = (value, validationOptions) => {
+    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 IsNotEmptyNumber = (validationOptions) => {
+    return (0, class_validator_1.ValidateBy)({
+        name: 'IsNotEmptyNumber',
+        constraints: [validationOptions],
+        validator: {
+            validate: (value) => isNotEmptyNumber(value, validationOptions),
+            defaultMessage(validationArguments) {
+                return `${validationArguments?.property} should be number`;
             },
-        });
-    };
-}
+        },
+    }, validationOptions);
+};
 exports.IsNotEmptyNumber = IsNotEmptyNumber;

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

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

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

@@ -4,27 +4,21 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.IsNotEmptySqlDateString = void 0;
+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 IsNotEmptySqlDateString(validationOptions) {
-    return function (object, propertyName) {
-        (0, class_validator_1.registerDecorator)({
-            name: 'IsNotEmptySqlDateString',
-            target: object.constructor,
-            propertyName: propertyName,
-            options: validationOptions,
-            validator: {
-                validate(value) {
-                    return typeof value === 'string' && (0, is_empty_1.isNotEmpty)(value) && (0, dayjs_1.default)(value, 'YYYY-MM-DD', true).isValid();
-                },
-                defaultMessage(validationArguments) {
-                    return `${validationArguments?.property} should be YYYY-MM-DD`;
-                },
+const isNotEmptySqlDateString = (value) => typeof value === 'string' && (0, dayjs_1.default)(value, 'YYYY-MM-DD', true).isValid();
+const IsNotEmptySqlDateString = (validationOptions) => {
+    return (0, class_validator_1.ValidateBy)({
+        name: 'IsNotEmptySqlDateString',
+        constraints: [validationOptions],
+        validator: {
+            validate: (value) => isNotEmptySqlDateString(value),
+            defaultMessage(validationArguments) {
+                return `${validationArguments?.property} should be YYYY-MM-DD`;
             },
-        });
-    };
-}
+        },
+    }, validationOptions);
+};
 exports.IsNotEmptySqlDateString = IsNotEmptySqlDateString;

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

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

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

@@ -4,27 +4,21 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.IsNotEmptySqlDateTimeString = void 0;
+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 IsNotEmptySqlDateTimeString(validationOptions) {
-    return function (object, propertyName) {
-        (0, class_validator_1.registerDecorator)({
-            name: 'IsNotEmptySqlDateTimeString',
-            target: object.constructor,
-            propertyName: propertyName,
-            options: validationOptions,
-            validator: {
-                validate(value) {
-                    return typeof value === 'string' && (0, is_empty_1.isNotEmpty)(value) && (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 isNotEmptySqlDateTimeString = (value) => typeof value === 'string' && (0, dayjs_1.default)(value, 'YYYY-MM-DD HH:mm:ss', true).isValid();
+const IsNotEmptySqlDateTimeString = (validationOptions) => {
+    return (0, class_validator_1.ValidateBy)({
+        name: 'IsNotEmptySqlDateTimeString',
+        constraints: [validationOptions],
+        validator: {
+            validate: (value) => isNotEmptySqlDateTimeString(value),
+            defaultMessage(validationArguments) {
+                return `${validationArguments?.property} should be YYYY-MM-DD hh:mm:ss`;
             },
-        });
-    };
-}
+        },
+    }, validationOptions);
+};
 exports.IsNotEmptySqlDateTimeString = IsNotEmptySqlDateTimeString;

package/dist/src/decorator/validate/is-not-empty-sql-time-string.decorator.d.ts

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

package/dist/src/decorator/validate/is-not-empty-sql-time-string.decorator.js

@@ -24,28 +24,25 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.IsNotEmptySqlTimeString = void 0;
+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 IsNotEmptySqlTimeString(validationOptions) {
-    return function (object, propertyName) {
-        (0, class_validator_1.registerDecorator)({
-            name: 'IsNotEmptySqlTimeString',
-            target: object.constructor,
-            propertyName: propertyName,
-            options: validationOptions,
-            validator: {
-                validate(value) {
-                    return FF.pipe(value, FO.fromNullable, FO.fold(() => false, right => {
-                        return FF.pipe(validationOptions?.format, FO.fromPredicate(refinement => refinement === 'hh:mm'), FO.fold(() => RegExp(/^(?:(?:([01]\d|2[0-3]):)?([0-5]\d):)?([0-5]\d)$/).test(right), () => RegExp(/^(0[0-9]|1[0-9]|2[0-3]):[0-5][0-9]$/).test(right)));
-                    }));
-                },
-                defaultMessage(validationArguments) {
-                    const format = validationOptions?.format ?? 'hh:mm:ss';
-                    return `${validationArguments?.property} should be YYYY-MM-DD ${format}`;
-                },
+const isNotEmptySqlTimeString = (value, validationOptions) => {
+    return FF.pipe(value, FO.fromNullable, FO.fold(() => false, right => {
+        return FF.pipe(validationOptions?.format, FO.fromPredicate(refinement => refinement === 'hh:mm'), FO.fold(() => RegExp(/^(?:(?:([01]\d|2[0-3]):)?([0-5]\d):)?([0-5]\d)$/).test(right), () => RegExp(/^(0[0-9]|1[0-9]|2[0-3]):[0-5][0-9]$/).test(right)));
+    }));
+};
+const IsNotEmptySqlTimeString = (validationOptions) => {
+    return (0, class_validator_1.ValidateBy)({
+        name: 'IsNoEmptySqlTimeString',
+        constraints: [validationOptions],
+        validator: {
+            validate: (value) => isNotEmptySqlTimeString(value, validationOptions),
+            defaultMessage(validationArguments) {
+                const format = validationOptions?.format ?? 'hh:mm:ss';
+                return `${validationArguments?.property} should be YYYY-MM-DD ${format}`;
             },
-        });
-    };
-}
+        },
+    }, validationOptions);
+};
 exports.IsNotEmptySqlTimeString = IsNotEmptySqlTimeString;

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

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

package/dist/src/decorator/validate/is-not-empty-string.decorator.js

@@ -3,22 +3,17 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.IsNotEmptyString = void 0;
 const class_validator_1 = require("class-validator");
 const string_validator_function_1 = require("./function/string-validator.function");
-function IsNotEmptyString(validationOptions) {
-    return function (object, propertyName) {
-        (0, class_validator_1.registerDecorator)({
-            name: 'IsNotEmptyString',
-            target: object.constructor,
-            propertyName: propertyName,
-            options: validationOptions,
-            validator: {
-                validate(value) {
-                    return (0, string_validator_function_1.stringValidator)(value, validationOptions?.blank);
-                },
-                defaultMessage(validationArguments) {
-                    return `${validationArguments?.property} should be string`;
-                },
+const isNotEmptyString = (value, validationOptions) => (0, string_validator_function_1.stringValidator)(value, validationOptions?.blank);
+const IsNotEmptyString = (validationOptions) => {
+    return (0, class_validator_1.ValidateBy)({
+        name: 'IsNotEmptyString',
+        constraints: [validationOptions],
+        validator: {
+            validate: (value) => isNotEmptyString(value, validationOptions),
+            defaultMessage(validationArguments) {
+                return `${validationArguments?.property} should be string`;
             },
-        });
-    };
-}
+        },
+    }, validationOptions);
+};
 exports.IsNotEmptyString = IsNotEmptyString;

package/dist/src/decorator/validate/is-nullable-bigint.decorator.d.ts

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