Reduce area of tiled API being wrapped

src/model/app.rs

@@ -1,15 +1,12 @@
 use async_graphql::SimpleObject;
-use serde::{Deserialize, Serialize};
+use serde::Deserialize;
 use serde_json::Value;
 
-use crate::model::node;
-
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, SimpleObject)]
+#[derive(Debug, Clone, PartialEq, Deserialize, SimpleObject)]
 pub struct AppMetadata {
     pub api_version: i64,
     pub library_version: String,
     pub queries: Vec<String>,
-    pub links: node::Links,
     pub meta: Value,
 }
 

src/model/container.rs

@@ -1,11 +1,10 @@
-use async_graphql::{SimpleObject, Union};
-use serde::{Deserialize, Serialize};
+use serde::Deserialize;
 use serde_json::Value;
 
 use crate::model::event_stream;
 use crate::model::run::{self, Start};
 
-#[derive(Union, Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[derive(Debug, Clone, PartialEq, Deserialize)]
 #[serde(rename_all = "lowercase", untagged)]
 pub enum ContainerMetadata {
     Run(Box<run::RunMetadata>),
@@ -22,8 +21,8 @@ impl ContainerMetadata {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, SimpleObject)]
+#[derive(Debug, Clone, PartialEq, Deserialize)]
 pub struct ContainerStructure {
-    pub contents: Value,
-    pub count: i64,
+    contents: Value,
+    count: i64,
 }

src/model/node.rs

@@ -1,17 +1,16 @@
 use std::collections::HashMap;
 
-use async_graphql::{Enum, SimpleObject};
-use serde::{Deserialize, Serialize};
+use async_graphql::Enum;
+use serde::Deserialize;
 use serde_json::Value;
 
 use crate::model::{array, container, table};
 
-#[derive(Debug, PartialEq, Serialize, Deserialize)]
+#[derive(Debug, PartialEq, Deserialize)]
 pub struct Root {
     data: Vec<DataOption>,
-    pub error: Value,
-    pub links: Option<Links>,
-    pub meta: Value,
+    error: Value,
+    meta: Value,
 }
 
 impl Root {
@@ -23,107 +22,90 @@ impl Root {
     }
 }
 
-#[derive(Debug, PartialEq, Serialize, Deserialize)]
+#[derive(Debug, PartialEq, Deserialize)]
 #[serde(untagged)]
