flowquery 1.0.0

package/src/parsing/functions/function.ts

@@ -0,0 +1,60 @@
+import ASTNode from "../ast_node";
+
+/**
+ * Base class for all functions in FlowQuery.
+ * 
+ * Functions can have parameters and may support the DISTINCT modifier.
+ * Subclasses implement specific function logic.
+ * 
+ * @example
+ * ```typescript
+ * const func = FunctionFactory.create("sum");
+ * func.parameters = [expression1, expression2];
+ * ```
+ */
+class Function extends ASTNode {
+    protected _name: string;
+    protected _expectedParameterCount: number | null = null;
+    protected _supports_distinct: boolean = false;
+
+    /**
+     * Creates a new Function with the given name.
+     * 
+     * @param name - The function name
+     */
+    constructor(name: string) {
+        super();
+        this._name = name;
+    }
+
+    /**
+     * Sets the function parameters.
+     * 
+     * @param nodes - Array of AST nodes representing the function arguments
+     * @throws {Error} If the number of parameters doesn't match expected count
+     */
+    public set parameters(nodes: ASTNode[]) {
+        if (this._expectedParameterCount !== null && this._expectedParameterCount !== nodes.length) {
+            throw new Error(`Function ${this._name} expected ${this._expectedParameterCount} parameters, but got ${nodes.length}`);
+        }
+        this.children = nodes;
+    }
+
+    public get name(): string {
+        return this._name;
+    }
+
+    public toString(): string {
+        return `Function (${this._name})`;
+    }
+
+    public set distinct(distinct: boolean) {
+        if (this._supports_distinct) {
+            this._supports_distinct = distinct;
+        } else {
+            throw new Error(`Function ${this._name} does not support distinct`);
+        }
+    }
+}
+
+export default Function;

package/src/parsing/functions/function_factory.ts

@@ -0,0 +1,66 @@
+import Sum from "./sum";
+import Collect from "./collect";
+import Avg from "./avg";
+import Range from "./range";
+import Rand from "./rand";
+import Round from "./round";
+import Split from "./split";
+import Join from "./join";
+import ToJson from "./to_json";
+import Replace from "./replace";
+import Stringify from "./stringify";
+import Size from "./size";
+import Function from "./function";
+
+/**
+ * Factory for creating function instances by name.
+ * 
+ * Maps function names (case-insensitive) to their corresponding implementation classes.
+ * Supports built-in functions like sum, avg, collect, range, split, join, etc.
+ * 
+ * @example
+ * ```typescript
+ * const sumFunc = FunctionFactory.create("sum");
+ * const avgFunc = FunctionFactory.create("AVG");
+ * ```
+ */
+class FunctionFactory {
+    /**
+     * Creates a function instance by name.
+     * 
+     * @param name - The function name (case-insensitive)
+     * @returns A Function instance of the appropriate type
+     */
+    public static create(name: string): Function {
+        switch (name.toLowerCase()) {
+            case "sum":
+                return new Sum();
+            case "collect":
+                return new Collect();
+            case "avg":
+                return new Avg();
+            case "range":
+                return new Range();
+            case "rand":
+                return new Rand();
+            case "round":
+                return new Round();
+            case "split":
+                return new Split();
+            case "join":
+                return new Join();
+            case "tojson":
+                return new ToJson();
+            case "replace":
+                return new Replace();
+            case "stringify":
+                return new Stringify();
+            case "size":
+                return new Size();
+            default:
+                return new Function(name);
+        }
+    }
+}
+
+export default FunctionFactory;

package/src/parsing/functions/join.ts

@@ -0,0 +1,26 @@
+import ASTNode from "../ast_node";
+import Function from "./function";
+import String from "../expressions/string";
+
+class Join extends Function {
+    constructor() {
+        super("join");
+        this._expectedParameterCount = 2;
+    }
+    public set parameters(nodes: ASTNode[]) {
+        if(nodes.length === 1) {
+            nodes.push(new String(""));
+        }
+        super.parameters = nodes;
+    }
+    public value(): any {
+        const array = this.getChildren()[0].value();
+        const delimiter = this.getChildren()[1].value();
+        if (!Array.isArray(array) || typeof delimiter !== "string") {
+            throw new Error("Invalid arguments for join function");
+        }
+        return array.join(delimiter);
+    }
+}
+
+export default Join;

package/src/parsing/functions/predicate_function.ts

@@ -0,0 +1,44 @@
+import ASTNode from "../ast_node";
+import Expression from "../expressions/expression";
+import Reference from "../expressions/reference";
+import Where from "../operations/where";
+import ValueHolder from "./value_holder";
+
+class PredicateFunction extends ASTNode {
+    private _name: string;
+    protected _valueHolder: ValueHolder = new ValueHolder();
+
+    constructor(name: string) {
+        super();
+        this._name = name;
+    }
+
+    protected get reference(): Reference {
+        return this.firstChild() as Reference;
+    }
+
+    protected get array(): ASTNode {
+        return this.getChildren()[1].firstChild();
+    }
+
+    protected get _return(): Expression {
+        return this.getChildren()[2] as Expression;
+    }
+
+    protected get where(): Where | null {
+        if (this.getChildren().length === 4) {
+            return this.getChildren()[3] as Where;
+        }
+        return null;
+    }
+
+    public value(): any {
+        throw new Error("Method not implemented.");
+    }
+
+    public toString(): string {
+        return `PredicateFunction (${this._name})`;
+    }
+}
+
+export default PredicateFunction;

