dwctl 8.38.2

The Doubleword Control Layer - A self-hostable observability and analytics platform for LLM applications
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

//! API request and response models for webhook endpoints.

use chrono::{DateTime, Utc};
use serde::{Deserialize, Serialize};
use utoipa::ToSchema;
use uuid::Uuid;

use crate::db::models::webhooks::{Webhook, WebhookId};
use crate::types::{UserId, UserIdOrCurrent};

/// Request to create a new webhook.
#[derive(Debug, Clone, Deserialize, ToSchema)]
pub struct WebhookCreate {
    /// HTTPS URL to receive webhook events
    pub url: String,
    /// Optional list of event types to receive (null for all events within scope)
    #[serde(default)]
    pub event_types: Option<Vec<String>>,
    /// Optional description to identify this webhook
    #[serde(default)]
    pub description: Option<String>,
    /// Webhook scope: "own" for user-scoped events, "platform" for platform-wide events (PlatformManager only)
    #[serde(default = "default_scope")]
    pub scope: String,
}

fn default_scope() -> String {
    "own".to_string()
}

/// Request to update a webhook.
#[derive(Debug, Clone, Deserialize, ToSchema)]
pub struct WebhookUpdate {
    /// New URL (optional)
    #[serde(default)]
    pub url: Option<String>,
    /// Enable/disable the webhook (optional)
    #[serde(default)]
    pub enabled: Option<bool>,
    /// New event types filter (optional, null to receive all events)
    #[serde(default)]
    pub event_types: Option<Option<Vec<String>>>,
    /// New description (optional)
    #[serde(default)]
    pub description: Option<Option<String>>,
}

/// Response for a webhook (secret hidden except on create/rotate).
#[derive(Debug, Clone, Serialize, Deserialize, ToSchema)]
pub struct WebhookResponse {
    #[schema(value_type = String, format = "uuid")]
    pub id: WebhookId,
    #[schema(value_type = String, format = "uuid")]
    pub user_id: UserId,
    pub url: String,
    pub enabled: bool,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub event_types: Option<Vec<String>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    pub scope: String,
    pub created_at: DateTime<Utc>,
    pub updated_at: DateTime<Utc>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub disabled_at: Option<DateTime<Utc>>,
}

impl From<Webhook> for WebhookResponse {
    fn from(webhook: Webhook) -> Self {
        let event_types = webhook.event_types.and_then(|v| serde_json::from_value::<Vec<String>>(v).ok());

        Self {
            id: webhook.id,
            user_id: webhook.user_id,
            url: webhook.url,
            enabled: webhook.enabled,
            event_types,
            description: webhook.description,
            scope: webhook.scope,
            created_at: webhook.created_at,
            updated_at: webhook.updated_at,
            disabled_at: webhook.disabled_at,
        }
    }
}

/// Response for webhook create/rotate that includes the secret (shown only once).
#[derive(Debug, Clone, Serialize, Deserialize, ToSchema)]
pub struct WebhookWithSecretResponse {
    #[schema(value_type = String, format = "uuid")]
    pub id: WebhookId,
    #[schema(value_type = String, format = "uuid")]
    pub user_id: UserId,
    pub url: String,
    /// The webhook secret (only shown on create and rotate operations)
    pub secret: String,
    pub enabled: bool,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub event_types: Option<Vec<String>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    pub scope: String,
    pub created_at: DateTime<Utc>,
    pub updated_at: DateTime<Utc>,
}

impl From<Webhook> for WebhookWithSecretResponse {
    fn from(webhook: Webhook) -> Self {
        let event_types = webhook.event_types.and_then(|v| serde_json::from_value::<Vec<String>>(v).ok());

        Self {
            id: webhook.id,
            user_id: webhook.user_id,
            url: webhook.url,
            secret: webhook.secret,
            enabled: webhook.enabled,
            event_types,
            description: webhook.description,
            scope: webhook.scope,
            created_at: webhook.created_at,
            updated_at: webhook.updated_at,
        }
    }
}

/// Path parameters for webhook endpoints.
#[derive(Debug, Clone, Deserialize)]
pub struct WebhookPathParams {
    pub user_id: UserIdOrCurrent,
    pub webhook_id: Uuid,
}

/// Path parameters for user-only webhook endpoints.
#[derive(Debug, Clone, Deserialize)]
pub struct UserWebhookPathParams {
    pub user_id: UserIdOrCurrent,
}