flowquery 1.0.0

package/src/parsing/operations/group_by.ts

@@ -0,0 +1,124 @@
+import Expression from "../expressions/expression";
+import AggregateFunction from "../functions/aggregate_function";
+import AggregationElement from "../functions/reducer_element";
+import Projection from "./projection";
+import Where from "./where";
+
+class Node {
+    private _value: any;
+    private _children: Map<string, Node> = new Map();
+    private _elements: AggregationElement[] | null = null;
+    constructor(value: any = null) {
+        this._value = value;
+    }
+    public get value(): any {
+        return this._value;
+    }
+    public get children(): Map<string, Node> {
+        return this._children;
+    }
+    public get elements(): AggregationElement[] | null {
+        return this._elements;
+    }
+    public set elements(elements: AggregationElement[]) {
+        this._elements = elements;
+    }
+}
+
+class GroupBy extends Projection {
+    private _root: Node = new Node();
+    private _current: Node = this._root;
+    private _mappers: Expression[] | null = null;
+    private _reducers: AggregateFunction[] | null = null;
+    protected _where: Where | null = null;
+    public async run(): Promise<void> {
+        this.resetTree();
+        this.map();
+        this.reduce();
+    }
+    private get root(): Node {
+        return this._root;
+    }
+    private get current(): Node {
+        return this._current;
+    }
+    private set current(node: Node) {
+        this._current = node;
+    }
+    private resetTree() {
+        this.current = this.root;
+    }
+    private map() {
+        let node: Node = this.current;
+        for(const mapper of this.mappers) {
+            const value: any = mapper.value();
+            let child: Node | undefined = node.children.get(value);
+            if(child === undefined) {
+                child = new Node(value);
+                node.children.set(value, child);
+            }
+            node = child;
+        }
+        this.current = node;
+    }
+    private reduce() {
+        if(this.current.elements === null) {
+            this.current.elements = this.reducers.map(reducer => reducer.element());
+        }
+        const elements: AggregationElement[] = this.current.elements;
+        this.reducers.forEach((reducer, index) => {
+            reducer.reduce(elements[index]);
+        });
+    }
+    private get mappers(): Expression[] {
+        if(this._mappers === null) {
+            this._mappers = [...this._generate_mappers()];
+        }
+        return this._mappers;
+    }
+    private *_generate_mappers(): Generator<Expression> {
+        for(const [expression, _] of this.expressions()) {
+            if(expression.mappable()) {
+                yield expression;
+            }
+        }
+    }
+    private get reducers(): AggregateFunction[] {
+        if(this._reducers === null) {
+            this._reducers = this.children.map((child) => {
+                return (child as Expression).reducers();
+            }).flat();
+        }
+        return this._reducers;
+    }
+    public *generate_results(mapperIndex: number = 0, node: Node = this.root): Generator<Record<string, any>> {
+        if(node.children.size > 0) {
+            for(const child of node.children.values()) {
+                this.mappers[mapperIndex].overridden = child.value;
+                yield* this.generate_results(mapperIndex + 1, child);
+            }
+        } else {
+            node.elements?.forEach((element, reducerIndex) => {
+                this.reducers[reducerIndex].overridden = element.value;
+            });
+            const record: Record<string, any> = {};
+            for(const [expression, alias] of this.expressions()) {
+                record[alias] = expression.value();
+            }
+            if(this.where) {
+                yield record;
+            }
+        }
+    }
+    public set where(where: Where) {
+        this._where = where;
+    }
+    public get where(): boolean {
+        if(this._where === null) {
+            return true;
+        }
+        return this._where.value();
+    }
+};
+
+export default GroupBy;

package/src/parsing/operations/limit.ts

@@ -0,0 +1,22 @@
+import Operation from "./operation";
+
+class Limit extends Operation {
+    private count: number = 0;
+    private limit: number = 0;
+    constructor(limit: number) {
+        super();
+        this.limit = limit;
+    }
+    public async run(): Promise<void> {
+        if (this.count >= this.limit) {
+            return;
+        }
+        this.count++;
+        await this.next?.run();
+    }
+    public reset(): void {
+        this.count = 0;
+    }
+}
+
+export default Limit;

package/src/parsing/operations/load.ts

