Feat: Add Unsupported type for bolt 6 (#47)

Author: thelonelyvulpes

neo4j/src/driver/io/bolt/bolt6x0/translator.rs

@@ -12,6 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+use std::collections::VecDeque;
 use std::mem::size_of;
 
 use usize_cast::FromUsize;
@@ -91,9 +92,9 @@ impl BoltStructTranslator for Bolt6x0StructTranslator {
     }
 
     fn deserialize_struct(&self, tag: u8, mut fields: Vec<ValueReceive>) -> ValueReceive {
+        let size = fields.len();
         match tag {
             TAG_VECTOR => {
-                let size = fields.len();
                 if size != 2 {
                     return invalid_struct(format!(
                         "expected 2 fields for vector struct b'V', found {size}"
@@ -181,6 +182,44 @@ impl BoltStructTranslator for Bolt6x0StructTranslator {
                     }
                 })
             }
+            TAG_UNSUPPORTED_TYPE => {
+                let mut fields = VecDeque::from(fields);
+                if size != 4 {
+                    return invalid_struct(format!(
+                        "expected 4 fields for unsupported type struct b'?', found {size}"
+                    ));
+                }
+                let name = as_string!(fields.pop_front().unwrap(), "unsupported type name");
+                let min_major = as_int!(fields.pop_front().unwrap(), "unsupported type min major");
+                let min_minor = as_int!(fields.pop_front().unwrap(), "unsupported type min minor");
+
+                let Ok(min_major) = u8::try_from(min_major) else {
+                    return invalid_struct(format!(
+                        "unsupported type minimum major version must be u8, found {min_major}"
+                    ));
+                };
+
+                let Ok(min_minor) = u8::try_from(min_minor) else {
+                    return invalid_struct(format!(
+                        "unsupported type minimum minor version must be u8, found {min_minor}"
+                    ));
+                };
+
+                let mut extra = as_map!(fields.pop_front().unwrap(), "unsupported type extra");
+
+                let message = extra.remove("message");
+
+                let message = match message {
+                    Some(text) => Some(as_string!(text, "unsupported type extra::message")),
+                    None => None,
+                };
+
+                ValueReceive::UnsupportedType(crate::value::unsupported_type::UnsupportedType {
+                    name,
+                    minimum_protocol_version: (min_major, min_minor),
+                    message,
+                })
+            }
             _ => self.bolt5x8_translator.deserialize_struct(tag, fields),
         }
     }

neo4j/src/driver/io/bolt/bolt_common.rs

@@ -36,6 +36,7 @@ pub(super) const TAG_LEGACY_DATE_TIME_ZONE_ID: u8 = b'f';
 pub(super) const TAG_LOCAL_DATE_TIME: u8 = b'd';
 pub(super) const TAG_DURATION: u8 = b'E';
 pub(super) const TAG_VECTOR: u8 = b'V';
+pub(super) const TAG_UNSUPPORTED_TYPE: u8 = b'?';
 pub(super) const VEC_TYPE_MARKER_F64: &[u8] = &[0xC1];
 pub(super) const VEC_TYPE_MARKER_F32: &[u8] = &[0xC6];
 pub(super) const VEC_TYPE_MARKER_I64: &[u8] = &[0xCB];

neo4j/src/test_data/public-api.txt

@@ -1680,6 +1680,24 @@ impl core::marker::Sync for neo4j::value::time::TimeComponents
 impl core::marker::Unpin for neo4j::value::time::TimeComponents
 impl core::panic::unwind_safe::RefUnwindSafe for neo4j::value::time::TimeComponents
 impl core::panic::unwind_safe::UnwindSafe for neo4j::value::time::TimeComponents
+pub mod neo4j::value::unsupported_type
+pub struct neo4j::value::unsupported_type::UnsupportedType
+impl neo4j::value::unsupported_type::UnsupportedType
+pub fn neo4j::value::unsupported_type::UnsupportedType::message(&self) -> core::option::Option<&str>
+pub fn neo4j::value::unsupported_type::UnsupportedType::minimum_protocol_version(&self) -> (u8, u8)
+pub fn neo4j::value::unsupported_type::UnsupportedType::name(&self) -> &str
+impl core::clone::Clone for neo4j::value::unsupported_type::UnsupportedType
+pub fn neo4j::value::unsupported_type::UnsupportedType::clone(&self) -> neo4j::value::unsupported_type::UnsupportedType
+impl core::cmp::PartialEq for neo4j::value::unsupported_type::UnsupportedType
+pub fn neo4j::value::unsupported_type::UnsupportedType::eq(&self, _: &Self) -> bool
+impl core::fmt::Debug for neo4j::value::unsupported_type::UnsupportedType
+pub fn neo4j::value::unsupported_type::UnsupportedType::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+impl core::marker::Freeze for neo4j::value::unsupported_type::UnsupportedType
+impl core::marker::Send for neo4j::value::unsupported_type::UnsupportedType
+impl core::marker::Sync for neo4j::value::unsupported_type::UnsupportedType
+impl core::marker::Unpin for neo4j::value::unsupported_type::UnsupportedType
+impl core::panic::unwind_safe::RefUnwindSafe for neo4j::value::unsupported_type::UnsupportedType
+impl core::panic::unwind_safe::UnwindSafe for neo4j::value::unsupported_type::UnsupportedType
 pub mod neo4j::value::vector
 #[non_exhaustive] pub enum neo4j::value::vector::Vector
 pub neo4j::value::vector::Vector::F32(alloc::vec::Vec<f32>)
@@ -1784,6 +1802,7 @@ pub neo4j::value::ValueReceive::Path(neo4j::value::graph::Path)
 pub neo4j::value::ValueReceive::Relationship(neo4j::value::graph::Relationship)
 pub neo4j::value::ValueReceive::String(alloc::string::String)
 pub neo4j::value::ValueReceive::Time(neo4j::value::time::Time)
+pub neo4j::value::ValueReceive::UnsupportedType(neo4j::value::unsupported_type::UnsupportedType)
 pub neo4j::value::ValueReceive::Vector(neo4j::value::vector::Vector)
 pub neo4j::value::ValueReceive::WGS84_2D(neo4j::value::spatial::WGS84_2D)
 pub neo4j::value::ValueReceive::WGS84_3D(neo4j::value::spatial::WGS84_3D)
@@ -2314,6 +2333,7 @@ pub neo4j::ValueReceive::Path(neo4j::value::graph::Path)
 pub neo4j::ValueReceive::Relationship(neo4j::value::graph::Relationship)
 pub neo4j::ValueReceive::String(alloc::string::String)
 pub neo4j::ValueReceive::Time(neo4j::value::time::Time)
+pub neo4j::ValueReceive::UnsupportedType(neo4j::value::unsupported_type::UnsupportedType)
 pub neo4j::ValueReceive::Vector(neo4j::value::vector::Vector)
 pub neo4j::ValueReceive::WGS84_2D(neo4j::value::spatial::WGS84_2D)
 pub neo4j::ValueReceive::WGS84_3D(neo4j::value::spatial::WGS84_3D)

neo4j/src/value.rs

@@ -15,6 +15,7 @@
 pub mod graph;
 pub mod spatial;
 pub mod time;
+pub mod unsupported_type;
 mod value_receive;
 mod value_send;
 pub mod vector;

neo4j/src/value/unsupported_type.rs

@@ -0,0 +1,50 @@
+// Copyright Rouven Bauer
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+/// Represents a type unknown to the driver, received from the server.
+///
+/// This type is used, for instance, when a newer DBMS produces a result containing a type that the
+/// current version of the driver does not yet understand.
+///
+/// The attributes exposed by this type are meant for displaying and debugging purposes.
+/// They may change in future versions of the server and should not be relied upon for any logic in
+/// your application.
+/// If your application requires handling this type, you must upgrade your driver to a version that
+/// supports it.
+#[derive(Debug, Clone)]
+pub struct UnsupportedType {
+    pub(crate) name: String,
+    pub(crate) minimum_protocol_version: (u8, u8),
+    pub(crate) message: Option<String>,
+}
+
+impl UnsupportedType {
+    pub fn name(&self) -> &str {
+        self.name.as_str()
+    }
+
+    pub fn minimum_protocol_version(&self) -> (u8, u8) {
+        self.minimum_protocol_version
+    }
+
+    pub fn message(&self) -> Option<&str> {
+        self.message.as_deref()
+    }
+}
+
+impl PartialEq for UnsupportedType {
+    fn eq(&self, _: &Self) -> bool {
+        false
+    }
+}

neo4j/src/value/value_receive.rs

@@ -16,11 +16,11 @@ use std::collections::{HashMap, VecDeque};
 
 use itertools::Itertools;
 
-use super::graph;
 use super::spatial;
 use super::time;
 use super::value_send::ValueSend;
 use super::vector;
+use super::{graph, unsupported_type};
 
 /// A value received from the database.
 #[derive(Debug, Clone, PartialEq)]
@@ -49,6 +49,7 @@ pub enum ValueReceive {
     DateTime(time::DateTime),
     DateTimeFixed(time::DateTimeFixed),
     Vector(vector::Vector),
+    UnsupportedType(unsupported_type::UnsupportedType),
     /// A value that could not be received.
     /// This can have multiple reasons, for example:
     ///  * Unexpected struct data (likely a driver or server bug)
@@ -1206,10 +1207,11 @@ impl ValueReceive {
             ValueReceive::LocalDateTime(v) => format!("{v:?}"),
             ValueReceive::DateTime(v) => format!("{v:?}"),
             ValueReceive::DateTimeFixed(v) => format!("{v:?}"),
+            ValueReceive::Vector(v) => format!("{v:?}"),
+            ValueReceive::UnsupportedType(v) => format!("{v:?}"),
             ValueReceive::BrokenValue(broken_value) => {
                 format!("BrokenValue({})", broken_value.reason())
             }
-            ValueReceive::Vector(v) => format!("{v:?}"),
         }
     }
 }

neo4j/src/value/value_send.rs

@@ -257,6 +257,7 @@ impl TryFrom<ValueReceive> for ValueSend {
             ValueReceive::Relationship(_) => return Err("cannot convert Relationship".into()),
             ValueReceive::Path(_) => return Err("cannot convert Path".into()),
             ValueReceive::Vector(v) => Self::Vector(v),
+            ValueReceive::UnsupportedType(_) => return Err("cannot convert UnsupportedType".into()),
         })
     }
 }

