kali 0.1.0

A query builder and orm-ish crate built on 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
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
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131

use kali::{column::ColumnExpr, entity::Entity};
use sqlx::SqlitePool;

#[kali::entity("users")]
#[derive(Debug, sqlx::FromRow)]
struct User {
    id: i64,
    username: String,

    #[relation(referenced_by = user)]
    profile: kali::reference::Reference<UserProfile>,

    #[relation(referenced_by = user)]
    posts: kali::collection::Collection<Post>,
}

#[kali::entity("user_profiles")]
#[derive(Debug, sqlx::FromRow)]
struct UserProfile {
    #[primary_key]
    user_id: i64,
    bio: String,

    #[relation(foreign_key = user_id)]
    user: kali::reference::Reference<User>,
}

#[kali::entity("posts")]
#[derive(Debug, sqlx::FromRow)]
struct Post {
    id: i64,
    content: String,
    user_id: i64,
    title: String,

    #[relation(foreign_key = user_id, references = id)]
    user: kali::reference::Reference<User>,
}

#[sqlx::test(migrations = "tests/migrations", fixtures("users", "profiles"))]
async fn test_user_profile_relation(pool: SqlitePool) -> anyhow::Result<()> {
    // Test fetching a user and then getting their profile
    let user = User::fetch_one(&pool, 1).await?;
    assert_eq!(user.id, 1);
    assert_eq!(user.username, "holden");

    let profile = user.profile().load(&pool).await?;
    assert_eq!(profile.user_id, 1);
    assert_eq!(profile.bio, "can't park there bud");

    Ok(())
}

#[sqlx::test(migrations = "tests/migrations", fixtures("users", "profiles"))]
async fn test_profile_user_relation(pool: SqlitePool) -> anyhow::Result<()> {
    // Test fetching a profile and then getting the related user
    let profile = UserProfile::fetch_one(&pool, 1).await?;
    assert_eq!(profile.user_id, 1);
    assert_eq!(profile.bio, "can't park there bud");

    let user = profile.user().load(&pool).await?;
    assert_eq!(user.id, 1);
    assert_eq!(user.username, "holden");

    Ok(())
}

#[sqlx::test(
    migrations = "tests/migrations",
    fixtures("users", "profiles", "posts")
)]
async fn test_user_posts_collection(pool: SqlitePool) -> anyhow::Result<()> {
    // Test fetching a user and then getting their posts
    let user = User::fetch_one(&pool, 7).await?;
    assert_eq!(user.id, 7);
    assert_eq!(user.username, "naomi");

    let posts = user.posts().load_all(&pool).await?;
    assert_eq!(posts.len(), 3); // User 7 has 3 posts

    // Check content of one of the posts
    let post = posts.iter().find(|p| p.id == 5).unwrap();
    assert_eq!(post.title, "Foundation");
    assert!(post.content.contains("Asimov"));

    Ok(())
}

#[sqlx::test(
    migrations = "tests/migrations",
    fixtures("users", "profiles", "posts")
)]
async fn test_post_user_relation(pool: SqlitePool) -> anyhow::Result<()> {
    // Test fetching a post and then getting the related user
    let post: Post = Post::query()
        .filter(Post::Id.eq(1))
        .fetch_one(&pool)
        .await?;

    assert_eq!(post.id, 1);

    let user = post.user().load(&pool).await?;
    assert_eq!(user.id, 1);
    assert_eq!(user.username, "holden");

    Ok(())
}

#[sqlx::test(
    migrations = "tests/migrations",
    fixtures("users", "profiles", "posts")
)]
async fn test_query_with_relation_filter(pool: SqlitePool) -> anyhow::Result<()> {
    // Get a user
    let user = User::fetch_one(&pool, 7).await?;

    // Use the relation's query method to get filtered posts
    let posts: Vec<Post> = user
        .posts()
        .query()
        .filter(Post::Title.eq("Foundation"))
        .fetch_all(&pool)
        .await?;

    assert_eq!(posts.len(), 1);
    assert_eq!(posts[0].id, 5);
    assert_eq!(posts[0].title, "Foundation");
    assert!(posts[0].content.contains("Asimov"));

    Ok(())
}