@wener/miniquery/lib/search/optimizeSearchExpr.js

SQL Where like **safe** filter expression for ORM.

function _define_property(obj, key, value) {
    if (key in obj) {
        Object.defineProperty(obj, key, {
            value: value,
            enumerable: true,
            configurable: true,
            writable: true
        });
    } else {
        obj[key] = value;
    }
    return obj;
}
function _object_spread(target) {
    for(var i = 1; i < arguments.length; i++){
        var source = arguments[i] != null ? arguments[i] : {};
        var ownKeys = Object.keys(source);
        if (typeof Object.getOwnPropertySymbols === "function") {
            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
            }));
        }
        ownKeys.forEach(function(key) {
            _define_property(target, key, source[key]);
        });
    }
    return target;
}
function ownKeys(object, enumerableOnly) {
    var keys = Object.keys(object);
    if (Object.getOwnPropertySymbols) {
        var symbols = Object.getOwnPropertySymbols(object);
        if (enumerableOnly) {
            symbols = symbols.filter(function(sym) {
                return Object.getOwnPropertyDescriptor(object, sym).enumerable;
            });
        }
        keys.push.apply(keys, symbols);
    }
    return keys;
}
function _object_spread_props(target, source) {
    source = source != null ? source : {};
    if (Object.getOwnPropertyDescriptors) {
        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
    } else {
        ownKeys(Object(source)).forEach(function(key) {
            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
        });
    }
    return target;
}
import { arrayOfMaybeArray, deepEqual } from '@wener/utils';
import { match } from 'ts-pattern';
export function optimizeSearchExpr(expr) {
    var NEG = {
        eq: 'ne',
        ne: 'eq',
        gt: 'lte',
        lt: 'gte',
        gte: 'lt',
        lte: 'gt'
    };
    var _expr = function(e) {
        // merge Exprs to AND ?
        return match(e)// (EXPR) -> EXPR
        // TODO (EXPR EXPR) -> EXPR AND EXPR
        .with({
            type: 'parentheses'
        }, function(expr) {
            // unwrap
            if (expr.value.length < 2) {
                return expr.value[0];
            }
            expr.value = expr.value.flatMap(_expr);
            return expr;
        }).with({
            type: 'comment'
        }, function(expr) {
            // remove empty comment
            if (!expr.value.length) {
                return [];
            }
            return expr;
        })// NOT
        .with({
            type: 'not'
        }, function(expr) {
            var out = arrayOfMaybeArray(_expr(expr.value));
            if (!out.length) {
                return [];
            } else if (out.length === 1) {
                expr.value = out[0];
            } else {
                throw new Error('NOT should have only one value');
            }
            return match(expr.value)// NOT NOT EXPR -> EXPR
            .with({
                type: 'not'
            }, function(expr) {
                return expr.value;
            })// NOT EXPR -> -EXPR
            .with({
                type: 'compare'
            }, function(expr) {
                return _object_spread_props(_object_spread({}, expr), {
                    negative: !expr.negative
                });
            }).with({
                type: 'keyword'
            }, function(expr) {
                return _object_spread_props(_object_spread({}, expr), {
                    negative: !expr.negative
                });
            }).otherwise(function() {
                return expr;
            });
        }).with({
            type: 'compare'
        }, function(expr) {
            // negative by swap operator
            if (expr.negative) {
                var ne = NEG[expr.operator];
                if (ne) {
                    expr.operator = ne;
                    expr.negative = false;
                }
            }
            if (expr.operator === 'range') {}
            return expr;
        }).otherwise(function(e) {
            return e;
        });
    };
    var last = expr;
    while(true){
        var next = structuredClone(last).flatMap(_expr);
        if (deepEqual(last, next)) {
            return last;
        }
        last = next;
    }
}