@@ -0,0 +1,92 @@
+import Operation from "./operation";
+import CSV from "../components/csv";
+import {default as _JSON} from "../components/json";
+import Text from "../components/text";
+import Function from "../functions/function";
+import AssociativeArray from "../data_structures/associative_array";
+import Reference from "../expressions/reference";
+import Expression from "../expressions/expression";
+import Headers from "../components/headers";
+import Post from "../components/post";
+import Lookup from "../data_structures/lookup";
+
+class Load extends Operation {
+  private _value: any = null;
+  constructor() {
+    super()
+  }
+  public get type(): _JSON | CSV | Text {
+    return this.children[0] as _JSON | CSV | Text;
+  }
+  public get from(): string {
+    return this.children[1].value() as string;
+  }
+  public get headers(): { [key: string]: string } {
+    if(this.childCount() > 2 && this.children[2] instanceof Headers) {
+      return this.children[2].value() as { [key: string]: string } || {};
+    }
+    return {};
+  }
+  public get payload(): Function | Reference | Expression | AssociativeArray | Lookup | null {
+    let post: Post | null = null;
+    if(this.childCount() > 2 && this.children[2] instanceof Post) {
+      post = this.children[2] as Post;
+    } else if(this.childCount() > 3 && this.children[3] instanceof Post) {
+      post = this.children[3] as Post;
+    }
+    return post !== null ? post.firstChild() as Function | Reference | Expression | AssociativeArray | Lookup : null;
+  }
+  private method(): "GET" | "POST" {
+    if(this.payload === null) {
+      return "GET";
+    } else {
+      return "POST";
+    }
+  }
+  private options(): object {
+    const headers = this.headers as { [key: string]: string };
+    const payload = this.payload;
+    const data = payload?.value();
+    if(data !== null && typeof data === "object" && !(headers.hasOwnProperty("Content-Type"))) {
+      headers["Content-Type"] = "application/json";
+    }
+    return {
+      "method": this.method(),
+      "headers": headers,
+      ...(payload !== null ? {"body": JSON.stringify(payload.value())} : {})
+    };
+  }
+  public async load(): Promise<any> {
+    const result = await fetch(this.from, this.options());
+    let data: any = null;
+    if(this.type instanceof _JSON) {
+      data = await result.json();
+    } else if(this.type instanceof Text) {
+      data = await result.text();
+    }
+    if(Array.isArray(data)) {
+      for(const item of data) {
+        this._value = item;
+        await this.next?.run();
+      }
+    } else if(typeof data === "object" && data !== null) {
+      this._value = data;
+      await this.next?.run();
+    } else if(typeof data === "string") {
+      this._value = data;
+      await this.next?.run();
+    }
+  }
+  public async run(): Promise<void> {
+    try {
+      await this.load();
+    } catch(e) {
+      throw new Error(`Failed to load data from ${this.from}. Error: ${e}`);
+    }
+  }
+  public value(): any {
+    return this._value;
+  }
+}
+
+export default Load;

package/src/parsing/operations/operation.ts

@@ -0,0 +1,65 @@
+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;
+    }
+    
+    /**
+     * 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 reset(): void {
+        ;
+    }
+    public get results(): Record<string, any>[] {
+        throw new Error('Not implemented');
+    }
+}
+
+export default Operation;

package/src/parsing/operations/projection.ts

@@ -0,0 +1,18 @@
+import Operation from "./operation";
+import Expression from "../expressions/expression";
+
+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

@@ -0,0 +1,43 @@
+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>[] = [];
+    public set where(where: Where) {
+        this._where = where;
+    }
+    public get where(): boolean {
+        if(this._where === null) {
+            return true;
+        }
+        return this._where.value();
+    }
+    public async run(): Promise<void> {
+        if(!this.where) {
+            return;
+        }
+        const record: Map<string, any> = new Map();
+        for(const [expression, alias] of this.expressions()) {
+            const value: any = expression.value();
+            record.set(alias, value);
+        }
+        this._results.push(Object.fromEntries(record));
+    }
+    public get results(): Record<string, any>[] {
+        return this._results;
+    }
+}
+
+export default Return;

package/src/parsing/operations/unwind.ts

@@ -0,0 +1,32 @@
+import Operation from "./operation";
+import Expression from "../expressions/expression";
+
+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(!(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

@@ -0,0 +1,38 @@
+import Operation from "./operation";
+import Expression from "../expressions/expression";
+
+/**
+ * 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> {
+        if(this.expression.value()) {
+            await this.next?.run();
+        }
+    }
+    public value(): any {
+        return this.expression.value();
+    }
+}
+
+export default Where;

package/src/parsing/operations/with.ts

@@ -0,0 +1,20 @@
+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;