flowquery 1.0.46 → 1.0.48

package/src/parsing/operations/match.ts

@@ -1,54 +0,0 @@
-import Node from "../../graph/node";
-import Pattern from "../../graph/pattern";
-import Patterns from "../../graph/patterns";
-import Operation from "./operation";
-
-class Match extends Operation {
-    private _patterns: Patterns | null = null;
-    private _optional: boolean = false;
-
-    constructor(patterns: Pattern[] = [], optional: boolean = false) {
-        super();
-        this._patterns = new Patterns(patterns);
-        this._optional = optional;
-    }
-    public get patterns(): Pattern[] {
-        return this._patterns ? this._patterns.patterns : [];
-    }
-    public get optional(): boolean {
-        return this._optional;
-    }
-    protected toString(): string {
-        return this._optional ? "OptionalMatch" : "Match";
-    }
-    /**
-     * Executes the match operation by chaining the patterns together.
-     * After each pattern match, it continues to the next operation in the chain.
-     * If optional and no match is found, continues with null values.
-     * @return Promise<void>
-     */
-    public async run(): Promise<void> {
-        await this._patterns!.initialize();
-        let matched = false;
-        this._patterns!.toDoNext = async () => {
-            matched = true;
-            // Continue to the next operation after all patterns are matched
-            await this.next?.run();
-        };
-        // Kick off the graph pattern traversal
-        await this._patterns!.traverse();
-        // For OPTIONAL MATCH: if nothing matched, continue with null values
-        if (!matched && this._optional) {
-            for (const pattern of this._patterns!.patterns) {
-                for (const element of pattern.chain) {
-                    if (element instanceof Node) {
-                        element.setValue(null!);
-                    }
-                }
-            }
-            await this.next?.run();
-        }
-    }
-}
-
-export default Match;

package/src/parsing/operations/operation.ts

@@ -1,69 +0,0 @@
-import ASTNode from "../ast_node";
-
-/**
- * Base class for all FlowQuery operations.
- *
- * Operations represent the main statements in FlowQuery (WITH, UNWIND, RETURN, LOAD, WHERE).
- * They form a linked list structure and can be executed sequentially.
- *
- * @abstract
- */
-abstract class Operation extends ASTNode {
-    private _previous: Operation | null = null;
-    private _next: Operation | null = null;
-
-    /**
-     * Creates a new Operation instance.
-     */
-    constructor() {
-        super();
-    }
-    public get previous(): Operation | null {
-        return this._previous;
-    }
-    public set previous(value: Operation | null) {
-        this._previous = value;
-    }
-    public get next(): Operation | null {
-        return this._next;
-    }
-    public set next(value: Operation | null) {
-        this._next = value;
-    }
-    public addSibling(operation: Operation): void {
-        this._parent?.addChild(operation);
-        operation.previous = this;
-        this.next = operation;
-    }
-    public get isLast(): boolean {
-        return this._next === null;
-    }
-
-    /**
-     * Executes this operation. Must be implemented by subclasses.
-     *
-     * @returns A promise that resolves when the operation completes
-     * @throws {Error} If not implemented by subclass
-     */
-    public async run(): Promise<void> {
-        throw new Error("Not implemented");
-    }
-
-    /**
-     * Finishes execution by calling finish on the next operation in the chain.
-     *
-     * @returns A promise that resolves when all operations finish
-     */
-    public async finish(): Promise<void> {
-        await this.next?.finish();
-    }
-    public async initialize(): Promise<void> {
-        await this.next?.initialize();
-    }
-    public reset(): void {}
-    public get results(): Record<string, any>[] {
-        throw new Error("Not implemented");
-    }
-}
-
-export default Operation;

package/src/parsing/operations/order_by.ts

