index.js

'use strict';

const { uniqWith, isEqual, intersection } = require('lodash');

function pruneExpression(expression) {
    if (typeof expression === 'string') {
        return expression;
    } else if (expression.not) {
        expression.not = pruneExpression(expression.not);
        return expression;
    } else if (expression.and) {
        for (let i = 0; i < expression.and.length; i++) {
            const andExpression = expression.and[i];
            if (typeof andExpression === 'object' && andExpression.and) {
                // Remove the nested 'and' expression and insert its contents
                expression.and.splice(i, 1, ...andExpression.and);
                i--; // bump counter back since we just inserted more items w/ the splice
            } else if (typeof andExpression === 'object' && andExpression.or) {
                // Check if there are any common variables between the base group and any nested "or" groups
                const variablesInGroup = expression.and.filter(item => typeof item === 'string');
                if (intersection(variablesInGroup, andExpression.or).length > 0) {
                    // Remove the nested 'or' expression as it is redundant
                    expression.and.splice(i, 1);
                    i--; // bump counter back since we just removed an element
                } else {
                    expression.and[i] = pruneExpression(andExpression);
                }
            } else {
                expression.and[i] = pruneExpression(andExpression);
            }
        }

        expression.and = uniqWith(expression.and, isEqual);

        // If there is only one element left after deduplication, just return that
        if (expression.and.length === 1) {
            return expression.and[0];
        }

        return expression;
    } else if (expression.or) {
        for (let i = 0; i < expression.or.length; i++) {
            const orExpression = expression.or[i];
            if (typeof orExpression === 'object' && orExpression.or) {
                // Remove the nested 'or' expression and insert its contents
                expression.or.splice(i, 1, ...orExpression.or);
                // bump counter back since we just inserted more items w/ the splice
                i--;
            } else if (typeof orExpression === 'object' && orExpression.and) {
                // Check if there are any common variables between the base group and any nested "and" groups
                const variablesInGroup = expression.or.filter(item => typeof item === 'string');
                if (intersection(variablesInGroup, orExpression.and).length > 0) {
                    // Remove the nested 'or' expression as it is redundant
                    expression.or.splice(i, 1);
                    i--; // bump counter back since we just removed an element
                } else {
                    expression.or[i] = pruneExpression(orExpression);
                }
            } else {
                expression.or[i] = pruneExpression(orExpression);
            }
        }

        expression.or = uniqWith(expression.or, isEqual);

        // If there is only one element left after deduplication, just return that
        if (expression.or.length === 1) {
            return expression.or[0];
        }

        return expression;
    }
}

module.exports = pruneExpression;