consolidate channel backend configs in jsonb col

Cargo.lock

@@ -758,6 +758,7 @@ dependencies = [
  "diesel_derives",
  "itoa",
  "pq-sys",
+ "serde_json",
  "uuid",
 ]
 

Cargo.toml

@@ -28,7 +28,7 @@ axum = { version = "0.8.1", features = ["macros"] }
 axum-extra = { version = "0.10.0", features = ["cookie", "form", "typed-header"] }
 chrono = { version = "0.4.39", features = ["serde"] }
 base64 = "0.22.1"
-diesel = { version = "2.2.6", features = ["postgres", "chrono", "uuid"] }
+diesel = { version = "2.2.6", features = ["postgres", "chrono", "uuid", "serde_json"] }
 tower = "0.5.2"
 regex = "1.11.1"
 lettre = { version = "0.11.12", features = ["tokio1", "serde", "tracing", "tokio1-native-tls"] }

migrations/2024-11-25-232658_init/down.sql

@@ -1,3 +1,5 @@
+DROP TABLE IF EXISTS channel_selections;
+DROP TABLE IF EXISTS channels;
 DROP TABLE IF EXISTS projects;
 DROP TABLE IF EXISTS api_keys;
 DROP TABLE IF EXISTS team_memberships;

migrations/2024-11-25-232658_init/up.sql

@@ -41,3 +41,19 @@ CREATE TABLE projects (
     UNIQUE (team_id, name)
 );
 CREATE INDEX ON projects(team_id);
+
+CREATE TABLE IF NOT EXISTS channels (
+    id UUID NOT NULL PRIMARY KEY,
+    team_id UUID NOT NULL REFERENCES teams(id),
+    name TEXT NOT NULL,
+    enable_by_default BOOLEAN NOT NULL DEFAULT FALSE,
+    backend_config JSONB NOT NULL DEFAULT '{}'::JSONB
+);
+
+CREATE TABLE IF NOT EXISTS channel_selections (
+    project_id UUID NOT NULL REFERENCES projects(id),
+    channel_id UUID NOT NULL REFERENCES channels(id),
+    PRIMARY KEY (project_id, channel_id)
+);
+CREATE INDEX ON channel_selections (project_id);
+CREATE INDEX ON channel_selections (channel_id);

migrations/2025-01-31-045014_messages/up.sql

@@ -1,8 +1,10 @@
 CREATE TABLE IF NOT EXISTS messages (
     id UUID PRIMARY KEY NOT NULL,
-    project_id UUID NOT NULL REFERENCES projects (id),
+    channel_id UUID NOT NULL REFERENCES channels (id),
     created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    sent_at TIMESTAMPTZ,
     message TEXT NOT NULL
 );
-CREATE INDEX ON messages (project_id);
+CREATE INDEX ON messages (channel_id);
 CREATE INDEX ON messages (created_at);
+CREATE INDEX ON messages (sent_at);

migrations/2025-02-04-070208_init_channels/down.sql

@@ -1,4 +0,0 @@
-DROP TABLE IF EXISTS channel_selections;
-DROP TABLE IF EXISTS slack_channels;
-DROP TABLE IF EXISTS email_channels;
-DROP TABLE IF EXISTS channels;

migrations/2025-02-04-070208_init_channels/up.sql

