sockudo 3.1.0

A simple, fast, and secure WebSocket server for real-time applications.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84

use ahash::AHashMap;
// src/webhook/types.rs
// No SdkConfig needed here, it's for AWS SDK interaction in lambda_sender.
use serde::{Deserialize, Serialize};
use sonic_rs::Value; // Keep this for Value type

#[derive(Debug, Clone, Serialize, Deserialize, Default, PartialEq)]
pub struct Webhook {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub url: Option<url::Url>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lambda_function: Option<String>, // Kept for potential legacy or direct Lambda use
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lambda: Option<LambdaConfig>, // For structured Lambda config
    pub event_types: Vec<String>, // Names of events this webhook is interested in
    #[serde(skip_serializing_if = "Option::is_none")]
    pub filter: Option<WebhookFilter>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub headers: Option<WebhookHeaders>, // Custom headers user might want to add to outgoing webhook
}

// This struct is not directly used in the Pusher payload format,
// but represents the type of events a webhook configuration can subscribe to.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct WebhookEventType {
    pub name: String,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct WebhookFilter {
    pub channel_prefix: Option<String>,
    pub channel_suffix: Option<String>,
    pub channel_pattern: Option<String>,
}

#[derive(Debug, Clone, Serialize, PartialEq)]
pub struct WebhookHeaders {
    pub headers: AHashMap<String, String>,
}

impl<'de> Deserialize<'de> for WebhookHeaders {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        // Flatten workaround for sonic-rs issue #114.
        let headers = AHashMap::<String, String>::deserialize(deserializer)?;
        Ok(Self { headers })
    }
}

#[derive(Debug, Clone, Serialize, Deserialize, Default, PartialEq)]
pub struct LambdaConfig {
    pub function_name: String,
    pub region: String,
}

// This is the JobData structure that Sockudo uses internally for its queue.
// The `payload` field will be structured to produce the Pusher-compatible format when sent.
#[derive(Debug, Clone, Serialize, Deserialize, Default, PartialEq)]
pub struct JobData {
    pub app_key: String,    // Needed for X-Pusher-Key and signing
    pub app_id: String,     // For logging and potentially for the webhook receiver
    pub app_secret: String, // Needed for signing the X-Pusher-Signature
    pub payload: JobPayload,
    pub original_signature: String, // Sockudo's internal signature for queue deduplication, etc.
}

// This is the JobPayload structure.
// The `events` field will now hold a vector of fully formed Pusher event objects.
#[derive(Debug, Clone, Serialize, Deserialize, Default, PartialEq)]
pub struct JobPayload {
    pub time_ms: i64, // Unix timestamp in milliseconds
    pub events: Vec<Value>, // Each Value is a JSON object representing a Pusher event,
                      // e.g., { "name": "channel_occupied", "channel": "my-channel" }
}

// This struct represents the final payload sent to the webhook receiver,
// aligning with Pusher's format.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PusherWebhookPayload {
    pub time_ms: i64,
    pub events: Vec<Value>, // Array of event objects
}