use serde::{Deserialize, Serialize};
use serde_json::Value;
#[derive(Debug, Default, Clone, Serialize)]
pub struct CreateRoomOptions {
#[serde(skip_serializing_if = "Option::is_none")]
pub max_participants: Option<i32>,
#[serde(skip_serializing_if = "Option::is_none")]
pub expires_at: Option<String>,
}
#[derive(Debug, Default, Clone, Serialize)]
pub struct ConfigureRoomOptions {
#[serde(
default,
skip_serializing_if = "Option::is_none",
serialize_with = "double_option::serialize"
)]
pub max_participants: Option<Option<i32>>,
#[serde(
default,
skip_serializing_if = "Option::is_none",
serialize_with = "double_option::serialize"
)]
pub expires_at: Option<Option<String>>,
#[serde(
default,
skip_serializing_if = "Option::is_none",
serialize_with = "double_option::serialize"
)]
pub metadata: Option<Option<Value>>,
#[serde(
default,
skip_serializing_if = "Option::is_none",
serialize_with = "double_option::serialize"
)]
pub allowed_origins: Option<Option<Vec<String>>>,
#[serde(
default,
skip_serializing_if = "Option::is_none",
serialize_with = "double_option::serialize"
)]
pub theme: Option<Option<Theme>>,
}
impl ConfigureRoomOptions {
pub fn new() -> Self {
Self::default()
}
pub fn max_participants(mut self, value: i32) -> Self {
self.max_participants = Some(Some(value));
self
}
pub fn clear_max_participants(mut self) -> Self {
self.max_participants = Some(None);
self
}
pub fn expires_at(mut self, value: impl Into<String>) -> Self {
self.expires_at = Some(Some(value.into()));
self
}
pub fn clear_expiry(mut self) -> Self {
self.expires_at = Some(None);
self
}
pub fn metadata(mut self, value: Value) -> Self {
self.metadata = Some(Some(value));
self
}
pub fn allowed_origins(mut self, value: Vec<String>) -> Self {
self.allowed_origins = Some(Some(value));
self
}
pub fn theme(mut self, value: Theme) -> Self {
self.theme = Some(Some(value));
self
}
pub fn clear_theme(mut self) -> Self {
self.theme = Some(None);
self
}
}
#[derive(Debug, Default, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct Theme {
#[serde(skip_serializing_if = "Option::is_none")]
pub accent: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub surface: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub text: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub radius: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub font: Option<String>,
}
#[derive(Debug, Clone, Deserialize)]
pub struct CreateRoomResponse {
pub room_id: String,
pub peer_id: String,
pub show_branding: bool,
#[serde(default)]
pub theme: Option<Theme>,
}
#[derive(Debug, Clone, Deserialize)]
pub struct Room {
pub id: String,
#[serde(default)]
pub max_participants: Option<i32>,
#[serde(default)]
pub expires_at: Option<String>,
#[serde(default)]
pub metadata: Option<Value>,
#[serde(default)]
pub allowed_origins: Option<Vec<String>>,
pub created_at: String,
#[serde(default)]
pub theme: Option<Theme>,
}
#[derive(Debug, Clone, Deserialize)]
pub struct IssueTokenResponse {
pub token: String,
#[serde(default)]
pub expires_at: Option<String>,
}
#[derive(Debug, Deserialize)]
pub(crate) struct ListRoomsResponse {
pub rooms: Vec<Room>,
}
mod double_option {
use serde::{Serialize, Serializer};
pub fn serialize<T, S>(value: &Option<Option<T>>, serializer: S) -> Result<S::Ok, S::Error>
where
T: Serialize,
S: Serializer,
{
match value {
Some(inner) => inner.serialize(serializer),
None => serializer.serialize_none(),
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use serde_json::json;
#[test]
fn configure_options_omit_vs_clear_vs_set() {
assert_eq!(
serde_json::to_value(ConfigureRoomOptions::new()).unwrap(),
json!({})
);
let opts = ConfigureRoomOptions::new()
.max_participants(20)
.clear_expiry();
assert_eq!(
serde_json::to_value(opts).unwrap(),
json!({ "max_participants": 20, "expires_at": null })
);
let opts = ConfigureRoomOptions::new().theme(Theme {
accent: Some("#5E6AD2".into()),
..Default::default()
});
assert_eq!(
serde_json::to_value(opts).unwrap(),
json!({ "theme": { "accent": "#5E6AD2" } })
);
assert_eq!(
serde_json::to_value(ConfigureRoomOptions::new().clear_theme()).unwrap(),
json!({ "theme": null })
);
}
#[test]
fn create_options_skip_absent_fields() {
assert_eq!(
serde_json::to_value(CreateRoomOptions::default()).unwrap(),
json!({})
);
let opts = CreateRoomOptions {
max_participants: Some(5),
expires_at: None,
};
assert_eq!(
serde_json::to_value(opts).unwrap(),
json!({ "max_participants": 5 })
);
}
#[test]
fn room_deserializes_with_optional_fields() {
let room: Room = serde_json::from_value(json!({
"id": "room_abc",
"created_at": "2026-01-01T00:00:00Z",
"theme": { "accent": "#000000" }
}))
.unwrap();
assert_eq!(room.id, "room_abc");
assert_eq!(room.max_participants, None);
assert_eq!(room.theme.unwrap().accent.as_deref(), Some("#000000"));
}
}