taganak_orm/

lib.rs

//! ORM (object-relational mapper) for Rust dataypes onto Taganak graphs
//!
//! This ORM allows serializing Rust datatypes into RDF statements, and
//! deserializing them again from a known schema.
//!
//! As the ORM requires several complex traits to be implemented, the easiest way is
//! to use it with the [GraphORM](derive@GraphORM) derive macro.
//!
//! <div class="warning">The ORM is under heavy development and to be considered unstable.</div>
//!
//! # Example implementations
//!
//! Some example implemtations that show-case how the ORM can be used are
//! listed here as references.
//!
//! * [Taganak SDK RDF Test Cases runner](https://codeberg.org/Taganak/taganak-sdk/src/branch/main/core/tests/rdf_test_suites)

use taganak_core::{default_graph_view, prelude::*};

use futures::{Stream, StreamExt, TryFutureExt};

use taganak_core::graphs::{GraphError, GraphView};
use taganak_core::terms::{BlankNode, Literal};

use std::collections::{HashMap, HashSet};
use std::pin::pin;

use iref::IriRefBuf;
use thiserror::Error;

// FIXME should wrap inner error types for several things
#[derive(Debug, Error, PartialEq)]
pub enum GraphORMError {
    #[error("Failed to deserialize from graph: {0}")]
    FailedDeserialize(String),
    #[error("Failed to serialize to graph: {0}")]
    FailedSerialize(String),
    #[error("Failed to generate schema: {0}")]
    FailedSchema(String),
}

/// Defines the strategy for minting an RDF subject on serialisation
///
/// This marker is used by the [GraphORMMeta] wrapper to indicate the method
/// by which a subject for serialised RDF statements is chosen.
#[derive(Default, Debug, Clone, PartialEq)]
pub enum SubjectMode {
    /// The subject is generated from the designated subject field of the target,
    /// probably by calling its [GraphORM::rdf_subject] method.
    #[default]
    Generated,
    /// The subject is set to a pre-defined value, probably because it is known
    /// from a previous deserialisation.
    Static(Arc<Term>),
}

/// A descriptor to track meta information about the serialisation of some target
/// on the graph.
///
/// This is necessary because simply keeping the target object would cause loss
/// of information. For example, if a `struct` is deserialised from a graph (e.g.
/// by calling [GraphORM::deserialize]), the original subject needs to be noted.
#[derive(Debug, Clone, PartialEq)]
pub struct GraphORMMeta<T>
where
    T: std::fmt::Debug + PartialEq,
{
    subject_mode: SubjectMode,
    thing: T,
}

impl<T> core::ops::Deref for GraphORMMeta<T>
where
    T: std::fmt::Debug + PartialEq,
{
    type Target = T;

    fn deref(&self) -> &Self::Target {
        &self.thing
    }
}

impl<T> core::ops::DerefMut for GraphORMMeta<T>
where
    T: std::fmt::Debug + PartialEq,
{
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.thing
    }
}

impl<T> GraphORMMeta<T>
where
    T: GraphORM + Unpin + std::fmt::Debug + PartialEq + Sync + Send,
{
    /// Wrap a target into the descriptor.
    ///
    /// This function consumes the target and stores it.
    pub fn new(thing: T) -> Self {
        Self {
            subject_mode: SubjectMode::default(),
            thing,
        }
    }

    /// Unwrap the target.
    ///
    /// <div class="warning">
    /// This operation consumes the meta descriptor, thus causing any meta-information
    /// to be lost. Serializing the target later will require to re-create a valid
    /// [GraphORMMeta] wrtapper.
    /// </div>
    pub fn into_deref(self) -> T {
        self.thing
    }

    /// Add a pre-defined subject to the descriptor.
    ///
    /// Subsequent serialisations will use this subject.
    pub fn with_subject(mut self, subject: Arc<Term>) -> Self {
        self.subject_mode = SubjectMode::Static(subject);
        self
    }

    /// Fixate the subject generated by the target.
    ///
    /// This calls [GraphORM::rdf_subject] once and stores the generated
    /// subject for later re-use.
    ///
    /// If the subject mode already is [SubjectMode::Static], this function
    /// does not change the subject.
    pub fn fixate_subject(&mut self) -> Result<(), GraphORMError> {
        match self.subject_mode {
            SubjectMode::Generated => {
                self.subject_mode = SubjectMode::Static(self.thing.rdf_subject()?);
            }
            SubjectMode::Static(_) => {}
        };

        Ok(())
    }

    pub fn subject(&self) -> Result<Arc<Term>, GraphORMError> {
        match &self.subject_mode {
            SubjectMode::Generated => self.thing.rdf_subject(),
            SubjectMode::Static(s) => Ok(s.clone()),
        }
    }

    /// Serialise the target into a stream of triples.
    ///
    /// This is a proxy for [GraphORM::serialize_stream] of the target,
    /// injecting the desired subject.
    pub fn serialize_stream(
        &self,
    ) -> Result<impl Stream<Item = Arc<Triple>> + Unpin + Send + use<'_, T>, GraphORMError> {
        self.thing.serialize_stream(self.subject()?)
    }

    /// Serialize the target into an existing [Graph].
    ///
    /// This method calls the [Graph::merge_stream] method, passing the stream of
    /// triples for the target to it.
    pub async fn serialize(&self, graph: &mut impl Graph) -> Result<(), GraphORMError> {
        graph
            .merge_stream(
                self.stream()
                    .await
                    .map_err(|e| todo!("find matching error kind"))?,
            )
            .await
            .map_err(|e| todo!("find matching error kind"))?;
        Ok(())
    }
}

