flowquery 1.0.41 → 1.0.43

package/flowquery-py/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "flowquery"
-version = "1.0.31"
+version = "1.0.33"
 description = "A declarative query language for data processing pipelines"
 readme = "README.md"
 requires-python = ">=3.10"

package/flowquery-py/src/graph/node_reference.py

@@ -32,10 +32,11 @@ class NodeReference(Node):
     async def next(self) -> None:
         """Process next using the referenced node's value."""
         ref_value = self._reference.value()
-        if ref_value is not None:
-            self.set_value(dict(ref_value))
-            if self._outgoing and self._value:
-                await self._outgoing.find(self._value['id'])
+        if ref_value is None:
+            return
+        self.set_value(dict(ref_value))
+        if self._outgoing and self._value:
+            await self._outgoing.find(self._value['id'])
         await self.run_todo_next()
 
     async def find(self, id_: str, hop: int = 0) -> None:

package/flowquery-py/src/graph/relationship_match_collector.py

@@ -2,19 +2,17 @@
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any, Dict, List, Optional, TypedDict, Union
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, Union
 
 if TYPE_CHECKING:
     from .node import Node
     from .relationship import Relationship
 
-
-class RelationshipMatchRecord(TypedDict, total=False):
-    """Represents a matched relationship record."""
-    type: str
-    startNode: Any
-    endNode: Any
-    properties: Dict[str, Any]
+# A relationship match record is a plain dict with known keys (type,
+# startNode, endNode, properties) plus any extra relationship-property
+# keys spread at the top level – mirroring the TypeScript version that
+# uses an index signature ``[key: string]: any``.
+RelationshipMatchRecord = Dict[str, Any]
 
 
 class RelationshipMatchCollector:
