flowquery 1.0.46 → 1.0.48

package/src/parsing/functions/value_holder.ts

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

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

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

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

package/src/parsing/logic/then.ts

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

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

@@ -1,22 +0,0 @@
-import Expression from "../expressions/expression";
-import GroupBy from "./group_by";
-import Return from "./return";
-
-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;
-        }
-        const results = Array.from(this._group_by.generate_results());
-        if (this._orderBy !== null) {
-            return this._orderBy.sort(results);
-        }
-        return results;
-    }
-}
-
-export default AggregatedReturn;

package/src/parsing/operations/aggregated_with.ts

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

package/src/parsing/operations/call.ts

@@ -1,69 +0,0 @@
-import Expression from "../expressions/expression";
-import ExpressionMap from "../expressions/expression_map";
-import AsyncFunction from "../functions/async_function";
-import Projection from "./projection";
-
-const DEFAULT_VARIABLE_NAME: string = "value";
-
-class Call extends Projection {
-    protected _function: AsyncFunction | null = null;
-    private _map: ExpressionMap = new ExpressionMap();
-    protected _results: Record<string, any>[] = [];
-    constructor() {
-        super([]);
-    }
-    public set function(asyncFunction: AsyncFunction) {
-        this._function = asyncFunction;
-    }
-    public get function(): AsyncFunction | null {
-        return this._function;
-    }
-    public set yielded(expressions: Expression[]) {
-        this.children = expressions;
-        this._map.map = expressions;
-    }
-    public get hasYield(): boolean {
-        return this.children.length > 0;
-    }
-    public async run(): Promise<void> {
-        if (this._function === null) {
-            throw new Error("No function set for Call operation.");
-        }
-        const args = this._function.getArguments();
-        for await (const item of this._function.generate(...args)) {
-            if (!this.isLast) {
-                if (typeof item == "object" && !Array.isArray(item)) {
-                    for (const [key, value] of Object.entries(item)) {
-                        const expression = this._map.get(key);
-                        if (expression) {
-                            expression.overridden = value;
-                        }
-                    }
-                } else {
-                    const expression = this._map.get(DEFAULT_VARIABLE_NAME);
-                    if (expression) {
-                        expression.overridden = item;
-                    }
-                }
-                await this.next?.run();
-            } else {
-                const record: Map<string, any> = new Map();
-                if (typeof item == "object" && !Array.isArray(item)) {
-                    for (const [key, value] of Object.entries(item)) {
-                        if (this._map.has(key) || !this.hasYield) {
-                            record.set(key, value);
-                        }
-                    }
-                } else {
-                    record.set(DEFAULT_VARIABLE_NAME, item);
-                }
-                this._results.push(Object.fromEntries(record));
-            }
-        }
-    }
-    public get results(): Record<string, any>[] {
-        return this._results;
-    }
-}
-
-export default Call;

package/src/parsing/operations/create_node.ts

@@ -1,39 +0,0 @@
-import Database from "../../graph/database";
-import Node from "../../graph/node";
-import ASTNode from "../ast_node";
-import Operation from "./operation";
-
-class CreateNode extends Operation {
-    private _node: Node | null = null;
-    private _statement: ASTNode | null = null;
-    constructor(node: Node, statement: ASTNode) {
-        super();
-        this._node = node;
-        this._statement = statement;
-    }
-    public get node(): Node | null {
-        return this._node;
-    }
-    public get statement(): ASTNode | null {
-        return this._statement;
-    }
-    public run(): Promise<void> {
-        return new Promise(async (resolve, reject) => {
-            try {
-                if (this._node === null) {
-                    throw new Error("Node is null");
-                }
-                const db: Database = Database.getInstance();
-                db.addNode(this._node, this._statement!);
-                resolve();
-            } catch (error) {
-                reject(error);
-            }
-        });
-    }
-    public get results(): Record<string, any>[] {
-        return [];
-    }
-}
-
-export default CreateNode;

package/src/parsing/operations/create_relationship.ts

@@ -1,38 +0,0 @@
-import Database from "../../graph/database";
-import Relationship from "../../graph/relationship";
-import ASTNode from "../ast_node";
-import Operation from "./operation";
-
-class CreateRelationship extends Operation {
-    private _relationship: Relationship | null = null;
-    private _statement: ASTNode | null = null;
-    constructor(relationship: Relationship, statement: ASTNode) {
-        super();
-        this._relationship = relationship;
-        this._statement = statement;
-    }
-    public get relationship(): Relationship | null {
-        return this._relationship;
-    }
-    public get statement(): ASTNode | null {
-        return this._statement;
-    }
-    public run(): Promise<void> {
-        return new Promise(async (resolve, reject) => {
-            try {
-                if (this._relationship === null) {
-                    throw new Error("Relationship is null");
-                }
-                const db = Database.getInstance();
-                db.addRelationship(this._relationship, this._statement!);
-                resolve();
-            } catch (error) {
-                reject(error);
-            }
-        });
-    }
-    public get results(): Record<string, any>[] {
-        return [];
-    }
-}
-export default CreateRelationship;

package/src/parsing/operations/delete_node.ts

