tablo-core 0.9.0

The core toolkit types for Tablo, a server-rendered admin toolkit on Topcoat and Toasty.
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

//! The builders, the [`Column`] impl and the sealed internals both relation columns share.

use super::*;

/// The builders and the [`Column`] impl both relation columns share.
macro_rules! relation_column {
    ($ty:ident) => {
        impl<M> $ty<M> {
            /// Replace the label the field's name gives it, and name the column after the label,
            /// as a [`ComputedColumn`](crate::ComputedColumn) is: two columns over one relation
            /// need two labels.
            pub fn label(mut self, label: impl Into<crate::Text>) -> Self {
                self.relation.relabel(label.into());
                self
            }

            /// Declare this column's width.
            pub fn width(mut self, width: ColumnWidth) -> Self {
                self.relation.width = width;
                self
            }

            toggle_builders!(relation.toggle);
        }

        impl<M> Column<M> for $ty<M>
        where
            M: toasty::schema::Model + Send + Sync + 'static,
        {
            fn name(&self) -> &str {
                &self.relation.name
            }

            fn label(&self) -> crate::Text {
                self.relation.label()
            }

            fn text(&self, cx: &Cx, row: &M) -> String {
                self.relation.text(self.loaded_text(cx, row))
            }

            fn column_width(&self) -> ColumnWidth {
                self.relation.width
            }

            fn toggle(&self) -> ColumnToggle {
                self.relation.toggle
            }

            fn includes(&self) -> Includes<M> {
                self.relation.includes.clone()
            }

            fn reads(&self) -> Option<crate::lens::Reads<M>> {
                Some(self.relation.reads.clone())
            }

            fn internals(&self) -> &dyn crate::column::ColumnInternals<M> {
                self
            }
        }

        impl<M> crate::column::ColumnInternals<M> for $ty<M>
        where
            M: toasty::schema::Model + Send + Sync + 'static,
        {
            fn restrict<'a>(
                &'a self,
                cx: &'a Cx,
                rows: &'a [M],
                ex: &'a mut dyn Executor,
            ) -> BoxFuture<'a, Result<()>> {
                match &self.relation.restrict {
                    Some(restrict) => restrict(cx, rows, ex),
                    None => Box::pin(async { Ok(()) }),
                }
            }

            fn masked(&self, cx: &Cx) -> bool {
                self.relation
                    .masked
                    .as_ref()
                    .is_some_and(|masked| masked(cx))
            }

            fn related(&self) -> Related {
                self.relation.related
            }

            fn misdeclared(&self) -> Option<DeclarationErrorKind> {
                self.relation.misdeclared.clone()
            }

            fn unavailable_source(&self, cx: &Cx) -> Option<&'static str> {
                self.relation
                    .source
                    .filter(|(_, available)| !available(cx))
                    .map(|(source, _)| source)
            }
        }
    };
}

relation_column!(RelationColumn);
relation_column!(CountColumn);