Basic creation/updating of metadata in .raph for MetaGraph

.github/workflows/test_rust_disk_storage_workflow.yml

@@ -18,7 +18,7 @@ jobs:
       matrix:
         include:
           - { os: macos-latest, flags: "" }
-          - { os: ubuntu-20.04, flags: "-C link-arg=-fuse-ld=lld" }
+          - { os: ubuntu-latest, flags: "-C link-arg=-fuse-ld=lld" }
           - { os: windows-latest, flags: "" }
     steps:
       - uses: maxim-lobanov/setup-xcode@v1

.github/workflows/test_rust_workflow.yml

@@ -18,7 +18,7 @@ jobs:
       matrix:
         include:
           - os: macos-latest
-          - os: ubuntu-20.04
+          - os: ubuntu-latest
           - os: windows-latest
     steps:
       - uses: maxim-lobanov/setup-xcode@v1

raphtory-graphql/src/lib.rs

@@ -920,7 +920,7 @@ mod graphql_test {
         let mut req = Request::new(query).variables(Variables::from_json(variables));
         req.set_upload("variables.file", upload_val);
         let res = schema.execute(req).await;
-        assert_eq!(res.errors.len(), 0);
+        assert_eq!(res.errors, vec![]);
         let res_json = res.data.into_json().unwrap();
         assert_eq!(res_json, json!({"uploadGraph": "test"}));
 
@@ -1202,4 +1202,166 @@ mod graphql_test {
             }),
         );
     }
+
+    #[tokio::test]
+    async fn test_query_namespace() {
+        let graph = Graph::new();
+        graph.add_constant_properties([("name", "graph")]).unwrap();
+        graph.add_node(1, 1, NO_PROPS, Some("a")).unwrap();
+        graph.add_node(1, 2, NO_PROPS, Some("b")).unwrap();
+        graph.add_node(1, 3, NO_PROPS, Some("b")).unwrap();
+        graph.add_node(1, 4, NO_PROPS, Some("a")).unwrap();
+        graph.add_node(1, 5, NO_PROPS, Some("c")).unwrap();
+        graph.add_node(1, 6, NO_PROPS, Some("e")).unwrap();
+        graph.add_edge(2, 1, 2, NO_PROPS, Some("a")).unwrap();
+        graph.add_edge(2, 3, 2, NO_PROPS, Some("a")).unwrap();
+        graph.add_edge(2, 2, 4, NO_PROPS, Some("a")).unwrap();
+        graph.add_edge(2, 4, 5, NO_PROPS, Some("a")).unwrap();
+        graph.add_edge(2, 4, 5, NO_PROPS, Some("a")).unwrap();
+        graph.add_edge(2, 5, 6, NO_PROPS, Some("a")).unwrap();
+        graph.add_edge(2, 3, 6, NO_PROPS, Some("a")).unwrap();
+
+        let graph = graph.into();
+        let graphs = HashMap::from([("graph".to_string(), graph)]);
+        let tmp_dir = tempdir().unwrap();
+        save_graphs_to_work_dir(tmp_dir.path(), &graphs).unwrap();
+
+        let data = Data::new(tmp_dir.path(), &AppConfig::default());
+        let schema = App::create_schema().data(data).finish().unwrap();
+
+        let req = r#"
+        {
+          namespace(path: "") {
+            path
+            graphs {
+              path
+              name
+              metadata {
+                nodeCount
+                edgeCount
+                properties {
+                  key
+                  value
+                }
+              }
+            }
+            children {
+              path
+            }
+            parent {
+              path
+            }
+          }
+        }
+        "#;
+
+        let req = Request::new(req);
+        let res = schema.execute(req).await;
+        let data = res.data.into_json().unwrap();
+        assert_eq!(
+            data,
+            json!({
+                "namespace": {
+                    "path": "",
+                    "graphs": [
+                        {
+                            "path": "graph",
+                            "name": "graph",
+                            "metadata": {
+                                "nodeCount": 6,
+                                "edgeCount": 6,
+                                "properties": [
+                                    {
+                                        "key": "name",
+                                        "value": "graph"
+                                    },
+                                ]
+                            }
+                        },
+                    ],
+                    "children": [],
+                    "parent": null
+                },
+            }),
+        );
+
+        let req = r#"
+        mutation CreateSubgraph {
+          createSubgraph(parentPath: "graph", newPath: "graph2", nodes: ["1", "2"], overwrite: false)
+        }
+        "#;
+        let req = Request::new(req);
+        let res = schema.execute(req).await;
+        assert_eq!(res.errors, vec![]);
+
+        let req = r#"
+        {
+          namespace(path: "") {
+            path
+            graphs {
+              path
+              name
+              metadata {
+                nodeCount
+                edgeCount
+                properties {
+                  key
+                  value
+                }
+              }
+            }
+            children {
+              path
+            }
+            parent {
+              path
+            }
+          }
+        }
+        "#;
+
+        let req = Request::new(req);
+        let res = schema.execute(req).await;
+        let data = res.data.into_json().unwrap();
+        assert_eq!(
+            data,
+            json!({
+                "namespace": {
+                    "path": "",
+                    "graphs": [
+                        {
+                            "path": "graph",
+                            "name": "graph",
+                            "metadata": {
+                                "nodeCount": 6,
+                                "edgeCount": 6,
+                                "properties": [
+                                    {
+                                        "key": "name",
+                                        "value": "graph"
+                                    },
+                                ]
+                            }
+                        },
+                        {
+                            "path": "graph2",
+                            "name": "graph2",
+                            "metadata": {
+                                "nodeCount": 2,
+                                "edgeCount": 1,
+                                "properties": [
+                                    {
+                                        "key": "name",
+                                        "value": "graph"
+                                    },
+                                ]
+                            }
+                        },
+                    ],
+                    "children": [],
+                    "parent": null
+                },
+            }),
+        );
+    }
 }

