flowquery 1.0.17 → 1.0.18

package/package.json

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

package/src/graph/pattern_expression.ts

@@ -10,11 +10,22 @@ class PatternExpression extends Pattern {
         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 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 () => {

package/src/parsing/parser.ts

@@ -516,9 +516,6 @@ class Parser extends BaseParser {
         if (node === null) {
             throw new Error("Expected node definition");
         }
-        if (!(node instanceof NodeReference)) {
-            throw new Error("PatternExpression must start with a NodeReference");
-        }
         pattern.addElement(node);
         let relationship: Relationship | null = null;
         while (true) {
@@ -536,6 +533,7 @@ class Parser extends BaseParser {
             }
             pattern.addElement(node);
         }
+        pattern.verify();
         return pattern;
     }
 
@@ -709,7 +707,12 @@ class Parser extends BaseParser {
                     const lookup = this.parseLookup(func);
                     expression.addNode(lookup);
                 }
-            } else if (this.token.isLeftParenthesis() && this.peek()?.isIdentifier()) {
+            } else if (
+                this.token.isLeftParenthesis() &&
+                (this.peek()?.isIdentifier() ||
+                    this.peek()?.isColon() ||
+                    this.peek()?.isRightParenthesis())
+            ) {
                 // Possible graph pattern expression
                 const pattern = this.parsePatternExpression();
                 if (pattern !== null) {

package/tests/parsing/parser.test.ts

@@ -752,3 +752,11 @@ test("Parse statement with graph pattern in where clause", () => {
     expect(relationship.type).toBe("KNOWS");
     expect(target.label).toBe("Person");
 });
+
+test("Test check pattern expression without NodeReference", () => {
+    const parser = new Parser();
+    // Should throw an error because pattern does not start with NodeReference
+    expect(() => {
+        parser.parse("MATCH (a:Person) WHERE (:Person)-[:KNOWS]->(:Person) RETURN a");
+    }).toThrow("PatternExpression must contain at least one NodeReference");
+});