stelae 0.6.4

A collection of tools in Rust and Python for preserving, authenticating, and accessing laws in perpetuity.
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

//! Database related module.
use async_trait::async_trait;
use sqlx::Transaction;
use std::str::FromStr as _;
use std::time;

use std::thread::available_parallelism;

use sqlx::any::{self, AnyPoolOptions};
use sqlx::AnyPool;
use sqlx::ConnectOptions as _;
use tracing::{instrument, log};

/// Database initialization.
pub mod init;
/// Models for the database.
pub mod models;

#[async_trait]
/// Generic Database
pub trait Db {
    /// Connects to a database.
    ///
    /// # Errors
    /// Errors if connection to database fails.
    async fn connect(url: &str) -> anyhow::Result<DatabaseConnection>;
}

#[async_trait]
/// Generic transaction
pub trait Tx {
    /// Begin a transaction.
    async fn begin(pool: AnyPool) -> anyhow::Result<DatabaseTransaction>;
    /// Commit a transaction.
    async fn commit(self) -> anyhow::Result<()>;
    /// Rollback a transaction.
    async fn rollback(self) -> anyhow::Result<()>;
}

/// Type of database connection.
#[derive(Debug, Clone)]
pub enum DatabaseKind {
    /// Sqlite database.
    Sqlite,
}

/// Database connection.
#[derive(Debug, Clone)]
pub struct DatabaseConnection {
    /// Database connection pool.
    pub pool: AnyPool,
    /// Type of database connection.
    pub kind: DatabaseKind,
}

/// Database transaction.
pub struct DatabaseTransaction {
    /// Database transaction.
    pub tx: Transaction<'static, sqlx::Any>,
}

#[async_trait]
impl Db for DatabaseConnection {
    /// Connects to a database.
    ///
    /// # Errors
    /// Errors if connection to database fails.
    #[instrument(level = "trace")]
    async fn connect(db_url: &str) -> anyhow::Result<Self> {
        any::install_default_drivers();
        let num_cpus = match available_parallelism() {
            Ok(cpus) => u32::try_from(cpus.get())?,
            Err(_) => 4,
        };
        let options = any::AnyConnectOptions::from_str(db_url)?
            .log_slow_statements(log::LevelFilter::Warn, time::Duration::from_secs(1));
        let pool = AnyPoolOptions::new()
            .max_connections(2 * num_cpus)
            .connect_with(options)
            .await?;
        let connection = match db_url {
            url if url.starts_with("sqlite:///") => Self {
                pool,
                kind: DatabaseKind::Sqlite,
            },
            _ => anyhow::bail!("Unsupported database URL: {}", db_url),
        };
        // Set journal mode to WAL. This way we support concurrent reads/writes without
        // locking the database.
        sqlx::query("PRAGMA journal_mode=WAL;")
            .execute(&connection.pool)
            .await?;

        Ok(connection)
    }
}

#[async_trait]
impl Tx for DatabaseTransaction {
    /// Begin a transaction.
    async fn begin(pool: AnyPool) -> anyhow::Result<Self> {
        let tx = pool.begin().await?;
        Ok(Self { tx })
    }
    /// Commit a transaction.
    async fn commit(self) -> anyhow::Result<()> {
        self.tx.commit().await?;
        Ok(())
    }

    /// Rollback a transaction.
    async fn rollback(self) -> anyhow::Result<()> {
        self.tx.rollback().await?;
        Ok(())
    }
}