@@ -1,33 +0,0 @@
-import Database from "../../graph/database";
-import Node from "../../graph/node";
-import Operation from "./operation";
-
-class DeleteNode extends Operation {
-    private _node: Node | null = null;
-    constructor(node: Node) {
-        super();
-        this._node = node;
-    }
-    public get node(): Node | null {
-        return this._node;
-    }
-    public run(): Promise<void> {
-        return new Promise(async (resolve, reject) => {
-            try {
-                if (this._node === null) {
-                    throw new Error("Node is null");
-                }
-                const db: Database = Database.getInstance();
-                db.removeNode(this._node);
-                resolve();
-            } catch (error) {
-                reject(error);
-            }
-        });
-    }
-    public get results(): Record<string, any>[] {
-        return [];
-    }
-}
-
-export default DeleteNode;

package/src/parsing/operations/delete_relationship.ts

@@ -1,32 +0,0 @@
-import Database from "../../graph/database";
-import Relationship from "../../graph/relationship";
-import Operation from "./operation";
-
-class DeleteRelationship extends Operation {
-    private _relationship: Relationship | null = null;
-    constructor(relationship: Relationship) {
-        super();
-        this._relationship = relationship;
-    }
-    public get relationship(): Relationship | null {
-        return this._relationship;
-    }
-    public run(): Promise<void> {
-        return new Promise(async (resolve, reject) => {
-            try {
-                if (this._relationship === null) {
-                    throw new Error("Relationship is null");
-                }
-                const db = Database.getInstance();
-                db.removeRelationship(this._relationship);
-                resolve();
-            } catch (error) {
-                reject(error);
-            }
-        });
-    }
-    public get results(): Record<string, any>[] {
-        return [];
-    }
-}
-export default DeleteRelationship;

package/src/parsing/operations/group_by.ts

@@ -1,137 +0,0 @@
-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();
-            const key: string =
-                typeof value === "object" && value !== null ? JSON.stringify(value) : String(value);
-            let child: Node | undefined = node.children.get(key);
-            if (child === undefined) {
-                child = new Node(value);
-                node.children.set(key, 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 (mapperIndex === 0 && node.children.size === 0 && this.mappers.length > 0) {
-            return;
-        }
-        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 {
-            if (node.elements === null) {
-                node.elements = this.reducers.map((reducer) => reducer.element());
-            }
-            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

@@ -1,31 +0,0 @@
-import Operation from "./operation";
-
-class Limit extends Operation {
-    private count: number = 0;
-    private limit: number = 0;
-    constructor(limit: number) {
-        super();
-        this.limit = limit;
-    }
-    public get isLimitReached(): boolean {
-        return this.count >= this.limit;
-    }
-    public get limitValue(): number {
-        return this.limit;
-    }
-    public increment(): void {
-        this.count++;
-    }
-    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

@@ -1,146 +0,0 @@
-import CSV from "../components/csv";
-import From from "../components/from";
-import Headers from "../components/headers";
-import { default as _JSON } from "../components/json";
-import Post from "../components/post";
-import Text from "../components/text";
-import AssociativeArray from "../data_structures/associative_array";
-import Lookup from "../data_structures/lookup";
-import Expression from "../expressions/expression";
-import Reference from "../expressions/reference";
-import AsyncFunction from "../functions/async_function";
-import Function from "../functions/function";
-import Operation from "./operation";
-
-class Load extends Operation {
-    private _value: any = null;
-
-    constructor() {
-        super();
-    }
-    public get type(): _JSON | CSV | Text {
-        return this.children[0] as _JSON | CSV | Text;
-    }
-
-    /**
-     * Gets the From component which contains either a URL expression or an AsyncFunction.
-     */
-    public get fromComponent(): From {
-        return this.children[1] as From;
-    }
-
-    /**
-     * Checks if the data source is an async function.
-     */
-    public get isAsyncFunction(): boolean {
-        return this.fromComponent.firstChild() instanceof AsyncFunction;
-    }
-
-    /**
-     * Gets the async function if the source is a function, otherwise null.
-     */
-    public get asyncFunction(): AsyncFunction | null {
-        const child = this.fromComponent.firstChild();
-        return child instanceof AsyncFunction ? child : null;
-    }
-
-    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()) } : {}),
-        };
-    }
-
-    /**
-     * Loads data from an async function source.
-     * Arguments from the query (e.g., myFunc(arg1, arg2)) are passed to generate().
-     */
-    private async loadFromFunction(): Promise<void> {
-        const asyncFunc = this.asyncFunction!;
-        const args = asyncFunc.getArguments();
-        for await (const item of asyncFunc.generate(...args)) {
-            this._value = item;
-            await this.next?.run();
-        }
-    }
-
-    /**
-     * Loads data from a URL source (original behavior).
-     */
-    private async loadFromUrl(): Promise<void> {
-        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 load(): Promise<any> {
-        if (this.isAsyncFunction) {
-            await this.loadFromFunction();
-        } else {
-            await this.loadFromUrl();
-        }
-    }
-    public async run(): Promise<void> {
-        try {
-            await this.load();
-        } catch (e) {
-            const source = this.isAsyncFunction ? this.asyncFunction?.name : this.from;
-            throw new Error(`Failed to load data from ${source}. Error: ${e}`);
-        }
-    }
-    public value(): any {
-        return this._value;
-    }
-}
-
-export default Load;