flowquery 1.0.46 → 1.0.48

package/src/parsing/expressions/number.ts

@@ -1,40 +0,0 @@
-import ASTNode from "../ast_node";
-
-/**
- * Represents a numeric literal in the AST.
- * 
- * Parses string representations of numbers into integer or float values.
- * 
- * @example
- * ```typescript
- * const num = new Number("42");
- * console.log(num.value()); // 42
- * ```
- */
-class Number extends ASTNode {
-    private _value: number;
-
-    /**
-     * Creates a new Number node by parsing the string value.
-     * 
-     * @param value - The string representation of the number
-     */
-    constructor(value: string) {
-        super();
-        if(value.indexOf('.') !== -1) {
-            this._value = parseFloat(value);
-        } else {
-            this._value = parseInt(value);
-        }
-    }
-
-    public value(): number {
-        return this._value;
-    }
-
-    protected toString(): string {
-        return `${this.constructor.name} (${this._value})`;
-    }
-}
-
-export default Number;

package/src/parsing/expressions/operator.ts

@@ -1,354 +0,0 @@
-import ASTNode from "../ast_node";
-
-function deepEquals(a: any, b: any): boolean {
-    if (a === b) return true;
-    if (a === null || b === null || a === undefined || b === undefined) return false;
-    if (typeof a !== typeof b) return false;
-    if (typeof a !== "object") return false;
-    if (Array.isArray(a) !== Array.isArray(b)) return false;
-    if (Array.isArray(a)) {
-        if (a.length !== b.length) return false;
-        for (let i = 0; i < a.length; i++) {
-            if (!deepEquals(a[i], b[i])) return false;
-        }
-        return true;
-    }
-    const keysA = Object.keys(a);
-    const keysB = Object.keys(b);
-    if (keysA.length !== keysB.length) return false;
-    for (const key of keysA) {
-        if (!Object.prototype.hasOwnProperty.call(b, key)) return false;
-        if (!deepEquals(a[key], b[key])) return false;
-    }
-    return true;
-}
-
-abstract class Operator extends ASTNode {
-    private _precedence: number = 0;
-    private _leftAssociative: boolean = true;
-
-    constructor(precedence: number, leftAssociative: boolean) {
-        super();
-        this._precedence = precedence;
-        this._leftAssociative = leftAssociative;
-    }
-
-    public isOperator(): boolean {
-        return true;
-    }
-
-    public get precedence(): number {
-        return this._precedence;
-    }
-    public get leftAssociative(): boolean {
-        return this._leftAssociative;
-    }
-    public abstract value(): any;
-    public get lhs(): ASTNode {
-        return this.getChildren()[0];
-    }
-    public get rhs(): ASTNode {
-        return this.getChildren()[1];
-    }
-}
-
-class Add extends Operator {
-    constructor() {
-        super(1, true);
-    }
-    public value(): any {
-        const l = this.lhs.value();
-        const r = this.rhs.value();
-        if (Array.isArray(l) && Array.isArray(r)) {
-            return [...l, ...r];
-        }
-        return l + r;
-    }
-}
-
-class Subtract extends Operator {
-    constructor() {
-        super(1, true);
-    }
-    public value(): number {
-        return this.lhs.value() - this.rhs.value();
-    }
-}
-
-class Multiply extends Operator {
-    constructor() {
-        super(2, true);
-    }
-    public value(): number {
-        return this.lhs.value() * this.rhs.value();
-    }
-}
-
-class Divide extends Operator {
-    constructor() {
-        super(2, true);
-    }
-    public value(): number {
-        return this.lhs.value() / this.rhs.value();
-    }
-}
-
-class Modulo extends Operator {
-    constructor() {
-        super(2, true);
-    }
-    public value(): number {
-        return this.lhs.value() % this.rhs.value();
-    }
-}
-
-class Power extends Operator {
-    constructor() {
-        super(3, false);
-    }
-    public value(): number {
-        return Math.pow(this.lhs.value(), this.rhs.value());
-    }
-}
-
-class Equals extends Operator {
-    constructor() {
-        super(0, true);
-    }
-    public value(): number {
-        return deepEquals(this.lhs.value(), this.rhs.value()) ? 1 : 0;
-    }
-}
-
-class NotEquals extends Operator {
-    constructor() {
-        super(0, true);
-    }
-    public value(): number {
-        return !deepEquals(this.lhs.value(), this.rhs.value()) ? 1 : 0;
-    }
-}
-
-class GreaterThan extends Operator {
-    constructor() {
-        super(0, true);
-    }
-    public value(): number {
-        return this.lhs.value() > this.rhs.value() ? 1 : 0;
-    }
-}
-
-class LessThan extends Operator {
-    constructor() {
-        super(0, true);
-    }
-    public value(): number {
-        return this.lhs.value() < this.rhs.value() ? 1 : 0;
-    }
-}
-
-class GreaterThanOrEqual extends Operator {
-    constructor() {
-        super(0, true);
-    }
-    public value(): number {
-        return this.lhs.value() >= this.rhs.value() ? 1 : 0;
-    }
-}
-
-class LessThanOrEqual extends Operator {
-    constructor() {
-        super(0, true);
-    }
-    public value(): number {
-        return this.lhs.value() <= this.rhs.value() ? 1 : 0;
-    }
-}
-
-class And extends Operator {
-    constructor() {
-        super(-1, true);
-    }
-    public value(): number {
-        return this.lhs.value() && this.rhs.value() ? 1 : 0;
-    }
-}
-
-class Or extends Operator {
-    constructor() {
-        super(-1, true);
-    }
-    public value(): number {
-        return this.lhs.value() || this.rhs.value() ? 1 : 0;
-    }
-}
-
-class Not extends Operator {
-    constructor() {
-        super(0, true);
-    }
-    public isOperator(): boolean {
-        return false;
-    }
-    public value(): number {
-        return !this.lhs.value() ? 1 : 0;
-    }
-}
-
-class Is extends Operator {
-    constructor() {
-        super(0, true);
-    }
-    public value(): number {
-        return this.lhs.value() == this.rhs.value() ? 1 : 0;
-    }
-}
-
-class IsNot extends Operator {
-    constructor() {
-        super(0, true);
-    }
-    public value(): number {
-        return this.lhs.value() != this.rhs.value() ? 1 : 0;
-    }
-}
-
-class In extends Operator {
-    constructor() {
-        super(0, true);
-    }
-    public value(): number {
-        const list = this.rhs.value();
-        if (!Array.isArray(list)) {
-            throw new Error("Right operand of IN must be a list");
-        }
-        return list.includes(this.lhs.value()) ? 1 : 0;
-    }
-}
-
-class NotIn extends Operator {
-    constructor() {
-        super(0, true);
-    }
-    public value(): number {
-        const list = this.rhs.value();
-        if (!Array.isArray(list)) {
-            throw new Error("Right operand of NOT IN must be a list");
-        }
-        return list.includes(this.lhs.value()) ? 0 : 1;
-    }
-}
-
-class Contains extends Operator {
-    constructor() {
-        super(0, true);
-    }
-    public value(): number {
-        const str = this.lhs.value();
-        const search = this.rhs.value();
-        if (typeof str !== "string" || typeof search !== "string") {
-            throw new Error("CONTAINS requires string operands");
-        }
-        return str.includes(search) ? 1 : 0;
-    }
-}
-
-class NotContains extends Operator {
-    constructor() {
-        super(0, true);
-    }
-    public value(): number {
-        const str = this.lhs.value();
-        const search = this.rhs.value();
-        if (typeof str !== "string" || typeof search !== "string") {
-            throw new Error("NOT CONTAINS requires string operands");
-        }
-        return str.includes(search) ? 0 : 1;
-    }
-}
-
-class StartsWith extends Operator {
-    constructor() {
-        super(0, true);
-    }
-    public value(): number {
-        const str = this.lhs.value();
-        const search = this.rhs.value();
-        if (typeof str !== "string" || typeof search !== "string") {
-            throw new Error("STARTS WITH requires string operands");
-        }
-        return str.startsWith(search) ? 1 : 0;
-    }
-}
-
-class NotStartsWith extends Operator {
-    constructor() {
-        super(0, true);
-    }
-    public value(): number {
-        const str = this.lhs.value();
-        const search = this.rhs.value();
-        if (typeof str !== "string" || typeof search !== "string") {
-            throw new Error("NOT STARTS WITH requires string operands");
-        }
-        return str.startsWith(search) ? 0 : 1;
-    }
-}
-
-class EndsWith extends Operator {
-    constructor() {
-        super(0, true);
-    }
-    public value(): number {
-        const str = this.lhs.value();
-        const search = this.rhs.value();
-        if (typeof str !== "string" || typeof search !== "string") {
-            throw new Error("ENDS WITH requires string operands");
-        }
-        return str.endsWith(search) ? 1 : 0;
-    }
-}
-
-class NotEndsWith extends Operator {
-    constructor() {
-        super(0, true);
-    }
-    public value(): number {
-        const str = this.lhs.value();
-        const search = this.rhs.value();
-        if (typeof str !== "string" || typeof search !== "string") {
-            throw new Error("NOT ENDS WITH requires string operands");
-        }
-        return str.endsWith(search) ? 0 : 1;
-    }
-}
-
-export {
-    deepEquals,
-    Operator,
-    Add,
-    Subtract,
-    Multiply,
-    Divide,
-    Modulo,
-    Power,
-    Equals,
-    NotEquals,
-    GreaterThan,
-    LessThan,
-    GreaterThanOrEqual,
-    LessThanOrEqual,
-    And,
-    Or,
-    Not,
-    Is,
-    IsNot,
-    In,
-    NotIn,
-    Contains,
-    NotContains,
-    StartsWith,
-    NotStartsWith,
-    EndsWith,
-    NotEndsWith,
-};

