Add single dataset get command

Author: pthurlow

src/command.rs

@@ -16,8 +16,19 @@ pub enum Commands {
 
     /// Manage datasets
     Datasets {
+        /// Dataset ID to show details
+        id: Option<String>,
+
+        /// Workspace ID (defaults to first workspace from login)
+        #[arg(long)]
+        workspace_id: Option<String>,
+
+        /// Output format (used with dataset ID)
+        #[arg(long, default_value = "table", value_parser = ["table", "json", "yaml"])]
+        format: String,
+
         #[command(subcommand)]
-        command: DatasetsCommands,
+        command: Option<DatasetsCommands>,
     },
 
     /// Execute a SQL query
@@ -159,22 +170,16 @@ pub enum DatasetsCommands {
         #[arg(long)]
         workspace_id: Option<String>,
 
-        /// Output format
-        #[arg(long, default_value = "yaml", value_parser = ["table", "json", "yaml"])]
-        format: String,
-    },
-
-    /// Get details for a specific dataset
-    Get {
-        /// Workspace ID (defaults to first workspace from login)
+        /// Maximum number of results (default: 100, max: 1000)
         #[arg(long)]
-        workspace_id: Option<String>,
+        limit: Option<u32>,
 
-        /// Dataset ID
-        dataset_id: String,
+        /// Pagination offset
+        #[arg(long)]
+        offset: Option<u32>,
 
         /// Output format
-        #[arg(long, default_value = "yaml", value_parser = ["table", "json", "yaml"])]
+        #[arg(long, default_value = "table", value_parser = ["table", "json", "yaml"])]
         format: String,
     },
 
@@ -197,70 +202,6 @@ pub enum DatasetsCommands {
         file: Option<String>,
     },
 
-    /// Update a dataset in a workspace
-    Update {
-        /// Workspace ID (defaults to first workspace from login)
-        #[arg(long)]
-        workspace_id: Option<String>,
-
-        /// Dataset ID
-        dataset_id: String,
-
-        /// New dataset name
-        #[arg(long)]
-        name: Option<String>,
-
-        /// New SQL query for the dataset
-        #[arg(long)]
-        query: Option<String>,
-
-        /// Output format
-        #[arg(long, default_value = "yaml", value_parser = ["table", "json", "yaml"])]
-        format: String,
-    },
-
-    /// Delete a dataset from a workspace
-    Delete {
-        /// Workspace ID (defaults to first workspace from login)
-        #[arg(long)]
-        workspace_id: Option<String>,
-
-        /// Dataset ID
-        dataset_id: String,
-    },
-
-    /// Update the SQL query for a dataset
-    UpdateSql {
-        /// Workspace ID (defaults to first workspace from login)
-        #[arg(long)]
-        workspace_id: Option<String>,
-
-        /// Dataset ID
-        dataset_id: String,
-
-        /// New SQL query for the dataset
-        #[arg(long)]
-        sql: String,
-
-        /// Output format
-        #[arg(long, default_value = "yaml", value_parser = ["table", "json", "yaml"])]
-        format: String,
-    },
-
-    /// Execute a dataset
-    Execute {
-        /// Workspace ID (defaults to first workspace from login)
-        #[arg(long)]
-        workspace_id: Option<String>,
-
-        /// Dataset ID
-        dataset_id: String,
-
-        /// Output format
-        #[arg(long, default_value = "yaml", value_parser = ["table", "json", "yaml"])]
-        format: String,
-    },
-
 }
 
 

src/datasets.rs

@@ -1,14 +1,42 @@
 use crate::config;
 use indicatif::{ProgressBar, ProgressStyle};
-use serde::Deserialize;
+use serde::{Deserialize, Serialize};
 use serde_json::json;
 use std::path::Path;
 