@@ -1,29 +0,0 @@
-CREATE TABLE IF NOT EXISTS channels (
-    id UUID NOT NULL PRIMARY KEY,
-    team_id UUID NOT NULL REFERENCES teams(id),
-    name TEXT NOT NULL,
-    enable_by_default BOOLEAN NOT NULL DEFAULT FALSE
-);
-
-CREATE TABLE IF NOT EXISTS email_channels (
-    id UUID NOT NULL PRIMARY KEY REFERENCES channels(id) ON DELETE CASCADE,
-    recipient TEXT NOT NULL DEFAULT '',
-    verification_code TEXT NOT NULL DEFAULT '',
-    verification_code_guesses INT NOT NULL DEFAULT 0,
-    verified BOOLEAN NOT NULL DEFAULT FALSE
-);
-
-CREATE TABLE IF NOT EXISTS slack_channels (
-    id UUID NOT NULL PRIMARY KEY REFERENCES channels(id) ON DELETE CASCADE,
-    oauth_state TEXT NOT NULL DEFAULT '',
-    access_token TEXT NOT NULL DEFAULT '',
-    conversation_id TEXT NOT NULL DEFAULT ''
-);
-
-CREATE TABLE IF NOT EXISTS channel_selections (
-    project_id UUID NOT NULL REFERENCES projects(id),
-    channel_id UUID NOT NULL REFERENCES channels(id),
-    PRIMARY KEY (project_id, channel_id)
-);
-CREATE INDEX ON channel_selections (project_id);
-CREATE INDEX ON channel_selections (channel_id);

src/channels.rs

@@ -1,64 +1,44 @@
-use anyhow::Context;
-use deadpool_diesel::postgres::Connection;
 use diesel::{
-    dsl::{auto_type, insert_into, AsSelect},
+    backend::Backend,
+    deserialize::{self, FromSql, FromSqlRow},
+    dsl::{auto_type, AsSelect},
+    expression::AsExpression,
     pg::Pg,
     prelude::*,
-    Connection as _,
+    serialize::{Output, ToSql},
+    sql_types::Jsonb,
 };
-use serde::Serialize;
+use serde::{Deserialize, Serialize};
+use serde_json::json;
 use uuid::Uuid;
 
-use crate::{
+use crate::{schema::channels, teams::Team};
-    app_error::AppError,
-    schema::{channels, email_channels, slack_channels},
-    teams::Team,
-};
 
+pub const CHANNEL_BACKEND_EMAIL: &'static str = "email";
+pub const CHANNEL_BACKEND_SLACK: &'static str = "slack";
+
+/**
+ * Represents a target/destination for messages, with the sender configuration
+ * defined in the backend_config field. A single channel may be attached to
+ * (in other words, "enabled" or "selected" for) any number of projects within
+ * the same team.
+ */
 #[derive(Associations, Clone, Debug, Identifiable, Queryable, Selectable)]
 #[diesel(belongs_to(Team))]
