mod.rs 84.0%

89 of 106 lines run, 17 of 32 functions · run #471 on main · run missed

//! Notifications (hub spec §10): who to tell about an event, the inbox
//! row, and email when the account asked for it and SMTP is configured.

use crate::db::{self, accounts::Account, notify as ndb};
use crate::Shared;
use std::collections::BTreeSet;

tokio::task_local! {
    /// The name of the agent-marked token this request came with, if any
    /// (oxygenhub#183): what an agent does with it is told to the token's
    /// owner too, though the owner is the actor.
    pub static AGENT: Option<String>;
}

/// The agent token acting now, when there is one.
pub fn agent_acting() -> Option<String> {
    AGENT.try_with(|a| a.clone()).ok().flatten()
}

/// An event worth telling people about.
pub struct Event<'a> {
    pub kind: &'a str,
    pub title: String,
    pub url: String,
    pub actor: &'a Account,
    pub repo_id: i64,
    /// `issue` or `proposal` and its id, for thread subscribers.
    pub thread: Option<(&'a str, i64)>,
    /// Bodies to scan for `@mentions`.
    pub mention_text: &'a str,
    /// Accounts to tell whatever their subscriptions (author, assignees).
    pub direct: Vec<i64>,
}

/// `@username` tokens in a text, unique.
pub fn mentions(text: &str) -> Vec<String> {
    let re = regex::Regex::new(r"(?:^|[^\w/])@([A-Za-z0-9][A-Za-z0-9._-]{0,63})").unwrap();
    let mut out = BTreeSet::new();
    for c in re.captures_iter(text) {
        out.insert(c[1].trim_end_matches('.').to_string());
    }
    out.into_iter().collect()
}

/// Deliver an event: subscribers of the thread, watchers of the
/// repository, mentioned accounts and direct targets, never the actor.
pub async fn deliver(app: &Shared, ev: Event<'_>) {
    let pool = &app.db;
    // Participants: the thread's subscribers, the mentioned, direct targets.
    // Watchers of the repository who are none of those are only watching.
    let mut participants: BTreeSet<i64> = BTreeSet::new();
    if let Some((kind, id)) = ev.thread {
        if let Ok(subs) = ndb::subscribers(pool, kind, id).await {
            participants.extend(subs);
        }
        // Acting on a thread subscribes the actor to it.
        ndb::subscribe(pool, ev.actor.id, kind, id).await.ok();
    }
    for name in mentions(ev.mention_text) {
        if let Ok(Some(a)) = db::accounts::account_by_name(pool, &name).await {
            participants.insert(a.id);
        }
    }
    participants.extend(ev.direct.iter().copied());
    let mut targets: Vec<(i64, ndb::Reason)> = participants.iter().map(|id| (*id, ndb::Reason::Participating)).collect();
    if let Ok(w) = ndb::watchers(pool, ev.repo_id).await {
        targets.extend(w.into_iter().filter(|id| !participants.contains(id)).map(|id| (id, ndb::Reason::Watching)));
    }
    // Never the actor, unless an agent acted with their token: then they
    // hear what their agent did.
    let agent = agent_acting();
    if agent.is_none() {
        targets.retain(|(id, _)| *id != ev.actor.id);
    }
    let actor = match &agent {
        Some(token) => format!("{} (agent token {token})", ev.actor.username),
        None => ev.actor.username.clone(),
    };
    tell(app, ev.kind, &ev.title, &ev.url, &actor, (ev.repo_id > 0).then_some(ev.repo_id), targets).await;
}

/// Tell each of `targets` about something: an inbox row, and an email
/// where the account asked for them and has proven its address.
pub async fn tell(app: &Shared, kind: &str, title: &str, url: &str, actor: &str, repo_id: Option<i64>, targets: Vec<(i64, ndb::Reason)>) {
    let pool = &app.db;
    for (id, reason) in targets {
        ndb::add(pool, ndb::New { account_id: id, repo_id, reason, kind, title, url, actor }).await.ok();
        app.bus.live(&crate::events::topic::user(id), "notification");
        if let Ok(Some(a)) = db::accounts::account_by_id(pool, id).await {
            // Only to addresses the account has proven it reads (hub spec §5.1.1).
            if a.email_notifications && a.email_verified && !a.email.is_empty() && crate::mail::enabled(app) {
                email(app, &a, kind, title, url, actor).await;
            }
        }
    }
}

