@allurereport/aql 3.1.0

package/dist/model.d.ts

@@ -0,0 +1,192 @@
+/**
+ * Types for AQL (Allure Query Language) parsing
+ */
+export type AqlValueKind = "NULL" | "BOOLEAN" | "NUMBER" | "STRING" | "FUNCTION";
+/**
+ * Token types for AQL tokenizer.
+ */
+export type AqlTokenType = AqlOperations | AqlLogicalOperators | AqlValueKind | "IDENTIFIER" | "LPAREN" | "RPAREN" | "LBRACKET" | "RBRACKET" | "COMMA" | "EOL" | "WS";
+/**
+ * Token interface for AQL tokenizer.
+ */
+export interface AqlToken {
+    type: AqlTokenType;
+    /**
+     * Token value. Required only for tokens that carry data:
+     * - STRING: string value with quotes
+     * - NUMBER: numeric value
+     * - IDENTIFIER: identifier name
+     * - FUNCTION: function name with "()"
+     * - BOOLEAN: "true" or "false"
+     * Optional for operators, keywords, brackets, and EOL tokens.
+     */
+    value?: string;
+    position: number;
+}
+/**
+ * AQL operation types.
+ */
+export declare const AqlOperation: {
+    /** Greater than: > */
+    readonly GT: "GT";
+    /** Greater than or equal: >= */
+    readonly GE: "GE";
+    /** Less than: < */
+    readonly LT: "LT";
+    /** Less than or equal: <= */
+    readonly LE: "LE";
+    /** Equal: = or is */
+    readonly EQ: "EQ";
+    /** Not equal: != */
+    readonly NEQ: "NEQ";
+    /** Contains: ~= */
+    readonly CONTAINS: "CONTAINS";
+    /** In array: IN */
+    readonly IN: "IN";
+};
+export type AqlOperations = (typeof AqlOperation)[keyof typeof AqlOperation];
+export declare const AqlOperationAliases: {
+    readonly EQ: "=";
+    readonly NEQ: "!=";
+    readonly GT: ">";
+    readonly GE: ">=";
+    readonly LT: "<";
+    readonly LE: "<=";
+    readonly CONTAINS: "~=";
+};
+export type AqlOperationAlias = (typeof AqlOperationAliases)[keyof typeof AqlOperationAliases];
+/**
+ * AQL operation with string literal aliases for backward compatibility.
+ * Includes both enum values (e.g., AqlOperation.EQ) and string literals (e.g., "=").
+ */
+export type AqlOperationOrAlias = AqlOperations | AqlOperationAlias;
+/**
+ * AQL logical operators.
+ */
+export declare const AqlLogicalOperator: {
+    /** Logical AND */
+    readonly AND: "AND";
+    /** Logical OR */
+    readonly OR: "OR";
+    /** Logical NOT */
+    readonly NOT: "NOT";
+};
+export type AqlLogicalOperators = (typeof AqlLogicalOperator)[keyof typeof AqlLogicalOperator];
+export interface AqlValue {
+    value: string;
+    type: AqlValueKind;
+}
+export interface AqlAccessor {
+    identifier: string;
+    param?: {
+        value: string | number;
+        type: "string" | "number";
+    };
+}
+type AqlConditionOperator = Exclude<AqlOperations, "IN">;
+export interface AqlConditionExpression {
+    type: "condition";
+    left: AqlAccessor;
+    operator: AqlConditionOperator;
+    right: AqlValue;
+}
+type AqlArrayOperator = Extract<AqlOperations, "IN">;
+export interface AqlArrayConditionExpression {
+    type: "arrayCondition";
+    left: AqlAccessor;
+    operator: AqlArrayOperator;
+    right: AqlValue[];
+}
+type AqlBinaryOperator = Extract<AqlLogicalOperators, "AND" | "OR">;
+export interface AqlBinaryExpression {
+    type: "binary";
+    left: AqlExpression;
+    operator: AqlBinaryOperator;
+    right: AqlExpression;
+}
+export interface AqlNotExpression {
+    type: "not";
+    expression: AqlExpression;
+}
+export interface AqlParenExpression {
+    type: "paren";
+    expression: AqlExpression;
+}
+export interface AqlBooleanExpression {
+    type: "boolean";
+    value: boolean;
+}
+export type AqlExpression = AqlConditionExpression | AqlArrayConditionExpression | AqlBinaryExpression | AqlNotExpression | AqlParenExpression | AqlBooleanExpression;
+export interface AqlParseResult {
+    expression: AqlExpression | null;
+}
+/**
+ * Configuration for AQL parser to restrict available features.
+ *
+ * @example
+ * ```typescript
+ * import { AqlLogicalOperator, AqlOperation } from "./types";
+ *
+ * const config: AqlParserConfig = {
+ *   logicalOperators: [AqlLogicalOperator.AND, AqlLogicalOperator.OR],
+ *   operations: [AqlOperation.EQ, AqlOperation.NEQ],
+ *   identifiers: ["status", "name"],
+ *   valueTypes: ["STRING", "NUMBER"],
+ *   parentheses: true,
+ *   indexAccess: false,
+ * };
+ * ```
+ */
+export interface AqlParserConfig {
+    /**
+     * Available logical operators (AND, OR, NOT).
+     * If not specified, all operators are available.
+     *
+     * @default undefined (all operators available)
+     */
+    logicalOperators?: AqlLogicalOperators[];
+    /**
+     * Available operations (GT, GE, LT, LE, EQ, NEQ, CONTAINS, IN).
+     * If not specified, all operations are available.
+     *
+     * @default undefined (all operations available)
+     */
+    operations?: AqlOperations[];
+    /**
+     * Allowed identifiers
+     * Can be an array of allowed identifiers or a validation function.
+     * If not specified, all identifiers are allowed.
+     *
+     * @default undefined (all identifiers allowed)
+     *
+     * @example
+     * ```typescript
+     * // Array of allowed identifiers
+     * identifiers: ["status", "name"]
+     *
+     * // Validation function
+     * identifiers: (identifier) => identifier.startsWith("allowed_")
+     * ```
+     */
+    identifiers?: string[] | ((identifier: string) => boolean);
+    /**
+     * Available value types (NULL, BOOLEAN, NUMBER, STRING, FUNCTION).
+     * If not specified, all value types are available.
+     *
+     * @default undefined (all value types available)
+     */
+    valueTypes?: AqlValueKind[];
+    /**
+     * Whether parentheses are allowed for grouping expressions.
+     *
+     * @default true
+     */
+    parentheses?: boolean;
+    /**
+     * Whether array/object index access via brackets is allowed (e.g., `identifier[key]`).
+     *
+     * @default true
+     */
+    indexAccess?: boolean;
+}
+export {};

