valraiso-expression-parser/dist/evaluator.js

An expression evaluator written in typescript with the goal to support SQL like WHERE clauses.

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.evaluateObject = exports.evaluate = void 0;
const parser_1 = require("./parser");
function evaluateExpressions(expressions, context) {
    return expressions.map((exp) => evaluateExpression(exp, context));
}
function evaluateFunctionCall(name, args) {
    switch (name) {
        case 'length':
            if (args.length !== 1) {
                throw new Error('Length function takes exactly one argument.');
            }
            return args[0].length;
        default:
            throw new Error(`Function ${name} not implemented`);
    }
}
function evaluateBinaryExpression(expression, context) {
    switch (expression.operator) {
        case '+':
            return evaluateExpression(expression.left, context) + evaluateExpression(expression.right, context);
        case '-':
            return evaluateExpression(expression.left, context) - evaluateExpression(expression.right, context);
        case '*':
            return evaluateExpression(expression.left, context) * evaluateExpression(expression.right, context);
        case '/':
            return evaluateExpression(expression.left, context) / evaluateExpression(expression.right, context);
        case '=':
            return evaluateExpression(expression.left, context) === evaluateExpression(expression.right, context);
        case '<>':
            return evaluateExpression(expression.left, context) !== evaluateExpression(expression.right, context);
        case '>':
            return evaluateExpression(expression.left, context) > evaluateExpression(expression.right, context);
        case '>=':
            return evaluateExpression(expression.left, context) >= evaluateExpression(expression.right, context);
        case '<':
            return evaluateExpression(expression.left, context) < evaluateExpression(expression.right, context);
        case '<=':
            return evaluateExpression(expression.left, context) <= evaluateExpression(expression.right, context);
        case 'and':
            return evaluateExpression(expression.left, context) && evaluateExpression(expression.right, context);
        case 'or':
            return evaluateExpression(expression.left, context) || evaluateExpression(expression.right, context);
        default:
            throw new Error(`Operator ${expression.operator} not implemented`);
    }
}
function evaluateCaseExpression(expression, context) {
    for (let index = 0; index < expression.conditions.length; index++) {
        const cond = expression.conditions[index];
        if (evaluateExpression(cond.when, context)) {
            return evaluateExpression(cond.then, context);
        }
    }
    if (expression.last) {
        return evaluateExpression(expression.last, context);
    }
    return false;
}
const invalidLeftSide = 'Invalid left side of IN expression';
function evaluateInExpression(expression, context) {
    const { left, right } = expression;
    const leftValue = evaluateExpression(left, context);
    const rightValues = evaluateExpression(right, context);
    const types = [left.type, right.type];
    if ((!types.includes('GroupExpression') && !types.includes('ValueExpression')) || !types.includes('IdentifierExpression')) {
        throw new Error('Invalid left or right side of IN expression');
    }
    if (right.type === 'IdentifierExpression') {
        if (rightValues == null) {
            throw new Error(`${right.name} is not defined`);
        }
        if (!Array.isArray(rightValues)) {
            throw new Error('Right side of IN expression must be an array');
        }
        return Array.isArray(leftValue) ? leftValue.every((v) => rightValues.indexOf(v) !== -1) : rightValues.indexOf(leftValue) !== -1;
    }
    if (left.type === 'IdentifierExpression') {
        if (leftValue == null) {
            throw new Error(`${left.name} is not defined`);
        }
        else {
            if (Array.isArray(leftValue)) {
                return leftValue.every((v) => rightValues.includes(v));
            }
            else if (typeof leftValue === 'object' && leftValue !== null) {
                throw new Error(invalidLeftSide);
            }
            else {
                return rightValues.includes(leftValue);
            }
        }
    }
}
function evaluateGroupExpression(expression, context) {
    const values = expression.values.map((v) => evaluateExpression(v, context));
    return values;
}
function evaluateExpression(expression, context) {
    switch (expression.type) {
        case 'IdentifierExpression':
            return context(expression.name);
        case 'ValueExpression':
            return expression.value;
        case 'FunctionCallExpression':
            return evaluateFunctionCall(expression.name, evaluateExpressions(expression.args, context));
        case 'BinaryExpression':
            return evaluateBinaryExpression(expression, context);
        case 'CaseExpression':
            return evaluateCaseExpression(expression, context);
        case 'InExpression':
            return evaluateInExpression(expression, context);
        case 'GroupExpression':
            return evaluateGroupExpression(expression, context);
        case 'NotExpression':
            return !evaluateExpression(expression.expression, context);
        default:
            throw new Error(`Invalid AST node${expression}`);
    }
}
function evaluate(expression, context) {
    const ast = (0, parser_1.parse)(expression);
    return evaluateExpression(ast, context);
}
exports.evaluate = evaluate;
function evaluateObject(expression, value) {
    return evaluate(expression, (name) => value[name]);
}
exports.evaluateObject = evaluateObject;