/// What a kind of notification is called in an email's subject, with its
/// emoji, so a glance at the inbox says what happened (Andy, 2026-10-14).
pub fn label(kind: &str) -> Option<&'static str> {
    Some(match kind {
        "flow.failed" => "💥 Build Broken",
        "flow.fixed" => "🎉 Build Success",
        "flow.runner_drained" => "🛑 Runner Drained",
        "backup" => "⚠️ Backup Failed",
        "backup.recovered" => "✅ Backup Recovered",
        "backup.summary" => "📦 Daily Backup Summary",
        "proposal.opened" => "🔀 New Proposal",
        "proposal.review_requested" => "👀 Review Requested",
        "proposal.review" => "📝 New Review",
        "proposal.landed" => "🚀 Proposal Landed",
        "proposal.comment" | "issue.comment" | "drop.comment" => "💬 New Comment",
        "issue.opened" => "🐛 New Issue",
        "issue.assigned" => "📌 Issue Assigned",
        "issue.closed" => "✔️ Issue Closed",
        "account.registered" => "👋 New Sign-up",
        _ => return None,
    })
}

/// A notification's email subject: its label, then what happened.
pub fn subject(kind: &str, title: &str) -> String {
    match label(kind) {
        Some(l) => format!("{l}: {title}"),
        None => title.to_string(),
    }
}