raphtory-graphql/src/model/graph/meta_graph.rs

@@ -1,7 +1,6 @@
-use dynamic_graphql::{ResolvedObject, ResolvedObjectFields};
-use raphtory::core::utils::errors::GraphError;
-
-use crate::paths::ExistingGraphFolder;
+use crate::{model::graph::property::GqlProp, paths::ExistingGraphFolder};
+use dynamic_graphql::{ResolvedObject, ResolvedObjectFields, SimpleObject};
+use raphtory::{core::utils::errors::GraphError, serialise::metadata::GraphMetadata};
 
 #[derive(ResolvedObject)]
 pub(crate) struct MetaGraph {
@@ -31,4 +30,29 @@ impl MetaGraph {
     async fn last_updated(&self) -> Result<i64, GraphError> {
         self.folder.last_updated()
     }
+    async fn metadata(&self) -> Result<GqlGraphMetadata, GraphError> {
+        let metadata = self.folder.read_metadata()?;
+        Ok(GqlGraphMetadata::from(metadata))
+    }
+}
+
+#[derive(Clone, SimpleObject)]
+pub(crate) struct GqlGraphMetadata {
+    pub(crate) node_count: usize,
+    pub(crate) edge_count: usize,
+    pub(crate) properties: Vec<GqlProp>,
+}
+
+impl From<GraphMetadata> for GqlGraphMetadata {
+    fn from(metadata: GraphMetadata) -> Self {
+        GqlGraphMetadata {
+            node_count: metadata.node_count,
+            edge_count: metadata.edge_count,
+            properties: metadata
+                .properties
+                .into_iter()
+                .map(|(key, prop)| GqlProp::new(key.to_string(), prop))
+                .collect(),
+        }
+    }
 }

raphtory-graphql/src/model/graph/namespace.rs

@@ -1,9 +1,10 @@
 use crate::{
     data::get_relative_path,
     model::graph::meta_graph::MetaGraph,
-    paths::{valid_path, ExistingGraphFolder},
+    paths::{valid_path, ExistingGraphFolder, ValidGraphFolder},
 };
 use dynamic_graphql::{ResolvedObject, ResolvedObjectFields};
+use itertools::Itertools;
 use std::path::PathBuf;
 use walkdir::WalkDir;
 
@@ -60,7 +61,14 @@ impl Namespace {
 impl Namespace {
     async fn graphs(&self) -> Vec<MetaGraph> {
         self.get_all_graph_folders()
-            .iter()
+            .into_iter()
+            .sorted_by(|a, b| {
+                let a_as_valid_folder: ValidGraphFolder = a.clone().into();
+                let b_as_valid_folder: ValidGraphFolder = b.clone().into();
+                a_as_valid_folder
+                    .get_original_path_str()
+                    .cmp(b_as_valid_folder.get_original_path_str())
+            })
             .map(|g| MetaGraph::new(g.clone()))
             .collect()
     }

raphtory-graphql/src/model/graph/property.rs

@@ -1,8 +1,5 @@
 use async_graphql::{Error, Name, Value as GqlValue};
-use dynamic_graphql::{
-    internal::{InputObject, Resolve},
-    Enum, InputObject, ResolvedObject, ResolvedObjectFields, Scalar, ScalarValue,
-};
+use dynamic_graphql::{InputObject, ResolvedObject, ResolvedObjectFields, Scalar, ScalarValue};
 use itertools::Itertools;
 use raphtory::{
     core::{utils::errors::GraphError, IntoPropMap, Prop},
@@ -144,7 +141,7 @@ fn prop_to_gql(prop: &Prop) -> GqlValue {
     }
 }
 
-#[derive(ResolvedObject)]
+#[derive(Clone, ResolvedObject)]
 pub(crate) struct GqlProp {
     key: String,
     prop: Prop,
@@ -354,7 +351,7 @@ impl GqlProperties {
         self.props.temporal().into()
     }
 
-    async fn constant(&self) -> GqlConstantProperties {
+    pub(crate) async fn constant(&self) -> GqlConstantProperties {
         self.props.constant().into()
     }
 }
@@ -373,7 +370,7 @@ impl GqlConstantProperties {
         self.props.keys().map(|k| k.clone().into()).collect()
     }
 
-    async fn values(&self, keys: Option<Vec<String>>) -> Vec<GqlProp> {
+    pub(crate) async fn values(&self, keys: Option<Vec<String>>) -> Vec<GqlProp> {
         match keys {
             Some(keys) => self
                 .props

raphtory-graphql/src/paths.rs

@@ -1,15 +1,14 @@
+use raphtory::{
+    core::utils::errors::{GraphError, InvalidPathReason, InvalidPathReason::*},
+    serialise::GraphFolder,
+};
 use std::{
     fs,
     ops::Deref,
     path::{Component, Path, PathBuf},
     time::{SystemTime, UNIX_EPOCH},
 };
 
-use raphtory::{
-    core::utils::errors::{GraphError, InvalidPathReason, InvalidPathReason::*},
-    serialise::GraphFolder,
-};
-
 #[derive(Clone, Debug)]
 pub struct ExistingGraphFolder {
     folder: ValidGraphFolder,
@@ -34,7 +33,6 @@ impl From<ExistingGraphFolder> for GraphFolder {
         value.folder.folder
     }
 }
-
 impl ExistingGraphFolder {
     pub(crate) fn try_from(base_path: PathBuf, relative_path: &str) -> Result<Self, GraphError> {
         let graph_folder = ValidGraphFolder::try_from(base_path, relative_path)?;
@@ -72,6 +70,12 @@ pub struct ValidGraphFolder {
     folder: GraphFolder,
 }
 
+impl From<ExistingGraphFolder> for ValidGraphFolder {
+    fn from(value: ExistingGraphFolder) -> Self {
+        value.folder
+    }
+}
+
 impl Deref for ValidGraphFolder {
     type Target = GraphFolder;
 

raphtory/src/core/utils/errors.rs

@@ -316,8 +316,8 @@ pub enum GraphError {
     TqdmError,
     #[error("An error when parsing Jinja query templates: {0}")]
     JinjaError(String),
-    #[error("An error when parsing the data to json")]
-    SerdeError,
+    #[error("An error when parsing the data to json: {0}")]
+    SerdeError(#[from] serde_json::Error),
     #[error("System time error: {0}")]
     SystemTimeError(#[from] SystemTimeError),
     #[error("Property filtering not implemented on PersistentGraph yet")]

raphtory/src/db/api/storage/storage.rs

@@ -122,10 +122,8 @@ impl Storage {
     /// Initialise the cache by pointing it at a proto file.
     /// Future updates will be appended to the cache.
     pub(crate) fn init_cache(&self, path: &GraphFolder) -> Result<(), GraphError> {
-        self.cache.get_or_try_init(|| {
-            let file = path.get_appendable_graph_file()?;
-            Ok::<_, GraphError>(GraphWriter::new(file))
-        })?;
+        self.cache
+            .get_or_try_init(|| Ok::<_, GraphError>(GraphWriter::new(path.clone())?))?;
         Ok(())
     }