@webda/cloudevents 3.0.0

package/lib/filters/sql.d.ts

@@ -0,0 +1,426 @@
+import { AbstractParseTreeVisitor } from "antlr4ts/tree.js";
+import { CloudEvent } from "cloudevents";
+import { Filter, FilterImplementation } from "./abstract.js";
+import { CESQLParserLexer } from "./sql/CESQLParserLexer.js";
+import { BinaryAdditiveExpressionContext, BinaryComparisonExpressionContext, BinaryLogicExpressionContext, BinaryMultiplicativeExpressionContext, BooleanLiteralContext, CesqlContext, ExistsExpressionContext, FunctionInvocationExpressionContext, FunctionParameterListContext, IdentifierContext, InExpressionContext, IntegerLiteralContext, LikeExpressionContext, SetExpressionContext, StringLiteralContext, SubExpressionContext, UnaryLogicExpressionContext, UnaryNumericExpressionContext } from "./sql/CESQLParserParser.js";
+import { CESQLParserVisitor } from "./sql/CESQLParserVisitor.js";
+/**
+ * Use of this MUST have a string value, representing a CloudEvents SQL Expression.
+ * The filter result MUST be true if the result value of the expression, coerced to boolean,
+ * equals to the TRUE boolean value, otherwise MUST be false if an error occurred while
+ * evaluating the expression or if the result value, coerced to boolean, equals to the FALSE
+ * boolean value.
+ *
+ * Implementations SHOULD reject subscriptions with invalid CloudEvents SQL expressions.
+ */
+export interface SqlFilter {
+    sql: string;
+}
+/**
+ * Function name defined by the specification
+ */
+type FunctionName = "ABS" | "LENGTH" | "CONCAT" | "CONCAT_WS" | "LOWER" | "UPPER" | "LEFT" | "RIGHT" | "TRIM" | "BOOL" | "INT" | "SUBSTRING" | "STRING" | "IS_BOOL" | "IS_INT";
+/**
+ * Functions implementation
+ */
+declare const functions: {
+    [key in FunctionName]: (...args: any[]) => any;
+};
+/**
+ * Represent the query expression or subset
+ */
+export declare abstract class Expression {
+    protected deps: Expression[];
+    constructor();
+    /**
+     * Evaluate the expression for the target object
+     * @param target to evaluate
+     */
+    abstract eval(target: any): any;
+    /**
+     * Return the representation of the expression
+     */
+    abstract toString(): string;
+    /**
+     * Resolve the expression if possible
+     *
+     * If the expression only contains static values then it can be resolved
+     * @returns
+     */
+    resolve(): Expression;
+}
+/**
+ * Represent an attribute expression
+ */
+export declare class AttributeExpression extends Expression {
+    readonly attribute: string;
+    constructor(attribute: string);
+    /**
+     * @override
+     */
+    eval(target: any): any;
+    /**
+     * @override
+     */
+    toString(): string;
+}
+/**
+ * Represent a function expression
+ */
+export declare class FunctionExpression extends Expression {
+    readonly functionName: keyof typeof functions;
+    readonly args: Expression[];
+    /**
+     *
+     * @param functionName to execute
+     * @param args to call with the function
+     */
+    constructor(functionName: keyof typeof functions, ...args: Expression[]);
+    /**
+     * @override
+     */
+    eval(target: any): any;
+    /**
+     * @override
+     */
+    toString(): string;
+}
+/**
+ * Represent a unary logic expression
+ */
+export declare class UnaryLogicExpression extends Expression {
+    readonly child: Expression;
+    /**
+     * Invert the result of the child expression
+     * @param child
+     */
+    constructor(child: Expression);
+    /**
+     * @override
+     */
+    eval(target: any): boolean;
+    /**
+     * @override
+     */
+    toString(): string;
+}
+/**
+ * Represent a unary numeric expression
+ */
+export declare class UnaryNumericExpression extends Expression {
+    readonly child: Expression;
+    /**
+     * Negative the result of the child expression
+     * @param child
+     */
+    constructor(child: Expression);
+    /**
+     * @override
+     */
+    eval(target: any): number;
+    /**
+     * @override
+     */
+    toString(): string;
+}
+/**
+ * Represent a LIKE expression
+ */
+export declare class LikeExpression extends Expression {
+    readonly left: Expression;
+    readonly right: string;
+    readonly invert: boolean;
+    regexp: RegExp;
+    /**
+     *
+     * @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: Expression, right: string, invert: boolean);
+    /**
+     * @override
+     */
+    eval(target: any): boolean;
+    /**
+     * @override
+     */
+    toString(): string;
+}
+/**
+ * Represent a EXISTS expression
+ */
+export declare class ExistsExpression extends Expression {
+    readonly property: string;
+    /**
+     *
+     * @param property to check
+     */
+    constructor(property: string);
+    /**
+     * @override
+     */
+    eval(target: any): boolean;
+    /**
+     * @override
+     */
+    toString(): string;
+}
+/**
+ * Represent a IN expression
+ */
+export declare class InExpression extends Expression {
+    readonly left: Expression;
+    readonly right: Expression[];
+    readonly invert: boolean;
+    staticContent: any[];
+    /**
+     *
+     * @param left part of the expression
+     * @param right part of the expression
+     * @param invert if NOT IN
+     */
+    constructor(left: Expression, right: Expression[], invert?: boolean);
+    /**
+     * @override
+     */
+    eval(target: any): boolean;
+    /**
+     * @override
+     */
+    toString(): string;
+}
+/**
+ * Represent a binary multiplicative expression
+ */
+export declare class BinaryMultiplicativeExpression extends Expression {
+    readonly left: Expression;
+    readonly right: Expression;
+    readonly operator: "*" | "/" | "%";
+    /**
+     *
+     * @param left part of the expression
+     * @param right part of the expression
+     * @param operator
+     */
+    constructor(left: Expression, right: Expression, operator: "*" | "/" | "%");
+    /**
+     * @override
+     */
+    eval(target: any): number;
+    /**
+     * @override
+     */
+    toString(): string;
+}
+/**
+ * Represent a binary additive expression
+ */
+export declare class BinaryAdditiveExpression extends Expression {
+    readonly left: Expression;
+    readonly right: Expression;
+    readonly operator: "+" | "-";
+    /**
+     *
+     * @param left part of the expression
+     * @param right part of the expression
+     * @param operator
+     */
+    constructor(left: Expression, right: Expression, operator: "+" | "-");
+    /**
+     * @override
+     */
+    eval(target: any): any;
+    /**
+     * @override
+     */
+    toString(): string;
+}
+/**
+ * Represent a binary comparison expression
+ */
+export declare class BinaryComparisonExpression extends Expression {
+    readonly left: Expression;
+    readonly right: Expression;
+    readonly operator: ">" | "<" | ">=" | "<=" | "!=" | "=";
+    /**
+     *
+     * @param left part of the expression
+     * @param right part of the expression
+     * @param operator to use
+     */
+    constructor(left: Expression, right: Expression, operator: ">" | "<" | ">=" | "<=" | "!=" | "=");
+    /**
+     * @override
+     */
+    eval(target: any): boolean;
+    /**
+     * @override
+     */
+    toString(): string;
+}
+/**
+ * Represent a binary logic expression
+ */
+export declare class BinaryLogicExpression extends Expression {
+    readonly left: Expression;
+    readonly right: Expression;
+    readonly operator: "AND" | "OR" | "XOR";
+    /**
+     *
+     * @param left part of the expression
+     * @param right part of the expression
+     * @param operator to use
+     */
+    constructor(left: Expression, right: Expression, operator: "AND" | "OR" | "XOR");
+    /**
+     * @override
+     */
+    eval(target: any): any;
+    /**
+     * @override
+     */
+    toString(): string;
+}
+/**
+ * Represent a value expression
+ */
+export declare class ValueExpression extends Expression {
+    readonly value: any;
+    /**
+     * Value represented by the expression
+     * @param value
+     */
+    constructor(value: any);
+    /**
+     * @override
+     */
+    eval(target: any): any;
+    /**
+     * @override
+     */
+    toString(): string;
+}
+/**
+ * Create Expression based on the parsed token
+ *
+ * Expression allow to optimize and split between Query and Filter
+ */
+export declare class CESQLExpressionBuilder extends AbstractParseTreeVisitor<Expression> implements CESQLParserVisitor<any> {
+    /**
+     * By default accepting it
+     * @returns
+     */
+    protected defaultResult(): ValueExpression;
+    /**
+     * @override
+     */
+    visitCesql(ctx: CesqlContext): Expression;
+    /**
+     * @override
+     */
+    visitFunctionInvocationExpression(ctx: FunctionInvocationExpressionContext): Expression;
+    /**
+     * @override
+     */
+    visitUnaryLogicExpression(ctx: UnaryLogicExpressionContext): Expression;
+    /**
+     * @override
+     */
+    visitUnaryNumericExpression(ctx: UnaryNumericExpressionContext): Expression;
+    /**
+     * @override
+     */
+    visitLikeExpression(ctx: LikeExpressionContext): Expression;
+    /**
+     * @override
+     */
+    visitExistsExpression(ctx: ExistsExpressionContext): Expression;
+    /**
+     * @override
+     */
+    visitInExpression(ctx: InExpressionContext): Expression;
+    /**
+     * @override
+     */
+    visitBinaryMultiplicativeExpression(ctx: BinaryMultiplicativeExpressionContext): Expression;
+    /**
+     * @override
+     */
+    visitBinaryAdditiveExpression(ctx: BinaryAdditiveExpressionContext): Expression;
+    /**
+     * Retrieve the children results
+     * @param ctx
+     * @returns
+     */
+    getChildrenResults(ctx: any): any;
+    /**
+     *
+     * @param ctx
+     * @returns
+     */
+    visitBinaryComparisonExpression(ctx: BinaryComparisonExpressionContext): Expression;
+    /**
+     * @override
+     */
+    visitBinaryLogicExpression(ctx: BinaryLogicExpressionContext): Expression;
+    /**
+     * @override
+     */
+    visitSubExpression(ctx: SubExpressionContext): Expression;
+    /**
+     * @override
+     */
+    visitIdentifier(ctx: IdentifierContext): any;
+    /**
+     * @override
+     */
+    visitBooleanLiteral(ctx: BooleanLiteralContext): Expression;
+    /**
+     * @override
+     */
+    visitStringLiteral(ctx: StringLiteralContext): Expression;
+    /**
+     * @override
+     */
+    visitIntegerLiteral(ctx: IntegerLiteralContext): Expression;
+    /**
+     * @override
+     */
+    visitFunctionParameterList(ctx: FunctionParameterListContext): Expression[];
+    /**
+     * @override
+     */
+    visitSetExpression(ctx: SetExpressionContext): any[];
+}
+/**
+ * SQL Filter implementation
+ */
+export declare class SqlFilterImplementation extends FilterImplementation<SqlFilter> {
+    lexer: CESQLParserLexer;
+    tree: any;
+    query: Expression;
+    /**
+     *
+     * @param definition {sql: "CESQL Expression"}
+     */
+    constructor(definition: SqlFilter);
+    /**
+     * Check if a cloudevent match the filter
+     * @param event
+     * @returns
+     */
+    match(event: CloudEvent): boolean;
+    /**
+     * 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(): FilterImplementation<Filter>;
+}
+export {};