littlegraph-query-api 0.2.1

Neo4j-compatible HTTP Query API for the littlegraph database
Documentation
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");
    }
}