pooly 0.2.1

A protobuf to Postgres adapter + connection pooling middleware.
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
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132

use std::sync::Arc;

use ring::rand::SystemRandom;
use sled::Db;

use crate::data::dao::TypedDao;
use crate::data::db::DbService;
use crate::services::auth::access::AccessControlService;
use crate::services::auth::connection_ids::{LiteralConnectionIdAccessEntryService, WildcardPatternConnectionIdAccessEntryService};
use crate::services::auth::jwt::JwtAuthService;
use crate::services::clock::Clock;
use crate::services::connections::config::ConnectionConfigService;
use crate::services::connections::ConnectionService;
use crate::services::initialize::InitializationService;
use crate::services::queries::QueryService;
use crate::services::secrets::{LocalSecretsService, SecretServiceFactory};
use crate::services::secrets::random::VecGenerator;
use crate::services::secrets::shares::MasterKeySharesService;
use crate::services::updatable::{CacheBackedService, UpdatableService};

pub mod data;
pub mod resources;
pub mod middleware;
pub mod models;
pub mod services;


pub struct AppContext {

    pub access_control_service: Arc<AccessControlService>,
    pub auth_service: Arc<JwtAuthService>,
    pub connection_config_service: Arc<ConnectionConfigService>,
    pub initialization_service: Arc<InitializationService>,
    pub literal_ids_service: Arc<LiteralConnectionIdAccessEntryService>,
    pub secrets_service: Arc<LocalSecretsService>,
    pub shares_service: Arc<MasterKeySharesService>,
    pub query_service: Arc<QueryService>,
    pub pattern_ids_service: Arc<WildcardPatternConnectionIdAccessEntryService>,
    pub vec_generator: Arc<VecGenerator>

}

impl AppContext {

    pub fn new() -> Self {
        Self::with_db(DbService::create())
    }

    fn with_db(db: Arc<Db>) -> Self {
        let vec_generator =
            Arc::new(
                VecGenerator::new(
                    Arc::new(SystemRandom::new())));

        let shares_service = Arc::new(MasterKeySharesService::new());

        let secrets_service: Arc<LocalSecretsService> =
            Arc::new(
                SecretServiceFactory::create(
                    shares_service.clone(), vec_generator.clone()));

        let connection_config_service =
            Arc::new(
                ConnectionConfigService::new(
                    db.clone(), secrets_service.clone()).unwrap()
            );

        let literal_ids_service =
            Arc::new(
                LiteralConnectionIdAccessEntryService::new(
                    db.clone(), secrets_service.clone()).unwrap()
            );

        let pattern_ids_service =
            Arc::new(
                WildcardPatternConnectionIdAccessEntryService::new(
                    db.clone(), secrets_service.clone()).unwrap()
            );

        let access_control_service =
            Arc::new(
                AccessControlService::new(
                    literal_ids_service.clone(),
                    pattern_ids_service.clone())
            );

        let query_service =
            Arc::new(QueryService::new(
                access_control_service.clone(),
                ConnectionService::new(
                    connection_config_service.clone())));

        let auth_service = Arc::new(
            JwtAuthService::new(
                Clock::new(), db.clone(), secrets_service.clone())
                .unwrap()
        );

        let initialization_service = Arc::new(
            InitializationService::new(
                auth_service.clone(),
                shares_service.clone(),
                secrets_service.clone())
        );

        AppContext {
            auth_service,
            access_control_service,
            connection_config_service,
            initialization_service,
            literal_ids_service,
            secrets_service,
            shares_service,
            query_service,
            pattern_ids_service,
            vec_generator
        }
    }
}

pub mod test_context {
    use crate::{AppContext, DbService};

    pub fn with_namespace(namespace: &str) -> AppContext {
        AppContext::with_db(DbService::with_namespace(namespace))
    }

    pub fn clear(namespace: &str) -> Result<(), ()> {
        DbService::clear(namespace)
    }

}