db-pool 0.6.0

A thread-safe database pool for running database-tied integration tests in parallel
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

use std::ops::DerefMut;

use async_trait::async_trait;
use deadpool::managed::{
    BuildError, Manager as DeadpoolManager, Object, Pool, PoolBuilder,
    PoolError as DeadpoolPoolError,
};
use diesel::{ConnectionError, result::Error as DieselError};
use diesel_async::{
    AsyncConnection,
    pooled_connection::{AsyncDieselConnectionManager, PoolError as DieselPoolError},
};

use crate::r#async::backend::error::Error as BackendError;

use super::r#trait::DieselPoolAssociation;

type DieselManager<Connection> = AsyncDieselConnectionManager<Connection>;

/// [`Diesel deadpool`](https://docs.rs/diesel-async/0.5.2/diesel_async/pooled_connection/deadpool/index.html) association
pub struct DieselDeadpool;

#[async_trait]
impl<Connection> DieselPoolAssociation<Connection> for DieselDeadpool
where
    Connection: AsyncConnection + 'static,
    DieselManager<Connection>: DeadpoolManager,
    for<'pool> Object<DieselManager<Connection>>: DerefMut<Target = Connection>,
    DeadpoolPoolError<<DieselManager<Connection> as DeadpoolManager>::Error>:
        Into<DeadpoolPoolError<DieselPoolError>>,
{
    type PooledConnection<'pool> = Object<DieselManager<Connection>>;

    type Builder = PoolBuilder<DieselManager<Connection>>;
    type Pool = Pool<DieselManager<Connection>>;

    type BuildError = BuildError;
    type PoolError = DeadpoolPoolError<DieselPoolError>;

    async fn build_pool(
        builder: Self::Builder,
        _: DieselManager<Connection>,
    ) -> Result<Self::Pool, Self::BuildError> {
        builder.build()
    }

    async fn get_connection<'pool>(
        pool: &'pool Self::Pool,
    ) -> Result<Self::PooledConnection<'pool>, Self::PoolError> {
        pool.get().await.map_err(Into::into)
    }
}

impl From<BuildError>
    for BackendError<BuildError, DeadpoolPoolError<DieselPoolError>, ConnectionError, DieselError>
{
    fn from(value: BuildError) -> Self {
        Self::Build(value)
    }
}

impl From<DeadpoolPoolError<DieselPoolError>>
    for BackendError<BuildError, DeadpoolPoolError<DieselPoolError>, ConnectionError, DieselError>
{
    fn from(value: DeadpoolPoolError<DieselPoolError>) -> Self {
        Self::Pool(value)
    }
}