package/dist/model.js

@@ -0,0 +1,45 @@
+/**
+ * Types for AQL (Allure Query Language) parsing
+ */
+/**
+ * AQL operation types.
+ */
+export const AqlOperation = {
+    /** Greater than: > */
+    GT: "GT",
+    /** Greater than or equal: >= */
+    GE: "GE",
+    /** Less than: < */
+    LT: "LT",
+    /** Less than or equal: <= */
+    LE: "LE",
+    /** Equal: = or is */
+    EQ: "EQ",
+    /** Not equal: != */
+    NEQ: "NEQ",
+    /** Contains: ~= */
+    CONTAINS: "CONTAINS",
+    /** In array: IN */
+    IN: "IN",
+};
+export const AqlOperationAliases = {
+    [AqlOperation.EQ]: "=",
+    [AqlOperation.NEQ]: "!=",
+    [AqlOperation.GT]: ">",
+    [AqlOperation.GE]: ">=",
+    [AqlOperation.LT]: "<",
+    [AqlOperation.LE]: "<=",
+    [AqlOperation.CONTAINS]: "~=",
+};
+/**
+ * AQL logical operators.
+ */
+export const AqlLogicalOperator = {
+    /** Logical AND */
+    AND: "AND",
+    /** Logical OR */
+    OR: "OR",
+    /** Logical NOT */
+    NOT: "NOT",
+};
+//# sourceMappingURL=model.js.map

package/dist/model.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"model.js","sourceRoot":"","sources":["../src/model.ts"],"names":[],"mappings":"AAAA;;GAEG;AAsCH;;GAEG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG;IAC1B,sBAAsB;IACtB,EAAE,EAAE,IAAI;IACR,gCAAgC;IAChC,EAAE,EAAE,IAAI;IACR,mBAAmB;IACnB,EAAE,EAAE,IAAI;IACR,6BAA6B;IAC7B,EAAE,EAAE,IAAI;IACR,qBAAqB;IACrB,EAAE,EAAE,IAAI;IACR,oBAAoB;IACpB,GAAG,EAAE,KAAK;IACV,mBAAmB;IACnB,QAAQ,EAAE,UAAU;IACpB,mBAAmB;IACnB,EAAE,EAAE,IAAI;CACA,CAAC;AAIX,MAAM,CAAC,MAAM,mBAAmB,GAAG;IACjC,CAAC,YAAY,CAAC,EAAE,CAAC,EAAE,GAAG;IACtB,CAAC,YAAY,CAAC,GAAG,CAAC,EAAE,IAAI;IACxB,CAAC,YAAY,CAAC,EAAE,CAAC,EAAE,GAAG;IACtB,CAAC,YAAY,CAAC,EAAE,CAAC,EAAE,IAAI;IACvB,CAAC,YAAY,CAAC,EAAE,CAAC,EAAE,GAAG;IACtB,CAAC,YAAY,CAAC,EAAE,CAAC,EAAE,IAAI;IACvB,CAAC,YAAY,CAAC,QAAQ,CAAC,EAAE,IAAI;CACrB,CAAC;AAUX;;GAEG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG;IAChC,kBAAkB;IAClB,GAAG,EAAE,KAAK;IACV,iBAAiB;IACjB,EAAE,EAAE,IAAI;IACR,kBAAkB;IAClB,GAAG,EAAE,KAAK;CACF,CAAC"}

