fabrique 0.3.1

SQL-first, type-safe, ergonomic database toolkit 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
88
89
90
91
92

use fabrique::prelude::*;
use fake::Dummy;
use uuid::Uuid;

#[derive(Debug, Default, Factory, PartialEq, Model)]
pub struct Order {
    pub id: Uuid,
    #[fabrique(belongs_to = "User")]
    pub user_id: Uuid,
    #[fabrique(as = "String")]
    pub status: Status,
}

#[derive(Clone, Debug, Default, Dummy, PartialEq)]
pub enum Status {
    #[default]
    Pending,
    Paid,
    Cancelled,
}

impl From<Status> for String {
    fn from(value: Status) -> Self {
        match value {
            Status::Cancelled => "cancelled".to_owned(),
            Status::Paid => "paid".to_owned(),
            Status::Pending => "pending".to_owned(),
        }
    }
}

impl TryFrom<String> for Status {
    type Error = String;

    fn try_from(value: String) -> Result<Self, Self::Error> {
        match value.to_lowercase().as_str() {
            "cancelled" => Ok(Status::Cancelled),
            "paid" => Ok(Status::Paid),
            "pending" => Ok(Status::Pending),
            other => Err(format!("unknown status: {other}")),
        }
    }
}

#[derive(Debug, Default, Factory, PartialEq, Model)]
pub struct User {
    pub id: Uuid,
    pub name: String,
    pub email: String,
}

#[fabrique::test]
async fn test_where_accepts_a_rust_type<DB: Dialect>(pool: Pool<DB>) {
    // Arrange a fixture
    Order::factory()
        .status(Status::Pending)
        .create(&pool)
        .await
        .unwrap();

    // Act the call to the query
    let result = Order::query()
        .r#where(Order::STATUS, "=", Status::Pending)
        .get(&pool)
        .await;

    // Assert the result
    assert!(result.is_ok());
    assert_eq!(result.iter().len(), 1);
}

#[fabrique::test]
async fn test_set_accepts_a_rust_type<DB: Dialect>(pool: Pool<DB>) {
    // Arrange a fixture
    let order = Order::factory().create(&pool).await.unwrap();

    // Act the call to the query
    Order::update()
        .set(Order::STATUS, Status::Paid)
        .r#where(Order::ID, "=", order.id)
        .execute(&pool)
        .await
        .unwrap();

    // Assert the result
    let updated = Order::query()
        .r#where(Order::ID, "=", order.id)
        .first_or_fail(&pool)
        .await
        .unwrap();
    assert_eq!(updated.status, Status::Paid);
}