mycelium-api 8.3.1-rc.1

Provide API ports to the mycelium project.
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
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

//! Converte os tipos default_response (FetchResponseKind, GetOrCreateResponseKind, etc.)
//! para o formato de resultado RPC, espelhando o comportamento da API REST:
//! Found/Created/Updated → result = corpo; NotFound/Deleted → result = null;
//! NotCreated/NotUpdated/NotDeleted → erro JSON-RPC.

use super::types::{self, JsonRpcError};
use mycelium_base::{
    dtos::PaginatedRecord,
    entities::{
        CreateResponseKind, DeletionResponseKind, FetchManyResponseKind,
        FetchResponseKind, GetOrCreateResponseKind, UpdatingResponseKind,
    },
};
use serde::Serialize;

/// Converte `FetchResponseKind` em resultado RPC: Found(t) → Ok(json(t)), NotFound → Ok(null).
pub fn fetch_response_kind_to_result<T: Serialize, U>(
    response: FetchResponseKind<T, U>,
) -> Result<serde_json::Value, JsonRpcError> {
    match response {
        FetchResponseKind::Found(res) => {
            serde_json::to_value(res).map_err(|e| JsonRpcError {
                code: types::codes::INTERNAL_ERROR,
                message: e.to_string(),
                data: None,
            })
        }
        FetchResponseKind::NotFound(_) => Ok(serde_json::Value::Null),
    }
}

/// Converte `FetchManyResponseKind` em resultado RPC: Found/FoundPaginated → Ok(json), NotFound → Ok(null).
pub fn fetch_many_response_kind_to_result<T: Serialize>(
    response: FetchManyResponseKind<T>,
) -> Result<serde_json::Value, JsonRpcError> {
    match response {
        FetchManyResponseKind::Found(res) => {
            serde_json::to_value(res).map_err(|e| JsonRpcError {
                code: types::codes::INTERNAL_ERROR,
                message: e.to_string(),
                data: None,
            })
        }
        FetchManyResponseKind::FoundPaginated {
            count,
            skip,
            size,
            records,
        } => serde_json::to_value(PaginatedRecord {
            count,
            skip,
            size,
            records,
        })
        .map_err(|e| JsonRpcError {
            code: types::codes::INTERNAL_ERROR,
            message: e.to_string(),
            data: None,
        }),
        FetchManyResponseKind::NotFound => Ok(serde_json::Value::Null),
    }
}

/// Converte `CreateResponseKind` em resultado RPC: Created(t) → Ok(json(t)), NotCreated → Err.
pub fn create_response_kind_to_result<T: Serialize>(
    response: CreateResponseKind<T>,
) -> Result<serde_json::Value, JsonRpcError> {
    match response {
        CreateResponseKind::Created(res) => {
            serde_json::to_value(res).map_err(|e| JsonRpcError {
                code: types::codes::INTERNAL_ERROR,
                message: e.to_string(),
                data: None,
            })
        }
        CreateResponseKind::NotCreated(_, msg) => Err(JsonRpcError {
            code: types::codes::INVALID_PARAMS,
            message: msg,
            data: None,
        }),
    }
}

/// Converte `GetOrCreateResponseKind` em resultado RPC: Created(t) → Ok(json(t)), NotCreated → Err.
pub fn get_or_create_response_kind_to_result<T: Serialize>(
    response: GetOrCreateResponseKind<T>,
) -> Result<serde_json::Value, JsonRpcError> {
    match response {
        GetOrCreateResponseKind::Created(res) => serde_json::to_value(res)
            .map_err(|e| JsonRpcError {
                code: types::codes::INTERNAL_ERROR,
                message: e.to_string(),
                data: None,
            }),
        GetOrCreateResponseKind::NotCreated(_, msg) => Err(JsonRpcError {
            code: types::codes::INVALID_PARAMS,
            message: msg,
            data: None,
        }),
    }
}

/// Converte `UpdatingResponseKind` em resultado RPC: Updated(t) → Ok(json(t)), NotUpdated → Err.
pub fn updating_response_kind_to_result<T: Serialize>(
    response: UpdatingResponseKind<T>,
) -> Result<serde_json::Value, JsonRpcError> {
    match response {
        UpdatingResponseKind::Updated(res) => serde_json::to_value(res)
            .map_err(|e| JsonRpcError {
                code: types::codes::INTERNAL_ERROR,
                message: e.to_string(),
                data: None,
            }),
        UpdatingResponseKind::NotUpdated(_, msg) => Err(JsonRpcError {
            code: types::codes::INVALID_PARAMS,
            message: msg,
            data: None,
        }),
    }
}

/// Converte `DeletionResponseKind` em resultado RPC: Deleted → Ok(null), NotDeleted → Err.
pub fn delete_response_kind_to_result<T: Serialize>(
    response: DeletionResponseKind<T>,
) -> Result<serde_json::Value, JsonRpcError> {
    match response {
        DeletionResponseKind::Deleted => Ok(serde_json::Value::Null),
        DeletionResponseKind::NotDeleted(_, msg) => Err(JsonRpcError {
            code: types::codes::INVALID_PARAMS,
            message: msg,
            data: None,
        }),
    }
}