flowquery 1.0.46 → 1.0.48

package/src/graph/database.ts

@@ -1,143 +0,0 @@
-import ASTNode from "../parsing/ast_node";
-import Node from "./node";
-import NodeData, { NodeRecord } from "./node_data";
-import PhysicalNode from "./physical_node";
-import PhysicalRelationship from "./physical_relationship";
-import Relationship from "./relationship";
-import RelationshipData, { RelationshipRecord } from "./relationship_data";
-
-class Database {
-    private static instance: Database;
-    private static nodes: Map<string, PhysicalNode> = new Map();
-    private static relationships: Map<string, PhysicalRelationship> = new Map();
-
-    public static getInstance(): Database {
-        if (!Database.instance) {
-            Database.instance = new Database();
-        }
-        return Database.instance;
-    }
-    public addNode(node: Node, statement: ASTNode): void {
-        if (node.label === null) {
-            throw new Error("Node label is null");
-        }
-        const physical = new PhysicalNode(null, node.label);
-        physical.statement = statement;
-        Database.nodes.set(node.label, physical);
-    }
-    public removeNode(node: Node): void {
-        if (node.label === null) {
-            throw new Error("Node label is null");
-        }
-        Database.nodes.delete(node.label);
-    }
-    public getNode(node: Node): PhysicalNode | null {
-        return Database.nodes.get(node.label!) || null;
-    }
-    public addRelationship(relationship: Relationship, statement: ASTNode): void {
-        if (relationship.type === null) {
-            throw new Error("Relationship type is null");
-        }
-        const physical = new PhysicalRelationship(null, relationship.type);
-        physical.statement = statement;
-        physical.source = relationship.source;
-        physical.target = relationship.target;
-        Database.relationships.set(relationship.type, physical);
-    }
-    public removeRelationship(relationship: Relationship): void {
-        if (relationship.type === null) {
-            throw new Error("Relationship type is null");
-        }
-        Database.relationships.delete(relationship.type);
-    }
-    public getRelationship(relationship: Relationship): PhysicalRelationship | null {
-        return Database.relationships.get(relationship.type!) || null;
-    }
-    public getRelationships(relationship: Relationship): PhysicalRelationship[] {
-        const result: PhysicalRelationship[] = [];
-        for (const type of relationship.types) {
-            const physical = Database.relationships.get(type);
-            if (physical) {
-                result.push(physical);
-            }
-        }
-        return result;
-    }
-    public async schema(): Promise<Record<string, any>[]> {
-        const result: Record<string, any>[] = [];
-
-        for (const [label, physical] of Database.nodes) {
-            const records = await physical.data();
-            const entry: Record<string, any> = { kind: "Node", label };
-            if (records.length > 0) {
-                const { id, ...sample } = records[0];
-                const properties = Object.keys(sample);
-                if (properties.length > 0) {
-                    entry.properties = properties;
-                    entry.sample = sample;
-                }
-            }
-            result.push(entry);
-        }
-
-        for (const [type, physical] of Database.relationships) {
-            const records = await physical.data();
-            const entry: Record<string, any> = {
-                kind: "Relationship",
-                type,
-                from_label: physical.source?.label || null,
-                to_label: physical.target?.label || null,
-            };
-            if (records.length > 0) {
-                const { left_id, right_id, ...sample } = records[0];
-                const properties = Object.keys(sample);
-                if (properties.length > 0) {
-                    entry.properties = properties;
-                    entry.sample = sample;
-                }
-            }
-            result.push(entry);
-        }
-
-        return result;
-    }
-
-    public async getData(element: Node | Relationship): Promise<NodeData | RelationshipData> {
-        if (element instanceof Node) {
-            const node = this.getNode(element);
-            if (node === null) {
-                throw new Error(`Physical node not found for label ${element.label}`);
-            }
-            const data = await node.data();
-            return new NodeData(data as NodeRecord[]);
-        } else if (element instanceof Relationship) {
-            if (element.types.length > 1) {
-                const physicals = this.getRelationships(element);
-                if (physicals.length === 0) {
-                    throw new Error(
-                        `No physical relationships found for types ${element.types.join(", ")}`
-                    );
-                }
-                const allRecords: RelationshipRecord[] = [];
-                for (let i = 0; i < physicals.length; i++) {
-                    const records = (await physicals[i].data()) as RelationshipRecord[];
-                    const typeName = element.types[i];
-                    for (const record of records) {
-                        allRecords.push({ ...record, _type: typeName });
-                    }
-                }
-                return new RelationshipData(allRecords);
-            }
-            const relationship = this.getRelationship(element);
-            if (relationship === null) {
-                throw new Error(`Physical relationship not found for type ${element.type}`);
-            }
-            const data = await relationship.data();
-            return new RelationshipData(data as RelationshipRecord[]);
-        } else {
-            throw new Error("Element is neither Node nor Relationship");
-        }
-    }
-}
-
-export default Database;