+#[diesel(check_for_backend(Pg))]
 pub struct Channel {
     pub id: Uuid,
     pub team_id: Uuid,
     pub name: String,
     pub enable_by_default: bool,
-
+    pub backend_config: BackendConfig,
-    #[diesel(embed)]
-    pub email_data: Option<EmailChannel>,
-    #[diesel(embed)]
-    pub slack_data: Option<SlackChannel>,
-}
-
-#[derive(
-    Associations, Clone, Debug, Identifiable, Insertable, Queryable, Selectable, Serialize,
-)]
-#[diesel(belongs_to(Channel, foreign_key = id))]
-pub struct EmailChannel {
-    pub id: Uuid,
-    pub recipient: String,
-    #[serde(skip_serializing)]
-    pub verification_code: String,
-    pub verification_code_guesses: i32,
-    pub verified: bool,
-}
-
-#[derive(Associations, Clone, Debug, Identifiable, Insertable, Queryable, Selectable)]
-#[diesel(belongs_to(Channel, foreign_key = id))]
-pub struct SlackChannel {
-    pub id: Uuid,
-    pub oauth_state: String,
-    pub access_token: String,
-    pub conversation_id: String,
 }
 
 impl Channel {
     #[auto_type(no_type_alias)]
     pub fn all() -> _ {
         let select: AsSelect<Channel, Pg> = Channel::as_select();
-        channels::table
+        channels::table.select(select)
-            .left_join(email_channels::table)
-            .left_join(slack_channels::table)
-            .select(select)
     }
 
     #[auto_type(no_type_alias)]
@@ -70,31 +50,123 @@ impl Channel {
     pub fn with_team(team_id: Uuid) -> _ {
         channels::team_id.eq(team_id)
     }
+}
 
-    pub async fn create_email_channel(
+/**
-        db_conn: &Connection,
+ * Encapsulates any information that needs to be persisted for setting up or
-        team_id: Uuid,
+ * using a channel's backend (that is, email sender, Slack app, etc.). This
-    ) -> Result<Self, AppError> {
+ * configuration is encoded to a jsonb column in the database, which determines
-        let id = Uuid::now_v7();
+ * the channel type along with configuration details.
-        db_conn
+ *
-            .interact(move |conn| {
+ * Note: In a previous implementation, channel configuration was handled by
-                conn.transaction(move |conn| {
+ * creating a dedicated table for each channel type and joining them to the
-                    insert_into(channels::table)
+ * `channels` table in order to access configuration fields. The jsonb approach
-                        .values((
+ * simplifies database management and lends itself to a cleaner Rust
-                            channels::id.eq(id.clone()),
+ * implementation in which this enum can be treated as a column type with
-                            channels::team_id.eq(team_id),
+ * enforcement of data structure invariants handled entirely in the to_sql()
-                            channels::name.eq("Untitled Email Channel"),
+ * and from_sql() serialization/deserialization logic.
+ */
+#[derive(AsExpression, Clone, Debug, FromSqlRow, Deserialize, Serialize)]
+#[diesel(sql_type = Jsonb)]
+pub enum BackendConfig {
+    Email(EmailBackendConfig),
+    Slack(SlackBackendConfig),
+}
+
+impl ToSql<Jsonb, Pg> for BackendConfig {
+    fn to_sql<'a>(&self, out: &mut Output<'a, '_, Pg>) -> diesel::serialize::Result {
+        match self.clone() {
+            BackendConfig::Email(config) => ToSql::<Jsonb, Pg>::to_sql(
+                &json!({
+                    "t": CHANNEL_BACKEND_EMAIL,
+                    "config": config,
+                }),
+                &mut out.reborrow(),
+            ),
+            BackendConfig::Slack(config) => ToSql::<Jsonb, Pg>::to_sql(
+                &json!({
+                    "t": CHANNEL_BACKEND_SLACK,
+                    "config": config,
+                }),
+                &mut out.reborrow(),
+            ),
+        }
+    }
+}
+
+impl FromSql<Jsonb, Pg> for BackendConfig {
+    fn from_sql(bytes: <Pg as Backend>::RawValue<'_>) -> deserialize::Result<Self> {
+        let value = <serde_json::Value as FromSql<Jsonb, Pg>>::from_sql(bytes)?;
+        #[derive(Deserialize)]
+        struct IntermediateBackendConfig {
+            pub t: String,
+            pub config: serde_json::Value,
+        }
+        let intermediate_value = IntermediateBackendConfig::deserialize(value)?;
+        match intermediate_value.t.as_str() {
+            CHANNEL_BACKEND_EMAIL => Ok(BackendConfig::Email(EmailBackendConfig::deserialize(
+                intermediate_value.config,
+            )?)),
+            CHANNEL_BACKEND_SLACK => Ok(BackendConfig::Slack(SlackBackendConfig::deserialize(
+                intermediate_value.config,
+            )?)),
+            t => Err(anyhow::anyhow!("backend type not recognized: {}", t).into()),
+        }
+    }
+}
+
+#[derive(Clone, Debug, Default, Deserialize, Serialize)]
+pub struct EmailBackendConfig {
+    pub recipient: String,
+    pub verification_code: String,
+    pub verification_code_guesses: u32,
+    pub verified: bool,
+}
+
+impl TryFrom<BackendConfig> for EmailBackendConfig {
+    type Error = anyhow::Error;
+
+    fn try_from(value: BackendConfig) -> Result<Self, Self::Error> {
+        if let BackendConfig::Email(config) = value {
+            Ok(config)
+        } else {
+            Err(anyhow::anyhow!(
+                "could not load backend config as email channel"
             ))
-                        .execute(conn)?;
+        }
-                    insert_into(email_channels::table)
+    }
-                        .values(email_channels::id.eq(id.clone()))
+}
-                        .execute(conn)?;
+
-                    Self::all().filter(Self::with_id(id)).first(conn)
+impl Into<BackendConfig> for EmailBackendConfig {
-                })
+    fn into(self) -> BackendConfig {
-            })
+        BackendConfig::Email(self)
-            .await
+    }
-            .unwrap()
+}
-            .context("Failed to insert new EmailChannel.")
+
-            .map_err(|err| err.into())
+#[derive(Clone, Debug, Deserialize, Serialize)]
+pub struct SlackBackendConfig {
+    pub oauth_state: String,
+    pub access_token: String,
+    pub refresh_token: String,
+    pub conversation_id: String,
+}
+
+impl TryFrom<BackendConfig> for SlackBackendConfig {
+    type Error = anyhow::Error;
+
+    fn try_from(value: BackendConfig) -> Result<Self, Self::Error> {
+        if let BackendConfig::Slack(config) = value {
+            Ok(config)
+        } else {
+            Err(anyhow::anyhow!(
+                "could not load backend config as slack channel"
+            ))
+        }
+    }
+}
+
+impl Into<BackendConfig> for SlackBackendConfig {
+    fn into(self) -> BackendConfig {
+        BackendConfig::Slack(self)
     }
 }

