nhb-toolbox/dist/cjs/object/sanitize.js

A versatile collection of smart, efficient, and reusable utility functions, classes and types for everyday development needs.

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.sanitizeData = sanitizeData;
exports.parseObjectValues = parseObjectValues;
const guards_1 = require("../date/guards");
const guards_2 = require("../form/guards");
const non_primitives_1 = require("../guards/non-primitives");
const primitives_1 = require("../guards/primitives");
const basics_1 = require("../string/basics");
function sanitizeData(input, options, _return) {
    const { keysToIgnore = [], requiredKeys = [], trimStrings = true, ignoreNullish = false, ignoreFalsy = false, ignoreEmpty = false, } = options || {};
    const ignoreKeySet = new Set(keysToIgnore);
    const _isRequiredKey = (key) => {
        return Array.isArray(requiredKeys)
            ? requiredKeys?.some((path) => key === path || key.startsWith(`${path}.`))
            : requiredKeys === '*';
    };
    const _skipObject = (obj) => {
        return ignoreEmpty && (0, non_primitives_1.isObject)(obj) && !(0, non_primitives_1.isNotEmptyObject)(obj);
    };
    const _shouldNotProcess = (value) => {
        return ((0, guards_2.isCustomFile)(value) ||
            (0, guards_2.isFileList)(value) ||
            (0, guards_2.isFileOrBlob)(value) ||
            (0, guards_2.isFileUpload)(value) ||
            (0, guards_1.isDateLike)(value));
    };
    const _processArray = (arr, path) => {
        return arr
            ?.map((item) => {
            if ((0, primitives_1.isString)(item) && trimStrings) {
                return (0, basics_1.trimString)(item);
            }
            if (Array.isArray(item)) {
                return _processArray(item, path);
            }
            if ((0, non_primitives_1.isObject)(item)) {
                return _processObject(item, path);
            }
            return item;
        })
            ?.filter((v) => {
            if (ignoreNullish && v == null)
                return false;
            if (ignoreFalsy && !v)
                return false;
            if (_skipObject(v) && !_isRequiredKey(path))
                return false;
            return true;
        });
    };
    const _processObject = (object, parentPath = '') => Object.entries(object).reduce((acc, [key, value]) => {
        const fullKeyPath = parentPath ? `${parentPath}.${key}` : key;
        if (ignoreKeySet.has(fullKeyPath)) {
            return acc;
        }
        if (ignoreNullish && !_isRequiredKey(fullKeyPath) && value == null) {
            return acc;
        }
        if (ignoreFalsy && !value && !_isRequiredKey(fullKeyPath)) {
            return acc;
        }
        if ((0, primitives_1.isString)(value) && trimStrings) {
            acc[key] = (0, basics_1.trimString)(value);
        }
        else if (_shouldNotProcess(value)) {
            acc[key] = value;
        }
        else if (value && (0, non_primitives_1.isObject)(value)) {
            if (_shouldNotProcess(value)) {
                acc[key] = value;
            }
            else {
                const processedValue = _processObject(value, fullKeyPath);
                if (!ignoreEmpty ||
                    _isRequiredKey(fullKeyPath) ||
                    (0, non_primitives_1.isNotEmptyObject)(processedValue)) {
                    acc[key] = processedValue;
                }
            }
        }
        else if (value && Array.isArray(value)) {
            const processedArray = _processArray(value, fullKeyPath);
            if (!ignoreEmpty || _isRequiredKey(fullKeyPath) || processedArray?.length > 0) {
                acc[key] = processedArray;
            }
        }
        else {
            acc[key] = value;
        }
        return acc;
    }, {});
    if ((0, primitives_1.isString)(input)) {
        return (0, basics_1.trimString)(input);
    }
    if (Array.isArray(input)) {
        if ((0, non_primitives_1.isArrayOfType)(input, primitives_1.isString)) {
            return (0, basics_1.trimString)(input);
        }
        return input
            ?.map((item) => sanitizeData(item, options, _return))
            ?.filter((val) => {
            if (ignoreNullish && val == null)
                return false;
            if (ignoreFalsy && !val)
                return false;
            if (_skipObject(val))
                return false;
            return true;
        });
    }
    if ((0, non_primitives_1.isObject)(input)) {
        return _processObject(input);
    }
    return input;
}
function parseObjectValues(object, parseNested = true) {
    function _deepParseValues(data) {
        if (Array.isArray(data)) {
            return data?.map(_deepParseValues);
        }
        else if ((0, non_primitives_1.isNotEmptyObject)(data)) {
            const result = {};
            for (const [key, value] of Object.entries(data)) {
                result[key] = parseNested ? _deepParseValues(value) : value;
            }
            return result;
        }
        else if ((0, primitives_1.isString)(data)) {
            try {
                const parsed = JSON.parse(data);
                return _deepParseValues(parsed);
            }
            catch {
                if (data === 'true')
                    return true;
                else if (data === 'false') {
                    return false;
                }
                else if (data === 'null') {
                    return null;
                }
                else if (data === 'undefined') {
                    return undefined;
                }
                else if (!Number.isNaN(Number(data))) {
                    return Number(data);
                }
                else
                    return data;
            }
        }
        return data;
    }
    const parsedBody = {};
    if ((0, non_primitives_1.isNotEmptyObject)(object)) {
        Object.entries(object)?.forEach(([key, value]) => {
            parsedBody[key] = _deepParseValues(value);
        });
    }
    return parsedBody;
}