Class ExpressionRuntime

packages/expr/src/runtime.ts:24–225

import { formatExpressionResult } from './utils';

export class ExpressionRuntime {
    #parserOptions: AcornOptions;
    #autocompleter: AutoComplete;
    #logger: Logger;

    constructor(logger: Logger = console) {
        this.#parserOptions = {
            ecmaVersion: 'latest',
            sourceType: 'script',
            allowHashBang: false,
            locations: true,
        };
        this.#autocompleter = new AutoComplete(this, logger);
        this.#logger = logger;
    }

    /**
     * Evaluates an expression based on the given inputs/context.
     */
    public evaluate(expr: string, inputs: object): unknown {
        try {
            const parsed = this.parse(expr);

            if (parsed.invalidNodes.length > 0) {
                throw new ExpressionError('Invalid nodes found when parsing');
            }

            return evaluate.sync<Expression>(parsed.result, inputs, {
                functions: true,
                withMembers: true,
                generate: escodegen.generate,
            });
        } catch (error) {
            throw error instanceof Error
                ? new ExpressionError(error.message)
                : new ExpressionError('Unexpected error');
        }
    }

    /**
     * Evaluates an expression safely by returning the error instead of throwing when invalid.
     */
    public safeEvaluate(
        expr: string,
        inputs: object
    ): { value: unknown; error?: undefined } | { value?: undefined; error: ExpressionError } {
        try {
            const value = this.evaluate(expr, inputs);
            return {
                value,
            };
        } catch (error) {
            this.#logger.error(`Error while evaluating expression ${expr}`, error);

            if (error instanceof ExpressionError) {
                return {
                    value: undefined,
                    error,