src/messages.rs

@@ -6,14 +6,14 @@ use diesel::{
 };
 use uuid::Uuid;
 
-use crate::{projects::Project, schema::messages};
+use crate::{channels::Channel, schema::messages};
 
 #[derive(Associations, Clone, Debug, Identifiable, Queryable, Selectable)]
 #[diesel(table_name = messages)]
-#[diesel(belongs_to(Project))]
+#[diesel(belongs_to(Channel))]
 pub struct Message {
     pub id: Uuid,
-    pub project_id: Uuid,
+    pub channel_id: Uuid,
     pub created_at: DateTime<Utc>,
     pub message: String,
 }
@@ -26,17 +26,7 @@ impl Message {
     }
 
     #[auto_type(no_type_alias)]
-    pub fn with_project(project_id: Uuid) -> _ {
+    pub fn with_channel(channel_id: Uuid) -> _ {
-        messages::project_id.eq(project_id)
+        messages::channel_id.eq(channel_id)
-    }
-
-    #[auto_type(no_type_alias)]
-    pub fn values_now(project_id: Uuid, message: String) -> _ {
-        let id: Uuid = Uuid::now_v7();
-        (
-            messages::id.eq(id),
-            messages::project_id.eq(project_id),
-            messages::message.eq(message),
-        )
     }
 }

src/projects.rs

@@ -7,7 +7,7 @@ use uuid::Uuid;
 
 use crate::{
     channels::Channel,
-    schema::{channel_selections, channels, email_channels, projects, slack_channels},
+    schema::{channel_selections, channels, projects},
     teams::Team,
 };
 
