@abdullah2993/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;
var parser_1 = require("./parser");
function evaluateExpressions(expressions, context) {
    return expressions.map(function (exp) { return 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 (var index = 0; index < expression.conditions.length; index++) {
        var cond = expression.conditions[index];
        if (evaluateExpression(cond.when, context)) {
            return evaluateExpression(cond.then, context);
        }
    }
    if (expression.last) {
        return evaluateExpression(expression.last, context);
    }
    return false;
}
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);
        default:
            throw new Error("Invalid AST node" + expression);
    }
}
function evaluate(expression, context) {
    var ast = parser_1.parse(expression);
    return evaluateExpression(ast, context);
}
exports.evaluate = evaluate;
function evaluateObject(expression, value) {
    return evaluate(expression, function (name) { return value[name]; });
}
exports.evaluateObject = evaluateObject;