Aether/apps/aether-gateway/tests/architecture/sql_and_data.rs

use super::*;

fn production_source(source: &str) -> &str {
    source.split("#[cfg(test)]").next().unwrap_or(source)
}

#[test]
fn handlers_do_not_inline_sql_queries() {
    assert_no_sqlx_queries("src/handlers");
}

#[test]
fn gateway_runtime_does_not_inline_sql_queries() {
    assert_no_sqlx_queries("src/state/runtime");
}

#[test]
fn aether_data_bootstrap_snapshot_is_built_from_schema_sources() {
    let build_rs = read_workspace_file("crates/aether-data/runtime/build.rs");
    assert!(
        build_rs.contains("schema/bootstrap/postgres/manifest.txt"),
        "build.rs should source the bootstrap snapshot from schema/bootstrap/postgres"
    );

    let compose_schema = read_workspace_file("crates/aether-data/runtime/schema/compose_schema.sh");
    assert!(
        compose_schema.contains("check_bootstrap_sources"),
        "compose_schema.sh should still validate bootstrap source fragments"
    );
    assert!(
        !compose_schema.contains("bootstrap/postgres/20260413020000_empty_database_snapshot.sql"),
        "compose_schema.sh should not depend on the outer bootstrap artifact anymore"
    );

    let bootstrap =
        read_workspace_file("crates/aether-data/runtime/src/lifecycle/bootstrap/postgres.rs");
    assert!(
        bootstrap
            .contains("include_str!(concat!(env!(\"OUT_DIR\"), \"/empty_database_snapshot.sql\"))"),
        "lifecycle/bootstrap/postgres.rs should embed the generated bootstrap snapshot from OUT_DIR"
    );
    assert!(
        !bootstrap
            .contains("../../../bootstrap/postgres/20260413020000_empty_database_snapshot.sql"),
        "lifecycle/bootstrap/postgres.rs should not read the outer bootstrap artifact directly"
    );

    let provider_catalog =
        read_workspace_file("crates/aether-data/adapters/postgres/src/provider_catalog.rs");
    assert!(
        !provider_catalog
            .contains("../../../bootstrap/postgres/20260413020000_empty_database_snapshot.sql"),
        "provider_catalog tests should use the shared bootstrap snapshot constant instead of the outer bootstrap artifact"
    );
}

#[test]
fn aether_data_backend_pool_modules_do_not_own_maintenance_sql() {
    for path in ["crates/aether-data/runtime/src/backend/postgres.rs"] {
        let source = read_workspace_file(path);
        let production = production_source(&source);
        for forbidden in [
            "run_table_maintenance(",
            "aggregate_wallet_daily_usage(",
            "aggregate_stats_hourly(",
            "aggregate_stats_daily(",
            "find_system_config_value(",
            "list_system_config_entries(",
            "upsert_system_config_entry(",
            "read_admin_system_stats(",
            "sqlx::query(",
            "sqlx::query_scalar",
            "sqlx::raw_sql(",
        ] {
            assert!(
                !production.contains(forbidden),
                "{path} should stay focused on pool and repository construction instead of owning maintenance SQL via {forbidden}"
            );
        }
    }

    let maintenance = read_workspace_file("crates/aether-data/runtime/src/backend/maintenance.rs");
    for pattern in [
        "Self::Postgres(postgres) => postgres.run_table_maintenance(table_names).await",
        "Self::Postgres(postgres) => postgres.aggregate_wallet_daily_usage(input).await",
        "Self::Postgres(postgres) => postgres.aggregate_stats_hourly(input).await",
        "Self::Postgres(postgres) => postgres.aggregate_stats_daily(input).await",
    ] {
        assert!(
            maintenance.contains(pattern),
            "backend/maintenance.rs should own SQL-driver maintenance dispatch {pattern}"
        );
    }
}

#[test]
fn wallet_maintenance_sql_is_partitioned_by_driver() {
    let facade = read_workspace_file("crates/aether-data/runtime/src/backend/wallet.rs");
    let module = "mod postgres;";
    assert!(
        facade.contains(module),
        "wallet facade should declare {module}"
    );
    for forbidden in [
        "sqlx::",
        "PostgresBackend",
        "SELECT ",
        "INSERT INTO ",
        "DELETE FROM ",
    ] {
        assert!(
            !facade.contains(forbidden),
            "wallet facade should not own driver implementation via {forbidden}"
        );
    }

    let (driver, backend) = ("postgres", "PostgresBackend");
    let path = format!("crates/aether-data/runtime/src/backend/wallet/{driver}.rs");
    let source = read_workspace_file(&path);
    assert!(source.contains(&format!("impl {backend}")));
    assert!(source.contains("aggregate_wallet_daily_usage"));
    assert!(source.contains("sqlx::query"));
}

#[test]
fn table_maintenance_is_partitioned_for_each_driver() {
    let facade = read_workspace_file("crates/aether-data/runtime/src/backend/maintenance.rs");
    let module = "mod postgres;";
    assert!(
        facade.contains(module),
        "maintenance facade should declare {module}"
    );
    for forbidden in [
        "impl PostgresBackend",
        "VACUUM ANALYZE",
        "ANALYZE TABLE",
        "PRAGMA optimize",
        "sqlx::Row",
    ] {
        assert!(
            !facade.contains(forbidden),
            "maintenance dispatch should not own driver SQL via {forbidden}"
        );
    }

    let postgres =
        read_workspace_file("crates/aether-data/runtime/src/backend/maintenance/postgres.rs");
    assert!(postgres.contains("impl PostgresBackend"));
    assert!(postgres.contains("postgres_observability_snapshot"));
    assert!(postgres.contains("VACUUM ANALYZE"));
}

#[test]
fn system_driver_database_operations_are_partitioned() {
    let facade = read_workspace_file("crates/aether-data/runtime/src/backend/system.rs");
    let module = "mod postgres;";
    assert!(
        facade.contains(module),
        "system facade should declare {module}"
    );
    for forbidden in [
        "impl PostgresBackend",
        "fn map_postgres_stats_daily_aggregate(",
        "fn map_postgres_stats_user_daily_aggregate(",
        "async fn export_postgres_admin_system_usage_aggregates(",
        "async fn import_postgres_admin_system_usage_aggregates(",
        "async fn pg_delete_table(",
        "async fn pg_execute_if_table(",
        "async fn pg_execute_batch_if_table(",
        "async fn pg_table_exists(",
        "async fn purge_postgres_admin_system_data(",
        "async fn purge_postgres_non_admin_users(",
        "async fn purge_postgres_request_bodies_batch(",
    ] {
        assert!(
            !facade.contains(forbidden),
            "system facade should not own driver database operations via {forbidden}"
        );
    }

    for driver in ["postgres"] {
        let source = read_workspace_file(&format!(
            "crates/aether-data/runtime/src/backend/system/{driver}.rs"
        ));
        let backend = match driver {
            "postgres" => "Postgres",

            _ => unreachable!(),
        };
        for required in [
            format!("impl {backend}Backend"),
            "map_stats_daily_aggregate".to_string(),
            "map_stats_user_daily_aggregate".to_string(),
            "map_stats_daily_api_key_aggregate".to_string(),
            "map_admin_system_stats".to_string(),
            format!("export_{driver}_admin_system_usage_aggregates"),
            format!("import_{driver}_admin_system_usage_aggregates"),
        ] {
            assert!(
                source.contains(&required),
                "system/{driver}.rs should own {required}"
            );
        }
        if driver == "postgres" {
            for required in [
                "pg_delete_table",
                "pg_execute_if_table",
                "pg_execute_batch_if_table",
                "pg_table_exists",
                "purge_postgres_admin_system_data",
                "purge_postgres_non_admin_users",
                "purge_postgres_request_bodies_batch",
            ] {
                assert!(
                    source.contains(required),
                    "system/postgres.rs should own {required}"
                );
            }
        }
    }
}

#[test]
fn audit_repository_database_operations_are_partitioned() {
    let facade = read_workspace_file("crates/aether-data/runtime/src/repository/audit.rs");
    for module in ["mod types;", "mod tests;"] {
        assert!(
            facade.contains(module),
            "audit facade should declare {module}"
        );
    }
    for forbidden in [
        "sqlx::",
        "PostgresPool",
        "impl AuditLogReadRepository",
        "SELECT ",
        "DELETE FROM ",
    ] {
        assert!(
            !facade.contains(forbidden),
            "audit facade should not own driver database operations via {forbidden}"
        );
    }

    let types = read_workspace_file("crates/aether-data/contracts/src/repository/audit.rs");
    for required in [
        "pub trait AuditLogReadRepository",
        "pub struct StoredAdminAuditLog",
        "pub struct StoredSuspiciousActivity",
        "pub struct StoredUserAuditLog",
        "pub const SUSPICIOUS_EVENT_TYPES",
    ] {
        assert!(
            types.contains(required),
            "aether-data-contracts audit.rs should own {required}"
        );
    }
    for forbidden in ["sqlx::", "PgPool"] {
        assert!(
            !types.contains(forbidden),
            "aether-data-contracts audit.rs should remain driver-independent from {forbidden}"
        );
    }

    let request_types =
        read_workspace_file("crates/aether-data/runtime/src/repository/audit/types.rs");
    for required in [
        "pub trait RequestAuditReader",
        "pub struct RequestAuditBundle",
        "pub async fn read_request_audit_bundle",
    ] {
        assert!(
            request_types.contains(required),
            "aether-data request audit types should own {required}"
        );
    }

    for (driver, repository, row_mapper) in [(
        "postgres",
        "PostgresAuditLogReadRepository",
        "map_postgres_admin_audit_log_row",
    )] {
        let source = read_workspace_file(&format!(
            "crates/aether-data/adapters/{driver}/src/audit.rs"
        ));
        for required in [
            format!("pub struct {repository}"),
            format!("impl AuditLogReadRepository for {repository}"),
            row_mapper.to_string(),
            "sqlx::query".to_string(),
        ] {
            assert!(
                source.contains(&required),
                "aether-data-{driver}/src/audit.rs should own {required}"
            );
        }
        assert!(
            !workspace_file_exists(&format!(
                "crates/aether-data/runtime/src/repository/audit/{driver}.rs"
            )),
            "audit SQL must be owned by adapter crates"
        );
    }
}

