athena_rs 3.26.1

Hyper performant polyglot Database driver
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
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

//! Client connection-URI resolution helpers for provisioning flows.
//!
//! This module isolates runtime/catalog URI source selection from endpoint
//! orchestration so provisioning handlers can consume one focused API.

use actix_web::HttpResponse;
use sqlx::{Pool, Postgres};

use crate::AppState;
use crate::api::response::{bad_request, internal_error};
use crate::athena::postgres_clients::resolved_catalog_postgres_uri;
use crate::data::clients::{AthenaClientRecord, get_athena_client_by_name};
use crate::drivers::postgresql::sqlx_driver::RegisteredClient;
use crate::parser::resolve_compatible_postgres_uri;

/// Resolves the active connection URI for a registered runtime client.
pub(super) fn resolve_registered_client_uri(
    state: &AppState,
    client_name: &str,
) -> Result<String, HttpResponse> {
    let registered: RegisteredClient = state
        .pg_registry
        .registered_client(client_name)
        .ok_or_else(|| {
            bad_request(
                "Unknown client",
                format!("No Postgres client named '{}' is registered.", client_name),
            )
        })?;

    registered_client_connection_uri(&registered).ok_or_else(|| {
        bad_request(
            "Client URI unavailable",
            format!("No Postgres URI is available for client '{}'.", client_name),
        )
    })
}

/// Resolves a connection URI from a runtime-registered client record.
fn registered_client_connection_uri(registered: &RegisteredClient) -> Option<String> {
    registered
        .config_uri_template
        .as_deref()
        .map(resolve_compatible_postgres_uri)
        .or_else(|| {
            registered
                .pg_uri
                .as_deref()
                .map(resolve_compatible_postgres_uri)
        })
}

/// Resolves a connection URI from a catalog client record.
fn catalog_client_connection_uri(client: &AthenaClientRecord) -> Option<String> {
    resolved_catalog_postgres_uri(client)
}

/// Resolves the best available connection URI for a client from runtime or catalog.
///
/// Runtime registration is preferred; catalog lookup is used as fallback.
pub(super) async fn resolve_client_connection_uri(
    state: &AppState,
    client_name: &str,
) -> Result<Option<String>, HttpResponse> {
    if let Some(runtime_client) = state.pg_registry.registered_client(client_name)
        && let Some(uri) = registered_client_connection_uri(&runtime_client)
    {
        return Ok(Some(uri));
    }

    let pool: Pool<Postgres> = match super::client_catalog_pool(state) {
        Ok(value) => value,
        Err(_) => return Ok(None),
    };
    let catalog_client: Option<AthenaClientRecord> = get_athena_client_by_name(&pool, client_name)
        .await
        .map_err(|err| internal_error("Failed to load catalog client", err.to_string()))?;
    Ok(catalog_client
        .as_ref()
        .and_then(catalog_client_connection_uri))
}