datasources 0.1.5

Async datasource interfaces, middleware, registry, and test doubles
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
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102

use crate::bulk_crud_repository::BulkCRUDRepository;
use crate::enrichment::Enrichment;
use crate::readonly_enrichment_strategy::ReadonlyEnrichmentStrategy;
use crate::repository::{as_readonly, ICRUDRepository, IReadonlyRepository};
use crate::result::Result;
use crate::row::Row;
use std::sync::Arc;

pub(crate) struct StoredEnrichment {
    pub enrichment: Enrichment,
    pub via: Arc<dyn IReadonlyRepository>,
    pub persist: Option<Arc<dyn ICRUDRepository>>,
    pub persist_bulk: Option<Arc<BulkCRUDRepository>>,
    pub link: Option<Arc<dyn ICRUDRepository>>,
    pub strategy: Arc<dyn ReadonlyEnrichmentStrategy>,
    linked: bool,
}

impl StoredEnrichment {
    pub(crate) fn direct(
        enrichment: Enrichment,
        via: Arc<dyn IReadonlyRepository>,
        persist: Option<Arc<dyn ICRUDRepository>>,
        strategy: Arc<dyn ReadonlyEnrichmentStrategy>,
    ) -> Self {
        Self::direct_bulk(enrichment, via, persist, None, strategy)
    }

    pub(crate) fn direct_bulk(
        enrichment: Enrichment,
        via: Arc<dyn IReadonlyRepository>,
        persist: Option<Arc<dyn ICRUDRepository>>,
        persist_bulk: Option<Arc<BulkCRUDRepository>>,
        strategy: Arc<dyn ReadonlyEnrichmentStrategy>,
    ) -> Self {
        Self {
            enrichment,
            via,
            persist,
            persist_bulk,
            link: None,
            strategy,
            linked: false,
        }
    }

    pub(crate) fn linked(
        enrichment: Enrichment,
        via: Arc<dyn IReadonlyRepository>,
        link: Arc<dyn ICRUDRepository>,
        strategy: Arc<dyn ReadonlyEnrichmentStrategy>,
    ) -> Self {
        Self {
            enrichment,
            via,
            persist: None,
            persist_bulk: None,
            link: Some(link),
            strategy,
            linked: true,
        }
    }

    pub(crate) async fn apply(
        &self,
        parents: &mut Vec<Row>,
        sources: Option<&[Option<Row>]>,
    ) -> Result<()> {
        match self.linked {
            true => {
                self.strategy
                    .apply_linked(
                        self.via.clone(),
                        as_readonly(self.link.clone().expect("linked enrichment")),
                        &self.enrichment,
                        parents,
                        sources,
                    )
                    .await
            }
            false => {
                self.strategy
                    .apply(self.via.clone(), &self.enrichment, parents, sources)
                    .await
            }
        }
    }
}

impl Clone for StoredEnrichment {
    fn clone(&self) -> Self {
        Self {
            enrichment: self.enrichment.clone(),
            via: self.via.clone(),
            persist: self.persist.clone(),
            persist_bulk: self.persist_bulk.clone(),
            link: self.link.clone(),
            strategy: self.strategy.clone(),
            linked: self.linked,
        }
    }
}