Merge remote-tracking branch 'origin/main' into code-cov

ZohebShaikh · ZohebShaikh · commit 39ecda85d9ab · 2025-11-13T11:10:13.000Z
diff --git a/resources/metadata_table.json b/resources/metadata_table.json
@@ -0,0 +1,57 @@
+{
+  "data": {
+    "id": "internal",
+    "attributes": {
+      "ancestors": [
+        "4866611f-e6d9-4517-bedf-fc5526df57ad",
+        "primary"
+      ],
+      "structure_family": "table",
+      "specs": [],
+      "metadata": {
+        "stage-x": {
+          "dtype": "number",
+          "shape": [],
+          "dtype_numpy": "<f8",
+          "source": "ca://BL01T-MO-SIMC-01:M1.RBV",
+          "units": "degrees",
+          "precision": 5,
+          "limits": {
+            "control": {
+              "low": -20000,
+              "high": 20000
+            },
+            "display": {
+              "low": -20000,
+              "high": 20000
+            }
+          },
+          "object_name": "stage-x"
+        }
+      },
+      "structure": {
+        "arrow_schema": "data:application/vnd.apache.arrow.file;base64,/////xgBAAAQAAAAAAAKAAwABgAFAAgACgAAAAABBAAMAAAACAAIAAAABAAIAAAABAAAAAQAAACsAAAAaAAAADgAAAAEAAAAdP///wAAAQMQAAAAHAAAAAQAAAAAAAAACgAAAHRzX3N0YWdlLXgAAKr///8AAAIApP///wAAAQMQAAAAGAAAAAQAAAAAAAAABwAAAHN0YWdlLXgA1v///wAAAgDQ////AAABAxAAAAAcAAAABAAAAAAAAAAEAAAAdGltZQAABgAIAAYABgAAAAAAAgAQABQACAAGAAcADAAAABAAEAAAAAAAAQIQAAAAIAAAAAQAAAAAAAAABwAAAHNlcV9udW0ACAAMAAgABwAIAAAAAAAAAUAAAAAAAAAA",
+        "npartitions": 1,
+        "columns": [
+          "seq_num",
+          "time",
+          "stage-x",
+          "ts_stage-x"
+        ],
+        "resizable": false
+      },
+      "access_blob": {},
+      "sorting": null,
+      "data_sources": null
+    },
+    "links": {
+      "self": "http://127.0.0.1:8000/api/v1/metadata/4866611f-e6d9-4517-bedf-fc5526df57ad/primary/internal",
+      "full": "http://127.0.0.1:8000/api/v1/table/full/4866611f-e6d9-4517-bedf-fc5526df57ad/primary/internal",
+      "partition": "http://127.0.0.1:8000/api/v1/table/partition/4866611f-e6d9-4517-bedf-fc5526df57ad/primary/internal?partition={index}"
+    },
+    "meta": null
+  },
+  "error": null,
+  "links": null,
+  "meta": {}
+}
diff --git a/resources/table_full.json b/resources/table_full.json
@@ -0,0 +1,30 @@
+{
+  "seq_num": [
+    1,
+    2,
+    3,
+    4,
+    5
+  ],
+  "time": [
+    1762787606.459906,
+    1762787609.4694269,
+    1762787612.4223065,
+    1762787615.400967,
+    1762787618.4348016
+  ],
+  "stage-x": [
+    0,
+    2.5,
+    5,
+    7.5,
+    10
+  ],
+  "ts_stage-x": [
+    631152000,
+    1762787609.198412,
+    1762787612.10868,
+    1762787615.118978,
+    1762787618.129375
+  ]
+}
diff --git a/src/clients.rs b/src/clients.rs
@@ -1,11 +1,12 @@
 use std::fmt;
 
+use axum::http::HeaderMap;
 use reqwest::Url;
 use serde::de::DeserializeOwned;
 use tracing::{info, instrument};
 use uuid::Uuid;
 
-use crate::model::{app, event_stream, run};
+use crate::model::{app, event_stream, run, table};
 
 pub type ClientResult<T> = Result<T, ClientError>;
 
