wasm-dbms-api 0.7.2

Runtime-agnostic API types and traits for the wasm-dbms DBMS engine.
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

use lazy_regex::{Lazy, Regex, lazy_regex};

use crate::prelude::{Validate, Value};

static PHONE_REGEX: Lazy<Regex> = lazy_regex!(r"^\+?[0-9\s().-]{7,20}$");

/// A validator for phone numbers.
///
/// # Examples of valid phone numbers:
///
/// +1-202-555-0173
/// (202) 555-0173
/// +44 20 7946 0958
/// 202.555.0173
/// 2025550173
///
/// ## Example
///
/// ```rust
/// use wasm_dbms_api::prelude::{PhoneNumberValidator, Validate, Value};
///
/// let validator = PhoneNumberValidator;
/// let valid_phone = Value::Text("+1-202-555-0173".into());
/// let invalid_phone = Value::Text("123-ABC-7890".into());
///
/// assert!(validator.validate(&valid_phone).is_ok());
/// assert!(validator.validate(&invalid_phone).is_err());
/// ```
pub struct PhoneNumberValidator;

impl Validate for PhoneNumberValidator {
    fn validate(&self, value: &Value) -> crate::prelude::DbmsResult<()> {
        let Value::Text(text) = value else {
            return Err(crate::prelude::DbmsError::Validation(
                "PhoneNumberValidator can only be applied to Text values".to_string(),
            ));
        };

        if PHONE_REGEX.is_match(text.as_str()) {
            Ok(())
        } else {
            Err(crate::prelude::DbmsError::Validation(format!(
                "Value '{text}' is not a valid phone number",
            )))
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_phone_number_validator() {
        let validator = PhoneNumberValidator;
        let valid_phones = vec![
            "+1-202-555-0173",
            "(202) 555-0173",
            "+44 20 7946 0958",
            "202.555.0173",
            "2025550173",
            "+91 (22) 1234-5678",
            "+81-3-1234-5678",
            "123-456-7890",
            "+49 30 123456",
            "+33 366 167 7509",
            "+33 3661677509",
        ];

        let invalid_phones = vec![
            "123-ABC-7890",
            "++1-202-555-0173",
            //"202--555--0173",
            "202 555 0173 ext. 5",
            "phone:2025550173",
            "202/555/0173",
            "202_555_0173",
            "++44 20 7946 0958",
        ];
        for phone in valid_phones {
            let value = Value::Text(phone.into());
            assert!(
                validator.validate(&value).is_ok(),
                "Expected '{}' to be valid",
                phone
            );
        }

        for phone in invalid_phones {
            let value = Value::Text(phone.into());
            assert!(
                validator.validate(&value).is_err(),
                "Expected '{}' to be invalid",
                phone
            );
        }

        // non-Text value
        let non_text_value = Value::Int32(1234567890i32.into());
        assert!(
            validator.validate(&non_text_value).is_err(),
            "Expected non-Text value to be invalid"
        );
    }
}