flowquery 1.0.46 → 1.0.47

package/src/parsing/base_parser.ts

@@ -1,98 +0,0 @@
-import Token from "../tokenization/token";
-import Tokenizer from "../tokenization/tokenizer";
-
-/**
- * Base class for parsers providing common token manipulation functionality.
- *
- * This class handles tokenization and provides utility methods for navigating
- * through tokens, peeking ahead, and checking token sequences.
- */
-class BaseParser {
-    private tokens: Token[] = <Token[]>[];
-    protected tokenIndex: number = 0;
-
-    constructor(tokens: Token[] | null = null) {
-        if (tokens !== null) {
-            this.tokens = tokens;
-        }
-    }
-
-    /**
-     * Tokenizes a statement and initializes the token array.
-     *
-     * @param statement - The input statement to tokenize
-     */
-    protected tokenize(statement: string): void {
-        this.tokens = new Tokenizer(statement).tokenize();
-        this.tokenIndex = 0;
-    }
-
-    /**
-     * Advances to the next token in the sequence.
-     */
-    protected setNextToken(): void {
-        this.tokenIndex++;
-    }
-
-    /**
-     * Peeks at the next token without advancing the current position.
-     *
-     * @returns The next token, or null if at the end of the token stream
-     */
-    protected peek(): Token | null {
-        if (this.tokenIndex + 1 >= this.tokens.length) {
-            return null;
-        }
-        return this.tokens[this.tokenIndex + 1];
-    }
-
-    /**
-     * Checks if a sequence of tokens appears ahead in the token stream.
-     *
-     * @param tokens - The sequence of tokens to look for
-     * @param skipWhitespaceAndComments - Whether to skip whitespace and comments when matching
-     * @returns True if the token sequence is found ahead, false otherwise
-     */
-    protected ahead(tokens: Token[], skipWhitespaceAndComments: boolean = true): boolean {
-        let j = 0;
-        for (let i = this.tokenIndex; i < this.tokens.length; i++) {
-            if (skipWhitespaceAndComments && this.tokens[i].isWhitespaceOrComment()) {
-                continue;
-            }
-            if (!this.tokens[i].equals(tokens[j])) {
-                return false;
-            }
-            j++;
-            if (j === tokens.length) {
-                break;
-            }
-        }
-        return j === tokens.length;
-    }
-
-    /**
-     * Gets the current token.
-     *
-     * @returns The current token, or EOF if at the end
-     */
-    protected get token(): Token {
-        if (this.tokenIndex >= this.tokens.length) {
-            return Token.EOF;
-        }
-        return this.tokens[this.tokenIndex];
-    }
-
-    /**
-     * Gets the previous token.
-     *
-     * @returns The previous token, or EOF if at the beginning
-     */
-    protected get previousToken(): Token {
-        if (this.tokenIndex - 1 < 0) {
-            return Token.EOF;
-        }
-        return this.tokens[this.tokenIndex - 1];
-    }
-}
-
-export default BaseParser;

package/src/parsing/components/csv.ts

@@ -1,9 +0,0 @@
-import ASTNode from "../ast_node";
-
-class CSV extends ASTNode {
-  constructor() {
-    super();
-  }
-}
-
-export default CSV;

package/src/parsing/components/from.ts

@@ -1,12 +0,0 @@
-import ASTNode from "../ast_node";
-
-class From extends ASTNode {
-  constructor() {
-    super()
-  }
-  public value(): string {
-    return this.children[0].value();
-  }
-}
-
-export default From;

package/src/parsing/components/headers.ts

@@ -1,12 +0,0 @@
-import ASTNode from "../ast_node";
-
-class Headers extends ASTNode {
-  constructor() {
-    super()
-  }
-  public value(): object {
-    return this.firstChild().value() as object || {};
-  }
-}
-
-export default Headers;

package/src/parsing/components/json.ts

@@ -1,9 +0,0 @@
-import ASTNode from "../ast_node";
-
-class JSON extends ASTNode {
-  constructor() {
-    super();
-  }
-}
-
-export default JSON;

package/src/parsing/components/null.ts

@@ -1,9 +0,0 @@
-import ASTNode from "../ast_node";
-
-class Null extends ASTNode {
-    constructor() {
-        super();
-    }
-}
-
-export default Null;

package/src/parsing/components/post.ts

@@ -1,9 +0,0 @@
-import ASTNode from "../ast_node";
-
-class Post extends ASTNode {
-    constructor() {
-        super()
-    }
-}
-
-export default Post;

package/src/parsing/components/text.ts

@@ -1,9 +0,0 @@
-import ASTNode from "../ast_node";
-
-class Text extends ASTNode {
-  constructor() {
-    super();
-  }
-}
-
-export default Text;

