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
138
139
140
141
142
143
144
145
146
147

//! API request/response models for authentication.

use serde::{Deserialize, Serialize};
use utoipa::ToSchema;

use crate::api::models::users::UserResponse;

/// Registration information
#[derive(Debug, Serialize, Deserialize, ToSchema)]
pub struct RegistrationInfo {
    /// Whether registration is enabled
    pub enabled: bool,
    /// Status message
    pub message: String,
}

/// Login information
#[derive(Debug, Serialize, Deserialize, ToSchema)]
pub struct LoginInfo {
    /// Whether native login is enabled
    pub enabled: bool,
    /// Status message
    pub message: String,
}

/// Request to register a new user
#[derive(Debug, Serialize, Deserialize, ToSchema)]
pub struct RegisterRequest {
    /// Username (must be unique)
    pub username: String,
    /// Email address (must be unique)
    pub email: String,
    /// Password (will be hashed)
    pub password: String,
    /// Optional display name
    pub display_name: Option<String>,
}

/// Request to login
#[derive(Debug, Serialize, Deserialize, ToSchema)]
pub struct LoginRequest {
    /// Email address
    pub email: String,
    /// Password
    pub password: String,
}

/// Response after successful login or registration
#[derive(Debug, Serialize, Deserialize, ToSchema)]
pub struct AuthResponse {
    /// User information
    pub user: UserResponse,
    /// Success message
    pub message: String,
}

/// Generic success response
#[derive(Debug, Serialize, Deserialize, ToSchema)]
pub struct AuthSuccessResponse {
    pub message: String,
}

/// Response models that implement IntoResponse for cleaner handler code
use axum::{
    Json,
    http::{HeaderMap, StatusCode, header},
    response::{IntoResponse, Response},
};

/// Structured response for successful registration
pub struct RegisterResponse {
    pub auth_response: AuthResponse,
    pub cookie: String,
}

impl IntoResponse for RegisterResponse {
    fn into_response(self) -> Response {
        let mut headers = HeaderMap::new();
        headers.insert(header::SET_COOKIE, self.cookie.parse().unwrap());
        (StatusCode::CREATED, headers, Json(self.auth_response)).into_response()
    }
}

/// Structured response for successful login
pub struct LoginResponse {
    pub auth_response: AuthResponse,
    pub cookie: String,
}

impl IntoResponse for LoginResponse {
    fn into_response(self) -> Response {
        let mut headers = HeaderMap::new();
        headers.insert(header::SET_COOKIE, self.cookie.parse().unwrap());
        (StatusCode::OK, headers, Json(self.auth_response)).into_response()
    }
}

/// Structured response for successful logout
pub struct LogoutResponse {
    pub auth_response: AuthSuccessResponse,
    pub cookie: String,
    /// Additional cookies to clear (e.g. dw_active_org)
    pub extra_cookies: Vec<String>,
}

/// Request to initiate password reset
#[derive(Debug, Serialize, Deserialize, ToSchema)]
pub struct PasswordResetRequest {
    /// Email address to send reset link to
    pub email: String,
}

/// Request to confirm password reset with token
#[derive(Debug, Serialize, Deserialize, ToSchema)]
pub struct PasswordResetConfirmRequest {
    /// Reset token from email
    pub token: String,
    /// New password
    pub new_password: String,
}

/// Response for password reset operations
#[derive(Debug, Serialize, Deserialize, ToSchema)]
pub struct PasswordResetResponse {
    /// Success message
    pub message: String,
}

/// Request to change password (for authenticated users)
#[derive(Debug, Serialize, Deserialize, ToSchema)]
pub struct ChangePasswordRequest {
    /// Current password (for verification)
    pub current_password: String,
    /// New password
    pub new_password: String,
}

impl IntoResponse for LogoutResponse {
    fn into_response(self) -> Response {
        let mut headers = HeaderMap::new();
        headers.append(header::SET_COOKIE, self.cookie.parse().unwrap());
        for cookie in &self.extra_cookies {
            headers.append(header::SET_COOKIE, cookie.parse().unwrap());
        }
        (StatusCode::OK, headers, Json(self.auth_response)).into_response()
    }
}