package/src/graph/hops.ts

@@ -1,22 +0,0 @@
-class Hops {
-    private _min: number = 0;
-    private _max: number = 1;
-
-    public set min(min: number) {
-        this._min = min;
-    }
-    public get min(): number {
-        return this._min;
-    }
-    public set max(max: number) {
-        this._max = max;
-    }
-    public get max(): number {
-        return this._max;
-    }
-    public multi(): boolean {
-        return this._max > 1 || this._max === -1;
-    }
-}
-
-export default Hops;

package/src/graph/node.ts

@@ -1,122 +0,0 @@
-import ASTNode from "../parsing/ast_node";
-import Expression from "../parsing/expressions/expression";
-import NodeData, { NodeRecord } from "./node_data";
-import Relationship from "./relationship";
-
-class Node extends ASTNode {
-    protected _identifier: string | null = null;
-    protected _label: string | null = null;
-    protected _properties: Map<string, Expression> = new Map();
-    protected _value: NodeRecord | null = null;
-
-    protected _incoming: Relationship | null = null;
-    protected _outgoing: Relationship | null = null;
-
-    private _data: NodeData | null = null;
-
-    // Function to be called after each 'next' and 'find' operation
-    // It is used to chain operations in a traversal
-    // For example, after matching on a graph pattern, we may want to
-    // continue to the next node or relationship in the pattern, or
-    // perform the next operation in a statement.
-    private _todoNext: (() => Promise<void>) | null = null;
-
-    constructor(identifier: string | null = null, label: string | null = null) {
-        super();
-        this._identifier = identifier;
-        this._label = label;
-    }
-    public set identifier(identifier: string) {
-        this._identifier = identifier;
-    }
-    public get identifier(): string | null {
-        return this._identifier;
-    }
-    public set label(label: string) {
-        this._label = label;
-    }
-    public get label(): string | null {
-        return this._label;
-    }
-    public get properties(): Map<string, Expression> {
-        return this._properties;
-    }
-    public set properties(properties: Map<string, Expression>) {
-        this._properties = properties;
-    }
-    private _matchesProperties(hop: number = 0): boolean {
-        const data: NodeData = this._data!;
-        for (const [key, expression] of this._properties) {
-            const record: NodeRecord = data.current(hop)!;
-            if (record === null) {
-                throw new Error("No current node data available");
-            }
-            if (!(key in record)) {
-                throw new Error("Node does not have property");
-            }
-            return record[key] === expression.value();
-        }
-        return true;
-    }
-    public setProperty(key: string, value: Expression): void {
-        this._properties.set(key, value);
-    }
-    public getProperty(key: string): Expression | null {
-        return this._properties.get(key) || null;
-    }
-    public setValue(value: NodeRecord): void {
-        this._value = value;
-    }
-    public value(): NodeRecord | null {
-        return this._value;
-    }
-    public set outgoing(relationship: Relationship | null) {
-        this._outgoing = relationship;
-    }
-    public get outgoing(): Relationship | null {
-        return this._outgoing;
-    }
-    public set incoming(relationship: Relationship | null) {
-        this._incoming = relationship;
-    }
-    public get incoming(): Relationship | null {
-        return this._incoming;
-    }
-    public setData(data: NodeData | null): void {
-        this._data = data;
-    }
-    public async next(): Promise<void> {
-        this._data?.reset();
-        while (this._data?.next()) {
-            this.setValue(this._data?.current()!);
-            if (!this._matchesProperties()) {
-                continue;
-            }
-            await this._outgoing?.find(this._value!.id);
-            await this.runTodoNext();
-        }
-    }
-    public async find(id: string, hop: number = 0): Promise<void> {
-        this._data?.reset();
-        while (this._data?.find(id, hop)) {
-            this.setValue(this._data?.current(hop) as NodeRecord);
-            if (!this._matchesProperties(hop)) {
-                continue;
-            }
-            this._incoming?.setEndNode(this);
-            await this._outgoing?.find(this._value!.id, hop);
-            await this.runTodoNext();
-        }
-    }
-    // For setting a function to be called after each 'next' and 'find' operation
-    public set todoNext(func: (() => Promise<void>) | null) {
-        this._todoNext = func;
-    }
-    public async runTodoNext(): Promise<void> {
-        if (this._todoNext) {
-            await this._todoNext();
-        }
-    }
-}
-
-export default Node;