package/src/parsing/context.ts

@@ -1,54 +0,0 @@
-import ASTNode from "./ast_node";
-
-/**
- * Maintains a stack of AST nodes to track parsing context.
- *
- * Used during parsing to maintain the current context and check for specific node types
- * in the parsing hierarchy, which helps with context-sensitive parsing decisions.
- *
- * @example
- * ```typescript
- * const context = new Context();
- * context.push(node);
- * const hasReturn = context.containsType(Return);
- * ```
- */
-class Context {
-    private nodes: ASTNode[] = [];
-
-    /**
-     * Pushes a node onto the context stack.
-     *
-     * @param node - The AST node to push
-     */
-    public push(node: ASTNode): void {
-        this.nodes.push(node);
-    }
-
-    /**
-     * Pops the top node from the context stack.
-     *
-     * @returns The popped node, or undefined if the stack is empty
-     */
-    public pop(): ASTNode | undefined {
-        return this.nodes.pop();
-    }
-
-    /**
-     * Checks if the nodes stack contains a node of the specified type.
-     *
-     * @param type - The constructor of the node type to search for
-     * @returns True if a node of the specified type is found in the stack, false otherwise
-     */
-    public containsType(type: new (...args: any[]) => ASTNode): boolean {
-        return this.nodes.some((v) => v instanceof type);
-    }
-
-    public clone(): Context {
-        const newContext = new Context();
-        newContext.nodes = [...this.nodes];
-        return newContext;
-    }
-}
-
-export default Context;

package/src/parsing/data_structures/associative_array.ts

@@ -1,43 +0,0 @@
-import ASTNode from "../ast_node";
-import KeyValuePair from "./key_value_pair";
-
-/**
- * Represents an associative array (object/dictionary) in the AST.
- * 
- * Associative arrays map string keys to values, similar to JSON objects.
- * 
- * @example
- * ```typescript
- * // For { name: "Alice", age: 30 }
- * const obj = new AssociativeArray();
- * obj.addKeyValue(new KeyValuePair("name", nameExpr));
- * obj.addKeyValue(new KeyValuePair("age", ageExpr));
- * ```
- */
-class AssociativeArray extends ASTNode {
-    /**
-     * Adds a key-value pair to the associative array.
-     * 
-     * @param keyValuePair - The key-value pair to add
-     */
-    public addKeyValue(keyValuePair: KeyValuePair): void {
-        this.addChild(keyValuePair);
-    }
-
-    public toString(): string {
-        return 'AssociativeArray';
-    }
-    private *_value(): Iterable<Record<PropertyKey, any>> {
-        for(const child of this.children) {
-            const key_value = child as KeyValuePair;
-            yield {
-                [key_value.key]: key_value._value
-            };
-        }
-    }
-    public value(): Record<string, any> {
-        return Object.assign({}, ...this._value());
-    }
-}
-
-export default AssociativeArray;

package/src/parsing/data_structures/json_array.ts

@@ -1,31 +0,0 @@
-import ASTNode from "../ast_node";
-
-/**
- * Represents a JSON array in the AST.
- * 
- * JSON arrays are ordered collections of values.
- * 
- * @example
- * ```typescript
- * // For [1, 2, 3]
- * const arr = new JSONArray();
- * arr.addValue(new Number("1"));
- * arr.addValue(new Number("2"));
- * arr.addValue(new Number("3"));
- * ```
- */
-class JSONArray extends ASTNode {
-    /**
-     * Adds a value to the array.
-     * 
-     * @param value - The AST node representing the value to add
-     */
-    public addValue(value: ASTNode): void {
-        this.addChild(value);
-    }
-    public value(): any[] {
-        return this.children.map(child => child.value());
-    }
-}
-
-export default JSONArray;

package/src/parsing/data_structures/key_value_pair.ts

@@ -1,37 +0,0 @@
-import ASTNode from "../ast_node";
-import String from "../expressions/string";
-
-/**
- * Represents a key-value pair in an associative array.
- * 
- * Used to build object literals in FlowQuery.
- * 
- * @example
- * ```typescript
- * const kvp = new KeyValuePair("name", new String("Alice"));
- * ```
- */
-class KeyValuePair extends ASTNode {
-    /**
-     * Creates a new key-value pair.
-     * 
-     * @param key - The key string
-     * @param value - The AST node representing the value
-     */
-    constructor(key: string, value: ASTNode) {
-        super();
-        this.addChild(new String(key));
-        this.addChild(value);
-    }
-    public get key(): string {
-        return this.children[0].value();
-    }
-    public get _value(): any {
-        return this.children[1].value();
-    }
-    public toString(): string {
-        return `KeyValuePair`;
-    }
-}
-
-export default KeyValuePair;