@@ -1,126 +0,0 @@
-import Expression from "../expressions/expression";
-import Reference from "../expressions/reference";
-import Operation from "./operation";
-
-export interface SortField {
-    direction: "asc" | "desc";
-    /** The parsed expression to evaluate for this sort field. */
-    expression: Expression;
-}
-
-/**
- * Represents an ORDER BY operation that sorts results.
- *
- * Can be attached to a RETURN operation (sorting its results),
- * or used as a standalone accumulating operation after a non-aggregate WITH.
- *
- * Supports both simple field references and arbitrary expressions:
- * @example
- * ```
- * RETURN x ORDER BY x DESC
- * RETURN x ORDER BY toLower(x.name) ASC
- * RETURN x ORDER BY string_distance(toLower(x.name), toLower('Thomas')) ASC
- * ```
- */
-class OrderBy extends Operation {
-    private _fields: SortField[];
-    private _results: Record<string, any>[] = [];
-    /**
-     * Parallel array of pre-computed sort-key tuples, one entry per
-     * accumulated result row.  Each inner array has one value per sort
-     * field, in the same order as `_fields`.
-     */
-    private _sortKeys: any[][] = [];
-
-    constructor(fields: SortField[]) {
-        super();
-        this._fields = fields;
-    }
-
-    public get fields(): SortField[] {
-        return this._fields;
-    }
-
-    /**
-     * Evaluates every sort-field expression against the current runtime
-     * context and stores the resulting values.  Must be called once per
-     * accumulated row (from `Return.run()`).
-     */
-    public captureSortKeys(): void {
-        this._sortKeys.push(this._fields.map((f) => f.expression.value()));
-    }
-
-    /**
-     * Sorts an array of records using the pre-computed sort keys captured
-     * during accumulation.  When no keys have been captured (e.g.
-     * aggregated returns), falls back to looking up simple reference
-     * identifiers in each record.
-     */
-    public sort(records: Record<string, any>[]): Record<string, any>[] {
-        const useKeys = this._sortKeys.length === records.length;
-        // Build an index array so we can sort records and keys together.
-        const indices = records.map((_, i) => i);
-        const keys = this._sortKeys;
-
-        // Pre-compute fallback field names for when sort keys aren't
-        // available (aggregated returns).  Simple references like `x`
-        // map to the column name; complex expressions have no fallback.
-        const fallbackFields: (string | null)[] = this._fields.map((f) => {
-            const root = f.expression.firstChild();
-            if (root instanceof Reference && f.expression.childCount() === 1) {
-                return (root as Reference).identifier;
-            }
-            return null;
-        });
-
-        indices.sort((ai, bi) => {
-            for (let f = 0; f < this._fields.length; f++) {
-                let aVal: any;
-                let bVal: any;
-                if (useKeys) {
-                    aVal = keys[ai][f];
-                    bVal = keys[bi][f];
-                } else if (fallbackFields[f] !== null) {
-                    aVal = records[ai][fallbackFields[f]!];
-                    bVal = records[bi][fallbackFields[f]!];
-                } else {
-                    continue;
-                }
-                let cmp = 0;
-                if (aVal == null && bVal == null) cmp = 0;
-                else if (aVal == null) cmp = -1;
-                else if (bVal == null) cmp = 1;
-                else if (aVal < bVal) cmp = -1;
-                else if (aVal > bVal) cmp = 1;
-                if (cmp !== 0) {
-                    return this._fields[f].direction === "desc" ? -cmp : cmp;
-                }
-            }
-            return 0;
-        });
-        return indices.map((i) => records[i]);
-    }
-
-    /**
-     * When used as a standalone operation (after non-aggregate WITH),
-     * accumulates records to sort later.
-     */
-    public async run(): Promise<void> {
-        const record: Record<string, any> = {};
-        // Collect current variable values from the context
-        // This gets called per-row, and then finish() sorts and emits
-        await this.next?.run();
-    }
-
-    public async initialize(): Promise<void> {
-        this._results = [];
-        this._sortKeys = [];
-        await this.next?.initialize();
-    }
-
-    public get results(): Record<string, any>[] {
-        return this._results;
-    }
-}
-
-export default OrderBy;

package/src/parsing/operations/projection.ts

@@ -1,18 +0,0 @@
-import Expression from "../expressions/expression";
-import Operation from "./operation";
-
-class Projection extends Operation {
-    constructor(expressions: Expression[]) {
-        super();
-        this.children = expressions;
-    }
-    protected *expressions(): Generator<[Expression, string]> {
-        for (let i = 0; i < this.children.length; i++) {
-            const expression: Expression = this.children[i] as Expression;
-            const alias = expression.alias || `expr${i}`;
-            yield [expression, alias];
-        }
-    }
-}
-
-export default Projection;

package/src/parsing/operations/return.ts

