loco-rs 0.4.0

The one-person framework 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
93
94
95
96
97
98
99
100
101
102

use sea_orm::{prelude::*, Condition, DatabaseConnection, EntityTrait, QueryFilter};

use crate::{
    model::query::{PaginatedInfoResponse, PaginatedResponse, PaginationQuery},
    Result as LocoResult,
};

/// Paginate function for fetching paginated data from the database.
///
/// # Examples
///
/// Without conditions
/// ```
/// use loco_rs::tests_cfg::db::*;
/// use sea_orm::{EntityTrait, QueryFilter, QuerySelect, QueryTrait};
/// use loco_rs::prelude::*;
///
/// async fn example() {
///     let db = dummy_connection().await;
///     let pagination_query = model::query::PaginationQuery {
///         page_size: 100,
///         page: 1,
///     };
///     
///     let res = model::query::exec::paginate(&db, test_db::Entity::find(), None, &pagination_query).await;
/// }
/// ````
/// With conditions
/// ```
/// use loco_rs::tests_cfg::db::*;
/// use sea_orm::{EntityTrait, QueryFilter, QuerySelect, QueryTrait};
/// use loco_rs::prelude::*;
///
/// async fn example() {
///     let db = dummy_connection().await;
///     let pagination_query = model::query::PaginationQuery {
///         page_size: 100,
///         page: 1,
///     };
///     let condition = model::query::dsl::condition().contains(test_db::Column::Name, "loco").build();
///     let res = model::query::exec::paginate(&db, test_db::Entity::find(), Some(condition), &pagination_query).await;
/// }
/// ````
/// With Order By
/// ```
/// use loco_rs::tests_cfg::db::*;
/// use sea_orm::{EntityTrait, QueryFilter, QuerySelect, QueryTrait, sea_query::Order, QueryOrder};
/// use loco_rs::prelude::*;
///
/// async fn example() {
///     let db = dummy_connection().await;
///     let pagination_query = model::query::PaginationQuery {
///         page_size: 100,
///         page: 1,
///     };
///     
///     let condition = model::query::dsl::condition().contains(test_db::Column::Name, "loco").build();
///     let entity = test_db::Entity::find().order_by(test_db::Column::Name, Order::Desc);
///     let res = model::query::exec::paginate(&db, entity, Some(condition), &pagination_query).await;
/// }
/// ````
///
/// # Errors
///
/// Returns a `LocoResult` indicating any errors that occur
/// during pagination.
pub async fn paginate<E>(
    db: &DatabaseConnection,
    entity: Select<E>,
    condition: Option<Condition>,
    pagination_query: &PaginationQuery,
) -> LocoResult<PaginatedResponse<E::Model>>
where
    E: EntityTrait,
    <E as EntityTrait>::Model: Sync,
{
    let page = if pagination_query.page <= 1 {
        0
    } else {
        pagination_query.page - 1
    };
    let entity = if let Some(condition) = condition {
        entity.filter(condition)
    } else {
        entity
    };

    let query = entity.paginate(db, pagination_query.page_size);
    let page_count = query.num_pages().await?;
    let rows: Vec<<E as EntityTrait>::Model> = query.fetch_page(page).await?;

    let paginated_response = PaginatedResponse {
        rows,
        info: PaginatedInfoResponse {
            page: pagination_query.page,
            page_size: pagination_query.page_size,
            total_pages: page_count,
        },
    };

    Ok(paginated_response)
}