architect-api-schema-builder 0.5.2

Auxiliary crate for building architect-api
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

use schemars::schema::RootSchema;
use serde::{Deserialize, Serialize, Serializer};

#[derive(Deserialize)]
pub enum RpcType {
    BidirectionalStreaming,
    ClientStreaming,
    ServerStreaming,
    Unary,
}

#[derive(Serialize, Deserialize)]
pub struct RpcDefinition {
    #[serde(rename = "type")]
    pub rpc_type: RpcType,
    pub route: String,
    pub request_type: RootSchema,
    pub response_type: RootSchema,
}

#[derive(Serialize, Deserialize)]
pub struct SdkGeneratorStruct {
    #[serde(rename = "$schema")]
    pub schema: String,
    pub name: String,
    pub rpcs: Vec<RpcDefinition>,
}

pub struct Config {
    // Pretty print json
    pub pretty: bool,
}

pub fn emit(definition: &SdkGeneratorStruct, config: &Config) -> String {
    if config.pretty {
        serde_json::to_string_pretty(definition).expect("derp")
    } else {
        serde_json::to_string(definition).expect("derp")
    }
}

impl Serialize for RpcType {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        let output = match *self {
            RpcType::BidirectionalStreaming => "duplex_stream",
            RpcType::ClientStreaming => "client_stream",
            RpcType::ServerStreaming => "stream",
            RpcType::Unary => "unary",
        };
        serializer.serialize_str(output)
    }
}