Publish user updates to NATS and pass NATS client

Add publish_user that sends user JSON over NATS and call it after
committing user-related transactions. Thread an async_nats::Client
through save_scrobble and the websocket handler. Change save_user to
return the user's xata_id and remove the per-publish NATS connection
spawn in favor of a shared client created in the subscriber.

crates/jetstream/src/repo.rs

···
-use std::{env, sync::Arc};
+use std::sync::Arc;
 
 use anyhow::Error;
 use chrono::DateTime;
-use futures_util::SinkExt;
 use owo_colors::OwoColorize;
 use serde_json::json;
 use sqlx::{Pool, Postgres};
···
 pub async fn save_scrobble(
     state: Arc<Mutex<AppState>>,
     pool: Arc<Mutex<Pool<Postgres>>>,
+    nc: Arc<async_nats::Client>,
     did: &str,
     commit: Commit,
 ) -> Result<(), Error> {
···
                 .bind(artist_id)
                 .bind(track_id)
                 .bind(uri)
-                .bind(user_id)
+                .bind(&user_id)
                 .bind(
                     DateTime::parse_from_rfc3339(&scrobble_record.created_at)
                         .unwrap()
···
                 .await?;
 
                 tx.commit().await?;
+                publish_user(&nc, &pool, &user_id).await?;
 
                 let users: Vec<User> =
                     sqlx::query_as::<_, User>("SELECT * FROM users WHERE did = $1")
···
                 update_artist_uri(&mut tx, &user_id, artist_record, &uri).await?;
 
                 tx.commit().await?;
+                publish_user(&nc, &pool, &user_id).await?;
             }
 
             if commit.collection == ALBUM_NSID {
···
                 update_album_uri(&mut tx, &user_id, album_record, &uri).await?;
 
                 tx.commit().await?;
+                publish_user(&nc, &pool, &user_id).await?;
             }
 
             if commit.collection == SONG_NSID {
···
                 update_track_uri(&mut tx, &user_id, song_record, &uri).await?;
 
                 tx.commit().await?;
+                publish_user(&nc, &pool, &user_id).await?;
             }
 
             if commit.collection == FEED_GENERATOR_NSID {
···
                 save_feed_generator(&mut tx, &user_id, feed_generator_record, &uri).await?;
 
                 tx.commit().await?;
+                publish_user(&nc, &pool, &user_id).await?;
             }
 
             if commit.collection == FOLLOW_NSID {
                 let mut tx = pool.begin().await?;
 
-                save_user(&mut tx, did).await?;
+                let user_id = save_user(&mut tx, did).await?;
                 let uri = format!("at://{}/app.rocksky.graph.follow/{}", did, commit.rkey);
 
                 let follow_record: FollowRecord = serde_json::from_value(commit.record)?;
-                save_user(&mut tx, &follow_record.subject).await?;
+                let subject_user_id = save_user(&mut tx, &follow_record.subject).await?;
                 save_follow(&mut tx, did, follow_record, &uri).await?;
 
                 tx.commit().await?;
+                publish_user(&nc, &pool, &user_id).await?;
+                publish_user(&nc, &pool, &subject_user_id).await?;
             }
         }
         _ => {
···
             .await?;
     }
 
+    Ok(users[0].xata_id.clone())
+}
+
+pub async fn publish_user(
+    nc: &async_nats::Client,
+    pool: &Pool<Postgres>,
+    id: &str,
+) -> Result<(), Error> {
+    let users: Vec<User> = sqlx::query_as("SELECT * FROM users WHERE xata_id = $1")
+        .bind(id)
+        .fetch_all(pool)
+        .await?;
+
+    if users.is_empty() {
+        tracing::warn!(user=%id, "user not found");
+        return Ok(());
+    }
+
     let u = &users[0];
+
     let payload = json!({
         "xata_id": u.xata_id,
         "did": u.did,
···
     });
     let payload = serde_json::to_string(&payload)?;
 
-    tokio::spawn(async move {
-        let addr = env::var("NATS_URL").unwrap_or_else(|_| "nats://localhost:4222".to_string());
-        let nc = async_nats::connect(&addr).await?;
-        tracing::info!(server = %addr.bright_green(), "Connected to NATS");
+    nc.publish("rocksky.user", payload.into()).await?;
+    nc.flush().await?;
 
-        nc.publish("rocksky.user", payload.into()).await?;
-        nc.flush().await?;
-
-        Ok::<(), Error>(())
-    });
-
-    Ok(users[0].xata_id.clone())
+    Ok(())
 }
 
 pub async fn save_track(

crates/jetstream/src/subscriber.rs

···
             .await?;
         let pool = Arc::new(Mutex::new(pool));
 
+        let addr = env::var("NATS_URL").unwrap_or_else(|_| "nats://localhost:4222".to_string());
+        let nc = Arc::new(async_nats::connect(&addr).await?);
+
         let (mut ws_stream, _) = connect_async(&self.service_url).await?;
         tracing::info!(url = %self.service_url.bright_green(), "Connected to jetstream at");
 
         while let Some(msg) = ws_stream.next().await {
             match msg {
                 Ok(msg) => {
-                    if let Err(e) = handle_message(state.clone(), pool.clone(), msg) {
+                    if let Err(e) = handle_message(state.clone(), pool.clone(), nc.clone(), msg) {
                         tracing::error!(error = %e, "Error handling message");
                     }
                 }
···
 fn handle_message(
     state: Arc<Mutex<AppState>>,
     pool: Arc<Mutex<sqlx::PgPool>>,
+    nc: Arc<async_nats::Client>,
     msg: Message,
 ) -> Result<(), Error> {
     tokio::spawn(async move {
···
 
             tracing::info!(message = %text, "Received message");
             if let Some(commit) = message.commit {
-                match save_scrobble(state, pool, &message.did, commit).await {
+                match save_scrobble(state, pool, nc, &message.did, commit).await {
                     Ok(_) => {
                         tracing::info!(user_id = %message.did.bright_green(), "Scrobble saved successfully");
                     }