Fault-tolerant delivery system

src/routes/admin/html/send_newsletter_form.html

@@ -10,6 +10,7 @@
       <input type="text" name="title" placeholder="Subject" />
       <input type="text" name="html" placeholder="Content (HTML)" />
       <input type="text" name="text" placeholder="Content (text)" />
+      <input hidden type="text" name="idempotency_key" value="{}" />
       <button type="submit">Send</button>
     </form>
     {}

src/routes/admin/newsletters.rs

@@ -1,75 +1,136 @@
-use crate::{domain::SubscriberEmail, routes::AdminError, startup::AppState};
+use crate::{
+    authentication::AuthenticatedUser,
+    idempotency::{IdempotencyKey, save_response, try_processing},
+    routes::AdminError,
+    startup::AppState,
+};
 use anyhow::Context;
 use axum::{
-    Form,
+    Extension, Form,
     extract::State,
     response::{Html, IntoResponse, Redirect, Response},
 };
 use axum_messages::Messages;
-use sqlx::PgPool;
+use sqlx::{Executor, Postgres, Transaction};
 use std::fmt::Write;
+use uuid::Uuid;
 
 #[derive(serde::Deserialize)]
 pub struct BodyData {
     title: String,
     html: String,
     text: String,
+    idempotency_key: String,
 }
 
-pub async fn publish_form(messages: Messages) -> Response {
+pub async fn publish_newsletter_form(messages: Messages) -> Response {
     let mut error_html = String::new();
     for message in messages {
         writeln!(error_html, "<p><i>{}</i></p>", message).unwrap();
     }
+    let idempotency_key = Uuid::new_v4();
     Html(format!(
         include_str!("html/send_newsletter_form.html"),
-        error_html
+        idempotency_key, error_html
     ))
     .into_response()
 }
 
+#[tracing::instrument(skip_all)]
+pub async fn insert_newsletter_issue(
+    transaction: &mut Transaction<'static, Postgres>,
+    title: &str,
+    text_content: &str,
+    html_content: &str,
+) -> Result<Uuid, sqlx::Error> {
+    let newsletter_issue_id = Uuid::new_v4();
+    let query = sqlx::query!(
+        r#"
+        INSERT INTO newsletter_issues (
+            newsletter_issue_id, title, text_content, html_content, published_at
+        )
+        VALUES ($1, $2, $3, $4, now())
+        "#,
+        newsletter_issue_id,
+        title,
+        text_content,
+        html_content
+    );
+    transaction.execute(query).await?;
+    Ok(newsletter_issue_id)
+}
+
+#[tracing::instrument(skip_all)]
+async fn enqueue_delivery_tasks(
+    transaction: &mut Transaction<'static, Postgres>,
+    newsletter_issue_id: Uuid,
+) -> Result<(), sqlx::Error> {
+    let query = sqlx::query!(
+        r#"
+        INSERT INTO issue_delivery_queue (
+            newsletter_issue_id,
+            subscriber_email
+        )
+        SELECT $1, email
+        FROM subscriptions
+        WHERE status = 'confirmed'
+        "#,
+        newsletter_issue_id,
+    );
+    transaction.execute(query).await?;
+    Ok(())
+}
+
 #[tracing::instrument(
     name = "Publishing a newsletter",
-    skip(connection_pool, email_client, form)
+    skip(connection_pool, form, messages)
 )]
