custom-class-validator-tools 1.0.12

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

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

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

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IsOptionalString = 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 string_validator_function_1 = require("./function/string-validator.function");
+function IsOptionalString(validationOptions) {
+    return function (object, propertyName) {
+        (0, class_validator_1.registerDecorator)({
+            name: 'IsOptionalString',
+            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.isEmptySimple)(value);
+                },
+                defaultMessage(validationArguments) {
+                    return `${validationArguments?.property} should be string or null or undefined`;
+                },
+            },
+        });
+    };
+}
+exports.IsOptionalString = IsOptionalString;

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,24 @@
+"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`;
+                },
+            },
+        });
+    };
+}
+exports.IsUndefinableBoolean = IsUndefinableBoolean;

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

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

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

@@ -0,0 +1,25 @@
+"use strict";
+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");
+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 (typeof value === 'string' && value.length > 0 && (0, is_boolean_1.isFalse)(isNaN(Number(value)))) || (0, is_empty_1.isUndefined)(value);
+                },
+                defaultMessage(validationArguments) {
+                    return `${validationArguments?.property} should be number`;
+                },
+            },
+        });
+    };
+}
+exports.IsUndefinableNumberString = IsUndefinableNumberString;

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

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

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

@@ -0,0 +1,25 @@
+"use strict";
+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");
+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 (typeof value === 'number' && (0, is_boolean_1.isFalse)(isNaN(value))) || (0, is_empty_1.isUndefined)(value);
+                },
+                defaultMessage(validationArguments) {
+                    return `${validationArguments?.property} should be number or undefined`;
+                },
+            },
+        });
+    };
+}
+exports.IsUndefinableNumber = IsUndefinableNumber;

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

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

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

@@ -0,0 +1,30 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IsUndefinableSQLDateString = void 0;
+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`;
+                },
+            },
+        });
+    };
+}
+exports.IsUndefinableSQLDateString = IsUndefinableSQLDateString;

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

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

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

@@ -0,0 +1,30 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IsUndefinableSQLDateTimeString = void 0;
+const is_empty_1 = require("../../util/is-empty");
+const dayjs_1 = __importDefault(require("dayjs"));
+const customParseFormat_1 = __importDefault(require("dayjs/plugin/customParseFormat"));
+const class_validator_1 = require("class-validator");
+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`;
+                },
+            },
+        });
+    };
+}
+exports.IsUndefinableSQLDateTimeString = IsUndefinableSQLDateTimeString;

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

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

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

@@ -0,0 +1,57 @@
+"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.IsUndefinableSQLTimeString = void 0;
+const is_empty_1 = require("../../util/is-empty");
+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`;
+                },
+            },
+        });
+    };
+}
+exports.IsUndefinableSQLTimeString = IsUndefinableSQLTimeString;

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

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

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

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IsUndefinableString = 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 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`;
+                },
+            },
+        });
+    };
+}
+exports.IsUndefinableString = IsUndefinableString;

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

@@ -0,0 +1 @@
+export declare function IsUndefinable(): PropertyDecorator;

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

@@ -0,0 +1,11 @@
+"use strict";
+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() {
+    return (0, class_validator_1.ValidateIf)((_, value) => {
+        return (0, is_empty_1.isNotUndefined)(value);
+    });
+}
+exports.IsUndefinable = IsUndefinable;

package/dist/src/function/validate-with-header.decorators.d.ts

@@ -0,0 +1,2 @@
+import { ClassConstructor } from 'class-transformer';
+export declare function validateWithHeaders(dto: ClassConstructor<any>): import("class-validator").ValidationError[];

package/dist/src/function/validate-with-header.decorators.js

@@ -0,0 +1,33 @@
+"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.validateWithHeaders = void 0;
+const class_validator_1 = require("class-validator");
+const FE = __importStar(require("fp-ts/Either"));
+const FF = __importStar(require("fp-ts/function"));
+function validateWithHeaders(dto) {
+    return FF.pipe(FE.tryCatch(() => (0, class_validator_1.validateSync)(dto, { skipUndefinedProperties: true }), FE.toError), FE.fold(() => [], right => right));
+}
+exports.validateWithHeaders = validateWithHeaders;