#[test]
fn auth_module_repositories_are_owned_by_contracts_and_driver_adapters() {
    let facade =
        read_workspace_file("crates/aether-data/runtime/src/repository/auth_modules/mod.rs");
    for forbidden in ["mod postgres;", "mod types;", "sqlx::", "QueryBuilder"] {
        assert!(
            !facade.contains(forbidden),
            "auth module facade should not own contracts or driver code via {forbidden}"
        );
    }

    let contracts =
        read_workspace_file("crates/aether-data/contracts/src/repository/auth_modules.rs");
    for required in [
        "pub struct StoredOAuthProviderModuleConfig",
        "pub struct StoredLdapModuleConfig",
        "pub trait AuthModuleReadRepository",
        "pub trait AuthModuleWriteRepository",
    ] {
        assert!(
            contracts.contains(required),
            "aether-data-contracts auth_modules.rs should own {required}"
        );
    }
    for forbidden in ["sqlx::", "PgPool"] {
        assert!(
            !contracts.contains(forbidden),
            "auth module contracts should remain driver-independent from {forbidden}"
        );
    }

    for (feature, adapter, read_repository, write_repository) in [(
        "postgres",
        "aether_data_postgres",
        "SqlxAuthModuleReadRepository",
        "SqlxAuthModuleRepository",
    )] {
        assert!(
            facade.contains(&format!("#[cfg(feature = \"{feature}\")]")),
            "auth module facade should preserve the {feature} feature boundary"
        );
        assert!(
            facade.contains(&format!(
                "pub use {adapter}::{{{read_repository}, {write_repository}}};"
            )),
            "auth module facade should re-export {feature} repositories from its adapter"
        );

        let source = read_workspace_file(&format!(
            "crates/aether-data/adapters/{feature}/src/auth_modules.rs"
        ));
        for required in [
            format!("pub struct {read_repository}"),
            format!("pub struct {write_repository}"),
            format!("impl AuthModuleReadRepository for {read_repository}"),
            format!("impl AuthModuleWriteRepository for {write_repository}"),
            "sqlx::query".to_string(),
            "ldap_configs".to_string(),
        ] {
            assert!(
                source.contains(&required),
                "aether-data-{feature}/src/auth_modules.rs should own {required}"
            );
        }
        assert!(
            !workspace_file_exists(&format!(
                "crates/aether-data/runtime/src/repository/auth_modules/{feature}.rs"
            )),
            "auth module SQL must be owned by adapter crates"
        );
    }
    assert!(
        !workspace_file_exists("crates/aether-data/runtime/src/repository/auth_modules/types.rs"),
        "auth module contracts must not be duplicated in aether-data"
    );
}

#[test]
fn announcement_repositories_are_owned_by_contracts_and_driver_adapters() {
    let facade =
        read_workspace_file("crates/aether-data/runtime/src/repository/announcements/mod.rs");
    for forbidden in ["mod postgres;", "mod types;", "sqlx::", "QueryBuilder"] {
        assert!(
            !facade.contains(forbidden),
            "announcement facade should not own contracts or driver code via {forbidden}"
        );
    }

    let contracts =
        read_workspace_file("crates/aether-data/contracts/src/repository/announcements.rs");
    for required in [
        "pub struct StoredAnnouncement",
        "pub struct AnnouncementListQuery",
        "pub struct CreateAnnouncementRecord",
        "pub struct UpdateAnnouncementRecord",
        "pub trait AnnouncementReadRepository",
        "pub trait AnnouncementWriteRepository",
    ] {
        assert!(
            contracts.contains(required),
            "aether-data-contracts announcements.rs should own {required}"
        );
    }
    for forbidden in ["sqlx::", "PgPool"] {
        assert!(
            !contracts.contains(forbidden),
            "announcement contracts should remain driver-independent from {forbidden}"
        );
    }

    for (feature, adapter, repository) in [(
        "postgres",
        "aether_data_postgres",
        "SqlxAnnouncementReadRepository",
    )] {
        assert!(
            facade.contains(&format!("#[cfg(feature = \"{feature}\")]")),
            "announcement facade should preserve the {feature} feature boundary"
        );
        assert!(
            facade.contains(&format!("pub use {adapter}::{repository};")),
            "announcement facade should re-export {feature} repository from its adapter"
        );

        let source = read_workspace_file(&format!(
            "crates/aether-data/adapters/{feature}/src/announcements.rs"
        ));
        for required in [
            format!("pub struct {repository}"),
            format!("impl AnnouncementReadRepository for {repository}"),
            format!("impl AnnouncementWriteRepository for {repository}"),
            "sqlx::query".to_string(),
            "announcement_reads".to_string(),
        ] {
            assert!(
                source.contains(&required),
                "aether-data-{feature}/src/announcements.rs should own {required}"
            );
        }
        assert!(
            !workspace_file_exists(&format!(
                "crates/aether-data/runtime/src/repository/announcements/{feature}.rs"
            )),
            "announcement SQL must be owned by adapter crates"
        );
    }
    assert!(
        !workspace_file_exists("crates/aether-data/runtime/src/repository/announcements/types.rs"),
        "announcement contracts must not be duplicated in aether-data"
    );
}

#[test]
fn oauth_provider_repositories_are_owned_by_contracts_and_driver_adapters() {
    let facade =
        read_workspace_file("crates/aether-data/runtime/src/repository/oauth_providers/mod.rs");
    for forbidden in ["mod postgres;", "mod types;", "sqlx::", "QueryBuilder"] {
        assert!(
            !facade.contains(forbidden),
            "oauth provider facade should not own contracts or driver code via {forbidden}"
        );
    }

    let contracts =
        read_workspace_file("crates/aether-data/contracts/src/repository/oauth_providers.rs");
    for required in [
        "pub struct StoredOAuthProviderConfig",
        "pub enum EncryptedSecretUpdate",
        "pub struct UpsertOAuthProviderConfigRecord",
        "pub trait OAuthProviderReadRepository",
        "pub trait OAuthProviderWriteRepository",
        "pub trait OAuthProviderRepository",
    ] {
        assert!(
            contracts.contains(required),
            "aether-data-contracts oauth_providers.rs should own {required}"
        );
    }
    for forbidden in ["sqlx::", "PgPool"] {
        assert!(
            !contracts.contains(forbidden),
            "oauth provider contracts should remain driver-independent from {forbidden}"
        );
    }

    for (feature, adapter, repository) in [(
        "postgres",
        "aether_data_postgres",
        "SqlxOAuthProviderRepository",
    )] {
        assert!(
            facade.contains(&format!("#[cfg(feature = \"{feature}\")]")),
            "oauth provider facade should preserve the {feature} feature boundary"
        );
        assert!(
            facade.contains(&format!("pub use {adapter}::{repository};")),
            "oauth provider facade should re-export {feature} repository from its adapter"
        );

        let source = read_workspace_file(&format!(
            "crates/aether-data/adapters/{feature}/src/oauth_providers.rs"
        ));
        for required in [
            format!("pub struct {repository}"),
            format!("impl OAuthProviderReadRepository for {repository}"),
            format!("impl OAuthProviderWriteRepository for {repository}"),
            "oauth_providers".to_string(),
            "sqlx::query".to_string(),
        ] {
            assert!(
                source.contains(&required),
                "aether-data-{feature}/src/oauth_providers.rs should own {required}"
            );
        }
        assert!(
            !workspace_file_exists(&format!(
                "crates/aether-data/runtime/src/repository/oauth_providers/{feature}.rs"
            )),
            "oauth provider SQL must be owned by adapter crates"
        );
    }
    assert!(
        !workspace_file_exists(
            "crates/aether-data/runtime/src/repository/oauth_providers/types.rs"
        ),
        "oauth provider contracts must not be duplicated in aether-data"
    );
}

