typescript-domain/lib/src/validation.js

Decorator-based transformation of JSON or plain Javascript objects to classes

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.EntityValidation = exports.validateValue = exports.DEBUG_INFO = void 0;
var DEBUG_INFO;
(function (DEBUG_INFO) {
    DEBUG_INFO["EMPTY"] = "value is undefined";
    DEBUG_INFO["NOT_ARRAY"] = "value is not array";
    DEBUG_INFO["NOT_BOOLEAN"] = "value is not a boolean";
    DEBUG_INFO["NOT_DATE"] = "value cannot be parsed to Date";
    DEBUG_INFO["NOT_ENUM"] = "value is not option of the enum";
    DEBUG_INFO["NOT_NUMBER"] = "value is not a number";
    DEBUG_INFO["NOT_STRING"] = "value is not a string";
    DEBUG_INFO["NOT_VALID_OBJECT"] = "object created from input is not valid";
})(DEBUG_INFO = exports.DEBUG_INFO || (exports.DEBUG_INFO = {}));
const validateValue = (value, 
// eslint-disable-next-line @typescript-eslint/ban-types
type, array, debugFunction, debugSkipUndef) => {
    if (array) {
        const { validatedValue, debugInfo } = EntityValidation.array(value, type, debugFunction, debugSkipUndef);
        return { validatedValue, debugInfo: debugInfo.join(',') };
    }
    const empty = validateEmpty(value);
    if (empty) {
        return empty;
    }
    switch (type) {
        case Boolean:
            return EntityValidation.boolean(value);
        case Date:
            return EntityValidation.date(value);
        case Number:
            return EntityValidation.number(value);
        case String:
            return EntityValidation.string(value);
        default:
            return Array.isArray(type)
                ? EntityValidation.enum(value, type)
                : EntityValidation.object(type, value, debugFunction, debugSkipUndef);
    }
};
exports.validateValue = validateValue;
const validateEmpty = (value) => {
    if (value === undefined) {
        return {
            validatedValue: null,
            debugInfo: DEBUG_INFO.EMPTY
        };
    }
    if (value === null) {
        return {
            validatedValue: null,
            debugInfo: null
        };
    }
    return null;
};
class EntityValidation {
    static array(data, 
    // eslint-disable-next-line @typescript-eslint/ban-types
    type, debugFunction, debugSkipUndef) {
        if (data === undefined) {
            return {
                validatedValue: [],
                debugInfo: [DEBUG_INFO.EMPTY]
            };
        }
        if (data === null) {
            return {
                validatedValue: [],
                debugInfo: []
            };
        }
        if (!Array.isArray(data)) {
            return {
                validatedValue: [],
                debugInfo: [DEBUG_INFO.NOT_ARRAY]
            };
        }
        const validatedValue = [];
        const debugInfo = [];
        for (const child of data) {
            const childValue = (0, exports.validateValue)(child, type, Array.isArray(child), debugFunction, debugSkipUndef);
            if (childValue.validatedValue !== null) {
                validatedValue.push(childValue.validatedValue);
            }
            if (childValue.debugInfo !== null) {
                debugInfo.push(childValue.debugInfo);
            }
        }
        return { validatedValue, debugInfo };
    }
    static boolean(value) {
        const empty = validateEmpty(value);
        if (empty) {
            return empty;
        }
        if (typeof value === 'boolean') {
            return {
                validatedValue: value,
                debugInfo: null
            };
        }
        return {
            validatedValue: null,
            debugInfo: DEBUG_INFO.NOT_BOOLEAN
        };
    }
    static date(value) {
        const empty = validateEmpty(value);
        if (empty) {
            return empty;
        }
        if (typeof value !== 'string' &&
            typeof value !== 'number' &&
            !(value instanceof Date)) {
            return {
                validatedValue: null,
                debugInfo: DEBUG_INFO.NOT_DATE
            };
        }
        const date = new Date(value);
        if (isNaN(date.getTime())) {
            return {
                validatedValue: null,
                debugInfo: DEBUG_INFO.NOT_DATE
            };
        }
        return {
            validatedValue: date,
            debugInfo: null
        };
    }
    static enum(value, options) {
        const empty = validateEmpty(value);
        if (empty) {
            return empty;
        }
        if (value && options.includes(value)) {
            return {
                validatedValue: value,
                debugInfo: null
            };
        }
        return {
            validatedValue: null,
            debugInfo: DEBUG_INFO.NOT_ENUM
        };
    }
    static number(value) {
        const empty = validateEmpty(value);
        if (empty) {
            return empty;
        }
        if (typeof value === 'number') {
            return {
                validatedValue: value,
                debugInfo: null
            };
        }
        return {
            validatedValue: null,
            debugInfo: DEBUG_INFO.NOT_NUMBER
        };
    }
    static object(Type, data, debugFunction, debugSkipUndef) {
        const empty = validateEmpty(data);
        if (empty) {
            return empty;
        }
        const object = new Type(data, debugFunction, debugSkipUndef);
        if (object.isValid()) {
            return {
                validatedValue: object,
                debugInfo: null
            };
        }
        return {
            validatedValue: null,
            debugInfo: DEBUG_INFO.NOT_VALID_OBJECT
        };
    }
    static string(value) {
        const empty = validateEmpty(value);
        if (empty) {
            return empty;
        }
        if (typeof value === 'string') {
            return {
                validatedValue: value,
                debugInfo: null
            };
        }
        return {
            validatedValue: null,
            debugInfo: DEBUG_INFO.NOT_STRING
        };
    }
}
exports.EntityValidation = EntityValidation;