package/src/parsing/functions/predicate_function_factory.ts

@@ -0,0 +1,15 @@
+import PredicateFunction from "./predicate_function";
+import PredicateSum from "./predicate_sum";
+
+class PredicateFunctionFactory {
+    public static create(name: string): PredicateFunction {
+        switch (name.toLowerCase()) {
+            case "sum":
+                return new PredicateSum();
+            default:
+                return new PredicateFunction(name);
+        }
+    }
+}
+
+export default PredicateFunctionFactory;

package/src/parsing/functions/predicate_sum.ts

@@ -0,0 +1,29 @@
+import PredicateFunction from "./predicate_function";
+
+class PredicateSum extends PredicateFunction {
+    constructor() {
+        super("sum");
+    }
+
+    public value(): any {
+        this.reference.referred = this._valueHolder;
+        const array = this.array.value();
+        if (array === null || !Array.isArray(array)) {
+            throw new Error("Invalid array for sum function");
+        }
+        let _sum: any | null = null;
+        for(let i = 0; i < array.length; i++) {
+            this._valueHolder.holder = array[i];
+            if (this.where === null || this.where.value()) {
+                if (_sum === null) {
+                    _sum = this._return.value();
+                } else {
+                    _sum += this._return.value();
+                }
+            }
+        }
+        return _sum;
+    }
+}
+
+export default PredicateSum;

package/src/parsing/functions/rand.ts

@@ -0,0 +1,13 @@
+import Function from "./function";
+
+class Rand extends Function {
+    constructor() {
+        super("rand");
+        this._expectedParameterCount = 0;
+    }
+    public value(): any {
+        return Math.random();
+    }
+}
+
+export default Rand;

package/src/parsing/functions/range.ts

@@ -0,0 +1,18 @@
+import Function from "./function";
+
+class Range extends Function {
+    constructor() {
+        super("range");
+        this._expectedParameterCount = 2;
+    }
+    public value(): any {
+        const start = this.getChildren()[0].value();
+        const end = this.getChildren()[1].value();
+        if (typeof start !== "number" || typeof end !== "number") {
+            throw new Error("Invalid arguments for range function");
+        }
+        return Array.from({ length: end - start + 1 }, (_, i) => start + i);
+    }
+}
+
+export default Range;

package/src/parsing/functions/reducer_element.ts

@@ -0,0 +1,10 @@
+class ReducerElement {
+    public get value(): any {
+        throw new Error("Method not implemented.");
+    }
+    public set value(value: any) {
+        throw new Error("Method not implemented.");
+    }
+}
+
+export default ReducerElement;

package/src/parsing/functions/replace.ts

@@ -0,0 +1,19 @@
+import Function from "./function";
+
+class Replace extends Function {
+    constructor() {
+        super("replace");
+        this._expectedParameterCount = 3;
+    }
+    public value(): any {
+        const str = this.getChildren()[0].value();
+        const search = this.getChildren()[1].value();
+        const replacement = this.getChildren()[2].value();
+        if (typeof str !== "string" || typeof search !== "string" || typeof replacement !== "string") {
+            throw new Error("Invalid arguments for replace function");
+        }
+        return str.replace(new RegExp(search, "g"), replacement);
+    }
+}
+
+export default Replace;

package/src/parsing/functions/round.ts

@@ -0,0 +1,17 @@
+import Function from "./function";
+
+class Round extends Function {
+    constructor() {
+        super("round");
+        this._expectedParameterCount = 1;
+    }
+    public value(): any {
+        const value = this.getChildren()[0].value();
+        if (typeof value !== "number") {
+            throw new Error("Invalid argument for round function");
+        }
+        return Math.round(value);
+    }
+}
+
+export default Round;

package/src/parsing/functions/size.ts

@@ -0,0 +1,17 @@
+import Function from "./function";
+
+class Size extends Function {
+    constructor() {
+        super("size");
+        this._expectedParameterCount = 1;
+    }
+    public value(): any {
+        const arr = this.getChildren()[0].value();
+        if (!Array.isArray(arr)) {
+            throw new Error("Invalid argument for size function");
+        }
+        return arr.length;
+    }
+}
+
+export default Size;

package/src/parsing/functions/split.ts