#[test]
fn management_token_repositories_are_owned_by_contracts_and_driver_adapters() {
    let facade =
        read_workspace_file("crates/aether-data/runtime/src/repository/management_tokens/mod.rs");
    for forbidden in ["mod postgres;", "mod types;", "sqlx::", "QueryBuilder"] {
        assert!(
            !facade.contains(forbidden),
            "management token facade should not own contracts or driver code via {forbidden}"
        );
    }

    let contracts =
        read_workspace_file("crates/aether-data/contracts/src/repository/management_tokens.rs");
    for required in [
        "pub struct StoredManagementToken",
        "pub struct StoredManagementTokenUserSummary",
        "pub struct CreateManagementTokenRecord",
        "pub struct UpdateManagementTokenRecord",
        "pub trait ManagementTokenReadRepository",
        "pub trait ManagementTokenWriteRepository",
    ] {
        assert!(
            contracts.contains(required),
            "aether-data-contracts management_tokens.rs should own {required}"
        );
    }
    for forbidden in ["sqlx::", "PgPool"] {
        assert!(
            !contracts.contains(forbidden),
            "management token contracts should remain driver-independent from {forbidden}"
        );
    }

    for (feature, adapter, repository) in [(
        "postgres",
        "aether_data_postgres",
        "SqlxManagementTokenRepository",
    )] {
        assert!(
            facade.contains(&format!("#[cfg(feature = \"{feature}\")]")),
            "management token facade should preserve the {feature} feature boundary"
        );
        assert!(
            facade.contains(&format!("pub use {adapter}::{repository};")),
            "management token facade should re-export {feature} repository from its adapter"
        );

        let source = read_workspace_file(&format!(
            "crates/aether-data/adapters/{feature}/src/management_tokens.rs"
        ));
        for required in [
            format!("pub struct {repository}"),
            format!("impl ManagementTokenReadRepository for {repository}"),
            format!("impl ManagementTokenWriteRepository for {repository}"),
            "management_tokens".to_string(),
            "sqlx::query".to_string(),
        ] {
            assert!(
                source.contains(&required),
                "aether-data-{feature}/src/management_tokens.rs should own {required}"
            );
        }
        assert!(
            !workspace_file_exists(&format!(
                "crates/aether-data/runtime/src/repository/management_tokens/{feature}.rs"
            )),
            "management token SQL must be owned by adapter crates"
        );
    }
    assert!(
        !workspace_file_exists(
            "crates/aether-data/runtime/src/repository/management_tokens/types.rs"
        ),
        "management token contracts must not be duplicated in aether-data"
    );
}

#[test]
fn gemini_file_mapping_repositories_are_owned_by_contracts_and_driver_adapters() {
    let facade = read_workspace_file(
        "crates/aether-data/runtime/src/repository/gemini_file_mappings/mod.rs",
    );
    for forbidden in ["sqlx::", "QueryBuilder", "PgPool"] {
        assert!(
            !facade.contains(forbidden),
            "gemini file mapping facade should not own driver code via {forbidden}"
        );
    }
    assert!(
        facade.contains("pub use aether_data_contracts::repository::gemini_file_mappings::*;"),
        "legacy types path should remain a contracts-backed compatibility facade"
    );

    let contracts =
        read_workspace_file("crates/aether-data/contracts/src/repository/gemini_file_mappings.rs");
    for required in [
        "pub struct StoredGeminiFileMapping",
        "pub struct GeminiFileMappingListQuery",
        "pub struct UpsertGeminiFileMappingRecord",
        "pub trait GeminiFileMappingReadRepository",
        "pub trait GeminiFileMappingWriteRepository",
    ] {
        assert!(
            contracts.contains(required),
            "aether-data-contracts gemini_file_mappings.rs should own {required}"
        );
    }
    for forbidden in ["sqlx::", "PgPool"] {
        assert!(
            !contracts.contains(forbidden),
            "gemini file mapping contracts should remain driver-independent from {forbidden}"
        );
    }

    for (feature, adapter, repository) in [(
        "postgres",
        "aether_data_postgres",
        "SqlxGeminiFileMappingRepository",
    )] {
        assert!(
            facade.contains(&format!("pub use {adapter}::{repository};")),
            "gemini file mapping facade should re-export {feature} repository from its adapter"
        );
        let source = read_workspace_file(&format!(
            "crates/aether-data/adapters/{feature}/src/gemini_file_mappings.rs"
        ));
        for required in [
            format!("pub struct {repository}"),
            format!("impl GeminiFileMappingReadRepository for {repository}"),
            format!("impl GeminiFileMappingWriteRepository for {repository}"),
            "gemini_file_mappings".to_string(),
            "sqlx::query".to_string(),
        ] {
            assert!(
                source.contains(&required),
                "aether-data-{feature}/src/gemini_file_mappings.rs should own {required}"
            );
        }
        assert!(
            !workspace_file_exists(&format!(
                "crates/aether-data/runtime/src/repository/gemini_file_mappings/{feature}.rs"
            )),
            "gemini file mapping SQL must be owned by adapter crates"
        );
    }
    assert!(
        !workspace_file_exists(
            "crates/aether-data/runtime/src/repository/gemini_file_mappings/types.rs"
        ),
        "gemini file mapping contracts must not be duplicated in aether-data"
    );
}

#[test]
fn video_task_repositories_are_owned_by_driver_adapters() {
    let facade =
        read_workspace_file("crates/aether-data/runtime/src/repository/video_tasks/mod.rs");
    for forbidden in ["mod postgres;", "sqlx::", "QueryBuilder"] {
        assert!(
            !facade.contains(forbidden),
            "video task facade should not own driver code via {forbidden}"
        );
    }

    let contracts =
        read_workspace_file("crates/aether-data/contracts/src/repository/video_tasks/types.rs");
    for required in [
        "pub struct StoredVideoTask",
        "pub struct UpsertVideoTask",
        "pub trait VideoTaskReadRepository",
        "pub trait VideoTaskWriteRepository",
    ] {
        assert!(
            contracts.contains(required),
            "aether-data-contracts video task types should own {required}"
        );
    }

    for (feature, adapter, repositories) in [(
        "postgres",
        "aether_data_postgres",
        vec!["SqlxVideoTaskReadRepository", "SqlxVideoTaskRepository"],
    )] {
        for repository in repositories {
            assert!(
                facade.contains(repository) && facade.contains(adapter),
                "video task facade should re-export {feature} {repository} from its adapter"
            );
            let source = read_workspace_file(&format!(
                "crates/aether-data/adapters/{feature}/src/video_tasks.rs"
            ));
            assert!(
                source.contains(repository),
                "aether-data-{feature}/src/video_tasks.rs should own {repository}"
            );
            assert!(source.contains("sqlx::query"));
        }
        assert!(
            !workspace_file_exists(&format!(
                "crates/aether-data/runtime/src/repository/video_tasks/{feature}.rs"
            )),
            "video task SQL must be owned by adapter crates"
        );
    }
}

#[test]
fn candidate_selection_repositories_are_owned_by_driver_adapters() {
    let facade =
        read_workspace_file("crates/aether-data/runtime/src/repository/candidate_selection/mod.rs");
    for forbidden in ["mod postgres;", "sqlx::", "PgPool"] {
        assert!(
            !facade.contains(forbidden),
            "candidate selection facade should not own driver code via {forbidden}"
        );
    }

    let contracts = read_workspace_file(
        "crates/aether-data/contracts/src/repository/candidate_selection/types.rs",
    );
    for required in [
        "pub struct StoredMinimalCandidateSelectionRow",
        "pub trait MinimalCandidateSelectionReadRepository",
        "pub struct StoredPoolKeyCandidateRowsQuery",
        "pub struct StoredRequestedModelCandidateRowsQuery",
    ] {
        assert!(
            contracts.contains(required),
            "candidate selection contracts should own {required}"
        );
    }

    for (feature, adapter, repository) in [(
        "postgres",
        "aether_data_postgres",
        "SqlxMinimalCandidateSelectionReadRepository",
    )] {
        assert!(facade.contains(adapter) && facade.contains(repository));
        let source = read_workspace_file(&format!(
            "crates/aether-data/adapters/{feature}/src/candidate_selection.rs"
        ));
        for required in [
            format!("pub struct {repository}"),
            format!("impl MinimalCandidateSelectionReadRepository for {repository}"),
            "provider_api_keys".to_string(),
            "sqlx::".to_string(),
        ] {
            assert!(
                source.contains(&required),
                "aether-data-{feature}/src/candidate_selection.rs should own {required}"
            );
        }
        assert!(
            !workspace_file_exists(&format!(
                "crates/aether-data/runtime/src/repository/candidate_selection/{feature}.rs"
            )),
            "candidate selection SQL must be owned by adapter crates"
        );
    }
}