-#[derive(Deserialize)]
+#[derive(Deserialize, Serialize)]
 struct Dataset {
     id: String,
     label: String,
     table_name: String,
+    created_at: String,
+    updated_at: String,
+}
+
+#[derive(Deserialize)]
+struct ListResponse {
+    datasets: Vec<Dataset>,
+    count: u64,
+    has_more: bool,
+}
+
+#[derive(Deserialize, Serialize)]
+struct Column {
+    name: String,
+    data_type: String,
+    nullable: bool,
+}
+
+#[derive(Deserialize, Serialize)]
+struct DatasetDetail {
+    id: String,
+    label: String,
+    schema_name: String,
+    table_name: String,
+    source_type: String,
+    created_at: String,
+    updated_at: String,
+    columns: Vec<Column>,
 }
 
 struct FileType {
@@ -293,3 +321,152 @@ pub fn create(
     println!("label:      {}", dataset.label);
     println!("table_name: {}", dataset.table_name);
 }
+
+pub fn list(workspace_id: &str, limit: Option<u32>, offset: Option<u32>, format: &str) {
+    let profile_config = match config::load("default") {
+        Ok(c) => c,
+        Err(e) => {
+            eprintln!("{e}");
+            std::process::exit(1);
+        }
+    };
+
+    let api_key = match &profile_config.api_key {
+        Some(key) if key != "PLACEHOLDER" => key.clone(),
+        _ => {
+            eprintln!("error: not authenticated. Run 'hotdata auth login' to log in.");
+            std::process::exit(1);
+        }
+    };
+
+    let mut url = format!("{}/datasets", profile_config.api_url);
+    let mut params = vec![];
+    if let Some(l) = limit { params.push(format!("limit={l}")); }
+    if let Some(o) = offset { params.push(format!("offset={o}")); }
+    if !params.is_empty() { url = format!("{url}?{}", params.join("&")); }
+
+    let client = reqwest::blocking::Client::new();
+    let resp = match client
+        .get(&url)
+        .header("Authorization", format!("Bearer {api_key}"))
+        .header("X-Workspace-Id", workspace_id)
+        .send()
+    {
+        Ok(r) => r,
+        Err(e) => {
+            eprintln!("error connecting to API: {e}");
+            std::process::exit(1);
+        }
+    };
+
+    if !resp.status().is_success() {
+        use crossterm::style::Stylize;
+        eprintln!("{}", api_error(resp.text().unwrap_or_default()).red());
+        std::process::exit(1);
+    }
+
+    let body: ListResponse = match resp.json() {
+        Ok(v) => v,
+        Err(e) => {
+            eprintln!("error parsing response: {e}");
+            std::process::exit(1);
+        }
+    };
+
+    match format {
+        "json" => println!("{}", serde_json::to_string_pretty(&body.datasets).unwrap()),
+        "yaml" => print!("{}", serde_yaml::to_string(&body.datasets).unwrap()),
+        "table" => {
+            let mut table = crate::util::make_table();
+            table.set_header(["ID", "LABEL", "TABLE NAME", "CREATED AT"]);
+            table.column_mut(1).unwrap().set_constraint(
+                comfy_table::ColumnConstraint::UpperBoundary(comfy_table::Width::Fixed(30))
+            );
+            for d in &body.datasets {
+                let created_at = d.created_at.split('.').next().unwrap_or(&d.created_at).replace('T', " ");
+                table.add_row([&d.id, &d.label, &d.table_name, &created_at]);
+            }
+            println!("{table}");
+            if body.has_more {
+                let next = offset.unwrap_or(0) + body.count as u32;
+                use crossterm::style::Stylize;
+                eprintln!("{}", format!("showing {} results — use --offset {next} for more", body.count).dark_grey());
+            }
+        }
+        _ => unreachable!(),
+    }
+}
+
+pub fn get(dataset_id: &str, workspace_id: &str, format: &str) {
+    let profile_config = match config::load("default") {
+        Ok(c) => c,
+        Err(e) => {
+            eprintln!("{e}");
+            std::process::exit(1);
+        }
+    };
+
+    let api_key = match &profile_config.api_key {
+        Some(key) if key != "PLACEHOLDER" => key.clone(),
+        _ => {
+            eprintln!("error: not authenticated. Run 'hotdata auth login' to log in.");
+            std::process::exit(1);
+        }
+    };
+
+    let url = format!("{}/datasets/{dataset_id}", profile_config.api_url);
+    let client = reqwest::blocking::Client::new();
+
+    let resp = match client
+        .get(&url)
+        .header("Authorization", format!("Bearer {api_key}"))
+        .header("X-Workspace-Id", workspace_id)
+        .send()
+    {
+        Ok(r) => r,
+        Err(e) => {
+            eprintln!("error connecting to API: {e}");
+            std::process::exit(1);
+        }
+    };
+
+    if !resp.status().is_success() {
+        use crossterm::style::Stylize;
+        eprintln!("{}", api_error(resp.text().unwrap_or_default()).red());
+        std::process::exit(1);
+    }
+
+    let d: DatasetDetail = match resp.json() {
+        Ok(v) => v,
+        Err(e) => {
+            eprintln!("error parsing response: {e}");
+            std::process::exit(1);
+        }
+    };
+
+    match format {
+        "json" => println!("{}", serde_json::to_string_pretty(&d).unwrap()),
+        "yaml" => print!("{}", serde_yaml::to_string(&d).unwrap()),
+        "table" => {
+            let created_at = d.created_at.split('.').next().unwrap_or(&d.created_at).replace('T', " ");
+            let updated_at = d.updated_at.split('.').next().unwrap_or(&d.updated_at).replace('T', " ");
+            println!("id:          {}", d.id);
+            println!("label:       {}", d.label);
+            println!("schema:      {}", d.schema_name);
+            println!("table:       {}", d.table_name);
+            println!("source_type: {}", d.source_type);
+            println!("created_at:  {created_at}");
+            println!("updated_at:  {updated_at}");
+            if !d.columns.is_empty() {
+                println!();
+                let mut table = crate::util::make_table();
+                table.set_header(["COLUMN", "DATA TYPE", "NULLABLE"]);
+                for col in &d.columns {
+                    table.add_row([&col.name, &col.data_type, &col.nullable.to_string()]);
+                }
+                println!("{table}");
+            }
+        }
+        _ => unreachable!(),
+    }
+}

src/main.rs

@@ -61,13 +61,28 @@ fn main() {
                 AuthCommands::Status { profile } => auth::status(&profile),
                 _ => eprintln!("not yet implemented"),
             },
-            Commands::Datasets { command } => match command {
-                DatasetsCommands::Create { workspace_id, label, table_name, file } => {
-                    let workspace_id = resolve_workspace(workspace_id);
-                    datasets::create(&workspace_id, label.as_deref(), table_name.as_deref(), file.as_deref())
+            Commands::Datasets { id, workspace_id, format, command } => {
+                let workspace_id = resolve_workspace(workspace_id);
+                if let Some(id) = id {
+                    datasets::get(&id, &workspace_id, &format)
+                } else {
+                    match command {
+                        Some(DatasetsCommands::List { workspace_id: ws, limit, offset, format }) => {
+                            let workspace_id = resolve_workspace(ws);
+                            datasets::list(&workspace_id, limit, offset, &format)
+                        }
+                        Some(DatasetsCommands::Create { workspace_id: ws, label, table_name, file }) => {
+                            let workspace_id = resolve_workspace(ws);
+                            datasets::create(&workspace_id, label.as_deref(), table_name.as_deref(), file.as_deref())
+                        }
+                        None => {
+                            use clap::CommandFactory;
+                            Cli::command().find_subcommand_mut("datasets").unwrap().print_help().unwrap();
+                            println!();
+                        }
+                    }
                 }
-                _ => eprintln!("not yet implemented"),
-            },
+            }
             Commands::Query { sql, workspace_id, connection, format } => {
                 let workspace_id = resolve_workspace(workspace_id);
                 query::execute(&sql, &workspace_id, connection.as_deref(), &format)