@@ -36,6 +34,7 @@ class RelationshipMatchCollector:
             actual_type = default_type
         rel_props: Dict[str, Any] = (rel_data.properties() or {}) if rel_data else {}
         match: RelationshipMatchRecord = {
+            **rel_props,
             "type": actual_type,
             "startNode": start_node_value or {},
             "endNode": None,

package/flowquery-py/tests/compute/test_runner.py

@@ -3542,6 +3542,76 @@ class TestRunner:
         assert len(results) == 1
         assert results[0] == {"sum": 0}
 
+    @pytest.mark.asyncio
+    async def test_relationship_properties_direct_dot_notation(self):
+        """Test relationship properties can be accessed directly via dot notation."""
+        await Runner(
+            """
+            CREATE VIRTUAL (:RCity) AS {
+                unwind [
+                    {id: 1, name: 'NYC'},
+                    {id: 2, name: 'LA'}
+                ] as record
+                RETURN record.id as id, record.name as name
+            }
+            """
+        ).run()
+        await Runner(
+            """
+            CREATE VIRTUAL (:RCity)-[:RFLIGHT]-(:RCity) 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()
+        match = Runner(
+            """
+            MATCH (a:RCity)-[r:RFLIGHT]->(b:RCity)
+            RETURN a.name AS from, b.name AS to, r.airline AS airline, r.duration AS duration
+            """
+        )
+        await match.run()
+        results = match.results
+        assert len(results) == 1
+        assert results[0] == {"from": "NYC", "to": "LA", "airline": "Delta", "duration": 5}
+
+    @pytest.mark.asyncio
+    async def test_relationship_properties_direct_and_via_properties_function(self):
+        """Test relationship properties accessible via both direct access and properties()."""
+        await Runner(
+            """
+            CREATE VIRTUAL (:RPerson) AS {
+                unwind [
+                    {id: 1, name: 'Alice'},
+                    {id: 2, name: 'Bob'}
+                ] as record
+                RETURN record.id as id, record.name as name
+            }
+            """
+        ).run()
+        await Runner(
+            """
+            CREATE VIRTUAL (:RPerson)-[:RKNOWS]-(:RPerson) 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()
+        match = Runner(
+            """
+            MATCH (a:RPerson)-[r:RKNOWS]->(b:RPerson)
+            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()
+        results = match.results
+        assert len(results) == 1
+        assert results[0] == {"from": "Alice", "to": "Bob", "since": 2020, "strength": "strong", "propSince": 2020}
+
     @pytest.mark.asyncio
     async def test_coalesce_returns_first_non_null(self):
         """Test coalesce returns first non-null value."""
@@ -4394,4 +4464,161 @@ class TestRunner:
             "mentor": "Bob Jones",
             "mentorJobTitle": "Staff Engineer",
             "mentorDepartment": "Engineering",
-        }
+        }
+
+    @pytest.mark.asyncio
+    async def test_chained_optional_match_with_null_intermediate_node(self):
+        """Test chained OPTIONAL MATCH where intermediate node is null doesn't crash."""
+        # Chain: Alice -> Bob -> Charlie (no outgoing)
+        await Runner(
+            """
+            CREATE VIRTUAL (:ChainEmp) 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 Runner(
+            """
+            CREATE VIRTUAL (:ChainEmp)-[:REPORTS_TO]-(:ChainEmp) 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
+        runner = Runner(
+            """
+            MATCH (u:ChainEmp)
+            WHERE u.name = "Alice"
+            OPTIONAL MATCH (u)-[:REPORTS_TO]->(m1:ChainEmp)
+            OPTIONAL MATCH (m1)-[:REPORTS_TO]->(m2:ChainEmp)
+            OPTIONAL MATCH (m2)-[:REPORTS_TO]->(m3:ChainEmp)
+            OPTIONAL MATCH (m3)-[:REPORTS_TO]->(m4:ChainEmp)
+            RETURN
+                u.name AS user,
+                m1.name AS manager1,
+                m2.name AS manager2,
+                m3.name AS manager3,
+                m4.name AS manager4
+            """
+        )
+        await runner.run()
+        results = runner.results
+
+        assert len(results) == 1
+        assert results[0]["user"] == "Alice"
+        assert results[0]["manager1"] == "Bob"
+        assert results[0]["manager2"] == "Charlie"
+        assert results[0]["manager3"] is None
+        assert results[0]["manager4"] is None
+
+    @pytest.mark.asyncio
+    async def test_chained_optional_match_all_null_from_first(self):
+        """Test chained OPTIONAL MATCH where first optional returns null propagates nulls."""
+        await Runner(
+            """
+            CREATE VIRTUAL (:ChainWorker) AS {
+                unwind [
+                    {id: 1, name: 'Solo'}
+                ] as record
+                RETURN record.id as id, record.name as name
+            }
+            """
+        ).run()
+        await Runner(
+            """
+            CREATE VIRTUAL (:ChainWorker)-[:MANAGES]-(:ChainWorker) AS {
+                unwind [] as record
+                RETURN record.left_id as left_id, record.right_id as right_id
+            }
+            """
+        ).run()
+
+        # Solo has no MANAGES relationship
+        runner = Runner(
+            """
+            MATCH (u:ChainWorker)
+            OPTIONAL MATCH (u)-[:MANAGES]->(m1:ChainWorker)
+            OPTIONAL MATCH (m1)-[:MANAGES]->(m2:ChainWorker)
+            OPTIONAL MATCH (m2)-[:MANAGES]->(m3:ChainWorker)
+            RETURN
+                u.name AS user,
+                m1.name AS mgr1,
+                m2.name AS mgr2,
+                m3.name AS mgr3
+            """
+        )
+        await runner.run()
+        results = runner.results
+
+        assert len(results) == 1
+        assert results[0]["user"] == "Solo"
+        assert results[0]["mgr1"] is None
+        assert results[0]["mgr2"] is None
+        assert results[0]["mgr3"] is None
+
+    @pytest.mark.asyncio
+    async def test_chained_optional_match_mixed_null_and_non_null(self):
+        """Test chained OPTIONAL MATCH with multiple start nodes having different chain depths."""
+        await Runner(
+            """
+            CREATE VIRTUAL (:ChainStaff) 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 Runner(
+            """
+            CREATE VIRTUAL (:ChainStaff)-[:REPORTS_TO]-(:ChainStaff) 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
+        runner = Runner(
+            """
+            MATCH (u:ChainStaff)
+            WHERE u.name = "Dev" OR u.name = "Intern"
+            OPTIONAL MATCH (u)-[:REPORTS_TO]->(m1:ChainStaff)
+            OPTIONAL MATCH (m1)-[:REPORTS_TO]->(m2:ChainStaff)
+            OPTIONAL MATCH (m2)-[:REPORTS_TO]->(m3:ChainStaff)
+            RETURN
+                u.name AS user,
+                m1.name AS mgr1,
+                m2.name AS mgr2,
+                m3.name AS mgr3
+            """
+        )
+        await runner.run()
+        results = runner.results
+
+        assert len(results) == 2
+        dev = next(r for r in results if r["user"] == "Dev")
+        assert dev["mgr1"] == "Lead"
+        assert dev["mgr2"] == "Director"
+        assert dev["mgr3"] is None
+        intern = next(r for r in results if r["user"] == "Intern")
+        assert intern["mgr1"] is None
+        assert intern["mgr2"] is None
+        assert intern["mgr3"] is None