portaldi 0.6.3

An ergonomic lightweight compile-time depencency injection library.
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 async_trait::async_trait;
use portaldi::*;

#[tokio::main]
async fn main() {
    use app::*;

    let created = HogeCreateCmd::di().execute("test").await;

    let found = HogeQuery::di().load(created.id).await;

    assert_eq!(created, found)
}

mod app {
    use super::*;
    use super::{domain::*, repo::*};

    #[derive(DIPortal)]
    pub struct HogeCreateCmd {
        hoge_service: DI<HogeService>,
        hoge_repo: DI<dyn HogeRepository>,
    }

    impl HogeCreateCmd {
        pub async fn execute(&self, name: &str) -> Hoge {
            let new_hoge = self.hoge_service.create(name).await;
            self.hoge_repo.save(&new_hoge).await;
            new_hoge
        }
    }

    #[derive(DIPortal)]
    pub struct HogeQuery {
        hoge_repo: DI<dyn HogeRepository>,
    }

    impl HogeQuery {
        pub async fn load(&self, id: u8) -> Hoge {
            self.hoge_repo
                .get(id)
                .await
                .expect(format!("hoge not found for {}", id).as_str())
        }
    }
}
mod domain {
    use super::*;

    #[derive(PartialEq, Debug, Clone)]
    pub struct Hoge {
        pub id: u8,
        pub name: String,
    }

    #[derive(DIPortal)]
    pub struct HogeService {}

    impl HogeService {
        pub async fn create(&self, name: &str) -> Hoge {
            Hoge {
                id: 1,
                name: name.into(),
            }
        }
    }

    #[async_trait]
    pub trait HogeRepository: DITarget {
        async fn save(&self, hoge: &Hoge) -> ();
        async fn get(&self, id: u8) -> Option<Hoge>;
    }
}
mod repo {
    use super::*;
    use crate::domain::*;
    use std::{collections::HashMap, sync::Mutex};

    #[derive(Default)]
    struct InMemoryHogeRepository {
        datas: Mutex<HashMap<u8, Hoge>>,
    }

    #[portaldi::provider(HogeRepository)]
    impl DIPortal for InMemoryHogeRepository {
        fn create_for_di(_container: &DIContainer) -> Self {
            InMemoryHogeRepository::default()
        }
    }

    #[async_trait]
    impl HogeRepository for InMemoryHogeRepository {
        async fn save(&self, hoge: &Hoge) -> () {
            println!("save in repository");
            self.datas.lock().unwrap().insert(hoge.id, hoge.clone());
        }
        async fn get(&self, id: u8) -> Option<Hoge> {
            println!("get from repository");
            self.datas.lock().unwrap().get(&id).map(|v| v.clone())
        }
    }
}