flowquery 1.0.29 → 1.0.31

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "flowquery",
-  "version": "1.0.29",
+  "version": "1.0.31",
   "description": "A declarative query language for data processing pipelines.",
   "main": "dist/index.node.js",
   "types": "dist/index.node.d.ts",

package/src/graph/node_reference.ts

@@ -1,8 +1,9 @@
+import ASTNode from "../parsing/ast_node";
 import Node from "./node";
 
 class NodeReference extends Node {
-    private _reference: Node | null = null;
-    constructor(base: Node, reference: Node) {
+    private _reference: ASTNode | null = null;
+    constructor(base: Node, reference: ASTNode) {
         super();
         this._identifier = base.identifier;
         this._label = base.label;
@@ -11,7 +12,7 @@ class NodeReference extends Node {
         this._incoming = base.incoming;
         this._reference = reference;
     }
-    public get reference(): Node | null {
+    public get reference(): ASTNode | null {
         return this._reference;
     }
     public async next(): Promise<void> {

package/src/graph/relationship.ts

@@ -71,8 +71,8 @@ class Relationship extends ASTNode {
     public get hops(): Hops | null {
         return this._hops;
     }
-    public setValue(relationship: Relationship): void {
-        const match: RelationshipMatchRecord = this._matches.push(relationship);
+    public setValue(relationship: Relationship, traversalId: string = ""): void {
+        const match: RelationshipMatchRecord = this._matches.push(relationship, traversalId);
         this._value = this._matches.value();
     }
     public set source(node: Node | null) {
@@ -108,10 +108,12 @@ class Relationship extends ASTNode {
     public setEndNode(node: Node): void {
         this._matches.endNode = node;
     }
+    public _left_id_or_right_id(): string {
+        return this._direction === "left" ? "left_id" : "right_id";
+    }
     public async find(left_id: string, hop: number = 0): Promise<void> {
         // Save original source node
         const original = this._source;
-        const isLeft = this._direction === "left";
         if (hop > 0) {
             // For hops greater than 0, the source becomes the target of the previous hop
             this._source = this._target;
@@ -127,28 +129,26 @@ class Relationship extends ASTNode {
                 await this._target.find(left_id, hop);
             }
         }
-        const findMatch = isLeft
-            ? (id: string, h: number) => this._data!.findReverse(id, h)
-            : (id: string, h: number) => this._data!.find(id, h);
-        const followId = isLeft ? "left_id" : "right_id";
-        while (findMatch(left_id, hop)) {
+        while (this._data!.find(left_id, hop, this._direction)) {
             const data: RelationshipRecord = this._data?.current(hop) as RelationshipRecord;
+            const id = data[this._left_id_or_right_id()];
             if (hop + 1 >= this.hops!.min) {
-                this.setValue(this);
+                this.setValue(this, left_id);
                 if (!this._matchesProperties(hop)) {
                     continue;
                 }
-                await this._target?.find(data[followId], hop);
-                if (this._matches.isCircular()) {
-                    throw new Error("Circular relationship detected");
-                }
+                await this._target?.find(id, hop);
                 if (hop + 1 < this.hops!.max) {
-                    await this.find(data[followId], hop + 1);
+                    if (this._matches.isCircular(id)) {
+                        this._matches.pop();
+                        continue;
+                    }
+                    await this.find(id, hop + 1);
                 }
                 this._matches.pop();
             } else {
                 // Below minimum hops: traverse the edge without yielding a match
-                await this.find(data[followId], hop + 1);
+                await this.find(id, hop + 1);
             }
         }
         // Restore original source node

package/src/graph/relationship_data.ts

@@ -8,11 +8,8 @@ class RelationshipData extends Data {
         super._buildIndex("left_id");
         super._buildIndex("right_id");
     }
-    public find(left_id: string, hop: number = 0): boolean {
-        return super._find(left_id, hop, "left_id");
-    }
-    public findReverse(right_id: string, hop: number = 0): boolean {
-        return super._find(right_id, hop, "right_id");
+    public find(id: string, hop: number = 0, direction: "left" | "right" = "right"): boolean {
+        return super._find(id, hop, direction === "left" ? "right_id" : "left_id");
     }
     /*
     ** Get the properties of the current relationship record

package/src/graph/relationship_match_collector.ts

@@ -11,7 +11,7 @@ class RelationshipMatchCollector {
     private _matches: RelationshipMatchRecord[] = [];
     private _nodeIds: Array<string> = [];
 
-    public push(relationship: Relationship): RelationshipMatchRecord {
+    public push(relationship: Relationship, traversalId: string): RelationshipMatchRecord {
         const match: RelationshipMatchRecord = {
             type: relationship.type!,
             startNode: relationship.source?.value() || {},
@@ -19,7 +19,7 @@ class RelationshipMatchCollector {
             properties: relationship.getData()?.properties() as Record<string, any>,
         };
         this._matches.push(match);
-        this._nodeIds.push(match.startNode.id);
+        this._nodeIds.push(traversalId);
         return match;
     }
     public set endNode(node: any) {
@@ -46,12 +46,11 @@ class RelationshipMatchCollector {
         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
+     ** Checks if traversing to the given node id would form a cycle
+     ** in the current traversal path
      */
-    public isCircular(): boolean {
-        const seen = new Set(this._nodeIds);
-        return seen.size < this._nodeIds.length;
+    public isCircular(nextId: string): boolean {
+        return this._nodeIds.includes(nextId);
     }
 }
 

package/src/parsing/parser.ts

@@ -467,7 +467,10 @@ class Parser extends BaseParser {
                     reference = inner;
                 }
             }
-            if (reference === undefined || !(reference instanceof Node)) {
+            if (
+                reference === undefined ||
+                (!(reference instanceof Node) && !(reference instanceof Unwind))
+            ) {
                 throw new Error(`Undefined node reference: ${identifier}`);
             }
             node = new NodeReference(node, reference);
@@ -798,12 +801,7 @@ class Parser extends BaseParser {
                 expression.addNode(lookup);
                 return true;
             }
-        } else if (
-            this.token.isLeftParenthesis() &&
-            (this.peek()?.isIdentifierOrKeyword() ||
-                this.peek()?.isColon() ||
-                this.peek()?.isRightParenthesis())
-        ) {
+        } else if (this.token.isLeftParenthesis() && this.looksLikeNodePattern()) {
             // Possible graph pattern expression
             const pattern = this.parsePatternExpression();
             if (pattern !== null) {
@@ -865,6 +863,42 @@ class Parser extends BaseParser {
         return false;
     }
 
+    /**
+     * Peeks ahead from a left parenthesis to determine whether the
+     * upcoming tokens form a graph-node pattern (e.g. (n:Label), (n),
+     * (:Label), ()) rather than a parenthesised expression (e.g.
+     * (variable.property), (a + b)).
+     *
+     * The heuristic is:
+     *   • ( followed by `:` or `)` → node pattern
+     *   • ( identifier, then `:` or `{` or `)` → node pattern
+     *   • anything else → parenthesised expression
+     */
+    private looksLikeNodePattern(): boolean {
+        const savedIndex = this.tokenIndex;
+        this.setNextToken(); // skip '('
+        this.skipWhitespaceAndComments();
+
+        if (this.token.isColon() || this.token.isRightParenthesis()) {
+            this.tokenIndex = savedIndex;
+            return true;
+        }
+
+        if (this.token.isIdentifierOrKeyword()) {
+            this.setNextToken(); // skip identifier
+            this.skipWhitespaceAndComments();
+            const result =
+                this.token.isColon() ||
+                this.token.isOpeningBrace() ||
+                this.token.isRightParenthesis();
+            this.tokenIndex = savedIndex;
+            return result;
+        }
+
+        this.tokenIndex = savedIndex;
+        return false;
+    }
+
     private parseExpression(): Expression | null {
         const expression = new Expression();
         while (true) {

package/tests/compute/runner.test.ts

@@ -1138,7 +1138,7 @@ test("Test circular graph pattern", async () => {
     expect(results[0].pattern[4].id).toBe(1);
 });
 
-test("Test circular graph pattern with variable length should throw error", async () => {
+test("Test circular graph pattern with variable length should not revisit nodes", async () => {
     await new Runner(`
         CREATE VIRTUAL (:Person) AS {
             unwind [
@@ -1161,9 +1161,10 @@ test("Test circular graph pattern with variable length should throw error", asyn
         MATCH p=(:Person)-[:KNOWS*]-(:Person)
         RETURN p AS pattern
     `);
-    await expect(async () => {
-        await match.run();
-    }).rejects.toThrow("Circular relationship detected");
+    await match.run();
+    const results = match.results;
+    // Circular graph 1↔2: cycles are skipped, only acyclic paths are returned
+    expect(results.length).toBe(6);
 });
 
 test("Test multi-hop match with min hops constraint *1..", async () => {
@@ -2064,3 +2065,107 @@ test("Test WHERE with CONTAINS combined with AND", async () => {
     expect(results.length).toBe(1);
     expect(results[0].fruit).toBe("pineapple");
 });
+
+test("Test collected nodes and re-matching", async () => {
+    await new Runner(`
+        CREATE VIRTUAL (:Person) AS {
+            unwind [
+                {id: 1, name: 'Person 1'},
+                {id: 2, name: 'Person 2'},
+                {id: 3, name: 'Person 3'},
+                {id: 4, name: 'Person 4'}
+            ] as record
+            RETURN record.id as id, record.name as name
+        }
+    `).run();
+    await new Runner(`
+        CREATE VIRTUAL (:Person)-[:KNOWS]-(:Person) AS {
+            unwind [
+                {left_id: 1, right_id: 2},
+                {left_id: 2, right_id: 3},
+                {left_id: 3, right_id: 4}
+            ] as record
+            RETURN record.left_id as left_id, record.right_id as right_id
+        }
+    `).run();
+    const match = new Runner(`
+        MATCH (a:Person)-[:KNOWS*0..3]->(b:Person)
+        WITH collect(a) AS persons, b
+        UNWIND persons AS p
+        match (p)-[:KNOWS]->(:Person)
+        return p.name AS name
+    `);
+    await match.run();
+    const results = match.results;
+    expect(results.length).toBe(9);
+    const names = results.map((r: any) => r.name);
+    expect(names).toContain("Person 1");
+    expect(names).toContain("Person 2");
+    expect(names).toContain("Person 3");
+});
+
+test("Test collected patterns and unwind", async () => {
+    await new Runner(`
+        CREATE VIRTUAL (:Person) AS {
+            unwind [
+                {id: 1, name: 'Person 1'},
+                {id: 2, name: 'Person 2'},
+                {id: 3, name: 'Person 3'},
+                {id: 4, name: 'Person 4'}
+            ] as record
+            RETURN record.id as id, record.name as name
+        }
+    `).run();
+    await new Runner(`
+        CREATE VIRTUAL (:Person)-[:KNOWS]-(:Person) AS {
+            unwind [
+                {left_id: 1, right_id: 2},
+                {left_id: 2, right_id: 3},
+                {left_id: 3, right_id: 4}
+            ] as record
+            RETURN record.left_id as left_id, record.right_id as right_id
+        }
+    `).run();
+    const match = new Runner(`
+        MATCH p=(a:Person)-[:KNOWS*0..3]->(b:Person)
+        WITH collect(p) AS patterns
+        UNWIND patterns AS pattern
+        RETURN pattern
+    `);
+    await match.run();
+    const results = match.results;
+    expect(results.length).toBe(10);
+    // Index 0: Person 1 zero-hop - pattern = [node1] (single node)
+    expect(results[0].pattern.length).toBe(1);
+    expect(results[0].pattern[0].id).toBe(1);
+
+    // Index 1: Person 1 -> Person 2 (1-hop)
+    expect(results[1].pattern.length).toBe(3);
+
+    // Index 2: Person 1 -> Person 2 -> Person 3 (2-hop)
+    expect(results[2].pattern.length).toBe(5);
+
+    // Index 3: Person 1 -> Person 2 -> Person 3 -> Person 4 (3-hop)
+    expect(results[3].pattern.length).toBe(7);
+
+    // Index 4: Person 2 zero-hop - pattern = [node2]
+    expect(results[4].pattern.length).toBe(1);
+    expect(results[4].pattern[0].id).toBe(2);
+
+    // Index 5: Person 2 -> Person 3 (1-hop)
+    expect(results[5].pattern.length).toBe(3);
+
+    // Index 6: Person 2 -> Person 3 -> Person 4 (2-hop)
+    expect(results[6].pattern.length).toBe(5);
+
+    // Index 7: Person 3 zero-hop - pattern = [node3]
+    expect(results[7].pattern.length).toBe(1);
+    expect(results[7].pattern[0].id).toBe(3);
+
+    // Index 8: Person 3 -> Person 4 (1-hop)
+    expect(results[8].pattern.length).toBe(3);
+
+    // Index 9: Person 4 zero-hop - pattern = [node4]
+    expect(results[9].pattern.length).toBe(1);
+    expect(results[9].pattern[0].id).toBe(4);
+});

package/tests/parsing/parser.test.ts

@@ -839,7 +839,7 @@ test("Parse statement with graph pattern in where clause", () => {
     const source = pattern.chain[0] as NodeReference;
     const relationship = pattern.chain[1] as Relationship;
     const target = pattern.chain[2] as Node;
-    expect(source.reference?.identifier).toBe("a");
+    expect((source.reference as Node)?.identifier).toBe("a");
     expect(relationship.type).toBe("KNOWS");
     expect(target.label).toBe("Person");
 });
@@ -909,7 +909,7 @@ test("Test node reference with label creates NodeReference instead of new node",
     expect(firstNode.identifier).toBe("n");
     expect(firstNode.label).toBe("Person");
     expect(secondNode).toBeInstanceOf(NodeReference);
-    expect(secondNode.reference!.identifier).toBe("n");
+    expect((secondNode.reference! as Node).identifier).toBe("n");
     expect(secondNode.label).toBe("Person");
 });
 
@@ -1098,3 +1098,61 @@ test("Test WHERE with NOT ENDS WITH", () => {
         "--- Reference (s)"
     );
 });
+
+test("Test parenthesized expression with addition", () => {
+    const parser = new Parser();
+    const ast = parser.parse("WITH 1 AS n RETURN (n + 2)");
+    // prettier-ignore
+    expect(ast.print()).toBe(
+        "ASTNode\n" +
+        "- With\n" +
+        "-- Expression (n)\n" +
+        "--- Number (1)\n" +
+        "- Return\n" +
+        "-- Expression\n" +
+        "--- Expression\n" +
+        "---- Add\n" +
+        "----- Reference (n)\n" +
+        "----- Number (2)"
+    );
+});
+
+test("Test parenthesized expression with property access", () => {
+    const parser = new Parser();
+    const ast = parser.parse("WITH {a: 1} AS obj RETURN (obj.a)");
+    // prettier-ignore
+    expect(ast.print()).toBe(
+        "ASTNode\n" +
+        "- With\n" +
+        "-- Expression (obj)\n" +
+        "--- AssociativeArray\n" +
+        "---- KeyValuePair\n" +
+        "----- String (a)\n" +
+        "----- Expression\n" +
+        "------ Number (1)\n" +
+        "- Return\n" +
+        "-- Expression\n" +
+        "--- Expression\n" +
+        "---- Lookup\n" +
+        "----- Identifier (a)\n" +
+        "----- Reference (obj)"
+    );
+});
+
+test("Test parenthesized expression with multiplication", () => {
+    const parser = new Parser();
+    const ast = parser.parse("WITH 5 AS x RETURN (x * 3)");
+    // prettier-ignore
+    expect(ast.print()).toBe(
+        "ASTNode\n" +
+        "- With\n" +
+        "-- Expression (x)\n" +
+        "--- Number (5)\n" +
+        "- Return\n" +
+        "-- Expression\n" +
+        "--- Expression\n" +
+        "---- Multiply\n" +
+        "----- Reference (x)\n" +
+        "----- Number (3)"
+    );
+});