use async_trait::async_trait;
use serde::Serialize;
use socketioxide::extract::{AckSender, SocketRef};
use socketioxide::SocketIo;
use thiserror::Error;
use wabot_core::injection::Container;
#[cfg(feature = "testing")]
#[cfg(feature = "live-harness")]
pub mod live;
pub mod runtime;
pub mod server;
pub mod testing;
pub use runtime::{register_socket_namespace, HandshakeEntry, SocketEventEntry, SocketEventFn};
pub use server::{run_socket_controllers, socket_layer, SocketServerConfig};
#[cfg(feature = "testing")]
pub use testing::{EmittedEvent, SocketHarness};
pub use socketioxide;
#[derive(Debug, Error)]
pub enum SocketError {
#[error("invalid event payload: {0}")]
Validation(String),
#[error("handshake refused: {0}")]
Unauthorized(String),
#[error("{0}")]
Handler(String),
}
pub type SocketResult<T> = Result<T, SocketError>;
impl SocketError {
pub fn to_payload(&self) -> serde_json::Value {
let code = match self {
SocketError::Validation(_) => "INVALID_PAYLOAD",
SocketError::Unauthorized(_) => "UNAUTHORIZED",
SocketError::Handler(_) => "HANDLER_ERROR",
};
serde_json::json!({ "error": { "code": code, "message": self.to_string() } })
}
}
#[async_trait]
pub trait HandshakeMiddleware: Send + Sync {
async fn handle(&self, socket: &SocketRef, container: &Container) -> SocketResult<()>;
}
pub fn connection_container(socket: &SocketRef) -> Option<Container> {
socket.extensions.get::<Container>()
}
pub enum AckSink {
Client(AckSender),
Captured(std::sync::Arc<parking_lot::Mutex<Option<serde_json::Value>>>),
None,
}
impl AckSink {
pub fn capture() -> (
Self,
std::sync::Arc<parking_lot::Mutex<Option<serde_json::Value>>>,
) {
let slot = std::sync::Arc::new(parking_lot::Mutex::new(None));
(Self::Captured(slot.clone()), slot)
}
pub fn send(self, value: &serde_json::Value) {
match self {
AckSink::Client(ack) => {
if let Err(error) = ack.send(value) {
tracing::debug!(%error, "could not send the ack");
}
}
AckSink::Captured(slot) => *slot.lock() = Some(value.clone()),
AckSink::None => {}
}
}
}
pub fn ack_with(ack: AckSink, value: &serde_json::Value) {
ack.send(value);
}
#[doc(hidden)]
pub fn ack_result<T: Serialize>(ack: AckSink, result: SocketResult<T>) {
match result {
Ok(value) => match serde_json::to_value(&value) {
Ok(value) => ack.send(&value),
Err(error) => ack.send(
&SocketError::Handler(format!("could not serialize the response: {error}"))
.to_payload(),
),
},
Err(error) => {
tracing::warn!(%error, "socket event failed");
ack.send(&error.to_payload());
}
}
}
pub struct SocketControllerRegistration {
pub namespace: String,
pub handshake: Vec<HandshakeEntry>,
pub events: Vec<SocketEventEntry>,
}
impl SocketControllerRegistration {
pub fn attach(self, io: &SocketIo, container: Container) {
register_socket_namespace(io, container, self.namespace, self.handshake, self.events);
}
pub fn event_names(&self) -> Vec<&'static str> {
self.events.iter().map(|entry| entry.event).collect()
}
pub fn handshake_names(&self) -> Vec<&'static str> {
self.handshake.iter().map(|entry| entry.name).collect()
}
}
#[doc(hidden)]
pub mod __reexport {
pub use async_trait::async_trait;
pub use serde_json;
pub use socketioxide::extract::{AckSender, Data, SocketRef};
pub use std::sync::Arc;
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn an_error_payload_is_a_shape_a_client_can_branch_on() {
let payload = SocketError::Validation("text is required".into()).to_payload();
assert_eq!(payload["error"]["code"], "INVALID_PAYLOAD");
assert!(payload["error"]["message"]
.as_str()
.unwrap()
.contains("text is required"));
assert_eq!(
SocketError::Unauthorized("no key".into()).to_payload()["error"]["code"],
"UNAUTHORIZED"
);
assert_eq!(
SocketError::Handler("boom".into()).to_payload()["error"]["code"],
"HANDLER_ERROR"
);
}
}