Estou utilizando sqlx com postgres.

Exemplo simples de estrutura do projeto:

src/application/repositories/company_repository.rs

use crate::core::entities::company::Company;
use async_trait::async_trait;

#[async_trait]
pub trait CompanyRepository {
    async fn update_or_create(&self, company: Company) -> Result<(), String>;
    async fn get_all(&self) -> Result<Vec<Company>, String>;
}

src/adapters/repositories/postgres_company_repository.rs

use crate::application::repositories::company_repository::CompanyRepository;
use async_trait::async_trait;
use sqlx::{Executor, PgPool};

#[async_trait]
impl CompanyRepository for PostgresCompanyRepository {
    async fn update_or_create(&self, company: Company) -> Result<(), String> {
        let model = CompanyModel::from(company);
        let query = sqlx::query(
            "
                INSERT INTO companies (id, social_reason, cnpj)
                VALUES ($1, $2, $3)
                ON CONFLICT (id) DO UPDATE SET social_reason = $2, cnpj = $3
                ",
        )
        .bind(model.id)
        .bind(model.social_reason)
        .bind(model.cnpj);
        self.get_pool()
            .execute(query)
            .await
            .map_err(|e| e.to_string())?;
        Ok(())
    }
}

O problema em questão é que a async_trait está em um arquivo que teoricamente deveria ter apenas dependência do core, sem dependência de third_party.

Mas não encontrei outra opção senão colocar ela aqui, o que me parece errado.

Por isso estou perguntando se existe uma maneira de fazer isso sem quebrar o padrão de dependência do projeto ou devo considerar essa crate como parte da linguagem Rust, porque sem ela ficamos limitados a criar traits síncronas.

A arquitetura deveria permitir essa dependência no arquivo de repositório? Isso que eu considero uma ferida, estou implementando a arquitetura de forma errada?