Implement error types & handling of them on the frontend

Cargo.toml

@@ -45,10 +45,12 @@
             "webgl",
         ], git="https://github.com/WebVOWL/WasmGrapher"}
         horned-owl={git="https://github.com/phillord/horned-owl", rev="c4f7835ecae70b5e7281dc23b9b7fc6daa497f1d"}
+        leptos={version="0.8.16", features=["nightly", "multipart", "rkyv"]}
         log="0.4"
         rdf-fusion="0.1.0"
         rkyv="0.8.12"
         smallvec={version="1.15.1", features=["union"]}
+        strum={version="0.27", features=["derive"]}
         tokio="1.48.0"
 
 [dependencies]
@@ -67,16 +69,16 @@
     futures={workspace=true}
     getrandom={version="0.3", features=["wasm_js"]}
     gloo-timers="0.2"
-    grapher={workspace=true}
+    grapher.workspace=true
     http={version="1.3.1", optional=true}
-    leptos={version="0.8.16", features=["nightly", "multipart", "rkyv"]}
+    leptos.workspace=true
     leptos_actix={version="0.8.7", optional=true}
     leptos_meta={version="0.8.6"}
     leptos_router={version="0.8.12", features=["nightly"]}
-    log={workspace=true}
+    log.workspace=true
     rayon="1.10"
     reqwest={version="0.12.24", optional=true, features=["json", "stream"]}
-    rkyv={workspace=true}
+    rkyv.workspace=true
     tokio={workspace=true, optional=true}
     vowlr-database={path="crates/database", optional=true}
     vowlr-parser={path="crates/parser", optional=true}
@@ -113,6 +115,7 @@
             "HtmlInputElement",
             "HtmlCollection",
             "Blob",
+            "BlobPropertyBag",
         ]
 
 
@@ -127,6 +130,7 @@
         "dep:vowlr-database",
         "dep:vowlr-parser",
         "leptos-use/actix",
+        "vowlr-util/server",
     ]
     ssr=[
         "dep:actix-files",

crates/database/src/errors.rs

@@ -0,0 +1,73 @@
+use std::panic::Location;
+
+use crate::serializers::Triple;
+use oxrdf::{BlankNodeIdParseError, IriParseError};
+use vowlr_util::prelude::{ErrorRecord, ErrorSeverity, ErrorType};
+
+#[derive(Debug)]
+pub enum SerializationErrorKind {
+    /// An error raised when the object of a triple is required but missing.
+    MissingObject(Triple, String),
+    /// An error raised when the subject of a triple is required but missing.
+    MissingSubject(Triple, String),
+    /// An error raised when the serializer encountered an unrecoverable problem.
+    SerializationFailed(Triple, String),
+    /// An error raised during Iri or IriRef validation.
+    IriParseError(String, IriParseError),
+    /// An error raised during BlankNode IDs validation
+    BlankNodeParseError(String, BlankNodeIdParseError),
+}
+
+#[derive(Debug)]
+pub struct SerializationError {
+    /// The contained error type.
+    inner: SerializationErrorKind,
+    /// The error's location in the source code.
+    location: &'static Location<'static>,
+}
+impl std::fmt::Display for SerializationError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{:?}", self.inner)
+    }
+}
+
+impl From<SerializationErrorKind> for SerializationError {
+    #[track_caller]
+    fn from(error: SerializationErrorKind) -> Self {
+        SerializationError {
+            inner: error,
+            location: Location::caller(),
+        }
+    }
+}
+
+impl From<SerializationError> for ErrorRecord {
+    fn from(value: SerializationError) -> Self {
+        let (message, severity) = match value.inner {
+            SerializationErrorKind::MissingObject(triple, e) => {
+                (format!("{e}:\n{triple}"), ErrorSeverity::Warning)
+            }
+            SerializationErrorKind::MissingSubject(triple, e) => {
+                (format!("{e}:\n{triple}"), ErrorSeverity::Warning)
+            }
+            SerializationErrorKind::SerializationFailed(triple, e) => {
+                (format!("{e}:\n{triple}"), ErrorSeverity::Critical)
+            }
+            SerializationErrorKind::IriParseError(iri, iri_parse_error) => (
+                format!("{iri_parse_error} (IRI: {iri})"),
+                ErrorSeverity::Error,
+            ),
+            SerializationErrorKind::BlankNodeParseError(id, blank_node_id_parse_error) => (
+                format!("{blank_node_id_parse_error} (ID: {id})"),
+                ErrorSeverity::Error,
+            ),
+        };
+        ErrorRecord::new(
+            severity,
+            ErrorType::Serializer,
+            message,
+            #[cfg(debug_assertions)]
+            Some(value.location.to_string()),
+        )
+    }
+}

crates/database/src/lib.rs

@@ -1,11 +1,4 @@
-use std::fmt::{Display, Formatter};
-
-use grapher::prelude::{ElementType, OwlEdge, OwlType, RdfEdge, RdfType};
-use oxrdf::{BlankNodeIdParseError, IriParseError};
-use vowlr_parser::errors::VOWLRStoreError;
-
-use crate::serializers::Triple;
-
+mod errors;
 pub mod serializers;
 pub mod store;
 pub mod vocab;
@@ -16,93 +9,3 @@ pub mod prelude {
 
     pub use crate::store::VOWLRStore;
 }
