@hiki9/rich-domain/dist/core/domain/validation-is.js

Rich Domain is a library that provides a set of tools to help you build complex business logic in NodeJS using Domain Driven Design principles.

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.is = void 0;
const is_email_1 = require("../../utils/is-email");
const is_uuid_1 = require("../../utils/is-uuid");
const is_valid_date_1 = require("../../utils/is-valid-date");
const LengthLog = (min, max) => {
    if (typeof min !== 'number' && typeof max !== 'number') {
        return '';
    }
    if (typeof min === 'number' && typeof max === 'number') {
        return `Intervalo permitido: ${min} - ${max}.`;
    }
    if (typeof min === 'number') {
        return `Valor mínimo permitido: ${min}.`;
    }
    if (typeof max === 'number') {
        return `Valor máximo permitido: ${max}.`;
    }
};
const StringRangeValidator = (min = 0, max = Number.MAX_SAFE_INTEGER) => {
    return function StringRange(value) {
        if (value.length < min || value.length > max) {
            return `Esperava receber um valor de texto válido. ` + LengthLog(min, max);
        }
    };
};
const NumberRangeValidator = (min = Number.MIN_SAFE_INTEGER, max = Number.MAX_SAFE_INTEGER) => {
    return function NumberRange(value) {
        if (value < min || value > max) {
            return `Valor fora do intervalo permitido. Intervalo permitido: ${min} - ${max}.`;
        }
    };
};
exports.is = {
    nullable(callback) {
        return function Nullable(value) {
            if (value === null || value === undefined) {
                return;
            }
            return callback(value);
        };
    },
    arrayOf(callback) {
        return function ArrayOf(value) {
            if (!Array.isArray(value)) {
                return 'Tipo de valor inválido. Esperava receber uma lista';
            }
            const result = value.findIndex(v => callback(v));
            if (result > -1) {
                return callback(value[result]);
            }
        };
    },
    in(values) {
        return function In(value) {
            if (!values.includes(value)) {
                return 'Valor inválido. Disponível: ' + values.join(', ');
            }
        };
    },
    defined() {
        return function AnyType(value) {
            if (value === null || value === undefined) {
                return 'Tipo de valor inválido. Esperava um valor definido.';
            }
        };
    },
    anyType() {
        return function AnyType(value) {
            value;
            return;
        };
    },
    uuid() {
        return function UUID(value) {
            if (typeof value !== 'string' || !(0, is_uuid_1.isUUID)(value)) {
                return 'UUID inválido.';
            }
        };
    },
    string(min, max) {
        return function String(value) {
            if (typeof value !== 'string') {
                return 'Esperava receber um valor de texto válido.';
            }
            return StringRangeValidator(min, max)(value);
        };
    },
    email() {
        return function Email(value) {
            if (typeof value !== 'string' || !(0, is_email_1.isEmail)(value)) {
                return 'Email inválido.';
            }
        };
    },
    date() {
        return function Date(value) {
            if (!(0, is_valid_date_1.isValidDate)(value)) {
                return 'Esperava receber um valor de data válido.';
            }
        };
    },
    number(min, max) {
        return function Number(value) {
            if (!(typeof value === 'number' && !isNaN(value))) {
                return 'Esperava receber um número válido.';
            }
            return NumberRangeValidator(min, max)(value);
        };
    },
    integer(min, max) {
        return function Integer(value) {
            if (!Number.isInteger(value)) {
                return 'Esperava receber um número inteiro.';
            }
            return NumberRangeValidator(min, max)(value);
        };
    },
    boolean() {
        return function Boolean(value) {
            if (typeof value !== 'boolean') {
                return 'Tipo de valor inválido. Esperava receber um valor booleano.';
            }
        };
    },
    enumOf(enumInstance) {
        return function EnumOf(value) {
            let thisEnum = enumInstance;
            if (typeof enumInstance === 'function') {
                thisEnum = enumInstance();
            }
            const enumValues = Object.values(thisEnum);
            if (!enumValues.includes(value)) {
                return 'Valor enum inválido. Disponível: ' + enumValues.join(', ');
            }
        };
    },
    instanceof(clazz) {
        return function InstanceOf(value) {
            let thisInstance;
            if (typeof clazz === 'function') {
                thisInstance = isClass(clazz) ? clazz : clazz();
            }
            if (!thisInstance) {
                throw new TypeError('O tipo de instância não foi definido. (is.instanceof)');
            }
            if (!(value instanceof thisInstance)) {
                return 'Tipo de valor inválido. instance-of reference: ' + (thisInstance?.name || thisInstance?.constructor?.name);
            }
        };
    }
};
function isClass(v) {
    return typeof v === 'function' && /^\s*class\s+/.test(v.toString());
}
//# sourceMappingURL=validation-is.js.map