earl-protocol-sql 0.6.3

SQL execution protocol for earl (sqlx)
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

use anyhow::{Result, bail};
use serde_json::Value;

use earl_core::{ExecutionContext, ProtocolExecutor, RawExecutionResult};

use crate::PreparedSqlQuery;

/// Execute a single SQL query via sqlx and return the result.
pub async fn execute_sql_once(
    data: &PreparedSqlQuery,
    ctx: &ExecutionContext,
) -> Result<RawExecutionResult> {
    let result = crate::sandbox::execute_query(
        &data.connection_url,
        &data.query,
        &data.params,
        data.read_only,
        data.max_rows,
        ctx.transport.timeout,
    )
    .await;

    // Wrap errors through the redactor to prevent credential leakage.
    let rows = match result {
        Ok(rows) => rows,
        Err(err) => {
            let redacted_msg = ctx.redactor.redact(&format!("{err:#}"));
            bail!("SQL query failed: {redacted_msg}");
        }
    };

    let result_value = Value::Array(rows.into_iter().map(Value::Object).collect());
    let body = serde_json::to_vec(&result_value)?;

    Ok(RawExecutionResult {
        status: 0,
        url: "sql://query".into(),
        body,
        content_type: Some("application/json".to_string()),
    })
}

/// SQL protocol executor.
pub struct SqlExecutor;

impl ProtocolExecutor for SqlExecutor {
    type PreparedData = PreparedSqlQuery;

    async fn execute(
        &mut self,
        data: &PreparedSqlQuery,
        ctx: &ExecutionContext,
    ) -> anyhow::Result<RawExecutionResult> {
        execute_sql_once(data, ctx).await
    }
}