tablo-core 0.10.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

//! What a `has_one` relation's related form needs of the resources it joins, checked at mount.

use crate::{
    RelatedFormFault,
    form::RecordForm,
    resource::{Mounted, Resource},
};

/// What a `has_one` relation's related form needs of a registered resource.
pub(in crate::panel) struct FormFacts {
    /// Whether the resource has a record form.
    has_form: bool,
    /// Every key its form posts.
    keys: Vec<String>,
    soft_deletes: bool,
    /// The first field of its form a related form cannot carry.
    own_keys: Option<String>,
}

impl FormFacts {
    pub(super) fn of<R: Resource>(mounted: &Mounted<R>) -> Self {
        Self {
            has_form: <R::Form as RecordForm>::HAS_FORM,
            keys: mounted
                .form
                .fields()
                .map(|field| field.name().to_string())
                .collect(),
            soft_deletes: mounted.soft_delete.is_some(),
            own_keys: mounted.form.needs_own_keys().map(str::to_string),
        }
    }

    /// Why `child`'s form cannot render inside this owner's, its controls posting under
    /// `{slug}.` and `foreign_key` filled by the owner.
    pub(super) fn related_faults(
        &self,
        child: &Self,
        slug: &str,
        foreign_key: &str,
    ) -> Vec<RelatedFormFault> {
        let mut faults = Vec::new();
        if !self.has_form {
            faults.push(RelatedFormFault::NoOwnerForm);
        }
        if !child.has_form {
            faults.push(RelatedFormFault::NoForm);
        } else if !child.keys.iter().any(|key| key == foreign_key) {
            faults.push(RelatedFormFault::UnboundForeignKey {
                column: foreign_key.to_string(),
            });
        }
        if child.soft_deletes {
            faults.push(RelatedFormFault::SoftDeletes);
        }
        if let Some(field) = &child.own_keys {
            faults.push(RelatedFormFault::OwnKeys {
                field: field.clone(),
            });
        }
        // A key equal to the slug shadows the prefix too: a repeater named so posts its rows
        // under `{slug}.`.
        let prefix = format!("{slug}.");
        faults.extend(
            self.keys
                .iter()
                .filter(|key| *key == slug || key.starts_with(&prefix))
                .map(|key| RelatedFormFault::ShadowedKey { field: key.clone() }),
        );
        faults
    }
}