package/src/graph/node_data.ts

@@ -1,18 +0,0 @@
-import Data from "./data";
-
-export type NodeRecord = { id: string } & Record<string, any>;
-
-class NodeData extends Data {
-    constructor(records: NodeRecord[] = []) {
-        super(records);
-        super._buildIndex("id");
-    }
-    public find(id: string, hop: number = 0): boolean {
-        return super._find(id, hop, "id");
-    }
-    public current(hop: number = 0): NodeRecord | null {
-        return super.current(hop) as NodeRecord | null;
-    }
-}
-
-export default NodeData;

package/src/graph/node_reference.ts

@@ -1,38 +0,0 @@
-import ASTNode from "../parsing/ast_node";
-import Node from "./node";
-
-class NodeReference extends Node {
-    private _reference: ASTNode | null = null;
-    constructor(base: Node, reference: ASTNode) {
-        super();
-        this._identifier = base.identifier;
-        this._label = base.label;
-        this._properties = base.properties;
-        this._outgoing = base.outgoing;
-        this._incoming = base.incoming;
-        this._reference = reference;
-    }
-    public get reference(): ASTNode | null {
-        return this._reference;
-    }
-    public async next(): Promise<void> {
-        const referenced = this._reference?.value();
-        if (referenced == null) {
-            return;
-        }
-        this.setValue(referenced);
-        await this._outgoing?.find(this._value!.id);
-        await this.runTodoNext();
-    }
-    public async find(id: string, hop: number = 0): Promise<void> {
-        const referenced = this._reference?.value();
-        if (id !== referenced?.id) {
-            return;
-        }
-        this.setValue(referenced!);
-        await this._outgoing?.find(this._value!.id, hop);
-        await this.runTodoNext();
-    }
-}
-
-export default NodeReference;

package/src/graph/pattern.ts

@@ -1,110 +0,0 @@
-import ASTNode from "../parsing/ast_node";
-import Database from "./database";
-import Node from "./node";
-import NodeData from "./node_data";
-import NodeReference from "./node_reference";
-import Relationship from "./relationship";
-import RelationshipData from "./relationship_data";
-import RelationshipReference from "./relationship_reference";
-
-class Pattern extends ASTNode {
-    private _identifier: string | null = null;
-    protected _chain: (Node | Relationship)[] = [];
-    public set identifier(id: string | null) {
-        this._identifier = id;
-    }
-    public get identifier(): string | null {
-        return this._identifier;
-    }
-    public addElement(element: Relationship | Node): void {
-        if (
-            this._chain.length > 0 &&
-            this._chain[this._chain.length - 1].constructor === element.constructor
-        ) {
-            throw new Error(
-                "Cannot add two consecutive elements of the same type to the graph pattern"
-            );
-        }
-        if (this._chain.length > 0) {
-            const last = this._chain[this._chain.length - 1];
-            if (last instanceof Node && element instanceof Relationship) {
-                last.outgoing = element as Relationship;
-                element.source = last as Node;
-            }
-            if (last instanceof Relationship && element instanceof Node) {
-                last.target = element as Node;
-                element.incoming = last as Relationship;
-            }
-        }
-        this._chain.push(element);
-    }
-    public get chain(): (Node | Relationship)[] {
-        return this._chain;
-    }
-    public get startNode(): Node {
-        if (this._chain.length === 0) {
-            throw new Error("Pattern is empty");
-        }
-        const first = this._chain[0];
-        if (first instanceof Node) {
-            return first;
-        }
-        throw new Error("Pattern does not start with a node");
-    }
-    public get endNode(): Node {
-        if (this._chain.length === 0) {
-            throw new Error("Pattern is empty");
-        }
-        const last = this._chain[this._chain.length - 1];
-        if (last instanceof Node) {
-            return last;
-        }
-        throw new Error("Pattern does not end with a node");
-    }
-    public value(): any {
-        return Array.from(this.values());
-    }
-    public *values(): Generator<any> {
-        for (let i = 0; i < this._chain.length; i++) {
-            const element = this._chain[i];
-            if (element instanceof Node) {
-                // Skip node if previous element was a zero-hop relationship (no matches)
-                if (
-                    i > 0 &&
-                    this._chain[i - 1] instanceof Relationship &&
-                    (this._chain[i - 1] as Relationship).matches.length === 0
-                ) {
-                    continue;
-                }
-                yield element.value();
-            } else if (element instanceof Relationship) {
-                let j = 0;
-                for (const match of element.matches) {
-                    yield match;
-                    if (j < element.matches.length - 1) {
-                        yield match.endNode;
-                    }
-                    j++;
-                }
-            }
-        }
-    }
-    public async fetchData(): Promise<void> {
-        const db: Database = Database.getInstance();
-        for (const element of this._chain) {
-            if (
-                element.constructor === NodeReference ||
-                element.constructor === RelationshipReference
-            ) {
-                continue;
-            }
-            const data = await db.getData(element);
-            if (element.constructor === Node) {
-                element.setData(data as NodeData);
-            } else if (element.constructor === Relationship) {
-                element.setData(data as RelationshipData);
-            }
-        }
-    }
-}
-export default Pattern;

