use littlegraph_core::{NodeValue, PathValue, RelationshipValue, Value};
use serde_json::{json, Map};
use crate::error::HttpError;
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(crate) enum ValueView {
Plain,
Typed,
}
pub(crate) fn encode(value: &Value, view: ValueView) -> Result<serde_json::Value, HttpError> {
if view == ValueView::Plain {
encode_plain(value)
} else {
encode_typed(value)
}
}
fn encode_plain(value: &Value) -> Result<serde_json::Value, HttpError> {
match value {
Value::Null => Ok(serde_json::Value::Null),
Value::Boolean(value) => Ok((*value).into()),
Value::Integer(value) => Ok((*value).into()),
Value::Float(value) => serde_json::Number::from_f64(*value)
.map(serde_json::Value::Number)
.ok_or_else(|| HttpError::invalid("query result contains a non-finite float")),
Value::String(value) => Ok(value.clone().into()),
Value::List(values) => values
.iter()
.map(encode_plain)
.collect::<Result<Vec<_>, _>>()
.map(serde_json::Value::Array),
Value::Map(values) => values
.iter()
.map(|(key, value)| encode_plain(value).map(|value| (key.clone(), value)))
.collect::<Result<Map<_, _>, _>>()
.map(serde_json::Value::Object),
Value::Node(node) => encode_node(node, ValueView::Plain),
Value::Relationship(relationship) => encode_relationship(relationship, ValueView::Plain),
Value::Path(path) => encode_path(path, ValueView::Plain),
_ => Err(HttpError::invalid(
"query result contains an unsupported value type",
)),
}
}
fn encode_typed(value: &Value) -> Result<serde_json::Value, HttpError> {
let (kind, inner) = match value {
Value::Null => ("Null", serde_json::Value::Null),
Value::Boolean(value) => ("Boolean", (*value).into()),
Value::Integer(value) => ("Integer", value.to_string().into()),
Value::Float(value) if value.is_finite() => ("Float", value.to_string().into()),
Value::Float(_) => {
return Err(HttpError::invalid(
"query result contains a non-finite float",
))
}
Value::String(value) => ("String", value.clone().into()),
Value::List(values) => (
"List",
serde_json::Value::Array(
values
.iter()
.map(encode_typed)
.collect::<Result<Vec<_>, _>>()?,
),
),
Value::Map(values) => (
"Map",
serde_json::Value::Object(
values
.iter()
.map(|(key, value)| encode_typed(value).map(|value| (key.clone(), value)))
.collect::<Result<Map<_, _>, _>>()?,
),
),
Value::Node(node) => return encode_node(node, ValueView::Typed),
Value::Relationship(relationship) => {
return encode_relationship(relationship, ValueView::Typed)
}
Value::Path(path) => return encode_path(path, ValueView::Typed),
_ => {
return Err(HttpError::invalid(
"query result contains an unsupported value type",
))
}
};
Ok(json!({"$type": kind, "_value": inner}))
}
fn encode_node(node: &NodeValue, view: ValueView) -> Result<serde_json::Value, HttpError> {
let properties = node
.properties
.iter()
.map(|(key, value)| encode(value, view).map(|value| (key.clone(), value)))
.collect::<Result<Map<_, _>, _>>()?;
let inner = if view == ValueView::Plain {
json!({
"elementId": node.id,
"labels": node.labels,
"properties": properties,
})
} else {
json!({
"_element_id": node.id,
"_labels": node.labels,
"_properties": properties,
})
};
Ok(if view == ValueView::Plain {
inner
} else {
json!({"$type": "Node", "_value": inner})
})
}
fn encode_relationship(
relationship: &RelationshipValue,
view: ValueView,
) -> Result<serde_json::Value, HttpError> {
let properties = relationship
.properties
.iter()
.map(|(key, value)| encode(value, view).map(|value| (key.clone(), value)))
.collect::<Result<Map<_, _>, _>>()?;
let inner = if view == ValueView::Plain {
json!({
"elementId": relationship.id,
"startNodeElementId": relationship.start,
"endNodeElementId": relationship.end,
"type": relationship.r#type,
"properties": properties,
})
} else {
json!({
"_element_id": relationship.id,
"_start_node_element_id": relationship.start,
"_end_node_element_id": relationship.end,
"_type": relationship.r#type,
"_properties": properties,
})
};
Ok(if view == ValueView::Plain {
inner
} else {
json!({"$type": "Relationship", "_value": inner})
})
}
fn encode_path(path: &PathValue, view: ValueView) -> Result<serde_json::Value, HttpError> {
let mut values = Vec::with_capacity(path.nodes.len() + path.relationships.len());
for (index, node) in path.nodes.iter().enumerate() {
values.push(encode_node(node, view)?);
if let Some(relationship) = path.relationships.get(index) {
values.push(encode_relationship(relationship, view)?);
}
}
let value = serde_json::Value::Array(values);
Ok(if view == ValueView::Plain {
value
} else {
json!({"$type": "Path", "_value": value})
})
}
#[cfg(test)]
mod tests {
use std::collections::BTreeMap;
use littlegraph_core::{NodeValue, Value};
use super::*;
#[test]
fn encodes_plain_and_typed_scalars() {
assert_eq!(
encode(&Value::Integer(42), ValueView::Plain).unwrap(),
json!(42)
);
assert_eq!(
encode(&Value::Integer(42), ValueView::Typed).unwrap(),
json!({"$type": "Integer", "_value": "42"})
);
}
#[test]
fn encodes_typed_nodes_with_typed_properties() {
let node = Value::Node(NodeValue::stored(
1,
"4:node:1".into(),
vec!["Person".into()],
BTreeMap::from([("age".into(), Value::Integer(42))]),
));
let encoded = encode(&node, ValueView::Typed).unwrap();
assert_eq!(encoded["$type"], "Node");
assert_eq!(encoded["_value"]["_element_id"], "4:node:1");
assert_eq!(encoded["_value"]["_properties"]["age"]["$type"], "Integer");
}
}