-
-pub const SYMMETRIC_EDGE_TYPES: [ElementType; 1] =
-    [ElementType::Owl(OwlType::Edge(OwlEdge::DisjointWith))];
-
-pub const PROPERTY_EDGE_TYPES: [ElementType; 7] = [
-    ElementType::Owl(OwlType::Edge(OwlEdge::ObjectProperty)),
-    ElementType::Owl(OwlType::Edge(OwlEdge::DatatypeProperty)),
-    ElementType::Owl(OwlType::Edge(OwlEdge::DeprecatedProperty)),
-    ElementType::Owl(OwlType::Edge(OwlEdge::ExternalProperty)),
-    ElementType::Owl(OwlType::Edge(OwlEdge::ValuesFrom)),
-    ElementType::Owl(OwlType::Edge(OwlEdge::InverseOf)),
-    ElementType::Rdf(RdfType::Edge(RdfEdge::RdfProperty)),
-];
-
-pub trait SerializationErrorExt {
-    fn triple(&self) -> Option<&Triple>;
-}
-
-macro_rules! ser_err {
-    ($variant:ident($triple:expr, $msg:expr)) => {
-        $crate::SerializationErrorKind::$variant(($triple).map(Box::new), $msg)
-    };
-}
-pub(crate) use ser_err;
-
-#[derive(Debug)]
-pub enum SerializationErrorKind {
-    MissingObject(Option<Box<Triple>>, String),
-    MissingSubject(Option<Box<Triple>>, String),
-    SerializationFailed(Option<Box<Triple>>, String),
-    IriParseError(Option<Box<Triple>>, Box<IriParseError>),
-    BlankNodeParseError(Option<Box<Triple>>, Box<BlankNodeIdParseError>),
-}
-impl SerializationErrorExt for SerializationErrorKind {
-    fn triple(&self) -> Option<&Triple> {
-        match &self {
-            SerializationErrorKind::MissingObject(triple, _)
-            | SerializationErrorKind::MissingSubject(triple, _)
-            | SerializationErrorKind::SerializationFailed(triple, _)
-            | SerializationErrorKind::IriParseError(triple, _)
-            | SerializationErrorKind::BlankNodeParseError(triple, _) => {
-                triple.as_ref().map(|t| &**t)
-            }
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct SerializationError {
-    inner: SerializationErrorKind,
-}
-impl Display for SerializationError {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        write!(f, "SerializationError: {:?}", self.inner)
-    }
-}
-
-impl SerializationErrorExt for SerializationError {
-    fn triple(&self) -> Option<&Triple> {
-        self.inner.triple()
-    }
-}
-
-impl From<SerializationErrorKind> for SerializationError {
-    fn from(error: SerializationErrorKind) -> Self {
-        SerializationError { inner: error }
-    }
-}
-
-impl From<IriParseError> for SerializationError {
-    fn from(error: IriParseError) -> Self {
-        SerializationError {
-            inner: SerializationErrorKind::IriParseError(None, Box::new(error)),
-        }
-    }
-}
-
-impl From<SerializationError> for VOWLRStoreError {
-    fn from(error: SerializationError) -> Self {
-        VOWLRStoreError::from(error.to_string())
-    }
-}
-
-impl From<BlankNodeIdParseError> for SerializationError {
-    fn from(error: BlankNodeIdParseError) -> Self {
-        SerializationError {
-            inner: SerializationErrorKind::BlankNodeParseError(None, Box::new(error)),
-        }
-    }
-}

crates/database/src/serializers.rs

@@ -7,8 +7,9 @@ use std::{
 use grapher::prelude::{ElementType, GraphDisplayData, OwlEdge, OwlType};
 use log::error;
 use oxrdf::Term;
+use vowlr_util::prelude::ErrorRecord;
 
-use crate::{PROPERTY_EDGE_TYPES, SYMMETRIC_EDGE_TYPES};
+use crate::serializers::util::{PROPERTY_EDGE_TYPES, SYMMETRIC_EDGE_TYPES};
 
 pub mod frontend;
 pub mod util;
@@ -221,15 +222,8 @@ pub struct SerializationDataBuffer {
     ///   can be either the subject, object or both (in this case, subject is used)
     /// - Value = The unresolved triples.
     unknown_buffer: HashMap<Term, HashSet<Triple>>,
-    /// Stores triples that are impossible to serialize.
-    ///
-    /// This could be caused by various reasons, such as
-    /// visualization of the triple is not supported.
-    ///
-    /// Each element is a tuple of:
-    /// - 0 = The triple (if any).
-    /// - 1 = The reason it failed to serialize (or the message if no triple is available).
-    failed_buffer: Vec<(Option<Triple>, String)>,
+    /// Stores errors encountered during serialization.
+    failed_buffer: Vec<ErrorRecord>,
     /// The base IRI of the document.
     ///
     /// For instance: `http://purl.obolibrary.org/obo/envo.owl`
@@ -409,17 +403,9 @@ impl Display for SerializationDataBuffer {
                     .join("\n")
             )?;
         }
-        writeln!(f, "\tfailed_buffer:")?;
-        for (triple, reason) in self.failed_buffer.iter() {
-            match triple {
-                Some(triple) => {
-                    writeln!(f, "\t\t{} : {}", triple, reason)?;
-                }
-                None => {
-                    writeln!(f, "\t\tNO TRIPLE : {}", reason)?;
-                }
-            }
-        }
+        // Not needed as it's displayed by the serializer
+        // writeln!(f, "\tfailed_buffer:")?;
+        // writeln!(f, "{}", ErrorRecord::format_records(&self.failed_buffer))?;
         writeln!(f, "}}")
     }
 }