#[test]
fn request_candidate_repositories_are_owned_by_driver_adapters() {
    let facade = read_workspace_file("crates/aether-data/runtime/src/repository/candidates/mod.rs");
    for forbidden in ["mod postgres;", "sqlx::", "PgPool"] {
        assert!(
            !facade.contains(forbidden),
            "request candidate facade should not own driver code via {forbidden}"
        );
    }

    let contracts =
        read_workspace_file("crates/aether-data/contracts/src/repository/candidates/types.rs");
    for required in [
        "pub struct StoredRequestCandidate",
        "pub struct UpsertRequestCandidateRecord",
        "pub trait RequestCandidateReadRepository",
        "pub trait RequestCandidateWriteRepository",
        "pub fn request_candidate_lifecycle_would_regress",
    ] {
        assert!(
            contracts.contains(required),
            "request candidate contracts should own {required}"
        );
    }

    for (feature, adapter, repository) in [(
        "postgres",
        "aether_data_postgres",
        "SqlxRequestCandidateReadRepository",
    )] {
        assert!(facade.contains(adapter) && facade.contains(repository));
        let source = read_workspace_file(&format!(
            "crates/aether-data/adapters/{feature}/src/candidates.rs"
        ));
        for required in [
            format!("pub struct {repository}"),
            format!("impl RequestCandidateReadRepository for {repository}"),
            format!("impl RequestCandidateWriteRepository for {repository}"),
            "request_candidates".to_string(),
            "sqlx::query".to_string(),
        ] {
            assert!(
                source.contains(&required),
                "aether-data-{feature}/src/candidates.rs should own {required}"
            );
        }
        assert!(
            !workspace_file_exists(&format!(
                "crates/aether-data/runtime/src/repository/candidates/{feature}.rs"
            )),
            "request candidate SQL must be owned by adapter crates"
        );
    }
}

#[test]
fn billing_repositories_are_owned_by_driver_adapters() {
    let facade = read_workspace_file("crates/aether-data/runtime/src/repository/billing/mod.rs");
    for forbidden in ["mod postgres;", "sqlx::", "QueryBuilder"] {
        assert!(
            !facade.contains(forbidden),
            "billing facade should not own driver code via {forbidden}"
        );
    }

    let contracts =
        read_workspace_file("crates/aether-data/contracts/src/repository/billing/types.rs");
    for required in [
        "pub trait BillingReadRepository",
        "pub struct StoredBillingModelContext",
        "pub struct BillingPlanRecord",
        "pub struct AdminBillingRuleRecord",
        "pub struct PaymentGatewayConfigRecord",
    ] {
        assert!(
            contracts.contains(required),
            "billing contracts should own {required}"
        );
    }

    for (feature, adapter, repository) in [(
        "postgres",
        "aether_data_postgres",
        "SqlxBillingReadRepository",
    )] {
        assert!(facade.contains(adapter) && facade.contains(repository));
        let source = read_workspace_file(&format!(
            "crates/aether-data/adapters/{feature}/src/billing.rs"
        ));
        for required in [
            format!("pub struct {repository}"),
            format!("impl BillingReadRepository for {repository}"),
            "billing_plans".to_string(),
            "sqlx::".to_string(),
        ] {
            assert!(
                source.contains(&required),
                "aether-data-{feature}/src/billing.rs should own {required}"
            );
        }
        assert!(
            !workspace_file_exists(&format!(
                "crates/aether-data/runtime/src/repository/billing/{feature}.rs"
            )),
            "billing SQL must be owned by adapter crates"
        );
    }
}

#[test]
fn settlement_repositories_are_owned_by_contracts_and_driver_adapters() {
    let facade = read_workspace_file("crates/aether-data/runtime/src/repository/settlement/mod.rs");
    for forbidden in ["mod postgres;", "sqlx::", "QueryBuilder"] {
        assert!(
            !facade.contains(forbidden),
            "settlement facade should not own driver code via {forbidden}"
        );
    }

    let contracts =
        read_workspace_file("crates/aether-data/contracts/src/repository/settlement/types.rs");
    for required in [
        "pub trait SettlementWriteRepository",
        "pub struct UsageSettlementInput",
        "pub struct StoredUsageSettlement",
        "pub struct WalletDebitPlan",
        "pub fn plan_finite_wallet_debit",
    ] {
        assert!(
            contracts.contains(required),
            "settlement contracts should own {required}"
        );
    }

    for (feature, adapter, repository) in [(
        "postgres",
        "aether_data_postgres",
        "SqlxSettlementRepository",
    )] {
        assert!(facade.contains(adapter) && facade.contains(repository));
        let source = read_workspace_file(&format!(
            "crates/aether-data/adapters/{feature}/src/settlement.rs"
        ));
        for required in [
            format!("pub struct {repository}"),
            format!("impl SettlementWriteRepository for {repository}"),
            "usage_settlement_snapshots".to_string(),
            "sqlx::".to_string(),
        ] {
            assert!(
                source.contains(&required),
                "aether-data-{feature}/src/settlement.rs should own {required}"
            );
        }
        assert!(
            !workspace_file_exists(&format!(
                "crates/aether-data/runtime/src/repository/settlement/{feature}.rs"
            )),
            "settlement SQL must be owned by adapter crates"
        );
    }
}

#[test]
fn proxy_node_repositories_are_owned_by_contracts_and_driver_adapters() {
    let facade =
        read_workspace_file("crates/aether-data/runtime/src/repository/proxy_nodes/mod.rs");
    for forbidden in ["mod postgres;", "mod types;", "sqlx::", "QueryBuilder"] {
        assert!(
            !facade.contains(forbidden),
            "proxy node facade should not own contracts or driver code via {forbidden}"
        );
    }

    let contracts =
        read_workspace_file("crates/aether-data/contracts/src/repository/proxy_nodes.rs");
    for required in [
        "pub struct StoredProxyNode",
        "pub struct ProxyNodeHeartbeatMutation",
        "pub struct StoredProxyNodeMetricsBucket",
        "pub trait ProxyNodeReadRepository",
        "pub trait ProxyNodeWriteRepository",
        "pub fn build_tunnel_metrics_sample",
    ] {
        assert!(
            contracts.contains(required),
            "proxy node contracts should own {required}"
        );
    }
    for forbidden in ["sqlx::", "PgPool", "tracing::"] {
        assert!(
            !contracts.contains(forbidden),
            "proxy node contracts should remain infrastructure-independent from {forbidden}"
        );
    }

    for (feature, adapter, repository) in [(
        "postgres",
        "aether_data_postgres",
        "SqlxProxyNodeRepository",
    )] {
        assert!(facade.contains(adapter) && facade.contains(repository));
        let source = read_workspace_file(&format!(
            "crates/aether-data/adapters/{feature}/src/proxy_nodes.rs"
        ));
        for required in [
            format!("pub struct {repository}"),
            format!("impl ProxyNodeReadRepository for {repository}"),
            format!("impl ProxyNodeWriteRepository for {repository}"),
            "proxy_node_metrics_1m".to_string(),
            "sqlx::".to_string(),
        ] {
            assert!(
                source.contains(&required),
                "aether-data-{feature}/src/proxy_nodes.rs should own {required}"
            );
        }
        assert!(
            !workspace_file_exists(&format!(
                "crates/aether-data/runtime/src/repository/proxy_nodes/{feature}.rs"
            )),
            "proxy node SQL must be owned by adapter crates"
        );
    }
    assert!(
        !workspace_file_exists("crates/aether-data/runtime/src/repository/proxy_nodes/types.rs"),
        "proxy node contracts must not be duplicated in aether-data"
    );
}

#[test]
fn global_model_repositories_are_owned_by_contracts_and_driver_adapters() {
    let facade =
        read_workspace_file("crates/aether-data/runtime/src/repository/global_models/mod.rs");
    for forbidden in [
        "mod postgres;",
        "sqlx::",
        "QueryBuilder",
        "EMBEDDING_API_FORMATS",
    ] {
        assert!(
            !facade.contains(forbidden),
            "global model facade should not own driver/query policy via {forbidden}"
        );
    }

    let contracts =
        read_workspace_file("crates/aether-data/contracts/src/repository/global_models/types.rs");
    for required in [
        "pub trait GlobalModelReadRepository",
        "pub trait GlobalModelWriteRepository",
        "pub struct StoredAdminGlobalModel",
        "pub fn metadata_supports_embedding",
    ] {
        assert!(
            contracts.contains(required),
            "global model contracts should own {required}"
        );
    }
    let snapshot = read_workspace_file(
        "crates/aether-data/contracts/src/repository/global_models/snapshot.rs",
    );
    for required in [
        "pub struct GlobalModelSnapshot",
        "pub fn list_public_models",
        "pub fn list_admin_global_models",
    ] {
        assert!(
            snapshot.contains(required),
            "global model snapshot policy should own {required}"
        );
    }
    for forbidden in ["sqlx::", "PgPool", "RwLock"] {
        assert!(
            !snapshot.contains(forbidden),
            "global model snapshot policy should remain infrastructure-independent from {forbidden}"
        );
    }

    for (feature, adapter, repository) in [(
        "postgres",
        "aether_data_postgres",
        "SqlxGlobalModelReadRepository",
    )] {
        assert!(facade.contains(adapter) && facade.contains(repository));
        let source = read_workspace_file(&format!(
            "crates/aether-data/adapters/{feature}/src/global_models.rs"
        ));
        for required in [
            format!("pub struct {repository}"),
            format!("impl GlobalModelReadRepository for {repository}"),
            format!("impl GlobalModelWriteRepository for {repository}"),
            "global_models".to_string(),
            "sqlx::".to_string(),
        ] {
            assert!(
                source.contains(&required),
                "aether-data-{feature}/src/global_models.rs should own {required}"
            );
        }
        assert!(
            !workspace_file_exists(&format!(
                "crates/aether-data/runtime/src/repository/global_models/{feature}.rs"
            )),
            "global model SQL must be owned by adapter crates"
        );
    }
}