impl<T> Graph for GraphORMMeta<T>
where
    T: GraphORM + Unpin + std::fmt::Debug + PartialEq + Sync + Send,
{
    type View<'g>
        = &'g Self
    where
        Self: 'g;

    async fn view(&self) -> Self::View<'_> {
        self
    }
}

impl<'a, T> GraphView for &'a GraphORMMeta<T>
where
    T: GraphORM + Unpin + std::fmt::Debug + PartialEq + Sync + Send + 'a,
{
    type Stream =
        core::pin::Pin<Box<dyn Stream<Item = Result<Arc<Triple>, GraphError>> + Unpin + Send + 'a>>;
    async fn stream(self) -> Result<Self::Stream, GraphError> {
        Ok(Box::pin(
            self.serialize_stream()
                .map_err(|e| todo!("find matching error kind") as GraphError)?
                .map(|t| Ok(t)),
        ))
    }
    default_graph_view!();
}

pub trait GraphORM {
    /// Generate a subject.
    ///
    /// This method generates a subject term.
    ///
    /// It is called by [GraphORMMeta::serialize_stream] when using the
    /// [SubjectMode::Generated] strategy.
    ///
    /// The default implementation generates a new blank node.
    fn rdf_subject(&self) -> Result<Arc<Term>, GraphORMError> {
        Ok(Arc::new(Term::BlankNode(BlankNode::new())))
    }

    /// Generate the rdf:type of the target.
    ///
    /// The default implementation uses rdfs:Resource.
    fn rdf_type() -> Arc<Term> {
        todo!("default impl -> rdfs:Resource")
    }

    // FIXME split into serialize_schema_stream and serialize_stream
    // FIXME provide default implementation the yields our type being a rdfs:Class
    /// Generate the schema for the target.
    ///
    /// This method should generate triples representing an RDF schema for the
    /// target. The serialisation from [Self::serialize_stream] should be valid
    /// under this schema.
    ///
    /// There is no presumption about hte used entailment regime.
    async fn serialize_schema(graph: &mut impl Graph) -> Result<(), GraphORMError>;

    /// Serialise into a stream of triples.
    fn serialize_stream(
        &self,
        subject: Arc<Term>,
    ) -> Result<impl Stream<Item = Arc<Triple>> + Unpin + Send, GraphORMError>;

    /// Deserialize from a [Graph] by providing a known subject.
    async fn deserialize(
        graph: impl GraphView,
        subject: &Term,
    ) -> Result<GraphORMMeta<Self>, GraphORMError>
    where
        Self: Sized + std::fmt::Debug + PartialEq;

    /// Wrap into a [GraphOEMMeta] descriptor.
    fn into_meta(self) -> GraphORMMeta<Self>
    where
        Self: Sized + Unpin + std::fmt::Debug + PartialEq + Sync + Send,
    {
        GraphORMMeta::new(self)
    }
}

#[cfg(feature = "derive")]
mod magic {
    use async_stream::stream;
    use futures::stream;
    use std::collections::{BTreeMap, BTreeSet};

