flowquery 1.0.20 → 1.0.21

package/package.json

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

package/src/graph/data.ts

@@ -27,13 +27,19 @@ class IndexEntry {
 }
 
 class Layer {
-    private _index: Map<string, IndexEntry> = new Map();
+    private _indexes: Map<string, Map<string, IndexEntry>> = new Map();
     private _current: number = -1;
-    constructor(index: Map<string, IndexEntry>) {
-        this._index = index;
+    constructor(indexes: Map<string, Map<string, IndexEntry>>) {
+        this._indexes = indexes;
     }
-    public get index(): Map<string, IndexEntry> {
-        return this._index;
+    public index(name: string): Map<string, IndexEntry> {
+        if (!this._indexes.has(name)) {
+            this._indexes.set(name, new Map());
+        }
+        return this._indexes.get(name)!;
+    }
+    public get indexes(): Map<string, Map<string, IndexEntry>> {
+        return this._indexes;
     }
     public get current(): number {
         return this._current;
@@ -52,33 +58,41 @@ class Data {
         this._layers.set(0, new Layer(new Map()));
     }
     protected _buildIndex(key: string, level: number = 0): void {
-        this.layer(level).index.clear();
-        this._records.forEach((record, idx) => {
+        const idx = this.layer(level).index(key);
+        idx.clear();
+        this._records.forEach((record, i) => {
             if (record.hasOwnProperty(key)) {
-                if (!this.layer(level).index.has(record[key])) {
-                    this.layer(level).index.set(record[key], new IndexEntry());
+                if (!idx.has(record[key])) {
+                    idx.set(record[key], new IndexEntry());
                 }
-                this.layer(level).index.get(record[key])!.add(idx);
+                idx.get(record[key])!.add(i);
             }
         });
     }
     public layer(level: number = 0): Layer {
         if (!this._layers.has(level)) {
             const first = this._layers.get(0)!;
-            const cloned = new Map<string, IndexEntry>();
-            for (const [key, entry] of first.index) {
-                cloned.set(key, entry.clone());
+            const clonedIndexes = new Map<string, Map<string, IndexEntry>>();
+            for (const [name, indexMap] of first.indexes) {
+                const clonedMap = new Map<string, IndexEntry>();
+                for (const [key, entry] of indexMap) {
+                    clonedMap.set(key, entry.clone());
+                }
+                clonedIndexes.set(name, clonedMap);
             }
-            this._layers.set(level, new Layer(cloned));
+            this._layers.set(level, new Layer(clonedIndexes));
         }
         return this._layers.get(level)!;
     }
-    protected _find(key: string, level: number = 0): boolean {
-        if (!this.layer(level).index.has(key)) {
+    protected _find(key: string, level: number = 0, indexName?: string): boolean {
+        const idx = indexName
+            ? this.layer(level).index(indexName)
+            : this.layer(level).indexes.values().next().value;
+        if (!idx || !idx.has(key)) {
             this.layer(level).current = this._records.length; // Move to end
             return false;
         } else {
-            const entry = this.layer(level).index.get(key)!;
+            const entry = idx.get(key)!;
             const more = entry.next();
             if (!more) {
                 this.layer(level).current = this._records.length; // Move to end
@@ -91,8 +105,10 @@ class Data {
     public reset(): void {
         for (const layer of this._layers.values()) {
             layer.current = -1;
-            for (const entry of layer.index.values()) {
-                entry.reset();
+            for (const indexMap of layer.indexes.values()) {
+                for (const entry of indexMap.values()) {
+                    entry.reset();
+                }
             }
         }
     }

package/src/graph/node.ts

@@ -41,6 +41,23 @@ class Node extends ASTNode {
     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);
     }
@@ -72,6 +89,9 @@ class Node extends ASTNode {
         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();
         }
@@ -80,6 +100,9 @@ class Node extends ASTNode {
         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();

package/src/graph/node_data.ts

@@ -8,7 +8,7 @@ class NodeData extends Data {
         super._buildIndex("id");
     }
     public find(id: string, hop: number = 0): boolean {
-        return super._find(id, hop);
+        return super._find(id, hop, "id");
     }
     public current(hop: number = 0): NodeRecord | null {
         return super.current(hop) as NodeRecord | null;

package/src/graph/relationship.ts

@@ -18,6 +18,7 @@ class Relationship extends ASTNode {
 
     protected _source: Node | null = null;
     protected _target: Node | null = null;
+    protected _direction: "left" | "right" = "right";
 
     private _data: RelationshipData | null = null;
 
@@ -38,8 +39,25 @@ class Relationship extends ASTNode {
     public get type(): string | null {
         return this._type;
     }
-    public get properties(): Record<string, any> {
-        return this._data?.properties() || {};
+    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: RelationshipData = this._data!;
+        for (const [key, expression] of this._properties) {
+            const record: RelationshipRecord = data.current(hop)!;
+            if (record === null) {
+                throw new Error("No current relationship data available");
+            }
+            if (!(key in record)) {
+                throw new Error("Relationship does not have property");
+            }
+            return record[key] === expression.value();
+        }
+        return true;
     }
     public setProperty(key: string, value: Expression): void {
         this._properties.set(key, value);
@@ -69,6 +87,12 @@ class Relationship extends ASTNode {
     public get target(): Node | null {
         return this._target;
     }
+    public set direction(direction: "left" | "right") {
+        this._direction = direction;
+    }
+    public get direction(): "left" | "right" {
+        return this._direction;
+    }
     public value(): RelationshipMatchRecord | RelationshipMatchRecord[] | null {
         return this._value;
     }
@@ -87,6 +111,7 @@ class Relationship extends ASTNode {
     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;
@@ -102,16 +127,23 @@ class Relationship extends ASTNode {
                 await this._target.find(left_id, hop);
             }
         }
-        while (this._data?.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)) {
             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._matchesProperties(hop)) {
+                    continue;
+                }
+                await this._target?.find(data[followId], 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);
+                    await this.find(data[followId], hop + 1);
                 }
                 this._matches.pop();
             }

package/src/graph/relationship_data.ts

@@ -6,9 +6,13 @@ class RelationshipData extends Data {
     constructor(records: RelationshipRecord[] = []) {
         super(records);
         super._buildIndex("left_id");
+        super._buildIndex("right_id");
     }
     public find(left_id: string, hop: number = 0): boolean {
-        return super._find(left_id, hop);
+        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");
     }
     /*
     ** Get the properties of the current relationship record
@@ -22,6 +26,9 @@ class RelationshipData extends Data {
         }
         return null;
     }
+    public current(hop: number = 0): RelationshipRecord | null {
+        return super.current(hop) as RelationshipRecord | null;
+    }
 }
 
 export default RelationshipData;

package/src/graph/relationship_match_collector.ts

@@ -16,7 +16,7 @@ class RelationshipMatchCollector {
             type: relationship.type!,
             startNode: relationship.source?.value() || {},
             endNode: null,
-            properties: relationship.properties,
+            properties: relationship.getData()?.properties() as Record<string, any>,
         };
         this._matches.push(match);
         this._nodeIds.push(match.startNode.id);

package/src/graph/relationship_reference.ts

@@ -17,7 +17,8 @@ class RelationshipReference extends Relationship {
         const data: RelationshipRecord = this._reference!.getData()?.current(
             hop
         ) as RelationshipRecord;
-        await this._target?.find(data.right_id, hop);
+        const followId = this._direction === "left" ? "left_id" : "right_id";
+        await this._target?.find(data[followId], hop);
     }
 }
 

package/src/index.ts

@@ -5,6 +5,7 @@
  *
  * @packageDocumentation
  */
+
 import CommandLine from "./io/command_line";
 
 const commandLine = new CommandLine();

package/src/parsing/parser.ts

@@ -431,6 +431,7 @@ class Parser extends BaseParser {
         }
         this.skipWhitespaceAndComments();
         let node = new Node();
+        node.properties = new Map(this.parseProperties());
         node.label = label!;
         if (label !== null && identifier !== null) {
             node.identifier = identifier;
@@ -449,6 +450,47 @@ class Parser extends BaseParser {
         return node;
     }
 
+    private *parseProperties(): Iterable<[string, Expression]> {
+        let parts: number = 0;
+        while (true) {
+            this.skipWhitespaceAndComments();
+            if (!this.token.isOpeningBrace() && parts == 0) {
+                return;
+            } else if (!this.token.isOpeningBrace() && parts > 0) {
+                throw new Error("Expected opening brace");
+            }
+            this.setNextToken();
+            this.skipWhitespaceAndComments();
+            if (!this.token.isIdentifier()) {
+                throw new Error("Expected identifier");
+            }
+            const key: string = this.token.value!;
+            this.setNextToken();
+            this.skipWhitespaceAndComments();
+            if (!this.token.isColon()) {
+                throw new Error("Expected colon");
+            }
+            this.setNextToken();
+            this.skipWhitespaceAndComments();
+            const expression: Expression | null = this.parseExpression();
+            if (expression === null) {
+                throw new Error("Expected expression");
+            }
+            this.skipWhitespaceAndComments();
+            if (!this.token.isClosingBrace()) {
+                throw new Error("Expected closing brace");
+            }
+            this.setNextToken();
+            yield [key, expression];
+            this.skipWhitespaceAndComments();
+            if (!this.token.isComma()) {
+                break;
+            }
+            this.setNextToken();
+            parts++;
+        }
+    }
+
     private *parsePatterns(): IterableIterator<Pattern> {
         while (true) {
             let identifier: string | null = null;
@@ -538,7 +580,9 @@ class Parser extends BaseParser {
     }
 
     private parseRelationship(): Relationship | null {
+        let direction: "left" | "right" = "right";
         if (this.token.isLessThan() && this.peek()?.isSubtract()) {
+            direction = "left";
             this.setNextToken();
             this.setNextToken();
         } else if (this.token.isSubtract()) {
@@ -565,6 +609,7 @@ class Parser extends BaseParser {
         const type: string = this.token.value || "";
         this.setNextToken();
         const hops: Hops | null = this.parseRelationshipHops();
+        const properties: Map<string, Expression> = new Map(this.parseProperties());
         if (!this.token.isClosingBracket()) {
             throw new Error("Expected closing bracket for relationship definition");
         }
@@ -577,6 +622,8 @@ class Parser extends BaseParser {
             this.setNextToken();
         }
         let relationship = new Relationship();
+        relationship.direction = direction;
+        relationship.properties = properties;
         if (type !== null && variable !== null) {
             relationship.identifier = variable;
             this.variables.set(variable, relationship);

package/tests/compute/runner.test.ts

@@ -1282,3 +1282,181 @@ test("Test equality comparison", async () => {
         }
     }
 });
+
+test("Test match with constraints", async () => {
+    await new Runner(`
+        CREATE VIRTUAL (:Employee) AS {
+            unwind [
+                {id: 1, name: 'Employee 1'},
+                {id: 2, name: 'Employee 2'},
+                {id: 3, name: 'Employee 3'},
+                {id: 4, name: 'Employee 4'}
+            ] as record
+            RETURN record.id as id, record.name as name
+        }
+    `).run();
+    const match = new Runner(`
+        match (e:Employee{name:'Employee 1'})
+        return e.name as name
+    `);
+    await match.run();
+    const results = match.results;
+    expect(results.length).toBe(1);
+    expect(results[0].name).toBe("Employee 1");
+});
+
+test("Test match with leftward relationship direction", async () => {
+    await new Runner(`
+        CREATE VIRTUAL (:Person) AS {
+            unwind [
+                {id: 1, name: 'Person 1'},
+                {id: 2, name: 'Person 2'},
+                {id: 3, name: 'Person 3'}
+            ] as record
+            RETURN record.id as id, record.name as name
+        }
+    `).run();
+    await new Runner(`
+        CREATE VIRTUAL (:Person)-[:REPORTS_TO]-(:Person) AS {
+            unwind [
+                {left_id: 2, right_id: 1},
+                {left_id: 3, right_id: 1}
+            ] as record
+            RETURN record.left_id as left_id, record.right_id as right_id
+        }
+    `).run();
+    // Rightward: left_id -> right_id (2->1, 3->1)
+    const rightMatch = new Runner(`
+        MATCH (a:Person)-[:REPORTS_TO]->(b:Person)
+        RETURN a.name AS employee, b.name AS manager
+    `);
+    await rightMatch.run();
+    const rightResults = rightMatch.results;
+    expect(rightResults.length).toBe(2);
+    expect(rightResults[0]).toEqual({ employee: "Person 2", manager: "Person 1" });
+    expect(rightResults[1]).toEqual({ employee: "Person 3", manager: "Person 1" });
+
+    // Leftward: right_id -> left_id (1->2, 1->3) — reverse traversal
+    const leftMatch = new Runner(`
+        MATCH (m:Person)<-[:REPORTS_TO]-(e:Person)
+        RETURN m.name AS manager, e.name AS employee
+    `);
+    await leftMatch.run();
+    const leftResults = leftMatch.results;
+    expect(leftResults.length).toBe(2);
+    expect(leftResults[0]).toEqual({ manager: "Person 1", employee: "Person 2" });
+    expect(leftResults[1]).toEqual({ manager: "Person 1", employee: "Person 3" });
+});
+
+test("Test match with leftward direction produces same results as rightward with swapped data", async () => {
+    await new Runner(`
+        CREATE VIRTUAL (:City) AS {
+            unwind [
+                {id: 1, name: 'New York'},
+                {id: 2, name: 'Boston'},
+                {id: 3, name: 'Chicago'}
+            ] as record
+            RETURN record.id as id, record.name as name
+        }
+    `).run();
+    await new Runner(`
+        CREATE VIRTUAL (:City)-[:ROUTE]-(:City) AS {
+            unwind [
+                {left_id: 1, right_id: 2},
+                {left_id: 1, right_id: 3}
+            ] as record
+            RETURN record.left_id as left_id, record.right_id as right_id
+        }
+    `).run();
+    // Leftward from destination: find where right_id matches, follow left_id
+    const match = new Runner(`
+        MATCH (dest:City)<-[:ROUTE]-(origin:City)
+        RETURN dest.name AS destination, origin.name AS origin
+    `);
+    await match.run();
+    const results = match.results;
+    expect(results.length).toBe(2);
+    expect(results[0]).toEqual({ destination: "Boston", origin: "New York" });
+    expect(results[1]).toEqual({ destination: "Chicago", origin: "New York" });
+});
+
+test("Test match with leftward variable-length relationships", async () => {
+    await new Runner(`
+        CREATE VIRTUAL (:Person) AS {
+            unwind [
+                {id: 1, name: 'Person 1'},
+                {id: 2, name: 'Person 2'},
+                {id: 3, name: 'Person 3'}
+            ] as record
+            RETURN record.id as id, record.name as name
+        }
+    `).run();
+    await new Runner(`
+        CREATE VIRTUAL (:Person)-[:MANAGES]-(:Person) AS {
+            unwind [
+                {left_id: 1, right_id: 2},
+                {left_id: 2, right_id: 3}
+            ] as record
+            RETURN record.left_id as left_id, record.right_id as right_id
+        }
+    `).run();
+    // Leftward variable-length: traverse from right_id to left_id
+    // Person 3 can reach Person 2 (1 hop) and Person 1 (2 hops)
+    const match = new Runner(`
+        MATCH (a:Person)<-[:MANAGES*]-(b:Person)
+        RETURN a.name AS name1, b.name AS name2
+    `);
+    await match.run();
+    const results = match.results;
+    // Zero-hop results for all 3 persons + multi-hop results
+    // Leftward indexes on right_id. find(id) looks up right_id=id, follows left_id.
+    // right_id=1: no records → Person 1 zero-hop only
+    // right_id=2: record {left_id:1, right_id:2} → Person 2 → Person 1, then recurse find(1) → no more
+    // right_id=3: record {left_id:2, right_id:3} → Person 3 → Person 2, then recurse find(2) → Person 1
+    expect(results.length).toBe(6);
+    // Person 1: zero-hop
+    expect(results[0]).toEqual({ name1: "Person 1", name2: "Person 1" });
+    // Person 2: zero-hop, then reaches Person 1
+    expect(results[1]).toEqual({ name1: "Person 2", name2: "Person 2" });
+    expect(results[2]).toEqual({ name1: "Person 2", name2: "Person 1" });
+    // Person 3: zero-hop, then reaches Person 2, then Person 1
+    expect(results[3]).toEqual({ name1: "Person 3", name2: "Person 3" });
+    expect(results[4]).toEqual({ name1: "Person 3", name2: "Person 2" });
+    expect(results[5]).toEqual({ name1: "Person 3", name2: "Person 1" });
+});
+
+test("Test match with leftward double graph pattern", 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();
+    // Leftward chain: (c)<-[:KNOWS]-(b)<-[:KNOWS]-(a)
+    // First rel: find right_id=c, follow left_id to b
+    // Second rel: find right_id=b, follow left_id to a
+    const match = new Runner(`
+        MATCH (c:Person)<-[:KNOWS]-(b:Person)<-[:KNOWS]-(a:Person)
+        RETURN a.name AS name1, b.name AS name2, c.name AS name3
+    `);
+    await match.run();
+    const results = match.results;
+    expect(results.length).toBe(2);
+    expect(results[0]).toEqual({ name1: "Person 1", name2: "Person 2", name3: "Person 3" });
+    expect(results[1]).toEqual({ name1: "Person 2", name2: "Person 3", name3: "Person 4" });
+});

package/tests/parsing/parser.test.ts

@@ -760,3 +760,35 @@ test("Test check pattern expression without NodeReference", () => {
         parser.parse("MATCH (a:Person) WHERE (:Person)-[:KNOWS]->(:Person) RETURN a");
     }).toThrow("PatternExpression must contain at least one NodeReference");
 });
+
+test("Test node with properties", () => {
+    const parser = new Parser();
+    const ast = parser.parse("MATCH (a:Person{value: 'hello'}) return a");
+    // prettier-ignore
+    expect(ast.print()).toBe(
+        "ASTNode\n" +
+        "- Match\n" +
+        "- Return\n" +
+        "-- Expression (a)\n" +
+        "--- Reference (a)"
+    );
+    const match: Match = ast.firstChild() as Match;
+    const node: Node = match.patterns[0].chain[0] as Node;
+    expect(node.properties.get("value")?.value()).toBe("hello");
+});
+
+test("Test relationship with properties", () => {
+    const parser = new Parser();
+    const ast = parser.parse("MATCH (:Person)-[r:LIKES{since: 2022}]->(:Food) return a");
+    // prettier-ignore
+    expect(ast.print()).toBe(
+        "ASTNode\n" +
+        "- Match\n" +
+        "- Return\n" +
+        "-- Expression (a)\n" +
+        "--- Reference (a)"
+    );
+    const match: Match = ast.firstChild() as Match;
+    const relationship: Relationship = match.patterns[0].chain[1] as Relationship;
+    expect(relationship.properties.get("since")?.value()).toBe(2022);
+});