package/dist/parser/index.d.ts

@@ -0,0 +1,120 @@
+import type { AqlParseResult, AqlParserConfig } from "../model.js";
+/**
+ * Parser for AQL (Allure Query Language) expressions.
+ * Converts AQL strings into abstract syntax trees (AST).
+ */
+export declare class AqlParser {
+    private tokens;
+    private position;
+    private context;
+    private config;
+    /**
+     * Creates a new AQL parser instance.
+     *
+     * @param input - The AQL string to parse
+     * @param context - Optional context map for function values (e.g., `now()`, `currentUser()`)
+     * @param config - Optional parser configuration to restrict available features
+     * @throws {AqlParserError} If input is not a non-empty string
+     */
+    constructor(input: string, context?: Map<string, any> | undefined, config?: AqlParserConfig);
+    /**
+     * Parses the AQL string into an abstract syntax tree.
+     *
+     * @returns The parse result containing the expression or null if input is empty
+     * @throws {AqlParserError} If the AQL string is invalid or uses forbidden features
+     *
+     * @example
+     * ```typescript
+     * const parser = new AqlParser('status = "passed"');
+     * const result = parser.parse();
+     * console.log(result.expression); // AqlConditionExpression
+     * ```
+     */
+    parse(): AqlParseResult;
+    private parseOrExpression;
+    private parseAndExpression;
+    private parseNotExpression;
+    private parsePrimaryExpression;
+    private parseAccessor;
+    private parseOperation;
+    private parseValue;
+    private parseArray;
+    private match;
+    private check;
+    private expect;
+    private getErrorContext;
+    private advance;
+    private get reachedEOL();
+    private get current();
+    private get previous();
+    private unquoteString;
+    /**
+     * Validates that the identifier format is correct (only Latin letters and underscores).
+     *
+     * @param identifier - The identifier to validate
+     * @param position - The position in the input string where the identifier was found
+     * @throws {AqlParserError} If the identifier format is invalid
+     * @private
+     */
+    private validateIdentifierFormat;
+    /**
+     * Validates that the logical operator is allowed according to the configuration.
+     *
+     * @param operator - The logical operator to validate (AND, OR, NOT)
+     * @param position - The position in the input string where the operator was found
+     * @throws {AqlParserError} If the operator is not allowed
+     * @private
+     */
+    private validateLogicalOperator;
+    /**
+     * Validates that the operation is allowed according to the configuration.
+     *
+     * @param operation - The operation to validate (GT, GE, LT, LE, EQ, NEQ, CONTAINS, IN)
+     * @param position - The position in the input string where the operation was found
+     * @throws {AqlParserError} If the operation is not allowed
+     * @private
+     */
+    private validateOperation;
+    /**
+     * Validates that the identifier is allowed according to the configuration.
+     *
+     * @param identifier - The identifier to validate
+     * @param position - The position in the input string where the identifier was found
+     * @throws {AqlParserError} If the identifier is not allowed
+     * @private
+     */
+    private validateIdentifier;
+    /**
+     * Validates that the value type is allowed according to the configuration.
+     *
+     * @param valueType - The value type to validate (NULL, BOOLEAN, NUMBER, STRING, FUNCTION)
+     * @param position - The position in the input string where the value was found
+     * @throws {AqlParserError} If the value type is not allowed
+     * @private
+     */
+    private validateValueType;
+}
+/**
+ * Convenience function for parsing AQL string.
+ *
+ * @param aql - The AQL string to parse
+ * @param context - Optional context map or object for function values (e.g., `now()`, `currentUser()`)
+ * @param config - Optional parser configuration to restrict available features
+ * @returns The parse result containing the expression or null if input is empty
+ * @throws {AqlParserError} If the AQL string is invalid or uses forbidden features
+ *
+ * @example
+ * ```typescript
+ * // Basic usage
+ * const result = parseAql('status = "passed"');
+ *
+ * // With context
+ * const result = parseAql('createdDate >= now()', { "now()": Date.now() });
+ *
+ * // With configuration
+ * import { AqlOperation } from "./types";
+ * const config = { operations: [AqlOperation.EQ, AqlOperation.NEQ], identifiers: ["status"] };
+ * const result = parseAql('status = "passed"', undefined, config);
+ * ```
+ */
+export declare function parseAql(aql: string, context?: Map<string, any> | Record<string, any>, config?: AqlParserConfig): AqlParseResult;