1use std::fmt;
14
15use crate::error_kinds::ErrorKind;
16
17use crate::typename::bare_type_name;
18use crate::{Error, Value};
19
20#[derive(Debug, Clone, Copy, PartialEq, Eq)]
25pub enum DynamicNameToken {
26 PropertyKey,
27 Label,
28}
29
30impl DynamicNameToken {
31 pub const fn as_str(self) -> &'static str {
33 match self {
34 Self::PropertyKey => "property key",
35 Self::Label => "label",
36 }
37 }
38
39 pub const fn position(self) -> &'static str {
41 match self {
42 Self::PropertyKey => "node or relationship property key",
43 Self::Label => "dynamic label",
44 }
45 }
46
47 pub const fn expected(self) -> &'static str {
49 match self {
50 Self::PropertyKey => "STRING",
51 Self::Label => "STRING or LIST<STRING>",
52 }
53 }
54
55 pub fn accepts_type(self, type_name: &str) -> bool {
62 match self {
63 Self::PropertyKey => type_name == "STRING",
64 Self::Label => type_name == "STRING" || type_name == "LIST",
65 }
66 }
67
68 pub fn check(self, value: &Value) -> Result<(), DynamicAccessError> {
75 match self {
76 Self::PropertyKey => dynamic_property_key(value).map(|_| ()),
77 Self::Label => dynamic_label_names(value).map(|_| ()),
78 }
79 }
80}
81
82#[derive(Debug, Clone, PartialEq, Eq)]
86pub enum DynamicAccessError {
87 WrongType {
89 token: DynamicNameToken,
90 type_name: String,
92 },
93 InvalidName {
95 token: DynamicNameToken,
96 input: String,
97 },
98}
99
100impl DynamicAccessError {
101 pub fn wrong_type(token: DynamicNameToken, type_name: impl Into<String>) -> Self {
106 Self::WrongType {
107 token,
108 type_name: type_name.into(),
109 }
110 }
111
112 pub fn kind(&self) -> ErrorKind {
116 match self {
117 Self::WrongType { .. } => ErrorKind::InvalidArgumentType,
118 Self::InvalidName { .. } => ErrorKind::SyntaxError,
119 }
120 }
121}
122
123impl fmt::Display for DynamicAccessError {
124 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
125 match self {
126 Self::WrongType { token, type_name } => write!(
127 f,
128 "Invalid input '{type_name}' for {}. Expected to be {}.",
129 token.position(),
130 token.expected()
131 ),
132 Self::InvalidName { token, input } => write!(
133 f,
134 "invalid name. A {} name cannot be empty or contain any null-bytes: '{}'.",
135 token.as_str(),
136 escape_for_message(input)
137 ),
138 }
139 }
140}
141
142impl From<DynamicAccessError> for Error {
143 fn from(error: DynamicAccessError) -> Self {
144 let detail = error.to_string();
145 match error {
151 DynamicAccessError::WrongType { .. } => Error::invalid_argument_type(detail),
152 DynamicAccessError::InvalidName { .. } => Error::syntax(detail),
153 }
154 }
155}
156
157pub fn dynamic_property_key(value: &Value) -> Result<String, DynamicAccessError> {
160 match value {
161 Value::String(key) => validated_name(DynamicNameToken::PropertyKey, key),
162 other => Err(DynamicAccessError::wrong_type(
163 DynamicNameToken::PropertyKey,
164 bare_type_name(other),
165 )),
166 }
167}
168
169pub fn dynamic_label_names(value: &Value) -> Result<Vec<String>, DynamicAccessError> {
172 match value {
173 Value::List(items) => items.iter().map(label_name).collect(),
174 other => label_name(other).map(|name| vec![name]),
175 }
176}
177
178fn label_name(item: &Value) -> Result<String, DynamicAccessError> {
182 match item {
183 Value::String(name) => validated_name(DynamicNameToken::Label, name),
184 other => Err(DynamicAccessError::wrong_type(
185 DynamicNameToken::Label,
186 bare_type_name(other),
187 )),
188 }
189}
190
191fn validated_name(token: DynamicNameToken, name: &str) -> Result<String, DynamicAccessError> {
194 if name.is_empty() || name.contains('\0') {
195 Err(DynamicAccessError::InvalidName {
196 token,
197 input: name.to_string(),
198 })
199 } else {
200 Ok(name.to_string())
201 }
202}
203
204fn escape_for_message(input: &str) -> String {
207 input.chars().flat_map(char::escape_default).collect()
208}
209
210#[cfg(test)]
211mod tests {
212 use super::*;
213 use crate::temporal::Temporal;
214
215 #[test]
216 fn string_property_key_is_accepted_by_reference() {
217 assert_eq!(
218 dynamic_property_key(&Value::String("name".into())).unwrap(),
219 "name"
220 );
221 }
222
223 #[test]
224 fn wrong_property_key_type_names_the_input_and_the_expected_type() {
225 let error = dynamic_property_key(&Value::Int(1)).unwrap_err();
226 assert_eq!(error.kind(), ErrorKind::InvalidArgumentType);
227 assert_eq!(
228 error.to_string(),
229 "Invalid input 'INTEGER' for node or relationship property key. Expected to be STRING."
230 );
231 }
232
233 #[test]
234 fn empty_and_nul_property_keys_are_invalid_names() {
235 for key in ["", "a\0b"] {
236 let error = dynamic_property_key(&Value::String(key.into())).unwrap_err();
237 assert_eq!(error.kind(), ErrorKind::SyntaxError);
238 assert!(error.to_string().starts_with(
239 "invalid name. A property key name cannot be empty or contain any null-bytes: '"
240 ));
241 }
242 }
243
244 #[test]
245 fn label_names_accept_a_string_and_a_string_list() {
246 assert_eq!(
247 dynamic_label_names(&Value::String("A".into())).unwrap(),
248 vec!["A".to_string()]
249 );
250 let list = Value::List(vec![Value::String("A".into()), Value::String("B".into())].into());
251 assert_eq!(
252 dynamic_label_names(&list).unwrap(),
253 vec!["A".to_string(), "B".to_string()]
254 );
255 }
256
257 #[test]
258 fn label_names_reject_non_string_and_invalid_elements() {
259 let wrong = dynamic_label_names(&Value::Int(1)).unwrap_err();
260 assert_eq!(
261 wrong.to_string(),
262 "Invalid input 'INTEGER' for dynamic label. Expected to be STRING or LIST<STRING>."
263 );
264 let mixed = Value::List(vec![Value::String("A".into()), Value::Int(1)].into());
265 assert_eq!(dynamic_label_names(&mixed).unwrap_err(), wrong);
266 assert!(dynamic_label_names(&Value::String("".into())).is_err());
267 }
268
269 #[test]
270 fn token_check_is_the_shared_validation_entry() {
271 DynamicNameToken::PropertyKey
272 .check(&Value::String("name".into()))
273 .unwrap();
274 DynamicNameToken::Label
275 .check(&Value::List(vec![Value::String("A".into())].into()))
276 .unwrap();
277 assert_eq!(
278 DynamicNameToken::PropertyKey
279 .check(&Value::Int(1))
280 .unwrap_err()
281 .kind(),
282 ErrorKind::InvalidArgumentType
283 );
284 assert_eq!(
285 DynamicNameToken::Label
286 .check(&Value::String("".into()))
287 .unwrap_err()
288 .kind(),
289 ErrorKind::SyntaxError
290 );
291 }
292
293 #[test]
297 fn accepts_type_is_the_type_half_of_check() {
298 assert!(DynamicNameToken::PropertyKey.accepts_type("STRING"));
299 assert!(!DynamicNameToken::PropertyKey.accepts_type("LIST"));
300 assert!(!DynamicNameToken::PropertyKey.accepts_type("INTEGER"));
301 assert!(DynamicNameToken::Label.accepts_type("STRING"));
302 assert!(DynamicNameToken::Label.accepts_type("LIST"));
303 assert!(!DynamicNameToken::Label.accepts_type("MAP"));
304 }
305
306 #[test]
310 fn error_conversion_follows_the_shared_classification() {
311 assert!(matches!(
312 Error::from(dynamic_property_key(&Value::Int(1)).unwrap_err()),
313 Error::InvalidArgumentType(_)
314 ));
315 assert!(matches!(
316 Error::from(dynamic_property_key(&Value::String("".into())).unwrap_err()),
317 Error::Syntax(_)
318 ));
319 }
320
321 #[test]
325 fn wrong_type_detail_orders_numerics_by_cip100_not_lexicographically() {
326 let mixed = Value::List(vec![Value::Float(1.5), Value::Int(1)].into());
327 assert_eq!(
328 dynamic_property_key(&mixed).unwrap_err().to_string(),
329 "Invalid input 'LIST<INTEGER | FLOAT>' for node or relationship property key. \
330 Expected to be STRING."
331 );
332 }
333
334 #[test]
337 fn wrong_type_detail_renders_the_temporal_spelling() {
338 let duration = Value::Temporal(Temporal::Duration {
339 months: 0,
340 days: 0,
341 nanos: 0,
342 });
343 assert_eq!(
344 dynamic_property_key(&duration).unwrap_err().to_string(),
345 "Invalid input 'DURATION' for node or relationship property key. \
346 Expected to be STRING."
347 );
348 let date = Value::Temporal(Temporal::CivilDate {
349 year: 2020,
350 month: 1,
351 day: 1,
352 });
353 assert_eq!(
354 dynamic_label_names(&date).unwrap_err().to_string(),
355 "Invalid input 'DATE' for dynamic label. Expected to be STRING or LIST<STRING>."
356 );
357 }
358}