testkit_backend/src/testkit_backend/cypher_value.rs

@@ -36,7 +36,7 @@ use neo4j::value::graph::{
     UnboundRelationship as Neo4jUnboundRelationship,
 };
 use neo4j::value::spatial::{Cartesian2D, Cartesian3D, WGS84_2D, WGS84_3D};
-use neo4j::value::{time, vector, ValueReceive, ValueSend};
+use neo4j::value::{time, unsupported_type, vector, ValueReceive, ValueSend};
 
 #[derive(Debug)]
 #[repr(transparent)]
@@ -121,6 +121,12 @@ pub(super) enum CypherValue {
         dtype: String,
         data: String,
     },
+    #[serde(rename_all = "camelCase")]
+    CypherUnsupportedType {
+        name: String,
+        minimum_protocol: String,
+        message: Option<String>,
+    },
 }
 
 #[derive(Debug, Deserialize, Serialize)]
@@ -511,6 +517,11 @@ impl TryFrom<CypherValue> for ValueSend {
                     }
                 }
             }
+            CypherValue::CypherUnsupportedType { .. } => {
+                return Err(NotADriverValueError::new(
+                    "UnsupportedType cannot be used as input type",
+                ))
+            }
         })
     }
 }
@@ -690,7 +701,7 @@ impl TryFrom<ValueSend> for CypherValue {
             ValueSend::LocalDateTime(value) => local_date_time_to_cypher_value(value)?,
             ValueSend::DateTime(value) => date_time_to_cypher_value(value)?,
             ValueSend::DateTimeFixed(value) => date_time_fixed_to_cypher_value(value)?,
-            ValueSend::Vector(value) => vector_cypher_value(value)?,
+            ValueSend::Vector(value) => vector_to_cypher_value(value)?,
             _ => {
                 return Err(TestKitError::backend_err(format!(
                     "Failed to serialize ValueSend to json: {v:?}",
@@ -834,7 +845,8 @@ impl TryFrom<ValueReceive> for CypherValue {
             ValueReceive::LocalDateTime(value) => local_date_time_to_cypher_value(value)?,
             ValueReceive::DateTime(value) => date_time_to_cypher_value(value)?,
             ValueReceive::DateTimeFixed(value) => date_time_fixed_to_cypher_value(value)?,
-            ValueReceive::Vector(value) => vector_cypher_value(value)?,
+            ValueReceive::Vector(value) => vector_to_cypher_value(value)?,
+            ValueReceive::UnsupportedType(value) => unsupported_type_to_cypher_value(value),
             ValueReceive::BrokenValue(v) => {
                 return Err(BrokenValueError::BrokenValue {
                     reason: v.reason().into(),
@@ -953,7 +965,7 @@ fn date_time_fixed_to_cypher_value(
     }))
 }
 
-fn vector_cypher_value(value: vector::Vector) -> Result<CypherValue, BrokenValueError> {
+fn vector_to_cypher_value(value: vector::Vector) -> Result<CypherValue, BrokenValueError> {
     Ok(match value {
         vector::Vector::F64(value) => CypherValue::CypherVector {
             dtype: String::from("f64"),
@@ -1021,6 +1033,18 @@ fn vector_cypher_value(value: vector::Vector) -> Result<CypherValue, BrokenValue
     })
 }
 
+fn unsupported_type_to_cypher_value(value: unsupported_type::UnsupportedType) -> CypherValue {
+    CypherValue::CypherUnsupportedType {
+        name: value.name().to_owned(),
+        minimum_protocol: format!(
+            "{}.{}",
+            value.minimum_protocol_version().0,
+            value.minimum_protocol_version().1
+        ),
+        message: value.message().map(String::from),
+    }
+}
+
 #[allow(clippy::result_large_err)]
 fn try_into_node(n: Neo4jNode) -> Result<CypherNode, TestKitError> {
     Ok(CypherNode {

testkit_backend/src/testkit_backend/responses.rs

@@ -38,7 +38,7 @@ use super::{BackendId, TestKitResultT};
 
 // [bolt-version-bump] search tag when changing bolt version support
 // https://github.com/rust-lang/rust/issues/85077
-const FEATURE_LIST: [&str; 55] = [
+const FEATURE_LIST: &[&str] = &[
     // === FUNCTIONAL FEATURES ===
     "Feature:API:BookmarkManager",
     "Feature:API:ConnectionAcquisitionTimeout",
@@ -65,7 +65,7 @@ const FEATURE_LIST: [&str; 55] = [
     "Feature:API:Summary:GqlStatusObjects",
     "Feature:API:Type.Spatial",
     "Feature:API:Type.Temporal",
-    // "Feature:API:Type.UnsupportedType",
+    "Feature:API:Type.UnsupportedType",
     "Feature:API:Type.Vector",
     "Feature:Auth:Bearer",
     "Feature:Auth:Custom",
@@ -850,7 +850,7 @@ impl TryFrom<EagerResult> for Response {
 impl Response {
     pub(super) fn feature_list() -> Self {
         Self::FeatureList {
-            features: FEATURE_LIST.into_iter().map(String::from).collect(),
+            features: FEATURE_LIST.iter().map(|x| String::from(*x)).collect(),
         }
     }