@zcatalyst/utils/dist-cjs/validators.js

'use strict';
Object.defineProperty(exports, "__esModule", { value: true });
exports.isBuffer = isBuffer;
exports.isArray = isArray;
exports.isBoolean = isBoolean;
exports.isNumber = isNumber;
exports.isValidNumber = isValidNumber;
exports.isString = isString;
exports.isObject = isObject;
exports.isEmail = isEmail;
exports.isURL = isURL;
exports.ObjectHasProperties = ObjectHasProperties;
exports.isNonEmptyString = isNonEmptyString;
exports.isNonNullValue = isNonNullValue;
exports.isNonNullObject = isNonNullObject;
exports.isNonEmptyObject = isNonEmptyObject;
exports.isNonEmptyArray = isNonEmptyArray;
exports.isNonEmptyStringOrNumber = isNonEmptyStringOrNumber;
exports.isValidType = isValidType;
exports.isValidApp = isValidApp;
exports.ObjectHasDeprecatedProperty = ObjectHasDeprecatedProperty;
exports.wrapValidatorsWithPromise = wrapValidatorsWithPromise;
exports.wrapValidators = wrapValidators;
exports.isValidInputString = isValidInputString;
const url_1 = require("url");
const errors_1 = require("./errors");
function isBuffer(value) {
    return isBuffer(value);
}
function isArray(value) {
    return Array.isArray(value);
}
function isBoolean(value) {
    return typeof value === 'boolean';
}
function isNumber(value) {
    return typeof value === 'number' && !isNaN(value);
}
function isValidNumber(value, throwErr = false) {
    if (typeof value !== 'number') {
        if (throwErr) {
            throw new errors_1.CatalystError({
                code: 'INVALID_NUMBER',
                message: 'Not a number type',
                value
            });
        }
        return false;
    }
    if ([Number.NaN, Number.POSITIVE_INFINITY, Number.NEGATIVE_INFINITY]
        .map((val) => val.toString())
        .includes(value.toString())) {
        if (throwErr) {
            throw new errors_1.CatalystError({
                code: 'INVALID_NUMBER',
                message: 'Special number values cannot be used',
                value
            });
        }
        return false;
    }
    else if (value > Number.MAX_SAFE_INTEGER) {
        if (throwErr) {
            throw new errors_1.CatalystError({
                code: 'UNSAFE_NUMBER',
                message: `Number ${value.toString()} is greater than Number.MAX_SAFE_INTEGER. Use BigInt`,
                value
            });
        }
        return false;
    }
    else if (value < Number.MIN_SAFE_INTEGER) {
        if (throwErr) {
            throw new errors_1.CatalystError({
                code: 'UNSAFE_NUMBER',
                message: `Number ${value.toString()} is lesser than Number.MIN_SAFE_INTEGER. Use BigInt`,
                value
            });
        }
        return false;
    }
    return true;
}
function isString(value) {
    return typeof value === 'string';
}
function isObject(value) {
    return typeof value === 'object' && !isArray(value);
}
function isEmail(email) {
    if (!isString(email)) {
        return false;
    }
    const re = /^[^@]+@[^@]+$/;
    return re.test(email);
}
function isURL(urlStr) {
    if (typeof urlStr !== 'string') {
        return false;
    }
    const re = /[^a-z0-9-._~:/?#[\]@!$&'()*+,;=]/i;
    if (re.test(urlStr)) {
        return false;
    }
    try {
        const schemeTest = /^(http|https):/;
        const uri = new url_1.URL(urlStr);
        const scheme = uri.protocol;
        const slashes = uri.pathname.startsWith('/');
        const hostname = uri.hostname;
        const pathname = uri.pathname;
        if ((scheme !== null && !schemeTest.test(scheme)) || !slashes) {
            return false;
        }
        if (hostname !== null && !/^[a-zA-Z0-9]+[w-]*([.]?[a-zA-Z0-9]+[w-]*)*$/.test(hostname)) {
            return false;
        }
        const pathnameRe = /(\/[0-9].*\?|$)/;
        if (pathname && !pathnameRe.test(pathname)) {
            return false;
        }
    }
    catch (e) {
        return false;
    }
    return true;
}
function ObjectHasProperties(obj, properties, objName, throwErr) {
    const undefinedElement = properties.find((prop) => typeof obj[prop] === 'undefined' || obj[prop] === null || obj[prop] === '');
    if (undefinedElement !== undefined) {
        if (throwErr) {
            throw new errors_1.CatalystError({
                code: 'INVALID_ARGUMENT',
                message: `Value for property ${undefinedElement} cannot be null or undefined in ${objName} object`,
                value: obj
            });
        }
        return false;
    }
    return true;
}
function isNonEmptyString(value, name, throwErr) {
    if (isString(value) && value !== '') {
        return true;
    }
    if (throwErr) {
        throw new errors_1.CatalystError({
            code: 'INVALID_ARGUMENT',
            message: `Value provided for ${name} is expected to be a non-empty and non-null string.`,
            value
        });
    }
    return false;
}
function isNonNullValue(value, name, throwErr) {
    if (value !== null) {
        return true;
    }
    if (throwErr) {
        throw new errors_1.CatalystError({
            code: 'INVALID_ARGUMENT',
            message: `Value provided for ${name} is expected to be a non-null value.`,
            value
        });
    }
    return false;
}
function isNonNullObject(value, name, throwErr) {
    if (isObject(value) && value !== null) {
        return true;
    }
    if (throwErr) {
        throw new errors_1.CatalystError({
            code: 'INVALID_ARGUMENT',
            message: `Value provided for ${name} is expected to be a non-null json object.`,
            value
        });
    }
    return false;
}
function isNonEmptyObject(value, name, throwErr) {
    if (isNonNullObject(value, name, throwErr) &&
        Object.keys(value).length !== 0) {
        return true;
    }
    if (throwErr) {
        throw new errors_1.CatalystError({
            code: 'INVALID_ARGUMENT',
            message: `Value provided for ${name} is expected to be a non-empty and non-null json object.`,
            value
        });
    }
    return false;
}
function isNonEmptyArray(value, name, throwErr) {
    if (isArray(value) && value.length !== 0) {
        return true;
    }
    if (throwErr) {
        throw new errors_1.CatalystError({
            code: 'INVALID_ARGUMENT',
            message: `Value provided for ${name} is expected to be a non-empty Array.`,
            value
        });
    }
    return false;
}
function isNonEmptyStringOrNumber(value, name, throwErr) {
    if (isNonEmptyString(value) || isValidNumber(value)) {
        return true;
    }
    if (throwErr) {
        throw new errors_1.CatalystError({
            code: 'INVALID_ARGUMENT',
            message: `Value provided for ${name} is expected to be a non-null and non-empty String/Number.`,
            value
        });
    }
    return false;
}
function isValidType(value, type, name, throwErr) {
    if (typeof value === type) {
        return true;
    }
    if (throwErr) {
        throw new errors_1.CatalystError({
            code: 'INVALID_ARGUMENT_TYPE',
            message: `Value provided for ${name} must be of type ${type}`,
            value
        });
    }
    return false;
}
function isValidApp(app, throwErr) {
    if (!isNonNullObject(app) ||
        !('config' in app) ||
        !('credential' in app) ||
        !isNonEmptyStringOrNumber(app.config.projectId)) {
        if (throwErr) {
            throw new errors_1.CatalystAppError('INVALID_PROJECT_INSTANCE', 'Project instance is not valid', app);
        }
        return false;
    }
    return true;
}
function ObjectHasDeprecatedProperty(object, depProp, prop, throwWarn, del) {
    if (object.hasOwnProperty(depProp)) {
        if (del) {
            object[prop] = object[depProp];
            delete object[depProp];
        }
        if (throwWarn) {
            console.warn(`Warning! Value for property ${depProp} is deprecated use ${prop} instead`);
        }
        return true;
    }
    return false;
}
function wrapValidatorsWithPromise(targetFunction, errorInstance) {
    return new Promise((resolve, reject) => {
        try {
            targetFunction();
        }
        catch (e) {
            if (e instanceof errors_1.CatalystError) {
                reject(new errorInstance(e.code, e.message));
            }
            reject(e);
        }
        resolve();
    });
}
function wrapValidators(targetFunction, errorInstance) {
    try {
        targetFunction();
    }
    catch (e) {
        if (e instanceof errors_1.CatalystError) {
            throw new errorInstance(e.code, e.message);
        }
        throw e;
    }
}
function isValidInputString(value, name, throwErr) {
    if (isNonEmptyString(value, name, throwErr)) {
        if (/^[a-zA-Z0-9-_]+$/.test(value)) {
            return true;
        }
    }
    if (throwErr) {
        throw new errors_1.CatalystError({
            code: 'INVALID_ARGUMENT',
            message: `The value provided for ${name} contains invalid characters.`,
            value
        });
    }
    return false;
}