saya-cli 0.3.2

Database-aware AI agent for the terminal: full-screen TUI, schema discovery, and bounded read-only SQL over PostgreSQL, MySQL, SQLite, DuckDB, and Snowflake.
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
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132

use super::{
    connection, connection_schema_cache,
    output::{emit, failure},
    state,
};
use crate::{
    config::runtime::RuntimeConfig,
    profile_identity::profile_identity,
    render::{RenderFormat, TerminalEvent},
};
use saya_connectors::DatabaseConnector;
use saya_store::{AuditOperation, AuditStatus, SchemaStore, SqliteStateStore};
use std::time::Instant;

pub(crate) async fn run(
    name: &str,
    refresh: bool,
    runtime: &RuntimeConfig,
    format: RenderFormat,
    can_prompt: bool,
    store: &SqliteStateStore,
) -> Result<i32, Box<dyn std::error::Error>> {
    let profile = match runtime.named_profile(name) {
        Ok(profile) => profile,
        Err(error) => {
            return failure(
                3,
                saya_types::ConnectionError::invalid_configuration(error.to_string()),
                format,
            );
        }
    };
    // The identity is derived once as a `ProfileIdentity` so the reconciliation
    // pass (which keys claims to schema by profile) gets the same value the
    // store keys schema by, without re-parsing the string form.
    let identity = profile_identity(name, profile, &runtime.cache_scope);
    let identity_str = identity.as_str();
    let mut persistence_failed = refresh && store.invalidate_schema(identity_str).await.is_err();
    let started = Instant::now();
    let connector = match connection::build(profile, runtime, can_prompt).await {
        Ok(connector) => connector,
        Err(error) if !refresh => {
            return connection_schema_cache::fallback(
                store,
                identity_str,
                started,
                error,
                format,
                &mut persistence_failed,
            )
            .await;
        }
        Err(error) => {
            persistence_failed |= state::audit_silent(
                store,
                identity_str,
                AuditOperation::SchemaRefresh,
                AuditStatus::Failure,
                started.elapsed(),
                None,
                None,
            )
            .await
            .is_err();
            warn(persistence_failed, format);
            return failure(3, error, format);
        }
    };
    match live_schema(&*connector).await {
        Ok(schema) => {
            persistence_failed |= store.upsert_schema(identity_str, &schema).await.is_err();
            persistence_failed |= state::audit_silent(
                store,
                identity_str,
                AuditOperation::SchemaRefresh,
                AuditStatus::Success,
                started.elapsed(),
                None,
                None,
            )
            .await
            .is_err();
            warn(persistence_failed, format);
            emit(
                TerminalEvent::Schema {
                    schema: schema.clone(),
                },
                format,
            );
            Ok(0)
        }
        Err(error) if !refresh => {
            connection_schema_cache::fallback(
                store,
                identity_str,
                started,
                error,
                format,
                &mut persistence_failed,
            )
            .await
        }
        Err(error) => {
            persistence_failed |= state::audit_silent(
                store,
                identity_str,
                AuditOperation::SchemaRefresh,
                AuditStatus::Failure,
                started.elapsed(),
                None,
                None,
            )
            .await
            .is_err();
            warn(persistence_failed, format);
            failure(3, error, format)
        }
    }
}

async fn live_schema(
    connector: &dyn DatabaseConnector,
) -> Result<saya_types::SchemaTree, saya_types::ConnectionError> {
    connector.connect().await?;
    connector.schema().await
}

fn warn(persistence_failed: bool, format: RenderFormat) {
    if persistence_failed {
        state::diagnostic(format);
    }
}