    #[doc(inline)]
    pub use taganak_orm_derive::*;

    pub mod re {
        //! This module re-exports items used by [taganak_orm_derive].
        pub use async_stream;
        pub use futures;
        pub use taganak_core::prelude::*;
        pub use tracing::trace;
    }
    use super::*;

    /// Trait for types that can be (de)serialised within a derived [GraphORM]
    /// implementor.
    ///
    /// Only needed for the automatic implementation of the [GraphORM](derive@GraphORM) derive
    /// macro. At derive time, the concrete types of fields in a struct cannot yet be resolved.
    /// Hence, it is necessary to choose the correct code paths solely by leveraging Rust's type
    /// system.
    ///
    /// <div class="warning">
    ///
    /// This trait should only be used internally by the [GraphORM](derive@GraphORM) derive macro,
    /// Do not try to implement it for your custom [GraphORM] implementations!
    ///
    /// </div>
    pub trait GraphORMField {
        /// Serialise into triples
        fn orm_triples(
            &self,
            subject: Option<&Term>,
            predicate: Option<&Term>,
        ) -> Result<impl Stream<Item = Arc<Triple>>, GraphORMError>;

        /// Deserialise a field from a graph.
        ///
        /// Because the field type is not known at derive time, we need this to partner with the
        /// generic function [get_graph_orm_field] and let Rust's type system call the correct
        /// implementation.
        async fn orm_field_from_graph(
            graph: impl GraphView,
            subject: &Term,
            predicate: &Term,
            object: Option<&Term>,
        ) -> Result<Self, GraphORMError>
        where
            Self: Sized;
    }

    impl<F> GraphORMField for GraphORMMeta<F>
    where
        F: GraphORMField + GraphORM + core::fmt::Debug + Unpin + Eq + Sync + Send,
    {
        fn orm_triples(
            &self,
            subject: Option<&Term>,
            predicate: Option<&Term>,
        ) -> Result<impl Stream<Item = Arc<Triple>>, GraphORMError> {
            Ok(Box::pin(stream! {
                    let subject = self.subject().unwrap();
                    let mut stream = pin!((**self).orm_triples(Some(subject.as_ref()), predicate).unwrap());
                    while let Some(triple) = stream.next().await {
                        yield triple;
                    }
            }))
        }

        async fn orm_field_from_graph(
            graph: impl GraphView,
            subject: &Term,
            predicate: &Term,
            object: Option<&Term>,
        ) -> Result<Self, GraphORMError>
        where
            Self: Sized,
        {
            let mut meta = GraphORMMeta::new(
                F::orm_field_from_graph(graph.clone(), subject, predicate, object).await?,
            );

            let matches_errfn = |e| {
                GraphORMError::FailedDeserialize(format!(
                    "failed to query graph for subject {subject}"
                ))
            };
            if let Some(Ok(t)) = pin!(graph
                .matches((Some(subject), Some(predicate), object), None)
                .await
                .map_err(matches_errfn)?
                .stream()
                .await
                .map_err(matches_errfn)?)
            .next()
            .await
            {
                meta = meta.with_subject(t.object_arc().clone());
            }

            Ok(meta)
        }
    }

    impl<F> GraphORMField for Option<F>
    where
        F: GraphORMField,
    {
        fn orm_triples(
            &self,
            subject: Option<&Term>,
            predicate: Option<&Term>,
        ) -> Result<impl Stream<Item = Arc<Triple>>, GraphORMError> {
            Ok(Box::pin(stream! {
                if let Some(f) = self {
                    let mut stream = pin!(f.orm_triples(subject, predicate).unwrap());
                    while let Some(triple) = stream.next().await {
                        yield triple;
                    }
                }
            }))
        }

        async fn orm_field_from_graph(
            graph: impl GraphView,
            subject: &Term,
            predicate: &Term,
            object: Option<&Term>,
        ) -> Result<Self, GraphORMError>
        where
            Self: Sized,
        {
            let matches_errfn = |e| {
                GraphORMError::FailedDeserialize(format!(
                    "failed to query graph for subject {subject}"
                ))
            };
            if pin!(graph
                .clone()
                .matches((Some(subject), Some(predicate), object), None)
                .await
                .map_err(matches_errfn)?
                .stream()
                .await
                .map_err(matches_errfn)?)
            .next()
            .await
            .is_some()
            {
                Ok(Some(
                    F::orm_field_from_graph(graph, subject, predicate, object).await?,
                ))
            } else {
                Ok(None)
            }
        }
    }