-pub async fn publish(
+pub async fn publish_newsletter(
     State(AppState {
-        connection_pool,
-        email_client,
-        ..
+        connection_pool, ..
     }): State<AppState>,
+    Extension(AuthenticatedUser { user_id, .. }): Extension<AuthenticatedUser>,
     messages: Messages,
     Form(form): Form<BodyData>,
 ) -> Result<Response, AdminError> {
     if let Err(e) = validate_form(&form) {
         messages.error(e);
-        return Err(AdminError::Publish);
+        return Err(AdminError::Publish(anyhow::anyhow!(e)));
     }
-    let subscribers = get_confirmed_subscribers(&connection_pool).await?;
-    for subscriber in subscribers {
-        match subscriber {
-            Ok(ConfirmedSubscriber { name, email }) => {
-                let title = format!("{}, we have news for you! {}", name, form.title);
-                email_client
-                    .send_email(&email, &title, &form.html, &form.text)
-                    .await
-                    .with_context(|| {
-                        format!("Failed to send newsletter issue to {}", email.as_ref())
-                    })?;
-            }
-            Err(e) => {
-                tracing::warn!(
-                    "Skipping a confirmed subscriber. Their stored contact details are invalid: {}",
-                    e
-                )
-            }
+
+    let idempotency_key: IdempotencyKey = form
+        .idempotency_key
+        .try_into()
+        .map_err(AdminError::Idempotency)?;
+
+    let success_message = || {
+        messages.success(format!(
+            "The newsletter issue '{}' has been published!",
+            form.title
+        ))
+    };
+
+    let mut transaction = match try_processing(&connection_pool, &idempotency_key, user_id).await? {
+        crate::idempotency::NextAction::StartProcessing(t) => t,
+        crate::idempotency::NextAction::ReturnSavedResponse(response) => {
+            success_message();
+            return Ok(response);
         }
-    }
-    messages.success(format!(
-        "The newsletter issue '{}' has been published!",
-        form.title,
-    ));
-    Ok(Redirect::to("/admin/newsletters").into_response())
+    };
+
+    let issue_id = insert_newsletter_issue(&mut transaction, &form.title, &form.text, &form.html)
+        .await
+        .context("Failed to store newsletter issue details")?;
+
+    enqueue_delivery_tasks(&mut transaction, issue_id)
+        .await
+        .context("Failed to enqueue delivery tasks")?;
+
+    let response = Redirect::to("/admin/newsletters").into_response();
+    success_message();
+    save_response(transaction, &idempotency_key, user_id, response)
+        .await
+        .map_err(AdminError::UnexpectedError)
 }
 
 fn validate_form(form: &BodyData) -> Result<(), &'static str> {
@@ -82,27 +143,27 @@ fn validate_form(form: &BodyData) -> Result<(), &'static str> {
     Ok(())
 }
 
-struct ConfirmedSubscriber {
-    name: String,
-    email: SubscriberEmail,
-}
+// struct ConfirmedSubscriber {
+//     name: String,
+//     email: SubscriberEmail,
+// }
 
-#[tracing::instrument(name = "Get confirmed subscribers", skip(connection_pool))]
-async fn get_confirmed_subscribers(
-    connection_pool: &PgPool,
-) -> Result<Vec<Result<ConfirmedSubscriber, anyhow::Error>>, anyhow::Error> {
-    let rows = sqlx::query!("SELECT name, email FROM subscriptions WHERE status = 'confirmed'")
-        .fetch_all(connection_pool)
-        .await?;
-    let confirmed_subscribers = rows
-        .into_iter()
-        .map(|r| match SubscriberEmail::parse(r.email) {
-            Ok(email) => Ok(ConfirmedSubscriber {
-                name: r.name,
-                email,
-            }),
-            Err(e) => Err(anyhow::anyhow!(e)),
-        })
-        .collect();
-    Ok(confirmed_subscribers)
-}
+// #[tracing::instrument(name = "Get confirmed subscribers", skip(connection_pool))]
+// async fn get_confirmed_subscribers(
+//     connection_pool: &PgPool,
+// ) -> Result<Vec<Result<ConfirmedSubscriber, anyhow::Error>>, anyhow::Error> {
+//     let rows = sqlx::query!("SELECT name, email FROM subscriptions WHERE status = 'confirmed'")
+//         .fetch_all(connection_pool)
+//         .await?;
+//     let confirmed_subscribers = rows
+//         .into_iter()
+//         .map(|r| match SubscriberEmail::parse(r.email) {
+//             Ok(email) => Ok(ConfirmedSubscriber {
+//                 name: r.name,
+//                 email,
+//             }),
+//             Err(e) => Err(anyhow::anyhow!(e)),
+//         })
+//         .collect();
+//     Ok(confirmed_subscribers)
+// }