package/dist/src/util/is-boolean.d.ts

@@ -0,0 +1,2 @@
+export declare function isTrue(value: boolean): boolean;
+export declare function isFalse(value: boolean): boolean;

package/dist/src/util/is-boolean.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isFalse = exports.isTrue = void 0;
+function isTrue(value) {
+    return value;
+}
+exports.isTrue = isTrue;
+function isFalse(value) {
+    return !value;
+}
+exports.isFalse = isFalse;

package/dist/src/util/is-empty.d.ts

@@ -0,0 +1,12 @@
+export declare function isUndefined<T>(value: T | undefined): value is undefined;
+export declare function isNotUndefined<T>(value?: T | undefined): value is T;
+export declare function isNull<T>(value?: T | null): value is null;
+export declare function isNotNull<T>(value?: T | null): value is T;
+declare type TSimpleValue<T> = T | null | undefined;
+export declare function isEmptySimple<T>(value: TSimpleValue<T>): value is null | undefined;
+export declare function isNotEmptySimple<T>(value: TSimpleValue<T>): value is T;
+export declare function isEmptyString(value?: string | null | undefined): value is null | undefined;
+export declare function isNotEmptyString(value?: string | null | undefined): value is string;
+export declare function isEmpty<T>(value?: T | null | undefined): value is null | undefined;
+export declare function isNotEmpty<T>(value?: T | null | undefined): value is T;
+export {};

package/dist/src/util/is-empty.js

@@ -0,0 +1,80 @@
+"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.isNotEmpty = exports.isEmpty = exports.isNotEmptyString = exports.isEmptyString = exports.isNotEmptySimple = exports.isEmptySimple = exports.isNotNull = exports.isNull = exports.isNotUndefined = exports.isUndefined = void 0;
+const FE = __importStar(require("fp-ts/Either"));
+const FF = __importStar(require("fp-ts/function"));
+function isUndefined(value) {
+    return value === undefined;
+}
+exports.isUndefined = isUndefined;
+function isNotUndefined(value) {
+    return !isUndefined(value);
+}
+exports.isNotUndefined = isNotUndefined;
+function isNull(value) {
+    return value === null;
+}
+exports.isNull = isNull;
+function isNotNull(value) {
+    return !isNull(value);
+}
+exports.isNotNull = isNotNull;
+function isEmptySimple(value) {
+    return isUndefined(value) || isNull(value);
+}
+exports.isEmptySimple = isEmptySimple;
+function isNotEmptySimple(value) {
+    return !isEmptySimple(value);
+}
+exports.isNotEmptySimple = isNotEmptySimple;
+function isEmptyString(value) {
+    return FF.pipe(value, FE.fromNullable(true), FE.map(notNull => notNull === ''), FE.fold(left => left, right => right));
+}
+exports.isEmptyString = isEmptyString;
+function isNotEmptyString(value) {
+    return !isEmptyString(value);
+}
+exports.isNotEmptyString = isNotEmptyString;
+function isEmpty(value) {
+    return FF.pipe(value, FE.fromNullable(true), FE.chain(notNull => {
+        return typeof notNull === 'string' && notNull === '' ? FE.left(true) : FE.right(notNull);
+    }), FE.chain(notString => {
+        return typeof notString === 'number' && isNaN(notString) ? FE.left(true) : FE.right(notString);
+    }), FE.chain(notNumber => {
+        return typeof notNumber === 'object' && Array.isArray(notNumber) && notNumber.length < 1
+            ? FE.left(true)
+            : FE.right(notNumber);
+    }), FE.chain(notArray => {
+        return typeof notArray === 'object' && !(notArray instanceof Date) && Object.keys(notArray).length < 1
+            ? FE.left(true)
+            : FE.right(notArray);
+    }), FE.fold(left => left, () => false));
+}
+exports.isEmpty = isEmpty;
+function isNotEmpty(value) {
+    return !isEmpty(value);
+}
+exports.isNotEmpty = isNotEmpty;

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "custom-class-validator-tools",
+  "version": "1.0.12",
+  "description": "",
+  "main": "dist/index.js",
+  "typings": "dist/index.d.ts",
+  "files": [
+    "dist/**/*"
+  ],
+  "scripts": {
+    "test": "jest",
+    "test:coverage": "jest --coverage",
+    "create:index": "just create:index",
+    "build": "just build",
+    "pub:npm": "just pub-npm"
+  },
+  "author": "internalservererror",
+  "license": "MIT",
+  "dependencies": {
+    "class-transformer": "^0.5.1",
+    "class-validator": "^0.13.2",
+    "dayjs": "^1.11.2",
+    "fp-ts": "^2.11.9"
+  },
+  "devDependencies": {
+    "@types/jest": "^27.4.1",
+    "@typescript-eslint/eslint-plugin": "^5.16.0",
+    "@typescript-eslint/parser": "^5.16.0",
+    "ctix": "^0.6.0",
+    "eslint": "^8.11.0",
+    "eslint-config-prettier": "^8.5.0",
+    "eslint-plugin-import": "^2.25.4",
+    "jest": "^28.1.0",
+    "just-scripts": "^2.0.0",
+    "prettier": "^2.6.0",
+    "reflect-metadata": "^0.1.13",
+    "ts-jest": "^28.0.3",
+    "ts-node": "^10.7.0",
+    "tsc-alias": "^1.6.7",
+    "typescript": "^4.6.2"
+  }
+}