#[test]
fn auth_api_key_repositories_are_owned_by_contracts_and_driver_adapters() {
    let facade = read_workspace_file("crates/aether-data/runtime/src/repository/auth/mod.rs");
    for forbidden in ["mod postgres;", "mod types;", "sqlx::", "QueryBuilder"] {
        assert!(
            !facade.contains(forbidden),
            "auth facade should not own contracts or driver code via {forbidden}"
        );
    }

    let contracts = read_workspace_file("crates/aether-data/contracts/src/repository/auth.rs");
    for required in [
        "pub struct StoredAuthApiKeySnapshot",
        "pub struct ResolvedAuthApiKeySnapshot",
        "pub trait AuthApiKeyReadRepository",
        "pub trait AuthApiKeyWriteRepository",
    ] {
        assert!(
            contracts.contains(required),
            "auth contracts should own {required}"
        );
    }
    for forbidden in ["sqlx::", "PgPool"] {
        assert!(
            !contracts.contains(forbidden),
            "auth contracts should remain infrastructure-independent from {forbidden}"
        );
    }

    for (feature, adapter, repository) in [(
        "postgres",
        "aether_data_postgres",
        "SqlxAuthApiKeySnapshotReadRepository",
    )] {
        assert!(facade.contains(adapter) && facade.contains(repository));
        let source = read_workspace_file(&format!(
            "crates/aether-data/adapters/{feature}/src/auth.rs"
        ));
        for required in [
            format!("pub struct {repository}"),
            format!("impl AuthApiKeyReadRepository for {repository}"),
            format!("impl AuthApiKeyWriteRepository for {repository}"),
            "api_keys".to_string(),
            "sqlx::".to_string(),
        ] {
            assert!(
                source.contains(&required),
                "aether-data-{feature}/src/auth.rs should own {required}"
            );
        }
        assert!(
            !workspace_file_exists(&format!(
                "crates/aether-data/runtime/src/repository/auth/{feature}.rs"
            )),
            "auth SQL must be owned by adapter crates"
        );
    }
    assert!(
        !workspace_file_exists("crates/aether-data/runtime/src/repository/auth/types.rs"),
        "auth contracts must not be duplicated in aether-data"
    );
}

#[test]
fn user_repositories_are_owned_by_contracts_and_driver_adapters() {
    let facade = read_workspace_file("crates/aether-data/runtime/src/repository/users/mod.rs");
    for forbidden in ["mod postgres;", "mod types;", "sqlx::", "QueryBuilder"] {
        assert!(
            !facade.contains(forbidden),
            "users facade should not own contracts or driver code via {forbidden}"
        );
    }

    let contracts = read_workspace_file("crates/aether-data/contracts/src/repository/users.rs");
    for required in [
        "pub struct StoredUserAuthRecord",
        "pub struct StoredUserGroup",
        "pub struct StoredUserSessionRecord",
        "pub trait UserReadRepository",
    ] {
        assert!(
            contracts.contains(required),
            "user contracts should own {required}"
        );
    }
    for forbidden in ["sqlx::", "PgPool"] {
        assert!(
            !contracts.contains(forbidden),
            "user contracts should remain infrastructure-independent from {forbidden}"
        );
    }

    for (feature, adapter, repository) in
        [("postgres", "aether_data_postgres", "SqlxUserReadRepository")]
    {
        assert!(facade.contains(adapter) && facade.contains(repository));
        let source = read_workspace_file(&format!(
            "crates/aether-data/adapters/{feature}/src/users.rs"
        ));
        for required in [
            format!("pub struct {repository}"),
            format!("impl UserReadRepository for {repository}"),
            "users".to_string(),
            "sqlx::".to_string(),
        ] {
            assert!(
                source.contains(&required),
                "aether-data-{feature}/src/users.rs should own {required}"
            );
        }
        assert!(
            !workspace_file_exists(&format!(
                "crates/aether-data/runtime/src/repository/users/{feature}.rs"
            )),
            "user SQL must be owned by adapter crates"
        );
    }
    assert!(
        !workspace_file_exists("crates/aether-data/runtime/src/repository/users/types.rs"),
        "user contracts must not be duplicated in aether-data"
    );
}

#[test]
fn provider_catalog_repositories_are_owned_by_contracts_and_driver_adapters() {
    let facade =
        read_workspace_file("crates/aether-data/runtime/src/repository/provider_catalog/mod.rs");
    for forbidden in ["mod postgres;", "sqlx::", "QueryBuilder"] {
        assert!(
            !facade.contains(forbidden),
            "provider catalog facade should not own driver code via {forbidden}"
        );
    }

    let contracts = read_workspace_file(
        "crates/aether-data/contracts/src/repository/provider_catalog/types.rs",
    );
    for required in [
        "pub struct StoredProviderCatalogProvider",
        "pub struct StoredProviderCatalogKey",
        "pub trait ProviderCatalogReadRepository",
        "pub trait ProviderCatalogWriteRepository",
    ] {
        assert!(
            contracts.contains(required),
            "provider catalog contracts should own {required}"
        );
    }
    let snapshot = read_workspace_file(
        "crates/aether-data/contracts/src/repository/provider_catalog/snapshot.rs",
    );
    for required in [
        "pub struct ProviderCatalogSnapshot",
        "pub fn list_providers",
        "pub fn list_keys_page",
    ] {
        assert!(
            snapshot.contains(required),
            "provider catalog snapshot policy should own {required}"
        );
    }
    for forbidden in ["sqlx::", "PgPool", "RwLock"] {
        assert!(
            !snapshot.contains(forbidden),
            "provider catalog snapshot should remain infrastructure-independent from {forbidden}"
        );
    }

    for (feature, adapter, repository) in [(
        "postgres",
        "aether_data_postgres",
        "SqlxProviderCatalogReadRepository",
    )] {
        assert!(facade.contains(adapter) && facade.contains(repository));
        let source = read_workspace_file(&format!(
            "crates/aether-data/adapters/{feature}/src/provider_catalog.rs"
        ));
        for required in [
            format!("pub struct {repository}"),
            format!("impl ProviderCatalogReadRepository for {repository}"),
            format!("impl ProviderCatalogWriteRepository for {repository}"),
            "provider_api_keys".to_string(),
            "sqlx::".to_string(),
        ] {
            assert!(
                source.contains(&required),
                "aether-data-{feature}/src/provider_catalog.rs should own {required}"
            );
        }
        assert!(
            !workspace_file_exists(&format!(
                "crates/aether-data/runtime/src/repository/provider_catalog/{feature}.rs"
            )),
            "provider catalog SQL must be owned by adapter crates"
        );
    }
}

#[test]
fn wallet_repositories_are_owned_by_contracts_and_driver_adapters() {
    let facade = read_workspace_file("crates/aether-data/runtime/src/repository/wallet/mod.rs");
    for forbidden in ["mod postgres;", "mod types;", "sqlx::", "QueryBuilder"] {
        assert!(
            !facade.contains(forbidden),
            "wallet facade should not own contracts or driver code via {forbidden}"
        );
    }

    let contracts =
        read_workspace_file("crates/aether-data/contracts/src/repository/wallet/types.rs");
    for required in [
        "pub struct StoredWalletSnapshot",
        "pub struct StoredAdminPaymentOrder",
        "pub trait WalletReadRepository",
        "pub trait WalletWriteRepository",
    ] {
        assert!(
            contracts.contains(required),
            "wallet contracts should own {required}"
        );
    }
    let snapshot =
        read_workspace_file("crates/aether-data/contracts/src/repository/wallet/snapshot.rs");
    for required in [
        "pub struct WalletReadSeed",
        "pub struct WalletReadSnapshot",
        "pub fn list_admin_wallets",
    ] {
        assert!(
            snapshot.contains(required),
            "wallet snapshot policy should own {required}"
        );
    }
    for forbidden in ["sqlx::", "PgPool", "RwLock"] {
        assert!(
            !snapshot.contains(forbidden),
            "wallet snapshot should remain infrastructure-independent from {forbidden}"
        );
    }

    for (feature, adapter, repository) in
        [("postgres", "aether_data_postgres", "SqlxWalletRepository")]
    {
        assert!(facade.contains(adapter) && facade.contains(repository));
        let source = read_workspace_file(&format!(
            "crates/aether-data/adapters/{feature}/src/wallet.rs"
        ));
        for required in [
            format!("pub struct {repository}"),
            format!("impl WalletReadRepository for {repository}"),
            format!("impl WalletWriteRepository for {repository}"),
            "wallets".to_string(),
            "sqlx::".to_string(),
        ] {
            assert!(
                source.contains(&required),
                "aether-data-{feature}/src/wallet.rs should own {required}"
            );
        }
        assert!(
            !workspace_file_exists(&format!(
                "crates/aether-data/runtime/src/repository/wallet/{feature}.rs"
            )),
            "wallet SQL must be owned by adapter crates"
        );
    }
    assert!(
        !workspace_file_exists("crates/aether-data/runtime/src/repository/wallet/types.rs"),
        "wallet contracts must not be duplicated in aether-data"
    );
}

