Fix extracting point properties from BoltType

lib/src/types/serde/point.rs

@@ -140,6 +140,33 @@ impl<'de, P: FromBuilder, E: Error> Visitor<'de> for BoltPointVisitor<P, E> {
         write!(formatter, "struct {}", std::any::type_name::<P>())
     }
 
+    fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
+    where
+        A: SeqAccess<'de>,
+    {
+        let mut point = BoltPointBuilder::default();
+
+        point.sr_id(|| {
+            seq.next_element::<BoltInteger>().map_or_else(Err, |item| {
+                item.ok_or_else(|| Error::missing_field("sr_id"))
+            })
+        })?;
+        point.x(|| {
+            seq.next_element::<BoltFloat>()
+                .map_or_else(Err, |item| item.ok_or_else(|| Error::missing_field("x")))
+        })?;
+        point.y(|| {
+            seq.next_element::<BoltFloat>()
+                .map_or_else(Err, |item| item.ok_or_else(|| Error::missing_field("y")))
+        })?;
+        if let Some(z) = seq.next_element::<BoltFloat>().transpose() {
+            point.z(|| z)?;
+        }
+
+        let point = point.build()?;
+        Ok(point)
+    }
+
     fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
     where
         A: ::serde::de::MapAccess<'de>,
@@ -281,8 +308,9 @@ impl<'de, E: Error, I: Iterator<Item = Result<Field, &'static str>>> SeqAccess<'
     where
         T: DeserializeSeed<'de>,
     {
-        self.next_key::<Field>()?;
-        self.next_value_seed(seed).map(Some)
+        self.next_key::<Field>()?
+            .map(|_| self.next_value_seed(seed))
+            .transpose()
     }
 }
 

lib/src/types/serde/typ.rs

@@ -5,7 +5,7 @@ use crate::{
             element::ElementDataDeserializer,
             node::BoltNodeVisitor,
             path::BoltPathVisitor,
-            point::{self, BoltPointDeserializer, BoltPointVisitor},
+            point::{BoltPointDeserializer, BoltPointVisitor},
             rel::BoltRelationVisitor,
             urel::BoltUnboundedRelationVisitor,
             BoltKind,
@@ -231,13 +231,10 @@ impl<'de> Visitor<'de> for BoltTypeVisitor {
                 .tuple_variant(1, BoltUnboundedRelationVisitor)
                 .map(BoltType::UnboundedRelation),
             BoltKind::Point2D => variant
-                .struct_variant(
-                    &point::Field::NAMES[..3],
-                    BoltPointVisitor::_2d::<A::Error>(),
-                )
+                .tuple_variant(3, BoltPointVisitor::_2d::<A::Error>())
                 .map(BoltType::Point2D),
             BoltKind::Point3D => variant
-                .struct_variant(point::Field::NAMES, BoltPointVisitor::_3d::<A::Error>())
+                .tuple_variant(4, BoltPointVisitor::_3d::<A::Error>())
                 .map(BoltType::Point3D),
             BoltKind::Bytes => variant.tuple_variant(1, self),
             BoltKind::Path => variant

lib/tests/node_property_parsing.rs

@@ -1,5 +1,5 @@
 use chrono::{DateTime, FixedOffset};
-use neo4rs::{query, Node};
+use neo4rs::{query, Node, Point2D, Point3D};
 
 mod container;
 
@@ -9,15 +9,49 @@ async fn node_property_parsing() {
     let graph = neo4j.graph();
 
     graph
-        .run(query("CREATE (:A {p1:DATETIME('2024-12-31T08:10:35')})"))
+        .run(query(
+            "CREATE
+(:Datetime {p1:DATETIME('2024-12-31T08:10:35')}),
+(:Point2D {a:Point ({x:2,y:3})}),
+(:Point3D {a:Point ({x:3,y:4,z:5})})
+",
+        ))
         .await
         .unwrap();
 
-    let mut result = graph.execute(query("MATCH (p:A) RETURN p")).await.unwrap();
+    let mut result = graph
+        .execute(query("MATCH (p:DateTime) RETURN p"))
+        .await
+        .unwrap();
 
     while let Ok(Some(row)) = result.next().await {
         let node: Node = row.get("p").unwrap();
         let p1 = node.get::<DateTime<FixedOffset>>("p1").unwrap();
         assert_eq!(p1.timestamp(), 1735632635);
     }
+
+    let mut result = graph
+        .execute(query("MATCH (p:Point2D) RETURN p"))
+        .await
+        .unwrap();
+
+    while let Ok(Some(row)) = result.next().await {
+        let node: Node = row.get("p").unwrap();
+        let p1 = node.get::<Point2D>("a").unwrap();
+        assert_eq!(p1.x(), 2.0);
+        assert_eq!(p1.y(), 3.0);
+    }
+
+    let mut result = graph
+        .execute(query("MATCH (p:Point3D) RETURN p"))
+        .await
+        .unwrap();
+
+    while let Ok(Some(row)) = result.next().await {
+        let node: Node = row.get("p").unwrap();
+        let p1 = node.get::<Point3D>("a").unwrap();
+        assert_eq!(p1.x(), 3.0);
+        assert_eq!(p1.y(), 4.0);
+        assert_eq!(p1.z(), 5.0);
+    }
 }