Struct Realtime

pub struct Realtime { /* private fields */ }

Realtime client for WebSocket subscriptions

Provides cross-platform realtime subscriptions to Supabase database changes.

Examples

Basic subscription

use supabase::{Client, realtime::RealtimeEvent};

let client = Client::new("your-url", "your-key")?;
let realtime = client.realtime();

realtime.connect().await?;

let sub_id = realtime
    .channel("public-posts")
    .table("posts")
    .subscribe(|msg| println!("New post: {:?}", msg))
    .await?;

Implementations

impl Realtime

pub fn new(config: Arc<SupabaseConfig>) -> Result<Self>

Create a new realtime client (works on both native and WASM)

Examples

use supabase::types::SupabaseConfig;
use supabase::realtime::Realtime;
use std::sync::Arc;

let config = Arc::new(SupabaseConfig {
    url: "https://your-project.supabase.co".to_string(),
    key: "your-anon-key".to_string(),
    ..Default::default()
});

let realtime = Realtime::new(config).unwrap();

pub async fn connect(&self) -> Result<()>

Connect to the realtime server (cross-platform)

Examples

let client = Client::new("your-url", "your-key")?;
let realtime = client.realtime();

realtime.connect().await?;
println!("Connected to Supabase realtime!");

pub async fn disconnect(&self) -> Result<()>

Disconnect from the realtime server

Examples

let client = Client::new("your-url", "your-key")?;
let realtime = client.realtime();

realtime.connect().await?;
// ... do work ...
realtime.disconnect().await?;

pub async fn is_connected(&self) -> bool

Check if connected to realtime server

Examples

let client = Client::new("your-url", "your-key")?;
let realtime = client.realtime();

if !realtime.is_connected().await {
    realtime.connect().await?;
}

pub fn channel(&self, _topic: &str) -> ChannelBuilder

Create a channel subscription builder

Examples

let client = Client::new("your-url", "your-key")?;

let subscription = client.realtime()
    .channel("public-posts")
    .table("posts")
    .subscribe(|msg| println!("Update: {:?}", msg))
    .await?;

pub async fn unsubscribe(&self, subscription_id: &str) -> Result<()>

Unsubscribe from a channel

Examples

let client = Client::new("your-url", "your-key")?;
let realtime = client.realtime();

let subscription_id = realtime
    .channel("posts")
    .table("posts")
    .subscribe(|_| {})
    .await?;

// Later...
realtime.unsubscribe(&subscription_id).await?;

pub async fn subscribe<F>( &self, subscription_config: SubscriptionConfig, callback: F, ) -> Result<String>

where F: Fn(RealtimeMessage) + Send + Sync + 'static,

Subscribe to a channel with custom configuration

pub async fn track_presence( &self, channel: &str, presence_state: PresenceState, ) -> Result<()>

Track user presence in a channel

Examples

use supabase::realtime::PresenceState;
use std::collections::HashMap;

let mut metadata = HashMap::new();
metadata.insert("status".to_string(), serde_json::Value::String("online".to_string()));
metadata.insert("location".to_string(), serde_json::Value::String("dashboard".to_string()));

let presence_state = PresenceState {
    user_id: "user123".to_string(),
    online_at: chrono::Utc::now().to_rfc3339(),
    metadata: Some(metadata),
};

realtime.track_presence("lobby", presence_state).await?;

pub async fn untrack_presence(&self, channel: &str, user_id: &str) -> Result<()>

Stop tracking user presence in a channel

Examples

realtime.untrack_presence("lobby", "user123").await?;

pub async fn get_presence(&self, channel: &str) -> Result<Vec<PresenceState>>

Get all users currently present in a channel

Examples

let present_users = realtime.get_presence("lobby").await?;
println!("Users online: {}", present_users.len());

pub async fn broadcast( &self, channel: &str, event: &str, payload: Value, from_user_id: Option<&str>, ) -> Result<()>

Send a broadcast message to all subscribers in a channel

Examples

use serde_json::json;

let payload = json!({
    "message": "Hello, everyone!",
    "from": "user123",
    "timestamp": chrono::Utc::now().to_rfc3339()
});

realtime.broadcast("chat", "new_message", payload, Some("user123")).await?;

pub async fn subscribe_advanced<F>( &self, channel: &str, config: SubscriptionConfig, callback: F, ) -> Result<String>

where F: Fn(RealtimeMessage) + Send + Sync + 'static,

Subscribe to a channel with advanced configuration

This method provides more control over subscriptions including presence tracking, broadcast messages, and advanced filtering.

Examples

use supabase::realtime::{SubscriptionConfig, RealtimeEvent, AdvancedFilter, FilterOperator};
use std::sync::Arc;

let config = SubscriptionConfig {
    table: Some("posts".to_string()),
    schema: "public".to_string(),
    event: Some(RealtimeEvent::All),
    advanced_filters: vec![
        AdvancedFilter {
            column: "status".to_string(),
            operator: FilterOperator::Equal,
            value: serde_json::Value::String("published".to_string()),
        }
    ],
    enable_presence: true,
    enable_broadcast: true,
    presence_callback: Some(Arc::new(|event| {
        println!("Presence event: {:?}", event);
    })),
    broadcast_callback: Some(Arc::new(|message| {
        println!("Broadcast message: {:?}", message);
    })),
    ..Default::default()
};

let subscription_id = realtime.subscribe_advanced("posts", config, |msg| {
    println!("Received message: {:?}", msg);
}).await?;
println!("Advanced subscription ID: {}", subscription_id);

Trait Implementations

impl Clone for Realtime

fn clone(&self) -> Realtime

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Realtime

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.