tailwag_orm 0.1.0

An ORM for building Postgres schemas and data access with a Manager pattern, backed by sqlx.
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

use std::{ops::Deref, sync::Arc};

/// Represents a Database Identifier, for column names and table names.
/// It's just a string under the hood, but forcing calls to use Identifier::new(String),
/// we are able to perform field validation.
#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Debug, Hash)]
pub struct Identifier {
    value: Arc<String>,
}

impl Deref for Identifier {
    type Target = str;

    fn deref(&self) -> &Self::Target {
        // TODO: Once I'm confident that this is impossible (it should b), remove the validate() call  - it adds a string pass on every deref.
        self.validate()
            .unwrap_or_else(|_| panic!("Identifier {} is invalid - this should have been caught on create. If you are seeing this mesage then you have found a bug - please file a bug report", self.value()));
        &self.value
    }
}

impl std::fmt::Display for Identifier {
    fn fmt(
        &self,
        f: &mut std::fmt::Formatter<'_>,
    ) -> std::fmt::Result {
        self.value.fmt(f)
    }
}

impl Identifier {
    fn validate(&self) -> Result<(), String> {
        if Self::is_valid(&self.value) {
            Ok(())
        } else {
            Err(format!(
                "Identifier {} contains invalid characters. [a-zA-Z0-9_.] are only allowed values.",
                &self.value
            ))
        }
    }

    fn is_valid(value: &str) -> bool {
        value
            .chars()
            .all(|c| matches!(c, 'a'..='z' | 'A'..='Z' | '0'..='9' | '_' | '.'))
    }

    pub fn new<S: Into<String>>(value: S) -> Result<Self, String> {
        let identifier = Self {
            value: Arc::new(value.into()),
        };
        match identifier.validate() {
            Ok(()) => Ok(identifier),
            Err(e) => Err(e),
        }
    }

    pub fn new_unchecked<S: Into<String>>(value: S) -> Self {
        match Self::new(value) {
            Ok(ident) => ident,
            Err(e) => panic!("Identifier::new_unchecked() failed: {}", &e),
        }
    }

    pub fn value(&self) -> &str {
        &self.value
    }
}