@@ -1,76 +0,0 @@
-import Limit from "./limit";
-import OrderBy from "./order_by";
-import Projection from "./projection";
-import Where from "./where";
-
-/**
- * Represents a RETURN operation that produces the final query results.
- *
- * The RETURN operation evaluates expressions and collects them into result records.
- * It can optionally have a WHERE clause to filter results.
- *
- * @example
- * ```typescript
- * // RETURN x, y WHERE x > 0
- * ```
- */
-class Return extends Projection {
-    protected _where: Where | null = null;
-    protected _results: Record<string, any>[] = [];
-    private _limit: Limit | null = null;
-    protected _orderBy: OrderBy | null = null;
-    public set where(where: Where) {
-        this._where = where;
-    }
-    public get where(): boolean {
-        if (this._where === null) {
-            return true;
-        }
-        return this._where.value();
-    }
-    public set limit(limit: Limit) {
-        this._limit = limit;
-    }
-    public set orderBy(orderBy: OrderBy) {
-        this._orderBy = orderBy;
-    }
-    public async run(): Promise<void> {
-        if (!this.where) {
-            return;
-        }
-        // When ORDER BY is present, skip limit during accumulation;
-        // limit will be applied after sorting in get results()
-        if (this._orderBy === null && this._limit !== null && this._limit.isLimitReached) {
-            return;
-        }
-        const record: Map<string, any> = new Map();
-        for (const [expression, alias] of this.expressions()) {
-            const raw = expression.value();
-            const value: any = typeof raw === "object" && raw !== null ? structuredClone(raw) : raw;
-            record.set(alias, value);
-        }
-        // Capture sort-key values while expression bindings are still live.
-        if (this._orderBy !== null) {
-            this._orderBy.captureSortKeys();
-        }
-        this._results.push(Object.fromEntries(record));
-        if (this._orderBy === null && this._limit !== null) {
-            this._limit.increment();
-        }
-    }
-    public async initialize(): Promise<void> {
-        this._results = [];
-    }
-    public get results(): Record<string, any>[] {
-        let results = this._results;
-        if (this._orderBy !== null) {
-            results = this._orderBy.sort(results);
-        }
-        if (this._orderBy !== null && this._limit !== null) {
-            results = results.slice(0, this._limit.limitValue);
-        }
-        return results;
-    }
-}
-
-export default Return;

package/src/parsing/operations/union.ts

@@ -1,114 +0,0 @@
-import Operation from "./operation";
-
-/**
- * Represents a UNION operation that combines results from two sub-queries.
- *
- * UNION merges the results of a left and right query pipeline, removing
- * duplicate rows. Both sides must return the same column names.
- *
- * @example
- * ```
- * WITH 1 AS x RETURN x
- * UNION
- * WITH 2 AS x RETURN x
- * // Results: [{x: 1}, {x: 2}]
- * ```
- */
-class Union extends Operation {
-    protected _left: Operation | null = null;
-    protected _right: Operation | null = null;
-    protected _results: Record<string, any>[] = [];
-
-    public set left(operation: Operation) {
-        this._left = operation;
-    }
-    public get left(): Operation {
-        if (!this._left) {
-            throw new Error("Left operation is not set");
-        }
-        return this._left;
-    }
-    public set right(operation: Operation) {
-        this._right = operation;
-    }
-    public get right(): Operation {
-        if (!this._right) {
-            throw new Error("Right operation is not set");
-        }
-        return this._right;
-    }
-
-    private lastInChain(operation: Operation): Operation {
-        let current = operation;
-        while (current.next) {
-            current = current.next;
-        }
-        return current;
-    }
-
-    public async initialize(): Promise<void> {
-        this._results = [];
-        await this.next?.initialize();
-    }
-
-    public async run(): Promise<void> {
-        // Execute left pipeline
-        await this._left!.initialize();
-        await this._left!.run();
-        await this._left!.finish();
-        const leftLast = this.lastInChain(this._left!);
-        const leftResults: Record<string, any>[] = leftLast.results;
-
-        // Execute right pipeline
-        await this._right!.initialize();
-        await this._right!.run();
-        await this._right!.finish();
-        const rightLast = this.lastInChain(this._right!);
-        const rightResults: Record<string, any>[] = rightLast.results;
-
-        // Validate column names match
-        if (leftResults.length > 0 && rightResults.length > 0) {
-            const leftKeys = Object.keys(leftResults[0]).sort().join(",");
-            const rightKeys = Object.keys(rightResults[0]).sort().join(",");
-            if (leftKeys !== rightKeys) {
-                throw new Error(
-                    "All sub queries in a UNION must have the same return column names"
-                );
-            }
-        }
-
-        // Combine results
-        this._results = this.combine(leftResults, rightResults);
-    }
-
-    /**
-     * Combines results from left and right pipelines.
-     * UNION removes duplicates; subclass UnionAll overrides to keep all rows.
-     */
-    protected combine(
-        left: Record<string, any>[],
-        right: Record<string, any>[]
-    ): Record<string, any>[] {
-        const combined = [...left];
-        for (const row of right) {
-            const serialized = JSON.stringify(row);
-            const isDuplicate = combined.some(
-                (existing) => JSON.stringify(existing) === serialized
-            );
-            if (!isDuplicate) {
-                combined.push(row);
-            }
-        }
-        return combined;
-    }
-
-    public async finish(): Promise<void> {
-        await this.next?.finish();
-    }
-
-    public get results(): Record<string, any>[] {
-        return this._results;
-    }
-}
-
-export default Union;