#[test]
fn usage_repositories_are_owned_by_contracts_and_driver_adapters() {
    let facade = read_workspace_file("crates/aether-data/runtime/src/repository/usage/mod.rs");
    for forbidden in [
        "mod postgres;",
        "sqlx::",
        "QueryBuilder",
        "pub(crate) struct ApiKeyUsageDelta",
        "pub(crate) struct ProviderApiKeyUsageDelta",
    ] {
        assert!(
            !facade.contains(forbidden),
            "usage facade should not own driver or pure policy code via {forbidden}"
        );
    }
    let contracts =
        read_workspace_file("crates/aether-data/contracts/src/repository/usage/types.rs");
    for required in [
        "pub struct StoredRequestUsageAudit",
        "pub struct UpsertUsageRecord",
        "pub trait UsageReadRepository",
        "pub trait UsageWriteRepository",
    ] {
        assert!(
            contracts.contains(required),
            "usage contracts should own {required}"
        );
    }
    let policy = read_workspace_file("crates/aether-data/contracts/src/repository/usage/policy.rs");
    for required in [
        "pub struct ApiKeyUsageDelta",
        "pub struct ProviderApiKeyUsageDelta",
        "pub fn usage_can_recover_terminal_failure",
        "pub fn strip_deprecated_usage_display_fields",
    ] {
        assert!(
            policy.contains(required),
            "usage policy should own {required}"
        );
    }
    for forbidden in ["sqlx::", "PgPool", "RwLock"] {
        assert!(
            !policy.contains(forbidden),
            "usage policy should remain infrastructure-independent from {forbidden}"
        );
    }

    let postgres = read_workspace_file("crates/aether-data/adapters/postgres/src/usage/mod.rs");
    for required in [
        "pub struct SqlxUsageReadRepository",
        "impl UsageReadRepository for SqlxUsageReadRepository",
        "impl UsageWriteRepository for SqlxUsageReadRepository",
        "sqlx::",
    ] {
        assert!(
            postgres.contains(required),
            "PostgreSQL usage adapter should own {required}"
        );
    }

    for path in [
        "crates/aether-data/runtime/src/repository/usage/postgres/mod.rs",
        "crates/aether-data/runtime/src/repository/usage/postgres/cleanup.rs",
    ] {
        assert!(
            !workspace_file_exists(path),
            "usage SQL must move out of {path}"
        );
    }
    assert_eq!(
        workspace_files_with_extension(
            "crates/aether-data/adapters/postgres/src/usage/queries",
            "sql"
        )
        .len(),
        27,
        "all PostgreSQL usage SQL fragments should be owned by the adapter crate"
    );
}

#[test]
fn lifecycle_backfills_are_partitioned_by_driver() {
    let facade = read_workspace_file("crates/aether-data/runtime/src/lifecycle/backfill.rs");
    for module in ["mod postgres;", "mod types;", "mod tests;"] {
        assert!(
            facade.contains(module),
            "backfill facade should declare {module}"
        );
    }
    for forbidden in ["sqlx::", "PgPool", "BACKFILL_MIGRATOR", "CREATE TABLE"] {
        assert!(
            !facade.contains(forbidden),
            "backfill facade should not own driver operations via {forbidden}"
        );
    }

    let types = read_workspace_file("crates/aether-data/runtime/src/lifecycle/backfill/types.rs");
    assert!(types.contains("pub struct PendingBackfillInfo"));
    assert!(!types.contains("sqlx::"));

    let postgres =
        read_workspace_file("crates/aether-data/runtime/src/lifecycle/backfill/postgres.rs");
    for required in [
        "sqlx::migrate!",
        "pub async fn run_backfills",
        "pub async fn pending_backfills",
        "schema_backfills",
    ] {
        assert!(
            postgres.contains(required),
            "backfill/postgres.rs should own {required}"
        );
    }
}

#[test]
fn lifecycle_migrations_are_partitioned_by_driver() {
    let facade = read_workspace_file("crates/aether-data/runtime/src/lifecycle/migrate.rs");
    for module in ["mod postgres;", "mod types;", "mod tests;"] {
        assert!(
            facade.contains(module),
            "migration facade should declare {module}"
        );
    }
    for forbidden in [
        "POSTGRES_MIGRATOR",
        "PgConnection",
        "PgPool",
        "apply_snapshot_if_empty",
        "sqlx::migrate!",
    ] {
        assert!(
            !production_source(&facade).contains(forbidden),
            "migration facade should not own PostgreSQL execution via {forbidden}"
        );
    }

    let types = read_workspace_file("crates/aether-data/runtime/src/lifecycle/migrate/types.rs");
    let required = "pub use aether_data_contracts::PendingMigrationInfo";
    assert!(
        types.contains(required),
        "migrate/types.rs should own {required}"
    );
    let forbidden = "PgPool";
    assert!(
        !types.contains(forbidden),
        "migrate/types.rs should remain driver-independent from {forbidden}"
    );

    let postgres =
        read_workspace_file("crates/aether-data/runtime/src/lifecycle/migrate/postgres.rs");
    assert!(postgres.contains("aether_data_postgres"));
    assert!(postgres.contains("PgPool"));
    assert!(postgres.contains("pub async fn run_migrations"));
    assert!(postgres.contains("apply_snapshot_if_empty"));
    assert!(postgres.contains("pub async fn prepare_database_for_startup"));
    assert!(!postgres.contains("sqlx::migrate!"));
    let postgres_adapter =
        read_workspace_file("crates/aether-data/adapters/postgres/src/migrations.rs");
    assert!(postgres_adapter.contains("sqlx::migrate!(\"./migrations\")"));
    assert!(workspace_file_exists(
        "crates/aether-data/adapters/postgres/migrations/20260403000000_baseline.sql"
    ));
    for required in [
        "sqlx::migrate!",
        "PgPool",
        "pub async fn run_migrations",
        "pub async fn pending_migrations",
        "pub async fn run_migrations_with_bootstrap",
        "pub trait PostgresMigrationBootstrap",
    ] {
        assert!(
            postgres_adapter.contains(required),
            "crates/aether-data/adapters/postgres/src/migrations.rs should own {required}"
        );
    }

    assert!(
        !workspace_file_exists("crates/aether-data/runtime/migrations"),
        "driver migration SQL must be owned by adapter crates"
    );
}

#[test]
fn routing_profile_repositories_are_owned_by_driver_adapters() {
    let facade =
        read_workspace_file("crates/aether-data/runtime/src/repository/routing_profiles/mod.rs");
    for forbidden in ["mod postgres;", "sqlx::"] {
        assert!(
            !facade.contains(forbidden),
            "routing profile facade should not own driver implementation via {forbidden}"
        );
    }
    for (feature, adapter, repository) in [(
        "postgres",
        "aether_data_postgres",
        "PostgresRoutingGroupRepository",
    )] {
        assert!(
            facade.contains(&format!("#[cfg(feature = \"{feature}\")]")),
            "routing profile facade should preserve the {feature} feature boundary"
        );
        assert!(
            facade.contains(&format!("pub use {adapter}::{repository};")),
            "routing profile facade should re-export {repository} from {adapter}"
        );

        let source = read_workspace_file(&format!(
            "crates/aether-data/adapters/{feature}/src/routing_profiles.rs"
        ));
        for required in [
            format!("pub struct {repository}"),
            format!("impl RoutingGroupReadRepository for {repository}"),
            format!("impl RoutingGroupWriteRepository for {repository}"),
            "sqlx::query".to_string(),
            "FROM routing_groups".to_string(),
        ] {
            assert!(
                source.contains(&required),
                "aether-data-{feature}/src/routing_profiles.rs should own {required}"
            );
        }
    }
}

#[test]
fn provider_quota_repositories_are_owned_by_driver_adapters() {
    let facade = read_workspace_file("crates/aether-data/runtime/src/repository/quota/mod.rs");
    for forbidden in ["mod postgres;", "sqlx::", "SelectQuery"] {
        assert!(
            !facade.contains(forbidden),
            "provider quota facade should not own driver implementation via {forbidden}"
        );
    }
    for (feature, adapter, repository) in [(
        "postgres",
        "aether_data_postgres",
        "SqlxProviderQuotaRepository",
    )] {
        assert!(
            facade.contains(&format!("#[cfg(feature = \"{feature}\")]")),
            "provider quota facade should preserve the {feature} feature boundary"
        );
        assert!(
            facade.contains(&format!("pub use {adapter}::{repository};")),
            "provider quota facade should re-export {repository} from {adapter}"
        );

        let source = read_workspace_file(&format!(
            "crates/aether-data/adapters/{feature}/src/quota.rs"
        ));
        for required in [
            format!("pub struct {repository}"),
            format!("impl ProviderQuotaReadRepository for {repository}"),
            format!("impl ProviderQuotaWriteRepository for {repository}"),
            "sqlx::query".to_string(),
            "UPDATE providers".to_string(),
        ] {
            assert!(
                source.contains(&required),
                "aether-data-{feature}/src/quota.rs should own {required}"
            );
        }
    }
}

