stmo_cli/commands/
execute.rs

1#![allow(clippy::missing_errors_doc)]
2#![allow(clippy::missing_panics_doc)]
3
4use anyhow::{Context, Result, bail};
5use std::collections::HashMap;
6use std::fs;
7use std::path::Path;
8use crate::api::RedashClient;
9use crate::models::{QueryMetadata, Parameter};
10use super::OutputFormat;
11
12fn parse_parameter_arg(arg: &str) -> Result<(String, serde_json::Value)> {
13    let parts: Vec<&str> = arg.splitn(2, '=').collect();
14    if parts.len() != 2 {
15        bail!("Invalid parameter format. Use: --param name=value");
16    }
17
18    let name = parts[0].to_string();
19    let value_str = parts[1];
20
21    let value = if let Ok(json_value) = serde_json::from_str(value_str) {
22        json_value
23    } else {
24        serde_json::Value::String(value_str.to_string())
25    };
26
27    Ok((name, value))
28}
29
30fn load_query_metadata_by_id(query_id: u64) -> Result<(QueryMetadata, String, String)> {
31    let queries_dir = Path::new("queries");
32
33    for entry in fs::read_dir(queries_dir).context("Failed to read queries directory")? {
34        let entry = entry.context("Failed to read directory entry")?;
35        let path = entry.path();
36
37        if path.extension().is_some_and(|ext| ext == "yaml")
38            && let Some(filename) = path.file_name().and_then(|f| f.to_str())
39            && let Some(id_str) = filename.split('-').next()
40            && let Ok(id) = id_str.parse::<u64>()
41            && id == query_id
42        {
43            let yaml_content = fs::read_to_string(&path)
44                .context(format!("Failed to read {}", path.display()))?;
45
46            let metadata: QueryMetadata = serde_yaml::from_str(&yaml_content)
47                .context(format!("Failed to parse {}", path.display()))?;
48
49            let yaml_path = path.display().to_string();
50            let sql_path = yaml_path.replace(".yaml", ".sql");
51
52            if !Path::new(&sql_path).exists() {
53                bail!("SQL file not found: {sql_path}");
54            }
55
56            let sql = fs::read_to_string(&sql_path)
57                .context(format!("Failed to read {sql_path}"))?;
58
59            return Ok((metadata, sql, yaml_path));
60        }
61    }
62
63    bail!("Query {query_id} not found in queries/ directory. Run 'stmo-cli fetch {query_id}' first.");
64}
65
66fn prompt_for_parameter(param: &Parameter) -> Result<serde_json::Value> {
67    use dialoguer::{Input, Select};
68
69    let title = &param.title;
70
71    match param.param_type.as_str() {
72        "date" => {
73            let input: String = Input::new()
74                .with_prompt(format!("{title} (YYYY-MM-DD)"))
75                .interact_text()?;
76            Ok(serde_json::Value::String(input))
77        }
78        "enum" => {
79            if let Some(enum_options) = &param.enum_options {
80                let options: Vec<&str> = enum_options.lines().collect();
81
82                if param.multi_values_options.is_some() {
83                    use dialoguer::MultiSelect;
84                    let selections = MultiSelect::new()
85                        .with_prompt(title)
86                        .items(&options)
87                        .interact()?;
88
89                    let selected: Vec<String> = selections.iter()
90                        .map(|&i| options[i].to_string())
91                        .collect();
92
93                    Ok(serde_json::Value::Array(
94                        selected.into_iter().map(serde_json::Value::String).collect()
95                    ))
96                } else {
97                    let selection = Select::new()
98                        .with_prompt(title)
99                        .items(&options)
100                        .default(0)
101                        .interact()?;
102
103                    Ok(serde_json::Value::String(options[selection].to_string()))
104                }
105            } else {
106                let input: String = Input::new()
107                    .with_prompt(title)
108                    .interact_text()?;
109                Ok(serde_json::Value::String(input))
110            }
111        }
112        "number" => {
113            let input: f64 = Input::new()
114                .with_prompt(title)
115                .interact_text()?;
116            Ok(serde_json::json!(input))
117        }
118        _ => {
119            let input: String = Input::new()
120                .with_prompt(title)
121                .interact_text()?;
122            Ok(serde_json::Value::String(input))
123        }
124    }
125}
126
127fn build_parameter_map(
128    metadata: &QueryMetadata,
129    cli_params: &[(String, serde_json::Value)],
130    interactive: bool,
131) -> Result<Option<HashMap<String, serde_json::Value>>> {
132    if metadata.options.parameters.is_empty() {
133        return Ok(None);
134    }
135
136    let mut param_map = HashMap::new();
137
138    for (name, value) in cli_params {
139        param_map.insert(name.clone(), value.clone());
140    }
141
142    for param in &metadata.options.parameters {
143        if !param_map.contains_key(&param.name) {
144            if interactive {
145                eprintln!("\nParameter '{}' required:", param.title);
146                let value = prompt_for_parameter(param)?;
147                param_map.insert(param.name.clone(), value);
148            } else if let Some(default_value) = &param.value {
149                param_map.insert(param.name.clone(), default_value.clone());
150            } else {
151                bail!(
152                    "Missing required parameter: '{}' ({}). Use --param {}=value or --interactive",
153                    param.name, param.title, param.name
154                );
155            }
156        }
157    }
158
159    Ok(if param_map.is_empty() { None } else { Some(param_map) })
160}
161
162fn format_results_json(result: &crate::models::QueryResult, limit: Option<usize>) -> Result<String> {
163    let rows = if let Some(limit) = limit {
164        result.data.rows.iter().take(limit).cloned().collect::<Vec<_>>()
165    } else {
166        result.data.rows.clone()
167    };
168
169    serde_json::to_string_pretty(&rows)
170        .context("Failed to format results as JSON")
171}
172
173fn format_results_table(result: &crate::models::QueryResult, limit: Option<usize>) -> String {
174    use std::fmt::Write;
175
176    let mut output = String::new();
177
178    let _ = writeln!(output);
179    for col in &result.data.columns {
180        let _ = write!(output, "{:20} ", col.name);
181    }
182    let _ = writeln!(output);
183    let _ = writeln!(output, "{}", "-".repeat(result.data.columns.len() * 21));
184
185    let rows_to_show = limit.unwrap_or(result.data.rows.len()).min(result.data.rows.len());
186
187    for row in &result.data.rows[..rows_to_show] {
188        if let serde_json::Value::Object(obj) = row {
189            for col in &result.data.columns {
190                let value = obj.get(&col.name)
191                    .map(|v| match v {
192                        serde_json::Value::Null => "NULL".to_string(),
193                        serde_json::Value::String(s) => s.clone(),
194                        _ => v.to_string(),
195                    })
196                    .unwrap_or_default();
197
198                let truncated = if value.len() > 18 {
199                    format!("{}...", &value[..15])
200                } else {
201                    value
202                };
203
204                let _ = write!(output, "{truncated:20} ");
205            }
206            let _ = writeln!(output);
207        }
208    }
209
210    if rows_to_show < result.data.rows.len() {
211        let _ = write!(output, "\n... {} more rows (showing {} of {})\n",
212            result.data.rows.len() - rows_to_show,
213            rows_to_show,
214            result.data.rows.len()
215        );
216    }
217
218    let _ = write!(output, "\n✓ {} rows returned in {:.2}s\n",
219        result.data.rows.len(), result.runtime);
220
221    output
222}
223
224pub async fn execute(
225    client: &RedashClient,
226    query_id: u64,
227    param_args: Vec<String>,
228    format: OutputFormat,
229    interactive: bool,
230    timeout_secs: u64,
231    limit_rows: Option<usize>,
232) -> Result<()> {
233    let (metadata, _sql, yaml_path) = load_query_metadata_by_id(query_id)?;
234
235    eprintln!("Executing query: {} - {}", metadata.id, metadata.name);
236    eprintln!("Source: {yaml_path}\n");
237
238    let cli_params: Vec<(String, serde_json::Value)> = param_args
239        .iter()
240        .map(|arg| parse_parameter_arg(arg))
241        .collect::<Result<Vec<_>>>()?;
242
243    let parameters = build_parameter_map(&metadata, &cli_params, interactive)?;
244
245    if let Some(ref params) = parameters {
246        eprintln!("Parameters:");
247        for (name, value) in params {
248            eprintln!("  {name} = {value}");
249        }
250        eprintln!();
251    }
252
253    let result = client
254        .execute_query_with_polling(query_id, parameters, timeout_secs, 500)
255        .await?;
256
257    match format {
258        OutputFormat::Json => {
259            let json = format_results_json(&result, limit_rows)?;
260            println!("{json}");
261        }
262        OutputFormat::Table => {
263            let table = format_results_table(&result, limit_rows);
264            println!("{table}");
265        }
266    }
267
268    Ok(())
269}
270
271#[cfg(test)]
272#[allow(clippy::missing_errors_doc)]
273mod tests {
274    use super::*;
275    use crate::models::{QueryResult, QueryResultData, Column};
276
277    #[test]
278    fn test_parse_parameter_arg_string() {
279        let result = parse_parameter_arg("name=value").unwrap();
280        assert_eq!(result.0, "name");
281        assert_eq!(result.1, serde_json::Value::String("value".to_string()));
282    }
283
284    #[test]
285    fn test_parse_parameter_arg_json_array() {
286        let result = parse_parameter_arg("channels=[\"release\",\"beta\"]").unwrap();
287        assert_eq!(result.0, "channels");
288        assert_eq!(result.1, serde_json::json!(["release", "beta"]));
289    }
290
291    #[test]
292    fn test_parse_parameter_arg_number() {
293        let result = parse_parameter_arg("count=42").unwrap();
294        assert_eq!(result.0, "count");
295        assert_eq!(result.1, serde_json::json!(42));
296    }
297
298    #[test]
299    fn test_parse_parameter_arg_invalid() {
300        let result = parse_parameter_arg("invalid");
301        assert!(result.is_err());
302        assert!(result.unwrap_err().to_string().contains("Invalid parameter format"));
303    }
304
305    #[test]
306    fn test_format_results_json() {
307        let result = QueryResult {
308            id: 1,
309            data: QueryResultData {
310                columns: vec![
311                    Column { name: "col1".to_string(), type_name: "string".to_string(), friendly_name: None },
312                    Column { name: "col2".to_string(), type_name: "integer".to_string(), friendly_name: None },
313                ],
314                rows: vec![
315                    serde_json::json!({"col1": "value1", "col2": 123}),
316                    serde_json::json!({"col1": "value2", "col2": 456}),
317                ],
318            },
319            runtime: 1.5,
320            retrieved_at: "2026-01-21T10:00:00".to_string(),
321        };
322
323        let json = format_results_json(&result, None).unwrap();
324        let parsed: serde_json::Value = serde_json::from_str(&json).unwrap();
325
326        let rows = parsed.as_array().unwrap();
327        assert_eq!(rows.len(), 2);
328        assert_eq!(rows[0]["col1"], "value1");
329        assert_eq!(rows[0]["col2"], 123);
330    }
331
332    #[test]
333    fn test_format_results_json_with_limit() {
334        let result = QueryResult {
335            id: 1,
336            data: QueryResultData {
337                columns: vec![
338                    Column { name: "col1".to_string(), type_name: "string".to_string(), friendly_name: None },
339                ],
340                rows: vec![
341                    serde_json::json!({"col1": "row1"}),
342                    serde_json::json!({"col1": "row2"}),
343                    serde_json::json!({"col1": "row3"}),
344                ],
345            },
346            runtime: 1.0,
347            retrieved_at: "2026-01-21T10:00:00".to_string(),
348        };
349
350        let json = format_results_json(&result, Some(2)).unwrap();
351        let parsed: serde_json::Value = serde_json::from_str(&json).unwrap();
352
353        assert_eq!(parsed.as_array().unwrap().len(), 2);
354    }
355
356    #[test]
357    fn test_format_results_table() {
358        let result = QueryResult {
359            id: 1,
360            data: QueryResultData {
361                columns: vec![
362                    Column { name: "col1".to_string(), type_name: "string".to_string(), friendly_name: None },
363                    Column { name: "col2".to_string(), type_name: "integer".to_string(), friendly_name: None },
364                ],
365                rows: vec![
366                    serde_json::json!({"col1": "value1", "col2": 123}),
367                    serde_json::json!({"col1": "value2", "col2": 456}),
368                ],
369            },
370            runtime: 1.5,
371            retrieved_at: "2026-01-21T10:00:00".to_string(),
372        };
373
374        let table = format_results_table(&result, None);
375
376        assert!(table.contains("col1"));
377        assert!(table.contains("col2"));
378        assert!(table.contains("value1"));
379        assert!(table.contains("value2"));
380        assert!(table.contains("2 rows returned"));
381    }
382
383    #[test]
384    fn test_format_results_table_with_limit() {
385        let result = QueryResult {
386            id: 1,
387            data: QueryResultData {
388                columns: vec![
389                    Column { name: "col1".to_string(), type_name: "string".to_string(), friendly_name: None },
390                ],
391                rows: vec![
392                    serde_json::json!({"col1": "row1"}),
393                    serde_json::json!({"col1": "row2"}),
394                    serde_json::json!({"col1": "row3"}),
395                ],
396            },
397            runtime: 1.0,
398            retrieved_at: "2026-01-21T10:00:00".to_string(),
399        };
400
401        let table = format_results_table(&result, Some(2));
402
403        assert!(table.contains("row1"));
404        assert!(table.contains("row2"));
405        assert!(table.contains("... 1 more rows"));
406        assert!(table.contains("3 rows returned"));
407    }
408
409    #[test]
410    fn test_format_results_table_truncation() {
411        let result = QueryResult {
412            id: 1,
413            data: QueryResultData {
414                columns: vec![
415                    Column { name: "col1".to_string(), type_name: "string".to_string(), friendly_name: None },
416                ],
417                rows: vec![
418                    serde_json::json!({"col1": "this_is_a_very_long_value_that_should_be_truncated"}),
419                ],
420            },
421            runtime: 1.0,
422            retrieved_at: "2026-01-21T10:00:00".to_string(),
423        };
424
425        let table = format_results_table(&result, None);
426
427        assert!(table.contains("..."));
428    }
429
430    #[test]
431    fn test_output_format_from_str() {
432        assert!(matches!("json".parse::<OutputFormat>().unwrap(), OutputFormat::Json));
433        assert!(matches!("JSON".parse::<OutputFormat>().unwrap(), OutputFormat::Json));
434        assert!(matches!("table".parse::<OutputFormat>().unwrap(), OutputFormat::Table));
435        assert!(matches!("TABLE".parse::<OutputFormat>().unwrap(), OutputFormat::Table));
436    }
437
438    #[test]
439    fn test_output_format_from_str_invalid() {
440        let result = "csv".parse::<OutputFormat>();
441        assert!(result.is_err());
442        assert!(result.unwrap_err().to_string().contains("Invalid format"));
443    }
444}
stmo_cli/commands/execute.rs

stmo_cli/commands/
execute.rs