package/src/parsing/operations/union_all.ts

@@ -1,16 +0,0 @@
-import Union from "./union";
-
-/**
- * Represents a UNION ALL operation that concatenates results from two sub-queries
- * without removing duplicates.
- */
-class UnionAll extends Union {
-    protected combine(
-        left: Record<string, any>[],
-        right: Record<string, any>[]
-    ): Record<string, any>[] {
-        return [...left, ...right];
-    }
-}
-
-export default UnionAll;

package/src/parsing/operations/unwind.ts

@@ -1,36 +0,0 @@
-import Expression from "../expressions/expression";
-import Operation from "./operation";
-
-class Unwind extends Operation {
-    private _value: any;
-    constructor(expression: Expression) {
-        super();
-        this.addChild(expression);
-    }
-    public get expression(): Expression {
-        return this.children[0] as Expression;
-    }
-    public get as(): string {
-        return this.children[1].value as unknown as string;
-    }
-    public async run(): Promise<void> {
-        const expression = this.expression.value();
-        if (expression === null || expression === undefined) {
-            this.next?.reset();
-            return;
-        }
-        if (!Array.isArray(expression)) {
-            throw new Error("Expected array");
-        }
-        for (let i = 0; i < expression.length; i++) {
-            this._value = expression[i];
-            await this.next?.run();
-        }
-        this.next?.reset();
-    }
-    public value(): any {
-        return this._value;
-    }
-}
-
-export default Unwind;

package/src/parsing/operations/where.ts

@@ -1,42 +0,0 @@
-import Expression from "../expressions/expression";
-import Operation from "./operation";
-
-/**
- * Represents a WHERE operation that filters data based on a condition.
- *
- * The WHERE operation evaluates a boolean expression and only continues
- * execution to the next operation if the condition is true.
- *
- * @example
- * ```typescript
- * // RETURN x WHERE x > 0
- * ```
- */
-class Where extends Operation {
-    /**
-     * Creates a new WHERE operation with the given condition.
-     *
-     * @param expression - The boolean expression to evaluate
-     */
-    constructor(expression: Expression) {
-        super();
-        this.addChild(expression);
-    }
-    public get expression(): Expression {
-        return this.children[0] as Expression;
-    }
-    public async run(): Promise<void> {
-        for (const pattern of this.expression.patterns()) {
-            await pattern.fetchData();
-            await pattern.evaluate();
-        }
-        if (this.expression.value()) {
-            await this.next?.run();
-        }
-    }
-    public value(): any {
-        return this.expression.value();
-    }
-}
-
-export default Where;

package/src/parsing/operations/with.ts

@@ -1,20 +0,0 @@
-import Projection from "./projection";
-
-/**
- * Represents a WITH operation that defines variables or intermediate results.
- * 
- * The WITH operation creates named expressions that can be referenced later in the query.
- * It passes control to the next operation in the chain.
- * 
- * @example
- * ```typescript
- * // WITH x = 1, y = 2 RETURN x + y
- * ```
- */
-class With extends Projection {
-    public async run(): Promise<void> {
-        await this.next?.run();
-    }
-}
-
-export default With;