junobuild-satellite 0.6.0

Core implementation of a Juno Satellite.
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

use crate::assets::storage::store::assert_assets_collection_empty_store;
use crate::db::store::{delete_collection_store, init_collection_store};
use crate::memory::state::STATE;
use junobuild_collections::store::{del_rule, filter_rules, list_rules, set_rule};
use junobuild_collections::types::core::CollectionKey;
use junobuild_collections::types::interface::{
    DelRule, ListRulesParams, ListRulesResults, SetRule,
};
use junobuild_collections::types::rules::{Memory, Rule};

// ---------------------------------------------------------
// Rules
// ---------------------------------------------------------

pub fn get_rule_db(collection: &CollectionKey) -> Option<Rule> {
    STATE.with(|state| state.borrow().heap.db.rules.get(collection).cloned())
}

pub fn get_rule_storage(collection: &CollectionKey) -> Option<Rule> {
    STATE.with(|state| state.borrow().heap.storage.rules.get(collection).cloned())
}

pub fn get_non_system_rules_db() -> Vec<(CollectionKey, Rule)> {
    STATE.with(|state| filter_rules(&state.borrow().heap.db.rules))
}

pub fn get_non_system_rules_storage() -> Vec<(CollectionKey, Rule)> {
    STATE.with(|state| filter_rules(&state.borrow().heap.storage.rules))
}

pub fn list_rules_db(filter: &ListRulesParams) -> ListRulesResults {
    STATE.with(|state| list_rules(filter, &state.borrow().heap.db.rules))
}

pub fn list_rules_storage(filter: &ListRulesParams) -> ListRulesResults {
    STATE.with(|state| list_rules(filter, &state.borrow().heap.storage.rules))
}

pub fn set_rule_db(collection: CollectionKey, rule: SetRule) -> Result<Rule, String> {
    let rule = STATE.with(|state| {
        set_rule(
            collection.clone(),
            rule.clone(),
            false,
            &mut state.borrow_mut().heap.db.rules,
        )
    })?;

    // If the collection does not exist yet we initialize it
    init_collection_store(&collection, &rule.memory.clone().unwrap_or(Memory::Stable));

    Ok(rule)
}

pub fn set_rule_storage(collection: CollectionKey, rule: SetRule) -> Result<Rule, String> {
    STATE.with(|state| {
        set_rule(
            collection,
            rule,
            true,
            &mut state.borrow_mut().heap.storage.rules,
        )
    })
}

pub fn del_rule_db(collection: CollectionKey, rule: DelRule) -> Result<(), String> {
    // We delete the empty collection first.
    delete_collection_store(&collection)?;

    STATE.with(|state| {
        del_rule(
            collection.clone(),
            rule,
            &mut state.borrow_mut().heap.db.rules,
        )
    })?;

    Ok(())
}

pub fn del_rule_storage(collection: CollectionKey, rule: DelRule) -> Result<(), String> {
    // Only unused rule can be removed
    assert_assets_collection_empty_store(&collection)?;

    STATE.with(|state| del_rule(collection, rule, &mut state.borrow_mut().heap.storage.rules))
}