jet-validators/utils/dist/parseObject.js

A list common typescript validator-functions and some useful utilities to go with them.

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.strictTestNullishObjectArray = exports.strictTestNullableObjectArray = exports.strictTestOptionalObjectArray = exports.strictTestObjectArray = exports.strictTestNullishObject = exports.strictTestNullableObject = exports.strictTestOptionalObject = exports.strictTestObject = exports.looseTestNullishObjectArray = exports.looseTestNullableObjectArray = exports.looseTestOptionalObjectArray = exports.looseTestObjectArray = exports.looseTestNullishObject = exports.looseTestNullableObject = exports.looseTestOptionalObject = exports.looseTestObject = exports.testNullishObjectArray = exports.testNullableObjectArray = exports.testOptionalObjectArray = exports.testObjectArray = exports.testNullishObject = exports.testNullableObject = exports.testOptionalObject = exports.testObject = exports.strictParseNullishObjectArray = exports.strictParseNullableObjectArray = exports.strictParseOptionalObjectArray = exports.strictParseObjectArray = exports.strictParseNullishObject = exports.strictParseNullableObject = exports.strictParseOptionalObject = exports.strictParseObject = exports.looseParseNullishObjectArray = exports.looseParseNullableObjectArray = exports.looseParseOptionalObjectArray = exports.looseParseObjectArray = exports.looseParseNullishObject = exports.looseParseNullableObject = exports.looseParseOptionalObject = exports.looseParseObject = exports.parseNullishObjectArray = exports.parseNullableObjectArray = exports.parseOptionalObjectArray = exports.parseObjectArray = exports.parseNullishObject = exports.parseNullableObject = exports.parseOptionalObject = exports.parseObject = void 0;
const dist_1 = require("../../dist");
var Safety;
(function (Safety) {
    Safety[Safety["Loose"] = 0] = "Loose";
    Safety[Safety["Default"] = 1] = "Default";
    Safety[Safety["Strict"] = 2] = "Strict";
})(Safety || (Safety = {}));
const ERRORS = {
    NotObject: 'Parsed item was not an object.',
    NotOptional: 'Root argument is undefined but not optional.',
    NotNullable: 'Root argument is null but not nullable.',
    NotArray: 'Root argument is not an array.',
    NestedValidation: 'Nested validation failed.',
    ValidatorFn: 'Validator-function returned false.',
    ErrorThrown: 'Validator function threw an error.',
    StrictSafety: 'strict-safety failed, prop not in schema.',
    SchemaProp: 'Schema property must be a function or nested schema',
};
;
const parseObject = (schema, onError) => _parseObject(schema, false, false, false, Safety.Default, onError);
exports.parseObject = parseObject;
const parseOptionalObject = (schema, onError) => _parseObject(schema, true, false, false, Safety.Default, onError);
exports.parseOptionalObject = parseOptionalObject;
const parseNullableObject = (schema, onError) => _parseObject(schema, false, true, false, Safety.Default, onError);
exports.parseNullableObject = parseNullableObject;
const parseNullishObject = (schema, onError) => _parseObject(schema, true, true, false, Safety.Default, onError);
exports.parseNullishObject = parseNullishObject;
const parseObjectArray = (schema, onError) => _parseObject(schema, false, false, true, Safety.Default, onError);
exports.parseObjectArray = parseObjectArray;
const parseOptionalObjectArray = (schema, onError) => _parseObject(schema, true, false, true, Safety.Default, onError);
exports.parseOptionalObjectArray = parseOptionalObjectArray;
const parseNullableObjectArray = (schema, onError) => _parseObject(schema, false, true, true, Safety.Default, onError);
exports.parseNullableObjectArray = parseNullableObjectArray;
const parseNullishObjectArray = (schema, onError) => _parseObject(schema, true, true, true, Safety.Default, onError);
exports.parseNullishObjectArray = parseNullishObjectArray;
const looseParseObject = (schema, onError) => _parseObject(schema, false, false, false, Safety.Loose, onError);
exports.looseParseObject = looseParseObject;
const looseParseOptionalObject = (schema, onError) => _parseObject(schema, true, false, false, Safety.Loose, onError);
exports.looseParseOptionalObject = looseParseOptionalObject;
const looseParseNullableObject = (schema, onError) => _parseObject(schema, false, true, false, Safety.Loose, onError);
exports.looseParseNullableObject = looseParseNullableObject;
const looseParseNullishObject = (schema, onError) => _parseObject(schema, true, true, false, Safety.Loose, onError);
exports.looseParseNullishObject = looseParseNullishObject;
const looseParseObjectArray = (schema, onError) => _parseObject(schema, false, false, true, Safety.Loose, onError);
exports.looseParseObjectArray = looseParseObjectArray;
const looseParseOptionalObjectArray = (schema, onError) => _parseObject(schema, true, false, true, Safety.Loose, onError);
exports.looseParseOptionalObjectArray = looseParseOptionalObjectArray;
const looseParseNullableObjectArray = (schema, onError) => _parseObject(schema, false, true, true, Safety.Loose, onError);
exports.looseParseNullableObjectArray = looseParseNullableObjectArray;
const looseParseNullishObjectArray = (schema, onError) => _parseObject(schema, true, true, true, Safety.Loose, onError);
exports.looseParseNullishObjectArray = looseParseNullishObjectArray;
const strictParseObject = (schema, onError) => _parseObject(schema, false, false, false, Safety.Strict, onError);
exports.strictParseObject = strictParseObject;
const strictParseOptionalObject = (schema, onError) => _parseObject(schema, true, false, false, Safety.Strict, onError);
exports.strictParseOptionalObject = strictParseOptionalObject;
const strictParseNullableObject = (schema, onError) => _parseObject(schema, false, true, false, Safety.Strict, onError);
exports.strictParseNullableObject = strictParseNullableObject;
const strictParseNullishObject = (schema, onError) => _parseObject(schema, true, true, false, Safety.Strict, onError);
exports.strictParseNullishObject = strictParseNullishObject;
const strictParseObjectArray = (schema, onError) => _parseObject(schema, false, false, true, Safety.Strict, onError);
exports.strictParseObjectArray = strictParseObjectArray;
const strictParseOptionalObjectArray = (schema, onError) => _parseObject(schema, true, false, true, Safety.Strict, onError);
exports.strictParseOptionalObjectArray = strictParseOptionalObjectArray;
const strictParseNullableObjectArray = (schema, onError) => _parseObject(schema, false, true, true, Safety.Strict, onError);
exports.strictParseNullableObjectArray = strictParseNullableObjectArray;
const strictParseNullishObjectArray = (schema, onError) => _parseObject(schema, true, true, true, Safety.Strict, onError);
exports.strictParseNullishObjectArray = strictParseNullishObjectArray;
function _parseObject(schema, optional, nullable, isArr, safety, onErrorLower) {
    return (arg, onError) => {
        if (!!onErrorLower || !!onError) {
            return _parseObjectHelperWithErrCb(!!optional, !!nullable, isArr, schema, arg, safety, (errors) => {
                Object.defineProperty(errors, 'isParseObjectErrorArr', {
                    value: true,
                    writable: false,
                });
                onErrorLower?.(errors);
                onError?.(errors);
            });
        }
        return _parseObjectHelperWoErrCb(!!optional, !!nullable, isArr, schema, arg, safety);
    };
}
function _parseObjectHelperWithErrCb(optional, nullable, isArr, schema, arg, safety, onError) {
    if (arg === undefined) {
        if (!optional) {
            onError([{ info: ERRORS.NotOptional }]);
            return false;
        }
        return undefined;
    }
    if (arg === null) {
        if (!nullable) {
            onError([{ info: ERRORS.NotNullable }]);
            return false;
        }
        return null;
    }
    const errArr = [];
    if (isArr) {
        if (!Array.isArray(arg)) {
            onError([{ info: ERRORS.NotArray }]);
            return false;
        }
        for (let i = 0; i < arg.length; i++) {
            _parseObjectHelperWithErrCb2(schema, arg[i], errArr, safety, i);
        }
        if (errArr.length > 0) {
            onError(errArr);
            return false;
        }
        return arg;
    }
    _parseObjectHelperWithErrCb2(schema, arg, errArr, safety);
    if (errArr.length > 0) {
        onError(errArr);
        return false;
    }
    return arg;
}
function _parseObjectHelperWithErrCb2(schemaParentObj, argParentObj, errArr, safety, index) {
    if (!(0, dist_1.isRecord)(argParentObj)) {
        errArr.push({
            info: ERRORS.NotObject,
            ...((0, dist_1.isUndef)(index) ? {} : { index }),
        });
        return false;
    }
    for (const key in schemaParentObj) {
        const schemaProp = schemaParentObj[key], val = argParentObj[key];
        if ((0, dist_1.isFunction)(schemaProp)) {
            try {
                let childErrors, passed = false, info = ERRORS.ValidatorFn;
                if (schemaProp.isTransFn === true) {
                    passed = schemaProp(val, tval => argParentObj[key] = tval);
                }
                else {
                    passed = schemaProp(val, errors => {
                        if (isParseObjectErrArr(errors)) {
                            info = ERRORS.NestedValidation;
                            childErrors = errors;
                        }
                    });
                }
                if (!passed) {
                    errArr.push({
                        info,
                        prop: key,
                        ...((!!childErrors && childErrors.length > 0) ? {
                            children: childErrors,
                        } : {
                            value: val,
                        }),
                        ...((0, dist_1.isUndef)(index) ? {} : { index }),
                    });
                }
            }
            catch (err) {
                let caught;
                if (err instanceof Error) {
                    caught = err.message;
                }
                else if ((0, dist_1.isString)(err)) {
                    caught = err;
                }
                else {
                    caught = JSON.stringify(err);
                }
                errArr.push({
                    info: ERRORS.ErrorThrown,
                    prop: key,
                    value: val,
                    caught,
                    ...((0, dist_1.isUndef)(index) ? {} : { index }),
                });
            }
        }
        else if ((0, dist_1.isRecord)(schemaProp) && Object.keys(schemaProp).length > 0) {
            const childErrArr = [], childVal = _parseObjectHelperWithErrCb2(schemaProp, val, childErrArr, safety);
            if (childVal === false) {
                errArr.push({
                    info: ERRORS.NestedValidation,
                    prop: key,
                    children: childErrArr,
                    ...((0, dist_1.isUndef)(index) ? {} : { index }),
                });
            }
        }
        else {
            throw new Error(ERRORS.SchemaProp);
        }
    }
    if (safety !== Safety.Loose) {
        for (const key in argParentObj) {
            if (!(key in schemaParentObj)) {
                if (safety === Safety.Strict) {
                    errArr.push({
                        info: ERRORS.StrictSafety,
                        prop: key,
                        ...((0, dist_1.isUndef)(index) ? {} : { index }),
                    });
                }
                Reflect.deleteProperty(argParentObj, key);
            }
        }
    }
    if (errArr.length > 0) {
        return false;
    }
    return argParentObj;
}
function _parseObjectHelperWoErrCb(optional, nullable, isArr, schema, arg, safety) {
    if (arg === undefined) {
        return !optional ? false : undefined;
    }
    if (arg === null) {
        return !nullable ? false : null;
    }
    if (isArr) {
        if (!Array.isArray(arg)) {
            return false;
        }
        for (const item of arg) {
            const parsedItem = _parseObjectHelperWoErrCb2(schema, item, safety);
            if (parsedItem === false) {
                return false;
            }
        }
        return arg;
    }
    const resp = _parseObjectHelperWoErrCb2(schema, arg, safety);
    if (resp === false) {
        return false;
    }
    return arg;
}
function _parseObjectHelperWoErrCb2(schemaParentObj, argParentObj, safety) {
    if (!(0, dist_1.isRecord)(argParentObj)) {
        return false;
    }
    for (const key in schemaParentObj) {
        const schemaProp = schemaParentObj[key], val = argParentObj[key];
        if ((0, dist_1.isFunction)(schemaProp)) {
            try {
                let passed = false;
                if (schemaProp.isTransFn === true) {
                    passed = schemaProp(val, tval => argParentObj[key] = tval);
                }
                else {
                    passed = schemaProp(val);
                }
                if (!passed) {
                    return false;
                }
            }
            catch {
                return false;
            }
        }
        else if ((0, dist_1.isRecord)(schemaProp) && Object.keys(schemaProp).length > 0) {
            const childVal = _parseObjectHelperWoErrCb2(schemaProp, val, safety);
            if (childVal === false) {
                return false;
            }
        }
        else {
            throw new Error(ERRORS.SchemaProp);
        }
    }
    if (safety !== Safety.Loose) {
        for (const key in argParentObj) {
            if (!(key in schemaParentObj)) {
                if (safety === Safety.Strict) {
                    return false;
                }
                Reflect.deleteProperty(argParentObj, key);
            }
        }
    }
    return argParentObj;
}
function isParseObjectErrArr(arg) {
    return (Array.isArray(arg) &&
        arg.length > 0 &&
        'isParseObjectErrorArr' in arg &&
        arg.isParseObjectErrorArr === true);
}
const testObject = (schema, onError) => _testObject(schema, false, false, false, Safety.Default, onError);
exports.testObject = testObject;
const testOptionalObject = (schema, onError) => _testObject(schema, true, false, false, Safety.Default, onError);
exports.testOptionalObject = testOptionalObject;
const testNullableObject = (schema, onError) => _testObject(schema, false, true, false, Safety.Default, onError);
exports.testNullableObject = testNullableObject;
const testNullishObject = (schema, onError) => _testObject(schema, true, true, false, Safety.Default, onError);
exports.testNullishObject = testNullishObject;
const testObjectArray = (schema, onError) => _testObject(schema, false, false, true, Safety.Default, onError);
exports.testObjectArray = testObjectArray;
const testOptionalObjectArray = (schema, onError) => _testObject(schema, true, false, true, Safety.Default, onError);
exports.testOptionalObjectArray = testOptionalObjectArray;
const testNullableObjectArray = (schema, onError) => _testObject(schema, false, true, true, Safety.Default, onError);
exports.testNullableObjectArray = testNullableObjectArray;
const testNullishObjectArray = (schema, onError) => _testObject(schema, true, true, true, Safety.Default, onError);
exports.testNullishObjectArray = testNullishObjectArray;
const looseTestObject = (schema, onError) => _testObject(schema, false, false, false, Safety.Loose, onError);
exports.looseTestObject = looseTestObject;
const looseTestOptionalObject = (schema, onError) => _testObject(schema, true, false, false, Safety.Loose, onError);
exports.looseTestOptionalObject = looseTestOptionalObject;
const looseTestNullableObject = (schema, onError) => _testObject(schema, false, true, false, Safety.Loose, onError);
exports.looseTestNullableObject = looseTestNullableObject;
const looseTestNullishObject = (schema, onError) => _testObject(schema, true, true, false, Safety.Loose, onError);
exports.looseTestNullishObject = looseTestNullishObject;
const looseTestObjectArray = (schema, onError) => _testObject(schema, false, false, true, Safety.Loose, onError);
exports.looseTestObjectArray = looseTestObjectArray;
const looseTestOptionalObjectArray = (schema, onError) => _testObject(schema, true, false, true, Safety.Loose, onError);
exports.looseTestOptionalObjectArray = looseTestOptionalObjectArray;
const looseTestNullableObjectArray = (schema, onError) => _testObject(schema, false, true, true, Safety.Loose, onError);
exports.looseTestNullableObjectArray = looseTestNullableObjectArray;
const looseTestNullishObjectArray = (schema, onError) => _testObject(schema, true, true, true, Safety.Loose, onError);
exports.looseTestNullishObjectArray = looseTestNullishObjectArray;
const strictTestObject = (schema, onError) => _testObject(schema, false, false, false, Safety.Strict, onError);
exports.strictTestObject = strictTestObject;
const strictTestOptionalObject = (schema, onError) => _testObject(schema, true, false, false, Safety.Strict, onError);
exports.strictTestOptionalObject = strictTestOptionalObject;
const strictTestNullableObject = (schema, onError) => _testObject(schema, false, true, false, Safety.Strict, onError);
exports.strictTestNullableObject = strictTestNullableObject;
const strictTestNullishObject = (schema, onError) => _testObject(schema, true, true, false, Safety.Strict, onError);
exports.strictTestNullishObject = strictTestNullishObject;
const strictTestObjectArray = (schema, onError) => _testObject(schema, false, false, true, Safety.Strict, onError);
exports.strictTestObjectArray = strictTestObjectArray;
const strictTestOptionalObjectArray = (schema, onError) => _testObject(schema, true, false, true, Safety.Strict, onError);
exports.strictTestOptionalObjectArray = strictTestOptionalObjectArray;
const strictTestNullableObjectArray = (schema, onError) => _testObject(schema, false, true, true, Safety.Strict, onError);
exports.strictTestNullableObjectArray = strictTestNullableObjectArray;
const strictTestNullishObjectArray = (schema, onError) => _testObject(schema, true, true, true, Safety.Strict, onError);
exports.strictTestNullishObjectArray = strictTestNullishObjectArray;
function _testObject(schema, optional, nullable, isArr, safety, onError) {
    const parseFn = _parseObject(schema, optional, nullable, isArr, safety, onError);
    return (arg, onError) => {
        const res = parseFn(arg, onError);
        return res !== false;
    };
}
//# sourceMappingURL=parseObject.js.map