#[test]
fn pool_score_repositories_are_owned_by_driver_adapters() {
    let facade =
        read_workspace_file("crates/aether-data/runtime/src/repository/pool_scores/mod.rs");
    for forbidden in ["mod postgres;", "sqlx::", "QueryBuilder"] {
        assert!(
            !facade.contains(forbidden),
            "pool score facade should not own driver implementation via {forbidden}"
        );
    }
    for (feature, adapter, repository) in [(
        "postgres",
        "aether_data_postgres",
        "PostgresPoolMemberScoreRepository",
    )] {
        assert!(
            facade.contains(&format!("#[cfg(feature = \"{feature}\")]")),
            "pool score facade should preserve the {feature} feature boundary"
        );
        assert!(
            facade.contains(&format!("pub use {adapter}::{repository};")),
            "pool score facade should re-export {repository} from {adapter}"
        );

        let source = read_workspace_file(&format!(
            "crates/aether-data/adapters/{feature}/src/pool_scores.rs"
        ));
        for required in [
            format!("pub struct {repository}"),
            format!("impl PoolScoreReadRepository for {repository}"),
            format!("impl PoolMemberScoreWriteRepository for {repository}"),
            "sqlx::query".to_string(),
            "pool_member_scores".to_string(),
        ] {
            assert!(
                source.contains(&required),
                "aether-data-{feature}/src/pool_scores.rs should own {required}"
            );
        }
    }
}

#[test]
fn background_task_repositories_are_owned_by_driver_adapters() {
    let facade =
        read_workspace_file("crates/aether-data/runtime/src/repository/background_tasks/mod.rs");
    for forbidden in ["mod postgres;", "sqlx::", "QueryBuilder"] {
        assert!(
            !facade.contains(forbidden),
            "background task facade should not own driver implementation via {forbidden}"
        );
    }
    for (feature, adapter, repository) in [(
        "postgres",
        "aether_data_postgres",
        "SqlxBackgroundTaskRepository",
    )] {
        assert!(
            facade.contains(&format!("#[cfg(feature = \"{feature}\")]")),
            "background task facade should preserve the {feature} feature boundary"
        );
        assert!(
            facade.contains(&format!("pub use {adapter}::{repository};")),
            "background task facade should re-export {repository} from {adapter}"
        );

        let source = read_workspace_file(&format!(
            "crates/aether-data/adapters/{feature}/src/background_tasks.rs"
        ));
        for required in [
            format!("pub struct {repository}"),
            format!("impl BackgroundTaskReadRepository for {repository}"),
            format!("impl BackgroundTaskWriteRepository for {repository}"),
            "sqlx::query".to_string(),
            "background_task_runs".to_string(),
            "background_task_events".to_string(),
        ] {
            assert!(
                source.contains(&required),
                "aether-data-{feature}/src/background_tasks.rs should own {required}"
            );
        }
    }
}

#[test]
fn lifecycle_driver_export_operations_are_partitioned() {
    let facade = read_workspace_file("crates/aether-data/runtime/src/lifecycle/export.rs");
    for required in ["mod postgres;", "mod tests;"] {
        assert!(
            facade.contains(required),
            "export facade should declare {required}"
        );
    }
    assert!(!facade.contains("mod tests {"));

    for (driver, implementation_marker) in [("postgres", "fn normalize_postgres_import_payload(")] {
        for required in [
            format!("pub use {driver}::"),
            format!("export_{driver}_core_jsonl"),
            format!("import_{driver}_plan"),
        ] {
            assert!(
                facade.contains(&required),
                "export facade should expose {driver} via {required}"
            );
        }
        for forbidden in [
            format!("pub async fn export_{driver}_core_jsonl("),
            format!("pub async fn export_{driver}_jsonl("),
            format!("pub async fn import_{driver}_jsonl("),
            format!("pub async fn import_{driver}_plan("),
            format!("fn {driver}_domain_table("),
            implementation_marker.to_string(),
        ] {
            assert!(
                !facade.contains(&forbidden),
                "export facade should not own {driver} implementation via {forbidden}"
            );
        }

        let source = read_workspace_file(&format!(
            "crates/aether-data/runtime/src/lifecycle/export/{driver}.rs"
        ));
        for required in [
            format!("pub async fn export_{driver}_core_jsonl("),
            format!("pub async fn export_{driver}_jsonl("),
            format!("pub async fn import_{driver}_jsonl("),
            format!("pub async fn import_{driver}_plan("),
            format!("fn {driver}_domain_table("),
            implementation_marker.to_string(),
            "sqlx::query".to_string(),
        ] {
            assert!(
                source.contains(&required),
                "export/{driver}.rs should own {required}"
            );
        }
    }

    let tests = read_workspace_file("crates/aether-data/runtime/src/lifecycle/export/tests.rs");
    assert!(tests.contains("jsonl_round_trips_manifest_and_domain_rows"));
    assert!(tests.contains("postgres_import_payload_normalizes_imported_values_for_target_columns"));
}

#[test]
fn testkit_does_not_copy_aether_business_schema_sql() {
    let owner_relay_baseline = read_workspace_file(
        "crates/aether-testing/integration/src/bin/multi_instance_owner_relay_baseline.rs",
    );
    for forbidden in [
        "CREATE TYPE proxynodestatus",
        "CREATE TABLE IF NOT EXISTS system_configs",
        "CREATE TABLE IF NOT EXISTS proxy_nodes",
        "CREATE TABLE IF NOT EXISTS proxy_node_events",
        "PgConnection::connect",
        "sqlx::{Connection, Executor, PgConnection}",
    ] {
        assert!(
            !owner_relay_baseline.contains(forbidden),
            "owner relay baseline should use aether-data schema bootstrap instead of copying business schema SQL via {forbidden}"
        );
    }
    assert!(
        owner_relay_baseline.contains("prepare_aether_postgres_schema(&postgres_url).await?"),
        "owner relay baseline should prepare business schema through aether-testkit's aether-data helper"
    );

    let postgres_testkit = read_workspace_file("crates/aether-testing/testkit/src/postgres.rs");
    for required in [
        "pub async fn prepare_aether_postgres_schema",
        "DataBackends::from_config",
        ".prepare_database_for_startup()",
        ".run_database_migrations()",
    ] {
        assert!(
            postgres_testkit.contains(required),
            "shared Postgres helper should delegate Aether schema setup to aether-data via {required}"
        );
    }
}

#[test]
fn gateway_main_keeps_database_export_import_driver_selection_in_data_layer() {
    let main_rs = read_workspace_file("apps/aether-gateway/src/main.rs");
    for forbidden in ["PostgresPoolFactory", "to_postgres_config()"] {
        assert!(
            !main_rs.contains(forbidden),
            "main.rs should delegate database export/import driver selection to aether-data instead of {forbidden}"
        );
    }
    for required in ["export_database_jsonl", "import_database_jsonl"] {
        assert!(
            main_rs.contains(required),
            "main.rs should use aether-data {required}"
        );
    }
}

#[test]
fn wallet_repository_does_not_reexport_settlement_types() {
    let wallet_mod = read_workspace_file("crates/aether-data/runtime/src/repository/wallet/mod.rs");
    let wallet_types =
        read_workspace_file("crates/aether-data/contracts/src/repository/wallet/types.rs");
    let wallet_sql = read_workspace_file("crates/aether-data/adapters/postgres/src/wallet.rs");
    let wallet_memory =
        read_workspace_file("crates/aether-data/runtime/src/repository/wallet/memory.rs");

    assert!(
        !wallet_mod.contains("StoredUsageSettlement"),
        "wallet/mod.rs should not export StoredUsageSettlement"
    );
    assert!(
        !wallet_mod.contains("UsageSettlementInput"),
        "wallet/mod.rs should not export UsageSettlementInput"
    );
    assert!(
        !wallet_types.contains("pub use crate::repository::settlement"),
        "wallet/types.rs should not re-export settlement types"
    );
    assert!(
        !wallet_types.contains("async fn settle_usage("),
        "wallet/types.rs should not own settlement entrypoints"
    );
    assert!(
        !wallet_sql.contains("impl SettlementWriteRepository"),
        "wallet/postgres.rs should not implement SettlementWriteRepository"
    );
    assert!(
        !wallet_memory.contains("impl SettlementWriteRepository"),
        "wallet/memory.rs should not implement SettlementWriteRepository"
    );
}

