bodega 0.2.0

A small, relatively simple object store implementation and helpers.
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
132
133
134
135
136
137
138
139
140
141
142
143

use std::fmt::Debug;

/// Indicated that the given type can produce a cursor for use in pagination.
pub trait Cursored {
    /// The type of the cursor.
    type CursorType: Debug + Clone + Into<sea_query::SimpleExpr>;

    /// Get the value of the cursor for this instance.
    fn cursor_value(&self) -> Self::CursorType;

    /// Get a reference to the column corresponding to the cursor (i.e. `id`).
    fn cursor_column() -> sea_query::DynIden;
}

/// Indicates the given type can be used for filtering paginated entries for a
/// model manager.
pub trait CursoredFilter {
    /// The type of the cursor.
    type Entity: Cursored;

    /// Get the cursor, if present.
    fn cursor(&self) -> Option<<Self::Entity as Cursored>::CursorType>;

    /// Sets the cursor to the specified value.
    ///
    /// We should prefer to use the builder for the filter to set this, but,
    /// internally, say for walking pages, this is a convenience. For this
    /// reason, this does not support _clearing_ the cursor (setting it to
    /// `None`).
    fn set_cursor(&mut self, cursor: <Self::Entity as Cursored>::CursorType);

    /// Get the page limit.
    fn page_limit(&self) -> usize;

    /// The ordering ASC or DESC.
    ///
    /// This is tied to the cursor because we need to know if we're looking
    /// above or below the given cursor.
    fn cursor_column_order() -> sea_query::Order {
        sea_query::Order::Asc
    }
}

/// A wrapper around the entities returned from the database that also includes
/// information required for requesting the next page of entries.
#[derive(Debug, Clone)]
pub struct Paginated<T: Cursored> {
    pub entries: Vec<T>,
    pub next_cursor: Option<<T as Cursored>::CursorType>,
    pub limit: usize,
}

impl<T: Cursored> Default for Paginated<T> {
    fn default() -> Self {
        Self {
            entries: Vec::default(),
            next_cursor: None,
            limit: 10,
        }
    }
}

impl<T> Paginated<T>
where
    T: Cursored,
{
    pub fn new(entries: Vec<T>, limit: usize) -> Self {
        // this has the effect that we will indicate that an extra page of
        // entries might exist if the number of entries is an exact multiple of
        // the limit.
        let next_cursor = if entries.len() >= limit {
            entries.last().map(|e| e.cursor_value())
        } else {
            None
        };

        Self {
            entries,
            next_cursor,
            limit,
        }
    }

    pub fn has_next(&self) -> bool {
        self.next_cursor.is_some()
    }
}

#[cfg(test)]
mod tests {
    use sea_query::{enum_def, IntoIden};

    use super::*;

    #[enum_def]
    struct Dummy {
        id: i64,
    }

    impl Cursored for Dummy {
        type CursorType = i64;

        fn cursor_value(&self) -> Self::CursorType {
            self.id
        }

        fn cursor_column() -> sea_query::DynIden {
            DummyIden::Id.into_iden()
        }
    }

    fn entries() -> Vec<Dummy> {
        vec![
            Dummy { id: 1 },
            Dummy { id: 2 },
            Dummy { id: 3 },
            Dummy { id: 4 },
            Dummy { id: 5 },
            Dummy { id: 6 },
            Dummy { id: 7 },
            Dummy { id: 8 },
            Dummy { id: 9 },
            Dummy { id: 10 },
        ]
    }

    #[test]
    fn cursor_set_when_enough_entries() {
        let p = Paginated::new(entries(), 10);
        assert_eq!(p.next_cursor, Some(10));

        let p = Paginated::new(entries().into_iter().take(2).collect(), 2);
        assert_eq!(p.next_cursor, Some(2));
    }

    #[test]
    fn cursor_none_when_not_enough_entries() {
        let entries = entries();
        let num = entries.len() + 1;
        let p = Paginated::new(entries, num);
        assert_eq!(p.next_cursor, None);
    }
}