package/src/graph/pattern_expression.ts

@@ -1,48 +0,0 @@
-import Node from "./node";
-import NodeReference from "./node_reference";
-import Pattern from "./pattern";
-import Relationship from "./relationship";
-
-class PatternExpression extends Pattern {
-    private _fetched: boolean = false;
-    private _evaluation: boolean = false;
-    public set identifier(id: string | null) {
-        throw new Error("Cannot set identifier on PatternExpression");
-    }
-    public addElement(element: Relationship | Node): void {
-        super.addElement(element);
-    }
-    public verify(): void {
-        if (this._chain.length === 0) {
-            throw new Error("PatternExpression must contain at least one element");
-        }
-        const referenced = this._chain.some((element) => {
-            if (element instanceof NodeReference) {
-                return true;
-            }
-            return false;
-        });
-        if (!referenced) {
-            throw new Error("PatternExpression must contain at least one NodeReference");
-        }
-    }
-    public async evaluate(): Promise<void> {
-        this._evaluation = false;
-        this.endNode.todoNext = async () => {
-            this._evaluation = true;
-        };
-        await this.startNode.next();
-    }
-    public value(): boolean {
-        return this._evaluation;
-    }
-    public async fetchData(): Promise<void> {
-        if (this._fetched) {
-            return;
-        }
-        await super.fetchData();
-        this._fetched = true;
-    }
-}
-
-export default PatternExpression;

package/src/graph/patterns.ts

@@ -1,36 +0,0 @@
-import Pattern from "./pattern";
-
-class Patterns {
-    private _patterns: Pattern[] = [];
-    constructor(patterns: Pattern[] = []) {
-        this._patterns = patterns;
-    }
-    public get patterns(): Pattern[] {
-        return this._patterns;
-    }
-    public async initialize(): Promise<void> {
-        let previous: Pattern | null = null;
-        for (const pattern of this._patterns) {
-            await pattern.fetchData(); // Ensure data is loaded
-            if (previous !== null) {
-                // Chain the patterns together
-                previous.endNode.todoNext = async () => {
-                    await pattern.startNode.next();
-                };
-            }
-            previous = pattern;
-        }
-    }
-    public set toDoNext(func: () => Promise<void>) {
-        if (this._patterns.length > 0) {
-            this._patterns[this._patterns.length - 1].endNode.todoNext = func;
-        }
-    }
-    public async traverse(): Promise<void> {
-        if (this._patterns.length > 0) {
-            await this._patterns[0].startNode.next();
-        }
-    }
-}
-
-export default Patterns;

package/src/graph/physical_node.ts

@@ -1,23 +0,0 @@
-import Runner from "../compute/runner";
-import ASTNode from "../parsing/ast_node";
-import Node from "./node";
-
-class PhysicalNode extends Node {
-    private _statement: ASTNode | null = null;
-    public set statement(statement: ASTNode | null) {
-        this._statement = statement;
-    }
-    public get statement(): ASTNode | null {
-        return this._statement;
-    }
-    public async data(): Promise<Record<string, any>[]> {
-        if (this._statement === null) {
-            throw new Error("Statement is null");
-        }
-        const runner = new Runner(null, this._statement);
-        await runner.run();
-        return runner.results;
-    }
-}
-
-export default PhysicalNode;

package/src/graph/physical_relationship.ts

@@ -1,23 +0,0 @@
-import Runner from "../compute/runner";
-import ASTNode from "../parsing/ast_node";
-import Relationship from "./relationship";
-
-class PhysicalRelationship extends Relationship {
-    private _statement: ASTNode | null = null;
-    public set statement(statement: ASTNode | null) {
-        this._statement = statement;
-    }
-    public get statement(): ASTNode | null {
-        return this._statement;
-    }
-    public async data(): Promise<Record<string, any>[]> {
-        if (this._statement === null) {
-            throw new Error("Statement is null");
-        }
-        const runner = new Runner(null, this._statement);
-        await runner.run();
-        return runner.results;
-    }
-}
-
-export default PhysicalRelationship;