package/src/parsing/data_structures/lookup.ts

@@ -1,44 +0,0 @@
-import ASTNode from "../ast_node";
-
-/**
- * Represents a lookup operation (array/object indexing) in the AST.
- *
- * Lookups access elements from arrays or properties from objects using an index or key.
- *
- * @example
- * ```typescript
- * // For array[0] or obj.property or obj["key"]
- * const lookup = new Lookup();
- * lookup.variable = arrayOrObjNode;
- * lookup.index = indexNode;
- * ```
- */
-class Lookup extends ASTNode {
-    constructor() {
-        super();
-    }
-    public set index(index: ASTNode) {
-        this.addChild(index);
-    }
-    public get index(): ASTNode {
-        return this.children[0];
-    }
-    public set variable(variable: ASTNode) {
-        this.addChild(variable);
-    }
-    public get variable(): ASTNode {
-        return this.children[1];
-    }
-    public isOperand(): boolean {
-        return true;
-    }
-    public value(): any {
-        const obj = this.variable.value();
-        if (obj === null || obj === undefined) {
-            return null;
-        }
-        return obj[this.index.value()];
-    }
-}
-
-export default Lookup;

package/src/parsing/data_structures/range_lookup.ts

@@ -1,36 +0,0 @@
-import ASTNode from "../ast_node";
-
-class RangeLookup extends ASTNode {
-    constructor() {
-        super();
-    }
-    public set from(from: ASTNode) {
-        this.addChild(from);
-    }
-    public get from(): ASTNode {
-        return this.children[0];
-    }
-    public set to(to: ASTNode) {
-        this.addChild(to);
-    }
-    public get to(): ASTNode {
-        return this.children[1];
-    }
-    public set variable(variable: ASTNode) {
-        this.addChild(variable);
-    }
-    public get variable(): ASTNode {
-        return this.children[2];
-    }
-    public isOperand(): boolean {
-        return true;
-    }
-    public value(): any {
-        const array: any[] = this.variable.value();
-        const from = this.from.value() || 0;
-        const to = this.to.value() || array.length;
-        return this.variable.value().slice(from, to);
-    }
-}
-
-export default RangeLookup;

package/src/parsing/expressions/boolean.ts

@@ -1,21 +0,0 @@
-import ASTNode from "../ast_node";
-
-class Boolean extends ASTNode {
-    private _value: boolean;
-    constructor(value: string) {
-        super();
-        const _value = value.toUpperCase();
-        if (_value === "TRUE") {
-            this._value = true;
-        } else if (_value === "FALSE") {
-            this._value = false;
-        } else {
-            throw new Error(`Invalid boolean value: ${value}`);
-        }
-    }
-    public value(): boolean {
-        return this._value;
-    }
-}
-
-export default Boolean;

package/src/parsing/expressions/expression.ts