@@ -0,0 +1,26 @@
+import ASTNode from "../ast_node";
+import Function from "./function";
+import String from "../expressions/string";
+
+class Split extends Function {
+    constructor() {
+        super("split");
+        this._expectedParameterCount = 2;
+    }
+    public set parameters(nodes: ASTNode[]) {
+        if(nodes.length === 1) {
+            nodes.push(new String(""));
+        }
+        super.parameters = nodes;
+    }
+    public value(): any {
+        const str = this.getChildren()[0].value();
+        const delimiter = this.getChildren()[1].value();
+        if (typeof str !== "string" || typeof delimiter !== "string") {
+            throw new Error("Invalid arguments for split function");
+        }
+        return str.split(delimiter);
+    }
+}
+
+export default Split;

package/src/parsing/functions/stringify.ts

@@ -0,0 +1,26 @@
+import ASTNode from "../ast_node";
+import Function from "./function";
+import Number from "../expressions/number";
+
+class Stringify extends Function {
+    constructor() {
+        super("stringify");
+        this._expectedParameterCount = 2;
+    }
+    public set parameters(nodes: ASTNode[]) {
+        if(nodes.length === 1) {
+            nodes.push(new Number("3")); // Default to 3 if only one parameter is provided
+        }
+        super.parameters = nodes;
+    }
+    public value(): any {
+        const value = this.getChildren()[0].value();
+        const indent = parseInt(this.getChildren()[1].value());
+        if (typeof value !== "object") {
+            throw new Error("Invalid argument for stringify function");
+        }
+        return JSON.stringify(value, null, indent);
+    }
+}
+
+export default Stringify;

package/src/parsing/functions/sum.ts

@@ -0,0 +1,31 @@
+import AggregateFunction from "./aggregate_function";
+import ReducerElement from "./reducer_element";
+
+class SumReducerElement extends ReducerElement {
+    private _value: any = null;
+    public get value(): any {
+        return this._value;
+    }
+    public set value(value: any) {
+        if(this._value !== null) {
+            this._value += value;
+        } else {
+            this._value = value;
+        }
+    }
+}
+
+class Sum extends AggregateFunction {
+    constructor() {
+        super("sum");
+        this._expectedParameterCount = 1;
+    }
+    public reduce(element: SumReducerElement): void {
+        element.value = this.firstChild().value();
+    }
+    public element(): SumReducerElement {
+        return new SumReducerElement();
+    }
+}
+
+export default Sum;

package/src/parsing/functions/to_json.ts

@@ -0,0 +1,17 @@
+import Function from "./function";
+
+class ToJson extends Function {
+    constructor() {
+        super("tojson");
+        this._expectedParameterCount = 1;
+    }
+    public value(): any {
+        const str = this.getChildren()[0].value();
+        if (typeof str !== "string") {
+            throw new Error("Invalid arguments for tojson function");
+        }
+        return JSON.parse(str);
+    }
+}
+
+export default ToJson;

package/src/parsing/functions/value_holder.ts

@@ -0,0 +1,13 @@
+import ASTNode from "../ast_node";
+
+class ValueHolder extends ASTNode {
+    private _holder: any;
+    public set holder(value: any) {
+        this._holder = value;
+    }
+    public value(): any {
+        return this._holder;
+    }
+}
+
+export default ValueHolder;

package/src/parsing/logic/case.ts

@@ -0,0 +1,26 @@
+import ASTNode from "../ast_node";
+import Else from "./else";
+import When from "./when";
+import Then from "./then";
+
+class Case extends ASTNode {
+    constructor() {
+        super();
+    }
+
+    public value(): any {
+        let i = 0;
+        let child = this.getChildren()[i];
+        while (child instanceof When) {
+            const then = (this.getChildren()[i+1] as Then);
+            if (child.value()) {
+                return then.value();
+            }
+            i += 2;
+            child = this.getChildren()[i];
+        }
+        return (child as Else).value();
+    }
+}
+
+export default Case;

package/src/parsing/logic/else.ts

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

package/src/parsing/logic/end.ts

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

package/src/parsing/logic/then.ts

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

package/src/parsing/logic/when.ts

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

package/src/parsing/operations/aggregated_return.ts

@@ -0,0 +1,18 @@
+import Return from "./return";
+import GroupBy from "./group_by";
+import Expression from "../expressions/expression";
+
+class AggregatedReturn extends Return {
+    private _group_by: GroupBy = new GroupBy(this.children as Expression[]);
+    public async run(): Promise<void> {
+        await this._group_by.run();
+    }
+    public get results(): Record<string, any>[] {
+        if(this._where !== null) {
+            this._group_by.where = this._where;
+        }
+        return Array.from(this._group_by.generate_results());
+    }
+}
+
+export default AggregatedReturn;

package/src/parsing/operations/aggregated_with.ts

@@ -0,0 +1,18 @@
+import With from "./return";
+import GroupBy from "./group_by";
+import Expression from "../expressions/expression";
+
+class AggregatedWith extends With {
+    private _group_by: GroupBy = new GroupBy(this.children as Expression[]);
+    public async run(): Promise<void> {
+        await this._group_by.run();
+    }
+    public async finish(): Promise<void> {
+        for(const _ of this._group_by.generate_results()) {
+            await this.next?.run();
+        }
+        await super.finish();
+    }
+}
+
+export default AggregatedWith;