flowquery 1.0.16 → 1.0.17

package/src/graph/database.ts

@@ -0,0 +1,63 @@
+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 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;
+        Database.relationships.set(relationship.type, physical);
+    }
+    public getRelationship(relationship: Relationship): PhysicalRelationship | null {
+        return Database.relationships.get(relationship.type!) || null;
+    }
+    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) {
+            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

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

@@ -0,0 +1,99 @@
+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 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()!);
+            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);
+            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

@@ -0,0 +1,18 @@
+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);
+    }
+    public current(hop: number = 0): NodeRecord | null {
+        return super.current(hop) as NodeRecord | null;
+    }
+}
+
+export default NodeData;

package/src/graph/node_reference.ts

@@ -0,0 +1,33 @@
+import Node from "./node";
+
+class NodeReference extends Node {
+    private _reference: Node | null = null;
+    constructor(base: Node, reference: Node) {
+        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(): Node | null {
+        return this._reference;
+    }
+    public async next(): Promise<void> {
+        this.setValue(this._reference!.value()!);
+        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

@@ -0,0 +1,101 @@
+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 (const element of this._chain) {
+            if (element instanceof Node) {
+                yield element.value();
+            } else if (element instanceof Relationship) {
+                let i = 0;
+                for (const match of element.matches) {
+                    yield match;
+                    if (i < element.matches.length - 1) {
+                        yield match.endNode;
+                    }
+                    i++;
+                }
+            }
+        }
+    }
+    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

@@ -0,0 +1,37 @@
+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 {
+        if (this._chain.length == 0 && !(element instanceof NodeReference)) {
+            throw new Error("PatternExpression must start with a NodeReference");
+        }
+        super.addElement(element);
+    }
+    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

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

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

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

package/src/graph/relationship.ts

@@ -0,0 +1,116 @@
+import ASTNode from "../parsing/ast_node";
+import Expression from "../parsing/expressions/expression";
+import Hops from "./hops";
+import Node from "./node";
+import RelationshipData, { RelationshipRecord } from "./relationship_data";
+import RelationshipMatchCollector, {
+    RelationshipMatchRecord,
+} from "./relationship_match_collector";
+
+class Relationship extends ASTNode {
+    protected _identifier: string | null = null;
+    protected _type: string | null = null;
+    protected _properties: Map<string, Expression> = new Map();
+    protected _hops: Hops = new Hops();
+
+    protected _value: RelationshipMatchRecord | RelationshipMatchRecord[] | null = null;
+    protected _matches: RelationshipMatchCollector = new RelationshipMatchCollector();
+
+    protected _source: Node | null = null;
+    protected _target: Node | null = null;
+
+    private _data: RelationshipData | null = null;
+
+    constructor(identifier: string | null = null, type: string | null = null) {
+        super();
+        this._identifier = identifier;
+        this._type = type;
+    }
+    public set identifier(identifier: string) {
+        this._identifier = identifier;
+    }
+    public get identifier(): string | null {
+        return this._identifier;
+    }
+    public set type(type: string) {
+        this._type = type;
+    }
+    public get type(): string | null {
+        return this._type;
+    }
+    public get properties(): Record<string, any> {
+        return this._data?.properties() || {};
+    }
+    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 set hops(hops: Hops) {
+        this._hops = hops;
+    }
+    public get hops(): Hops | null {
+        return this._hops;
+    }
+    public setValue(relationship: Relationship): void {
+        const match: RelationshipMatchRecord = this._matches.push(relationship);
+        this._value = this._matches.value();
+    }
+    public set source(node: Node | null) {
+        this._source = node;
+    }
+    public get source(): Node | null {
+        return this._source;
+    }
+    public set target(node: Node | null) {
+        this._target = node;
+    }
+    public get target(): Node | null {
+        return this._target;
+    }
+    public value(): RelationshipMatchRecord | RelationshipMatchRecord[] | null {
+        return this._value;
+    }
+    public get matches(): RelationshipMatchRecord[] {
+        return this._matches.matches;
+    }
+    public setData(data: RelationshipData | null): void {
+        this._data = data;
+    }
+    public getData(): RelationshipData | null {
+        return this._data;
+    }
+    public setEndNode(node: Node): void {
+        this._matches.endNode = node;
+    }
+    public async find(left_id: string, hop: number = 0): Promise<void> {
+        // Save original source node
+        const original = this._source;
+        if (hop > 0) {
+            // For hops greater than 0, the source becomes the target of the previous hop
+            this._source = this._target;
+        }
+        if (hop === 0) {
+            this._data?.reset();
+        }
+        while (this._data?.find(left_id, hop)) {
+            const data: RelationshipRecord = this._data?.current(hop) as RelationshipRecord;
+            if (hop >= this.hops!.min) {
+                this.setValue(this);
+                await this._target?.find(data.right_id, hop);
+                if (this._matches.isCircular()) {
+                    throw new Error("Circular relationship detected");
+                }
+                if (hop + 1 < this.hops!.max) {
+                    await this.find(data.right_id, hop + 1);
+                }
+                this._matches.pop();
+            }
+        }
+        // Restore original source node
+        this._source = original;
+    }
+}
+
+export default Relationship;

package/src/graph/relationship_data.ts

@@ -0,0 +1,27 @@
+import Data from "./data";
+
+export type RelationshipRecord = { left_id: string; right_id: string } & Record<string, any>;
+
+class RelationshipData extends Data {
+    constructor(records: RelationshipRecord[] = []) {
+        super(records);
+        super._buildIndex("left_id");
+    }
+    public find(left_id: string, hop: number = 0): boolean {
+        return super._find(left_id, hop);
+    }
+    /*
+    ** Get the properties of the current relationship record
+    '' excluding the left_id and right_id fields
+    */
+    public properties(): Record<string, any> | null {
+        const current = this.current();
+        if (current) {
+            const { left_id, right_id, ...props } = current;
+            return props;
+        }
+        return null;
+    }
+}
+
+export default RelationshipData;

package/src/graph/relationship_match_collector.ts

@@ -0,0 +1,58 @@
+import Relationship from "./relationship";
+
+export type RelationshipMatchRecord = {
+    type: string;
+    startNode: Record<string, any>;
+    endNode: Record<string, any> | null;
+    properties: Record<string, any>;
+};
+
+class RelationshipMatchCollector {
+    private _matches: RelationshipMatchRecord[] = [];
+    private _nodeIds: Array<string> = [];
+
+    public push(relationship: Relationship): RelationshipMatchRecord {
+        const match: RelationshipMatchRecord = {
+            type: relationship.type!,
+            startNode: relationship.source?.value() || {},
+            endNode: null,
+            properties: relationship.properties,
+        };
+        this._matches.push(match);
+        this._nodeIds.push(match.startNode.id);
+        return match;
+    }
+    public set endNode(node: any) {
+        if (this._matches.length > 0) {
+            this._matches[this._matches.length - 1].endNode = node.value();
+        }
+    }
+    public pop(): RelationshipMatchRecord | undefined {
+        this._nodeIds.pop();
+        return this._matches.pop();
+    }
+    public value(): RelationshipMatchRecord | RelationshipMatchRecord[] | null {
+        if (this._matches.length === 0) {
+            return null;
+        } else if (this._matches.length === 1) {
+            const _match = this._matches[0];
+            return _match;
+        } else {
+            const _matches = this._matches;
+            return _matches;
+        }
+    }
+    public get matches(): RelationshipMatchRecord[] {
+        return this._matches;
+    }
+    /*
+     ** Checks if the collected relationships form a circular pattern
+     ** meaning the same node id occur more than 2 times in the collected matches
+     */
+    public isCircular(): boolean {
+        const seen = new Set(this._nodeIds);
+        return seen.size < this._nodeIds.length;
+    }
+}
+
+export default RelationshipMatchCollector;

package/src/graph/relationship_reference.ts

@@ -0,0 +1,24 @@
+import Relationship from "./relationship";
+import { RelationshipRecord } from "./relationship_data";
+
+class RelationshipReference extends Relationship {
+    private _reference: Relationship | null = null;
+    constructor(base: Relationship, reference: Relationship) {
+        super();
+        this._identifier = base.identifier;
+        this._type = base.type;
+        this._hops = base.hops!;
+        this._source = base.source;
+        this._target = base.target;
+        this._reference = reference;
+    }
+    public async find(left_id: string, hop: number = 0): Promise<void> {
+        this.setValue(this._reference!);
+        const data: RelationshipRecord = this._reference!.getData()?.current(
+            hop
+        ) as RelationshipRecord;
+        await this._target?.find(data.right_id, hop);
+    }
+}
+
+export default RelationshipReference;