    impl<F> GraphORMField for Arc<F>
    where
        F: GraphORMField,
    {
        fn orm_triples(
            &self,
            subject: Option<&Term>,
            predicate: Option<&Term>,
        ) -> Result<impl Stream<Item = Arc<Triple>>, GraphORMError> {
            Ok(Box::pin(stream! {
                    let mut stream = pin!((**self).orm_triples(subject, predicate).unwrap());
                    while let Some(triple) = stream.next().await {
                        yield triple;
                    }
            }))
        }

        async fn orm_field_from_graph(
            graph: impl GraphView,
            subject: &Term,
            predicate: &Term,
            object: Option<&Term>,
        ) -> Result<Self, GraphORMError>
        where
            Self: Sized,
        {
            Ok(Arc::new(
                F::orm_field_from_graph(graph, subject, predicate, object).await?,
            ))
        }
    }

    impl<F> GraphORMField for HashSet<F>
    where
        F: GraphORMField + Eq + std::hash::Hash,
    {
        fn orm_triples(
            &self,
            subject: Option<&Term>,
            predicate: Option<&Term>,
        ) -> Result<impl Stream<Item = Arc<Triple>>, GraphORMError> {
            Ok(Box::pin(async_stream::stream! {
                // FIXME error handling
                for v in self {
                    let mut stream = pin!(v.orm_triples(subject, predicate).unwrap());
                    while let Some(triple) = stream.next().await {
                        yield triple;
                    }
                }
            }))
        }

        async fn orm_field_from_graph(
            graph: impl GraphView,
            subject: &Term,
            predicate: &Term,
            object: Option<&Term>,
        ) -> Result<Self, GraphORMError>
        where
            Self: Sized,
        {
            let mut set = HashSet::new();
            let matches_errfn = |e| {
                GraphORMError::FailedDeserialize(format!(
                    "failed to query graph for subject {subject}"
                ))
            };
            let mut triples = pin!(graph
                .clone()
                .matches((Some(subject), Some(predicate), object), None)
                .await
                .map_err(matches_errfn)?
                .stream()
                .await
                .map_err(matches_errfn)?);

            while let Some(triple) = triples.next().await {
                // FIXME
                let triple = triple.expect("handle error streams, actually");
                set.insert(
                    F::orm_field_from_graph(
                        graph.clone(),
                        subject,
                        predicate,
                        Some(triple.object()),
                    )
                    .await?,
                );
            }

            Ok(set)
        }
    }

    impl<F> GraphORMField for BTreeSet<F>
    where
        F: Ord + GraphORMField,
    {
        fn orm_triples(
            &self,
            subject: Option<&Term>,
            predicate: Option<&Term>,
        ) -> Result<impl Stream<Item = Arc<Triple>>, GraphORMError> {
            Ok(Box::pin(async_stream::stream! {
                // FIXME error handling
                for v in self {
                    let mut stream = pin!(v.orm_triples(subject, predicate).unwrap());
                    while let Some(triple) = stream.next().await {
                        yield triple;
                    }
                }
            }))
        }

        async fn orm_field_from_graph(
            graph: impl GraphView,
            subject: &Term,
            predicate: &Term,
            object: Option<&Term>,
        ) -> Result<Self, GraphORMError>
        where
            Self: Sized,
        {
            let matches_errfn = |e| {
                GraphORMError::FailedDeserialize(format!(
                    "failed to query graph for subject {subject}"
                ))
            };
            let mut set = BTreeSet::new();
            let mut triples = pin!(graph
                .clone()
                .matches((Some(subject), Some(predicate), object), None)
                .await
                .map_err(matches_errfn)?
                .stream()
                .await
                .map_err(matches_errfn)?);

            while let Some(triple) = triples.next().await {
                // FIXME
                let triple = triple.expect("handle error streams suitably");
                set.insert(
                    F::orm_field_from_graph(
                        graph.clone(),
                        subject,
                        predicate,
                        Some(triple.object()),
                    )
                    .await?,
                );
            }

            Ok(set)
        }
    }

