@narwhal/data-engine-core/dist/predicate_parser.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const tslib_1 = require("tslib");
const babel = require("@babel/standalone");
const t = require("@babel/types");
const data_engine_utils_1 = require("@narwhal/data-engine-utils");
const inversify_1 = require("inversify");
let PredicateParser = class PredicateParser {
    constructor() {
        this.cache = {};
        this.async_field_names = {};
    }
    convertPredicate(predicate, scope) {
        return this._cached_convertPredicate(predicate, scope);
    }
    _cached_convertPredicate(predicate, scope) {
        const key = JSON.stringify({ predicate });
        if (this.cache[key] === undefined) {
            this.cache[key] = this._convertPredicate(predicate, scope);
        }
        return this.cache[key];
    }
    _convertPredicate(predicate, scope = {}) {
        // Run the input predicate string through babel to get an abstract syntax tree.
        const transformed = babel.transform(predicate, { ast: true, babelrc: false, presets: [], plugins: [] });
        const statements = transformed.ast.program.body;
        let actual_program;
        if (statements.length > 1) {
            actual_program = t.blockStatement(transformed.ast.program.body);
        }
        else {
            actual_program = statements[0];
        }
        // Get the root of the ast, which happens to be a "file" object.
        if (!actual_program) {
            // We probably got a string literal parsed as a directive instead of an expression. Fix that...
            actual_program = t.expressionStatement(t.stringLiteral(predicate));
        }
        const new_statements = [];
        let isFunction = t.isFunction(actual_program);
        let isAsync = false;
        if (t.isFunctionDeclaration(actual_program)) {
            actual_program = t.expressionStatement(t.arrowFunctionExpression(actual_program.params, actual_program.body));
            isFunction = true;
        }
        if (t.isExpressionStatement(actual_program)) {
            if (t.isFunction(actual_program.expression)) {
                const funcExpression = actual_program.expression;
                isFunction = true;
                new_statements.push(t.returnStatement(funcExpression));
            }
            else {
                isFunction = false;
                // wrap literal statements in ()=>{return blabla}
                const return_statement = t.returnStatement(t.isStringLiteral(actual_program.expression) &&
                    (actual_program.expression.value.startsWith("'") || actual_program.expression.value.startsWith('"'))
                    ? t.stringLiteral(actual_program.expression.value.slice(1, -1))
                    : actual_program.expression);
                new_statements.push(return_statement);
            }
        }
        else if (statements.find(statement => t.isExpressionStatement(statement))) {
            const exprStatement = (statements.find(statement => t.isExpressionStatement(statement)));
            isFunction = t.isFunction(exprStatement.expression);
            if (exprStatement.expression.async) {
                isAsync = true;
            }
            const wrapped = [
                ...statements.filter(statement => !t.isExpressionStatement(statement)),
                t.returnStatement(exprStatement.expression),
            ];
            new_statements.push(...wrapped);
        }
        else {
            new_statements.push(...statements);
        }
        if (!isAsync) {
            if (predicate.startsWith("async")) {
                isAsync = true;
            }
        }
        const errorAgg = this.errorAggregator;
        const compiled = babel.transformFromAst(t.file(t.program(new_statements, [], "script"), [], []), undefined, { babelrc: false, presets: [], plugins: ["proposal-optional-chaining"] });
        // }
        const order = Object.keys(scope);
        // tslint:disable-next-line:ban-types
        let func;
        try {
            func = new Function(...order, compiled.code);
        }
        catch (e) {
            // Sentry.captureException(e, {extra: {predicate, code: compiled.code}});
            const err = new Error(`Error while parsing predicate: ${predicate}\n converted to: ${compiled.code}\n Eval error: ${e}`);
            errorAgg.handleError(e, { predicate, code: compiled.code, err });
            throw err;
        }
        let evald = function (...args) {
            try {
                let evalResult = func.apply(this, order.map(key => scope[key]));
                if (isFunction) {
                    evalResult = evalResult.apply(this, arguments);
                }
                return evalResult;
            }
            catch (e) {
                const err = new Error(`Error when executing predicate. Predicate contents: ${predicate}. Error: \n${e}`);
                err.stack = e.stack;
                err.name = e.name;
                errorAgg.handleError(e, { predicate, code: compiled.code, err });
                throw err;
            }
        };
        if (isAsync) {
            const old_evald = evald;
            evald = function (...args) {
                return tslib_1.__awaiter(this, void 0, void 0, function* () {
                    let done = false;
                    const keepAlive = () => setTimeout(() => { if (!done) {
                        keepAlive();
                    } }, 10);
                    keepAlive();
                    try {
                        return yield old_evald.apply(this, args);
                    }
                    finally {
                        done = true;
                    }
                });
            };
        }
        evald.isAsync = isAsync;
        return evald;
    }
};
tslib_1.__decorate([
    inversify_1.inject(data_engine_utils_1.UTIL_TYPES.TelemetryErrorAggregator),
    tslib_1.__metadata("design:type", data_engine_utils_1.TelemetryErrorReporterAggregator)
], PredicateParser.prototype, "errorAggregator", void 0);
PredicateParser = tslib_1.__decorate([
    inversify_1.injectable()
], PredicateParser);
exports.PredicateParser = PredicateParser;
//# sourceMappingURL=predicate_parser.js.map