datasources 0.1.68

Async datasource interfaces, middleware, registry, and test doubles
Documentation
use crate::converters::{RowTypeConverter, TypeConverter};
use crate::entity::Entity;
use crate::repository_tree::RepositoryTree;
use crate::result::Result;
use crate::row::Row;
use crate::schema::Schema;
use crate::write_mode::WriteMode;
use async_trait::async_trait;
use std::collections::HashSet;

#[async_trait]
pub trait WriteEnrichmentStrategy<T: Entity = Row>: Send + Sync {
    fn use_transaction(&self) -> bool {
        false
    }

    async fn persist(
        &self,
        tree: &RepositoryTree<T>,
        items: &mut [T],
        mode: WriteMode,
    ) -> Result<()>;

    async fn persist_bulk(
        &self,
        tree: &RepositoryTree<T>,
        items: &mut [T],
        mode: WriteMode,
    ) -> Result<()> {
        self.persist(tree, items, mode).await
    }

    async fn resolve_lookups(
        &self,
        _tree: &RepositoryTree<T>,
        _items: &mut [T],
        _record: &mut Row,
        _schema: &Schema,
    ) -> Result<()> {
        Ok(())
    }

    fn mapped_sources(
        &self,
        _tree: &RepositoryTree<T>,
        _column: &dyn Fn(&str) -> String,
    ) -> Vec<(String, String)> {
        Vec::new()
    }

    async fn lookup(
        &self,
        tree: &RepositoryTree<T>,
        items: &mut [T],
        record: &mut Row,
        schema: &Schema,
        _columns: Vec<(String, String)>,
    ) -> Result<()> {
        self.resolve_lookups(tree, items, record, schema).await
    }

    async fn lookup_row(
        &self,
        tree: &RepositoryTree<T>,
        item: &mut T,
        schema: &Schema,
        objects: Box<dyn TypeConverter<T, Row> + Send + Sync>,
        rows: Option<&RowTypeConverter>,
        columns: Vec<(String, String)>,
    ) -> Result<Row> {
        let mut record = objects.reverse_convert(item)?;
        self.lookup(tree, std::slice::from_mut(item), &mut record, schema, columns)
            .await?;
        match rows {
            Some(converter) => converter.reverse_convert(&record),
            None => Ok(record),
        }
    }

    fn sources(
        &self,
        tree: &RepositoryTree<T>,
        column: &dyn Fn(&str) -> String,
    ) -> HashSet<String> {
        self.mapped_sources(tree, column)
            .into_iter()
            .flat_map(|(source, mapped)| [source, mapped])
            .collect()
    }

    fn destination(&self, _tree: &RepositoryTree<T>, _name: &str) -> bool {
        false
    }
}