package/src/parsing/expressions/reference.ts

@@ -1,45 +0,0 @@
-import ASTNode from "../ast_node";
-import Identifier from "./identifier";
-
-/**
- * Represents a reference to a previously defined variable or expression.
- *
- * References point to values defined earlier in the query (e.g., in WITH or LOAD statements).
- *
- * @example
- * ```typescript
- * const ref = new Reference("myVar", previousNode);
- * console.log(ref.value()); // Gets value from referred node
- * ```
- */
-class Reference extends Identifier {
-    private _referred: ASTNode | undefined = undefined;
-
-    /**
-     * Creates a new Reference to a variable.
-     *
-     * @param value - The identifier name
-     * @param referred - The node this reference points to (optional)
-     */
-    constructor(value: string, referred: ASTNode | undefined = undefined) {
-        super(value);
-        this._referred = referred;
-    }
-    public get referred(): ASTNode | undefined {
-        return this._referred;
-    }
-    public set referred(node: ASTNode) {
-        this._referred = node;
-    }
-    public toString(): string {
-        return `Reference (${this._value})`;
-    }
-    public value(): any {
-        return this._referred?.value();
-    }
-    public get identifier(): string {
-        return this._value;
-    }
-}
-
-export default Reference;

package/src/parsing/expressions/string.ts

