nyx-agent-types 0.1.0

Implementation-detail serde and TypeScript wire types shared by nyx-agent crates.
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
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161

//! Project-scoped outbound integrations.
//!
//! These types are shared by the daemon API and the embedded SPA. The
//! public record deliberately exposes only a target summary, not raw
//! webhook URLs or SMTP passwords.

use serde::{Deserialize, Serialize};
use std::str::FromStr;
use ts_rs::TS;

#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, TS)]
#[serde(rename_all = "snake_case")]
pub enum ProjectIntegrationKind {
    Webhook,
    Slack,
    Smtp,
}

impl ProjectIntegrationKind {
    pub fn as_str(self) -> &'static str {
        match self {
            Self::Webhook => "webhook",
            Self::Slack => "slack",
            Self::Smtp => "smtp",
        }
    }

    fn parse(raw: &str) -> Option<Self> {
        match raw {
            "webhook" => Some(Self::Webhook),
            "slack" => Some(Self::Slack),
            "smtp" => Some(Self::Smtp),
            _ => None,
        }
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, TS)]
#[serde(rename_all = "snake_case")]
pub enum ProjectIntegrationEvent {
    RunFinished,
    FindingVerified,
}

impl ProjectIntegrationEvent {
    pub fn as_str(self) -> &'static str {
        match self {
            Self::RunFinished => "run_finished",
            Self::FindingVerified => "finding_verified",
        }
    }
}

impl FromStr for ProjectIntegrationKind {
    type Err = ();

    fn from_str(raw: &str) -> Result<Self, Self::Err> {
        Self::parse(raw).ok_or(())
    }
}

#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Serialize, Deserialize, TS)]
#[serde(rename_all = "snake_case")]
pub enum SmtpSecurity {
    #[default]
    StartTls,
    None,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, TS)]
pub struct ProjectIntegrationRecord {
    pub id: String,
    pub project_id: String,
    pub kind: ProjectIntegrationKind,
    pub name: String,
    pub enabled: bool,
    pub events: Vec<ProjectIntegrationEvent>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    #[ts(optional)]
    pub min_severity: Option<String>,
    pub target: String,
    #[ts(type = "number")]
    pub created_at: i64,
    #[ts(type = "number")]
    pub updated_at: i64,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    #[ts(optional, type = "number")]
    pub last_delivery_at: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    #[ts(optional)]
    pub last_delivery_status: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    #[ts(optional)]
    pub last_delivery_error: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, TS)]
#[serde(tag = "kind", rename_all = "snake_case")]
pub enum ProjectIntegrationConfigInput {
    Webhook {
        url: String,
        #[serde(default, skip_serializing_if = "Option::is_none")]
        #[ts(optional)]
        signing_secret: Option<String>,
    },
    Slack {
        webhook_url: String,
    },
    Smtp {
        host: String,
        #[ts(type = "number")]
        port: u16,
        #[serde(default)]
        security: SmtpSecurity,
        #[serde(default, skip_serializing_if = "Option::is_none")]
        #[ts(optional)]
        username: Option<String>,
        #[serde(default, skip_serializing_if = "Option::is_none")]
        #[ts(optional)]
        password: Option<String>,
        from: String,
        recipients: Vec<String>,
    },
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, TS)]
pub struct CreateProjectIntegrationRequest {
    pub name: String,
    #[serde(default)]
    pub enabled: bool,
    pub events: Vec<ProjectIntegrationEvent>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    #[ts(optional)]
    pub min_severity: Option<String>,
    pub config: ProjectIntegrationConfigInput,
}

#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize, TS)]
pub struct PatchProjectIntegrationRequest {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    #[ts(optional)]
    pub name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    #[ts(optional)]
    pub enabled: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    #[ts(optional)]
    pub events: Option<Vec<ProjectIntegrationEvent>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    #[ts(optional)]
    pub min_severity: Option<Option<String>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    #[ts(optional)]
    pub config: Option<ProjectIntegrationConfigInput>,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, TS)]
pub struct TestProjectIntegrationResponse {
    pub ok: bool,
    pub message: String,
}