feat: full group support

src/db.rs

@@ -23,9 +23,7 @@ impl Database {
 
         let pool = SqlitePoolOptions::new().connect_with(db_options).await?;
 
-        sqlx::migrate!("./migrations/each_user/")
-            .run(&pool)
-            .await?;
+        sqlx::migrate!("./migrations/each_user/").run(&pool).await?;
         if user.username == "demo" {
             sqlx::query_file!("./migrations/demo.sql")
                 .execute(&pool)

src/main.rs

@@ -17,19 +17,19 @@ use tower_sessions_sqlx_store::SqliteStore;
 use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt};
 
 mod models;
-use models::contact::ContactTrie;
+use models::contact::MentionTrie;
 use models::user::{Backend, User};
 
 mod db;
 use db::{Database, DbId};
 
 mod web;
-use web::{auth, contact, home, ics, journal, settings};
+use web::{auth, contact, group, home, ics, journal, settings};
 
 #[derive(Clone)]
 struct AppStateEntry {
     database: Arc<Database>,
-    contact_search: Arc<RwLock<ContactTrie>>,
+    contact_search: Arc<RwLock<MentionTrie>>,
 }
 
 #[derive(Clone)]
@@ -50,7 +50,7 @@ impl AppState {
     pub async fn init(&mut self, user: &User) -> Result<Option<AppStateEntry>, AppError> {
         let database = Database::for_user(&user).await?;
         let mut trie = radix_trie::Trie::new();
-        let rows = sqlx::query_as!(
+        let mentionable_names = sqlx::query_as!(
             NameReference,
             "select name, contact_id from (
                 select contact_id, name, count(name) as ct from names group by name
@@ -59,8 +59,21 @@ impl AppState {
         .fetch_all(&database.pool)
         .await?;
 
-        for row in rows {
-            trie.insert(row.name, DbId::try_from(row.contact_id)?);
+        for row in mentionable_names {
+            trie.insert(
+                row.name,
+                format!("/contact/{}", DbId::try_from(row.contact_id)?),
+            );
+        }
+
+        let groups: Vec<(String, String)> =
+            sqlx::query_as("select distinct name, slug from groups")
+                .fetch_all(&database.pool)
+                .await?;
+
+        for (group, slug) in groups {
+            // TODO urlencode
+            trie.insert(group, format!("/group/{}", slug));
         }
 
         let mut map = self.map.write().expect("rwlock poisoned");
@@ -78,10 +91,9 @@ impl AppState {
     }
     pub fn db(&self, user: &impl AuthUser<Id = DbId>) -> Arc<Database> {
         let map = self.map.read().expect("rwlock poisoned");
-
         map.get(&user.id()).unwrap().database.clone()
     }
-    pub fn contact_search(&self, user: &impl AuthUser<Id = DbId>) -> Arc<RwLock<ContactTrie>> {
+    pub fn contact_search(&self, user: &impl AuthUser<Id = DbId>) -> Arc<RwLock<MentionTrie>> {
         let map = self.map.read().expect("rwlock poisoned");
         map.get(&user.id()).unwrap().contact_search.clone()
     }
@@ -165,7 +177,7 @@ async fn serve(port: &u32) -> Result<(), anyhow::Error> {
         .with(
             tracing_subscriber::EnvFilter::try_from_default_env().unwrap_or_else(|_| {
                 format!(
-                    "{}=debug,tower_http=debug,axum=trace",
+                    "{}=debug,tower_http=debug,axum=trace,sqlx=debug",
                     env!("CARGO_CRATE_NAME")
                 )
                 .into()
@@ -177,6 +189,7 @@ async fn serve(port: &u32) -> Result<(), anyhow::Error> {
     let app = Router::new()
         .route("/", get(home::get::home))
         .merge(contact::router())
+        .merge(group::router())
         .merge(journal::router())
         .merge(settings::router())
         .route_layer(login_required!(Backend, login_url = "/login"))

src/models/contact.rs

@@ -36,7 +36,9 @@ impl HydratedContact {
         }
     }
 }
-pub type ContactTrie = radix_trie::Trie<String, DbId>;
+
+/*                                  name/group, url */
+pub type MentionTrie = radix_trie::Trie<String, String>;
 
 impl FromRow<'_, SqliteRow> for Contact {
     fn from_row(row: &SqliteRow) -> sqlx::Result<Self> {

src/models/journal.rs

@@ -7,7 +7,7 @@ use sqlx::{FromRow, Row};
 use std::collections::HashSet;
 use std::sync::{Arc, RwLock};
 
-use super::contact::ContactTrie;
+use super::contact::MentionTrie;
 use crate::AppError;
 use crate::db::DbId;
 
@@ -19,24 +19,24 @@ pub struct JournalEntry {
 }
 
 #[derive(Debug, PartialEq, Eq, Hash, FromRow)]
-pub struct ContactMention {
+pub struct Mention {
     pub entry_id: DbId,
-    pub contact_id: DbId,
+    pub url: String,
     pub input_text: String,
     pub byte_range_start: u32,
     pub byte_range_end: u32,
 }
 
 impl JournalEntry {
-    pub fn extract_mentions(&self, trie: &ContactTrie) -> HashSet<ContactMention> {
+    pub fn extract_mentions(&self, trie: &MentionTrie) -> HashSet<Mention> {
         let name_re = Regex::new(r"\[\[(.+?)\]\]").unwrap();
         name_re
             .captures_iter(&self.value)
             .map(|caps| {
                 let range = caps.get_match().range();
-                trie.get(&caps[1]).map(|cid| ContactMention {
+                trie.get(&caps[1]).map(|url| Mention {
                     entry_id: self.id,
-                    contact_id: cid.to_owned(),
+                    url: url.to_string(),
                     input_text: caps[1].to_string(),
                     byte_range_start: u32::try_from(range.start).unwrap(),
                     byte_range_end: u32::try_from(range.end).unwrap(),
@@ -49,9 +49,9 @@ impl JournalEntry {
 
     pub async fn insert_mentions(
         &self,
-        trie: Arc<RwLock<ContactTrie>>,
+        trie: Arc<RwLock<MentionTrie>>,
         pool: &SqlitePool,
-    ) -> Result<HashSet<ContactMention>, AppError> {
+    ) -> Result<HashSet<Mention>, AppError> {
         let mentions = {
             let trie = trie.read().unwrap();
             self.extract_mentions(&trie)
@@ -59,12 +59,12 @@ impl JournalEntry {
 
         for mention in &mentions {
             sqlx::query!(
-                "insert into contact_mentions(
-                    entry_id, contact_id, input_text,
+                "insert into journal_mentions(
+                    entry_id, url, input_text,
                     byte_range_start, byte_range_end
                 ) values ($1, $2, $3, $4, $5)",
                 mention.entry_id,
-                mention.contact_id,
+                mention.url,
                 mention.input_text,
                 mention.byte_range_start,
                 mention.byte_range_end
@@ -79,8 +79,8 @@ impl JournalEntry {
     pub async fn to_html(&self, pool: &SqlitePool) -> Result<Markup, AppError> {
         // important to sort desc so that changing contents early in the string
         // doesn't break inserting mentions at byte offsets further in
-        let mentions: Vec<ContactMention> = sqlx::query_as(
-            "select * from contact_mentions
+        let mentions: Vec<Mention> = sqlx::query_as(
+            "select * from journal_mentions
             where entry_id = $1 order by byte_range_start desc",
         )
         .bind(self.id)
@@ -89,9 +89,10 @@ impl JournalEntry {
 
         let mut value = self.value.clone();
         for mention in mentions {
+            tracing::debug!("url ({})", mention.url);
             value.replace_range(
                 (mention.byte_range_start as usize)..(mention.byte_range_end as usize),
-                &format!("[{}](/contact/{})", mention.input_text, mention.contact_id),
+                &format!("[{}]({})", mention.input_text, mention.url),
             );
         }
 
@@ -119,7 +120,7 @@ impl JournalEntry {
                         button x-bind:disabled="(date === initial_date) && (value === initial_value)"
                             x-on:click="initial_date = date; initial_value = value"
                             hx-patch=(entry_url)
-                            hx-target="previous .entry"
+                            hx-target="closest .entry"
                             hx-swap="outerHTML"
                             title="Save" { "✓" }
                         button x-bind:disabled="(date === initial_date) && (value === initial_value)"

src/web/contact.rs

@@ -11,6 +11,7 @@ use chrono::DateTime;
 use maud::{Markup, PreEscaped, html};
 use serde::Deserialize;
 use serde_json::json;
+use slug::slugify;
 use sqlx::{QueryBuilder, Sqlite};
 
 use super::Layout;
@@ -32,9 +33,9 @@ pub struct Address {
 pub struct Group {
     pub contact_id: DbId,
     pub name: String,
+    pub slug: String,
 }
 
-
 pub fn router() -> Router<AppState> {
     Router::new()
         .route("/contact/new", post(self::post::contact))
@@ -85,9 +86,14 @@ mod get {
         .await?;
 
         let entries: Vec<JournalEntry> = sqlx::query_as(
-            "select j.id, j.value, j.date from journal_entries j
-            join contact_mentions cm on j.id = cm.entry_id
-            where cm.contact_id = $1",
+            "select distinct j.id, j.value, j.date from journal_entries j
+            join journal_mentions cm on j.id = cm.entry_id
+            where cm.url = '/contact/'||$1 or cm.url in (
+                select '/group/'||slug from groups
+                where contact_id = $1
+            )
+            order by j.date desc
+            ",
         )
         .bind(contact_id)
         .fetch_all(pool)
@@ -104,10 +110,11 @@ mod get {
         let groups: Vec<Group> = sqlx::query_as!(
             Group,
             "select * from groups where contact_id = $1",
-            contact_id)
-            .fetch_all(pool)
-            .await?;
-        
+            contact_id
+        )
+        .fetch_all(pool)
+        .await?;
+
         let text_body: Option<String> =
             sqlx::query!("select text_body from contacts where id = $1", contact_id)
                 .fetch_one(pool)
@@ -172,7 +179,9 @@ mod get {
                         label { "in groups" }
                         #groups {
                             @for group in groups {
-                                .group { (group.name) }
+                                a .group href=(format!("/group/{}", group.slug)) {
+                                    (group.name)
+                                }
                             }
                         }
                     }
@@ -203,8 +212,8 @@ mod get {
             from names where contact_id = c.id
         ) as names, (
             select jes.date from journal_entries jes
-            join contact_mentions cms on cms.entry_id = jes.id
-            where cms.contact_id = c.id
+            join journal_mentions cms on cms.entry_id = jes.id
+            where cms.url = '/contact/'||c.id
             order by jes.date desc limit 1
         ) as last_mention_date from contacts c
         where c.id = $1",
@@ -230,12 +239,13 @@ mod get {
         let groups: Vec<String> = sqlx::query_as!(
             Group,
             "select * from groups where contact_id = $1",
-            contact_id)
-            .fetch_all(pool)
-            .await?
-            .into_iter()
-            .map(|group| group.name)
-            .collect();
+            contact_id
+        )
+        .fetch_all(pool)
+        .await?
+        .into_iter()
+        .map(|group| group.name)
+        .collect();
 
         let text_body: String =
             sqlx::query!("select text_body from contacts where id = $1", contact_id)
@@ -353,13 +363,14 @@ mod put {
         manually_freshened_at: String,
         address_label: Option<Vec<String>>,
         address_value: Option<Vec<String>>,
+        group: Option<Vec<String>>,
         text_body: String,
     }
 
     pub async fn contact(
         auth_session: AuthSession,
         State(state): State<AppState>,
-        Path(contact_id): Path<u32>,
+        Path(contact_id): Path<DbId>,
         Form(payload): Form<PutContact>,
     ) -> Result<impl IntoResponse, AppError> {
         let user = auth_session.user.unwrap();
@@ -398,100 +409,183 @@ mod put {
         .execute(pool)
         .await?;
 
+        // these blocks are not in functions because payload gets progressively
+        // partially moved as we handle each field and i don't want to deal with it
+
         {
             // update addresses
-            sqlx::query!("delete from addresses where contact_id = $1", contact_id)
+            let new_addresses = payload.address_value.clone().map(|values| {
+                let labels: Vec<String> = if values.len() == 1 {
+                    vec![String::new()]
+                } else {
+                    payload.address_label.clone().unwrap_or(vec![])
+                };
+
+                labels
+                    .into_iter()
+                    .zip(values)
+                    .filter(|(_, val)| val.len() > 0)
+                    .collect::<Vec<(String, String)>>()
+            });
+            let new_addresses = new_addresses.unwrap_or(vec![]);
+
+            let old_addresses: Vec<(String, String)> =
+                sqlx::query_as("select label, value from addresses where contact_id = $1")
+                    .bind(contact_id)
+                    .fetch_all(pool)
+                    .await?;
+
+            if new_addresses != old_addresses {
+                sqlx::query!("delete from addresses where contact_id = $1", contact_id)
+                    .execute(pool)
+                    .await?;
+
+                // trailing space in query intentional
+                QueryBuilder::new("insert into addresses (contact_id, label, value) ")
+                    .push_values(new_addresses, |mut b, (label, value)| {
+                        b.push_bind(contact_id).push_bind(label).push_bind(value);
+                    })
+                    .build()
+                    .persistent(false)
+                    .execute(pool)
+                    .await?;
+            }
+        }
+
+        {
+            // recalculate all contact mentions and name trie if name-list changed
+            let new_names: Vec<String> = payload
+                .name
+                .unwrap_or(vec![])
+                .into_iter()
+                .filter(|n| n.len() > 0)
+                .collect();
+            let old_names: Vec<(String,)> =
+                sqlx::query_as("select name from names where contact_id = $1")
+                    .bind(contact_id)
+                    .fetch_all(pool)
+                    .await?;
+            let old_names: Vec<String> = old_names.into_iter().map(|(s,)| s).collect();
+
+            if old_names != new_names {
+                // delete and regen *all* journal mentions, not just the ones for the
+                // current user, since changing *this* user's names can change, *globally*,
+                // which names have n=1 and thus are eligible for mentioning
+                sqlx::query!(
+                    "delete from journal_mentions; delete from names where contact_id = $1",
+                    contact_id
+                )
                 .execute(pool)
                 .await?;
 
-            if let Some(values) = payload.address_value {
-                let labels = if values.len() == 1 {
-                    Some(vec![String::new()])
-                } else {
-                    payload.address_label
-                };
-                if let Some(labels) = labels {
-                    let new_addresses = labels
-                        .into_iter()
-                        .zip(values)
-                        .filter(|(_, val)| val.len() > 0);
-                    for (label, value) in new_addresses {
-                        sqlx::query!(
-                            "insert into addresses (contact_id, label, value) values ($1, $2, $3)",
-                            contact_id,
-                            label,
-                            value
-                        )
-                        .execute(pool)
-                        .await?;
+                let mut recalc_counts: QueryBuilder<Sqlite> = QueryBuilder::new(
+                    "select name, contact_id from (
+            select name, contact_id, count(name) as ct from names where name in (",
+                );
+                let mut name_list = recalc_counts.separated(", ");
+                for name in &old_names {
+                    name_list.push_bind(name);
+                }
+
+                if !new_names.is_empty() {
+                    for name in &new_names {
+                        name_list.push_bind(name.clone());
+                    }
+
+                    let mut name_insert: QueryBuilder<Sqlite> =
+                        QueryBuilder::new("insert into names (contact_id, sort, name) ");
+                    name_insert.push_values(
+                        new_names.iter().enumerate(),
+                        |mut builder, (sort, name)| {
+                            builder
+                                .push_bind(contact_id)
+                                .push_bind(DbId::try_from(sort).unwrap())
+                                .push_bind(name);
+                        },
+                    );
+                    name_insert.build().persistent(false).execute(pool).await?;
+                }
+
+                name_list.push_unseparated(") group by name) where ct = 1");
+                let recalc_names: Vec<(String, DbId)> = recalc_counts
+                    .build_query_as()
+                    .persistent(false)
+                    .fetch_all(pool)
+                    .await?;
+
+                {
+                    let trie_mutex = state.contact_search(&user);
+                    let mut trie = trie_mutex.write().unwrap();
+                    for name in &old_names {
+                        trie.remove(name);
+                    }
+
+                    for name in recalc_names {
+                        trie.insert(name.0, format!("/contact/{}", name.1));
                     }
                 }
             }
-        }
 
-        let old_names: Vec<(String,)> = sqlx::query_as(
-            "delete from contact_mentions;
-            delete from names where contact_id = $1 returning name;",
-        )
-        .bind(contact_id)
-        .fetch_all(pool)
-        .await?;
+            let new_groups: Vec<String> = payload
+                .group
+                .unwrap_or(vec![])
+                .into_iter()
+                .filter(|n| n.len() > 0)
+                .collect();
+            let old_groups: Vec<(String,)> =
+                sqlx::query_as("select name from groups where contact_id = $1")
+                    .bind(contact_id)
+                    .fetch_all(pool)
+                    .await?;
+            let old_groups: Vec<String> = old_groups.into_iter().map(|(s,)| s).collect();
 
-        let mut recalc_counts: QueryBuilder<Sqlite> = QueryBuilder::new(
-            "select name, contact_id from (
-            select name, contact_id, count(name) as ct from names where name in (",
-        );
-        let mut name_list = recalc_counts.separated(", ");
-        for (name,) in &old_names {
-            name_list.push_bind(name);
-        }
-
-        if let Some(names) = payload.name {
-            let names: Vec<String> = names.into_iter().filter(|n| n.len() > 0).collect();
-            if !names.is_empty() {
-                for name in &names {
-                    name_list.push_bind(name.clone());
-                }
-
-                let mut name_insert: QueryBuilder<Sqlite> =
-                    QueryBuilder::new("insert into names (contact_id, sort, name) ");
-                name_insert.push_values(names.iter().enumerate(), |mut builder, (sort, name)| {
-                    builder
-                        .push_bind(contact_id)
-                        .push_bind(DbId::try_from(sort).unwrap())
-                        .push_bind(name);
-                });
-                name_insert.build().persistent(false).execute(pool).await?;
-            }
-        }
-
-        name_list.push_unseparated(") group by name) where ct = 1");
-        let recalc_names: Vec<(String, DbId)> = recalc_counts
-            .build_query_as()
-            .persistent(false)
-            .fetch_all(pool)
-            .await?;
-
-        {
-            let trie_mutex = state.contact_search(&user);
-            let mut trie = trie_mutex.write().unwrap();
-            for name in &old_names {
-                trie.remove(&name.0);
-            }
-
-            for name in recalc_names {
-                trie.insert(name.0, name.1);
-            }
-        }
-
-        let journal_entries: Vec<JournalEntry> = sqlx::query_as("select * from journal_entries")
-            .fetch_all(pool)
-            .await?;
-
-        for entry in journal_entries {
-            entry
-                .insert_mentions(state.contact_search(&user), pool)
+            if new_groups != old_groups {
+                sqlx::query!(
+                    "delete from journal_mentions; delete from groups where contact_id = $1",
+                    contact_id
+                )
+                .execute(pool)
                 .await?;
+
+                QueryBuilder::new("insert into groups (contact_id, name, slug) ")
+                    .push_values(&new_groups, |mut b, name| {
+                        b.push_bind(contact_id)
+                            .push_bind(name)
+                            .push_bind(slugify(name));
+                    })
+                    .build()
+                    .persistent(false)
+                    .execute(pool)
+                    .await?;
+
+                {
+                    let trie_mutex = state.contact_search(&user);
+                    let mut trie = trie_mutex.write().unwrap();
+                    for name in &old_groups {
+                        // TODO i think we care about group name vs contact name counts,
+                        // otherwise this will cause a problem (or we want to disallow
+                        // setting group names that are contact names or vice versa?)
+                        trie.remove(name);
+                    }
+
+                    for group in &new_groups {
+                        trie.insert(group.clone(), format!("/group/{}", slugify(group)));
+                    }
+                }
+            }
+
+            if new_names != old_names || new_groups != old_groups {
+                let journal_entries: Vec<JournalEntry> =
+                    sqlx::query_as("select * from journal_entries")
+                        .fetch_all(pool)
+                        .await?;
+
+                for entry in journal_entries {
+                    entry
+                        .insert_mentions(state.contact_search(&user), pool)
+                        .await?;
+                }
+            }
         }
 
         let mut headers = HeaderMap::new();
@@ -510,7 +604,7 @@ mod delete {
         let pool = &state.db(&user).pool;
 
         sqlx::query(
-            "delete from contact_mentions where contact_id = $1;
+            "delete from journal_mentions where contact_id = $1;
         delete from names where contact_id = $1;
         delete from contacts where id = $1;",
         )

src/web/group.rs

@@ -0,0 +1,72 @@
+use axum::{
+    Router,
+    extract::{State, path::Path},
+    routing::get,
+};
+use cache_bust::asset;
+use maud::{Markup, html};
+
+use super::Layout;
+use crate::db::DbId;
+use crate::models::user::AuthSession;
+use crate::{AppError, AppState};
+
+pub fn router() -> Router<AppState> {
+    Router::new().route("/group/{slug}", get(self::get::group))
+}
+
+mod get {
+    use super::*;
+
+    struct ContactLink {
+        id: DbId,
+        primary_name: String,
+    }
+
+    pub async fn group(
+        auth_session: AuthSession,
+        State(state): State<AppState>,
+        Path(slug): Path<String>,
+        layout: Layout,
+    ) -> Result<Markup, AppError> {
+        let pool = &state.db(&auth_session.user.unwrap()).pool;
+
+        let name: String = sqlx::query!("select name from groups where slug = $1 limit 1", slug)
+            .fetch_one(pool)
+            .await?
+            .name;
+
+        let contacts = sqlx::query_as!(
+            ContactLink,
+            "select
+                c.id as id, coalesce(
+                    (select n.name from names n
+                    where n.contact_id = c.id limit 1)
+                , '(unknown)') as primary_name
+                from contacts c
+                join groups g on c.id = g.contact_id
+                where g.slug = $1
+                order by primary_name asc",
+            slug
+        )
+        .fetch_all(pool)
+        .await?;
+
+        Ok(layout.render(
+            Some(vec![asset!("group.css")]),
+            html! {
+                h1 { (name) }
+                p { "Group members:" }
+                ul #groups {
+                    @for link in contacts {
+                        li {
+                            a href=(format!("/contact/{}", link.id)) {
+                                (link.primary_name)
+                            }
+                        }
+                    }
+                }
+            },
+        ))
+    }
+}

src/web/home.rs

@@ -131,8 +131,8 @@ pub mod get {
             from names where contact_id = c.id
         ) as names, (
             select jes.date from journal_entries jes
-            join contact_mentions cms on cms.entry_id = jes.id
-            where cms.contact_id = c.id
+            join journal_mentions cms on cms.entry_id = jes.id
+            where cms.url = '/contact/'||c.id
             order by jes.date desc limit 1
         ) as last_mention_date from contacts c",
         )

src/web/journal.rs

@@ -98,26 +98,26 @@ mod patch {
             .fetch_one(pool)
             .await?;
 
-        sqlx::query!(
-            "update journal_entries set date = $1, value = $2 where id = $3",
-            payload.date,
-            payload.value,
-            entry_id
+        let new_entry: JournalEntry = sqlx::query_as(
+            "update journal_entries set date = $1, value = $2 where id = $3 returning *",
         )
-        .execute(pool)
+        .bind(&payload.date)
+        .bind(&payload.value)
+        .bind(entry_id)
+        .fetch_one(pool)
         .await?;
 
-        if entry.value != payload.value {
-            sqlx::query!("delete from contact_mentions where entry_id = $1", entry_id)
+        if entry.value != new_entry.value {
+            sqlx::query!("delete from journal_mentions where entry_id = $1", entry_id)
                 .execute(pool)
                 .await?;
 
-            entry
+            new_entry
                 .insert_mentions(state.contact_search(&user), pool)
                 .await?;
         }
 
-        Ok(entry.to_html(pool).await?)
+        Ok(new_entry.to_html(pool).await?)
     }
 }
 
@@ -133,7 +133,7 @@ mod delete {
         let pool = &state.db(&user).pool;
 
         sqlx::query(
-            "delete from contact_mentions where entry_id = $1;
+            "delete from journal_mentions where entry_id = $1;
         delete from journal_entries where id = $2 returning id,date,value",
         )
         .bind(entry_id)

src/web/mod.rs

@@ -10,6 +10,7 @@ use super::{AppError, AppState};
 
 pub mod auth;
 pub mod contact;
+pub mod group;
 pub mod home;
 pub mod ics;
 pub mod journal;