-pub enum DataOption {
+enum DataOption {
     Data(Data),
     Error(Value),
 }
 
 impl DataOption {
-    pub fn as_data(&self) -> Option<&Data> {
+    fn as_data(&self) -> Option<&Data> {
         match self {
             Self::Data(data) => Some(data),
             Self::Error(_) => None,
         }
     }
-    pub fn into_data(self) -> Option<Data> {
+    fn into_data(self) -> Option<Data> {
         match self {
             Self::Data(data) => Some(data),
             Self::Error(_) => None,
         }
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[derive(Debug, Clone, PartialEq, Deserialize)]
 pub struct Data {
     pub id: String,
     pub attributes: Box<NodeAttributes>,
-    pub links: Box<Links>,
-    pub meta: Value,
+    meta: Value,
 }
 
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[derive(Debug, Clone, PartialEq, Deserialize)]
 #[serde(tag = "structure_family", rename_all = "lowercase")]
 pub enum NodeAttributes {
     Container(Attributes<container::ContainerMetadata, container::ContainerStructure>),
     Array(Attributes<HashMap<String, Value>, array::ArrayStructure>),
     Table(Attributes<HashMap<String, Value>, table::TableStructure>),
 }
 
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[derive(Debug, Clone, PartialEq, Deserialize)]
 pub struct Attributes<Meta, S> {
     pub ancestors: Vec<String>,
-    pub specs: Vec<Spec>,
+    specs: Vec<Spec>,
     pub metadata: Meta,
     pub structure: S,
-    pub access_blob: Value,
-    pub sorting: Option<Vec<Sorting>>,
+    access_blob: Value,
+    sorting: Option<Vec<Sorting>>,
     pub data_sources: Option<Vec<DataSource<S>>>,
 }
 
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-pub struct Spec {
-    pub name: String,
-    pub version: Option<String>,
+#[derive(Debug, Clone, PartialEq, Deserialize)]
+struct Spec {
+    name: String,
+    version: Option<String>,
 }
 
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-pub struct Sorting {
-    pub key: String,
-    pub direction: i64,
+#[derive(Debug, Clone, PartialEq, Deserialize)]
+struct Sorting {
+    key: String,
+    direction: i64,
 }
 
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[derive(Debug, Clone, PartialEq, Deserialize)]
 pub struct DataSource<S> {
-    pub structure: S,
-    pub id: Option<u64>,
-    pub mimetype: Option<String>,
-    pub parameters: HashMap<String, Value>,
+    structure: S,
+    id: Option<u64>,
+    mimetype: Option<String>,
+    parameters: HashMap<String, Value>,
     pub assets: Vec<Asset>,
     management: Management,
 }
 
-#[derive(Enum, Debug, Copy, Clone, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Enum, Debug, Copy, Clone, Eq, PartialEq, Deserialize)]
 #[serde(rename_all = "lowercase")]
-pub enum Management {
+enum Management {
     External,
     Immutable,
     Locked,
     Writable,
 }
 
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, SimpleObject)]
+#[derive(Debug, Clone, PartialEq, Deserialize)]
 pub struct Asset {
     pub data_uri: String,
     is_directory: bool,
     parameter: Option<String>,
     num: Option<i64>,
     pub id: Option<i64>,
 }
-
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, SimpleObject)]
-pub struct Links {
-    #[serde(rename = "self")]
-    #[graphql(name = "self")]
-    pub self_field: String,
-    pub documentation: Option<String>,
-    pub first: Option<String>,
-    pub last: Option<String>,
-    pub next: Option<String>,
-    pub prev: Option<String>,
-    pub search: Option<String>,
-    pub full: Option<String>,
-    pub block: Option<String>,
-    pub partition: Option<String>,
-}

src/model/run.rs

@@ -1,53 +1,52 @@
 use std::collections::HashMap;
 
-use async_graphql::SimpleObject;
-use serde::{Deserialize, Serialize};
+use serde::Deserialize;
 use serde_json::Value;
 use uuid::Uuid;
 
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, SimpleObject)]
+#[derive(Debug, Clone, PartialEq, Deserialize)]
 pub struct RunMetadata {
     pub start: Start,
-    pub stop: Option<Stop>,
+    stop: Option<Stop>,
 }
 
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, SimpleObject)]
+#[derive(Debug, Clone, PartialEq, Deserialize)]
 pub struct Start {
-    pub uid: Uuid,
-    pub time: f64,
-    pub versions: Versions,
-    pub instrument: String,
-    pub instrument_session: String,
-    pub data_session_directory: Option<String>,
-    pub scan_file: Option<String>,
+    uid: Uuid,
+    time: f64,
+    versions: Versions,
+    instrument: String,
+    instrument_session: String,
+    data_session_directory: Option<String>,
+    scan_file: Option<String>,
     pub scan_id: i64,
-    pub plan_type: String,
-    pub plan_name: String,
-    pub detectors: Vec<String>,
-    pub motors: Option<Vec<String>>,
-    pub num_points: i64,
-    pub num_intervals: i64,
-    pub plan_args: HashMap<String, Value>,
-    pub hints: Hints,
-    pub shape: Vec<i64>,
+    plan_type: String,
+    plan_name: String,
+    detectors: Vec<String>,
+    motors: Option<Vec<String>>,
+    num_points: i64,
+    num_intervals: i64,
+    plan_args: HashMap<String, Value>,
+    hints: Hints,
+    shape: Vec<i64>,
 }
 
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, SimpleObject)]
-pub struct Versions {
-    pub ophyd: String,
-    pub ophyd_async: String,
-    pub bluesky: String,
+#[derive(Debug, Clone, PartialEq, Deserialize)]
+struct Versions {
+    ophyd: String,
+    ophyd_async: String,
+    bluesky: String,
 }
 
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, SimpleObject)]
-pub struct Hints {
-    pub dimensions: Vec<HintDimension>,
+#[derive(Debug, Clone, PartialEq, Deserialize)]
+struct Hints {
+    dimensions: Vec<HintDimension>,
 }
 
-#[derive(Debug, Clone, PartialEq, Serialize, SimpleObject)]
+#[derive(Debug, Clone, PartialEq)]
 pub struct HintDimension {
-    pub axes: Vec<String>,
-    pub stream: String,
+    axes: Vec<String>,
+    stream: String,
 }
 
 impl<'de> Deserialize<'de> for HintDimension {
@@ -60,14 +59,14 @@ impl<'de> Deserialize<'de> for HintDimension {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, SimpleObject)]
-pub struct Stop {
-    pub uid: Uuid,
-    pub time: f64,
-    pub run_start: Uuid,
-    pub exit_status: String,
-    pub reason: String,
-    pub num_events: HashMap<String, Value>,
+#[derive(Debug, Clone, PartialEq, Deserialize)]
+struct Stop {
+    uid: Uuid,
+    time: f64,
+    run_start: Uuid,
+    exit_status: String,
+    reason: String,
+    num_events: HashMap<String, Value>,
 }
 
 #[cfg(test)]