package/readme.md

@@ -0,0 +1,71 @@
+## String type decorator
+
+
+| Decorator            | Type   | Description|
+| --- | --- | --- |
+| @IsNullableString | string | null | If want to ignore value ≠= ‘’, @IsNullableString({ blank: true }) |
+| @IsUndefinableString | string | undefined | If want to ignore value ≠= ‘’, @IsUndefinableString({ blank: true }) |
+| @IsOptionalString | string | null | undefined | If want to ignore value ≠= ‘’, @IsOptionalString({ blank: true }) |
+| @IsNotEmptyNumberString | string | Checks a string is a number |
+| @IsNotEmptyBooleanString | string | Checks a string is a boolean |
+| @IsNullableNumberString | string | null | Checks a string is a number or null |
+| @IsNullableBooleanString | string | null | Checks a string is a boolean or null |
+| @IsUndefinableNumberString | string | undefined | Checks a string is a number or undefined |
+| @IsUndefinableBooleanString | string | undefined | Checks a string is a boolean or null |
+| @IsOptionalNumberString | string | null | undefined | Checks a string is a number or  null or undefined |
+| @IsOptionalBooleanString | string | null | undefined | Checks a string is a boolean or  null or undefined |
+
+## Number type decorator
+
+
+| Decorator            | Type   |
+|----------------------|--------|
+| @IsNotEmptyNumber    | number |
+| @IsNullableNumber    | nubmer | null |
+| @IsUndefinableNumber | number | undefined |
+| @IsOptionalNumber    | number | null | undefined |
+|                      |        |
+
+## Boolean type decorator
+
+| Decorator            | Type   |
+| --- | --- |
+| @IsNotEmptyBoolean | boolean |
+| @IsNullableBoolean | boolean | null |
+| @IsUndefinalbeBoolean | boolean | undefined |
+| @IsOptionalBoolean | boolean | null | undefined |
+
+## ValidateNested usage case
+
+```ts
+import { isNotEmptyString, IsNotEmptyBoolean, isNullable, IsUndefinable } from 'custom-class-validator-tools';
+import { IsInstance, ArrayNotEmpty, ValidateNested } from 'class-validator';
+import { Type } from 'class-transformer';
+
+class Tag {
+  @IsNotEmptyString()
+  tag1: string;
+  @IsNotEmptyString()
+  tag2: string;
+}
+
+class Result {
+  @IsNotEmptyBoolean()
+  failed: boolean;
+}
+
+class Post {
+  @IsNullable()
+  @ArrayNotEmpty()
+  @IsInstance(Tag, { each: true })
+  @ValidateNested({ each: true })
+  @Type(() => Tag)
+  tags: Tag[] | null;
+
+  @IsUndefinable()
+  @IsInstance(Result)
+  @ValidateNested()
+  @Type(() => Result)
+  result?: Result;
+}
+```