flowquery 1.0.29 → 1.0.30

package/package.json

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

package/src/parsing/parser.ts

@@ -798,12 +798,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 +860,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/parsing/parser.test.ts

@@ -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)"
+    );
+});