junobuild_collections/
store.rs

1use crate::assert::rules::{
2    assert_memory, assert_mutable_permissions, assert_storage_reserved_collection,
3    assert_system_collection_delete_permission, assert_system_collection_set_permission,
4    assert_write_version,
5};
6use crate::constants::core::SYS_COLLECTION_PREFIX;
7use crate::types::core::CollectionKey;
8use crate::types::interface::{DelRule, ListRulesParams, ListRulesResults, SetRule};
9use crate::types::rules::{Rule, Rules};
10
11// ---------------------------------------------------------
12// Rules
13// ---------------------------------------------------------
14
15pub fn filter_rules(rules: &Rules) -> Vec<(CollectionKey, Rule)> {
16    rules
17        .clone()
18        .into_iter()
19        .filter(|(path, _rules)| path.starts_with(|c| c != SYS_COLLECTION_PREFIX))
20        .collect()
21}
22
23pub fn set_rule(
24    collection: CollectionKey,
25    user_rule: SetRule,
26    storage_checks: bool,
27    rules: &mut Rules,
28) -> Result<Rule, String> {
29    let current_rule = rules.get(&collection);
30
31    assert_write_version(current_rule, &user_rule.version)?;
32
33    assert_system_collection_set_permission(&collection, current_rule, &user_rule)?;
34
35    if storage_checks {
36        assert_storage_reserved_collection(&collection, rules)?;
37    }
38
39    assert_memory(current_rule, &user_rule.memory)?;
40    assert_mutable_permissions(current_rule, &user_rule)?;
41
42    let rule: Rule = Rule::prepare(&collection, &current_rule, &user_rule)?;
43
44    rules.insert(collection, rule.clone());
45
46    Ok(rule)
47}
48
49pub fn del_rule(
50    collection: CollectionKey,
51    user_rule: DelRule,
52    rules: &mut Rules,
53) -> Result<(), String> {
54    let current_rule = rules.get(&collection);
55
56    assert_write_version(current_rule, &user_rule.version)?;
57
58    assert_system_collection_delete_permission(&collection)?;
59
60    rules.remove(&collection);
61
62    Ok(())
63}
64
65pub fn list_rules(params: &ListRulesParams, rules: &Rules) -> ListRulesResults {
66    let include_system = params
67        .matcher
68        .as_ref()
69        .map(|m| m.include_system)
70        .unwrap_or(false);
71
72    if include_system {
73        let items_length = rules.len();
74
75        return ListRulesResults {
76            items: rules
77                .iter()
78                .map(|(key, rule)| (key.clone(), rule.clone()))
79                .collect(),
80            items_length,
81            matches_length: items_length,
82        };
83    }
84
85    let items = filter_rules(rules);
86
87    let items_length = items.len();
88
89    ListRulesResults {
90        items,
91        items_length,
92        matches_length: items_length,
93    }
94}