@@ -1,34 +0,0 @@
-import ASTNode from "../ast_node";
-
-/**
- * Represents a string literal in the AST.
- * 
- * @example
- * ```typescript
- * const str = new String("hello");
- * console.log(str.value()); // "hello"
- * ```
- */
-class String extends ASTNode {
-    protected _value: string;
-
-    /**
-     * Creates a new String node with the given value.
-     * 
-     * @param value - The string value
-     */
-    constructor(value: string) {
-        super();
-        this._value = value;
-    }
-
-    public value(): string {
-        return this._value;
-    }
-
-    public toString(): string {
-        return `String (${this._value})`;
-    }
-}
-
-export default String;

package/src/parsing/functions/aggregate_function.ts

@@ -1,58 +0,0 @@
-import Function from "./function";
-import ReducerElement from "./reducer_element";
-
-/**
- * Base class for aggregate functions that reduce multiple values to a single value.
- * 
- * Aggregate functions like SUM, AVG, and COLLECT process multiple input values
- * and produce a single output. They cannot be nested within other aggregate functions.
- * 
- * @example
- * ```typescript
- * const sumFunc = new Sum();
- * // Used in: RETURN SUM(values)
- * ```
- */
-class AggregateFunction extends Function {
-    private _overridden: any | null = null;
-    
-    /**
-     * Creates a new AggregateFunction with the given name.
-     * 
-     * @param name - The function name
-     */
-    constructor(name?: string) {
-        super(name);
-    }
-    
-    /**
-     * Processes a value during the aggregation phase.
-     * 
-     * @param value - The element to aggregate
-     * @throws {Error} If not implemented by subclass
-     */
-    public reduce(value: ReducerElement): void {
-        throw new Error("Method not implemented.");
-    }
-    
-    /**
-     * Creates a reducer element for this aggregate function.
-     * 
-     * @returns A ReducerElement instance
-     * @throws {Error} If not implemented by subclass
-     */
-    public element(): ReducerElement {
-        throw new Error("Method not implemented.");
-    }
-    public get overridden(): any | null {
-        return this._overridden;
-    }
-    public set overridden(value: any | null) {
-        this._overridden = value;
-    }
-    public value(): any {
-        return this._overridden;
-    }
-}
-
-export default AggregateFunction;

package/src/parsing/functions/async_function.ts