async fn email(app: &Shared, to: &Account, kind: &str, title: &str, url: &str, actor: &str) {
    let unsubscribe = format!("{}/settings/notifications?unsubscribe={}", app.config.base_url(), to.unsubscribe_key);
    let link = format!("{}{url}", app.config.base_url());
    let body = format!("{actor}: {title}\n\n{link}\n\nStop these emails: {unsubscribe}\n");
    let action = crate::mail::Action { label: "Open it", url: &link };
    let subject = subject(kind, title);
    if let Err(e) = crate::mail::send_letter(app, to.name(), &to.email, &subject, &body, Some(action), Some(&unsubscribe)).await {
        tracing::warn!("email to {}: {e}", to.email);
        // Sent again from the work queue (#276), when mail is on at all.
        if crate::mail::enabled(app) {
            crate::queue::queue_mail(app, to.name(), &to.email, &subject, &body, Some(("Open it", &link)), Some(&unsubscribe)).await;
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn subjects_say_what_happened() {
        assert_eq!(
            subject("flow.failed", "andy/demo: run #4 on main failed (test)"),
            "💥 Build Broken: andy/demo: run #4 on main failed (test)"
        );
        assert_eq!(
            subject("flow.fixed", "andy/demo: run #5 on main passed: fixed"),
            "🎉 Build Success: andy/demo: run #5 on main passed: fixed"
        );
        assert_eq!(subject("backup.summary", "x"), "📦 Daily Backup Summary: x");
        assert_eq!(subject("something.new", "x"), "x", "a kind without a label keeps its title");
    }

    #[test]
    fn finds_mentions() {
        assert_eq!(mentions("cc @andy and @bob. not an email [email protected], nor /@path"), vec!["andy", "bob"]);
        assert!(mentions("nothing here").is_empty());
    }
}

1		//! Notifications (hub spec §10): who to tell about an event, the inbox
2		//! row, and email when the account asked for it and SMTP is configured.
3
4		use crate::db::{self, accounts::Account, notify as ndb};
5		use crate::Shared;
6		use std::collections::BTreeSet;
7
8		tokio::task_local! {
9		/// The name of the agent-marked token this request came with, if any
10		/// (oxygenhub#183): what an agent does with it is told to the token's
11		/// owner too, though the owner is the actor.
12		pub static AGENT: Option<String>;
13		}
14
15		/// The agent token acting now, when there is one.
16	112×	pub fn agent_acting() -> Option<String> {
17	112×	AGENT.try_with(\|a\| a.clone()).ok().flatten()
18	112×	}
19
20		/// An event worth telling people about.
21		pub struct Event<'a> {
22		pub kind: &'a str,
23		pub title: String,
24		pub url: String,
25		pub actor: &'a Account,
26		pub repo_id: i64,
27		/// `issue` or `proposal` and its id, for thread subscribers.
28		pub thread: Option<(&'a str, i64)>,
29		/// Bodies to scan for `@mentions`.
30		pub mention_text: &'a str,
31		/// Accounts to tell whatever their subscriptions (author, assignees).
32		pub direct: Vec<i64>,
33		}
34
35		/// `@username` tokens in a text, unique.
36	114×	pub fn mentions(text: &str) -> Vec<String> {
37	114×	let re = regex::Regex::new(r"(?:^\|[^\w/])@([A-Za-z0-9][A-Za-z0-9._-]{0,63})").unwrap();
38	114×	let mut out = BTreeSet::new();
39	114×	for c in re.captures_iter(text) {
40	3×	out.insert(c[1].trim_end_matches('.').to_string());
41	3×	}
42	114×	out.into_iter().collect()
43	114×	}
44
45		/// Deliver an event: subscribers of the thread, watchers of the
46		/// repository, mentioned accounts and direct targets, never the actor.
47	112×	pub async fn deliver(app: &Shared, ev: Event<'_>) {
48	112×	let pool = &app.db;
49		// Participants: the thread's subscribers, the mentioned, direct targets.
50		// Watchers of the repository who are none of those are only watching.
51	112×	let mut participants: BTreeSet<i64> = BTreeSet::new();
52	112×	if let Some((kind, id)) = ev.thread {
53	90×	if let Ok(subs) = ndb::subscribers(pool, kind, id).await {
54	90×	participants.extend(subs);
55	90×	}
56		// Acting on a thread subscribes the actor to it.
57	90×	ndb::subscribe(pool, ev.actor.id, kind, id).await.ok();
58	22×	}
59	112×	for name in mentions(ev.mention_text) {
60	1×	if let Ok(Some(a)) = db::accounts::account_by_name(pool, &name).await {
61	1×	participants.insert(a.id);
62	1×	}
63		}
64	112×	participants.extend(ev.direct.iter().copied());
65	112×	let mut targets: Vec<(i64, ndb::Reason)> = participants.iter().map(\|id\| (*id, ndb::Reason::Participating)).collect();
66	112×	if let Ok(w) = ndb::watchers(pool, ev.repo_id).await {
67	118×	targets.extend(w.into_iter().filter(\|id\| !participants.contains(id)).map(\|id\| (id, ndb::Reason::Watching)));
68	0×	}
69		// Never the actor, unless an agent acted with their token: then they
70		// hear what their agent did.
71	112×	let agent = agent_acting();
72	112×	if agent.is_none() {
73	125×	targets.retain(\|(id, _)\| *id != ev.actor.id);
74	3×	}
75	112×	let actor = match &agent {
76	3×	Some(token) => format!("{} (agent token {token})", ev.actor.username),
77	109×	None => ev.actor.username.clone(),
78		};
79	112×	tell(app, ev.kind, &ev.title, &ev.url, &actor, (ev.repo_id > 0).then_some(ev.repo_id), targets).await;
80	112×	}
81
82		/// Tell each of `targets` about something: an inbox row, and an email
83		/// where the account asked for them and has proven its address.
84	159×	pub async fn tell(app: &Shared, kind: &str, title: &str, url: &str, actor: &str, repo_id: Option<i64>, targets: Vec<(i64, ndb::Reason)>) {
85	159×	let pool = &app.db;
86	159×	for (id, reason) in targets {
87	101×	ndb::add(pool, ndb::New { account_id: id, repo_id, reason, kind, title, url, actor }).await.ok();
88	101×	app.bus.live(&crate::events::topic::user(id), "notification");
89	101×	if let Ok(Some(a)) = db::accounts::account_by_id(pool, id).await {
90		// Only to addresses the account has proven it reads (hub spec §5.1.1).
91	101×	if a.email_notifications && a.email_verified && !a.email.is_empty() && crate::mail::enabled(app) {
92	0×	email(app, &a, kind, title, url, actor).await;
93	101×	}
94	0×	}
95		}
96	159×	}
97
98		/// What a kind of notification is called in an email's subject, with its
99		/// emoji, so a glance at the inbox says what happened (Andy, 2026-10-14).
100	19×	pub fn label(kind: &str) -> Option<&'static str> {
101	19×	Some(match kind {
102	19×	"flow.failed" => "💥 Build Broken",
103	18×	"flow.fixed" => "🎉 Build Success",
104	17×	"flow.runner_drained" => "🛑 Runner Drained",
105	17×	"backup" => "⚠️ Backup Failed",
106	17×	"backup.recovered" => "✅ Backup Recovered",
107	17×	"backup.summary" => "📦 Daily Backup Summary",
108	16×	"proposal.opened" => "🔀 New Proposal",
109	15×	"proposal.review_requested" => "👀 Review Requested",
110	14×	"proposal.review" => "📝 New Review",
111	13×	"proposal.landed" => "🚀 Proposal Landed",
112	13×	"proposal.comment" \| "issue.comment" \| "drop.comment" => "💬 New Comment",
113	11×	"issue.opened" => "🐛 New Issue",
114	6×	"issue.assigned" => "📌 Issue Assigned",
115	6×	"issue.closed" => "✔️ Issue Closed",
116	6×	"account.registered" => "👋 New Sign-up",
117	5×	_ => return None,
118		})
119	19×	}
120
121		/// A notification's email subject: its label, then what happened.
122	4×	pub fn subject(kind: &str, title: &str) -> String {
123	4×	match label(kind) {
124	3×	Some(l) => format!("{l}: {title}"),
125	1×	None => title.to_string(),
126		}
127	4×	}
128
129	0×	async fn email(app: &Shared, to: &Account, kind: &str, title: &str, url: &str, actor: &str) {
130	0×	let unsubscribe = format!("{}/settings/notifications?unsubscribe={}", app.config.base_url(), to.unsubscribe_key);
131	0×	let link = format!("{}{url}", app.config.base_url());
132	0×	let body = format!("{actor}: {title}\n\n{link}\n\nStop these emails: {unsubscribe}\n");
133	0×	let action = crate::mail::Action { label: "Open it", url: &link };
134	0×	let subject = subject(kind, title);
135	0×	if let Err(e) = crate::mail::send_letter(app, to.name(), &to.email, &subject, &body, Some(action), Some(&unsubscribe)).await {
136	0×	tracing::warn!("email to {}: {e}", to.email);
137		// Sent again from the work queue (#276), when mail is on at all.
138	0×	if crate::mail::enabled(app) {
139	0×	crate::queue::queue_mail(app, to.name(), &to.email, &subject, &body, Some(("Open it", &link)), Some(&unsubscribe)).await;
140	0×	}
141	0×	}
142	0×	}
143
144		#[cfg(test)]
145		mod tests {
146		use super::*;
147
148		#[test]
149	1×	fn subjects_say_what_happened() {
150	1×	assert_eq!(
151	1×	subject("flow.failed", "andy/demo: run #4 on main failed (test)"),
152		"💥 Build Broken: andy/demo: run #4 on main failed (test)"
153		);
154	1×	assert_eq!(
155	1×	subject("flow.fixed", "andy/demo: run #5 on main passed: fixed"),
156		"🎉 Build Success: andy/demo: run #5 on main passed: fixed"
157		);
158	1×	assert_eq!(subject("backup.summary", "x"), "📦 Daily Backup Summary: x");
159	1×	assert_eq!(subject("something.new", "x"), "x", "a kind without a label keeps its title");
160	1×	}
161
162		#[test]
163	1×	fn finds_mentions() {
164	1×	assert_eq!(mentions("cc @andy and @bob. not an email [email protected], nor /@path"), vec!["andy", "bob"]);
165	1×	assert!(mentions("nothing here").is_empty());
166	1×	}
167		}

`/`	Search
`g` `c`	Code
`g` `h`	History
`g` `b`	Bookmarks
`g` `t`	Trust
`y`	Permalink to this state (files and trees)
`?`	This sheet

Coverage / crates/hub/src/notify/mod.rs 84.0%

Keyboard