@@ -1,150 +0,0 @@
-import PatternExpression from "../../graph/pattern_expression";
-import ASTNode from "../ast_node";
-import AggregateFunction from "../functions/aggregate_function";
-import Reference from "./reference";
-
-/**
- * Represents an expression in the FlowQuery AST.
- *
- * Expressions are built using the Shunting Yard algorithm to handle operator
- * precedence and associativity. They can contain operands (numbers, strings, identifiers)
- * and operators (arithmetic, logical, comparison).
- *
- * @example
- * ```typescript
- * const expr = new Expression();
- * expr.addNode(numberNode);
- * expr.addNode(plusOperator);
- * expr.addNode(anotherNumberNode);
- * expr.finish();
- * ```
- */
-class Expression extends ASTNode {
-    private operators: ASTNode[] = <ASTNode[]>[];
-    private output: ASTNode[] = <ASTNode[]>[];
-    private _alias: string | null = null;
-    private _overridden: any | null = null;
-    private _reducers: AggregateFunction[] | null = null;
-    private _patterns: PatternExpression[] | null = null;
-
-    /**
-     * Adds a node (operand or operator) to the expression.
-     *
-     * Uses the Shunting Yard algorithm to maintain correct operator precedence.
-     *
-     * @param node - The AST node to add (operand or operator)
-     */
-    public addNode(node: ASTNode): void {
-        /* Implements the Shunting Yard algorithm */
-        if (node.isOperand()) {
-            this.output.push(node);
-        } else if (node.isOperator()) {
-            const operator1: ASTNode = node;
-            while (this.operators.length > 0) {
-                let operator2 = this.operators[this.operators.length - 1];
-                if (
-                    operator2.precedence > operator1.precedence ||
-                    (operator2.precedence === operator1.precedence && operator1.leftAssociative)
-                ) {
-                    this.output.push(operator2);
-                    this.operators.pop();
-                } else {
-                    break;
-                }
-            }
-            this.operators.push(operator1);
-        }
-    }
-
-    /**
-     * Finalizes the expression by converting it to a tree structure.
-     *
-     * Should be called after all nodes have been added.
-     */
-    public finish(): void {
-        let last: ASTNode | undefined;
-        while ((last = this.operators.pop())) {
-            this.output.push(last);
-        }
-        this.addChild(this.toTree());
-    }
-
-    private toTree(): ASTNode {
-        const node = this.output.pop() || new ASTNode();
-        if (node.isOperator()) {
-            const rhs = this.toTree();
-            const lhs = this.toTree();
-            node.addChild(lhs);
-            node.addChild(rhs);
-        }
-        return node;
-    }
-
-    public nodesAdded(): boolean {
-        return this.operators.length > 0 || this.output.length > 0;
-    }
-
-    public value(): any {
-        if (this._overridden !== null) {
-            return this._overridden;
-        }
-        if (this.childCount() !== 1) {
-            throw new Error("Expected one child");
-        }
-        return this.children[0].value();
-    }
-
-    public setAlias(alias: string): void {
-        this._alias = alias;
-    }
-
-    public set alias(alias: string) {
-        this._alias = alias;
-    }
-
-    public get alias(): string | null {
-        if (this.firstChild() instanceof Reference && this._alias === null) {
-            return (<Reference>this.firstChild()).identifier;
-        }
-        return this._alias;
-    }
-
-    public toString(): string {
-        if (this._alias !== null) {
-            return `Expression (${this._alias})`;
-        } else {
-            return "Expression";
-        }
-    }
-    public reducers(): AggregateFunction[] {
-        if (this._reducers === null) {
-            this._reducers = [...this._extract(this, AggregateFunction)];
-        }
-        return this._reducers;
-    }
-    public patterns(): PatternExpression[] {
-        if (this._patterns === null) {
-            this._patterns = [...this._extract(this, PatternExpression)];
-        }
-        return this._patterns;
-    }
-    private *_extract(node: ASTNode = this, of_type: any): Generator<any> {
-        if (node instanceof of_type) {
-            yield node;
-        }
-        for (const child of node.getChildren()) {
-            yield* this._extract(child, of_type);
-        }
-    }
-    public mappable(): boolean {
-        return this.reducers().length === 0;
-    }
-    public has_reducers(): boolean {
-        return this.reducers().length > 0;
-    }
-    public set overridden(value: any) {
-        this._overridden = value;
-    }
-}
-
-export default Expression;

package/src/parsing/expressions/expression_map.ts

@@ -1,22 +0,0 @@
-import Expression from "./expression";
-
-class ExpressionMap {
-    private _map: Map<string, Expression> = new Map();
-    public get(alias: string): Expression | undefined {
-        return this._map.get(alias);
-    }
-    public has(alias: string): boolean {
-        return this._map.has(alias);
-    }
-    public set map(expressions: Expression[]) {
-        this._map.clear();
-        for (const expr of expressions) {
-            if (expr.alias == undefined) {
-                continue;
-            }
-            this._map.set(expr.alias, expr);
-        }
-    }
-}
-
-export default ExpressionMap;

package/src/parsing/expressions/f_string.ts

@@ -1,26 +0,0 @@
-import ASTNode from "../ast_node";
-import Expression from "./expression";
-
-/**
- * Represents a formatted string (f-string) in the AST.
- * 
- * F-strings allow embedding expressions within string literals.
- * Child nodes represent the parts of the f-string (literal strings and expressions).
- * 
- * @example
- * ```typescript
- * // For f"Hello {name}!"
- * const fstr = new FString();
- * fstr.addChild(new String("Hello "));
- * fstr.addChild(nameExpression);
- * fstr.addChild(new String("!"));
- * ```
- */
-class FString extends ASTNode {
-    public value(): string {
-        const parts: Expression[] = this.getChildren() as Array<Expression>;
-        return parts.map((part) => part.value()).join("");
-    }
-}
-
-export default FString;

package/src/parsing/expressions/identifier.ts

@@ -1,22 +0,0 @@
-import String from "./string";
-
-/**
- * Represents an identifier in the AST.
- * 
- * Identifiers are used for variable names, property names, and similar constructs.
- * 
- * @example
- * ```typescript
- * const id = new Identifier("myVariable");
- * ```
- */
-class Identifier extends String {
-    public toString(): string {
-        return `Identifier (${this._value})`;
-    }
-    public value(): any {
-        return super.value();
-    }
-}
-
-export default Identifier;