@@ -15,35 +16,68 @@ pub struct TiledClient {
 
 impl TiledClient {
     #[instrument(skip(self))]
-    async fn request<T: DeserializeOwned>(&self, endpoint: &str) -> ClientResult<T> {
+    async fn request<T: DeserializeOwned>(
+        &self,
+        endpoint: &str,
+        headers: Option<HeaderMap>,
+    ) -> ClientResult<T> {
         info!("Requesting from tiled: {}", endpoint);
         let url = self.address.join(endpoint)?;
-        let response = reqwest::get(url).await?.error_for_status()?;
+        let client = reqwest::Client::new();
+        let request = match headers {
+            Some(headers) => client.get(url).headers(headers),
+            None => client.get(url),
+        };
+        let response = request.send().await?.error_for_status()?;
         let body = response.text().await?;
         serde_json::from_str(&body).map_err(|e| ClientError::InvalidResponse(e, body))
     }
     pub async fn app_metadata(&self) -> ClientResult<app::AppMetadata> {
-        self.request("/api/v1/").await
+        self.request("/api/v1/", None).await
     }
     pub async fn run_metadata(&self, id: Uuid) -> ClientResult<run::RunMetadataRoot> {
-        self.request(&format!("/api/v1/metadata/{id}")).await
+        self.request(&format!("/api/v1/metadata/{id}"), None).await
     }
     pub async fn event_stream_metadata(
         &self,
         id: Uuid,
         stream: String,
     ) -> ClientResult<event_stream::EventStreamMetadataRoot> {
-        self.request(&format!("/api/v1/metadata/{id}/{stream}"))
+        self.request(&format!("/api/v1/metadata/{id}/{stream}"), None)
+            .await
+    }
+    pub async fn table_metadata(
+        &self,
+        id: Uuid,
+        stream: String,
+        table: String,
+    ) -> ClientResult<table::TableMetadataRoot> {
+        self.request(&format!("/api/v1/metadata/{id}/{stream}/{table}"), None)
             .await
     }
+    pub async fn table_full(
+        &self,
+        id: Uuid,
+        stream: String,
+        table: String,
+    ) -> ClientResult<table::Table> {
+        let mut headers = HeaderMap::new();
+        headers.insert("accept", "application/json".parse().unwrap());
+
+        self.request(
+            &format!("/api/v1/table/full/{id}/{stream}/{table}"),
+            Some(headers),
+        )
+        .await
+    }
     pub async fn search_root(&self) -> ClientResult<run::RunRoot> {
-        self.request("/api/v1/search/").await
+        self.request("/api/v1/search/", None).await
     }
     pub async fn search_run_container(
         &self,
         id: Uuid,
     ) -> ClientResult<event_stream::EventStreamRoot> {
-        self.request(&format!("/api/v1/search/{id}")).await
+        self.request(&format!("/api/v1/search/{id}"), None).await
     }
 }
 
@@ -78,6 +112,7 @@ impl std::fmt::Display for ClientError {
 
 #[cfg(test)]
 mod tests {
+    use axum::http::HeaderMap;
     use httpmock::MockServer;
     use url::Url;
 
@@ -96,7 +131,33 @@ mod tests {
             address: Url::parse(&server.base_url()).unwrap(),
         };
         assert_eq!(
-            client.request::<Vec<u8>>("/demo/api").await.unwrap(),
+            client.request::<Vec<u8>>("/demo/api", None).await.unwrap(),
+            vec![1, 2, 3]
+        );
+        mock.assert();
+    }
+    #[tokio::test]
+    async fn request_with_headers() {
+        let server = MockServer::start();
+        let mock = server
+            .mock_async(|when, then| {
+                when.method("GET")
+                    .path("/demo/api")
+                    .header("api-key", "foo");
+                then.status(200).body("[1,2,3]");
+            })
+            .await;
+        let client = TiledClient {
+            address: Url::parse(&server.base_url()).unwrap(),
+        };
+        let mut headers = HeaderMap::new();
+        headers.insert("api-key", "foo".parse().unwrap());
+
+        assert_eq!(
+            client
+                .request::<Vec<u8>>("/demo/api", Some(headers))
+                .await
+                .unwrap(),
             vec![1, 2, 3]
         );
         mock.assert();
diff --git a/src/model.rs b/src/model.rs
@@ -3,6 +3,7 @@ pub(crate) mod container;
 pub(crate) mod event_stream;
 pub(crate) mod node;
 pub(crate) mod run;
+pub(crate) mod table;
 
 use async_graphql::Object;
 use tracing::instrument;
@@ -31,6 +32,24 @@ impl TiledQuery {
         self.0.event_stream_metadata(id, stream).await
     }
     #[instrument(skip(self))]
+    async fn table_metadata(
+        &self,
+        id: Uuid,
+        stream: String,
+        table: String,
+    ) -> Result<table::TableMetadataRoot, ClientError> {
+        self.0.table_metadata(id, stream, table).await
+    }
+    #[instrument(skip(self))]
+    async fn table_full(
+        &self,
+        id: Uuid,
+        stream: String,
+        table: String,
+    ) -> Result<table::Table, ClientError> {
+        self.0.table_full(id, stream, table).await
+    }
+    #[instrument(skip(self))]
     async fn search_root(&self) -> Result<run::RunRoot, ClientError> {
         self.0.search_root().await
     }
@@ -104,6 +123,31 @@ mod tests {
         mock.assert();
     }
     #[tokio::test]
+    async fn table_metadata() {
+        let id = Uuid::parse_str("4866611f-e6d9-4517-bedf-fc5526df57ad").unwrap();
+        let stream = "primary";
+        let table = "internal";
+        let server = MockServer::start();
+        let mock = server
+            .mock_async(|when, then| {
+                when.method("GET")
+                    .path(format!("/api/v1/metadata/{id}/{stream}/{table}"));
+                then.status(200)
+                    .body_from_file("resources/metadata_table.json");
+            })
+            .await;
+        let schema = build_schema(&server.base_url());
+        let query = r#"{ tableMetadata(id:"4866611f-e6d9-4517-bedf-fc5526df57ad", stream:"primary", table:"internal") {data {id}}}"#;
+        let response = schema.execute(query).await;
+        let exp = value! ({
+            "tableMetadata": { "data": {"id": "internal"}}
+        });
+
+        assert_eq!(response.data, exp);
+        assert_eq!(response.errors, &[]);
+        mock.assert();
+    }
+    #[tokio::test]
     async fn search_root() {
         let server = MockServer::start();
         let mock = server
diff --git a/src/model/table.rs b/src/model/table.rs
@@ -0,0 +1,69 @@
+use std::collections::HashMap;
+
+use async_graphql::SimpleObject;
+use serde::{Deserialize, Serialize};
+use serde_json::Value;
+
+use crate::model::node;
+
+pub type Table = HashMap<String, Vec<Value>>;
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, SimpleObject)]
+pub struct TableMetadataRoot {
+    pub data: TableData,
+    pub error: Value,
+    pub links: Option<node::Links>,
+    pub meta: Value,
+}
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, SimpleObject)]
+pub struct TableData {
+    pub id: String,
+    pub attributes: TableAttributes,
+    pub links: TableLinks,
+    pub meta: Value,
+}
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, SimpleObject)]
+pub struct TableAttributes {
+    pub ancestors: Vec<Value>,
+    pub structure_family: String,
+    pub specs: Option<Vec<Value>>,
+    pub metadata: HashMap<String, Value>,
+    pub structure: TableStructure,
+    pub access_blob: Value,
+    pub sorting: Value,
+    pub data_sources: Value,
+}
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, SimpleObject)]
+pub struct TableStructure {
+    pub arrow_schema: String,
+    pub npartitions: i64,
+    pub columns: Vec<Value>,
+    pub resizable: bool,
+}
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, SimpleObject)]
+pub struct TableLinks {
+    #[serde(rename = "self")]
+    #[graphql(name = "self")]
+    pub self_field: String,
+    pub full: Option<String>,
+    pub partition: Option<String>,
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::model::table;
+    use crate::test_utils::assert_readable_as;
+
+    #[test]
+    fn table_metadata() {
+        assert_readable_as::<table::TableMetadataRoot>("resources/metadata_table.json");
+    }
+    #[test]
+    fn table_full() {
+        assert_readable_as::<table::Table>("resources/table_full.json");
+    }
+}
