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

'use strict';
import { URL } from 'url';
import { CatalystAppError, CatalystError } from './errors';
export function isBuffer(value) {
    return isBuffer(value);
}
export function isArray(value) {
    return Array.isArray(value);
}
export function isBoolean(value) {
    return typeof value === 'boolean';
}
export function isNumber(value) {
    return typeof value === 'number' && !isNaN(value);
}
export function isValidNumber(value, throwErr = false) {
    if (typeof value !== 'number') {
        if (throwErr) {
            throw new 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 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 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 CatalystError({
                code: 'UNSAFE_NUMBER',
                message: `Number ${value.toString()} is lesser than Number.MIN_SAFE_INTEGER. Use BigInt`,
                value
            });
        }
        return false;
    }
    return true;
}
export function isString(value) {
    return typeof value === 'string';
}
export function isObject(value) {
    return typeof value === 'object' && !isArray(value);
}
export function isEmail(email) {
    if (!isString(email)) {
        return false;
    }
    const re = /^[^@]+@[^@]+$/;
    return re.test(email);
}
export 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(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;
}
export 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 CatalystError({
                code: 'INVALID_ARGUMENT',
                message: `Value for property ${undefinedElement} cannot be null or undefined in ${objName} object`,
                value: obj
            });
        }
        return false;
    }
    return true;
}
export function isNonEmptyString(value, name, throwErr) {
    if (isString(value) && value !== '') {
        return true;
    }
    if (throwErr) {
        throw new CatalystError({
            code: 'INVALID_ARGUMENT',
            message: `Value provided for ${name} is expected to be a non-empty and non-null string.`,
            value
        });
    }
    return false;
}
export function isNonNullValue(value, name, throwErr) {
    if (value !== null) {
        return true;
    }
    if (throwErr) {
        throw new CatalystError({
            code: 'INVALID_ARGUMENT',
            message: `Value provided for ${name} is expected to be a non-null value.`,
            value
        });
    }
    return false;
}
export function isNonNullObject(value, name, throwErr) {
    if (isObject(value) && value !== null) {
        return true;
    }
    if (throwErr) {
        throw new CatalystError({
            code: 'INVALID_ARGUMENT',
            message: `Value provided for ${name} is expected to be a non-null json object.`,
            value
        });
    }
    return false;
}
export function isNonEmptyObject(value, name, throwErr) {
    if (isNonNullObject(value, name, throwErr) &&
        Object.keys(value).length !== 0) {
        return true;
    }
    if (throwErr) {
        throw new CatalystError({
            code: 'INVALID_ARGUMENT',
            message: `Value provided for ${name} is expected to be a non-empty and non-null json object.`,
            value
        });
    }
    return false;
}
export function isNonEmptyArray(value, name, throwErr) {
    if (isArray(value) && value.length !== 0) {
        return true;
    }
    if (throwErr) {
        throw new CatalystError({
            code: 'INVALID_ARGUMENT',
            message: `Value provided for ${name} is expected to be a non-empty Array.`,
            value
        });
    }
    return false;
}
export function isNonEmptyStringOrNumber(value, name, throwErr) {
    if (isNonEmptyString(value) || isValidNumber(value)) {
        return true;
    }
    if (throwErr) {
        throw new CatalystError({
            code: 'INVALID_ARGUMENT',
            message: `Value provided for ${name} is expected to be a non-null and non-empty String/Number.`,
            value
        });
    }
    return false;
}
export function isValidType(value, type, name, throwErr) {
    if (typeof value === type) {
        return true;
    }
    if (throwErr) {
        throw new CatalystError({
            code: 'INVALID_ARGUMENT_TYPE',
            message: `Value provided for ${name} must be of type ${type}`,
            value
        });
    }
    return false;
}
export function isValidApp(app, throwErr) {
    if (!isNonNullObject(app) ||
        !('config' in app) ||
        !('credential' in app) ||
        !isNonEmptyStringOrNumber(app.config.projectId)) {
        if (throwErr) {
            throw new CatalystAppError('INVALID_PROJECT_INSTANCE', 'Project instance is not valid', app);
        }
        return false;
    }
    return true;
}
export 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;
}
export function wrapValidatorsWithPromise(targetFunction, errorInstance) {
    return new Promise((resolve, reject) => {
        try {
            targetFunction();
        }
        catch (e) {
            if (e instanceof CatalystError) {
                reject(new errorInstance(e.code, e.message));
            }
            reject(e);
        }
        resolve();
    });
}
export function wrapValidators(targetFunction, errorInstance) {
    try {
        targetFunction();
    }
    catch (e) {
        if (e instanceof CatalystError) {
            throw new errorInstance(e.code, e.message);
        }
        throw e;
    }
}
export function isValidInputString(value, name, throwErr) {
    if (isNonEmptyString(value, name, throwErr)) {
        if (/^[a-zA-Z0-9-_]+$/.test(value)) {
            return true;
        }
    }
    if (throwErr) {
        throw new CatalystError({
            code: 'INVALID_ARGUMENT',
            message: `The value provided for ${name} contains invalid characters.`,
            value
        });
    }
    return false;
}