@webda/cloudevents 3.0.0

package/lib/filters/sql.js

@@ -0,0 +1,752 @@
+import { ANTLRInputStream, CommonTokenStream } from "antlr4ts";
+import { AbstractParseTreeVisitor } from "antlr4ts/tree.js";
+import { FilterImplementation } from "./abstract.js";
+import { CESQLParserLexer } from "./sql/CESQLParserLexer.js";
+import { CESQLParserParser } from "./sql/CESQLParserParser.js";
+import { ExactFilterImplementation, PrefixFilterImplementation, SuffixFilterImplementation } from "./string.js";
+/**
+ * Functions implementation
+ */
+const functions = {
+    ABS: (...args) => {
+        if (args.length > 1) {
+            throw new Error("Too many arguments");
+        }
+        return Math.abs(args[0]);
+    },
+    LENGTH: (...args) => {
+        if (args.length > 1) {
+            throw new Error("Too many arguments");
+        }
+        return (args[0] || "").length;
+    },
+    CONCAT: (...args) => {
+        return args.join("");
+    },
+    CONCAT_WS: (...args) => {
+        let merger = args.shift();
+        return args.join(merger);
+    },
+    LOWER: (...args) => {
+        if (args.length > 1) {
+            throw new Error("Too many arguments");
+        }
+        return (args[0] || "").toLowerCase();
+    },
+    UPPER: (...args) => {
+        if (args.length > 1) {
+            throw new Error("Too many arguments");
+        }
+        return (args[0] || "").toUpperCase();
+    },
+    TRIM: (...args) => {
+        if (args.length > 1) {
+            throw new Error("Too many arguments");
+        }
+        return (args[0] || "").trim();
+    },
+    LEFT: (...args) => {
+        if (args.length !== 2) {
+            throw new Error("Wrong arguments count");
+        }
+        return (args[0] || "").substr(0, args[1]);
+    },
+    RIGHT: (...args) => {
+        if (args.length !== 2) {
+            throw new Error("Wrong arguments count");
+        }
+        args[0] ?? (args[0] = "");
+        return args[0].substr(args[0].length - args[1]);
+    },
+    SUBSTRING: (...args) => {
+        if (args.length > 3 || args.length < 2) {
+            throw new Error("Wrong arguments count");
+        }
+        return (args[0] || "").substring(args[1], args[2]);
+    },
+    INT: (...args) => {
+        if (args.length > 1) {
+            throw new Error("Too many arguments");
+        }
+        switch (typeof args[0]) {
+            case "number":
+                return args[0];
+            case "string":
+                let res = Number.parseInt(args[0]);
+                if (!Number.isNaN(res)) {
+                    return res;
+                }
+        }
+        return 0;
+    },
+    BOOL: (...args) => {
+        if (args.length > 1) {
+            throw new Error("Too many arguments");
+        }
+        if (typeof args[0] === "string") {
+            return args[0].toLowerCase() === "true";
+        }
+        else if (typeof args[0] === "boolean") {
+            return args[0];
+        }
+        return false;
+    },
+    STRING: (...args) => {
+        if (args.length > 1) {
+            throw new Error("Too many arguments");
+        }
+        if (typeof args[0] === "boolean") {
+            return args[0].toString().toUpperCase();
+        }
+        return args[0].toString();
+    },
+    IS_BOOL: (...args) => {
+        if (args.length > 1) {
+            throw new Error("Too many arguments");
+        }
+        return typeof args[0] === "boolean";
+    },
+    IS_INT: (...args) => {
+        if (args.length > 1) {
+            throw new Error("Too many arguments");
+        }
+        return typeof args[0] === "number";
+    }
+};
+/**
+ * Represent the query expression or subset
+ */
+export class Expression {
+    constructor() {
+        this.deps = [];
+    }
+    /**
+     * Resolve the expression if possible
+     *
+     * If the expression only contains static values then it can be resolved
+     * @returns
+     */
+    resolve() {
+        if (this.deps.length && this.deps.every(d => d instanceof ValueExpression)) {
+            return new ValueExpression(this.eval({}));
+        }
+        return this;
+    }
+}
+/**
+ * Represent an attribute expression
+ */
+export class AttributeExpression extends Expression {
+    constructor(attribute) {
+        super();
+        this.attribute = attribute;
+    }
+    /**
+     * @override
+     */
+    eval(target) {
+        return target[this.attribute];
+    }
+    /**
+     * @override
+     */
+    toString() {
+        return this.attribute;
+    }
+}
+/**
+ * Represent a function expression
+ */
+export class FunctionExpression extends Expression {
+    /**
+     *
+     * @param functionName to execute
+     * @param args to call with the function
+     */
+    constructor(functionName, ...args) {
+        super();
+        this.functionName = functionName;
+        if (!functions[functionName]) {
+            throw new Error(`Unknown function: '${functionName}'`);
+        }
+        this.deps.push(...args);
+        this.args = args;
+    }
+    /**
+     * @override
+     */
+    eval(target) {
+        return functions[this.functionName](...this.args.map(a => a.eval(target)));
+    }
+    /**
+     * @override
+     */
+    toString() {
+        return `${this.functionName}(${this.args.map(a => a.toString()).join(",")})`;
+    }
+}
+/**
+ * Represent a unary logic expression
+ */
+export class UnaryLogicExpression extends Expression {
+    /**
+     * Invert the result of the child expression
+     * @param child
+     */
+    constructor(child) {
+        super();
+        this.child = child;
+        this.deps.push(child);
+    }
+    /**
+     * @override
+     */
+    eval(target) {
+        return !this.deps[0].eval(target);
+    }
+    /**
+     * @override
+     */
+    toString() {
+        return `NOT ${this.deps[0].toString()}`;
+    }
+}
+/**
+ * Represent a unary numeric expression
+ */
+export class UnaryNumericExpression extends Expression {
+    /**
+     * Negative the result of the child expression
+     * @param child
+     */
+    constructor(child) {
+        super();
+        this.child = child;
+        this.deps.push(child);
+    }
+    /**
+     * @override
+     */
+    eval(target) {
+        return -1 * this.child.eval(target);
+    }
+    /**
+     * @override
+     */
+    toString() {
+        return `-${this.child.toString()}`;
+    }
+}
+/**
+ * Represent a LIKE expression
+ */
+export class LikeExpression extends Expression {
+    /**
+     *
+     * @param left part of the expression
+     * @param right part of the expression the regexp with % and _
+     * @param invert if NOT LIKE is used
+     */
+    constructor(left, right, invert) {
+        super();
+        this.left = left;
+        this.right = right;
+        this.invert = invert;
+        this.deps.push(left);
+        this.regexp = new RegExp(right
+            .substring(1, right.length - 1)
+            .replace(/([^\\])%/g, "$1.*")
+            .replace(/([^\\])_/g, "$1.?"));
+    }
+    /**
+     * @override
+     */
+    eval(target) {
+        let res = this.regexp.exec(this.left.eval(target)) !== null;
+        if (this.invert) {
+            return !res;
+        }
+        return res;
+    }
+    /**
+     * @override
+     */
+    toString() {
+        return `${this.left.toString()} ${this.invert ? "NOT " : ""}LIKE ${this.right}`;
+    }
+}
+/**
+ * Represent a EXISTS expression
+ */
+export class ExistsExpression extends Expression {
+    /**
+     *
+     * @param property to check
+     */
+    constructor(property) {
+        super();
+        this.property = property;
+    }
+    /**
+     * @override
+     */
+    eval(target) {
+        return target[this.property] !== undefined;
+    }
+    /**
+     * @override
+     */
+    toString() {
+        return `EXISTS ${this.property}`;
+    }
+}
+/**
+ * Represent a IN expression
+ */
+export class InExpression extends Expression {
+    /**
+     *
+     * @param left part of the expression
+     * @param right part of the expression
+     * @param invert if NOT IN
+     */
+    constructor(left, right, invert = false) {
+        super();
+        this.left = left;
+        this.right = right;
+        this.invert = invert;
+        this.deps.push(left, ...right);
+        this.staticContent = right.every(d => d instanceof ValueExpression) ? right.map(r => r.eval({})) : undefined;
+    }
+    /**
+     * @override
+     */
+    eval(target) {
+        let right = this.staticContent || this.right.map(r => r.eval(target));
+        if (this.invert) {
+            return !right.includes(this.left.eval(target));
+        }
+        return right.includes(this.left.eval(target));
+    }
+    /**
+     * @override
+     */
+    toString() {
+        return `${this.left.toString()} ${this.invert ? "NOT " : ""}IN (${this.right.map(r => r.toString()).join(",")})`;
+    }
+}
+/**
+ * Represent a binary multiplicative expression
+ */
+export class BinaryMultiplicativeExpression extends Expression {
+    /**
+     *
+     * @param left part of the expression
+     * @param right part of the expression
+     * @param operator
+     */
+    constructor(left, right, operator) {
+        super();
+        this.left = left;
+        this.right = right;
+        this.operator = operator;
+        this.deps.push(left, right);
+    }
+    /**
+     * @override
+     */
+    eval(target) {
+        switch (this.operator) {
+            case "*":
+                return this.left.eval(target) * this.right.eval(target);
+            case "/":
+                return this.left.eval(target) / this.right.eval(target);
+            case "%":
+                return this.left.eval(target) % this.right.eval(target);
+        }
+    }
+    /**
+     * @override
+     */
+    toString() {
+        return `${this.left.toString()} ${this.operator} ${this.right.toString()}`;
+    }
+}
+/**
+ * Represent a binary additive expression
+ */
+export class BinaryAdditiveExpression extends Expression {
+    /**
+     *
+     * @param left part of the expression
+     * @param right part of the expression
+     * @param operator
+     */
+    constructor(left, right, operator) {
+        super();
+        this.left = left;
+        this.right = right;
+        this.operator = operator;
+        this.deps.push(left, right);
+    }
+    /**
+     * @override
+     */
+    eval(target) {
+        return this.left.eval(target) + this.right.eval(target) * (this.operator === "+" ? 1 : -1);
+    }
+    /**
+     * @override
+     */
+    toString() {
+        return `${this.left.toString()} + ${this.right.toString()}`;
+    }
+}
+/**
+ * Represent a binary comparison expression
+ */
+export class BinaryComparisonExpression extends Expression {
+    /**
+     *
+     * @param left part of the expression
+     * @param right part of the expression
+     * @param operator to use
+     */
+    constructor(left, right, operator) {
+        super();
+        this.left = left;
+        this.right = right;
+        this.operator = operator;
+        this.deps.push(left, right);
+    }
+    /**
+     * @override
+     */
+    eval(target) {
+        switch (this.operator) {
+            case ">":
+                return this.left.eval(target) > this.right.eval(target);
+            case "<":
+                return this.left.eval(target) < this.right.eval(target);
+            case ">=":
+                return this.left.eval(target) >= this.right.eval(target);
+            case "<=":
+                return this.left.eval(target) <= this.right.eval(target);
+            case "!=":
+                return this.left.eval(target) != this.right.eval(target);
+            case "=":
+                return this.left.eval(target) == this.right.eval(target);
+        }
+    }
+    /**
+     * @override
+     */
+    toString() {
+        return `${this.left.toString()} ${this.operator} ${this.right.toString()}`;
+    }
+}
+/**
+ * Represent a binary logic expression
+ */
+export class BinaryLogicExpression extends Expression {
+    /**
+     *
+     * @param left part of the expression
+     * @param right part of the expression
+     * @param operator to use
+     */
+    constructor(left, right, operator) {
+        super();
+        this.left = left;
+        this.right = right;
+        this.operator = operator;
+        this.deps.push(left, right);
+    }
+    /**
+     * @override
+     */
+    eval(target) {
+        switch (this.operator) {
+            case "OR":
+                return this.left.eval(target) || this.right.eval(target);
+            case "XOR":
+                return this.left.eval(target) ? !this.right.eval(target) : this.right.eval(target);
+            case "AND":
+                return this.left.eval(target) && this.right.eval(target);
+        }
+    }
+    /**
+     * @override
+     */
+    toString() {
+        return `${this.left.toString()} ${this.operator} ${this.right.toString()}`;
+    }
+}
+/**
+ * Represent a value expression
+ */
+export class ValueExpression extends Expression {
+    /**
+     * Value represented by the expression
+     * @param value
+     */
+    constructor(value) {
+        super();
+        this.value = value;
+    }
+    /**
+     * @override
+     */
+    eval(target) {
+        return this.value;
+    }
+    /**
+     * @override
+     */
+    toString() {
+        if (typeof this.value === "string") {
+            return `"${this.value}"`;
+        }
+        else if (typeof this.value === "boolean") {
+            return this.value.toString().toUpperCase();
+        }
+        return this.value.toString();
+    }
+}
+/**
+ * Create Expression based on the parsed token
+ *
+ * Expression allow to optimize and split between Query and Filter
+ */
+export class CESQLExpressionBuilder extends AbstractParseTreeVisitor {
+    /**
+     * By default accepting it
+     * @returns
+     */
+    defaultResult() {
+        return new ValueExpression(true);
+    }
+    /**
+     * @override
+     */
+    visitCesql(ctx) {
+        return this.visit(ctx.children[0]);
+    }
+    /**
+     * @override
+     */
+    visitFunctionInvocationExpression(ctx) {
+        let args = [];
+        for (let i = 1; i < ctx.childCount; i += 2) {
+            args.push(...this.visit(ctx.children[i]));
+        }
+        return new FunctionExpression(ctx.children[0].text, ...args).resolve();
+    }
+    /**
+     * @override
+     */
+    visitUnaryLogicExpression(ctx) {
+        return new UnaryLogicExpression(this.getChildrenResults(ctx)[1]).resolve();
+    }
+    /**
+     * @override
+     */
+    visitUnaryNumericExpression(ctx) {
+        return new UnaryNumericExpression(this.getChildrenResults(ctx)[1]).resolve();
+    }
+    /**
+     * @override
+     */
+    visitLikeExpression(ctx) {
+        const [left, regexp] = [this.visit(ctx.children[0]), ctx.children[ctx.children.length - 1].text];
+        return new LikeExpression(left, regexp, ctx.childCount === 4).resolve();
+    }
+    /**
+     * @override
+     */
+    visitExistsExpression(ctx) {
+        let results = this.getChildrenResults(ctx);
+        return new ExistsExpression(results[1]).resolve();
+    }
+    /**
+     * @override
+     */
+    visitInExpression(ctx) {
+        let results = this.getChildrenResults(ctx);
+        if (ctx.childCount === 4) {
+            return new InExpression(results[0], results[3], true).resolve();
+        }
+        return new InExpression(results[0], results[2]).resolve();
+    }
+    /**
+     * @override
+     */
+    visitBinaryMultiplicativeExpression(ctx) {
+        let [left, op, right] = [this.visit(ctx.children[0]), ctx.children[1].text, this.visit(ctx.children[2])];
+        /* istanbul ignore next */
+        if (!["*", "/", "%"].includes(op)) {
+            throw new Error("Not implemented");
+        }
+        return new BinaryMultiplicativeExpression(left, right, op).resolve();
+    }
+    /**
+     * @override
+     */
+    visitBinaryAdditiveExpression(ctx) {
+        let [left, op, right] = [this.visit(ctx.children[0]), ctx.children[1].text, this.visit(ctx.children[2])];
+        /* istanbul ignore next */
+        if (!["+", "-"].includes(op)) {
+            throw new Error("Not implemented");
+        }
+        return new BinaryAdditiveExpression(left, right, op).resolve();
+    }
+    /**
+     * Retrieve the children results
+     * @param ctx
+     * @returns
+     */
+    getChildrenResults(ctx) {
+        return ctx.children.map((c) => this.visit(c));
+    }
+    /**
+     *
+     * @param ctx
+     * @returns
+     */
+    visitBinaryComparisonExpression(ctx) {
+        let [left, op, right] = [this.visit(ctx.children[0]), ctx.children[1].text, this.visit(ctx.children[2])];
+        /* istanbul ignore next */
+        if (!["<", ">", "<=", ">=", "!=", "="].includes(op)) {
+            throw new Error("Not implemented");
+        }
+        return new BinaryComparisonExpression(left, right, op).resolve();
+    }
+    /**
+     * @override
+     */
+    visitBinaryLogicExpression(ctx) {
+        let [left, op, right] = [this.visit(ctx.children[0]), ctx.children[1].text, this.visit(ctx.children[2])];
+        /* istanbul ignore next */
+        if (!["AND", "OR", "XOR"].includes(op)) {
+            throw new Error("Not implemented");
+        }
+        return new BinaryLogicExpression(left, right, op).resolve();
+    }
+    /**
+     * @override
+     */
+    visitSubExpression(ctx) {
+        return this.visit(ctx.children[1]);
+    }
+    /**
+     * @override
+     */
+    visitIdentifier(ctx) {
+        return new AttributeExpression(ctx.text);
+    }
+    /**
+     * @override
+     */
+    visitBooleanLiteral(ctx) {
+        return new ValueExpression(ctx.text === "TRUE");
+    }
+    /**
+     * @override
+     */
+    visitStringLiteral(ctx) {
+        // Remove quotes
+        return new ValueExpression(ctx.text.substr(1, ctx.text.length - 2));
+    }
+    /**
+     * @override
+     */
+    visitIntegerLiteral(ctx) {
+        return new ValueExpression(Number(ctx.text));
+    }
+    /**
+     * @override
+     */
+    visitFunctionParameterList(ctx) {
+        // Only take the odd part LBRACKET exp1 COMMA exp2 RBRACKET
+        return this.getChildrenResults(ctx).filter((_, i) => i % 2);
+    }
+    /**
+     * @override
+     */
+    visitSetExpression(ctx) {
+        // Only take the odd part LBRACKET exp1 COMMA exp2 RBRACKET
+        return this.getChildrenResults(ctx)
+            .filter((_, i) => i % 2)
+            .map(e => e.resolve());
+    }
+}
+/**
+ * SQL Filter implementation
+ */
+export class SqlFilterImplementation extends FilterImplementation {
+    /**
+     *
+     * @param definition {sql: "CESQL Expression"}
+     */
+    constructor(definition) {
+        super(definition);
+        this.lexer = new CESQLParserLexer(new ANTLRInputStream(definition.sql));
+        let tokenStream = new CommonTokenStream(this.lexer);
+        let parser = new CESQLParserParser(tokenStream);
+        // Parse the input, where `compilationUnit` is whatever entry point you defined
+        this.tree = parser.cesql();
+        this.query = new CESQLExpressionBuilder().visit(this.tree);
+        // Display query post optimization
+        // console.log("SQL", definition.sql, " => ", this.query.toString());
+    }
+    /**
+     * Check if a cloudevent match the filter
+     * @param event
+     * @returns
+     */
+    match(event) {
+        return this.query.eval(event);
+    }
+    /**
+     * Some filter can be optimized into a simpler form
+     *
+     * Samples:
+     *  LEFT(a, 3) = "foo" => prefix: {a: "foo"}
+     *  RIGHT(a, 3) = "foo" => suffix: {a: "foo"}
+     *  a = "foo" => exact: {a: "foo"}
+     *
+     * @returns
+     */
+    optimize() {
+        if (this.query instanceof BinaryComparisonExpression &&
+            this.query.operator === "=" &&
+            this.query.right instanceof ValueExpression) {
+            if (this.query.left instanceof AttributeExpression) {
+                return new ExactFilterImplementation({
+                    exact: {
+                        [this.query.left.attribute]: this.query.right.value
+                    }
+                });
+            }
+            else if (this.query.left instanceof FunctionExpression &&
+                this.query.left.args[0] instanceof AttributeExpression) {
+                if (this.query.left.functionName === "LEFT") {
+                    return new PrefixFilterImplementation({
+                        prefix: {
+                            [this.query.left.args[0].attribute]: this.query.right.value
+                        }
+                    });
+                }
+                else if (this.query.left.functionName === "RIGHT") {
+                    return new SuffixFilterImplementation({
+                        suffix: {
+                            [this.query.left.args[0].attribute]: this.query.right.value
+                        }
+                    });
+                }
+            }
+        }
+        return this;
+    }
+}
+//# sourceMappingURL=sql.js.map