    impl GraphORMField for Term {
        fn orm_triples(
            &self,
            subject: Option<&Term>,
            predicate: Option<&Term>,
        ) -> Result<impl Stream<Item = Arc<Triple>>, GraphORMError> {
            Ok(Box::pin(stream! {
                yield Triple::new(Arc::new(subject.unwrap().clone()), Arc::new(predicate.unwrap().clone()), Arc::new(self.clone())).unwrap();
            }))
        }

        async fn orm_field_from_graph(
            graph: impl GraphView,
            subject: &Term,
            predicate: &Term,
            object: Option<&Term>,
        ) -> Result<Self, GraphORMError>
        where
            Self: Sized,
        {
            let matches_errfn = |e| {
                GraphORMError::FailedDeserialize(format!(
                    "failed to query graph for subject {subject}"
                ))
            };
            Ok((*graph
                .object(Some(subject), Some(predicate))
                .await
                .map_err(matches_errfn)?
                .ok_or(GraphORMError::FailedDeserialize(format!(
                    "failed to query graph for subject {subject}"
                )))?)
            .clone())
        }
    }

    impl<F> GraphORMField for Vec<F>
    where
        F: GraphORMField,
    {
        fn orm_triples(
            &self,
            subject: Option<&Term>,
            predicate: Option<&Term>,
        ) -> Result<impl Stream<Item = Arc<Triple>>, GraphORMError> {
            Ok(Box::pin(async_stream::stream! {
                // FIXME error handling
                for v in self {
                    let mut stream = pin!(v.orm_triples(subject, predicate).unwrap());
                    while let Some(triple) = stream.next().await {
                        // FIXME broken!!!
                        yield triple;
                    }
                }
            }))
        }

        async fn orm_field_from_graph(
            graph: impl GraphView,
            subject: &Term,
            predicate: &Term,
            object: Option<&Term>,
        ) -> Result<Self, GraphORMError>
        where
            Self: Sized,
        {
            let mut items = Vec::new();

            let matches_errfn = |e| {
                GraphORMError::FailedDeserialize(format!(
                    "failed to query graph for subject {subject}"
                ))
            };

            let rdf_first = Term::NamedNode(
                Iri::new("http://www.w3.org/1999/02/22-rdf-syntax-ns#first".to_string()).unwrap(),
            );
            let rdf_rest = Term::NamedNode(
                Iri::new("http://www.w3.org/1999/02/22-rdf-syntax-ns#rest".to_string()).unwrap(),
            );
            let rdf_nil = Term::NamedNode(
                Iri::new("http://www.w3.org/1999/02/22-rdf-syntax-ns#nil".to_string()).unwrap(),
            );

            let mut current = (*graph
                .clone()
                .object(Some(subject), Some(predicate))
                .await
                .map_err(matches_errfn)?
                .ok_or(GraphORMError::FailedDeserialize(format!(
                    "failed to query graph for subject {subject}"
                )))?)
            .clone();
            let mut rest;
            loop {
                items.push(
                    F::orm_field_from_graph(graph.clone(), &current, &rdf_first, None).await?,
                );

                rest = graph
                    .clone()
                    .object(Some(&current), Some(&rdf_rest))
                    .await
                    .map_err(matches_errfn)?
                    .ok_or(GraphORMError::FailedDeserialize(
                        "not a valid RDF collection".to_string(),
                    ))?;
                if *rest == rdf_nil {
                    break;
                } else {
                    current = (*rest).clone();
                }
            }

            Ok(items)
        }
    }

