bridge: Rename sender and receiver config and add some docs

Author: svix-jplatte

bridge/svix-bridge/src/config/mod.rs

@@ -19,10 +19,12 @@ use tracing::Level;
 #[derive(Deserialize)]
 #[serde(deny_unknown_fields)]
 pub struct Config {
+    /// Config for reading messages from plugins and forwarding to Svix.
     #[serde(default)]
-    pub senders: Vec<SenderConfig>,
+    pub senders: Vec<WebhookSenderConfig>,
+    /// Config for receiving webhooks and forwarding them to plugins.
     #[serde(default)]
-    pub receivers: Vec<ReceiverConfig>,
+    pub receivers: Vec<WebhookReceiverConfig>,
     /// The log level to run the service with. Supported: info, debug, trace
     #[serde(default)]
     pub log_level: LogLevel,
@@ -141,9 +143,10 @@ pub enum LogFormat {
     Json,
 }
 
+/// Config for reading messages from plugins and forwarding to Svix.
 #[derive(Deserialize)]
 #[serde(untagged)]
-pub enum SenderConfig {
+pub enum WebhookSenderConfig {
     #[cfg(any(
         feature = "gcp-pubsub",
         feature = "rabbitmq",
@@ -153,36 +156,37 @@ pub enum SenderConfig {
     Queue(QueueSenderConfig),
 }
 
-impl SenderConfig {
+impl WebhookSenderConfig {
     pub fn name(&self) -> &str {
         match self {
-            SenderConfig::Queue(cfg) => &cfg.name,
+            WebhookSenderConfig::Queue(cfg) => &cfg.name,
         }
     }
     pub fn transformation(&self) -> Option<&TransformationConfig> {
         match self {
-            SenderConfig::Queue(cfg) => cfg.transformation.as_ref(),
+            WebhookSenderConfig::Queue(cfg) => cfg.transformation.as_ref(),
         }
     }
 }
 
-impl TryFrom<SenderConfig> for Box<dyn SenderInput> {
+impl TryFrom<WebhookSenderConfig> for Box<dyn SenderInput> {
     type Error = &'static str;
-    fn try_from(value: SenderConfig) -> Result<Self, Self::Error> {
+    fn try_from(value: WebhookSenderConfig) -> Result<Self, Self::Error> {
         match value {
             #[cfg(any(
                 feature = "gcp-pubsub",
                 feature = "rabbitmq",
                 feature = "redis",
                 feature = "sqs"
             ))]
-            SenderConfig::Queue(backend) => backend.into_sender_input(),
+            WebhookSenderConfig::Queue(backend) => backend.into_sender_input(),
         }
     }
 }
 
+/// Config for receiving webhooks and forwarding them to plugins.
 #[derive(Deserialize)]
-pub struct ReceiverConfig {
+pub struct WebhookReceiverConfig {
     pub name: String,
     pub input: ReceiverInputOpts,
     #[serde(default)]
@@ -202,7 +206,7 @@ pub enum ReceiverOut {
     Queue(QueueOutOpts),
 }
 
-impl ReceiverConfig {
+impl WebhookReceiverConfig {
     pub async fn into_receiver_output(self) -> std::io::Result<Box<dyn ReceiverOutput>> {
         match self.output {
             ReceiverOut::Queue(x) => {

bridge/svix-bridge/src/config/tests.rs

@@ -4,7 +4,7 @@ use svix_bridge_plugin_queue::config::{QueueSenderConfig, RabbitMqInputOpts, Sen
 use svix_bridge_types::{SenderOutputOpts, SvixSenderOutputOpts};
 
 use super::Config;
-use crate::config::{LogFormat, LogLevel, SenderConfig};
+use crate::config::{LogFormat, LogLevel, WebhookSenderConfig};
 
 /// This is meant to be a kitchen sink config, hitting as many possible
 /// configuration options as possible to ensure they parse correctly.
@@ -241,7 +241,7 @@ receivers:
 
 #[test]
 fn test_sender_parses_ok() {
-    let conf: Result<SenderConfig, _> = serde_yaml::from_str(
+    let conf: Result<WebhookSenderConfig, _> = serde_yaml::from_str(
         r#"
 name: "from-rabbit-local-to-svix"
 input:
@@ -260,7 +260,7 @@ output:
 
 #[test]
 fn test_senders_parses_ok() {
-    let conf: Result<Vec<SenderConfig>, _> = serde_yaml::from_str(
+    let conf: Result<Vec<WebhookSenderConfig>, _> = serde_yaml::from_str(
         r#"
 
 - name: "from-rabbit-local-to-svix"
@@ -455,7 +455,7 @@ fn test_variable_substitution_repeated_lookups() {
     vars.insert(String::from("SVIX_TOKEN"), String::from("x"));
     let cfg = Config::from_src(src, Some(&vars)).unwrap();
 
-    if let SenderConfig::Queue(QueueSenderConfig {
+    if let WebhookSenderConfig::Queue(QueueSenderConfig {
         input:
             SenderInputOpts::RabbitMQ(RabbitMqInputOpts {
                 uri, queue_name, ..
@@ -471,7 +471,7 @@ fn test_variable_substitution_repeated_lookups() {
         panic!("sender did not match expected pattern");
     }
 
-    if let SenderConfig::Queue(QueueSenderConfig {
+    if let WebhookSenderConfig::Queue(QueueSenderConfig {
         input:
             SenderInputOpts::RabbitMQ(RabbitMqInputOpts {
                 uri, queue_name, ..

bridge/svix-bridge/src/webhook_receiver/config.rs

@@ -1,7 +1,7 @@
 use serde::Deserialize;
 use svix_bridge_types::{TransformationConfig, WebhookVerifier};
 
-use crate::config::ReceiverConfig;
+use crate::config::WebhookReceiverConfig;
 
 /// The [`IntegrationConfig`] is the struct associated with a given [`IntegrationId`]. When the route
 /// associated with an [`IntegrationId`] receives a webhook, or any other HTTP request, then it will
@@ -11,7 +11,7 @@ use crate::config::ReceiverConfig;
 #[derive(Deserialize)]
 #[allow(dead_code)]
 pub struct IntegrationConfig {
-    pub receiver_cfg: ReceiverConfig,
+    pub receiver_cfg: WebhookReceiverConfig,
     pub verification: WebhookVerifier,
     #[serde(default)]
     pub transformation: Option<TransformationConfig>,

bridge/svix-bridge/src/webhook_receiver/mod.rs

@@ -13,7 +13,7 @@ use svix_bridge_types::{
 use tracing::instrument;
 use types::{IntegrationId, IntegrationState, InternalState, SerializableRequest, Unvalidated};
 
-use crate::{config::ReceiverConfig, webhook_receiver::types::SerializablePayload};
+use crate::{config::WebhookReceiverConfig, webhook_receiver::types::SerializablePayload};
 
 mod config;
 mod types;
@@ -33,7 +33,7 @@ fn router() -> Router<InternalState, Body> {
 
 pub async fn run(
     listen_addr: SocketAddr,
-    routes: Vec<ReceiverConfig>,
+    routes: Vec<WebhookReceiverConfig>,
     transformer_tx: TransformerTx,
 ) -> std::io::Result<()> {
     let state = InternalState::from_receiver_configs(routes, transformer_tx)

bridge/svix-bridge/src/webhook_receiver/types.rs

@@ -14,7 +14,7 @@ use svix_bridge_types::{
 };
 
 use super::verification::{NoVerifier, SvixVerifier, VerificationMethod, Verifier};
-use crate::config::ReceiverConfig;
+use crate::config::WebhookReceiverConfig;
 
 #[derive(Clone)]
 /// The [`InternalState`] is passed to the Axum route and is used to map the "IntegrationId" in the
@@ -50,7 +50,7 @@ impl InternalState {
     }
 
     pub async fn from_receiver_configs(
-        routes: Vec<ReceiverConfig>,
+        routes: Vec<WebhookReceiverConfig>,
         transformer_tx: TransformerTx,
     ) -> Result<Self> {
         let mut state_map = HashMap::new();