athena_rs 3.26.3

//! Compatibility adapter over `athena-provisioning`.
//!
//! The canonical provisioning implementation lives in the internal
//! `athena-provisioning` crate. This module keeps the historical in-crate API
//! surface stable while constructing runtime defaults from root `Config`.

use athena_provisioning::ProvisioningRuntimeConfig;

use crate::config::Config;

pub use athena_provisioning::{
    BindInstancePortRouteRequest, CatalogPublicProxyBinding, DeleteInstanceRequest,
    DockerContainerStatus, DockerManagedContainer, DockerRuntimeAccessStatus, EXPECTED_TABLES,
    InstallLocalProvisionDependenciesParams, InstallProvisionDependenciesRequest,
    InstanceLifecycleRequest, InstanceStatusQuery, LocalClusterCreateDatabaseParams,
    LocalClusterCreateDatabaseRequest, LocalClusterDatabaseCreateOptions,
    LocalClusterDatabasesQuery, LocalProvisionAdvancedOptions,
    LocalProvisionDependencyInstallResult, LocalProvisionDependencyInstallStep,
    LocalProvisionDependencyStatus, LocalProvisionMode, LocalProvisionPipelineRequest,
    ManagedCatalogPublicProxyRequest, NeonConnectionParams, NeonProjectCreateParams,
    NeonProjectCreateResult, NeonProviderProvisionRequest, PROVISION_SQL, PostgresUriSummary,
    ProvisionRequest, ProvisionStatusQuery, ProvisioningError, ProvisioningMetadataSummary,
    ProvisioningMonitorEntry, ProvisioningMonitorNetwork, ProvisioningMonitorProbe,
    ProvisioningMonitorPublicEndpoint, ProvisioningMonitorSummary, RailwayConnectionParams,
    RailwayPluginCreateParams, RailwayPluginCreateResult, RailwayProjectCreateParams,
    RailwayProjectCreateResult, RailwayProviderProvisionRequest, RailwayServiceCreateParams,
    RailwayServiceCreateResult, RenderConnectionParams, RenderPostgresCreateParams,
    RenderPostgresCreateResult, RenderProviderProvisionRequest, SpinUpInstanceRequest,
    SpinUpPostgresParams, SpinUpPostgresResult, build_catalog_public_proxy_binding,
    build_host_from_prefix, check_dns_host, create_postgres_database, inspect_container,
    inspect_docker_runtime_access_current_user, inspect_local_provisioning_dependencies,
    json_object_insert_if_missing, list_managed_postgres_containers, list_postgres_databases,
    managed_base_domain_from_pattern, merge_catalog_public_proxy_metadata,
    normalize_postgres_compatible_uri_scheme, postgres_major_version_from_image,
    postgres_uri_database_name, postgres_uri_fingerprint, postgres_uri_port,
    private_catalog_pg_uri, remove_container, replace_uri_database_name,
    rewrite_postgres_uri_authority, run_provision_sql, split_provision_statements, start_container,
    stop_container, summarize_catalog_route_bindings, summarize_postgres_uri,
    summarize_provisioning_metadata, wildcard_host_pattern_from_env,
    wildcard_public_host_for_route_key,
};

pub fn runtime_config_from_root() -> ProvisioningRuntimeConfig {
    match Config::load() {
        Ok(config) => ProvisioningRuntimeConfig {
            expected_tables: config.get_provisioning_expected_tables(),
            postgres_image: Some(config.get_provisioning_default_postgres_image()),
            instance_host: Some(config.get_provisioning_default_instance_host()),
            startup_timeout_secs: Some(config.get_provisioning_default_startup_timeout_secs()),
            neon_api_base_url: Some(config.get_provisioning_default_neon_api_base_url()),
            railway_graphql_url: Some(config.get_provisioning_default_railway_graphql_url()),
            render_api_base_url: Some(config.get_provisioning_default_render_api_base_url()),
            docker_sudo_password: config.get_provisioning_docker_sudo_password(),
            docker_self_heal_group: config.get_provisioning_docker_self_heal_group(),
        },
        Err(_) => ProvisioningRuntimeConfig::default(),
    }
}