@@ -1,64 +0,0 @@
-import ASTNode from "../ast_node";
-import Function from "./function";
-
-/**
- * Represents an async data provider function call for use in LOAD operations.
- * 
- * This class holds the function name and arguments, and provides async iteration
- * over the results from a registered async data provider.
- * 
- * @example
- * ```typescript
- * // Used in: LOAD JSON FROM myDataSource('arg1', 'arg2') AS data
- * const asyncFunc = new AsyncFunction("myDataSource");
- * asyncFunc.parameters = [arg1Node, arg2Node];
- * for await (const item of asyncFunc.execute()) {
- *     console.log(item);
- * }
- * ```
- */
-class AsyncFunction extends Function {
-    /**
-     * Sets the function parameters.
-     * 
-     * @param nodes - Array of AST nodes representing the function arguments
-     */
-    public set parameters(nodes: ASTNode[]) {
-        this.children = nodes;
-    }
-
-    /**
-     * Evaluates all parameters and returns their values.
-     * Used by the framework to pass arguments to generate().
-     * 
-     * @returns Array of parameter values
-     */
-    public getArguments(): any[] {
-        return this.children.map(child => child.value());
-    }
-
-    /**
-     * Generates the async data provider function results.
-     * 
-     * Subclasses override this method with their own typed parameters.
-     * The framework automatically evaluates the AST children and spreads
-     * them as arguments when calling this method.
-     * 
-     * @param args - Arguments passed from the query (e.g., myFunc(arg1, arg2))
-     * @yields Data items from the async provider
-     * @throws {Error} If the function is not registered as an async provider
-     * 
-     * @example
-     * ```typescript
-     * // Subclass with typed parameters:
-     * async *generate(count: number = 1, filter?: string): AsyncGenerator<any> {
-     *     // Implementation
-     * }
-     * ```
-     */
-    public async *generate(...args: any[]): AsyncGenerator<any, void, unknown> {
-        throw new Error("Not implemented: generate method must be overridden in subclasses.");
-    }
-}
-
-export default AsyncFunction;

package/src/parsing/functions/avg.ts

@@ -1,47 +0,0 @@
-import AggregateFunction from "./aggregate_function";
-import ASTNode from "../ast_node";
-import ReducerElement from "./reducer_element";
-import { FunctionDef } from "./function_metadata";
-
-class AvgReducerElement extends ReducerElement {
-    private _count: number = 0;
-    private _sum: number | null = null;
-    public get value(): number | null {
-        if(this._sum === null) {
-            return null;
-        }
-        return this._sum / this._count;
-    }
-    public set value(value: number) {
-        this._count += 1;
-        if(this._sum !== null) {
-            this._sum += value;
-        } else {
-            this._sum = value;
-        }
-    }
-}
-
-@FunctionDef({
-    description: "Calculates the average of numeric values across grouped rows",
-    category: "aggregate",
-    parameters: [
-        { name: "value", description: "Numeric value to average", type: "number" }
-    ],
-    output: { description: "Average of all values", type: "number", example: 50 },
-    examples: ["WITH [10, 20, 30] AS nums UNWIND nums AS n RETURN avg(n)"]
-})
-class Avg extends AggregateFunction {
-    constructor() {
-        super("avg");
-        this._expectedParameterCount = 1;
-    }
-    public reduce(element: AvgReducerElement): void {
-        element.value = this.firstChild().value();
-    }
-    public element(): AvgReducerElement {
-        return new AvgReducerElement();
-    }
-}
-
-export default Avg;

package/src/parsing/functions/coalesce.ts

@@ -1,49 +0,0 @@
-import Function from "./function";
-import { FunctionDef } from "./function_metadata";
-
-/**
- * Returns the first non-null value from a list of expressions.
- *
- * @example
- * ```
- * RETURN coalesce(null, null, 'hello', 'world')  // returns 'hello'
- * MATCH (n) RETURN coalesce(n.nickname, n.name) AS displayName
- * ```
- */
-@FunctionDef({
-    description: "Returns the first non-null value from a list of expressions",
-    category: "scalar",
-    parameters: [
-        { name: "expressions", description: "Two or more expressions to evaluate", type: "any" },
-    ],
-    output: {
-        description: "The first non-null value, or null if all values are null",
-        type: "any",
-    },
-    examples: [
-        "RETURN coalesce(null, 'hello', 'world')",
-        "MATCH (n) RETURN coalesce(n.nickname, n.name) AS displayName",
-    ],
-})
-class Coalesce extends Function {
-    constructor() {
-        super("coalesce");
-        this._expectedParameterCount = null; // variable number of parameters
-    }
-
-    public value(): any {
-        const children = this.getChildren();
-        if (children.length === 0) {
-            throw new Error("coalesce() requires at least one argument");
-        }
-        for (const child of children) {
-            const val = child.value();
-            if (val !== null && val !== undefined) {
-                return val;
-            }
-        }
-        return null;
-    }
-}
-
-export default Coalesce;