#[test]
fn gateway_system_config_types_are_owned_by_aether_data() {
    let state_mod = read_workspace_file("apps/aether-gateway/src/data/state/mod.rs");
    assert!(
        state_mod.contains("aether_data::repository::system"),
        "data/state/mod.rs should depend on aether-data system types"
    );
    assert!(
        !state_mod.contains("pub(crate) struct StoredSystemConfigEntry"),
        "data/state/mod.rs should not define StoredSystemConfigEntry locally"
    );

    let state_core = read_workspace_file("apps/aether-gateway/src/data/state/core.rs");
    for pattern in [
        "backends.list_system_config_entries().await",
        ".upsert_system_config_entry(key, value, description)",
        "backends.read_admin_system_stats().await",
        "AdminSystemStats::default()",
    ] {
        assert!(
            state_core.contains(pattern),
            "data/state/core.rs should use shared system DTO path {pattern}"
        );
    }
    let data_backends =
        read_workspace_file("crates/aether-data/runtime/src/backend/maintenance.rs");
    let pattern = "postgres.list_system_config_entries().await";
    assert!(
        data_backends.contains(pattern),
        "aether-data backends should own driver-specific system config dispatch {pattern}"
    );
    for pattern in [
        "|(key, value, description, updated_at_unix_secs)|",
        "Ok((0, 0, 0, 0))",
    ] {
        assert!(
            !state_core.contains(pattern),
            "data/state/core.rs should not own local system DTO projection {pattern}"
        );
    }

    let system_types = read_workspace_file("crates/aether-data/runtime/src/repository/system.rs");
    for pattern in [
        "pub struct StoredSystemConfigEntry",
        "pub struct AdminSystemStats",
        "pub struct AdminSecurityBlacklistEntry",
    ] {
        assert!(
            system_types.contains(pattern),
            "aether-data system module should own {pattern}"
        );
    }

    let admin_types = read_workspace_file("apps/aether-gateway/src/state/admin_types.rs");
    assert!(
        admin_types.contains("aether_data::repository::system::AdminSecurityBlacklistEntry"),
        "state/admin_types.rs should re-export AdminSecurityBlacklistEntry from aether-data"
    );
    assert!(
        !admin_types.contains("struct AdminSecurityBlacklistEntry"),
        "state/admin_types.rs should not define AdminSecurityBlacklistEntry locally"
    );

    let runtime_mod = read_workspace_file("apps/aether-gateway/src/state/runtime/mod.rs");
    assert!(
        !runtime_mod.contains("AdminSecurityBlacklistEntryPayload"),
        "state/runtime/mod.rs should not keep the unused blacklist payload wrapper"
    );
}

#[test]
fn gateway_auth_snapshot_type_is_owned_by_aether_data() {
    let gateway_auth = read_workspace_file("apps/aether-gateway/src/data/auth.rs");
    let runtime_mod = read_workspace_file("apps/aether-gateway/src/state/runtime/mod.rs");
    let auth_api_keys =
        read_workspace_file("apps/aether-gateway/src/state/runtime/auth/api_keys.rs");
    assert!(
        gateway_auth.contains("aether_data::repository::auth"),
        "data/auth.rs should depend on aether-data auth snapshot types"
    );
    assert!(
        gateway_auth.contains("ResolvedAuthApiKeySnapshot as GatewayAuthApiKeySnapshot"),
        "data/auth.rs should expose the shared resolved auth snapshot type under the gateway-facing name"
    );
    for pattern in [
        "pub(crate) struct GatewayAuthApiKeySnapshot",
        "pub(crate) async fn read_auth_api_key_snapshot(",
        "pub(crate) async fn read_auth_api_key_snapshot_by_key_hash(",
        "fn effective_allowed_providers(",
        "fn effective_allowed_api_formats(",
        "fn effective_allowed_models(",
    ] {
        assert!(
            !gateway_auth.contains(pattern),
            "data/auth.rs should not own local auth snapshot logic {pattern}"
        );
    }
    for pattern in [
        "pub(crate) async fn read_auth_api_key_snapshot(",
        "pub(crate) async fn read_auth_api_key_snapshots_by_ids(",
    ] {
        assert!(
            !auth_api_keys.contains(pattern),
            "state/runtime/auth/api_keys.rs should not keep auth snapshot read wrapper {pattern}"
        );
    }
    assert!(
        !runtime_mod.contains("mod audit;"),
        "state/runtime/mod.rs should not keep the obsolete audit runtime module"
    );
    assert!(
        auth_api_keys.contains("touch_auth_api_key_last_used_best_effort"),
        "state/runtime/auth/api_keys.rs should own auth api key last_used touch helper"
    );
    assert!(
        !auth_api_keys.contains("fn has_auth_api_key_writer("),
        "state/runtime/auth/api_keys.rs should not keep auth api key writer passthrough"
    );

    let auth_types = read_workspace_file("crates/aether-data/contracts/src/repository/auth.rs");
    for pattern in [
        "pub struct ResolvedAuthApiKeySnapshot",
        "pub trait ResolvedAuthApiKeySnapshotReader",
        "pub async fn read_resolved_auth_api_key_snapshot(",
        "pub async fn read_resolved_auth_api_key_snapshot_by_key_hash(",
        "pub async fn read_resolved_auth_api_key_snapshot_by_user_api_key_ids(",
        "pub fn effective_allowed_providers(&self)",
        "pub fn effective_allowed_api_formats(&self)",
        "pub fn effective_allowed_models(&self)",
    ] {
        assert!(
            auth_types.contains(pattern),
            "aether-data auth types should own {pattern}"
        );
    }
}

#[test]
fn gateway_auth_data_layer_does_not_keep_ldap_row_wrapper() {
    let gateway_auth_state = read_workspace_file("apps/aether-gateway/src/data/state/auth.rs");
    for pattern in [
        "struct StoredLdapAuthUserRow",
        "fn map_ldap_user_auth_row(",
        "Result<Option<StoredLdapAuthUserRow>, DataLayerError>",
        "existing.user.",
        "map_user_auth_row(row)",
    ] {
        assert!(
            !gateway_auth_state.contains(pattern),
            "data/state/auth.rs should not keep ldap row wrapper {pattern}"
        );
    }

    let user_sql = read_workspace_file("crates/aether-data/adapters/postgres/src/users.rs");
    for pattern in [
        "Result<Option<StoredUserAuthRecord>, DataLayerError>",
        "return map_user_auth_row(row).map(Some);",
    ] {
        assert!(
            user_sql.contains(pattern),
            "aether-data user repository should use shared user auth record directly via {pattern}"
        );
    }
}

#[test]
fn gateway_provider_oauth_storage_types_are_owned_by_aether_data() {
    let provider_oauth_storage = read_workspace_file(
        "apps/aether-gateway/src/handlers/admin/provider/oauth/state/storage.rs",
    );
    let request_provider_oauth =
        read_workspace_file("apps/aether-gateway/src/handlers/admin/request/provider/oauth.rs");
    assert!(
        request_provider_oauth.contains("aether_data::repository::provider_oauth"),
        "request/provider/oauth.rs should depend on aether-data provider oauth storage types"
    );
    for pattern in [
        "pub(crate) struct StoredAdminProviderOAuthDeviceSession",
        "pub(crate) struct StoredAdminProviderOAuthState",
        "const KIRO_DEVICE_AUTH_SESSION_PREFIX",
        "fn provider_oauth_device_session_key(",
        "fn build_provider_oauth_batch_task_status_payload(",
        "fn provider_oauth_batch_task_key(",
        "const PROVIDER_OAUTH_BATCH_TASK_TTL_SECS",
        "format!(\"provider_oauth_state:{nonce}\")",
    ] {
        assert!(
            !provider_oauth_storage.contains(pattern),
            "provider_oauth/state/storage.rs should not own local storage helper {pattern}"
        );
    }
    for pattern in [
        "StoredAdminProviderOAuthDeviceSession",
        "StoredAdminProviderOAuthState",
        "provider_oauth_batch_task_storage_key",
        "build_provider_oauth_batch_task_status_payload",
        "PROVIDER_OAUTH_BATCH_TASK_TTL_SECS",
    ] {
        assert!(
            request_provider_oauth.contains(pattern),
            "request/provider/oauth.rs should own aether-data provider oauth storage boundary {pattern}"
        );
    }

    assert!(
        !workspace_file_exists("apps/aether-gateway/src/handlers/admin/provider/oauth/state.rs"),
        "provider_oauth/state.rs should not exist after oauth storage helpers move under state/storage.rs"
    );

    let dispatch_device_authorize = read_workspace_file(
        "apps/aether-gateway/src/handlers/admin/provider/oauth/dispatch/device/authorize.rs",
    );
    assert!(
        dispatch_device_authorize.contains("aether_data::repository::provider_oauth"),
        "provider_oauth/dispatch/device/authorize.rs should use shared provider oauth storage DTOs"
    );
    assert!(
        !workspace_file_exists(
            "apps/aether-gateway/src/handlers/admin/provider/oauth/dispatch/device.rs"
        ),
        "provider_oauth/dispatch/device.rs should be removed once device flows move under dispatch/device/"
    );

    let shared_provider_oauth =
        read_workspace_file("crates/aether-data/runtime/src/repository/provider_oauth.rs");
    for pattern in [
        "pub struct StoredAdminProviderOAuthDeviceSession",
        "pub struct StoredAdminProviderOAuthState",
        "pub fn provider_oauth_device_session_storage_key(",
        "pub fn provider_oauth_state_storage_key(",
        "pub fn provider_oauth_batch_task_storage_key(",
        "pub fn build_provider_oauth_batch_task_status_payload(",
        "pub const KIRO_DEVICE_AUTH_SESSION_TTL_BUFFER_SECS: u64 = 60;",
        "pub const PROVIDER_OAUTH_BATCH_TASK_TTL_SECS: u64 = 24 * 60 * 60;",
        "pub const PROVIDER_OAUTH_STATE_TTL_SECS: u64 = 600;",
    ] {
        assert!(
            shared_provider_oauth.contains(pattern),
            "aether-data provider oauth storage module should own {pattern}"
        );
    }
}