a3s-orm 0.3.0

A type-safe, executor-neutral SQL query builder for Rust
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

use std::collections::HashSet;

use super::{Migration, MigrationBackend, MigrationError, MigrationRunError, PreparedMigration};

#[derive(Clone, Debug, Default, PartialEq, Eq)]
pub struct MigrationReport {
    pub applied: Vec<String>,
}

impl MigrationReport {
    pub fn is_up_to_date(&self) -> bool {
        self.applied.is_empty()
    }
}

pub struct Migrator<B> {
    backend: B,
}

impl<B: MigrationBackend> Migrator<B> {
    pub const fn new(backend: B) -> Self {
        Self { backend }
    }

    pub fn backend(&self) -> &B {
        &self.backend
    }

    pub async fn run(
        &self,
        migrations: impl IntoIterator<Item = Migration>,
    ) -> Result<MigrationReport, MigrationRunError<B::Error>> {
        let migrations = prepare(migrations)?;
        self.backend
            .apply(&migrations)
            .await
            .map_err(MigrationRunError::Backend)
    }
}

fn prepare(
    migrations: impl IntoIterator<Item = Migration>,
) -> Result<Vec<PreparedMigration>, MigrationError> {
    let mut migrations = migrations.into_iter().collect::<Vec<_>>();
    for migration in &migrations {
        validate(migration)?;
    }
    migrations.sort_by(|left, right| left.version().cmp(right.version()));
    let mut versions = HashSet::with_capacity(migrations.len());
    for migration in &migrations {
        if !versions.insert(migration.version().to_owned()) {
            return Err(MigrationError::DuplicateVersion(
                migration.version().to_owned(),
            ));
        }
    }
    Ok(migrations
        .into_iter()
        .map(PreparedMigration::prepare)
        .collect())
}

fn validate(migration: &Migration) -> Result<(), MigrationError> {
    if migration.version().is_empty() {
        return Err(MigrationError::EmptyVersion);
    }
    if !migration
        .version()
        .bytes()
        .all(|byte| byte.is_ascii_alphanumeric() || matches!(byte, b'.' | b'_' | b'-'))
    {
        return Err(MigrationError::InvalidVersion(
            migration.version().to_owned(),
        ));
    }
    if migration.name().trim().is_empty() {
        return Err(MigrationError::EmptyName {
            version: migration.version().to_owned(),
        });
    }
    if migration.up_sql().trim().is_empty() {
        return Err(MigrationError::EmptySql {
            version: migration.version().to_owned(),
        });
    }
    Ok(())
}