pub async fn spin_up_postgres_instance(
    params: SpinUpPostgresParams,
) -> Result<SpinUpPostgresResult, ProvisioningError> {
    let runtime = runtime_config_from_root();
    athena_provisioning::spin_up_postgres_instance_with_runtime_config(params, &runtime).await
}

pub async fn create_neon_project(
    mut params: NeonProjectCreateParams,
) -> Result<NeonProjectCreateResult, ProvisioningError> {
    let runtime = runtime_config_from_root();
    if params.api_base_url.is_none() {
        params.api_base_url = runtime.neon_api_base_url.clone();
    }
    athena_provisioning::create_neon_project_with_runtime_config(params, &runtime).await
}

pub async fn fetch_neon_connection_uri(
    mut params: NeonConnectionParams,
) -> Result<String, ProvisioningError> {
    let runtime = runtime_config_from_root();
    if params.api_base_url.is_none() {
        params.api_base_url = runtime.neon_api_base_url.clone();
    }
    athena_provisioning::fetch_neon_connection_uri_with_runtime_config(params, &runtime).await
}

pub async fn create_railway_project(
    mut params: RailwayProjectCreateParams,
) -> Result<RailwayProjectCreateResult, ProvisioningError> {
    let runtime = runtime_config_from_root();
    if params.graphql_url.is_none() {
        params.graphql_url = runtime.railway_graphql_url.clone();
    }
    athena_provisioning::create_railway_project_with_runtime_config(params, &runtime).await
}

pub async fn create_railway_service(
    mut params: RailwayServiceCreateParams,
) -> Result<RailwayServiceCreateResult, ProvisioningError> {
    let runtime = runtime_config_from_root();
    if params.graphql_url.is_none() {
        params.graphql_url = runtime.railway_graphql_url.clone();
    }
    athena_provisioning::create_railway_service_with_runtime_config(params, &runtime).await
}

pub async fn create_railway_plugin(
    mut params: RailwayPluginCreateParams,
) -> Result<RailwayPluginCreateResult, ProvisioningError> {
    let runtime = runtime_config_from_root();
    if params.graphql_url.is_none() {
        params.graphql_url = runtime.railway_graphql_url.clone();
    }
    athena_provisioning::create_railway_plugin_with_runtime_config(params, &runtime).await
}

pub async fn fetch_railway_project_base_environment_id(
    api_key: &str,
    project_id: &str,
    graphql_url: Option<&str>,
) -> Result<Option<String>, ProvisioningError> {
    let runtime = runtime_config_from_root();
    athena_provisioning::fetch_railway_project_base_environment_id_with_runtime_config(
        api_key,
        project_id,
        graphql_url,
        &runtime,
    )
    .await
}

pub async fn fetch_railway_connection_uri(
    mut params: RailwayConnectionParams,
) -> Result<String, ProvisioningError> {
    let runtime = runtime_config_from_root();
    if params.graphql_url.is_none() {
        params.graphql_url = runtime.railway_graphql_url.clone();
    }
    athena_provisioning::fetch_railway_connection_uri_with_runtime_config(params, &runtime).await
}

pub async fn create_render_postgres_service(
    mut params: RenderPostgresCreateParams,
) -> Result<RenderPostgresCreateResult, ProvisioningError> {
    let runtime = runtime_config_from_root();
    if params.api_base_url.is_none() {
        params.api_base_url = runtime.render_api_base_url.clone();
    }
    athena_provisioning::create_render_postgres_service_with_runtime_config(params, &runtime).await
}

pub async fn fetch_render_connection_uri(
    mut params: RenderConnectionParams,
) -> Result<String, ProvisioningError> {
    let runtime = runtime_config_from_root();
    if params.api_base_url.is_none() {
        params.api_base_url = runtime.render_api_base_url.clone();
    }
    athena_provisioning::fetch_render_connection_uri_with_runtime_config(params, &runtime).await
}

pub async fn install_local_provisioning_dependencies(
    params: InstallLocalProvisionDependenciesParams,
) -> Result<LocalProvisionDependencyInstallResult, ProvisioningError> {
    athena_provisioning::install_local_provisioning_dependencies(params).await
}