use parking_lot::RwLock;
use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use std::sync::Arc;
use std::sync::atomic::{AtomicU64, AtomicUsize, Ordering};
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub enum ChangeOp {
Insert,
Update,
Delete,
}
impl std::fmt::Display for ChangeOp {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
ChangeOp::Insert => write!(f, "INSERT"),
ChangeOp::Update => write!(f, "UPDATE"),
ChangeOp::Delete => write!(f, "DELETE"),
}
}
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ChangeEvent {
pub op: ChangeOp,
pub table: String,
pub row_id: u64,
pub timestamp: u64,
pub data: serde_json::Value,
}
type Callback = Arc<dyn Fn(&ChangeEvent) + Send + Sync>;
pub struct RealtimeBus {
next_sub_id: AtomicU64,
active_subscribers: AtomicUsize,
table_subscribers: RwLock<HashMap<String, Vec<(u64, Callback)>>>,
global_subscribers: RwLock<Vec<(u64, Callback)>>,
}
impl Default for RealtimeBus {
fn default() -> Self {
Self::new()
}
}
impl RealtimeBus {
pub fn new() -> Self {
Self {
next_sub_id: AtomicU64::new(1),
active_subscribers: AtomicUsize::new(0),
table_subscribers: RwLock::new(HashMap::new()),
global_subscribers: RwLock::new(Vec::new()),
}
}
#[inline(always)]
pub fn has_subscribers(&self) -> bool {
self.active_subscribers.load(Ordering::Relaxed) > 0
}
pub fn subscribe<F>(&self, table: &str, callback: F) -> u64
where
F: Fn(&ChangeEvent) + Send + Sync + 'static,
{
let id = self.next_sub_id.fetch_add(1, Ordering::SeqCst);
self.active_subscribers.fetch_add(1, Ordering::SeqCst);
let cb: Callback = Arc::new(callback);
if table == "*" {
let mut global = self.global_subscribers.write();
global.push((id, cb));
} else {
let mut map = self.table_subscribers.write();
map.entry(table.to_lowercase()).or_default().push((id, cb));
}
id
}
pub fn unsubscribe(&self, sub_id: u64) {
let mut removed = false;
{
let mut global = self.global_subscribers.write();
let before = global.len();
global.retain(|(id, _)| *id != sub_id);
if global.len() < before {
removed = true;
}
}
{
let mut map = self.table_subscribers.write();
for subscribers in map.values_mut() {
let before = subscribers.len();
subscribers.retain(|(id, _)| *id != sub_id);
if subscribers.len() < before {
removed = true;
}
}
}
if removed {
self.active_subscribers.fetch_sub(1, Ordering::SeqCst);
}
}
pub fn publish(&self, event: &ChangeEvent) {
if !self.has_subscribers() {
return;
}
{
let map = self.table_subscribers.read();
if let Some(subscribers) = map.get(&event.table.to_lowercase()) {
for (_, cb) in subscribers {
cb(event);
}
}
}
{
let global = self.global_subscribers.read();
for (_, cb) in global.iter() {
cb(event);
}
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use std::sync::atomic::AtomicUsize;
#[test]
fn test_realtime_table_subscription() {
let bus = RealtimeBus::new();
let counter = Arc::new(AtomicUsize::new(0));
let counter_clone = counter.clone();
let sub_id = bus.subscribe("users", move |ev| {
assert_eq!(ev.table, "users");
assert_eq!(ev.op, ChangeOp::Insert);
counter_clone.fetch_add(1, Ordering::SeqCst);
});
bus.publish(&ChangeEvent {
op: ChangeOp::Insert,
table: "users".to_string(),
row_id: 1,
timestamp: 1700000000,
data: serde_json::json!({"name": "Alex"}),
});
assert_eq!(counter.load(Ordering::SeqCst), 1);
bus.publish(&ChangeEvent {
op: ChangeOp::Insert,
table: "orders".to_string(),
row_id: 100,
timestamp: 1700000001,
data: serde_json::json!({"total": 50}),
});
assert_eq!(counter.load(Ordering::SeqCst), 1);
bus.unsubscribe(sub_id);
bus.publish(&ChangeEvent {
op: ChangeOp::Insert,
table: "users".to_string(),
row_id: 2,
timestamp: 1700000002,
data: serde_json::json!({"name": "Ahmad"}),
});
assert_eq!(counter.load(Ordering::SeqCst), 1);
}
}