    impl<F> GraphORMField for HashMap<Arc<Term>, F>
    where
        F: GraphORMField + Eq + std::hash::Hash,
    {
        fn orm_triples(
            &self,
            subject: Option<&Term>,
            predicate: Option<&Term>,
        ) -> Result<impl Stream<Item = Arc<Triple>>, GraphORMError> {
            Ok(Box::pin(async_stream::stream! {
                // FIXME error handling
                for v in self.values() {
                    let mut stream = pin!(v.orm_triples(subject, predicate).unwrap());
                    while let Some(triple) = stream.next().await {
                        yield triple;
                    }
                }
            }))
        }

        async fn orm_field_from_graph(
            graph: impl GraphView,
            subject: &Term,
            predicate: &Term,
            object: Option<&Term>,
        ) -> Result<Self, GraphORMError>
        where
            Self: Sized,
        {
            let matches_errfn = |e| {
                GraphORMError::FailedDeserialize(format!(
                    "failed to query graph for subject {subject}"
                ))
            };
            let mut map = HashMap::new();
            let mut triples = pin!(graph
                .clone()
                .matches((Some(subject), Some(predicate), object), None)
                .await
                .map_err(matches_errfn)?
                .stream()
                .await
                .map_err(matches_errfn)?);

            while let Some(triple) = triples.next().await {
                // FIXME
                let triple = triple.expect("handle error streams appropriately");
                map.insert(
                    Arc::new(triple.object().clone()),
                    F::orm_field_from_graph(
                        graph.clone(),
                        subject,
                        predicate,
                        Some(triple.object()),
                    )
                    .await?,
                );
            }

            Ok(map)
        }
    }
    /// Get the value of a field from a graph.
    ///
    /// This method is generic over the result type, in order for Rust's type system to
    /// choose the correct implementation of [GraphORMField::orm_field_from_graph].
    #[inline(always)]
    pub async fn get_graph_orm_field<F: GraphORMField>(
        graph: impl GraphView,
        subject: &Term,
        predicate: &Term,
        object: Option<&Term>,
    ) -> Result<F, GraphORMError> {
        F::orm_field_from_graph(graph, subject, predicate, object).await
    }

    pub trait GraphORMValue: TryFrom<Literal> + Clone
    where
        Literal: for<'a> TryFrom<Self>,
    {
    }

    impl GraphORMValue for u8 {}
    impl GraphORMValue for u16 {}
    impl GraphORMValue for u32 {}
    impl GraphORMValue for u64 {}
    impl GraphORMValue for u128 {}
    impl GraphORMValue for i8 {}
    impl GraphORMValue for i16 {}
    impl GraphORMValue for i32 {}
    impl GraphORMValue for i64 {}
    impl GraphORMValue for f32 {}
    impl GraphORMValue for f64 {}
    impl GraphORMValue for i128 {}
    impl GraphORMValue for String {}
    impl GraphORMValue for IriRefBuf {}
    impl GraphORMValue for bool {}
    #[cfg(feature = "chrono")]
    impl GraphORMValue for chrono::NaiveDate {}
    #[cfg(feature = "chrono")]
    impl GraphORMValue for chrono::NaiveTime {}
    #[cfg(feature = "chrono")]
    impl GraphORMValue for chrono::NaiveDateTime {}
    #[cfg(feature = "decimal")]
    impl GraphORMValue for rust_decimal::Decimal {}

    impl<V> GraphORMField for V
    where
        V: GraphORMValue,
        Literal: TryFrom<V>,
    {
        fn orm_triples(
            &self,
            subject: Option<&Term>,
            predicate: Option<&Term>,
        ) -> Result<impl Stream<Item = Arc<Triple>>, GraphORMError> {
            let subject = Arc::new(subject.unwrap().clone());
            let predicate = Arc::new(predicate.unwrap().clone());

            Ok(Box::pin(async_stream::stream! {
                // FIXME error handling
                let object = Arc::new(Term::Literal(self.clone().try_into().map_err(|e| GraphORMError::FailedSerialize("failed to convert into literal".to_string())).unwrap()));
                yield Triple::new(subject.clone(), predicate.clone(), object).unwrap();
            }))
        }

        async fn orm_field_from_graph(
            graph: impl GraphView,
            subject: &Term,
            predicate: &Term,
            object: Option<&Term>,
        ) -> Result<Self, GraphORMError>
        where
            Self: Sized,
        {
            let matches_errfn = |e| {
                GraphORMError::FailedDeserialize(format!(
                    "failed to query graph for subject {subject}"
                ))
            };
            pin!(graph
                .matches((Some(subject), Some(predicate), object), Some(1))
                .await
                .map_err(matches_errfn)?
                .stream()
                .await
                .map_err(matches_errfn)?)
            .next()
            .await
            .ok_or(GraphORMError::FailedDeserialize(format!(
                "predicate {} not found for subject {}",
                predicate, subject
            )))?
            .unwrap() // FIXME: handle error of stream
            .object()
            .to_literal()
            .map_err(|e| GraphORMError::FailedDeserialize("object is not a literal".to_string()))?
            .clone()
            .try_into()
            .map_err(|e| {
                GraphORMError::FailedDeserialize("failed to parse value into literal".to_string())
            })
        }
    }
}

#[cfg(feature = "derive")]
#[doc(inline)]
pub use self::magic::*;