use std::future::Future;
use std::pin::Pin;
use std::sync::Arc;
use socketioxide::extract::{AckSender, Data, SocketRef};
use socketioxide::handler::ConnectHandler;
use socketioxide::SocketIo;
use wabot_core::injection::Container;
use crate::{HandshakeMiddleware, SocketError};
#[derive(Clone)]
pub struct SocketEventEntry {
pub event: &'static str,
pub invoke: SocketEventFn,
}
pub type SocketEventFn = Arc<
dyn Fn(
Container,
Option<SocketRef>,
serde_json::Value,
crate::AckSink,
) -> Pin<Box<dyn Future<Output = ()> + Send>>
+ Send
+ Sync,
>;
#[derive(Clone)]
pub struct HandshakeEntry {
pub name: &'static str,
#[allow(clippy::type_complexity)]
pub build: Arc<dyn Fn(&Container) -> Arc<dyn HandshakeMiddleware> + Send + Sync>,
}
pub const CONNECTION_EVENT: &str = "connection";
pub fn register_socket_namespace(
io: &SocketIo,
parent: Container,
namespace: String,
handshake: Vec<HandshakeEntry>,
events: Vec<SocketEventEntry>,
) {
tracing::info!(namespace = %namespace, events = events.len(), "config socket namespace");
let middleware_namespace = namespace.clone();
let middleware = move |socket: SocketRef| {
let parent = parent.clone();
let handshake = handshake.clone();
let namespace = middleware_namespace.clone();
async move {
let container = parent.create_child();
for entry in &handshake {
let middleware = (entry.build)(&container);
if let Err(error) = middleware.handle(&socket, &container).await {
tracing::warn!(
namespace = %namespace,
middleware = entry.name,
%error,
"handshake refused"
);
return Err(error);
}
}
socket.extensions.insert(container);
Ok::<(), SocketError>(())
}
};
let handler = move |socket: SocketRef| {
let Some(container) = socket.extensions.get::<Container>() else {
tracing::error!("socket reached the handler without a connection container");
socket.disconnect().ok();
return;
};
let mut on_connection: Option<SocketEventEntry> = None;
for entry in events.clone() {
if entry.event == CONNECTION_EVENT {
on_connection = Some(entry);
continue;
}
let container = container.clone();
let invoke = entry.invoke.clone();
socket.on(
entry.event,
move |socket: SocketRef, Data::<serde_json::Value>(payload), ack: AckSender| {
let container = container.clone();
let invoke = invoke.clone();
async move {
(invoke)(
container,
Some(socket),
payload,
crate::AckSink::Client(ack),
)
.await;
}
},
);
}
if let Some(entry) = on_connection {
let socket = socket.clone();
tokio::spawn(async move {
(entry.invoke)(
container,
Some(socket),
serde_json::Value::Null,
crate::AckSink::None,
)
.await;
});
}
};
io.ns(namespace, handler.with(middleware));
}
pub fn parse_payload<T>(payload: serde_json::Value) -> Result<T, SocketError>
where
T: serde::de::DeserializeOwned + wabot_core::validation::Validate,
{
let value: T = serde_json::from_value(payload)
.map_err(|error| SocketError::Validation(error.to_string()))?;
value
.validate()
.map_err(|error| SocketError::Validation(error.to_string()))?;
Ok(value)
}