@@ -48,8 +48,6 @@ impl Project {
         let project_filter: Eq<channel_selections::project_id, Uuid> =
             channel_selections::project_id.eq(self.id);
         channels::table
-            .left_join(email_channels::table)
-            .left_join(slack_channels::table)
             .inner_join(channel_selections::table)
             .filter(project_filter)
             .select(select)

src/router.rs

@@ -27,13 +27,13 @@ use crate::{
     app_state::{AppState, DbConn},
     auth,
     channel_selections::ChannelSelection,
-    channels::Channel,
+    channels::{BackendConfig, Channel, EmailBackendConfig, CHANNEL_BACKEND_EMAIL},
     csrf::generate_csrf_token,
     email::{MailSender as _, Mailer},
     guards,
     nav_state::{Breadcrumb, NavState},
     projects::Project,
-    schema::{self, channel_selections, channels, email_channels},
+    schema::{self, channel_selections, channels},
     settings::Settings,
     team_memberships::TeamMembership,
     teams::Team,
@@ -41,6 +41,9 @@ use crate::{
     v0_router,
 };
 
+const VERIFICATION_CODE_LEN: usize = 6;
+const MAX_VERIFICATION_GUESSES: u32 = 100;
+
 pub fn new_router(state: AppState) -> Router<()> {
     let base_path = state.settings.base_path.clone();
     Router::new().nest(
@@ -107,7 +110,7 @@ async fn teams_page(
         .set_base_path(&base_path)
         .push_slug(Breadcrumb {
             href: "teams".to_string(),
-            label: "New Team".to_string(),
+            label: "Teams".to_string(),
         })
         .set_navbar_active_item("teams");
     #[derive(Template)]
@@ -339,8 +342,24 @@ async fn post_new_channel(
     let team = guards::require_team_membership(&current_user, &team_id, &db_conn).await?;
     guards::require_valid_csrf_token(&form_body.csrf_token, &current_user, &db_conn).await?;
 
+    let channel_id = Uuid::now_v7();
     let channel = match form_body.channel_type.as_str() {
-        "email" => Channel::create_email_channel(&db_conn, team.id.clone()).await?,
+        CHANNEL_BACKEND_EMAIL => db_conn
+            .interact::<_, Result<Channel, AppError>>(move |conn| {
+                Ok(insert_into(channels::table)
+                    .values((
+                        channels::id.eq(channel_id),
+                        channels::team_id.eq(team_id),
+                        channels::name.eq("Untitled Email Channel"),
+                        channels::backend_config
+                            .eq(Into::<BackendConfig>::into(EmailBackendConfig::default())),
+                    ))
+                    .returning(Channel::as_returning())
+                    .get_result(conn)
+                    .context("Failed to insert new EmailChannel.")?)
+            })
+            .await
+            .unwrap()?,
         _ => {
             return Err(AppError::BadRequestError(
                 "Channel type not recognized.".to_string(),
@@ -399,7 +418,8 @@ async fn channel_page(
         })
         .set_navbar_active_item("channels");
 
-    if channel.email_data.is_some() {
+    match channel.backend_config {
+        BackendConfig::Email(_) => {
             #[derive(Template)]
             #[template(path = "channel-email.html")]
             struct ResponseTemplate {
@@ -417,13 +437,10 @@ async fn channel_page(
                 }
                 .render()?,
             ))
-    } else if channel.slack_data.is_some() {
+        }
+        BackendConfig::Slack(_) => {
             Err(anyhow::anyhow!("Slack channel config page is not yet implemented.").into())
-    } else {
+        }
-        Err(anyhow::anyhow!(
-            "Channel doesn't have a recognized variant for which to render a config page."
-        )
-        .into())
     }
 }
 
@@ -473,6 +490,28 @@ async fn update_channel(
     .into_response())
 }
 
+/**
+ * Helper function to query a channel from the database by ID and team, and
+ * return an appropriate error if no such channel exists.
+ */
+fn get_channel_by_params(
+    conn: &mut PgConnection,
+    team_id: Uuid,
+    channel_id: Uuid,
+) -> Result<Channel, AppError> {
+    match Channel::all()
+        .filter(Channel::with_id(channel_id))
+        .filter(Channel::with_team(team_id))
+        .first(conn)
+    {
+        diesel::QueryResult::Err(diesel::result::Error::NotFound) => Err(AppError::NotFoundError(
+            "Channel with that team and ID not found.".to_string(),
+        )),
+        diesel::QueryResult::Err(err) => Err(err.into()),
+        diesel::QueryResult::Ok(channel) => Ok(channel),
+    }
+}
+
 #[derive(Deserialize)]
 struct UpdateChannelEmailRecipientFormBody {
     // Yes it's a mouthful, but it's only used twice
@@ -503,49 +542,41 @@ async fn update_channel_email_recipient(
 
     let verification_code: String = rand::thread_rng()
         .sample_iter(&Uniform::try_from(0..9).unwrap())
-        .take(6)
+        .take(VERIFICATION_CODE_LEN)
         .map(|n| n.to_string())
         .collect();
 
-    let verification_code_copy = verification_code.clone();
-    let recipient_copy = form_body.recipient.clone();
-
-    let channel_id_filter = Channel::with_id(channel_id.clone());
-    let email_channel_id_filter = email_channels::id.eq(channel_id.clone());
-    let team_filter = Channel::with_team(team_id.clone());
-    let updated_rows = db_conn
-        .interact(move |conn| {
-            if Channel::all()
-                .filter(channel_id_filter)
-                .filter(team_filter)
-                .filter(email_channel_id_filter.clone())
-                .first(conn)
-                .optional()
-                .context("failed to check whether channel exists under team")
-                .map_err(Into::<AppError>::into)?
-                .is_none()
     {
-                return Err(AppError::NotFoundError(
+        let verification_code = verification_code.clone();
-                    "Channel with that team and ID not found.".to_string(),
+        let recipient = form_body.recipient.clone();
-                ));
+        let channel_id = channel_id.clone();
+        let team_id = team_id.clone();
+        db_conn
+            .interact(move |conn| {
+                // TODO: transaction retries
+                conn.transaction::<_, AppError, _>(move |conn| {
+                    let channel = get_channel_by_params(conn, team_id, channel_id)?;
+                    let new_config = BackendConfig::Email(EmailBackendConfig {
+                        recipient,
+                        verification_code,
+                        verification_code_guesses: 0,
+                        ..channel.backend_config.try_into()?
+                    });
+                    let num_rows = update(channels::table.filter(Channel::with_id(channel.id)))
+                        .set(channels::backend_config.eq(new_config))
+                        .execute(conn)?;
+                    if num_rows != 1 {
+                        return Err(anyhow!(
+                            "Updating EmailChannel recipient, the channel was found but {} rows were updated.",
+                            num_rows
+                        )
+                        .into());
                     }
-            update(email_channels::table.filter(email_channel_id_filter))
+                    Ok(())
-                .set((
+                })
-                    email_channels::recipient.eq(recipient_copy),
-                    email_channels::verification_code.eq(verification_code_copy),
-                    email_channels::verification_code_guesses.eq(0),
-                ))
-                .execute(conn)
-                .map_err(Into::<AppError>::into)
             })
             .await
             .unwrap()?;
-    if updated_rows != 1 {
-        return Err(anyhow!(
-            "Updating EmailChannel recipient, the channel was found but {} rows were updated.",
-            updated_rows
-        )
-        .into());
     }
 
     tracing::debug!(
@@ -600,48 +631,54 @@ async fn verify_email(
     guards::require_valid_csrf_token(&form_body.csrf_token, &current_user, &db_conn).await?;
     guards::require_team_membership(&current_user, &team_id, &db_conn).await?;
 
-    let channel_id_filter = Channel::with_id(channel_id.clone());
+    if form_body.code.len() != VERIFICATION_CODE_LEN {
-    let email_channel_id_filter = email_channels::id.eq(channel_id.clone());
+        return Err(AppError::BadRequestError(format!(
-    let team_filter = Channel::with_team(team_id.clone());
+            "Verification code must be {} characters long.",
-    let updated_rows = db_conn
+            VERIFICATION_CODE_LEN
-        .interact(move |conn| {
+        )));
-            if Channel::all()
+    }
-                .filter(channel_id_filter)
+
-                .filter(team_filter)
-                .filter(email_channel_id_filter.clone())
-                .first(conn)
-                .optional()
-                .context("failed to check whether channel exists under team")
-                .map_err(Into::<AppError>::into)?
-                .is_none()
     {
-                return Err(AppError::NotFoundError(
+        let channel_id = channel_id.clone();
-                    "Channel with that team and ID not found.".to_string(),
+        let team_id = team_id.clone();
+        let verification_code = form_body.code;
+        db_conn
+            .interact(move |conn| {
+                conn.transaction::<(), AppError, _>(move |conn| {
+                    let channel = get_channel_by_params(conn, team_id, channel_id)?;
+                    let config: EmailBackendConfig = channel.backend_config.try_into()?;
+                    if config.verified {
+                        return Err(AppError::BadRequestError(
+                            "Channel's email address is already verified.".to_string(),
                         ));
                     }
-            update(email_channels::table.filter(email_channel_id_filter))
+                    if config.verification_code_guesses > MAX_VERIFICATION_GUESSES {
-                .set(
+                        return Err(AppError::BadRequestError(
-                    email_channels::verification_code_guesses
+                            "Verification expired.".to_string(),
-                        .eq(email_channels::verification_code_guesses + 1),
+                        ));
-                )
+                    }
-                .execute(conn)
+                    let new_config = if config.verification_code == verification_code {
-                .map_err(Into::<AppError>::into)?;
+                        EmailBackendConfig {
-            update(
+                            verified: true,
-                email_channels::table
+                            verification_code: "".to_string(),
-                    .filter(email_channel_id_filter)
+                            verification_code_guesses: 0,
-                    .filter(email_channels::verification_code.eq(form_body.code)),
+                            ..config
-            )
+                        }
-            .set(email_channels::verified.eq(true))
+                    } else {
-            .execute(conn)
+                        EmailBackendConfig {
-            .map_err(Into::<AppError>::into)
+                            verification_code_guesses: config.verification_code_guesses + 1,
+                            ..config
+                        }
+                    };
+                    update(channels::table.filter(Channel::with_id(channel_id)))
+                        .set(channels::backend_config.eq(Into::<BackendConfig>::into(new_config)))
+                        .execute(conn)?;
+                    Ok(())
+                })
             })
             .await
             .unwrap()?;
-    if updated_rows != 1 {
+    };
-        return Err(AppError::BadRequestError(
-            "Verification code not accepted.".to_string(),
-        ));
-    }
 
     Ok(Redirect::to(&format!(
         "{}/teams/{}/channels/{}",

src/schema.rs

@@ -31,6 +31,7 @@ diesel::table! {
         team_id -> Uuid,
         name -> Text,
         enable_by_default -> Bool,
+        backend_config -> Jsonb,
     }
 }
 
@@ -42,21 +43,12 @@ diesel::table! {
     }
 }
 
-diesel::table! {
-    email_channels (id) {
-        id -> Uuid,
-        recipient -> Text,
-        verification_code -> Text,
-        verification_code_guesses -> Int4,
-        verified -> Bool,
-    }
-}
-
 diesel::table! {
     messages (id) {
         id -> Uuid,
-        project_id -> Uuid,
+        channel_id -> Uuid,
         created_at -> Timestamptz,
+        sent_at -> Nullable<Timestamptz>,
         message -> Text,
     }
 }
@@ -69,15 +61,6 @@ diesel::table! {
     }
 }
 
-diesel::table! {
-    slack_channels (id) {
-        id -> Uuid,
-        oauth_state -> Text,
-        access_token -> Text,
-        conversation_id -> Text,
-    }
-}
-
 diesel::table! {
     team_memberships (team_id, user_id) {
         team_id -> Uuid,
@@ -106,10 +89,8 @@ diesel::joinable!(channel_selections -> channels (channel_id));
 diesel::joinable!(channel_selections -> projects (project_id));
 diesel::joinable!(channels -> teams (team_id));
 diesel::joinable!(csrf_tokens -> users (user_id));
-diesel::joinable!(email_channels -> channels (id));
+diesel::joinable!(messages -> channels (channel_id));
-diesel::joinable!(messages -> projects (project_id));
 diesel::joinable!(projects -> teams (team_id));
-diesel::joinable!(slack_channels -> channels (id));
 diesel::joinable!(team_memberships -> teams (team_id));
 diesel::joinable!(team_memberships -> users (user_id));
 
@@ -119,10 +100,8 @@ diesel::allow_tables_to_appear_in_same_query!(
     channel_selections,
     channels,
     csrf_tokens,
-    email_channels,
     messages,
     projects,
-    slack_channels,
     team_memberships,
     teams,
     users,

src/v0_router.rs

@@ -14,6 +14,7 @@ use crate::{
     api_keys::ApiKey,
     app_error::AppError,
     app_state::{AppState, DbConn},
+    channels::{Channel, EmailBackendConfig},
     email::{MailSender as _, Mailer},
     projects::Project,
     schema::{api_keys, projects},
@@ -40,56 +41,59 @@ async fn say_get(
     DbConn(db_conn): DbConn,
     Query(query): Query<SayQuery>,
 ) -> Result<impl IntoResponse, AppError> {
-    let key = query.key.clone();
+    // TODO: do some validation of message contents
-    let maybe_api_key = db_conn
+    let api_key = {
-        .interact(move |conn| {
+        let query_key = query.key.clone();
-            update(api_keys::table.filter(ApiKey::with_id(key)))
+        db_conn
+            .interact::<_, Result<ApiKey, AppError>>(move |conn| {
+                update(api_keys::table.filter(ApiKey::with_id(query_key)))
                     .set(api_keys::last_used_at.eq(diesel::dsl::now))
                     .returning(ApiKey::as_returning())
                     .get_result(conn)
                     .optional()
+                    .context("failed to get API key")?
+                    .ok_or(AppError::ForbiddenError("Key not accepted.".to_string()))
             })
             .await
-        .unwrap()
+            .unwrap()?
-        .context("unable to get API key")?;
-    let api_key = match maybe_api_key {
-        Some(api_key) => api_key,
-        None => return Err(AppError::ForbiddenError("key not accepted".to_string())),
     };
+
+    let selected_channels = {
         let project_name = query.project.to_lowercase();
-    let selected_channels = db_conn
+        db_conn
-        .interact(move |conn| {
+            .interact::<_, Result<Vec<Channel>, AppError>>(move |conn| {
-            insert_into(projects::table)
+                conn.transaction(move |conn| {
+                    let project = match Project::all()
+                        .filter(Project::with_team(api_key.team_id))
+                        .filter(Project::with_name(project_name.clone()))
+                        .first(conn)
+                        .optional()
+                        .context("failed to load project")?
+                    {
+                        Some(project) => project,
+                        None => insert_into(projects::table)
                             .values((
                                 projects::id.eq(Uuid::now_v7()),
-                    projects::team_id.eq(api_key.team_id.clone()),
+                                projects::team_id.eq(api_key.team_id),
-                    projects::name.eq(project_name.clone()),
+                                projects::name.eq(project_name),
                             ))
-                .on_conflict((projects::team_id, projects::name))
+                            .get_result(conn)
-                .do_nothing()
+                            .context("failed to insert project")?,
-                .execute(conn)
+                    };
-                .context("failed to insert project")?;
+                    Ok(project
-            // It would be nice to merge these two database operations into one,
-            // but it's not trivial to do so without faking an update; refer to:
-            // https://stackoverflow.com/a/42217872
-            let project = Project::all()
-                .filter(Project::with_team(api_key.team_id))
-                .filter(Project::with_name(project_name))
-                .first(conn)
-                .context("failed to load project")?;
-            project
                         .selected_channels()
                         .load(conn)
-                .context("failed to load selected channels")
+                        .context("failed to load selected channels")?)
+                })
             })
             .await
-        .unwrap()
+            .unwrap()?
-        .context("unable to get project")?;
+    };
 
     for channel in selected_channels {
-        if let Some(email_data) = channel.email_data {
+        if let Ok(config) = TryInto::<EmailBackendConfig>::try_into(channel.backend_config) {
-            if email_data.verified {
+            if config.verified {
-                let recipient: lettre::message::Mailbox = email_data.recipient.parse()?;
+                let recipient: lettre::message::Mailbox = config.recipient.parse()?;
                 let email = crate::email::Message {
                     from: email_settings.message_from.clone().into(),
                     to: recipient.into(),

templates/channel-email.html

@@ -3,7 +3,7 @@
 {% block title %}Shout.dev: Channels{% endblock %}
 
 {% block main %}
-{% let email_data = channel.email_data.clone().unwrap() %}
+{% if let BackendConfig::Email(email_data) = channel.backend_config %}
   {% include "breadcrumbs.html" %}
   <main class="container mt-5">
     <section class="mb-4">
@@ -122,4 +122,5 @@
       </section>
     {% endif %}
   </main>
+{% endif %}
 {% endblock %}