datasources 0.1.55

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

use crate::create_enrichment_strategy::{set, CreateEnrichmentStrategy};
use crate::datasource_error::DatasourceError;
use crate::default_write_enrichment_strategy::{related_ids, required};
use crate::enrichment::Enrichment;
use crate::entity::Entity;
use crate::repository::ICRUDRepository;
use crate::result::Result;
use async_trait::async_trait;
use std::sync::Arc;

pub struct DefaultCreateEnrichmentStrategy;

#[async_trait]
impl<T: Entity> CreateEnrichmentStrategy<T> for DefaultCreateEnrichmentStrategy {
    async fn create_children(
        &self,
        writer: Arc<dyn ICRUDRepository>,
        enrichment: &Enrichment,
        parent: &mut T,
    ) -> Result<()> {
        create_children(writer.as_ref(), enrichment, parent).await
    }

    async fn create_linked(
        &self,
        writer: Arc<dyn ICRUDRepository>,
        enrichment: &Enrichment,
        parent: &mut T,
    ) -> Result<()> {
        create_links(writer.as_ref(), enrichment, parent).await
    }
}

pub(crate) async fn create_children<T: Entity, TChild: Entity>(
    writer: &dyn ICRUDRepository<TChild>,
    enrichment: &Enrichment,
    parent: &mut T,
) -> Result<()> {
    let schema = writer.schema();
    let mut related = crate::create_enrichment_strategy::children::<T, TChild>(enrichment, parent, schema)?;
    if enrichment.r#type == crate::EnrichmentPropertyType::Dictionary {
        let key_name = enrichment.map_key()?;
        related.sort_by(|left, right| dict_key(left, key_name).cmp(&dict_key(right, key_name)));
    }
    let key = parent.cell(&enrichment.source_property);
    for child in &mut related {
        if let Some(key) = &key {
            set(child, &enrichment.related_key, key.clone())?;
        }
        writer.create(child.clone()).await?;
    }
    Ok(())
}

pub(crate) async fn create_links<T: Entity, TLink: Entity>(
    writer: &dyn ICRUDRepository<TLink>,
    enrichment: &Enrichment,
    parent: &T,
) -> Result<()> {
    let association = enrichment
        .association
        .as_ref()
        .ok_or_else(|| DatasourceError::message("Missing association"))?;
    let parent_key = required(
        parent,
        &enrichment.source_property,
        &enrichment.destination_property,
    )?;
    for id in related_ids(parent, enrichment)? {
        let mut row = TLink::default();
        set(&mut row, &association.parent, parent_key.clone())?;
        set(&mut row, &association.related, id)?;
        writer.create(row).await?;
    }
    Ok(())
}

fn dict_key<TChild: Entity>(child: &TChild, key_name: &str) -> String {
    child
        .cell(key_name)
        .map(|value| value.wire_text())
        .unwrap_or_default()
}