objectManipulator.js

function manipulate({ model, ignore, keyMap, valueMap, order }) {
      const _ignore = (
            [
                /_?id$/,
                /_at$/
            ]
        )
        .concat(ignore)
        .filter(r => r);

    const _stringIgnore = _ignore.filter(rule => (
        typeof rule === 'string'
    ));

    const _regexIgnore = _ignore.filter(rule => (
        rule.constructor === RegExp
    ));

    const _funcIgnore = _ignore.filter(rule => (
        typeof rule === 'function'
    ));

    let entries = (
        Object
            .entries(model)
            .filter(([_, value]) => (
                !(typeof value === 'object' && value !== null)
                && value !== undefined
            ))
    );

    // Filter based on string
    if (_stringIgnore.length) {
        entries = entries.filter(([key]) => (
            !_stringIgnore.includes(key)
        ));
    }

    // Filter based on regex
    if (_regexIgnore.length) {
        entries = entries.filter(([key]) => {
            for (let i = 0; i < _regexIgnore.length; i++) {
                const rule = _regexIgnore[i];

                if (rule.test(key)) {
                    return false;
                }
            }

            return true;
        });
    }

    // Filter based on function
    if (_funcIgnore.length) {
        entries = entries.filter(([key]) => {
            for (let i = 0; i < _funcIgnore.length; i++) {
                const rule = _funcIgnore[i];

                if (rule(key)) {
                    return false;
                }
            }

            return true;
        });
    }

    // Map keys
    switch (typeof keyMap) {
        case 'object':
            if (Object.keys(keyMap).length) {
                entries = entries.map(([key, value]) => {
                    const mapper = keyMap[key];

                    if (mapper) {
                        switch (typeof mapper) {
                            case 'function':
                                key = mapper(key);
                                break;
                            default:
                                key = mapper;
                        }
                    }

                    return [key, value];
                });
            }

            break;
        case 'function':
            if (!isNoop(keyMap)) {
                entries = entries.map(([key, value]) => {
                    return [keyMap(key), value];
                });
            }

            break;
    }

    // Map values
    switch (typeof valueMap) {
        case 'object':
            const valueMapKeys = Object.values(valueMap);

            if (valueMapKeys.length) {
                entries = entries.map(([key, value]) => {
                    const mapper = valueMap[key];

                    if (mapper) {
                        switch (typeof mapper) {
                            case 'function':
                                value = mapper({ key, value });
                                break;
                        }
                    }

                    return [key, value];
                });
            }

            break;
        case 'function':
            if (!isNoop(valueMap)) {
                entries = entries.map(([key, value]) => {
                    return [key, valueMap({ key, value })];
                });
            }

            break;
    }

    let orderedEntries = [];

    if (order.length) {
        for (let i = 0; i < entries.length; i++) {
            const entry = entries[i];
            const [key] = entry;

            const j = order.findIndex(query => {
                if (typeof query === 'function') {
                    return query(entry);
                } else if (query.constructor) {
                    switch (query.constructor) {
                        case RegExp:
                            return query.test(key);
                        default:
                            return query === key;
                    }
                }

                return false;
            });

            if (j !== -1) {
                orderedEntries.splice(j, 0, entry);

                continue;
            }

            orderedEntries.push(entry);
        }
    } else {
        orderedEntries = entries;
    }
    
    return orderedEntries;
}