flowquery 1.0.41 → 1.0.43

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "flowquery",
-  "version": "1.0.41",
+  "version": "1.0.43",
   "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

@@ -16,7 +16,11 @@ class NodeReference extends Node {
         return this._reference;
     }
     public async next(): Promise<void> {
-        this.setValue(this._reference!.value()!);
+        const referenced = this._reference?.value();
+        if (referenced == null) {
+            return;
+        }
+        this.setValue(referenced);
         await this._outgoing?.find(this._value!.id);
         await this.runTodoNext();
     }

package/src/graph/relationship_match_collector.ts

@@ -5,6 +5,7 @@ export type RelationshipMatchRecord = {
     startNode: Record<string, any>;
     endNode: Record<string, any> | null;
     properties: Record<string, any>;
+    [key: string]: any;
 };
 
 class RelationshipMatchCollector {
@@ -16,11 +17,13 @@ class RelationshipMatchCollector {
         const currentRecord = data?.current();
         const actualType =
             currentRecord && "_type" in currentRecord ? currentRecord["_type"] : relationship.type!;
+        const relProperties = data?.properties() as Record<string, any>;
         const match: RelationshipMatchRecord = {
+            ...(relProperties || {}),
             type: actualType,
             startNode: relationship.source?.value() || {},
             endNode: null,
-            properties: data?.properties() as Record<string, any>,
+            properties: relProperties,
         };
         this._matches.push(match);
         this._nodeIds.push(traversalId);

package/tests/compute/runner.test.ts

@@ -3343,6 +3343,69 @@ test("Test match with ORed relationship types returns correct type in relationsh
     expect(results[1]).toEqual({ from: "NYC", to: "Chicago", type: "TRAIN" });
 });
 
+test("Test relationship properties can be accessed directly via dot notation", async () => {
+    await new Runner(`
+        CREATE VIRTUAL (:City) AS {
+            unwind [
+                {id: 1, name: 'NYC'},
+                {id: 2, name: 'LA'},
+                {id: 3, name: 'Chicago'}
+            ] as record
+            RETURN record.id as id, record.name as name
+        }
+    `).run();
+    await new Runner(`
+        CREATE VIRTUAL (:City)-[:FLIGHT]-(:City) AS {
+            unwind [
+                {left_id: 1, right_id: 2, airline: 'Delta', duration: 5}
+            ] as record
+            RETURN record.left_id as left_id, record.right_id as right_id, record.airline as airline, record.duration as duration
+        }
+    `).run();
+    const match = new Runner(`
+        MATCH (a:City)-[r:FLIGHT]->(b:City)
+        RETURN a.name AS from, b.name AS to, r.airline AS airline, r.duration AS duration
+    `);
+    await match.run();
+    const results = match.results;
+    expect(results.length).toBe(1);
+    expect(results[0]).toEqual({ from: "NYC", to: "LA", airline: "Delta", duration: 5 });
+});
+
+test("Test relationship properties accessible via both direct access and properties()", async () => {
+    await new Runner(`
+        CREATE VIRTUAL (:Person) AS {
+            unwind [
+                {id: 1, name: 'Alice'},
+                {id: 2, name: 'Bob'}
+            ] 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, since: 2020, strength: 'strong'}
+            ] as record
+            RETURN record.left_id as left_id, record.right_id as right_id, record.since as since, record.strength as strength
+        }
+    `).run();
+    const match = new Runner(`
+        MATCH (a:Person)-[r:KNOWS]->(b:Person)
+        RETURN a.name AS from, b.name AS to, r.since AS since, r.strength AS strength, properties(r).since AS propSince
+    `);
+    await match.run();
+    const results = match.results;
+    expect(results.length).toBe(1);
+    expect(results[0]).toEqual({
+        from: "Alice",
+        to: "Bob",
+        since: 2020,
+        strength: "strong",
+        propSince: 2020,
+    });
+});
+
 test("Test coalesce returns first non-null value", async () => {
     const runner = new Runner("RETURN coalesce(null, null, 'hello', 'world') as result");
     await runner.run();
@@ -4097,3 +4160,145 @@ test("Test RETURN alias shadowing graph variable in same RETURN clause", async (
         mentorDepartment: "Engineering",
     });
 });
+
+test("Test chained optional match with null intermediate node", async () => {
+    // Create a chain: A -> B -> C (C has no outgoing REPORTS_TO)
+    await new Runner(`
+        CREATE VIRTUAL (:Employee) AS {
+            unwind [
+                {id: 1, name: 'Alice'},
+                {id: 2, name: 'Bob'},
+                {id: 3, name: 'Charlie'}
+            ] as record
+            RETURN record.id as id, record.name as name
+        }
+    `).run();
+    await new Runner(`
+        CREATE VIRTUAL (:Employee)-[:REPORTS_TO]-(:Employee) 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();
+
+    // Alice -> Bob -> Charlie -> null -> null
+    // m1=Bob, m2=Charlie, m3=null, m4=null (should not crash)
+    const runner = new Runner(`
+        MATCH (u:Employee)
+        WHERE u.name = "Alice"
+        OPTIONAL MATCH (u)-[:REPORTS_TO]->(m1:Employee)
+        OPTIONAL MATCH (m1)-[:REPORTS_TO]->(m2:Employee)
+        OPTIONAL MATCH (m2)-[:REPORTS_TO]->(m3:Employee)
+        OPTIONAL MATCH (m3)-[:REPORTS_TO]->(m4:Employee)
+        RETURN
+            u.name AS user,
+            m1.name AS manager1,
+            m2.name AS manager2,
+            m3.name AS manager3,
+            m4.name AS manager4
+    `);
+    await runner.run();
+    const results = runner.results;
+
+    expect(results.length).toBe(1);
+    expect(results[0].user).toBe("Alice");
+    expect(results[0].manager1).toBe("Bob");
+    expect(results[0].manager2).toBe("Charlie");
+    expect(results[0].manager3).toBeNull();
+    expect(results[0].manager4).toBeNull();
+});
+
+test("Test chained optional match all null from first optional", async () => {
+    // Create nodes with no relationships
+    await new Runner(`
+        CREATE VIRTUAL (:Worker) AS {
+            unwind [
+                {id: 1, name: 'Solo'}
+            ] as record
+            RETURN record.id as id, record.name as name
+        }
+    `).run();
+    await new Runner(`
+        CREATE VIRTUAL (:Worker)-[:MANAGES]-(:Worker) AS {
+            unwind [] as record
+            RETURN record.left_id as left_id, record.right_id as right_id
+        }
+    `).run();
+
+    // Solo has no MANAGES relationship at all
+    // m1=null, m2=null, m3=null
+    const runner = new Runner(`
+        MATCH (u:Worker)
+        OPTIONAL MATCH (u)-[:MANAGES]->(m1:Worker)
+        OPTIONAL MATCH (m1)-[:MANAGES]->(m2:Worker)
+        OPTIONAL MATCH (m2)-[:MANAGES]->(m3:Worker)
+        RETURN
+            u.name AS user,
+            m1.name AS mgr1,
+            m2.name AS mgr2,
+            m3.name AS mgr3
+    `);
+    await runner.run();
+    const results = runner.results;
+
+    expect(results.length).toBe(1);
+    expect(results[0].user).toBe("Solo");
+    expect(results[0].mgr1).toBeNull();
+    expect(results[0].mgr2).toBeNull();
+    expect(results[0].mgr3).toBeNull();
+});
+
+test("Test chained optional match with mixed null and non-null paths", async () => {
+    // Two starting nodes: one with full chain, one with partial
+    await new Runner(`
+        CREATE VIRTUAL (:Staff) AS {
+            unwind [
+                {id: 1, name: 'Dev'},
+                {id: 2, name: 'Lead'},
+                {id: 3, name: 'Director'},
+                {id: 4, name: 'Intern'}
+            ] as record
+            RETURN record.id as id, record.name as name
+        }
+    `).run();
+    await new Runner(`
+        CREATE VIRTUAL (:Staff)-[:REPORTS_TO]-(:Staff) 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();
+
+    // Dev -> Lead -> Director -> null
+    // Intern -> null -> null -> null
+    const runner = new Runner(`
+        MATCH (u:Staff)
+        WHERE u.name = "Dev" OR u.name = "Intern"
+        OPTIONAL MATCH (u)-[:REPORTS_TO]->(m1:Staff)
+        OPTIONAL MATCH (m1)-[:REPORTS_TO]->(m2:Staff)
+        OPTIONAL MATCH (m2)-[:REPORTS_TO]->(m3:Staff)
+        RETURN
+            u.name AS user,
+            m1.name AS mgr1,
+            m2.name AS mgr2,
+            m3.name AS mgr3
+    `);
+    await runner.run();
+    const results = runner.results;
+
+    expect(results.length).toBe(2);
+    // Dev's chain
+    const dev = results.find((r: any) => r.user === "Dev");
+    expect(dev.mgr1).toBe("Lead");
+    expect(dev.mgr2).toBe("Director");
+    expect(dev.mgr3).toBeNull();
+    // Intern's chain
+    const intern = results.find((r: any) => r.user === "Intern");
+    expect(intern.mgr1).toBeNull();
+    expect(intern.mgr2).toBeNull();
+    expect(intern.mgr3).toBeNull();
+});