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
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

use crate::hooks::db::{
    invoke_on_delete_doc, invoke_on_delete_filtered_docs, invoke_on_delete_many_docs,
    invoke_on_set_doc, invoke_on_set_many_docs,
};
use crate::user::internal_hooks::{
    on_delete_many_users, on_delete_user, on_set_many_users, on_set_user,
};
use crate::{
    caller, count_collection_docs_store, count_docs_store, delete_doc_store, delete_docs_store,
    delete_filtered_docs_store, get_doc_store, list_docs_store, set_doc_store, DelDoc, Doc,
    DocContext, DocUpsert, SetDoc,
};
use junobuild_collections::types::core::CollectionKey;
use junobuild_shared::ic::UnwrapOrTrap;
use junobuild_shared::types::core::Key;
use junobuild_shared::types::list::{ListParams, ListResults};

pub fn set_doc(collection: CollectionKey, key: Key, doc: SetDoc) -> Doc {
    let caller = caller();

    let doc = set_doc_store(caller, collection, key, doc).unwrap_or_trap();

    on_set_user(&doc).unwrap_or_trap();

    invoke_on_set_doc(&caller, &doc);

    doc.data.after
}

pub fn get_doc(collection: CollectionKey, key: Key) -> Option<Doc> {
    let caller = caller();

    get_doc_store(caller, collection, key).unwrap_or_trap()
}

pub fn del_doc(collection: CollectionKey, key: Key, doc: DelDoc) {
    let caller = caller();

    let deleted_doc = delete_doc_store(caller, collection, key, doc).unwrap_or_trap();

    on_delete_user(&deleted_doc).unwrap_or_trap();

    invoke_on_delete_doc(&caller, &deleted_doc);
}

pub fn list_docs(collection: CollectionKey, filter: ListParams) -> ListResults<Doc> {
    let caller = caller();

    list_docs_store(caller, collection, &filter).unwrap_or_trap()
}

pub fn count_docs(collection: CollectionKey, filter: ListParams) -> usize {
    let caller = caller();

    count_docs_store(caller, collection, &filter).unwrap_or_trap()
}

pub fn get_many_docs(docs: Vec<(CollectionKey, Key)>) -> Vec<(Key, Option<Doc>)> {
    docs.iter()
        .map(|(collection, key)| {
            let doc = get_doc(collection.clone(), key.clone());
            (key.clone(), doc.clone())
        })
        .collect()
}

pub fn set_many_docs(docs: Vec<(CollectionKey, Key, SetDoc)>) -> Vec<(Key, Doc)> {
    let caller = caller();

    let mut hook_payload: Vec<DocContext<DocUpsert>> = Vec::new();
    let mut results: Vec<(Key, Doc)> = Vec::new();

    for (collection, key, doc) in docs {
        let result = set_doc_store(caller, collection, key.clone(), doc).unwrap_or_trap();

        results.push((result.key.clone(), result.data.after.clone()));

        hook_payload.push(result);
    }

    on_set_many_users(&hook_payload).unwrap_or_trap();

    invoke_on_set_many_docs(&caller, &hook_payload);

    results
}

pub fn del_many_docs(docs: Vec<(CollectionKey, Key, DelDoc)>) {
    let caller = caller();

    let mut results: Vec<DocContext<Option<Doc>>> = Vec::new();

    for (collection, key, doc) in docs {
        let deleted_doc = delete_doc_store(caller, collection, key.clone(), doc).unwrap_or_trap();
        results.push(deleted_doc);
    }

    on_delete_many_users(&results).unwrap_or_trap();

    invoke_on_delete_many_docs(&caller, &results);
}

pub fn del_filtered_docs(collection: CollectionKey, filter: ListParams) {
    let caller = caller();

    let results = delete_filtered_docs_store(caller, collection, &filter).unwrap_or_trap();

    invoke_on_delete_filtered_docs(&caller, &results);
}

pub fn del_docs(collection: CollectionKey) {
    delete_docs_store(&collection).unwrap_or_trap();
}

pub fn count_collection_docs(collection: CollectionKey) -> usize {
    count_collection_docs_store(&collection).unwrap_or_trap()
}