fix: wire PgActivityPubRepository into ThoughtsObjectHandler — closes activitypub→postgres violation

Cargo.toml

@@ -0,0 +1,52 @@
+[workspace]
+members = [
+    "crates/domain",
+    "crates/application",
+    "crates/api-types",
+    "crates/presentation",
+    "crates/worker",
+    "crates/adapters/postgres",
+    "crates/adapters/postgres-search",
+    "crates/adapters/postgres-federation",
+    "crates/adapters/activitypub-base",
+    "crates/adapters/activitypub",
+    "crates/adapters/auth",
+    "crates/adapters/nats",
+    "crates/adapters/event-payload",
+    "crates/adapters/event-publisher",
+]
+resolver = "2"
+
+[workspace.dependencies]
+tokio = { version = "1.0", features = ["macros", "net", "rt", "rt-multi-thread", "sync", "time"] }
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
+anyhow = "1.0"
+thiserror = "2.0"
+tracing = "0.1"
+tracing-subscriber = { version = "0.3", features = ["env-filter"] }
+async-trait = "0.1"
+uuid = { version = "1.0", features = ["v4", "v5", "serde"] }
+chrono = { version = "0.4", features = ["serde"] }
+sqlx = { version = "0.8", features = ["runtime-tokio-rustls", "postgres", "uuid", "chrono", "macros"] }
+axum = { version = "0.8", features = ["macros"] }
+tower-http = { version = "0.6", features = ["cors", "trace"] }
+futures = "0.3"
+dotenvy = "0.15"
+async-nats = "0.38"
+async-stream = "0.3"
+reqwest = { version = "0.13", features = ["json"] }
+url = { version = "2", features = ["serde"] }
+
+domain           = { path = "crates/domain" }
+application      = { path = "crates/application" }
+api-types        = { path = "crates/api-types" }
+postgres         = { path = "crates/adapters/postgres" }
+postgres-search  = { path = "crates/adapters/postgres-search" }
+postgres-federation = { path = "crates/adapters/postgres-federation" }
+activitypub-base = { path = "crates/adapters/activitypub-base" }
+activitypub      = { path = "crates/adapters/activitypub" }
+auth             = { path = "crates/adapters/auth" }
+nats             = { path = "crates/adapters/nats" }
+event-payload    = { path = "crates/adapters/event-payload" }
+event-publisher  = { path = "crates/adapters/event-publisher" }

crates/adapters/activitypub-base/Cargo.toml

@@ -0,0 +1,21 @@
+[package]
+name = "activitypub-base"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+tokio        = { workspace = true }
+serde        = { workspace = true }
+serde_json   = { workspace = true }
+uuid         = { workspace = true }
+chrono       = { workspace = true }
+anyhow       = { workspace = true }
+tracing      = { workspace = true }
+async-trait  = { workspace = true }
+axum         = { workspace = true }
+reqwest      = { workspace = true }
+url          = { workspace = true }
+domain       = { workspace = true }
+
+activitypub_federation = "0.7.0-beta.11"
+enum_delegate          = "0.2"

crates/adapters/activitypub-base/src/activities.rs

@@ -0,0 +1,615 @@
+use activitypub_federation::{
+    config::Data,
+    fetch::object_id::ObjectId,
+    kinds::activity::{
+        AcceptType, CreateType, DeleteType, FollowType, RejectType, UndoType, UpdateType,
+    },
+    traits::Activity,
+};
+use serde::{Deserialize, Serialize};
+use url::Url;
+
+#[derive(Clone, Default, Debug, Serialize, Deserialize)]
+#[serde(rename = "Announce")]
+pub struct AnnounceType;
+
+use crate::actors::DbActor;
+use crate::data::FederationData;
+use crate::error::Error;
+use crate::repository::{FollowerStatus, FollowingStatus};
+
+// --- Follow ---
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct FollowActivity {
+    pub(crate) id: Url,
+    #[serde(rename = "type", default)]
+    pub(crate) kind: FollowType,
+    pub(crate) actor: ObjectId<DbActor>,
+    pub(crate) object: ObjectId<DbActor>,
+}
+
+#[async_trait::async_trait]
+impl Activity for FollowActivity {
+    type DataType = FederationData;
+    type Error = Error;
+
+    fn id(&self) -> &Url {
+        &self.id
+    }
+
+    fn actor(&self) -> &Url {
+        self.actor.inner()
+    }
+
+    async fn verify(&self, data: &Data<Self::DataType>) -> Result<(), Self::Error> {
+        let target_url = self.object.inner();
+        let target_domain = match (target_url.host_str(), target_url.port()) {
+            (Some(host), Some(port)) => format!("{}:{}", host, port),
+            (Some(host), None) => host.to_string(),
+            _ => {
+                return Err(Error::bad_request(anyhow::anyhow!(
+                    "invalid follow target URL"
+                )));
+            }
+        };
+        if target_domain != data.domain {
+            return Err(Error::bad_request(anyhow::anyhow!(
+                "follow target is not a local actor"
+            )));
+        }
+        Ok(())
+    }
+
+    async fn receive(self, data: &Data<Self::DataType>) -> Result<(), Self::Error> {
+        let domain = self.actor().host_str().unwrap_or("");
+        if data.federation_repo.is_domain_blocked(domain).await? {
+            tracing::info!(actor = %self.actor(), "ignoring activity from blocked domain");
+            return Ok(());
+        }
+        let _follower = self.actor.dereference(data).await?;
+        let local_actor = self.object.dereference(data).await?;
+
+        if data
+            .federation_repo
+            .is_actor_blocked(local_actor.user_id, self.actor.inner().as_str())
+            .await?
+        {
+            tracing::info!(actor = %self.actor.inner(), "ignoring follow from blocked actor");
+            return Ok(());
+        }
+
+        data.federation_repo
+            .add_follower(
+                local_actor.user_id,
+                self.actor.inner().as_str(),
+                FollowerStatus::Pending,
+                self.id.as_str(),
+            )
+            .await?;
+
+        tracing::info!(
+            follower = %self.actor.inner(),
+            local_user = %local_actor.user_id,
+            "follow request pending approval"
+        );
+        Ok(())
+    }
+}
+
+// --- Accept ---
+
+#[derive(Debug, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct AcceptActivity {
+    pub(crate) id: Url,
+    #[serde(rename = "type", default)]
+    pub(crate) kind: AcceptType,
+    pub(crate) actor: ObjectId<DbActor>,
+    pub(crate) object: FollowActivity,
+}
+
+#[async_trait::async_trait]
+impl Activity for AcceptActivity {
+    type DataType = FederationData;
+    type Error = Error;
+
+    fn id(&self) -> &Url {
+        &self.id
+    }
+
+    fn actor(&self) -> &Url {
+        self.actor.inner()
+    }
+
+    async fn verify(&self, _data: &Data<Self::DataType>) -> Result<(), Self::Error> {
+        Ok(())
+    }
+
+    async fn receive(self, data: &Data<Self::DataType>) -> Result<(), Self::Error> {
+        let domain = self.actor().host_str().unwrap_or("");
+        if data.federation_repo.is_domain_blocked(domain).await? {
+            tracing::info!(actor = %self.actor(), "ignoring activity from blocked domain");
+            return Ok(());
+        }
+        let local_user_id = crate::urls::extract_user_id_from_url(self.object.actor.inner())
+            .ok_or_else(|| Error::bad_request(anyhow::anyhow!("invalid actor URL in Follow")))?;
+        data.federation_repo
+            .update_following_status(
+                local_user_id,
+                self.actor.inner().as_str(),
+                FollowingStatus::Accepted,
+            )
+            .await?;
+
+        tracing::info!(remote_actor = %self.actor.inner(), "follow accepted by remote");
+        Ok(())
+    }
+}
+
+// --- Reject ---
+
+#[derive(Debug, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct RejectActivity {
+    pub(crate) id: Url,
+    #[serde(rename = "type", default)]
+    pub(crate) kind: RejectType,
+    pub(crate) actor: ObjectId<DbActor>,
+    pub(crate) object: FollowActivity,
+}
+
+#[async_trait::async_trait]
+impl Activity for RejectActivity {
+    type DataType = FederationData;
+    type Error = Error;
+
+    fn id(&self) -> &Url {
+        &self.id
+    }
+
+    fn actor(&self) -> &Url {
+        self.actor.inner()
+    }
+
+    async fn verify(&self, _data: &Data<Self::DataType>) -> Result<(), Self::Error> {
+        Ok(())
+    }
+
+    async fn receive(self, data: &Data<Self::DataType>) -> Result<(), Self::Error> {
+        let domain = self.actor().host_str().unwrap_or("");
+        if data.federation_repo.is_domain_blocked(domain).await? {
+            tracing::info!(actor = %self.actor(), "ignoring activity from blocked domain");
+            return Ok(());
+        }
+        if let Some(user_id) = crate::urls::extract_user_id_from_url(self.object.actor.inner()) {
+            data.federation_repo
+                .remove_following(user_id, self.actor.inner().as_str())
+                .await?;
+        }
+        tracing::info!(actor = %self.actor.inner(), "follow rejected");
+        Ok(())
+    }
+}
+
+// --- Undo ---
+
+#[derive(Debug, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct UndoActivity {
+    pub(crate) id: Url,
+    #[serde(rename = "type", default)]
+    pub(crate) kind: UndoType,
+    pub(crate) actor: ObjectId<DbActor>,
+    pub(crate) object: serde_json::Value,
+}
+
+#[async_trait::async_trait]
+impl Activity for UndoActivity {
+    type DataType = FederationData;
+    type Error = Error;
+
+    fn id(&self) -> &Url {
+        &self.id
+    }
+
+    fn actor(&self) -> &Url {
+        self.actor.inner()
+    }
+
+    async fn verify(&self, _data: &Data<Self::DataType>) -> Result<(), Self::Error> {
+        Ok(())
+    }
+
+    async fn receive(self, data: &Data<Self::DataType>) -> Result<(), Self::Error> {
+        let domain = self.actor().host_str().unwrap_or("");
+        if data.federation_repo.is_domain_blocked(domain).await? {
+            tracing::info!(actor = %self.actor(), "ignoring Undo from blocked domain");
+            return Ok(());
+        }
+
+        let obj_type = self
+            .object
+            .get("type")
+            .and_then(|t| t.as_str())
+            .unwrap_or("");
+
+        match obj_type {
+            "Follow" => {
+                if let Some(obj_url) = self.object.get("object").and_then(|o| o.as_str()) {
+                    if let Ok(url) = Url::parse(obj_url) {
+                        if let Some(user_id) = crate::urls::extract_user_id_from_url(&url) {
+                            data.federation_repo
+                                .remove_follower(user_id, self.actor.inner().as_str())
+                                .await?;
+                        }
+                    }
+                }
+                data.object_handler
+                    .on_actor_removed(self.actor.inner())
+                    .await
+                    .map_err(|e| Error::from(anyhow::anyhow!(e)))?;
+                tracing::info!(actor = %self.actor.inner(), "unfollowed");
+            }
+            "Add" => {
+                let ap_id_str = self
+                    .object
+                    .get("object")
+                    .and_then(|o| o.get("id"))
+                    .and_then(|id| id.as_str())
+                    .or_else(|| self.object.get("id").and_then(|id| id.as_str()));
+
+                if let Some(ap_id_str) = ap_id_str {
+                    if let Ok(ap_id) = Url::parse(ap_id_str) {
+                        data.object_handler
+                            .on_delete(&ap_id, self.actor.inner())
+                            .await
+                            .map_err(|e| Error::from(anyhow::anyhow!(e)))?;
+                        tracing::info!(ap_id = %ap_id_str, "undo Add (watchlist remove)");
+                    }
+                }
+            }
+            other => {
+                tracing::debug!(kind = %other, "ignoring Undo of unknown activity type");
+            }
+        }
+
+        Ok(())
+    }
+}
+
+// --- Create ---
+
+#[derive(Debug, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct CreateActivity {
+    pub(crate) id: Url,
+    #[serde(rename = "type", default)]
+    pub(crate) kind: CreateType,
+    pub(crate) actor: ObjectId<DbActor>,
+    pub(crate) object: serde_json::Value,
+    #[serde(skip_serializing_if = "Vec::is_empty", default)]
+    pub(crate) to: Vec<String>,
+    #[serde(skip_serializing_if = "Vec::is_empty", default)]
+    pub(crate) cc: Vec<String>,
+}
+
+#[async_trait::async_trait]
+impl Activity for CreateActivity {
+    type DataType = FederationData;
+    type Error = Error;
+
+    fn id(&self) -> &Url {
+        &self.id
+    }
+
+    fn actor(&self) -> &Url {
+        self.actor.inner()
+    }
+
+    async fn verify(&self, _data: &Data<Self::DataType>) -> Result<(), Self::Error> {
+        Ok(())
+    }
+
+    async fn receive(self, data: &Data<Self::DataType>) -> Result<(), Self::Error> {
+        let domain = self.actor().host_str().unwrap_or("");
+        if data.federation_repo.is_domain_blocked(domain).await? {
+            tracing::info!(actor = %self.actor(), "ignoring activity from blocked domain");
+            return Ok(());
+        }
+        let ap_id = self.id.clone();
+        let actor_url = self.actor.inner().clone();
+        data.object_handler
+            .on_create(&ap_id, &actor_url, self.object)
+            .await
+            .map_err(|e| Error::from(anyhow::anyhow!(e)))?;
+        tracing::info!(actor = %actor_url, "received create activity");
+        Ok(())
+    }
+}
+
+// --- Delete ---
+
+#[derive(Debug, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct DeleteActivity {
+    pub(crate) id: Url,
+    #[serde(rename = "type", default)]
+    pub(crate) kind: DeleteType,
+    pub(crate) actor: ObjectId<DbActor>,
+    pub(crate) object: Url,
+    #[serde(skip_serializing_if = "Vec::is_empty", default)]
+    pub(crate) to: Vec<String>,
+    #[serde(skip_serializing_if = "Vec::is_empty", default)]
+    pub(crate) cc: Vec<String>,
+}
+
+#[async_trait::async_trait]
+impl Activity for DeleteActivity {
+    type DataType = FederationData;
+    type Error = Error;
+
+    fn id(&self) -> &Url {
+        &self.id
+    }
+
+    fn actor(&self) -> &Url {
+        self.actor.inner()
+    }
+
+    async fn verify(&self, _data: &Data<Self::DataType>) -> Result<(), Self::Error> {
+        Ok(())
+    }
+
+    async fn receive(self, data: &Data<Self::DataType>) -> Result<(), Self::Error> {
+        let domain = self.actor().host_str().unwrap_or("");
+        if data.federation_repo.is_domain_blocked(domain).await? {
+            tracing::info!(actor = %self.actor(), "ignoring activity from blocked domain");
+            return Ok(());
+        }
+        let actor_url = self.actor.inner().clone();
+        data.object_handler
+            .on_delete(&self.object, &actor_url)
+            .await
+            .map_err(|e| Error::from(anyhow::anyhow!(e)))?;
+        tracing::info!(object = %self.object, "received delete activity");
+        Ok(())
+    }
+}
+
+// --- Update ---
+
+#[derive(Debug, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct UpdateActivity {
+    pub(crate) id: Url,
+    #[serde(rename = "type", default)]
+    pub(crate) kind: UpdateType,
+    pub(crate) actor: ObjectId<DbActor>,
+    pub(crate) object: serde_json::Value,
+    #[serde(skip_serializing_if = "Vec::is_empty", default)]
+    pub(crate) to: Vec<String>,
+    #[serde(skip_serializing_if = "Vec::is_empty", default)]
+    pub(crate) cc: Vec<String>,
+}
+
+#[async_trait::async_trait]
+impl Activity for UpdateActivity {
+    type DataType = FederationData;
+    type Error = Error;
+
+    fn id(&self) -> &Url {
+        &self.id
+    }
+
+    fn actor(&self) -> &Url {
+        self.actor.inner()
+    }
+
+    async fn verify(&self, _data: &Data<Self::DataType>) -> Result<(), Self::Error> {
+        Ok(())
+    }
+
+    async fn receive(self, data: &Data<Self::DataType>) -> Result<(), Self::Error> {
+        let domain = self.actor().host_str().unwrap_or("");
+        if data.federation_repo.is_domain_blocked(domain).await? {
+            tracing::info!(actor = %self.actor(), "ignoring activity from blocked domain");
+            return Ok(());
+        }
+        let ap_id = self.id.clone();
+        let actor_url = self.actor.inner().clone();
+        data.object_handler
+            .on_update(&ap_id, &actor_url, self.object)
+            .await
+            .map_err(|e| Error::from(anyhow::anyhow!(e)))?;
+        tracing::info!(actor = %actor_url, "received update activity");
+        Ok(())
+    }
+}
+
+// --- Announce ---
+
+#[derive(Debug, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct AnnounceActivity {
+    pub(crate) id: Url,
+    #[serde(rename = "type", default)]
+    pub(crate) kind: AnnounceType,
+    pub(crate) actor: ObjectId<DbActor>,
+    pub(crate) object: Url,
+    pub(crate) published: Option<chrono::DateTime<chrono::Utc>>,
+}
+
+#[async_trait::async_trait]
+impl Activity for AnnounceActivity {
+    type DataType = FederationData;
+    type Error = Error;
+
+    fn id(&self) -> &Url {
+        &self.id
+    }
+
+    fn actor(&self) -> &Url {
+        self.actor.inner()
+    }
+
+    async fn verify(&self, _data: &Data<Self::DataType>) -> Result<(), Self::Error> {
+        Ok(())
+    }
+
+    async fn receive(self, data: &Data<Self::DataType>) -> Result<(), Self::Error> {
+        let domain = self.actor().host_str().unwrap_or("");
+        if data.federation_repo.is_domain_blocked(domain).await? {
+            tracing::info!(actor = %self.actor(), "ignoring activity from blocked domain");
+            return Ok(());
+        }
+        let object_domain = self.object.host_str().unwrap_or("");
+        if object_domain != data.domain {
+            return Ok(());
+        }
+        data.federation_repo
+            .add_announce(
+                self.id.as_str(),
+                self.object.as_str(),
+                self.actor.inner().as_str(),
+                self.published.unwrap_or_else(chrono::Utc::now),
+            )
+            .await?;
+        tracing::info!(actor = %self.actor.inner(), object = %self.object, "received announce");
+        Ok(())
+    }
+}
+
+// --- Add ---
+
+#[derive(Clone, Default, Debug, Serialize, Deserialize)]
+#[serde(rename = "Add")]
+pub struct AddType;
+
+#[derive(Debug, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct AddActivity {
+    pub(crate) id: Url,
+    #[serde(rename = "type", default)]
+    pub(crate) kind: AddType,
+    pub(crate) actor: ObjectId<DbActor>,
+    pub(crate) object: serde_json::Value,
+    #[serde(skip_serializing_if = "Vec::is_empty", default)]
+    pub(crate) to: Vec<String>,
+    #[serde(skip_serializing_if = "Vec::is_empty", default)]
+    pub(crate) cc: Vec<String>,
+}
+
+#[async_trait::async_trait]
+impl Activity for AddActivity {
+    type DataType = FederationData;
+    type Error = Error;
+
+    fn id(&self) -> &Url {
+        &self.id
+    }
+
+    fn actor(&self) -> &Url {
+        self.actor.inner()
+    }
+
+    async fn verify(&self, _data: &Data<Self::DataType>) -> Result<(), Self::Error> {
+        Ok(())
+    }
+
+    async fn receive(self, data: &Data<Self::DataType>) -> Result<(), Self::Error> {
+        let domain = self.actor().host_str().unwrap_or("");
+        if data.federation_repo.is_domain_blocked(domain).await? {
+            tracing::info!(actor = %self.actor(), "ignoring Add from blocked domain");
+            return Ok(());
+        }
+        let ap_id = self.id.clone();
+        let actor_url = self.actor.inner().clone();
+        data.object_handler
+            .on_create(&ap_id, &actor_url, self.object)
+            .await
+            .map_err(|e| Error::from(anyhow::anyhow!(e)))?;
+        tracing::info!(actor = %actor_url, "received Add activity");
+        Ok(())
+    }
+}
+
+// --- Block ---
+
+#[derive(Clone, Default, Debug, Serialize, Deserialize)]
+#[serde(rename = "Block")]
+pub struct BlockType;
+
+#[derive(Debug, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct BlockActivity {
+    pub(crate) id: Url,
+    #[serde(rename = "type", default)]
+    pub(crate) kind: BlockType,
+    pub(crate) actor: ObjectId<DbActor>,
+    pub(crate) object: Url,
+}
+
+#[async_trait::async_trait]
+impl Activity for BlockActivity {
+    type DataType = FederationData;
+    type Error = Error;
+
+    fn id(&self) -> &Url {
+        &self.id
+    }
+
+    fn actor(&self) -> &Url {
+        self.actor.inner()
+    }
+
+    async fn verify(&self, _data: &Data<Self::DataType>) -> Result<(), Self::Error> {
+        Ok(())
+    }
+
+    async fn receive(self, data: &Data<Self::DataType>) -> Result<(), Self::Error> {
+        let domain = self.actor().host_str().unwrap_or("");
+        if data.federation_repo.is_domain_blocked(domain).await? {
+            tracing::info!(actor = %self.actor(), "ignoring activity from blocked domain");
+            return Ok(());
+        }
+        // They blocked us — remove them from our following list
+        if let Some(local_user_id) = crate::urls::extract_user_id_from_url(&self.object) {
+            let _ = data
+                .federation_repo
+                .remove_following(local_user_id, self.actor.inner().as_str())
+                .await;
+        }
+        tracing::info!(actor = %self.actor.inner(), "received block");
+        Ok(())
+    }
+}
+
+// --- Inbox dispatch enum ---
+
+#[derive(Debug, Deserialize, Serialize)]
+#[serde(tag = "type")]
+#[enum_delegate::implement(Activity)]
+pub enum InboxActivities {
+    #[serde(rename = "Follow")]
+    Follow(FollowActivity),
+    #[serde(rename = "Accept")]
+    Accept(AcceptActivity),
+    #[serde(rename = "Reject")]
+    Reject(RejectActivity),
+    #[serde(rename = "Undo")]
+    Undo(UndoActivity),
+    #[serde(rename = "Create")]
+    Create(CreateActivity),
+    #[serde(rename = "Delete")]
+    Delete(DeleteActivity),
+    #[serde(rename = "Update")]
+    Update(UpdateActivity),
+    #[serde(rename = "Announce")]
+    Announce(AnnounceActivity),
+    #[serde(rename = "Add")]
+    Add(AddActivity),
+    #[serde(rename = "Block")]
+    Block(BlockActivity),
+}

crates/adapters/activitypub-base/src/actor_handler.rs

@@ -0,0 +1,25 @@
+use activitypub_federation::{
+    axum::json::FederationJson, config::Data, protocol::context::WithContext, traits::Object,
+};
+use axum::extract::Path;
+
+use crate::actors::{Person, get_local_actor};
+use crate::data::FederationData;
+use crate::error::Error;
+
+pub async fn actor_handler(
+    Path(username): Path<String>,
+    data: Data<FederationData>,
+) -> Result<FederationJson<WithContext<Person>>, Error> {
+    let ap_user = data
+        .user_repo
+        .find_by_username(&username)
+        .await
+        .map_err(Error::from)?
+        .ok_or_else(|| Error::bad_request(anyhow::anyhow!("user not found")))?;
+
+    let db_actor = get_local_actor(ap_user.id, &data).await?;
+    let person = db_actor.into_json(&data).await?;
+
+    Ok(FederationJson(WithContext::new_default(person)))
+}

crates/adapters/activitypub-base/src/actors.rs

@@ -0,0 +1,327 @@
+use activitypub_federation::{
+    config::Data,
+    fetch::object_id::ObjectId,
+    http_signatures::generate_actor_keypair,
+    kinds::actor::PersonType,
+    protocol::{public_key::PublicKey, verification::verify_domains_match},
+    traits::{Actor, Object},
+};
+use chrono::{DateTime, Utc};
+use serde::{Deserialize, Serialize};
+use url::Url;
+
+use crate::data::FederationData;
+use crate::error::Error;
+use crate::repository::RemoteActor;
+use crate::user::ApProfileField;
+
+#[derive(Debug, Clone)]
+pub struct DbActor {
+    pub user_id: uuid::Uuid,
+    pub username: String,
+    pub public_key_pem: String,
+    pub private_key_pem: Option<String>,
+    pub inbox_url: Url,
+    pub outbox_url: Url,
+    pub followers_url: Url,
+    pub following_url: Url,
+    pub ap_id: Url,
+    pub last_refreshed_at: DateTime<Utc>,
+    pub bio: Option<String>,
+    pub avatar_url: Option<Url>,
+    pub banner_url: Option<Url>,
+    pub also_known_as: Option<String>,
+    pub profile_url: Option<Url>,
+    pub attachment: Vec<ApProfileField>,
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+pub struct ApImageObject {
+    #[serde(rename = "type")]
+    pub kind: String,
+    pub url: Url,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Endpoints {
+    pub shared_inbox: Url,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ProfileFieldObject {
+    #[serde(rename = "type")]
+    pub kind: String,
+    pub name: String,
+    pub value: String,
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Person {
+    #[serde(rename = "type")]
+    kind: PersonType,
+    id: ObjectId<DbActor>,
+    preferred_username: String,
+    inbox: Url,
+    outbox: Url,
+    followers: Url,
+    following: Url,
+    public_key: PublicKey,
+    name: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    summary: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    icon: Option<ApImageObject>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    url: Option<Url>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    discoverable: Option<bool>,
+    manually_approves_followers: bool,
+    #[serde(skip_serializing_if = "Option::is_none", default)]
+    updated: Option<DateTime<Utc>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    endpoints: Option<Endpoints>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    image: Option<ApImageObject>,
+    #[serde(rename = "alsoKnownAs", skip_serializing_if = "Vec::is_empty", default)]
+    also_known_as: Vec<String>,
+    #[serde(skip_serializing_if = "Vec::is_empty", default)]
+    attachment: Vec<ProfileFieldObject>,
+}
+
+pub async fn get_local_actor(
+    user_id: uuid::Uuid,
+    data: &Data<FederationData>,
+) -> Result<DbActor, Error> {
+    let user = data
+        .user_repo
+        .find_by_id(user_id)
+        .await
+        .map_err(Error::from)?
+        .ok_or_else(|| Error::not_found(anyhow::anyhow!("user not found: {}", user_id)))?;
+
+    let (public_key, private_key) = match data
+        .federation_repo
+        .get_local_actor_keypair(user_id)
+        .await?
+    {
+        Some(kp) => kp,
+        None => {
+            let kp = generate_actor_keypair()?;
+            data.federation_repo
+                .save_local_actor_keypair(user_id, kp.public_key.clone(), kp.private_key.clone())
+                .await?;
+            (kp.public_key, kp.private_key)
+        }
+    };
+
+    let ap_id = crate::urls::actor_url(&data.base_url, user_id);
+    let inbox_url = Url::parse(&format!("{}/inbox", &ap_id)).expect("valid inbox url");
+    let outbox_url = Url::parse(&format!("{}/outbox", &ap_id)).expect("valid outbox url");
+    let followers_url = Url::parse(&format!("{}/followers", &ap_id)).expect("valid followers url");
+    let following_url = Url::parse(&format!("{}/following", &ap_id)).expect("valid following url");
+
+    Ok(DbActor {
+        user_id,
+        username: user.username,
+        public_key_pem: public_key,
+        private_key_pem: Some(private_key),
+        inbox_url,
+        outbox_url,
+        followers_url,
+        following_url,
+        ap_id,
+        last_refreshed_at: Utc::now(),
+        bio: user.bio,
+        avatar_url: user.avatar_url,
+        banner_url: user.banner_url,
+        also_known_as: user.also_known_as,
+        profile_url: user.profile_url,
+        attachment: user.attachment,
+    })
+}
+
+#[async_trait::async_trait]
+impl Object for DbActor {
+    type DataType = FederationData;
+    type Kind = Person;
+    type Error = Error;
+
+    fn id(&self) -> &Url {
+        &self.ap_id
+    }
+
+    fn last_refreshed_at(&self) -> Option<DateTime<Utc>> {
+        Some(self.last_refreshed_at)
+    }
+
+    async fn read_from_id(
+        object_id: Url,
+        data: &Data<Self::DataType>,
+    ) -> Result<Option<Self>, Self::Error> {
+        let user_id = match crate::urls::extract_user_id_from_url(&object_id) {
+            Some(id) => id,
+            None => return Ok(None),
+        };
+        let user = match data.user_repo.find_by_id(user_id).await {
+            Ok(Some(u)) => u,
+            _ => return Ok(None),
+        };
+
+        let keypair = data
+            .federation_repo
+            .get_local_actor_keypair(user_id)
+            .await?;
+
+        let (public_key, private_key) = match keypair {
+            Some(kp) => (kp.0, Some(kp.1)),
+            None => return Ok(None),
+        };
+
+        let ap_id = crate::urls::actor_url(&data.base_url, user_id);
+        let inbox_url = Url::parse(&format!("{}/inbox", &ap_id)).expect("valid url");
+        let outbox_url = Url::parse(&format!("{}/outbox", &ap_id)).expect("valid url");
+        let followers_url = Url::parse(&format!("{}/followers", &ap_id)).expect("valid url");
+        let following_url = Url::parse(&format!("{}/following", &ap_id)).expect("valid url");
+
+        Ok(Some(DbActor {
+            user_id,
+            username: user.username,
+            public_key_pem: public_key,
+            private_key_pem: private_key,
+            inbox_url,
+            outbox_url,
+            followers_url,
+            following_url,
+            ap_id,
+            last_refreshed_at: Utc::now(),
+            bio: None,
+            avatar_url: None,
+            banner_url: None,
+            also_known_as: None,
+            profile_url: None,
+            attachment: vec![],
+        }))
+    }
+
+    async fn into_json(self, data: &Data<Self::DataType>) -> Result<Self::Kind, Self::Error> {
+        let public_key = PublicKey {
+            id: format!("{}#main-key", &self.ap_id),
+            owner: self.ap_id.clone(),
+            public_key_pem: self.public_key_pem.clone(),
+        };
+
+        let icon = self.avatar_url.map(|url| ApImageObject {
+            kind: "Image".to_string(),
+            url,
+        });
+        let image = self.banner_url.map(|url| ApImageObject {
+            kind: "Image".to_string(),
+            url,
+        });
+        let profile_url = self.profile_url;
+        let also_known_as: Vec<String> = self.also_known_as.into_iter().collect();
+        let attachment: Vec<ProfileFieldObject> = self
+            .attachment
+            .into_iter()
+            .map(|f| ProfileFieldObject {
+                kind: "PropertyValue".to_string(),
+                name: f.name,
+                value: f.value,
+            })
+            .collect();
+
+        let shared_inbox =
+            Url::parse(&format!("{}/inbox", data.base_url)).expect("base_url is always valid");
+
+        Ok(Person {
+            kind: Default::default(),
+            id: self.ap_id.clone().into(),
+            preferred_username: self.username.clone(),
+            inbox: self.inbox_url.clone(),
+            outbox: self.outbox_url.clone(),
+            followers: self.followers_url.clone(),
+            following: self.following_url.clone(),
+            public_key,
+            name: Some(self.username.clone()),
+            summary: self.bio.clone(),
+            icon,
+            url: profile_url,
+            discoverable: Some(true),
+            manually_approves_followers: true,
+            updated: Some(self.last_refreshed_at),
+            endpoints: Some(Endpoints { shared_inbox }),
+            image,
+            also_known_as,
+            attachment,
+        })
+    }
+
+    async fn verify(
+        json: &Self::Kind,
+        expected_domain: &Url,
+        _data: &Data<Self::DataType>,
+    ) -> Result<(), Self::Error> {
+        verify_domains_match(json.id.inner(), expected_domain)?;
+        Ok(())
+    }
+
+    async fn from_json(json: Self::Kind, data: &Data<Self::DataType>) -> Result<Self, Self::Error> {
+        let actor = RemoteActor {
+            url: json.id.inner().to_string(),
+            handle: json.preferred_username.clone(),
+            inbox_url: json.inbox.to_string(),
+            shared_inbox_url: None,
+            display_name: json.name.clone(),
+            avatar_url: json.icon.as_ref().map(|i| i.url.to_string()),
+            outbox_url: Some(json.outbox.to_string()),
+        };
+        data.federation_repo.upsert_remote_actor(actor).await?;
+
+        let url_str = json.id.inner().to_string();
+        let user_id = uuid::Uuid::new_v5(&uuid::Uuid::NAMESPACE_URL, url_str.as_bytes());
+        let ap_id = json.id.inner().clone();
+        let inbox_url = json.inbox.clone();
+        let outbox_url = json.outbox.clone();
+        let followers_url = json.followers.clone();
+        let following_url = json.following.clone();
+
+        Ok(DbActor {
+            user_id,
+            username: json.preferred_username.clone(),
+            public_key_pem: json.public_key.public_key_pem,
+            private_key_pem: None,
+            inbox_url,
+            outbox_url,
+            followers_url,
+            following_url,
+            ap_id,
+            last_refreshed_at: Utc::now(),
+            bio: None,
+            avatar_url: None,
+            banner_url: None,
+            also_known_as: None,
+            profile_url: None,
+            attachment: vec![],
+        })
+    }
+}
+
+impl Actor for DbActor {
+    fn public_key_pem(&self) -> &str {
+        &self.public_key_pem
+    }
+
+    fn private_key_pem(&self) -> Option<String> {
+        self.private_key_pem.clone()
+    }
+
+    fn inbox(&self) -> Url {
+        self.inbox_url.clone()
+    }
+}
+
+#[cfg(test)]
+#[path = "tests/actors.rs"]
+mod tests;

crates/adapters/activitypub-base/src/content.rs

@@ -0,0 +1,47 @@
+use async_trait::async_trait;
+use chrono::{DateTime, Utc};
+use url::Url;
+
+#[async_trait]
+pub trait ApObjectHandler: Send + Sync {
+    /// Returns (ap_id, serialized object) for all local content owned by this user.
+    /// Used by outbox (count) and backfill (delivery). Must only return locally-authored content.
+    async fn get_local_objects_for_user(
+        &self,
+        user_id: uuid::Uuid,
+    ) -> anyhow::Result<Vec<(Url, serde_json::Value)>>;
+
+    /// Returns up to `limit` objects ordered newest-first, published before `before`.
+    /// Returns (ap_id, object_json, published_at).
+    async fn get_local_objects_page(
+        &self,
+        user_id: uuid::Uuid,
+        before: Option<DateTime<Utc>>,
+        limit: usize,
+    ) -> anyhow::Result<Vec<(Url, serde_json::Value, DateTime<Utc>)>>;
+
+    /// Incoming Create activity — persist remote content.
+    async fn on_create(
+        &self,
+        ap_id: &Url,
+        actor_url: &Url,
+        object: serde_json::Value,
+    ) -> anyhow::Result<()>;
+
+    /// Incoming Update activity — update existing remote content.
+    async fn on_update(
+        &self,
+        ap_id: &Url,
+        actor_url: &Url,
+        object: serde_json::Value,
+    ) -> anyhow::Result<()>;
+
+    /// Incoming Delete activity — remove specific remote content.
+    async fn on_delete(&self, ap_id: &Url, actor_url: &Url) -> anyhow::Result<()>;
+
+    /// Actor unfollowed/was removed — clean up all their remote content.
+    async fn on_actor_removed(&self, actor_url: &Url) -> anyhow::Result<()>;
+
+    /// Total number of locally-authored posts across all users.
+    async fn count_local_posts(&self) -> anyhow::Result<u64>;
+}

crates/adapters/activitypub-base/src/data.rs

@@ -0,0 +1,48 @@
+use std::sync::Arc;
+
+use crate::content::ApObjectHandler;
+use crate::repository::FederationRepository;
+use crate::user::ApUserRepository;
+use domain::ports::EventPublisher;
+
+#[derive(Clone)]
+pub struct FederationData {
+    pub(crate) federation_repo: Arc<dyn FederationRepository>,
+    pub(crate) user_repo: Arc<dyn ApUserRepository>,
+    pub(crate) object_handler: Arc<dyn ApObjectHandler>,
+    pub(crate) base_url: String,
+    pub(crate) domain: String,
+    pub(crate) allow_registration: bool,
+    pub(crate) software_name: String,
+    pub(crate) event_publisher: Option<Arc<dyn EventPublisher>>,
+}
+
+impl FederationData {
+    pub fn new(
+        federation_repo: Arc<dyn FederationRepository>,
+        user_repo: Arc<dyn ApUserRepository>,
+        object_handler: Arc<dyn ApObjectHandler>,
+        base_url: String,
+        allow_registration: bool,
+        software_name: String,
+        event_publisher: Option<Arc<dyn EventPublisher>>,
+    ) -> Self {
+        let domain = base_url
+            .trim_start_matches("https://")
+            .trim_start_matches("http://")
+            .split('/')
+            .next()
+            .unwrap_or("")
+            .to_string();
+        Self {
+            federation_repo,
+            user_repo,
+            object_handler,
+            base_url,
+            domain,
+            allow_registration,
+            software_name,
+            event_publisher,
+        }
+    }
+}

crates/adapters/activitypub-base/src/error.rs

@@ -0,0 +1,48 @@
+use std::fmt::{Display, Formatter};
+
+use axum::http::StatusCode;
+
+#[derive(Debug)]
+pub struct Error(pub(crate) anyhow::Error, pub(crate) StatusCode);
+
+impl Error {
+    pub fn not_found(e: impl Into<anyhow::Error>) -> Self {
+        Self(e.into(), StatusCode::NOT_FOUND)
+    }
+
+    pub fn bad_request(e: impl Into<anyhow::Error>) -> Self {
+        Self(e.into(), StatusCode::BAD_REQUEST)
+    }
+}
+
+impl Display for Error {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        std::fmt::Display::fmt(&self.0, f)
+    }
+}
+
+impl<T> From<T> for Error
+where
+    T: Into<anyhow::Error>,
+{
+    fn from(t: T) -> Self {
+        Error(t.into(), StatusCode::INTERNAL_SERVER_ERROR)
+    }
+}
+
+impl axum::response::IntoResponse for Error {
+    fn into_response(self) -> axum::response::Response {
+        let status = self.1;
+        if status.is_server_error() {
+            tracing::error!(error = %self.0, status = status.as_u16(), "federation error");
+        } else {
+            tracing::debug!(error = %self.0, status = status.as_u16(), "federation response");
+        }
+        let body = if status.is_server_error() {
+            "internal server error".to_string()
+        } else {
+            self.0.to_string()
+        };
+        (status, body).into_response()
+    }
+}

crates/adapters/activitypub-base/src/federation.rs

@@ -0,0 +1,50 @@
+use activitypub_federation::config::{Data, FederationConfig, FederationMiddleware, UrlVerifier};
+use activitypub_federation::error::Error as FedError;
+use url::Url;
+
+use crate::data::FederationData;
+
+#[derive(Clone)]
+struct PermissiveVerifier;
+
+#[async_trait::async_trait]
+impl UrlVerifier for PermissiveVerifier {
+    async fn verify(&self, _url: &Url) -> Result<(), FedError> {
+        Ok(())
+    }
+}
+
+#[derive(Clone)]
+pub struct ApFederationConfig(pub FederationConfig<FederationData>);
+
+impl ApFederationConfig {
+    pub async fn new(data: FederationData, debug: bool) -> anyhow::Result<Self> {
+        let config = if debug {
+            FederationConfig::builder()
+                .domain(&data.domain)
+                .app_data(data)
+                .debug(true)
+                .http_signature_compat(true)
+                .url_verifier(Box::new(PermissiveVerifier))
+                .build()
+                .await?
+        } else {
+            FederationConfig::builder()
+                .domain(&data.domain)
+                .app_data(data)
+                .debug(false)
+                .http_signature_compat(true)
+                .build()
+                .await?
+        };
+        Ok(Self(config))
+    }
+
+    pub fn to_request_data(&self) -> Data<FederationData> {
+        self.0.to_request_data()
+    }
+
+    pub fn middleware(&self) -> FederationMiddleware<FederationData> {
+        FederationMiddleware::new(self.0.clone())
+    }
+}

crates/adapters/activitypub-base/src/followers_handler.rs

@@ -0,0 +1,130 @@
+use activitypub_federation::{axum::json::FederationJson, config::Data};
+use axum::extract::{Path, Query};
+use serde::Deserialize;
+use serde_json::json;
+
+use crate::data::FederationData;
+use crate::error::Error;
+
+const PAGE_SIZE: usize = 20;
+
+#[derive(Deserialize)]
+pub struct PageQuery {
+    page: Option<u32>,
+}
+
+pub async fn followers_handler(
+    Path(user_id_str): Path<String>,
+    Query(query): Query<PageQuery>,
+    data: Data<FederationData>,
+) -> Result<FederationJson<serde_json::Value>, Error> {
+    let user_id = uuid::Uuid::parse_str(&user_id_str)
+        .map_err(|_| Error::bad_request(anyhow::anyhow!("invalid user id")))?;
+
+    data.user_repo
+        .find_by_id(user_id)
+        .await
+        .map_err(Error::from)?
+        .ok_or_else(|| Error::not_found(anyhow::anyhow!("user not found")))?;
+
+    let collection_id = format!("{}/users/{}/followers", data.base_url, user_id_str);
+    let total = data
+        .federation_repo
+        .count_followers(user_id)
+        .await
+        .map_err(Error::from)?;
+
+    if let Some(page) = query.page {
+        let page = page.max(1);
+        let offset = (page.saturating_sub(1) as usize) * PAGE_SIZE;
+        let followers = data
+            .federation_repo
+            .get_followers_page(user_id, offset as u32, PAGE_SIZE)
+            .await
+            .map_err(Error::from)?;
+
+        let has_next = offset + followers.len() < total;
+        let items: Vec<String> = followers.into_iter().map(|f| f.actor.url).collect();
+
+        let mut obj = json!({
+            "@context": "https://www.w3.org/ns/activitystreams",
+            "type": "OrderedCollectionPage",
+            "id": format!("{}?page={}", collection_id, page),
+            "partOf": collection_id,
+            "totalItems": total,
+            "orderedItems": items,
+        });
+
+        if has_next {
+            obj["next"] = json!(format!("{}?page={}", collection_id, page + 1));
+        }
+
+        Ok(FederationJson(obj))
+    } else {
+        Ok(FederationJson(json!({
+            "@context": "https://www.w3.org/ns/activitystreams",
+            "type": "OrderedCollection",
+            "id": collection_id,
+            "totalItems": total,
+            "first": format!("{}?page=1", collection_id),
+        })))
+    }
+}
+
+pub async fn following_handler(
+    Path(user_id_str): Path<String>,
+    Query(query): Query<PageQuery>,
+    data: Data<FederationData>,
+) -> Result<FederationJson<serde_json::Value>, Error> {
+    let user_id = uuid::Uuid::parse_str(&user_id_str)
+        .map_err(|_| Error::bad_request(anyhow::anyhow!("invalid user id")))?;
+
+    data.user_repo
+        .find_by_id(user_id)
+        .await
+        .map_err(Error::from)?
+        .ok_or_else(|| Error::not_found(anyhow::anyhow!("user not found")))?;
+
+    let collection_id = format!("{}/users/{}/following", data.base_url, user_id_str);
+    let total = data
+        .federation_repo
+        .count_following(user_id)
+        .await
+        .map_err(Error::from)?;
+
+    if let Some(page) = query.page {
+        let page = page.max(1);
+        let offset = (page.saturating_sub(1) as usize) * PAGE_SIZE;
+        let following = data
+            .federation_repo
+            .get_following_page(user_id, offset as u32, PAGE_SIZE)
+            .await
+            .map_err(Error::from)?;
+
+        let has_next = offset + following.len() < total;
+        let items: Vec<String> = following.into_iter().map(|a| a.url).collect();
+
+        let mut obj = json!({
+            "@context": "https://www.w3.org/ns/activitystreams",
+            "type": "OrderedCollectionPage",
+            "id": format!("{}?page={}", collection_id, page),
+            "partOf": collection_id,
+            "totalItems": total,
+            "orderedItems": items,
+        });
+
+        if has_next {
+            obj["next"] = json!(format!("{}?page={}", collection_id, page + 1));
+        }
+
+        Ok(FederationJson(obj))
+    } else {
+        Ok(FederationJson(json!({
+            "@context": "https://www.w3.org/ns/activitystreams",
+            "type": "OrderedCollection",
+            "id": collection_id,
+            "totalItems": total,
+            "first": format!("{}?page=1", collection_id),
+        })))
+    }
+}

crates/adapters/activitypub-base/src/inbox.rs

@@ -0,0 +1,18 @@
+use activitypub_federation::{
+    axum::inbox::{ActivityData, receive_activity},
+    config::Data,
+    protocol::context::WithContext,
+};
+
+use crate::activities::InboxActivities;
+use crate::actors::DbActor;
+use crate::data::FederationData;
+use crate::error::Error;
+
+pub async fn inbox_handler(
+    data: Data<FederationData>,
+    activity_data: ActivityData,
+) -> Result<(), Error> {
+    receive_activity::<WithContext<InboxActivities>, DbActor, FederationData>(activity_data, &data)
+        .await
+}

crates/adapters/activitypub-base/src/lib.rs

@@ -0,0 +1,27 @@
+pub mod activities;
+pub mod actor_handler;
+pub mod actors;
+pub mod content;
+pub mod data;
+pub mod error;
+pub mod federation;
+pub mod followers_handler;
+pub mod inbox;
+pub mod nodeinfo;
+pub mod outbox;
+pub mod repository;
+pub mod service;
+pub(crate) mod urls;
+pub use urls::AS_PUBLIC;
+pub mod user;
+pub mod webfinger;
+
+pub use content::ApObjectHandler;
+pub use data::FederationData;
+pub use error::Error;
+pub use federation::ApFederationConfig;
+pub use repository::{
+    BlockedDomain, FederationRepository, Follower, FollowerStatus, FollowingStatus, RemoteActor,
+};
+pub use service::ActivityPubService;
+pub use user::{ApProfileField, ApUser, ApUserRepository};

crates/adapters/activitypub-base/src/nodeinfo.rs

@@ -0,0 +1,80 @@
+use activitypub_federation::config::Data;
+use axum::Json;
+use serde::Serialize;
+
+use crate::data::FederationData;
+use crate::error::Error;
+
+#[derive(Serialize)]
+pub struct NodeInfoWellKnown {
+    pub links: Vec<NodeInfoLink>,
+}
+
+#[derive(Serialize)]
+pub struct NodeInfoLink {
+    pub rel: String,
+    pub href: String,
+}
+
+#[derive(Serialize)]
+pub struct NodeInfoSoftware {
+    pub name: String,
+    pub version: String,
+}
+
+#[derive(Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct NodeInfoUsage {
+    pub users: NodeInfoUsers,
+    pub local_posts: u64,
+}
+
+#[derive(Serialize)]
+pub struct NodeInfoUsers {
+    pub total: usize,
+}
+
+#[derive(Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct NodeInfo {
+    pub version: String,
+    pub software: NodeInfoSoftware,
+    pub protocols: Vec<String>,
+    pub usage: NodeInfoUsage,
+    pub open_registrations: bool,
+}
+
+pub async fn nodeinfo_well_known_handler(
+    data: Data<FederationData>,
+) -> Result<Json<NodeInfoWellKnown>, Error> {
+    let href = format!("{}/nodeinfo/2.0", data.base_url);
+    Ok(Json(NodeInfoWellKnown {
+        links: vec![NodeInfoLink {
+            rel: "http://nodeinfo.diaspora.software/ns/schema/2.0".to_string(),
+            href,
+        }],
+    }))
+}
+
+pub async fn nodeinfo_handler(data: Data<FederationData>) -> Result<Json<NodeInfo>, Error> {
+    let user_count = data.user_repo.count_users().await.unwrap_or(0);
+    let local_posts = data.object_handler.count_local_posts().await.unwrap_or(0);
+
+    Ok(Json(NodeInfo {
+        version: "2.0".to_string(),
+        software: NodeInfoSoftware {
+            name: data.software_name.clone(),
+            version: env!("CARGO_PKG_VERSION").to_string(),
+        },
+        protocols: vec!["activitypub".to_string()],
+        usage: NodeInfoUsage {
+            users: NodeInfoUsers { total: user_count },
+            local_posts,
+        },
+        open_registrations: data.allow_registration,
+    }))
+}
+
+#[cfg(test)]
+#[path = "tests/nodeinfo.rs"]
+mod tests;

crates/adapters/activitypub-base/src/outbox.rs

@@ -0,0 +1,138 @@
+use axum::extract::{Path, Query};
+use axum::response::IntoResponse;
+use chrono::{DateTime, Utc};
+use serde::{Deserialize, Serialize};
+use url::Url;
+
+use activitypub_federation::{
+    config::Data, fetch::object_id::ObjectId, kinds::activity::CreateType,
+    protocol::context::WithContext,
+};
+
+use crate::{activities::CreateActivity, data::FederationData, error::Error};
+
+const PAGE_SIZE: usize = 20;
+
+#[derive(Deserialize)]
+pub struct OutboxQuery {
+    page: Option<bool>,
+    before: Option<String>,
+}
+
+#[derive(Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct OrderedCollection {
+    #[serde(rename = "@context")]
+    context: String,
+    #[serde(rename = "type")]
+    kind: String,
+    id: String,
+    total_items: u64,
+    first: String,
+}
+
+#[derive(Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct OrderedCollectionPage {
+    #[serde(rename = "@context")]
+    context: String,
+    #[serde(rename = "type")]
+    kind: String,
+    id: String,
+    part_of: String,
+    ordered_items: Vec<serde_json::Value>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    next: Option<String>,
+}
+
+pub async fn outbox_handler(
+    Path(user_id_str): Path<String>,
+    Query(query): Query<OutboxQuery>,
+    data: Data<FederationData>,
+) -> Result<axum::response::Response, Error> {
+    let uuid = uuid::Uuid::parse_str(&user_id_str)
+        .map_err(|_| Error::bad_request(anyhow::anyhow!("invalid user id")))?;
+
+    data.user_repo
+        .find_by_id(uuid)
+        .await
+        .map_err(Error::from)?
+        .ok_or_else(|| Error::not_found(anyhow::anyhow!("user not found")))?;
+
+    let outbox_url = format!("{}/users/{}/outbox", data.base_url, user_id_str);
+
+    if query.page.unwrap_or(false) {
+        let before: Option<DateTime<Utc>> = query.before.as_deref().and_then(|s| s.parse().ok());
+
+        let items = data
+            .object_handler
+            .get_local_objects_page(uuid, before, PAGE_SIZE)
+            .await
+            .map_err(|e| Error::from(anyhow::anyhow!("{}", e)))?;
+
+        let actor_url: Url = format!("{}/users/{}", data.base_url, user_id_str)
+            .parse()
+            .expect("valid url");
+
+        let has_more = items.len() == PAGE_SIZE;
+        let oldest_ts = items.last().map(|(_, _, ts)| *ts);
+
+        let followers_url = format!("{}/followers", actor_url);
+        let ordered_items: Vec<serde_json::Value> = items
+            .into_iter()
+            .map(|(ap_id, object, _)| {
+                let create_id = Url::parse(&format!("{}/activity", ap_id)).expect("valid url");
+                serde_json::to_value(WithContext::new_default(CreateActivity {
+                    id: create_id,
+                    kind: CreateType::default(),
+                    actor: ObjectId::from(actor_url.clone()),
+                    object,
+                    to: vec![crate::urls::AS_PUBLIC.to_string()],
+                    cc: vec![followers_url.clone()],
+                }))
+                .expect("serializable")
+            })
+            .collect();
+
+        let page_id = match &query.before {
+            Some(b) => format!("{}?page=true&before={}", outbox_url, b),
+            None => format!("{}?page=true", outbox_url),
+        };
+
+        let next = if has_more {
+            oldest_ts.map(|ts| {
+                // Use RFC 3339 with Z suffix (no + sign) to avoid percent-encoding
+                let ts_str = ts.format("%Y-%m-%dT%H:%M:%S%.3fZ").to_string();
+                format!("{}?page=true&before={}", outbox_url, ts_str)
+            })
+        } else {
+            None
+        };
+
+        Ok(axum::Json(OrderedCollectionPage {
+            context: "https://www.w3.org/ns/activitystreams".to_string(),
+            kind: "OrderedCollectionPage".to_string(),
+            id: page_id,
+            part_of: outbox_url,
+            ordered_items,
+            next,
+        })
+        .into_response())
+    } else {
+        let total = data
+            .object_handler
+            .get_local_objects_for_user(uuid)
+            .await
+            .map_err(|e| Error::from(anyhow::anyhow!("{}", e)))?
+            .len() as u64;
+
+        Ok(axum::Json(OrderedCollection {
+            context: "https://www.w3.org/ns/activitystreams".to_string(),
+            kind: "OrderedCollection".to_string(),
+            id: outbox_url.clone(),
+            total_items: total,
+            first: format!("{}?page=true", outbox_url),
+        })
+        .into_response())
+    }
+}

crates/adapters/activitypub-base/src/repository.rs

@@ -0,0 +1,134 @@
+use anyhow::Result;
+use async_trait::async_trait;
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum FollowerStatus {
+    Pending,
+    Accepted,
+    Rejected,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum FollowingStatus {
+    Pending,
+    Accepted,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct RemoteActor {
+    pub url: String,
+    pub handle: String,
+    pub inbox_url: String,
+    pub shared_inbox_url: Option<String>,
+    pub display_name: Option<String>,
+    pub avatar_url: Option<String>,
+    pub outbox_url: Option<String>,
+}
+
+#[derive(Debug, Clone)]
+pub struct Follower {
+    pub actor: RemoteActor,
+    pub status: FollowerStatus,
+}
+
+#[derive(Debug, Clone)]
+pub struct BlockedDomain {
+    pub domain: String,
+    pub reason: Option<String>,
+    pub blocked_at: String,
+}
+
+#[async_trait]
+pub trait FederationRepository: Send + Sync {
+    async fn add_follower(
+        &self,
+        local_user_id: uuid::Uuid,
+        remote_actor_url: &str,
+        status: FollowerStatus,
+        follow_activity_id: &str,
+    ) -> Result<()>;
+    async fn get_follower_follow_activity_id(
+        &self,
+        local_user_id: uuid::Uuid,
+        remote_actor_url: &str,
+    ) -> Result<Option<String>>;
+    async fn remove_follower(
+        &self,
+        local_user_id: uuid::Uuid,
+        remote_actor_url: &str,
+    ) -> Result<()>;
+    async fn get_followers(&self, local_user_id: uuid::Uuid) -> Result<Vec<Follower>>;
+    async fn get_followers_page(
+        &self,
+        local_user_id: uuid::Uuid,
+        offset: u32,
+        limit: usize,
+    ) -> Result<Vec<Follower>>;
+    async fn count_followers(&self, local_user_id: uuid::Uuid) -> Result<usize>;
+    async fn get_following_page(
+        &self,
+        local_user_id: uuid::Uuid,
+        offset: u32,
+        limit: usize,
+    ) -> Result<Vec<RemoteActor>>;
+    async fn update_follower_status(
+        &self,
+        local_user_id: uuid::Uuid,
+        remote_actor_url: &str,
+        status: FollowerStatus,
+    ) -> Result<()>;
+    async fn add_following(
+        &self,
+        local_user_id: uuid::Uuid,
+        actor: RemoteActor,
+        follow_activity_id: &str,
+    ) -> Result<()>;
+    async fn get_follow_activity_id(
+        &self,
+        local_user_id: uuid::Uuid,
+        remote_actor_url: &str,
+    ) -> Result<Option<String>>;
+    async fn remove_following(&self, local_user_id: uuid::Uuid, actor_url: &str) -> Result<()>;
+    async fn get_following(&self, local_user_id: uuid::Uuid) -> Result<Vec<RemoteActor>>;
+    async fn count_following(&self, local_user_id: uuid::Uuid) -> Result<usize>;
+    async fn upsert_remote_actor(&self, actor: RemoteActor) -> Result<()>;
+    async fn get_remote_actor(&self, actor_url: &str) -> Result<Option<RemoteActor>>;
+    async fn get_local_actor_keypair(
+        &self,
+        user_id: uuid::Uuid,
+    ) -> Result<Option<(String, String)>>;
+    async fn save_local_actor_keypair(
+        &self,
+        user_id: uuid::Uuid,
+        public_key: String,
+        private_key: String,
+    ) -> Result<()>;
+    async fn get_pending_followers(&self, local_user_id: uuid::Uuid) -> Result<Vec<RemoteActor>>;
+    async fn update_following_status(
+        &self,
+        local_user_id: uuid::Uuid,
+        remote_actor_url: &str,
+        status: FollowingStatus,
+    ) -> Result<()>;
+    async fn get_following_outbox_url(
+        &self,
+        local_user_id: uuid::Uuid,
+        remote_actor_url: &str,
+    ) -> Result<Option<String>>;
+    async fn add_announce(
+        &self,
+        activity_id: &str,
+        object_url: &str,
+        actor_url: &str,
+        announced_at: chrono::DateTime<chrono::Utc>,
+    ) -> Result<()>;
+    async fn count_announces(&self, object_url: &str) -> Result<usize>;
+    async fn add_blocked_domain(&self, domain: &str, reason: Option<&str>) -> Result<()>;
+    async fn remove_blocked_domain(&self, domain: &str) -> Result<()>;
+    async fn get_blocked_domains(&self) -> Result<Vec<BlockedDomain>>;
+    async fn is_domain_blocked(&self, domain: &str) -> Result<bool>;
+    async fn add_blocked_actor(&self, local_user_id: uuid::Uuid, actor_url: &str) -> Result<()>;
+    async fn remove_blocked_actor(&self, local_user_id: uuid::Uuid, actor_url: &str) -> Result<()>;
+    async fn get_blocked_actors(&self, local_user_id: uuid::Uuid) -> Result<Vec<String>>;
+    async fn is_actor_blocked(&self, local_user_id: uuid::Uuid, actor_url: &str) -> Result<bool>;
+}

crates/adapters/activitypub-base/src/tests/actors.rs

@@ -0,0 +1,49 @@
+use super::*;
+
+#[test]
+fn person_serializes_with_enriched_fields() {
+    let person = Person {
+        kind: Default::default(),
+        id: "https://example.com/users/1"
+            .parse::<url::Url>()
+            .unwrap()
+            .into(),
+        preferred_username: "alice".to_string(),
+        inbox: "https://example.com/users/1/inbox".parse().unwrap(),
+        outbox: "https://example.com/users/1/outbox".parse().unwrap(),
+        followers: "https://example.com/users/1/followers".parse().unwrap(),
+        following: "https://example.com/users/1/following".parse().unwrap(),
+        public_key: PublicKey {
+            id: "https://example.com/users/1#main-key".to_string(),
+            owner: "https://example.com/users/1".parse().unwrap(),
+            public_key_pem: "pem".to_string(),
+        },
+        name: Some("Alice".to_string()),
+        summary: Some("Bio text".to_string()),
+        icon: Some(ApImageObject {
+            kind: "Image".to_string(),
+            url: "https://example.com/images/avatars/1".parse().unwrap(),
+        }),
+        url: Some("https://example.com/u/alice".parse().unwrap()),
+        discoverable: Some(true),
+        manually_approves_followers: true,
+        updated: Some(Utc::now()),
+        endpoints: Some(Endpoints {
+            shared_inbox: "https://example.com/inbox".parse().unwrap(),
+        }),
+        image: None,
+        also_known_as: vec![],
+        attachment: vec![],
+    };
+    let json = serde_json::to_value(&person).unwrap();
+    assert_eq!(json["discoverable"], true);
+    assert_eq!(json["summary"], "Bio text");
+    assert_eq!(json["icon"]["type"], "Image");
+    assert_eq!(json["manuallyApprovesFollowers"], true);
+    assert!(json.get("updated").is_some());
+    assert!(json.get("endpoints").is_some());
+    assert_eq!(
+        json["endpoints"]["sharedInbox"],
+        "https://example.com/inbox"
+    );
+}

crates/adapters/activitypub-base/src/tests/nodeinfo.rs

@@ -0,0 +1,40 @@
+use super::*;
+
+#[test]
+fn nodeinfo_well_known_serializes_correctly() {
+    let doc = NodeInfoWellKnown {
+        links: vec![NodeInfoLink {
+            rel: "http://nodeinfo.diaspora.software/ns/schema/2.0".to_string(),
+            href: "https://example.com/nodeinfo/2.0".to_string(),
+        }],
+    };
+    let json = serde_json::to_value(&doc).unwrap();
+    assert_eq!(
+        json["links"][0]["rel"],
+        "http://nodeinfo.diaspora.software/ns/schema/2.0"
+    );
+    assert_eq!(json["links"][0]["href"], "https://example.com/nodeinfo/2.0");
+}
+
+#[test]
+fn nodeinfo_serializes_camel_case() {
+    let doc = NodeInfo {
+        version: "2.0".to_string(),
+        software: NodeInfoSoftware {
+            name: "my-app".to_string(),
+            version: "0.1.0".to_string(),
+        },
+        protocols: vec!["activitypub".to_string()],
+        usage: NodeInfoUsage {
+            users: NodeInfoUsers { total: 3 },
+            local_posts: 42,
+        },
+        open_registrations: false,
+    };
+    let json = serde_json::to_value(&doc).unwrap();
+    assert_eq!(json["version"], "2.0");
+    assert_eq!(json["software"]["name"], "my-app");
+    assert_eq!(json["usage"]["users"]["total"], 3);
+    assert_eq!(json["usage"]["localPosts"], 42);
+    assert_eq!(json["openRegistrations"], false);
+}

crates/adapters/activitypub-base/src/tests/service.rs

@@ -0,0 +1,45 @@
+use super::*;
+use crate::repository::{Follower, FollowerStatus, RemoteActor};
+
+fn make_follower(inbox: &str, shared: Option<&str>) -> Follower {
+    Follower {
+        actor: RemoteActor {
+            url: format!("https://remote/{}", inbox),
+            handle: "user".to_string(),
+            inbox_url: inbox.to_string(),
+            shared_inbox_url: shared.map(|s| s.to_string()),
+            display_name: None,
+            avatar_url: None,
+            outbox_url: None,
+        },
+        status: FollowerStatus::Accepted,
+    }
+}
+
+#[test]
+fn collect_inboxes_deduplicates_shared() {
+    let followers = vec![
+        make_follower(
+            "https://mastodon.social/users/a/inbox",
+            Some("https://mastodon.social/inbox"),
+        ),
+        make_follower(
+            "https://mastodon.social/users/b/inbox",
+            Some("https://mastodon.social/inbox"),
+        ),
+        make_follower("https://other.instance/users/c/inbox", None),
+    ];
+    let inboxes = collect_inboxes(&followers);
+    assert_eq!(inboxes.len(), 2);
+    let strs: Vec<_> = inboxes.iter().map(|u| u.as_str()).collect();
+    assert!(strs.contains(&"https://mastodon.social/inbox"));
+    assert!(strs.contains(&"https://other.instance/users/c/inbox"));
+}
+
+#[test]
+fn collect_inboxes_falls_back_to_individual_inbox() {
+    let followers = vec![make_follower("https://example.com/users/x/inbox", None)];
+    let inboxes = collect_inboxes(&followers);
+    assert_eq!(inboxes.len(), 1);
+    assert_eq!(inboxes[0].as_str(), "https://example.com/users/x/inbox");
+}

crates/adapters/activitypub-base/src/urls.rs

@@ -0,0 +1,30 @@
+use url::Url;
+
+use crate::error::Error;
+
+pub const AS_PUBLIC: &str = "https://www.w3.org/ns/activitystreams#Public";
+
+pub fn extract_user_id_from_url(url: &Url) -> Option<uuid::Uuid> {
+    let path = url.path();
+    path.strip_prefix("/users/")
+        .and_then(|s| s.split('/').next())
+        .and_then(|s| uuid::Uuid::parse_str(s).ok())
+}
+
+pub fn activity_url(base_url: &str) -> Result<Url, Error> {
+    Url::parse(&format!("{}/activities/{}", base_url, uuid::Uuid::new_v4()))
+        .map_err(|e| Error::bad_request(anyhow::anyhow!(e)))
+}
+
+pub fn actor_url(base_url: &str, user_id: uuid::Uuid) -> Url {
+    Url::parse(&format!("{}/users/{}", base_url, user_id))
+        .expect("base_url is always a valid URL prefix")
+}
+
+/// Extract the username segment from a /users/:username URL.
+pub fn extract_username_from_url(url: &Url) -> Option<String> {
+    url.path()
+        .strip_prefix("/users/")
+        .and_then(|s| s.split('/').next())
+        .map(|s| s.to_string())
+}

crates/adapters/activitypub-base/src/user.rs

@@ -0,0 +1,27 @@
+use async_trait::async_trait;
+use url::Url;
+
+#[derive(Debug, Clone)]
+pub struct ApProfileField {
+    pub name: String,
+    pub value: String,
+}
+
+#[derive(Debug, Clone)]
+pub struct ApUser {
+    pub id: uuid::Uuid,
+    pub username: String,
+    pub bio: Option<String>,
+    pub avatar_url: Option<Url>,
+    pub banner_url: Option<Url>,
+    pub also_known_as: Option<String>,
+    pub profile_url: Option<Url>,
+    pub attachment: Vec<ApProfileField>,
+}
+
+#[async_trait]
+pub trait ApUserRepository: Send + Sync {
+    async fn find_by_id(&self, id: uuid::Uuid) -> anyhow::Result<Option<ApUser>>;
+    async fn find_by_username(&self, username: &str) -> anyhow::Result<Option<ApUser>>;
+    async fn count_users(&self) -> anyhow::Result<usize>;
+}

crates/adapters/activitypub-base/src/webfinger.rs

@@ -0,0 +1,38 @@
+use activitypub_federation::{
+    config::Data,
+    fetch::webfinger::{Webfinger, build_webfinger_response, extract_webfinger_name},
+};
+use axum::{
+    extract::Query,
+    http::header,
+    response::{IntoResponse, Response},
+};
+use serde::Deserialize;
+
+use crate::data::FederationData;
+use crate::error::Error;
+
+#[derive(Deserialize)]
+pub struct WebfingerQuery {
+    resource: String,
+}
+
+pub async fn webfinger_handler(
+    Query(query): Query<WebfingerQuery>,
+    data: Data<FederationData>,
+) -> Result<Response, Error> {
+    let name = extract_webfinger_name(&query.resource, &data)?;
+
+    let user = data
+        .user_repo
+        .find_by_username(name)
+        .await
+        .map_err(Error::from)?
+        .ok_or_else(|| Error::not_found(anyhow::anyhow!("user not found")))?;
+
+    let ap_id = crate::urls::actor_url(&data.base_url, user.id);
+
+    let wf: Webfinger = build_webfinger_response(query.resource, ap_id);
+    let body = serde_json::to_string(&wf).map_err(|e| Error::from(anyhow::anyhow!(e)))?;
+    Ok(([(header::CONTENT_TYPE, "application/jrd+json")], body).into_response())
+}

crates/adapters/activitypub/Cargo.toml

@@ -0,0 +1,17 @@
+[package]
+name = "activitypub"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+activitypub-base       = { workspace = true }
+activitypub_federation = "0.7.0-beta.11"
+domain                 = { workspace = true }
+url                    = { workspace = true }
+serde                  = { workspace = true }
+serde_json             = { workspace = true }
+anyhow                 = { workspace = true }
+chrono                 = { workspace = true }
+uuid                   = { workspace = true }
+async-trait            = { workspace = true }
+tracing                = { workspace = true }

crates/adapters/activitypub/src/handler.rs

@@ -0,0 +1,113 @@
+use std::sync::Arc;
+use anyhow::{anyhow, Result};
+use async_trait::async_trait;
+use chrono::{DateTime, Utc};
+use url::Url;
+
+use activitypub_base::ApObjectHandler;
+use domain::ports::ActivityPubRepository;
+use domain::value_objects::UserId;
+use crate::note::ThoughtNote;
+use crate::urls::ThoughtsUrls;
+
+pub struct ThoughtsObjectHandler {
+    repo: Arc<dyn ActivityPubRepository>,
+    urls: ThoughtsUrls,
+}
+
+impl ThoughtsObjectHandler {
+    pub fn new(repo: Arc<dyn ActivityPubRepository>, base_url: &str) -> Self {
+        Self { repo, urls: ThoughtsUrls::new(base_url) }
+    }
+}
+
+#[async_trait]
+impl ApObjectHandler for ThoughtsObjectHandler {
+    async fn get_local_objects_for_user(
+        &self,
+        user_id: uuid::Uuid,
+    ) -> Result<Vec<(Url, serde_json::Value)>> {
+        let uid = UserId::from_uuid(user_id);
+        let entries = self.repo.outbox_entries_for_actor(&uid).await
+            .map_err(|e| anyhow!("{e}"))?;
+        entries.into_iter().map(|e| {
+            let note_url    = self.urls.thought_url(e.thought.id.as_uuid());
+            let actor_url   = self.urls.user_url(e.author_username.as_str());
+            let followers   = self.urls.user_followers(e.author_username.as_str());
+            let in_reply_to = e.thought.in_reply_to_id.map(|id| self.urls.thought_url(id.as_uuid()));
+            let note = ThoughtNote::new_public(
+                note_url.clone(), actor_url,
+                e.thought.content.as_str().to_owned(),
+                e.thought.created_at, in_reply_to,
+                e.thought.sensitive, e.thought.content_warning, followers,
+            );
+            Ok((note_url, serde_json::to_value(&note)?))
+        }).collect()
+    }
+
+    async fn get_local_objects_page(
+        &self,
+        user_id: uuid::Uuid,
+        before: Option<DateTime<Utc>>,
+        limit: usize,
+    ) -> Result<Vec<(Url, serde_json::Value, DateTime<Utc>)>> {
+        let uid = UserId::from_uuid(user_id);
+        let entries = self.repo.outbox_page_for_actor(&uid, before, limit).await
+            .map_err(|e| anyhow!("{e}"))?;
+        entries.into_iter().map(|e| {
+            let created_at  = e.thought.created_at;
+            let note_url    = self.urls.thought_url(e.thought.id.as_uuid());
+            let actor_url   = self.urls.user_url(e.author_username.as_str());
+            let followers   = self.urls.user_followers(e.author_username.as_str());
+            let in_reply_to = e.thought.in_reply_to_id.map(|id| self.urls.thought_url(id.as_uuid()));
+            let note = ThoughtNote::new_public(
+                note_url.clone(), actor_url,
+                e.thought.content.as_str().to_owned(),
+                created_at, in_reply_to,
+                e.thought.sensitive, e.thought.content_warning, followers,
+            );
+            Ok((note_url, serde_json::to_value(&note)?, created_at))
+        }).collect()
+    }
+
+    async fn on_create(
+        &self,
+        ap_id: &Url,
+        actor_url: &Url,
+        object: serde_json::Value,
+    ) -> Result<()> {
+        let note: ThoughtNote = serde_json::from_value(object)?;
+        let author_id = self.repo.intern_remote_actor(actor_url).await
+            .map_err(|e| anyhow!("{e}"))?;
+        self.repo.accept_note(
+            ap_id, &author_id,
+            &note.content,
+            note.published,
+            note.sensitive,
+            note.summary,
+        ).await.map_err(|e| anyhow!("{e}"))
+    }
+
+    async fn on_update(
+        &self,
+        ap_id: &Url,
+        _actor_url: &Url,
+        object: serde_json::Value,
+    ) -> Result<()> {
+        let note: ThoughtNote = serde_json::from_value(object)?;
+        self.repo.apply_note_update(ap_id, &note.content).await
+            .map_err(|e| anyhow!("{e}"))
+    }
+
+    async fn on_delete(&self, ap_id: &Url, _actor_url: &Url) -> Result<()> {
+        self.repo.retract_note(ap_id).await.map_err(|e| anyhow!("{e}"))
+    }
+
+    async fn on_actor_removed(&self, actor_url: &Url) -> Result<()> {
+        self.repo.retract_actor_notes(actor_url).await.map_err(|e| anyhow!("{e}"))
+    }
+
+    async fn count_local_posts(&self) -> Result<u64> {
+        self.repo.count_local_notes().await.map_err(|e| anyhow!("{e}"))
+    }
+}

crates/adapters/activitypub/src/lib.rs

@@ -0,0 +1,7 @@
+pub mod handler;
+pub mod note;
+pub mod urls;
+
+pub use handler::ThoughtsObjectHandler;
+pub use note::ThoughtNote;
+pub use urls::ThoughtsUrls;

crates/adapters/activitypub/src/note.rs

@@ -0,0 +1,62 @@
+use activitypub_base::AS_PUBLIC;
+use activitypub_federation::kinds::object::NoteType;
+use chrono::{DateTime, Utc};
+use serde::{Deserialize, Serialize};
+use url::Url;
+
+/// AP Note representing a Thought.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ThoughtNote {
+    #[serde(rename = "type")]
+    pub kind: NoteType,
+    pub id: Url,
+    pub attributed_to: Url,
+    pub content: String,
+    pub published: DateTime<Utc>,
+    #[serde(skip_serializing_if = "Vec::is_empty", default)]
+    pub to: Vec<String>,
+    #[serde(skip_serializing_if = "Vec::is_empty", default)]
+    pub cc: Vec<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub in_reply_to: Option<Url>,
+    pub sensitive: bool,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub summary: Option<String>,
+}
+
+impl ThoughtNote {
+    pub fn new_public(
+        id: Url, actor_url: Url, content: String, published: DateTime<Utc>,
+        in_reply_to: Option<Url>, sensitive: bool, summary: Option<String>,
+        followers_url: Url,
+    ) -> Self {
+        Self {
+            kind: Default::default(),
+            id, attributed_to: actor_url, content, published,
+            to: vec![AS_PUBLIC.to_string()],
+            cc: vec![followers_url.to_string()],
+            in_reply_to, sensitive, summary,
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn note_serializes_with_public_audience() {
+        let note = ThoughtNote::new_public(
+            "https://example.com/thoughts/1".parse().unwrap(),
+            "https://example.com/users/alice".parse().unwrap(),
+            "Hello world".to_string(),
+            chrono::Utc::now(),
+            None, false, None,
+            "https://example.com/users/alice/followers".parse().unwrap(),
+        );
+        let json = serde_json::to_string(&note).unwrap();
+        assert!(json.contains(AS_PUBLIC));
+        assert!(json.contains("Hello world"));
+    }
+}

crates/adapters/activitypub/src/urls.rs

@@ -0,0 +1,49 @@
+use url::Url;
+
+pub struct ThoughtsUrls {
+    pub base_url: String,
+}
+
+impl ThoughtsUrls {
+    pub fn new(base_url: &str) -> Self {
+        Self { base_url: base_url.trim_end_matches('/').to_string() }
+    }
+
+    pub fn user_url(&self, username: &str) -> Url {
+        Url::parse(&format!("{}/users/{}", self.base_url, username)).expect("valid URL")
+    }
+
+    pub fn thought_url(&self, thought_id: uuid::Uuid) -> Url {
+        Url::parse(&format!("{}/thoughts/{}", self.base_url, thought_id)).expect("valid URL")
+    }
+
+    pub fn user_inbox(&self, username: &str) -> Url {
+        Url::parse(&format!("{}/users/{}/inbox", self.base_url, username)).expect("valid URL")
+    }
+
+    pub fn user_outbox(&self, username: &str) -> Url {
+        Url::parse(&format!("{}/users/{}/outbox", self.base_url, username)).expect("valid URL")
+    }
+
+    pub fn user_followers(&self, username: &str) -> Url {
+        Url::parse(&format!("{}/users/{}/followers", self.base_url, username)).expect("valid URL")
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn user_url_format() {
+        let urls = ThoughtsUrls::new("https://example.com");
+        assert_eq!(urls.user_url("alice").as_str(), "https://example.com/users/alice");
+    }
+
+    #[test]
+    fn thought_url_format() {
+        let urls = ThoughtsUrls::new("https://example.com");
+        let id = uuid::Uuid::nil();
+        assert!(urls.thought_url(id).as_str().starts_with("https://example.com/thoughts/"));
+    }
+}

crates/adapters/auth/Cargo.toml

@@ -0,0 +1,16 @@
+[package]
+name = "auth"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+domain       = { workspace = true }
+async-trait  = { workspace = true }
+thiserror    = { workspace = true }
+uuid         = { workspace = true }
+chrono       = { workspace = true }
+tokio        = { workspace = true }
+serde        = { workspace = true }
+jsonwebtoken = "9"
+argon2       = "0.5"
+rand          = "0.8"

crates/adapters/auth/src/lib.rs

@@ -0,0 +1,116 @@
+use async_trait::async_trait;
+use chrono::{Duration, Utc};
+use jsonwebtoken::{decode, encode, DecodingKey, EncodingKey, Header, Validation};
+use serde::{Deserialize, Serialize};
+use domain::{
+    errors::DomainError,
+    ports::{AuthService, GeneratedToken, PasswordHasher},
+    value_objects::{PasswordHash, UserId},
+};
+
+#[derive(Serialize, Deserialize)]
+struct Claims {
+    sub: String,
+    exp: usize,
+}
+
+pub struct JwtAuthService {
+    secret: String,
+    ttl_seconds: i64,
+}
+
+impl JwtAuthService {
+    pub fn new(secret: String, ttl_seconds: i64) -> Self {
+        Self { secret, ttl_seconds }
+    }
+}
+
+impl AuthService for JwtAuthService {
+    fn generate_token(&self, user_id: &UserId) -> Result<GeneratedToken, DomainError> {
+        let exp = (Utc::now() + Duration::seconds(self.ttl_seconds)).timestamp() as usize;
+        let claims = Claims {
+            sub: user_id.as_uuid().to_string(),
+            exp,
+        };
+        let token = encode(
+            &Header::default(),
+            &claims,
+            &EncodingKey::from_secret(self.secret.as_bytes()),
+        )
+        .map_err(|e| DomainError::Internal(e.to_string()))?;
+        Ok(GeneratedToken {
+            token,
+            user_id: user_id.clone(),
+        })
+    }
+
+    fn validate_token(&self, token: &str) -> Result<UserId, DomainError> {
+        let data = decode::<Claims>(
+            token,
+            &DecodingKey::from_secret(self.secret.as_bytes()),
+            &Validation::default(),
+        )
+        .map_err(|_| DomainError::Unauthorized)?;
+        let uuid = uuid::Uuid::parse_str(&data.claims.sub)
+            .map_err(|_| DomainError::Unauthorized)?;
+        Ok(UserId::from_uuid(uuid))
+    }
+}
+
+pub struct Argon2PasswordHasher;
+
+#[async_trait]
+impl PasswordHasher for Argon2PasswordHasher {
+    async fn hash(&self, plain: &str) -> Result<PasswordHash, DomainError> {
+        use argon2::{
+            password_hash::SaltString,
+            Argon2, PasswordHasher as _,
+        };
+        use rand::rngs::OsRng;
+        let salt = SaltString::generate(OsRng);
+        let hash = Argon2::default()
+            .hash_password(plain.as_bytes(), &salt)
+            .map_err(|e| DomainError::Internal(e.to_string()))?
+            .to_string();
+        Ok(PasswordHash(hash))
+    }
+
+    async fn verify(&self, plain: &str, hash: &PasswordHash) -> Result<bool, DomainError> {
+        use argon2::{password_hash::PasswordHash as ArgonHash, Argon2, PasswordVerifier};
+        let parsed = ArgonHash::new(&hash.0)
+            .map_err(|e| DomainError::Internal(e.to_string()))?;
+        Ok(Argon2::default()
+            .verify_password(plain.as_bytes(), &parsed)
+            .is_ok())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use domain::ports::AuthService;
+
+    #[test]
+    fn generate_and_validate_token() {
+        let svc = JwtAuthService::new("secret".into(), 3600);
+        let id = UserId::new();
+        let tok = svc.generate_token(&id).unwrap();
+        let parsed = svc.validate_token(&tok.token).unwrap();
+        assert_eq!(parsed.as_uuid(), id.as_uuid());
+    }
+
+    #[test]
+    fn invalid_token_returns_unauthorized() {
+        let svc = JwtAuthService::new("secret".into(), 3600);
+        let err = svc.validate_token("not.a.token").unwrap_err();
+        assert!(matches!(err, DomainError::Unauthorized));
+    }
+
+    #[tokio::test]
+    async fn hash_and_verify() {
+        let hasher = Argon2PasswordHasher;
+        let hash = hasher.hash("mypassword").await.unwrap();
+        assert!(hasher.verify("mypassword", &hash).await.unwrap());
+        assert!(!hasher.verify("wrongpassword", &hash).await.unwrap());
+    }
+}

crates/adapters/event-payload/Cargo.toml

@@ -0,0 +1,10 @@
+[package]
+name = "event-payload"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+serde      = { workspace = true }
+serde_json = { workspace = true }
+domain     = { workspace = true }
+uuid       = { workspace = true }

crates/adapters/event-payload/src/lib.rs

@@ -0,0 +1,239 @@
+use domain::{
+    errors::DomainError,
+    events::DomainEvent,
+    value_objects::{BoostId, LikeId, ThoughtId, UserId},
+};
+use serde::{Deserialize, Serialize};
+
+/// Serializable mirror of domain::events::DomainEvent.
+/// All IDs are Strings (UUID hex) — no domain type dependencies.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(tag = "type", content = "data")]
+pub enum EventPayload {
+    ThoughtCreated {
+        thought_id: String,
+        user_id: String,
+        in_reply_to_id: Option<String>,
+    },
+    ThoughtDeleted {
+        thought_id: String,
+        user_id: String,
+    },
+    ThoughtUpdated {
+        thought_id: String,
+        user_id: String,
+    },
+    LikeAdded {
+        like_id: String,
+        user_id: String,
+        thought_id: String,
+    },
+    LikeRemoved {
+        user_id: String,
+        thought_id: String,
+    },
+    BoostAdded {
+        boost_id: String,
+        user_id: String,
+        thought_id: String,
+    },
+    BoostRemoved {
+        user_id: String,
+        thought_id: String,
+    },
+    FollowRequested {
+        follower_id: String,
+        following_id: String,
+    },
+    FollowAccepted {
+        follower_id: String,
+        following_id: String,
+    },
+    FollowRejected {
+        follower_id: String,
+        following_id: String,
+    },
+    Unfollowed {
+        follower_id: String,
+        following_id: String,
+    },
+    UserBlocked {
+        blocker_id: String,
+        blocked_id: String,
+    },
+}
+
+impl EventPayload {
+    /// Returns the NATS subject for this event.
+    pub fn subject(&self) -> &'static str {
+        match self {
+            Self::ThoughtCreated { .. }  => "thoughts.created",
+            Self::ThoughtDeleted { .. }  => "thoughts.deleted",
+            Self::ThoughtUpdated { .. }  => "thoughts.updated",
+            Self::LikeAdded { .. }       => "likes.added",
+            Self::LikeRemoved { .. }     => "likes.removed",
+            Self::BoostAdded { .. }      => "boosts.added",
+            Self::BoostRemoved { .. }    => "boosts.removed",
+            Self::FollowRequested { .. } => "follows.requested",
+            Self::FollowAccepted { .. }  => "follows.accepted",
+            Self::FollowRejected { .. }  => "follows.rejected",
+            Self::Unfollowed { .. }      => "follows.removed",
+            Self::UserBlocked { .. }     => "users.blocked",
+        }
+    }
+}
+
+// ── DomainEvent → EventPayload ─────────────────────────────────────────────
+
+impl From<&DomainEvent> for EventPayload {
+    fn from(e: &DomainEvent) -> Self {
+        match e {
+            DomainEvent::ThoughtCreated { thought_id, user_id, in_reply_to_id } => Self::ThoughtCreated {
+                thought_id: thought_id.to_string(),
+                user_id: user_id.to_string(),
+                in_reply_to_id: in_reply_to_id.as_ref().map(|x| x.to_string()),
+            },
+            DomainEvent::ThoughtDeleted { thought_id, user_id } => Self::ThoughtDeleted {
+                thought_id: thought_id.to_string(), user_id: user_id.to_string(),
+            },
+            DomainEvent::ThoughtUpdated { thought_id, user_id } => Self::ThoughtUpdated {
+                thought_id: thought_id.to_string(), user_id: user_id.to_string(),
+            },
+            DomainEvent::LikeAdded { like_id, user_id, thought_id } => Self::LikeAdded {
+                like_id: like_id.to_string(), user_id: user_id.to_string(), thought_id: thought_id.to_string(),
+            },
+            DomainEvent::LikeRemoved { user_id, thought_id } => Self::LikeRemoved {
+                user_id: user_id.to_string(), thought_id: thought_id.to_string(),
+            },
+            DomainEvent::BoostAdded { boost_id, user_id, thought_id } => Self::BoostAdded {
+                boost_id: boost_id.to_string(), user_id: user_id.to_string(), thought_id: thought_id.to_string(),
+            },
+            DomainEvent::BoostRemoved { user_id, thought_id } => Self::BoostRemoved {
+                user_id: user_id.to_string(), thought_id: thought_id.to_string(),
+            },
+            DomainEvent::FollowRequested { follower_id, following_id } => Self::FollowRequested {
+                follower_id: follower_id.to_string(), following_id: following_id.to_string(),
+            },
+            DomainEvent::FollowAccepted { follower_id, following_id } => Self::FollowAccepted {
+                follower_id: follower_id.to_string(), following_id: following_id.to_string(),
+            },
+            DomainEvent::FollowRejected { follower_id, following_id } => Self::FollowRejected {
+                follower_id: follower_id.to_string(), following_id: following_id.to_string(),
+            },
+            DomainEvent::Unfollowed { follower_id, following_id } => Self::Unfollowed {
+                follower_id: follower_id.to_string(), following_id: following_id.to_string(),
+            },
+            DomainEvent::UserBlocked { blocker_id, blocked_id } => Self::UserBlocked {
+                blocker_id: blocker_id.to_string(), blocked_id: blocked_id.to_string(),
+            },
+        }
+    }
+}
+
+// ── EventPayload → DomainEvent ─────────────────────────────────────────────
+
+fn parse_uuid(s: &str, field: &str) -> Result<uuid::Uuid, DomainError> {
+    uuid::Uuid::parse_str(s)
+        .map_err(|_| DomainError::Internal(format!("invalid uuid for {field}: {s}")))
+}
+
+impl TryFrom<EventPayload> for DomainEvent {
+    type Error = DomainError;
+
+    fn try_from(p: EventPayload) -> Result<Self, DomainError> {
+        Ok(match p {
+            EventPayload::ThoughtCreated { thought_id, user_id, in_reply_to_id } => DomainEvent::ThoughtCreated {
+                thought_id: ThoughtId::from_uuid(parse_uuid(&thought_id, "thought_id")?),
+                user_id: UserId::from_uuid(parse_uuid(&user_id, "user_id")?),
+                in_reply_to_id: in_reply_to_id
+                    .map(|s| parse_uuid(&s, "in_reply_to_id").map(ThoughtId::from_uuid))
+                    .transpose()?,
+            },
+            EventPayload::ThoughtDeleted { thought_id, user_id } => DomainEvent::ThoughtDeleted {
+                thought_id: ThoughtId::from_uuid(parse_uuid(&thought_id, "thought_id")?),
+                user_id: UserId::from_uuid(parse_uuid(&user_id, "user_id")?),
+            },
+            EventPayload::ThoughtUpdated { thought_id, user_id } => DomainEvent::ThoughtUpdated {
+                thought_id: ThoughtId::from_uuid(parse_uuid(&thought_id, "thought_id")?),
+                user_id: UserId::from_uuid(parse_uuid(&user_id, "user_id")?),
+            },
+            EventPayload::LikeAdded { like_id, user_id, thought_id } => DomainEvent::LikeAdded {
+                like_id: LikeId::from_uuid(parse_uuid(&like_id, "like_id")?),
+                user_id: UserId::from_uuid(parse_uuid(&user_id, "user_id")?),
+                thought_id: ThoughtId::from_uuid(parse_uuid(&thought_id, "thought_id")?),
+            },
+            EventPayload::LikeRemoved { user_id, thought_id } => DomainEvent::LikeRemoved {
+                user_id: UserId::from_uuid(parse_uuid(&user_id, "user_id")?),
+                thought_id: ThoughtId::from_uuid(parse_uuid(&thought_id, "thought_id")?),
+            },
+            EventPayload::BoostAdded { boost_id, user_id, thought_id } => DomainEvent::BoostAdded {
+                boost_id: BoostId::from_uuid(parse_uuid(&boost_id, "boost_id")?),
+                user_id: UserId::from_uuid(parse_uuid(&user_id, "user_id")?),
+                thought_id: ThoughtId::from_uuid(parse_uuid(&thought_id, "thought_id")?),
+            },
+            EventPayload::BoostRemoved { user_id, thought_id } => DomainEvent::BoostRemoved {
+                user_id: UserId::from_uuid(parse_uuid(&user_id, "user_id")?),
+                thought_id: ThoughtId::from_uuid(parse_uuid(&thought_id, "thought_id")?),
+            },
+            EventPayload::FollowRequested { follower_id, following_id } => DomainEvent::FollowRequested {
+                follower_id: UserId::from_uuid(parse_uuid(&follower_id, "follower_id")?),
+                following_id: UserId::from_uuid(parse_uuid(&following_id, "following_id")?),
+            },
+            EventPayload::FollowAccepted { follower_id, following_id } => DomainEvent::FollowAccepted {
+                follower_id: UserId::from_uuid(parse_uuid(&follower_id, "follower_id")?),
+                following_id: UserId::from_uuid(parse_uuid(&following_id, "following_id")?),
+            },
+            EventPayload::FollowRejected { follower_id, following_id } => DomainEvent::FollowRejected {
+                follower_id: UserId::from_uuid(parse_uuid(&follower_id, "follower_id")?),
+                following_id: UserId::from_uuid(parse_uuid(&following_id, "following_id")?),
+            },
+            EventPayload::Unfollowed { follower_id, following_id } => DomainEvent::Unfollowed {
+                follower_id: UserId::from_uuid(parse_uuid(&follower_id, "follower_id")?),
+                following_id: UserId::from_uuid(parse_uuid(&following_id, "following_id")?),
+            },
+            EventPayload::UserBlocked { blocker_id, blocked_id } => DomainEvent::UserBlocked {
+                blocker_id: UserId::from_uuid(parse_uuid(&blocker_id, "blocker_id")?),
+                blocked_id: UserId::from_uuid(parse_uuid(&blocked_id, "blocked_id")?),
+            },
+        })
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn thought_created_roundtrip() {
+        let p = EventPayload::ThoughtCreated {
+            thought_id: "abc".into(),
+            user_id: "def".into(),
+            in_reply_to_id: None,
+        };
+        let json = serde_json::to_string(&p).unwrap();
+        let back: EventPayload = serde_json::from_str(&json).unwrap();
+        assert_eq!(back.subject(), "thoughts.created");
+    }
+
+    #[test]
+    fn all_subjects_are_unique() {
+        let samples: &[EventPayload] = &[
+            EventPayload::ThoughtCreated { thought_id: "a".into(), user_id: "b".into(), in_reply_to_id: None },
+            EventPayload::ThoughtDeleted { thought_id: "a".into(), user_id: "b".into() },
+            EventPayload::ThoughtUpdated { thought_id: "a".into(), user_id: "b".into() },
+            EventPayload::LikeAdded { like_id: "a".into(), user_id: "b".into(), thought_id: "c".into() },
+            EventPayload::LikeRemoved { user_id: "b".into(), thought_id: "c".into() },
+            EventPayload::BoostAdded { boost_id: "a".into(), user_id: "b".into(), thought_id: "c".into() },
+            EventPayload::BoostRemoved { user_id: "b".into(), thought_id: "c".into() },
+            EventPayload::FollowRequested { follower_id: "a".into(), following_id: "b".into() },
+            EventPayload::FollowAccepted { follower_id: "a".into(), following_id: "b".into() },
+            EventPayload::FollowRejected { follower_id: "a".into(), following_id: "b".into() },
+            EventPayload::Unfollowed { follower_id: "a".into(), following_id: "b".into() },
+            EventPayload::UserBlocked { blocker_id: "a".into(), blocked_id: "b".into() },
+        ];
+        let mut subjects: Vec<&str> = samples.iter().map(|p| p.subject()).collect();
+        subjects.sort();
+        subjects.dedup();
+        assert_eq!(subjects.len(), samples.len(), "each event must have a unique subject");
+    }
+}

crates/adapters/event-publisher/Cargo.toml

@@ -0,0 +1,4 @@
+[package]
+name = "event-publisher"
+version = "0.1.0"
+edition = "2021"

crates/adapters/nats/Cargo.toml

@@ -0,0 +1,16 @@
+[package]
+name = "nats"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+domain        = { workspace = true }
+event-payload = { workspace = true }
+async-nats    = { workspace = true }
+async-stream  = { workspace = true }
+serde_json    = { workspace = true }
+futures       = { workspace = true }
+tokio         = { workspace = true }
+async-trait   = { workspace = true }
+tracing       = { workspace = true }
+uuid          = { workspace = true }

crates/adapters/nats/src/lib.rs

@@ -0,0 +1,114 @@
+use async_trait::async_trait;
+use domain::{
+    errors::DomainError,
+    events::{DomainEvent, EventEnvelope},
+    ports::{EventConsumer, EventPublisher},
+};
+use event_payload::EventPayload;
+use futures::stream::BoxStream;
+
+// ── NatsEventPublisher ────────────────────────────────────────────────────
+
+pub struct NatsEventPublisher {
+    client: async_nats::Client,
+}
+
+impl NatsEventPublisher {
+    pub fn new(client: async_nats::Client) -> Self { Self { client } }
+}
+
+#[async_trait]
+impl EventPublisher for NatsEventPublisher {
+    async fn publish(&self, event: &DomainEvent) -> Result<(), DomainError> {
+        let payload = EventPayload::from(event);
+        let subject = payload.subject();
+        let bytes = serde_json::to_vec(&payload)
+            .map_err(|e| DomainError::Internal(e.to_string()))?;
+        self.client
+            .publish(subject, bytes.into())
+            .await
+            .map_err(|e| DomainError::Internal(e.to_string()))
+    }
+}
+
+// ── NatsEventConsumer ─────────────────────────────────────────────────────
+
+pub struct NatsEventConsumer {
+    client: async_nats::Client,
+}
+
+impl NatsEventConsumer {
+    pub fn new(client: async_nats::Client) -> Self { Self { client } }
+}
+
+impl EventConsumer for NatsEventConsumer {
+    fn consume(&self) -> BoxStream<'_, Result<EventEnvelope, DomainError>> {
+        let client = self.client.clone();
+        Box::pin(async_stream::try_stream! {
+            let mut sub = client
+                .subscribe(">")
+                .await
+                .map_err(|e| DomainError::Internal(e.to_string()))?;
+
+            use futures::StreamExt;
+            while let Some(msg) = sub.next().await {
+                let payload = match serde_json::from_slice::<EventPayload>(&msg.payload) {
+                    Ok(p) => p,
+                    Err(e) => {
+                        tracing::warn!("failed to deserialize event payload: {e}");
+                        continue;
+                    }
+                };
+                let event = match DomainEvent::try_from(payload) {
+                    Ok(e) => e,
+                    Err(e) => {
+                        tracing::warn!("failed to convert payload to domain event: {e}");
+                        continue;
+                    }
+                };
+                // Basic NATS: no ack/nack (at-most-once delivery)
+                yield EventEnvelope {
+                    event,
+                    ack:  Box::new(|| {}),
+                    nack: Box::new(|| {}),
+                };
+            }
+        })
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use domain::value_objects::{LikeId, ThoughtId, UserId};
+
+    #[test]
+    fn payload_from_domain_event_has_correct_subject() {
+        let event = DomainEvent::ThoughtCreated {
+            thought_id: ThoughtId::new(),
+            user_id: UserId::new(),
+            in_reply_to_id: None,
+        };
+        let payload = EventPayload::from(&event);
+        assert_eq!(payload.subject(), "thoughts.created");
+    }
+
+    #[test]
+    fn domain_event_roundtrip_via_payload() {
+        let uid = UserId::new();
+        let tid = ThoughtId::new();
+        let event = DomainEvent::LikeAdded {
+            like_id: LikeId::new(),
+            user_id: uid.clone(),
+            thought_id: tid.clone(),
+        };
+        let payload = EventPayload::from(&event);
+        let back = DomainEvent::try_from(payload).unwrap();
+        if let DomainEvent::LikeAdded { user_id, thought_id, .. } = back {
+            assert_eq!(user_id, uid);
+            assert_eq!(thought_id, tid);
+        } else {
+            panic!("wrong variant");
+        }
+    }
+}

crates/adapters/postgres-federation/Cargo.toml

@@ -0,0 +1,18 @@
+[package]
+name = "postgres-federation"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+activitypub-base = { workspace = true }
+sqlx        = { workspace = true }
+uuid        = { workspace = true }
+chrono      = { workspace = true }
+tracing     = { workspace = true }
+async-trait = { workspace = true }
+anyhow      = { workspace = true }
+url         = { workspace = true }
+
+[dev-dependencies]
+tokio = { workspace = true, features = ["full"] }
+sqlx  = { workspace = true, features = ["migrate"] }

crates/adapters/postgres-federation/src/lib.rs

@@ -0,0 +1,362 @@
+use anyhow::{anyhow, Result};
+use async_trait::async_trait;
+use chrono::{DateTime, Utc};
+use sqlx::PgPool;
+
+use activitypub_base::{
+    ApUser, ApUserRepository,
+    BlockedDomain, FederationRepository, Follower, FollowerStatus, FollowingStatus, RemoteActor,
+};
+
+// ── PostgresFederationRepository ─────────────────────────────────────────────
+
+pub struct PostgresFederationRepository {
+    pool: PgPool,
+}
+
+impl PostgresFederationRepository {
+    pub fn new(pool: PgPool) -> Self { Self { pool } }
+}
+
+fn status_str(s: &FollowerStatus) -> &'static str {
+    match s { FollowerStatus::Pending => "pending", FollowerStatus::Accepted => "accepted", FollowerStatus::Rejected => "rejected" }
+}
+fn str_status(s: &str) -> FollowerStatus {
+    match s { "accepted" => FollowerStatus::Accepted, "rejected" => FollowerStatus::Rejected, _ => FollowerStatus::Pending }
+}
+
+fn map_remote_actor(
+    url: String, handle: String, inbox_url: String,
+    shared_inbox_url: Option<String>, display_name: Option<String>,
+    avatar_url: Option<String>, outbox_url: Option<String>,
+) -> RemoteActor {
+    RemoteActor { url, handle, inbox_url, shared_inbox_url, display_name, avatar_url, outbox_url }
+}
+
+#[async_trait]
+impl FederationRepository for PostgresFederationRepository {
+    async fn add_follower(
+        &self, local_user_id: uuid::Uuid, remote_actor_url: &str,
+        status: FollowerStatus, follow_activity_id: &str,
+    ) -> Result<()> {
+        sqlx::query(
+            "INSERT INTO federation_followers(local_user_id,remote_actor_url,status,follow_activity_id)
+             VALUES($1,$2,$3,$4)
+             ON CONFLICT(local_user_id,remote_actor_url) DO UPDATE
+             SET status=EXCLUDED.status, follow_activity_id=EXCLUDED.follow_activity_id"
+        )
+        .bind(local_user_id).bind(remote_actor_url).bind(status_str(&status)).bind(follow_activity_id)
+        .execute(&self.pool).await.map_err(|e| anyhow!(e)).map(|_| ())
+    }
+
+    async fn get_follower_follow_activity_id(
+        &self, local_user_id: uuid::Uuid, remote_actor_url: &str,
+    ) -> Result<Option<String>> {
+        sqlx::query_scalar::<_, String>(
+            "SELECT follow_activity_id FROM federation_followers WHERE local_user_id=$1 AND remote_actor_url=$2"
+        ).bind(local_user_id).bind(remote_actor_url).fetch_optional(&self.pool).await.map_err(|e| anyhow!(e))
+    }
+
+    async fn remove_follower(&self, local_user_id: uuid::Uuid, remote_actor_url: &str) -> Result<()> {
+        sqlx::query("DELETE FROM federation_followers WHERE local_user_id=$1 AND remote_actor_url=$2")
+            .bind(local_user_id).bind(remote_actor_url)
+            .execute(&self.pool).await.map_err(|e| anyhow!(e)).map(|_| ())
+    }
+
+    async fn get_followers(&self, local_user_id: uuid::Uuid) -> Result<Vec<Follower>> {
+        #[derive(sqlx::FromRow)]
+        struct Row { remote_actor_url: String, status: String, handle: String, inbox_url: String, shared_inbox_url: Option<String>, display_name: Option<String>, avatar_url: Option<String>, outbox_url: Option<String> }
+        sqlx::query_as::<_, Row>(
+            "SELECT f.remote_actor_url, f.status, COALESCE(r.handle,'') AS handle,
+             COALESCE(r.inbox_url,'') AS inbox_url, r.shared_inbox_url, r.display_name, r.avatar_url, r.outbox_url
+             FROM federation_followers f
+             LEFT JOIN remote_actors r ON r.url=f.remote_actor_url
+             WHERE f.local_user_id=$1"
+        ).bind(local_user_id).fetch_all(&self.pool).await.map_err(|e| anyhow!(e)).map(|rows| rows.into_iter().map(|r| Follower {
+            actor: map_remote_actor(r.remote_actor_url, r.handle, r.inbox_url, r.shared_inbox_url, r.display_name, r.avatar_url, r.outbox_url),
+            status: str_status(&r.status),
+        }).collect())
+    }
+
+    async fn get_followers_page(
+        &self, local_user_id: uuid::Uuid, offset: u32, limit: usize,
+    ) -> Result<Vec<Follower>> {
+        #[derive(sqlx::FromRow)]
+        struct Row { remote_actor_url: String, status: String, handle: String, inbox_url: String, shared_inbox_url: Option<String>, display_name: Option<String>, avatar_url: Option<String>, outbox_url: Option<String> }
+        sqlx::query_as::<_, Row>(
+            "SELECT f.remote_actor_url, f.status, COALESCE(r.handle,'') AS handle,
+             COALESCE(r.inbox_url,'') AS inbox_url, r.shared_inbox_url, r.display_name, r.avatar_url, r.outbox_url
+             FROM federation_followers f
+             LEFT JOIN remote_actors r ON r.url=f.remote_actor_url
+             WHERE f.local_user_id=$1 AND f.status='accepted'
+             ORDER BY f.created_at DESC LIMIT $2 OFFSET $3"
+        ).bind(local_user_id).bind(limit as i64).bind(offset as i64).fetch_all(&self.pool).await.map_err(|e| anyhow!(e)).map(|rows| rows.into_iter().map(|r| Follower {
+            actor: map_remote_actor(r.remote_actor_url, r.handle, r.inbox_url, r.shared_inbox_url, r.display_name, r.avatar_url, r.outbox_url),
+            status: str_status(&r.status),
+        }).collect())
+    }
+
+    async fn count_followers(&self, local_user_id: uuid::Uuid) -> Result<usize> {
+        let n: i64 = sqlx::query_scalar(
+            "SELECT COUNT(*) FROM federation_followers WHERE local_user_id=$1 AND status='accepted'"
+        ).bind(local_user_id).fetch_one(&self.pool).await.map_err(|e| anyhow!(e))?;
+        Ok(n as usize)
+    }
+
+    async fn get_pending_followers(&self, local_user_id: uuid::Uuid) -> Result<Vec<RemoteActor>> {
+        #[derive(sqlx::FromRow)]
+        struct Row { remote_actor_url: String, handle: String, inbox_url: String, shared_inbox_url: Option<String>, display_name: Option<String>, avatar_url: Option<String>, outbox_url: Option<String> }
+        sqlx::query_as::<_, Row>(
+            "SELECT f.remote_actor_url, COALESCE(r.handle,'') AS handle,
+             COALESCE(r.inbox_url,'') AS inbox_url, r.shared_inbox_url, r.display_name, r.avatar_url, r.outbox_url
+             FROM federation_followers f
+             LEFT JOIN remote_actors r ON r.url=f.remote_actor_url
+             WHERE f.local_user_id=$1 AND f.status='pending'"
+        ).bind(local_user_id).fetch_all(&self.pool).await.map_err(|e| anyhow!(e)).map(|rows| rows.into_iter().map(|r|
+            map_remote_actor(r.remote_actor_url, r.handle, r.inbox_url, r.shared_inbox_url, r.display_name, r.avatar_url, r.outbox_url)
+        ).collect())
+    }
+
+    async fn update_follower_status(
+        &self, local_user_id: uuid::Uuid, remote_actor_url: &str, status: FollowerStatus,
+    ) -> Result<()> {
+        sqlx::query("UPDATE federation_followers SET status=$3 WHERE local_user_id=$1 AND remote_actor_url=$2")
+            .bind(local_user_id).bind(remote_actor_url).bind(status_str(&status))
+            .execute(&self.pool).await.map_err(|e| anyhow!(e)).map(|_| ())
+    }
+
+    async fn add_following(
+        &self, local_user_id: uuid::Uuid, actor: RemoteActor, follow_activity_id: &str,
+    ) -> Result<()> {
+        self.upsert_remote_actor(actor.clone()).await?;
+        sqlx::query(
+            "INSERT INTO federation_following(local_user_id,remote_actor_url,follow_activity_id,outbox_url)
+             VALUES($1,$2,$3,$4)
+             ON CONFLICT(local_user_id,remote_actor_url) DO UPDATE
+             SET follow_activity_id=EXCLUDED.follow_activity_id"
+        )
+        .bind(local_user_id).bind(&actor.url).bind(follow_activity_id).bind(&actor.outbox_url)
+        .execute(&self.pool).await.map_err(|e| anyhow!(e)).map(|_| ())
+    }
+
+    async fn get_follow_activity_id(
+        &self, local_user_id: uuid::Uuid, remote_actor_url: &str,
+    ) -> Result<Option<String>> {
+        sqlx::query_scalar::<_, String>(
+            "SELECT follow_activity_id FROM federation_following WHERE local_user_id=$1 AND remote_actor_url=$2"
+        ).bind(local_user_id).bind(remote_actor_url).fetch_optional(&self.pool).await.map_err(|e| anyhow!(e))
+    }
+
+    async fn remove_following(&self, local_user_id: uuid::Uuid, actor_url: &str) -> Result<()> {
+        sqlx::query("DELETE FROM federation_following WHERE local_user_id=$1 AND remote_actor_url=$2")
+            .bind(local_user_id).bind(actor_url)
+            .execute(&self.pool).await.map_err(|e| anyhow!(e)).map(|_| ())
+    }
+
+    async fn get_following(&self, local_user_id: uuid::Uuid) -> Result<Vec<RemoteActor>> {
+        #[derive(sqlx::FromRow)]
+        struct Row { remote_actor_url: String, handle: String, inbox_url: String, shared_inbox_url: Option<String>, display_name: Option<String>, avatar_url: Option<String>, outbox_url: Option<String> }
+        sqlx::query_as::<_, Row>(
+            "SELECT f.remote_actor_url, COALESCE(r.handle,'') AS handle,
+             COALESCE(r.inbox_url,'') AS inbox_url, r.shared_inbox_url, r.display_name, r.avatar_url, r.outbox_url
+             FROM federation_following f
+             LEFT JOIN remote_actors r ON r.url=f.remote_actor_url
+             WHERE f.local_user_id=$1"
+        ).bind(local_user_id).fetch_all(&self.pool).await.map_err(|e| anyhow!(e)).map(|rows| rows.into_iter().map(|r|
+            map_remote_actor(r.remote_actor_url, r.handle, r.inbox_url, r.shared_inbox_url, r.display_name, r.avatar_url, r.outbox_url)
+        ).collect())
+    }
+
+    async fn get_following_page(
+        &self, local_user_id: uuid::Uuid, offset: u32, limit: usize,
+    ) -> Result<Vec<RemoteActor>> {
+        #[derive(sqlx::FromRow)]
+        struct Row { remote_actor_url: String, handle: String, inbox_url: String, shared_inbox_url: Option<String>, display_name: Option<String>, avatar_url: Option<String>, outbox_url: Option<String> }
+        sqlx::query_as::<_, Row>(
+            "SELECT f.remote_actor_url, COALESCE(r.handle,'') AS handle,
+             COALESCE(r.inbox_url,'') AS inbox_url, r.shared_inbox_url, r.display_name, r.avatar_url, r.outbox_url
+             FROM federation_following f
+             LEFT JOIN remote_actors r ON r.url=f.remote_actor_url
+             WHERE f.local_user_id=$1
+             ORDER BY f.created_at DESC LIMIT $2 OFFSET $3"
+        ).bind(local_user_id).bind(limit as i64).bind(offset as i64).fetch_all(&self.pool).await.map_err(|e| anyhow!(e)).map(|rows| rows.into_iter().map(|r|
+            map_remote_actor(r.remote_actor_url, r.handle, r.inbox_url, r.shared_inbox_url, r.display_name, r.avatar_url, r.outbox_url)
+        ).collect())
+    }
+
+    async fn count_following(&self, local_user_id: uuid::Uuid) -> Result<usize> {
+        let n: i64 = sqlx::query_scalar(
+            "SELECT COUNT(*) FROM federation_following WHERE local_user_id=$1"
+        ).bind(local_user_id).fetch_one(&self.pool).await.map_err(|e| anyhow!(e))?;
+        Ok(n as usize)
+    }
+
+    async fn update_following_status(
+        &self, _local_user_id: uuid::Uuid, _remote_actor_url: &str, _status: FollowingStatus,
+    ) -> Result<()> {
+        Ok(())
+    }
+
+    async fn get_following_outbox_url(
+        &self, local_user_id: uuid::Uuid, remote_actor_url: &str,
+    ) -> Result<Option<String>> {
+        sqlx::query_scalar::<_, String>(
+            "SELECT outbox_url FROM federation_following WHERE local_user_id=$1 AND remote_actor_url=$2"
+        ).bind(local_user_id).bind(remote_actor_url).fetch_optional(&self.pool).await.map_err(|e| anyhow!(e))
+    }
+
+    async fn upsert_remote_actor(&self, actor: RemoteActor) -> Result<()> {
+        sqlx::query(
+            "INSERT INTO remote_actors(url,handle,display_name,inbox_url,shared_inbox_url,public_key,avatar_url,outbox_url,last_fetched_at)
+             VALUES($1,$2,$3,$4,$5,'',$6,$7,NOW())
+             ON CONFLICT(url) DO UPDATE SET handle=EXCLUDED.handle,display_name=EXCLUDED.display_name,
+             inbox_url=EXCLUDED.inbox_url,shared_inbox_url=EXCLUDED.shared_inbox_url,
+             avatar_url=EXCLUDED.avatar_url,outbox_url=EXCLUDED.outbox_url,last_fetched_at=NOW()"
+        )
+        .bind(&actor.url).bind(&actor.handle).bind(&actor.display_name)
+        .bind(&actor.inbox_url).bind(&actor.shared_inbox_url)
+        .bind(&actor.avatar_url).bind(&actor.outbox_url)
+        .execute(&self.pool).await.map_err(|e| anyhow!(e)).map(|_| ())
+    }
+
+    async fn get_remote_actor(&self, actor_url: &str) -> Result<Option<RemoteActor>> {
+        #[derive(sqlx::FromRow)]
+        struct Row { url: String, handle: String, inbox_url: String, shared_inbox_url: Option<String>, display_name: Option<String>, avatar_url: Option<String>, outbox_url: Option<String> }
+        sqlx::query_as::<_, Row>(
+            "SELECT url,handle,inbox_url,shared_inbox_url,display_name,avatar_url,outbox_url FROM remote_actors WHERE url=$1"
+        ).bind(actor_url).fetch_optional(&self.pool).await.map_err(|e| anyhow!(e)).map(|o| o.map(|r|
+            map_remote_actor(r.url, r.handle, r.inbox_url, r.shared_inbox_url, r.display_name, r.avatar_url, r.outbox_url)
+        ))
+    }
+
+    async fn get_local_actor_keypair(&self, user_id: uuid::Uuid) -> Result<Option<(String, String)>> {
+        #[derive(sqlx::FromRow)]
+        struct Row { public_key: Option<String>, private_key: Option<String> }
+        let row = sqlx::query_as::<_, Row>(
+            "SELECT public_key, private_key FROM users WHERE id=$1 AND local=true"
+        ).bind(user_id).fetch_optional(&self.pool).await.map_err(|e| anyhow!(e))?;
+        Ok(row.and_then(|r| match (r.public_key, r.private_key) {
+            (Some(pub_k), Some(priv_k)) => Some((pub_k, priv_k)),
+            _ => None,
+        }))
+    }
+
+    async fn save_local_actor_keypair(
+        &self, user_id: uuid::Uuid, public_key: String, private_key: String,
+    ) -> Result<()> {
+        sqlx::query("UPDATE users SET public_key=$2, private_key=$3, updated_at=NOW() WHERE id=$1")
+            .bind(user_id).bind(&public_key).bind(&private_key)
+            .execute(&self.pool).await.map_err(|e| anyhow!(e)).map(|_| ())
+    }
+
+    async fn add_announce(
+        &self, activity_id: &str, object_url: &str, actor_url: &str, announced_at: DateTime<Utc>,
+    ) -> Result<()> {
+        sqlx::query(
+            "INSERT INTO federation_announces(activity_id,object_url,actor_url,announced_at)
+             VALUES($1,$2,$3,$4) ON CONFLICT(activity_id) DO NOTHING"
+        ).bind(activity_id).bind(object_url).bind(actor_url).bind(announced_at)
+        .execute(&self.pool).await.map_err(|e| anyhow!(e)).map(|_| ())
+    }
+
+    async fn count_announces(&self, object_url: &str) -> Result<usize> {
+        let n: i64 = sqlx::query_scalar(
+            "SELECT COUNT(*) FROM federation_announces WHERE object_url=$1"
+        ).bind(object_url).fetch_one(&self.pool).await.map_err(|e| anyhow!(e))?;
+        Ok(n as usize)
+    }
+
+    async fn add_blocked_domain(&self, domain: &str, reason: Option<&str>) -> Result<()> {
+        sqlx::query(
+            "INSERT INTO federation_blocked_domains(domain,reason) VALUES($1,$2) ON CONFLICT(domain) DO NOTHING"
+        ).bind(domain).bind(reason).execute(&self.pool).await.map_err(|e| anyhow!(e)).map(|_| ())
+    }
+
+    async fn remove_blocked_domain(&self, domain: &str) -> Result<()> {
+        sqlx::query("DELETE FROM federation_blocked_domains WHERE domain=$1")
+            .bind(domain).execute(&self.pool).await.map_err(|e| anyhow!(e)).map(|_| ())
+    }
+
+    async fn get_blocked_domains(&self) -> Result<Vec<BlockedDomain>> {
+        #[derive(sqlx::FromRow)]
+        struct Row { domain: String, reason: Option<String>, blocked_at: DateTime<Utc> }
+        sqlx::query_as::<_, Row>("SELECT domain,reason,blocked_at FROM federation_blocked_domains ORDER BY domain")
+            .fetch_all(&self.pool).await.map_err(|e| anyhow!(e)).map(|rows| rows.into_iter().map(|r|
+                BlockedDomain { domain: r.domain, reason: r.reason, blocked_at: r.blocked_at.to_rfc3339() }
+            ).collect())
+    }
+
+    async fn is_domain_blocked(&self, domain: &str) -> Result<bool> {
+        let n: i64 = sqlx::query_scalar("SELECT COUNT(*) FROM federation_blocked_domains WHERE domain=$1")
+            .bind(domain).fetch_one(&self.pool).await.map_err(|e| anyhow!(e))?;
+        Ok(n > 0)
+    }
+
+    async fn add_blocked_actor(&self, local_user_id: uuid::Uuid, actor_url: &str) -> Result<()> {
+        sqlx::query(
+            "INSERT INTO federation_blocked_actors(local_user_id,actor_url) VALUES($1,$2) ON CONFLICT DO NOTHING"
+        ).bind(local_user_id).bind(actor_url).execute(&self.pool).await.map_err(|e| anyhow!(e)).map(|_| ())
+    }
+
+    async fn remove_blocked_actor(&self, local_user_id: uuid::Uuid, actor_url: &str) -> Result<()> {
+        sqlx::query("DELETE FROM federation_blocked_actors WHERE local_user_id=$1 AND actor_url=$2")
+            .bind(local_user_id).bind(actor_url).execute(&self.pool).await.map_err(|e| anyhow!(e)).map(|_| ())
+    }
+
+    async fn get_blocked_actors(&self, local_user_id: uuid::Uuid) -> Result<Vec<String>> {
+        sqlx::query_scalar::<_, String>(
+            "SELECT actor_url FROM federation_blocked_actors WHERE local_user_id=$1 ORDER BY created_at DESC"
+        ).bind(local_user_id).fetch_all(&self.pool).await.map_err(|e| anyhow!(e))
+    }
+
+    async fn is_actor_blocked(&self, local_user_id: uuid::Uuid, actor_url: &str) -> Result<bool> {
+        let n: i64 = sqlx::query_scalar(
+            "SELECT COUNT(*) FROM federation_blocked_actors WHERE local_user_id=$1 AND actor_url=$2"
+        ).bind(local_user_id).bind(actor_url).fetch_one(&self.pool).await.map_err(|e| anyhow!(e))?;
+        Ok(n > 0)
+    }
+}
+
+// ── PostgresApUserRepository ──────────────────────────────────────────────────
+
+pub struct PostgresApUserRepository {
+    pool: PgPool,
+    base_url: String,
+}
+
+impl PostgresApUserRepository {
+    pub fn new(pool: PgPool, base_url: String) -> Self { Self { pool, base_url } }
+
+    fn row_to_ap_user(&self, id: uuid::Uuid, username: String, bio: Option<String>, avatar_url: Option<String>) -> ApUser {
+        let profile_url = url::Url::parse(&format!("{}/users/{}", self.base_url, username)).ok();
+        let avatar_url = avatar_url.and_then(|u| url::Url::parse(&u).ok());
+        ApUser { id, username, bio, avatar_url, banner_url: None, also_known_as: None, profile_url, attachment: vec![] }
+    }
+}
+
+#[async_trait]
+impl ApUserRepository for PostgresApUserRepository {
+    async fn find_by_id(&self, id: uuid::Uuid) -> Result<Option<ApUser>> {
+        #[derive(sqlx::FromRow)]
+        struct Row { id: uuid::Uuid, username: String, bio: Option<String>, avatar_url: Option<String> }
+        let row = sqlx::query_as::<_, Row>(
+            "SELECT id,username,bio,avatar_url FROM users WHERE id=$1 AND local=true"
+        ).bind(id).fetch_optional(&self.pool).await.map_err(|e| anyhow!(e))?;
+        Ok(row.map(|r| self.row_to_ap_user(r.id, r.username, r.bio, r.avatar_url)))
+    }
+
+    async fn find_by_username(&self, username: &str) -> Result<Option<ApUser>> {
+        #[derive(sqlx::FromRow)]
+        struct Row { id: uuid::Uuid, username: String, bio: Option<String>, avatar_url: Option<String> }
+        let row = sqlx::query_as::<_, Row>(
+            "SELECT id,username,bio,avatar_url FROM users WHERE username=$1 AND local=true"
+        ).bind(username).fetch_optional(&self.pool).await.map_err(|e| anyhow!(e))?;
+        Ok(row.map(|r| self.row_to_ap_user(r.id, r.username, r.bio, r.avatar_url)))
+    }
+
+    async fn count_users(&self) -> Result<usize> {
+        let n: i64 = sqlx::query_scalar("SELECT COUNT(*) FROM users WHERE local=true")
+            .fetch_one(&self.pool).await.map_err(|e| anyhow!(e))?;
+        Ok(n as usize)
+    }
+}

crates/adapters/postgres-search/Cargo.toml

@@ -0,0 +1,16 @@
+[package]
+name = "postgres-search"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+domain      = { workspace = true }
+sqlx        = { workspace = true }
+uuid        = { workspace = true }
+chrono      = { workspace = true }
+async-trait = { workspace = true }
+
+[dev-dependencies]
+tokio    = { workspace = true, features = ["full"] }
+sqlx     = { workspace = true, features = ["migrate"] }
+postgres = { workspace = true }

crates/adapters/postgres-search/src/lib.rs

@@ -0,0 +1,273 @@
+use async_trait::async_trait;
+use chrono::{DateTime, Utc};
+use sqlx::PgPool;
+use domain::{
+    errors::DomainError,
+    models::{
+        feed::{FeedEntry, PageParams, Paginated},
+        thought::Thought,
+        user::User,
+    },
+    ports::SearchPort,
+    value_objects::{Content, Email, PasswordHash, ThoughtId, UserId, Username},
+};
+use domain::models::thought::Visibility;
+
+pub struct PgSearchRepository { pool: PgPool }
+impl PgSearchRepository { pub fn new(pool: PgPool) -> Self { Self { pool } } }
+
+#[derive(sqlx::FromRow)]
+struct FeedRow {
+    thought_id: uuid::Uuid,
+    t_user_id: uuid::Uuid,
+    content: String,
+    in_reply_to_id: Option<uuid::Uuid>,
+    in_reply_to_url: Option<String>,
+    t_ap_id: Option<String>,
+    visibility: String,
+    content_warning: Option<String>,
+    sensitive: bool,
+    t_local: bool,
+    thought_created_at: DateTime<Utc>,
+    updated_at: Option<DateTime<Utc>>,
+    author_id: uuid::Uuid,
+    username: String,
+    email: String,
+    password_hash: String,
+    display_name: Option<String>,
+    bio: Option<String>,
+    avatar_url: Option<String>,
+    header_url: Option<String>,
+    custom_css: Option<String>,
+    author_local: bool,
+    u_ap_id: Option<String>,
+    inbox_url: Option<String>,
+    public_key: Option<String>,
+    private_key: Option<String>,
+    author_created_at: DateTime<Utc>,
+    author_updated_at: DateTime<Utc>,
+    like_count: i64,
+    boost_count: i64,
+    reply_count: i64,
+}
+
+const FEED_SELECT: &str = "
+    SELECT
+        t.id AS thought_id, t.user_id AS t_user_id, t.content,
+        t.in_reply_to_id, t.in_reply_to_url, t.ap_id AS t_ap_id,
+        t.visibility, t.content_warning, t.sensitive, t.local AS t_local,
+        t.created_at AS thought_created_at, t.updated_at,
+        u.id AS author_id, u.username, u.email, u.password_hash,
+        u.display_name, u.bio, u.avatar_url, u.header_url, u.custom_css,
+        u.local AS author_local, u.ap_id AS u_ap_id, u.inbox_url,
+        u.public_key, u.private_key,
+        u.created_at AS author_created_at, u.updated_at AS author_updated_at,
+        (SELECT COUNT(*) FROM likes l WHERE l.thought_id=t.id) AS like_count,
+        (SELECT COUNT(*) FROM boosts b WHERE b.thought_id=t.id) AS boost_count,
+        (SELECT COUNT(*) FROM thoughts r WHERE r.in_reply_to_id=t.id) AS reply_count
+    FROM thoughts t JOIN users u ON u.id=t.user_id";
+
+fn row_to_entry(r: FeedRow) -> FeedEntry {
+    let thought = Thought {
+        id: ThoughtId::from_uuid(r.thought_id),
+        user_id: UserId::from_uuid(r.t_user_id),
+        content: Content::new_remote(r.content),
+        in_reply_to_id: r.in_reply_to_id.map(ThoughtId::from_uuid),
+        in_reply_to_url: r.in_reply_to_url,
+        ap_id: r.t_ap_id,
+        visibility: Visibility::from_str(&r.visibility),
+        content_warning: r.content_warning,
+        sensitive: r.sensitive,
+        local: r.t_local,
+        created_at: r.thought_created_at,
+        updated_at: r.updated_at,
+    };
+    let author = User {
+        id: UserId::from_uuid(r.author_id),
+        username: Username::from_trusted(r.username),
+        email: Email::from_trusted(r.email),
+        password_hash: PasswordHash(r.password_hash),
+        display_name: r.display_name, bio: r.bio,
+        avatar_url: r.avatar_url, header_url: r.header_url, custom_css: r.custom_css,
+        local: r.author_local, ap_id: r.u_ap_id, inbox_url: r.inbox_url,
+        public_key: r.public_key, private_key: r.private_key,
+        created_at: r.author_created_at, updated_at: r.author_updated_at,
+    };
+    FeedEntry { thought, author, like_count: r.like_count, boost_count: r.boost_count, reply_count: r.reply_count, liked_by_viewer: false, boosted_by_viewer: false }
+}
+
+#[derive(sqlx::FromRow)]
+struct UserRow {
+    id: uuid::Uuid,
+    username: String,
+    email: String,
+    password_hash: String,
+    display_name: Option<String>,
+    bio: Option<String>,
+    avatar_url: Option<String>,
+    header_url: Option<String>,
+    custom_css: Option<String>,
+    local: bool,
+    ap_id: Option<String>,
+    inbox_url: Option<String>,
+    public_key: Option<String>,
+    private_key: Option<String>,
+    created_at: DateTime<Utc>,
+    updated_at: DateTime<Utc>,
+}
+
+impl From<UserRow> for User {
+    fn from(r: UserRow) -> Self {
+        User {
+            id: UserId::from_uuid(r.id),
+            username: Username::from_trusted(r.username),
+            email: Email::from_trusted(r.email),
+            password_hash: PasswordHash(r.password_hash),
+            display_name: r.display_name, bio: r.bio,
+            avatar_url: r.avatar_url, header_url: r.header_url, custom_css: r.custom_css,
+            local: r.local, ap_id: r.ap_id, inbox_url: r.inbox_url,
+            public_key: r.public_key, private_key: r.private_key,
+            created_at: r.created_at, updated_at: r.updated_at,
+        }
+    }
+}
+
+const USER_SELECT: &str =
+    "SELECT id,username,email,password_hash,display_name,bio,avatar_url,header_url,\
+     custom_css,local,ap_id,inbox_url,public_key,private_key,created_at,updated_at FROM users";
+
+#[async_trait]
+impl SearchPort for PgSearchRepository {
+    async fn search_thoughts(
+        &self,
+        query: &str,
+        page: &PageParams,
+        _viewer_id: Option<&UserId>,
+    ) -> Result<Paginated<FeedEntry>, DomainError> {
+        let total: i64 = sqlx::query_scalar(
+            "SELECT COUNT(*) FROM thoughts t
+             WHERE t.content % $1 AND t.visibility='public'"
+        )
+        .bind(query)
+        .fetch_one(&self.pool)
+        .await
+        .map_err(|e| DomainError::Internal(e.to_string()))?;
+
+        let sql = format!(
+            "{FEED_SELECT}
+             WHERE t.content % $1 AND t.visibility='public'
+             ORDER BY similarity(t.content, $1) DESC
+             LIMIT $2 OFFSET $3"
+        );
+        let rows = sqlx::query_as::<_, FeedRow>(&sql)
+            .bind(query)
+            .bind(page.limit())
+            .bind(page.offset())
+            .fetch_all(&self.pool)
+            .await
+            .map_err(|e| DomainError::Internal(e.to_string()))?;
+
+        Ok(Paginated {
+            items: rows.into_iter().map(row_to_entry).collect(),
+            total,
+            page: page.page,
+            per_page: page.per_page,
+        })
+    }
+
+    async fn search_users(
+        &self,
+        query: &str,
+        page: &PageParams,
+    ) -> Result<Paginated<User>, DomainError> {
+        let total: i64 = sqlx::query_scalar(
+            "SELECT COUNT(*) FROM users u
+             WHERE u.local=true AND (u.username % $1 OR u.display_name % $1)"
+        )
+        .bind(query)
+        .fetch_one(&self.pool)
+        .await
+        .map_err(|e| DomainError::Internal(e.to_string()))?;
+
+        let sql = format!(
+            "{USER_SELECT}
+             WHERE local=true AND (username % $1 OR display_name % $1)
+             ORDER BY similarity(username || ' ' || COALESCE(display_name,''), $1) DESC
+             LIMIT $2 OFFSET $3"
+        );
+        let rows = sqlx::query_as::<_, UserRow>(&sql)
+            .bind(query)
+            .bind(page.limit())
+            .bind(page.offset())
+            .fetch_all(&self.pool)
+            .await
+            .map_err(|e| DomainError::Internal(e.to_string()))?;
+
+        Ok(Paginated {
+            items: rows.into_iter().map(User::from).collect(),
+            total,
+            page: page.page,
+            per_page: page.per_page,
+        })
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use domain::{
+        models::{thought::{Thought, Visibility}, user::User},
+        ports::{SearchPort, ThoughtRepository, UserRepository},
+        value_objects::*,
+    };
+
+    async fn seed_thought(pool: &sqlx::PgPool, username: &str, content: &str) -> (User, Thought) {
+        use postgres::{thought::PgThoughtRepository, user::PgUserRepository};
+        let urepo = PgUserRepository::new(pool.clone());
+        let trepo = PgThoughtRepository::new(pool.clone());
+        let u = User::new_local(
+            UserId::new(),
+            Username::new(username).unwrap(),
+            Email::new(format!("{username}@ex.com")).unwrap(),
+            PasswordHash("h".into()),
+        );
+        urepo.save(&u).await.unwrap();
+        let t = Thought::new_local(
+            ThoughtId::new(), u.id.clone(),
+            Content::new_local(content).unwrap(),
+            None, Visibility::Public, None, false,
+        );
+        trepo.save(&t).await.unwrap();
+        (u, t)
+    }
+
+    #[sqlx::test(migrations = "../postgres/migrations")]
+    async fn search_thoughts_finds_by_keyword(pool: sqlx::PgPool) {
+        seed_thought(&pool, "alice", "hello world").await;
+        seed_thought(&pool, "bob", "goodbye universe").await;
+        let repo = PgSearchRepository::new(pool);
+        let result = repo.search_thoughts("hello world", &PageParams { page: 1, per_page: 20 }, None).await.unwrap();
+        assert_eq!(result.total, 1);
+        assert_eq!(result.items[0].thought.content.as_str(), "hello world");
+    }
+
+    #[sqlx::test(migrations = "../postgres/migrations")]
+    async fn search_users_finds_by_username(pool: sqlx::PgPool) {
+        use postgres::user::PgUserRepository;
+        let urepo = PgUserRepository::new(pool.clone());
+        let alice = User::new_local(UserId::new(), Username::new("alice_search").unwrap(), Email::new("alice@ex.com").unwrap(), PasswordHash("h".into()));
+        urepo.save(&alice).await.unwrap();
+        let repo = PgSearchRepository::new(pool);
+        let result = repo.search_users("alice", &PageParams { page: 1, per_page: 20 }).await.unwrap();
+        assert!(!result.items.is_empty());
+        assert!(result.items.iter().any(|u| u.username.as_str() == "alice_search"));
+    }
+
+    #[sqlx::test(migrations = "../postgres/migrations")]
+    async fn search_thoughts_returns_empty_for_no_match(pool: sqlx::PgPool) {
+        seed_thought(&pool, "alice", "hello world").await;
+        let repo = PgSearchRepository::new(pool);
+        let result = repo.search_thoughts("zzzzzzzzz", &PageParams { page: 1, per_page: 20 }, None).await.unwrap();
+        assert_eq!(result.total, 0);
+    }
+}

crates/adapters/postgres/Cargo.toml

@@ -0,0 +1,18 @@
+[package]
+name = "postgres"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+domain      = { workspace = true }
+sqlx        = { workspace = true }
+uuid        = { workspace = true }
+chrono      = { workspace = true }
+async-trait = { workspace = true }
+thiserror   = { workspace = true }
+tracing     = { workspace = true }
+url         = { workspace = true }
+
+[dev-dependencies]
+tokio = { workspace = true, features = ["full"] }
+sqlx  = { workspace = true, features = ["migrate"] }

crates/adapters/postgres/migrations/001_initial_schema.sql

@@ -0,0 +1,55 @@
+CREATE EXTENSION IF NOT EXISTS "pgcrypto";
+
+CREATE TABLE IF NOT EXISTS users (
+    id           UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    username     VARCHAR(32)  NOT NULL UNIQUE,
+    email        VARCHAR(255) NOT NULL UNIQUE,
+    password_hash TEXT        NOT NULL,
+    display_name VARCHAR(50),
+    bio          VARCHAR(160),
+    avatar_url   TEXT,
+    header_url   TEXT,
+    custom_css   TEXT,
+    created_at   TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    updated_at   TIMESTAMPTZ NOT NULL DEFAULT NOW()
+);
+
+CREATE TABLE IF NOT EXISTS thoughts (
+    id         UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    user_id    UUID        NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+    content    VARCHAR(128) NOT NULL,
+    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+);
+
+CREATE TABLE IF NOT EXISTS follows (
+    follower_id  UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+    following_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+    PRIMARY KEY (follower_id, following_id)
+);
+
+CREATE TABLE IF NOT EXISTS top_friends (
+    user_id   UUID     NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+    friend_id UUID     NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+    position  SMALLINT NOT NULL,
+    PRIMARY KEY (user_id, friend_id),
+    UNIQUE (user_id, position)
+);
+
+CREATE TABLE IF NOT EXISTS tags (
+    id   SERIAL PRIMARY KEY,
+    name VARCHAR(50) NOT NULL UNIQUE
+);
+
+CREATE TABLE IF NOT EXISTS thought_tags (
+    thought_id UUID    NOT NULL REFERENCES thoughts(id) ON DELETE CASCADE,
+    tag_id     INTEGER NOT NULL REFERENCES tags(id) ON DELETE CASCADE,
+    PRIMARY KEY (thought_id, tag_id)
+);
+
+CREATE TABLE IF NOT EXISTS api_keys (
+    id         UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    user_id    UUID        NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+    key_hash   TEXT        NOT NULL UNIQUE,
+    name       VARCHAR(50) NOT NULL,
+    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+);

crates/adapters/postgres/migrations/002_federation_columns.sql

@@ -0,0 +1,21 @@
+ALTER TABLE users
+    ADD COLUMN IF NOT EXISTS ap_id        TEXT UNIQUE,
+    ADD COLUMN IF NOT EXISTS inbox_url    TEXT,
+    ADD COLUMN IF NOT EXISTS public_key   TEXT,
+    ADD COLUMN IF NOT EXISTS private_key  TEXT,
+    ADD COLUMN IF NOT EXISTS local        BOOLEAN NOT NULL DEFAULT true;
+
+ALTER TABLE thoughts
+    ADD COLUMN IF NOT EXISTS in_reply_to_id  UUID REFERENCES thoughts(id),
+    ADD COLUMN IF NOT EXISTS in_reply_to_url TEXT,
+    ADD COLUMN IF NOT EXISTS ap_id           TEXT UNIQUE,
+    ADD COLUMN IF NOT EXISTS visibility      TEXT NOT NULL DEFAULT 'public',
+    ADD COLUMN IF NOT EXISTS content_warning TEXT,
+    ADD COLUMN IF NOT EXISTS sensitive       BOOLEAN NOT NULL DEFAULT false,
+    ADD COLUMN IF NOT EXISTS local           BOOLEAN NOT NULL DEFAULT true,
+    ADD COLUMN IF NOT EXISTS updated_at      TIMESTAMPTZ;
+
+ALTER TABLE follows
+    ADD COLUMN IF NOT EXISTS state      TEXT        NOT NULL DEFAULT 'accepted',
+    ADD COLUMN IF NOT EXISTS ap_id      TEXT,
+    ADD COLUMN IF NOT EXISTS created_at TIMESTAMPTZ NOT NULL DEFAULT NOW();

crates/adapters/postgres/migrations/003_new_tables.sql

@@ -0,0 +1,49 @@
+CREATE TABLE IF NOT EXISTS likes (
+    id         UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    user_id    UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+    thought_id UUID NOT NULL REFERENCES thoughts(id) ON DELETE CASCADE,
+    ap_id      TEXT UNIQUE,
+    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    UNIQUE (user_id, thought_id)
+);
+
+CREATE TABLE IF NOT EXISTS boosts (
+    id         UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    user_id    UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+    thought_id UUID NOT NULL REFERENCES thoughts(id) ON DELETE CASCADE,
+    ap_id      TEXT UNIQUE,
+    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    UNIQUE (user_id, thought_id)
+);
+
+CREATE TABLE IF NOT EXISTS blocks (
+    blocker_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+    blocked_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    PRIMARY KEY (blocker_id, blocked_id)
+);
+
+CREATE TABLE IF NOT EXISTS remote_actors (
+    url              TEXT PRIMARY KEY,
+    handle           TEXT NOT NULL,
+    display_name     TEXT,
+    inbox_url        TEXT NOT NULL,
+    shared_inbox_url TEXT,
+    public_key       TEXT NOT NULL,
+    last_fetched_at  TIMESTAMPTZ NOT NULL DEFAULT NOW()
+);
+
+CREATE TABLE IF NOT EXISTS notifications (
+    id           UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    user_id      UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+    type         TEXT NOT NULL,
+    from_user_id UUID REFERENCES users(id) ON DELETE SET NULL,
+    thought_id   UUID REFERENCES thoughts(id) ON DELETE CASCADE,
+    read         BOOLEAN NOT NULL DEFAULT false,
+    created_at   TIMESTAMPTZ NOT NULL DEFAULT NOW()
+);
+
+CREATE INDEX IF NOT EXISTS idx_thoughts_user_id ON thoughts(user_id);
+CREATE INDEX IF NOT EXISTS idx_thoughts_created_at ON thoughts(created_at DESC);
+CREATE INDEX IF NOT EXISTS idx_follows_following_id ON follows(following_id);
+CREATE INDEX IF NOT EXISTS idx_notifications_user_id ON notifications(user_id, read);

crates/adapters/postgres/migrations/004_search_indexes.sql

@@ -0,0 +1,11 @@
+CREATE EXTENSION IF NOT EXISTS pg_trgm;
+
+CREATE INDEX IF NOT EXISTS idx_thoughts_content_trgm
+    ON thoughts USING GIN(content gin_trgm_ops);
+
+CREATE INDEX IF NOT EXISTS idx_users_username_trgm
+    ON users USING GIN(username gin_trgm_ops);
+
+CREATE INDEX IF NOT EXISTS idx_users_display_name_trgm
+    ON users USING GIN(display_name gin_trgm_ops)
+    WHERE display_name IS NOT NULL;

crates/adapters/postgres/migrations/005_federation_tables.sql

@@ -0,0 +1,54 @@
+-- Add avatar_url and outbox_url to remote_actors (FederationRepository::RemoteActor needs them)
+ALTER TABLE remote_actors
+    ADD COLUMN IF NOT EXISTS avatar_url  TEXT,
+    ADD COLUMN IF NOT EXISTS outbox_url  TEXT;
+
+-- Federation followers: remote actors following local users
+CREATE TABLE IF NOT EXISTS federation_followers (
+    id               UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    local_user_id    UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+    remote_actor_url TEXT NOT NULL,
+    status           TEXT NOT NULL DEFAULT 'pending',
+    follow_activity_id TEXT NOT NULL,
+    created_at       TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    UNIQUE (local_user_id, remote_actor_url)
+);
+
+-- Federation following: local users following remote actors
+CREATE TABLE IF NOT EXISTS federation_following (
+    id               UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    local_user_id    UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+    remote_actor_url TEXT NOT NULL,
+    follow_activity_id TEXT NOT NULL,
+    outbox_url       TEXT,
+    created_at       TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    UNIQUE (local_user_id, remote_actor_url)
+);
+
+-- Announces (boosts of remote objects via AP)
+CREATE TABLE IF NOT EXISTS federation_announces (
+    id           UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    activity_id  TEXT NOT NULL UNIQUE,
+    object_url   TEXT NOT NULL,
+    actor_url    TEXT NOT NULL,
+    announced_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+);
+
+-- Blocked domains (instance-level)
+CREATE TABLE IF NOT EXISTS federation_blocked_domains (
+    domain     TEXT PRIMARY KEY,
+    reason     TEXT,
+    blocked_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+);
+
+-- Blocked actors (per local user)
+CREATE TABLE IF NOT EXISTS federation_blocked_actors (
+    local_user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+    actor_url     TEXT NOT NULL,
+    created_at    TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    PRIMARY KEY (local_user_id, actor_url)
+);
+
+CREATE INDEX IF NOT EXISTS idx_fed_followers_user   ON federation_followers(local_user_id);
+CREATE INDEX IF NOT EXISTS idx_fed_following_user   ON federation_following(local_user_id);
+CREATE INDEX IF NOT EXISTS idx_fed_announces_object ON federation_announces(object_url);

crates/adapters/postgres/src/activitypub.rs

@@ -0,0 +1,267 @@
+use async_trait::async_trait;
+use chrono::{DateTime, Utc};
+use sqlx::PgPool;
+use url::Url;
+
+use domain::{
+    errors::DomainError,
+    models::thought::{Thought, Visibility},
+    ports::{ActivityPubRepository, OutboxEntry},
+    value_objects::{Content, ThoughtId, UserId, Username},
+};
+
+pub struct PgActivityPubRepository {
+    pool: PgPool,
+}
+
+impl PgActivityPubRepository {
+    pub fn new(pool: PgPool) -> Self {
+        Self { pool }
+    }
+}
+
+#[async_trait]
+impl ActivityPubRepository for PgActivityPubRepository {
+    async fn outbox_entries_for_actor(&self, user_id: &UserId) -> Result<Vec<OutboxEntry>, DomainError> {
+        #[derive(sqlx::FromRow)]
+        struct Row {
+            id: uuid::Uuid,
+            user_id: uuid::Uuid,
+            content: String,
+            created_at: DateTime<Utc>,
+            in_reply_to_id: Option<uuid::Uuid>,
+            content_warning: Option<String>,
+            sensitive: bool,
+            username: String,
+            updated_at: Option<DateTime<Utc>>,
+        }
+        sqlx::query_as::<_, Row>(
+            "SELECT t.id, t.user_id, t.content, t.created_at, t.in_reply_to_id, t.content_warning, t.sensitive, u.username, t.updated_at
+             FROM thoughts t JOIN users u ON u.id=t.user_id
+             WHERE t.user_id=$1 AND t.local=true AND t.visibility='public'
+             ORDER BY t.created_at DESC",
+        )
+        .bind(user_id.as_uuid())
+        .fetch_all(&self.pool)
+        .await
+        .map_err(|e| DomainError::Internal(e.to_string()))
+        .map(|rows| {
+            rows.into_iter()
+                .map(|r| OutboxEntry {
+                    thought: Thought {
+                        id: ThoughtId::from_uuid(r.id),
+                        user_id: UserId::from_uuid(r.user_id),
+                        content: Content::new_remote(r.content),
+                        in_reply_to_id: r.in_reply_to_id.map(ThoughtId::from_uuid),
+                        in_reply_to_url: None,
+                        ap_id: None,
+                        visibility: Visibility::Public,
+                        content_warning: r.content_warning,
+                        sensitive: r.sensitive,
+                        local: true,
+                        created_at: r.created_at,
+                        updated_at: r.updated_at,
+                    },
+                    author_username: Username::from_trusted(r.username),
+                })
+                .collect()
+        })
+    }
+
+    async fn outbox_page_for_actor(
+        &self,
+        user_id: &UserId,
+        before: Option<DateTime<Utc>>,
+        limit: usize,
+    ) -> Result<Vec<OutboxEntry>, DomainError> {
+        #[derive(sqlx::FromRow)]
+        struct Row {
+            id: uuid::Uuid,
+            user_id: uuid::Uuid,
+            content: String,
+            created_at: DateTime<Utc>,
+            in_reply_to_id: Option<uuid::Uuid>,
+            content_warning: Option<String>,
+            sensitive: bool,
+            username: String,
+            updated_at: Option<DateTime<Utc>>,
+        }
+        let rows = if let Some(before) = before {
+            sqlx::query_as::<_, Row>(
+                "SELECT t.id, t.user_id, t.content, t.created_at, t.in_reply_to_id, t.content_warning, t.sensitive, u.username, t.updated_at
+                 FROM thoughts t JOIN users u ON u.id=t.user_id
+                 WHERE t.user_id=$1 AND t.local=true AND t.visibility='public' AND t.created_at < $2
+                 ORDER BY t.created_at DESC LIMIT $3",
+            )
+            .bind(user_id.as_uuid())
+            .bind(before)
+            .bind(limit as i64)
+            .fetch_all(&self.pool)
+            .await
+        } else {
+            sqlx::query_as::<_, Row>(
+                "SELECT t.id, t.user_id, t.content, t.created_at, t.in_reply_to_id, t.content_warning, t.sensitive, u.username, t.updated_at
+                 FROM thoughts t JOIN users u ON u.id=t.user_id
+                 WHERE t.user_id=$1 AND t.local=true AND t.visibility='public'
+                 ORDER BY t.created_at DESC LIMIT $2",
+            )
+            .bind(user_id.as_uuid())
+            .bind(limit as i64)
+            .fetch_all(&self.pool)
+            .await
+        }
+        .map_err(|e| DomainError::Internal(e.to_string()))?;
+
+        Ok(rows
+            .into_iter()
+            .map(|r| OutboxEntry {
+                thought: Thought {
+                    id: ThoughtId::from_uuid(r.id),
+                    user_id: UserId::from_uuid(r.user_id),
+                    content: Content::new_remote(r.content),
+                    in_reply_to_id: r.in_reply_to_id.map(ThoughtId::from_uuid),
+                    in_reply_to_url: None,
+                    ap_id: None,
+                    visibility: Visibility::Public,
+                    content_warning: r.content_warning,
+                    sensitive: r.sensitive,
+                    local: true,
+                    created_at: r.created_at,
+                    updated_at: r.updated_at,
+                },
+                author_username: Username::from_trusted(r.username),
+            })
+            .collect())
+    }
+
+    async fn find_remote_actor_id(&self, actor_ap_url: &Url) -> Result<Option<UserId>, DomainError> {
+        sqlx::query_scalar::<_, uuid::Uuid>("SELECT id FROM users WHERE ap_id=$1")
+            .bind(actor_ap_url.as_str())
+            .fetch_optional(&self.pool)
+            .await
+            .map_err(|e| DomainError::Internal(e.to_string()))
+            .map(|o| o.map(UserId::from_uuid))
+    }
+
+    async fn intern_remote_actor(&self, actor_ap_url: &Url) -> Result<UserId, DomainError> {
+        if let Some(id) = self.find_remote_actor_id(actor_ap_url).await? {
+            return Ok(id);
+        }
+        let new_id = uuid::Uuid::new_v4();
+        let handle = actor_ap_url.path().trim_start_matches('/').replace('/', "_");
+        sqlx::query(
+            "INSERT INTO users(id,username,email,password_hash,local,ap_id,created_at,updated_at)
+             VALUES($1,$2,$3,'',false,$4,NOW(),NOW()) ON CONFLICT(ap_id) DO NOTHING",
+        )
+        .bind(new_id)
+        .bind(&handle)
+        .bind(format!("{}@remote", new_id))
+        .bind(actor_ap_url.as_str())
+        .execute(&self.pool)
+        .await
+        .map_err(|e| DomainError::Internal(e.to_string()))?;
+        // Re-fetch to get whichever id won the race
+        self.find_remote_actor_id(actor_ap_url)
+            .await?
+            .ok_or_else(|| DomainError::Internal("intern_remote_actor: insert succeeded but row not found".into()))
+    }
+
+    async fn accept_note(
+        &self,
+        ap_id: &Url,
+        author_id: &UserId,
+        content: &str,
+        published: DateTime<Utc>,
+        sensitive: bool,
+        content_warning: Option<String>,
+    ) -> Result<(), DomainError> {
+        let capped: String = content.chars().take(500).collect();
+        sqlx::query(
+            "INSERT INTO thoughts(id,user_id,content,ap_id,visibility,sensitive,local,content_warning,created_at)
+             VALUES($1,$2,$3,$4,'public',$5,false,$6,$7) ON CONFLICT(ap_id) DO NOTHING",
+        )
+        .bind(uuid::Uuid::new_v4())
+        .bind(author_id.as_uuid())
+        .bind(&capped)
+        .bind(ap_id.as_str())
+        .bind(sensitive)
+        .bind(content_warning)
+        .bind(published)
+        .execute(&self.pool)
+        .await
+        .map_err(|e| DomainError::Internal(e.to_string()))
+        .map(|_| ())
+    }
+
+    async fn apply_note_update(&self, ap_id: &Url, new_content: &str) -> Result<(), DomainError> {
+        let capped: String = new_content.chars().take(500).collect();
+        sqlx::query("UPDATE thoughts SET content=$2,updated_at=NOW() WHERE ap_id=$1 AND local=false")
+            .bind(ap_id.as_str())
+            .bind(&capped)
+            .execute(&self.pool)
+            .await
+            .map_err(|e| DomainError::Internal(e.to_string()))
+            .map(|_| ())
+    }
+
+    async fn retract_note(&self, ap_id: &Url) -> Result<(), DomainError> {
+        sqlx::query("DELETE FROM thoughts WHERE ap_id=$1 AND local=false")
+            .bind(ap_id.as_str())
+            .execute(&self.pool)
+            .await
+            .map_err(|e| DomainError::Internal(e.to_string()))
+            .map(|_| ())
+    }
+
+    async fn retract_actor_notes(&self, actor_ap_url: &Url) -> Result<(), DomainError> {
+        sqlx::query(
+            "DELETE FROM thoughts WHERE local=false AND user_id=(SELECT id FROM users WHERE ap_id=$1)",
+        )
+        .bind(actor_ap_url.as_str())
+        .execute(&self.pool)
+        .await
+        .map_err(|e| DomainError::Internal(e.to_string()))
+        .map(|_| ())
+    }
+
+    async fn count_local_notes(&self) -> Result<u64, DomainError> {
+        let n: i64 = sqlx::query_scalar("SELECT COUNT(*) FROM thoughts WHERE local=true")
+            .fetch_one(&self.pool)
+            .await
+            .map_err(|e| DomainError::Internal(e.to_string()))?;
+        Ok(n as u64)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use domain::ports::ActivityPubRepository;
+
+    #[sqlx::test(migrations = "./migrations")]
+    async fn intern_remote_actor_is_idempotent(pool: sqlx::PgPool) {
+        let repo = PgActivityPubRepository::new(pool);
+        let url = url::Url::parse("https://mastodon.social/users/alice").unwrap();
+        let id1 = repo.intern_remote_actor(&url).await.unwrap();
+        let id2 = repo.intern_remote_actor(&url).await.unwrap();
+        assert_eq!(id1, id2);
+    }
+
+    #[sqlx::test(migrations = "./migrations")]
+    async fn accept_and_retract_note(pool: sqlx::PgPool) {
+        let repo = PgActivityPubRepository::new(pool);
+        let actor_url = url::Url::parse("https://remote.example/users/bob").unwrap();
+        let ap_id = url::Url::parse("https://remote.example/notes/1").unwrap();
+        let author = repo.intern_remote_actor(&actor_url).await.unwrap();
+        repo.accept_note(&ap_id, &author, "hello from remote", chrono::Utc::now(), false, None)
+            .await
+            .unwrap();
+        repo.retract_note(&ap_id).await.unwrap();
+    }
+
+    #[sqlx::test(migrations = "./migrations")]
+    async fn count_local_notes_excludes_remote(pool: sqlx::PgPool) {
+        let repo = PgActivityPubRepository::new(pool);
+        assert_eq!(repo.count_local_notes().await.unwrap(), 0);
+    }
+}

crates/adapters/postgres/src/api_key.rs

@@ -0,0 +1,73 @@
+use async_trait::async_trait;
+use chrono::{DateTime, Utc};
+use sqlx::PgPool;
+use domain::{errors::DomainError, models::api_key::ApiKey, ports::ApiKeyRepository, value_objects::{ApiKeyId, UserId}};
+
+pub struct PgApiKeyRepository { pool: PgPool }
+impl PgApiKeyRepository { pub fn new(pool: PgPool) -> Self { Self { pool } } }
+
+#[async_trait]
+impl ApiKeyRepository for PgApiKeyRepository {
+    async fn save(&self, k: &ApiKey) -> Result<(), DomainError> {
+        sqlx::query("INSERT INTO api_keys(id,user_id,key_hash,name,created_at) VALUES($1,$2,$3,$4,$5)")
+            .bind(k.id.as_uuid()).bind(k.user_id.as_uuid()).bind(&k.key_hash).bind(&k.name).bind(k.created_at)
+            .execute(&self.pool).await.map_err(|e| DomainError::Internal(e.to_string())).map(|_| ())
+    }
+
+    async fn find_by_hash(&self, hash: &str) -> Result<Option<ApiKey>, DomainError> {
+        #[derive(sqlx::FromRow)] struct Row { id: uuid::Uuid, user_id: uuid::Uuid, key_hash: String, name: String, created_at: DateTime<Utc> }
+        sqlx::query_as::<_, Row>("SELECT id,user_id,key_hash,name,created_at FROM api_keys WHERE key_hash=$1")
+            .bind(hash).fetch_optional(&self.pool).await
+            .map_err(|e| DomainError::Internal(e.to_string()))
+            .map(|o| o.map(|r| ApiKey { id: ApiKeyId::from_uuid(r.id), user_id: UserId::from_uuid(r.user_id), key_hash: r.key_hash, name: r.name, created_at: r.created_at }))
+    }
+
+    async fn list_for_user(&self, user_id: &UserId) -> Result<Vec<ApiKey>, DomainError> {
+        #[derive(sqlx::FromRow)] struct Row { id: uuid::Uuid, user_id: uuid::Uuid, key_hash: String, name: String, created_at: DateTime<Utc> }
+        sqlx::query_as::<_, Row>("SELECT id,user_id,key_hash,name,created_at FROM api_keys WHERE user_id=$1 ORDER BY created_at DESC")
+            .bind(user_id.as_uuid()).fetch_all(&self.pool).await
+            .map_err(|e| DomainError::Internal(e.to_string()))
+            .map(|rows| rows.into_iter().map(|r| ApiKey { id: ApiKeyId::from_uuid(r.id), user_id: UserId::from_uuid(r.user_id), key_hash: r.key_hash, name: r.name, created_at: r.created_at }).collect())
+    }
+
+    async fn delete(&self, id: &ApiKeyId, user_id: &UserId) -> Result<(), DomainError> {
+        sqlx::query("DELETE FROM api_keys WHERE id=$1 AND user_id=$2")
+            .bind(id.as_uuid()).bind(user_id.as_uuid())
+            .execute(&self.pool).await.map_err(|e| DomainError::Internal(e.to_string())).map(|_| ())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use chrono::Utc;
+    use domain::{models::user::User, value_objects::*};
+    use crate::user::PgUserRepository;
+    use domain::ports::UserRepository;
+
+    async fn seed_user(pool: &sqlx::PgPool) -> User {
+        let repo = PgUserRepository::new(pool.clone());
+        let u = User::new_local(UserId::new(), Username::new("alice").unwrap(), Email::new("alice@ex.com").unwrap(), PasswordHash("h".into()));
+        repo.save(&u).await.unwrap(); u
+    }
+
+    #[sqlx::test(migrations = "./migrations")]
+    async fn save_and_find_by_hash(pool: sqlx::PgPool) {
+        let user = seed_user(&pool).await;
+        let repo = PgApiKeyRepository::new(pool);
+        let key = ApiKey { id: ApiKeyId::new(), user_id: user.id.clone(), key_hash: "abc123".into(), name: "test".into(), created_at: Utc::now() };
+        repo.save(&key).await.unwrap();
+        let found = repo.find_by_hash("abc123").await.unwrap().unwrap();
+        assert_eq!(found.name, "test");
+    }
+
+    #[sqlx::test(migrations = "./migrations")]
+    async fn delete_key(pool: sqlx::PgPool) {
+        let user = seed_user(&pool).await;
+        let repo = PgApiKeyRepository::new(pool);
+        let key = ApiKey { id: ApiKeyId::new(), user_id: user.id.clone(), key_hash: "def456".into(), name: "key2".into(), created_at: Utc::now() };
+        repo.save(&key).await.unwrap();
+        repo.delete(&key.id, &user.id).await.unwrap();
+        assert!(repo.find_by_hash("def456").await.unwrap().is_none());
+    }
+}

crates/adapters/postgres/src/block.rs

@@ -0,0 +1,81 @@
+use async_trait::async_trait;
+use sqlx::PgPool;
+use domain::{errors::DomainError, models::social::Block, ports::BlockRepository, value_objects::UserId};
+
+pub struct PgBlockRepository { pool: PgPool }
+impl PgBlockRepository { pub fn new(pool: PgPool) -> Self { Self { pool } } }
+
+#[async_trait]
+impl BlockRepository for PgBlockRepository {
+    async fn save(&self, b: &Block) -> Result<(), DomainError> {
+        sqlx::query(
+            "INSERT INTO blocks(blocker_id,blocked_id,created_at) VALUES($1,$2,$3) ON CONFLICT DO NOTHING"
+        )
+        .bind(b.blocker_id.as_uuid())
+        .bind(b.blocked_id.as_uuid())
+        .bind(b.created_at)
+        .execute(&self.pool)
+        .await
+        .map_err(|e| DomainError::Internal(e.to_string()))
+        .map(|_| ())
+    }
+
+    async fn delete(&self, blocker_id: &UserId, blocked_id: &UserId) -> Result<(), DomainError> {
+        sqlx::query("DELETE FROM blocks WHERE blocker_id=$1 AND blocked_id=$2")
+            .bind(blocker_id.as_uuid())
+            .bind(blocked_id.as_uuid())
+            .execute(&self.pool)
+            .await
+            .map_err(|e| DomainError::Internal(e.to_string()))
+            .map(|_| ())
+    }
+
+    async fn exists(&self, blocker_id: &UserId, blocked_id: &UserId) -> Result<bool, DomainError> {
+        let count: i64 = sqlx::query_scalar(
+            "SELECT COUNT(*) FROM blocks WHERE blocker_id=$1 AND blocked_id=$2"
+        )
+        .bind(blocker_id.as_uuid())
+        .bind(blocked_id.as_uuid())
+        .fetch_one(&self.pool)
+        .await
+        .map_err(|e| DomainError::Internal(e.to_string()))?;
+        Ok(count > 0)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use chrono::Utc;
+    use domain::{models::user::User, value_objects::*};
+    use crate::user::PgUserRepository;
+    use domain::ports::UserRepository;
+
+    async fn seed_user(pool: &sqlx::PgPool, username: &str, email: &str) -> User {
+        let repo = PgUserRepository::new(pool.clone());
+        let u = User::new_local(UserId::new(), Username::new(username).unwrap(), Email::new(email).unwrap(), PasswordHash("h".into()));
+        repo.save(&u).await.unwrap(); u
+    }
+
+    #[sqlx::test(migrations = "./migrations")]
+    async fn block_exists(pool: sqlx::PgPool) {
+        let alice = seed_user(&pool, "alice", "alice@ex.com").await;
+        let bob   = seed_user(&pool, "bob",   "bob@ex.com").await;
+        let repo = PgBlockRepository::new(pool);
+        let block = Block { blocker_id: alice.id.clone(), blocked_id: bob.id.clone(), created_at: Utc::now() };
+        repo.save(&block).await.unwrap();
+        assert!(repo.exists(&alice.id, &bob.id).await.unwrap());
+        assert!(!repo.exists(&bob.id, &alice.id).await.unwrap());
+    }
+
+    #[sqlx::test(migrations = "./migrations")]
+    async fn unblock(pool: sqlx::PgPool) {
+        let alice = seed_user(&pool, "alice", "alice@ex.com").await;
+        let bob   = seed_user(&pool, "bob",   "bob@ex.com").await;
+        let repo = PgBlockRepository::new(pool);
+        let block = Block { blocker_id: alice.id.clone(), blocked_id: bob.id.clone(), created_at: Utc::now() };
+        repo.save(&block).await.unwrap();
+        repo.delete(&alice.id, &bob.id).await.unwrap();
+        assert!(!repo.exists(&alice.id, &bob.id).await.unwrap());
+    }
+}

crates/adapters/postgres/src/boost.rs

@@ -0,0 +1,80 @@
+use async_trait::async_trait;
+use chrono::{DateTime, Utc};
+use sqlx::PgPool;
+use domain::{errors::DomainError, models::social::Boost, ports::BoostRepository, value_objects::{BoostId, ThoughtId, UserId}};
+
+pub struct PgBoostRepository { pool: PgPool }
+impl PgBoostRepository { pub fn new(pool: PgPool) -> Self { Self { pool } } }
+
+#[async_trait]
+impl BoostRepository for PgBoostRepository {
+    async fn save(&self, b: &Boost) -> Result<(), DomainError> {
+        sqlx::query(
+            "INSERT INTO boosts(id,user_id,thought_id,ap_id,created_at) VALUES($1,$2,$3,$4,$5) ON CONFLICT(user_id,thought_id) DO NOTHING"
+        )
+        .bind(b.id.as_uuid()).bind(b.user_id.as_uuid()).bind(b.thought_id.as_uuid()).bind(&b.ap_id).bind(b.created_at)
+        .execute(&self.pool).await.map_err(|e| DomainError::Internal(e.to_string())).map(|_| ())
+    }
+
+    async fn delete(&self, user_id: &UserId, thought_id: &ThoughtId) -> Result<(), DomainError> {
+        let r = sqlx::query("DELETE FROM boosts WHERE user_id=$1 AND thought_id=$2")
+            .bind(user_id.as_uuid()).bind(thought_id.as_uuid())
+            .execute(&self.pool).await.map_err(|e| DomainError::Internal(e.to_string()))?;
+        if r.rows_affected() == 0 { return Err(DomainError::NotFound); }
+        Ok(())
+    }
+
+    async fn find(&self, user_id: &UserId, thought_id: &ThoughtId) -> Result<Option<Boost>, DomainError> {
+        #[derive(sqlx::FromRow)]
+        struct Row { id: uuid::Uuid, user_id: uuid::Uuid, thought_id: uuid::Uuid, ap_id: Option<String>, created_at: DateTime<Utc> }
+        sqlx::query_as::<_, Row>("SELECT id,user_id,thought_id,ap_id,created_at FROM boosts WHERE user_id=$1 AND thought_id=$2")
+            .bind(user_id.as_uuid()).bind(thought_id.as_uuid())
+            .fetch_optional(&self.pool).await
+            .map_err(|e| DomainError::Internal(e.to_string()))
+            .map(|o| o.map(|r| Boost { id: BoostId::from_uuid(r.id), user_id: UserId::from_uuid(r.user_id), thought_id: ThoughtId::from_uuid(r.thought_id), ap_id: r.ap_id, created_at: r.created_at }))
+    }
+
+    async fn count_for_thought(&self, thought_id: &ThoughtId) -> Result<i64, DomainError> {
+        sqlx::query_scalar("SELECT COUNT(*) FROM boosts WHERE thought_id=$1")
+            .bind(thought_id.as_uuid()).fetch_one(&self.pool).await
+            .map_err(|e| DomainError::Internal(e.to_string()))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use chrono::Utc;
+    use domain::{models::{thought::{Thought, Visibility}, user::User}, value_objects::*};
+    use crate::{thought::PgThoughtRepository, user::PgUserRepository};
+    use domain::ports::{ThoughtRepository, UserRepository};
+
+    async fn seed(pool: &sqlx::PgPool) -> (User, Thought) {
+        let urepo = PgUserRepository::new(pool.clone());
+        let trepo = PgThoughtRepository::new(pool.clone());
+        let u = User::new_local(UserId::new(), Username::new("alice").unwrap(), Email::new("alice@ex.com").unwrap(), PasswordHash("h".into()));
+        urepo.save(&u).await.unwrap();
+        let t = Thought::new_local(ThoughtId::new(), u.id.clone(), Content::new_local("hi").unwrap(), None, Visibility::Public, None, false);
+        trepo.save(&t).await.unwrap();
+        (u, t)
+    }
+
+    #[sqlx::test(migrations = "./migrations")]
+    async fn boost_and_count(pool: sqlx::PgPool) {
+        let (user, thought) = seed(&pool).await;
+        let repo = PgBoostRepository::new(pool);
+        let boost = Boost { id: BoostId::new(), user_id: user.id.clone(), thought_id: thought.id.clone(), ap_id: None, created_at: Utc::now() };
+        repo.save(&boost).await.unwrap();
+        assert_eq!(repo.count_for_thought(&thought.id).await.unwrap(), 1);
+    }
+
+    #[sqlx::test(migrations = "./migrations")]
+    async fn unboost(pool: sqlx::PgPool) {
+        let (user, thought) = seed(&pool).await;
+        let repo = PgBoostRepository::new(pool);
+        let boost = Boost { id: BoostId::new(), user_id: user.id.clone(), thought_id: thought.id.clone(), ap_id: None, created_at: Utc::now() };
+        repo.save(&boost).await.unwrap();
+        repo.delete(&user.id, &thought.id).await.unwrap();
+        assert_eq!(repo.count_for_thought(&thought.id).await.unwrap(), 0);
+    }
+}

crates/adapters/postgres/src/feed.rs

@@ -0,0 +1,180 @@
+use async_trait::async_trait;
+use chrono::{DateTime, Utc};
+use sqlx::PgPool;
+use domain::{
+    errors::DomainError,
+    models::{feed::{FeedEntry, PageParams, Paginated}, thought::Thought, user::User},
+    ports::FeedRepository,
+    value_objects::{Content, Email, PasswordHash, ThoughtId, UserId, Username},
+};
+use domain::models::thought::Visibility;
+
+pub struct PgFeedRepository { pool: PgPool }
+impl PgFeedRepository { pub fn new(pool: PgPool) -> Self { Self { pool } } }
+
+#[derive(sqlx::FromRow)]
+struct FeedRow {
+    thought_id: uuid::Uuid,
+    t_user_id: uuid::Uuid,
+    content: String,
+    in_reply_to_id: Option<uuid::Uuid>,
+    in_reply_to_url: Option<String>,
+    t_ap_id: Option<String>,
+    visibility: String,
+    content_warning: Option<String>,
+    sensitive: bool,
+    t_local: bool,
+    thought_created_at: DateTime<Utc>,
+    updated_at: Option<DateTime<Utc>>,
+    author_id: uuid::Uuid,
+    username: String,
+    email: String,
+    password_hash: String,
+    display_name: Option<String>,
+    bio: Option<String>,
+    avatar_url: Option<String>,
+    header_url: Option<String>,
+    custom_css: Option<String>,
+    author_local: bool,
+    u_ap_id: Option<String>,
+    inbox_url: Option<String>,
+    public_key: Option<String>,
+    private_key: Option<String>,
+    author_created_at: DateTime<Utc>,
+    author_updated_at: DateTime<Utc>,
+    like_count: i64,
+    boost_count: i64,
+    reply_count: i64,
+}
+
+const FEED_SELECT: &str = "
+    SELECT
+        t.id AS thought_id, t.user_id AS t_user_id, t.content,
+        t.in_reply_to_id, t.in_reply_to_url, t.ap_id AS t_ap_id,
+        t.visibility, t.content_warning, t.sensitive, t.local AS t_local,
+        t.created_at AS thought_created_at, t.updated_at,
+        u.id AS author_id, u.username, u.email, u.password_hash,
+        u.display_name, u.bio, u.avatar_url, u.header_url, u.custom_css,
+        u.local AS author_local, u.ap_id AS u_ap_id, u.inbox_url,
+        u.public_key, u.private_key,
+        u.created_at AS author_created_at, u.updated_at AS author_updated_at,
+        (SELECT COUNT(*) FROM likes l WHERE l.thought_id=t.id) AS like_count,
+        (SELECT COUNT(*) FROM boosts b WHERE b.thought_id=t.id) AS boost_count,
+        (SELECT COUNT(*) FROM thoughts r WHERE r.in_reply_to_id=t.id) AS reply_count
+    FROM thoughts t JOIN users u ON u.id=t.user_id";
+
+fn row_to_entry(r: FeedRow) -> FeedEntry {
+    let thought = Thought {
+        id: ThoughtId::from_uuid(r.thought_id),
+        user_id: UserId::from_uuid(r.t_user_id),
+        content: Content::new_remote(r.content),
+        in_reply_to_id: r.in_reply_to_id.map(ThoughtId::from_uuid),
+        in_reply_to_url: r.in_reply_to_url,
+        ap_id: r.t_ap_id,
+        visibility: Visibility::from_str(&r.visibility),
+        content_warning: r.content_warning,
+        sensitive: r.sensitive,
+        local: r.t_local,
+        created_at: r.thought_created_at,
+        updated_at: r.updated_at,
+    };
+    let author = User {
+        id: UserId::from_uuid(r.author_id),
+        username: Username::from_trusted(r.username),
+        email: Email::from_trusted(r.email),
+        password_hash: PasswordHash(r.password_hash),
+        display_name: r.display_name, bio: r.bio,
+        avatar_url: r.avatar_url, header_url: r.header_url, custom_css: r.custom_css,
+        local: r.author_local, ap_id: r.u_ap_id, inbox_url: r.inbox_url,
+        public_key: r.public_key, private_key: r.private_key,
+        created_at: r.author_created_at, updated_at: r.author_updated_at,
+    };
+    FeedEntry { thought, author, like_count: r.like_count, boost_count: r.boost_count, reply_count: r.reply_count, liked_by_viewer: false, boosted_by_viewer: false }
+}
+
+#[async_trait]
+impl FeedRepository for PgFeedRepository {
+    async fn home_feed(&self, following_ids: &[UserId], page: &PageParams, _viewer_id: Option<&UserId>) -> Result<Paginated<FeedEntry>, DomainError> {
+        let ids: Vec<uuid::Uuid> = following_ids.iter().map(|id| id.as_uuid()).collect();
+        let total: i64 = sqlx::query_scalar(
+            "SELECT COUNT(*) FROM thoughts t WHERE t.user_id=ANY($1) AND t.visibility='public'"
+        ).bind(&ids).fetch_one(&self.pool).await.map_err(|e| DomainError::Internal(e.to_string()))?;
+
+        let sql = format!("{FEED_SELECT} WHERE t.user_id=ANY($1) AND t.visibility='public' ORDER BY t.created_at DESC LIMIT $2 OFFSET $3");
+        let rows = sqlx::query_as::<_, FeedRow>(&sql)
+            .bind(&ids).bind(page.limit()).bind(page.offset())
+            .fetch_all(&self.pool).await.map_err(|e| DomainError::Internal(e.to_string()))?;
+
+        Ok(Paginated { items: rows.into_iter().map(row_to_entry).collect(), total, page: page.page, per_page: page.per_page })
+    }
+
+    async fn public_feed(&self, page: &PageParams, _viewer_id: Option<&UserId>) -> Result<Paginated<FeedEntry>, DomainError> {
+        let total: i64 = sqlx::query_scalar(
+            "SELECT COUNT(*) FROM thoughts t WHERE t.local=true AND t.visibility='public'"
+        ).fetch_one(&self.pool).await.map_err(|e| DomainError::Internal(e.to_string()))?;
+
+        let sql = format!("{FEED_SELECT} WHERE t.local=true AND t.visibility='public' ORDER BY t.created_at DESC LIMIT $1 OFFSET $2");
+        let rows = sqlx::query_as::<_, FeedRow>(&sql)
+            .bind(page.limit()).bind(page.offset())
+            .fetch_all(&self.pool).await.map_err(|e| DomainError::Internal(e.to_string()))?;
+
+        Ok(Paginated { items: rows.into_iter().map(row_to_entry).collect(), total, page: page.page, per_page: page.per_page })
+    }
+
+    async fn search(&self, query: &str, page: &PageParams, _viewer_id: Option<&UserId>) -> Result<Paginated<FeedEntry>, DomainError> {
+        let total: i64 = sqlx::query_scalar(
+            "SELECT COUNT(*) FROM thoughts t WHERE t.content % $1 AND t.visibility='public'"
+        )
+        .bind(query)
+        .fetch_one(&self.pool)
+        .await
+        .map_err(|e| DomainError::Internal(e.to_string()))?;
+
+        let sql = format!("{FEED_SELECT} WHERE t.content % $1 AND t.visibility='public' ORDER BY similarity(t.content, $1) DESC LIMIT $2 OFFSET $3");
+        let rows = sqlx::query_as::<_, FeedRow>(&sql)
+            .bind(query)
+            .bind(page.limit())
+            .bind(page.offset())
+            .fetch_all(&self.pool)
+            .await
+            .map_err(|e| DomainError::Internal(e.to_string()))?;
+
+        Ok(Paginated { items: rows.into_iter().map(row_to_entry).collect(), total, page: page.page, per_page: page.per_page })
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use domain::{models::{thought::{Thought, Visibility}, user::User}, ports::{ThoughtRepository, UserRepository}, value_objects::*};
+    use crate::{thought::PgThoughtRepository, user::PgUserRepository};
+
+    async fn seed(pool: &sqlx::PgPool, username: &str, content: &str) -> (User, Thought) {
+        let urepo = PgUserRepository::new(pool.clone());
+        let trepo = PgThoughtRepository::new(pool.clone());
+        let u = User::new_local(UserId::new(), Username::new(username).unwrap(), Email::new(format!("{username}@ex.com")).unwrap(), PasswordHash("h".into()));
+        urepo.save(&u).await.unwrap();
+        let t = Thought::new_local(ThoughtId::new(), u.id.clone(), Content::new_local(content).unwrap(), None, Visibility::Public, None, false);
+        trepo.save(&t).await.unwrap();
+        (u, t)
+    }
+
+    #[sqlx::test(migrations = "./migrations")]
+    async fn public_feed_returns_local_thoughts(pool: sqlx::PgPool) {
+        let (_, _) = seed(&pool, "alice", "hello").await;
+        let repo = PgFeedRepository::new(pool);
+        let result = repo.public_feed(&PageParams { page: 1, per_page: 20 }, None).await.unwrap();
+        assert_eq!(result.total, 1);
+        assert_eq!(result.items[0].thought.content.as_str(), "hello");
+    }
+
+    #[sqlx::test(migrations = "./migrations")]
+    async fn search_returns_matching_thoughts(pool: sqlx::PgPool) {
+        let (_, _) = seed(&pool, "alice", "hello world").await;
+        let (_, _) = seed(&pool, "bob", "goodbye world").await;
+        let repo = PgFeedRepository::new(pool);
+        let result = repo.search("hello world", &PageParams { page: 1, per_page: 20 }, None).await.unwrap();
+        assert!(result.total >= 1);
+        assert!(result.items.iter().any(|e| e.thought.content.as_str() == "hello world"));
+    }
+}

crates/adapters/postgres/src/follow.rs

@@ -0,0 +1,194 @@
+use async_trait::async_trait;
+use chrono::{DateTime, Utc};
+use sqlx::PgPool;
+use domain::{
+    errors::DomainError,
+    models::{feed::{PageParams, Paginated}, social::{Follow, FollowState}, user::User},
+    ports::FollowRepository,
+    value_objects::UserId,
+};
+
+pub struct PgFollowRepository { pool: PgPool }
+impl PgFollowRepository { pub fn new(pool: PgPool) -> Self { Self { pool } } }
+
+#[async_trait]
+impl FollowRepository for PgFollowRepository {
+    async fn save(&self, f: &Follow) -> Result<(), DomainError> {
+        sqlx::query(
+            "INSERT INTO follows(follower_id,following_id,state,ap_id,created_at)
+             VALUES($1,$2,$3,$4,$5)
+             ON CONFLICT(follower_id,following_id) DO UPDATE SET state=EXCLUDED.state,ap_id=EXCLUDED.ap_id"
+        )
+        .bind(f.follower_id.as_uuid())
+        .bind(f.following_id.as_uuid())
+        .bind(f.state.as_str())
+        .bind(&f.ap_id)
+        .bind(f.created_at)
+        .execute(&self.pool)
+        .await
+        .map_err(|e| DomainError::Internal(e.to_string()))
+        .map(|_| ())
+    }
+
+    async fn delete(&self, follower_id: &UserId, following_id: &UserId) -> Result<(), DomainError> {
+        let r = sqlx::query("DELETE FROM follows WHERE follower_id=$1 AND following_id=$2")
+            .bind(follower_id.as_uuid())
+            .bind(following_id.as_uuid())
+            .execute(&self.pool)
+            .await
+            .map_err(|e| DomainError::Internal(e.to_string()))?;
+        if r.rows_affected() == 0 { return Err(DomainError::NotFound); }
+        Ok(())
+    }
+
+    async fn find(&self, follower_id: &UserId, following_id: &UserId) -> Result<Option<Follow>, DomainError> {
+        #[derive(sqlx::FromRow)]
+        struct Row { follower_id: uuid::Uuid, following_id: uuid::Uuid, state: String, ap_id: Option<String>, created_at: DateTime<Utc> }
+        sqlx::query_as::<_, Row>(
+            "SELECT follower_id,following_id,state,ap_id,created_at FROM follows WHERE follower_id=$1 AND following_id=$2"
+        )
+        .bind(follower_id.as_uuid())
+        .bind(following_id.as_uuid())
+        .fetch_optional(&self.pool)
+        .await
+        .map_err(|e| DomainError::Internal(e.to_string()))
+        .map(|o| o.map(|r| Follow {
+            follower_id: UserId::from_uuid(r.follower_id),
+            following_id: UserId::from_uuid(r.following_id),
+            state: FollowState::from_str(&r.state),
+            ap_id: r.ap_id,
+            created_at: r.created_at,
+        }))
+    }
+
+    async fn update_state(&self, follower_id: &UserId, following_id: &UserId, state: &FollowState) -> Result<(), DomainError> {
+        sqlx::query("UPDATE follows SET state=$3 WHERE follower_id=$1 AND following_id=$2")
+            .bind(follower_id.as_uuid())
+            .bind(following_id.as_uuid())
+            .bind(state.as_str())
+            .execute(&self.pool)
+            .await
+            .map_err(|e| DomainError::Internal(e.to_string()))
+            .map(|_| ())
+    }
+
+    async fn list_followers(&self, user_id: &UserId, page: &PageParams) -> Result<Paginated<User>, DomainError> {
+        let total: i64 = sqlx::query_scalar(
+            "SELECT COUNT(*) FROM follows WHERE following_id=$1 AND state='accepted'"
+        )
+        .bind(user_id.as_uuid())
+        .fetch_one(&self.pool)
+        .await
+        .map_err(|e| DomainError::Internal(e.to_string()))?;
+
+        let rows = sqlx::query_as::<_, crate::user::UserRow>(
+            "SELECT u.id,u.username,u.email,u.password_hash,u.display_name,u.bio,u.avatar_url,u.header_url,u.custom_css,u.local,u.ap_id,u.inbox_url,u.public_key,u.private_key,u.created_at,u.updated_at
+             FROM users u JOIN follows f ON f.follower_id=u.id
+             WHERE f.following_id=$1 AND f.state='accepted'
+             ORDER BY f.created_at DESC LIMIT $2 OFFSET $3"
+        )
+        .bind(user_id.as_uuid())
+        .bind(page.limit())
+        .bind(page.offset())
+        .fetch_all(&self.pool)
+        .await
+        .map_err(|e| DomainError::Internal(e.to_string()))?;
+
+        Ok(Paginated {
+            items: rows.into_iter().map(User::from).collect(),
+            total,
+            page: page.page,
+            per_page: page.per_page,
+        })
+    }
+
+    async fn list_following(&self, user_id: &UserId, page: &PageParams) -> Result<Paginated<User>, DomainError> {
+        let total: i64 = sqlx::query_scalar(
+            "SELECT COUNT(*) FROM follows WHERE follower_id=$1 AND state='accepted'"
+        )
+        .bind(user_id.as_uuid())
+        .fetch_one(&self.pool)
+        .await
+        .map_err(|e| DomainError::Internal(e.to_string()))?;
+
+        let rows = sqlx::query_as::<_, crate::user::UserRow>(
+            "SELECT u.id,u.username,u.email,u.password_hash,u.display_name,u.bio,u.avatar_url,u.header_url,u.custom_css,u.local,u.ap_id,u.inbox_url,u.public_key,u.private_key,u.created_at,u.updated_at
+             FROM users u JOIN follows f ON f.following_id=u.id
+             WHERE f.follower_id=$1 AND f.state='accepted'
+             ORDER BY f.created_at DESC LIMIT $2 OFFSET $3"
+        )
+        .bind(user_id.as_uuid())
+        .bind(page.limit())
+        .bind(page.offset())
+        .fetch_all(&self.pool)
+        .await
+        .map_err(|e| DomainError::Internal(e.to_string()))?;
+
+        Ok(Paginated {
+            items: rows.into_iter().map(User::from).collect(),
+            total,
+            page: page.page,
+            per_page: page.per_page,
+        })
+    }
+
+    async fn get_accepted_following_ids(&self, user_id: &UserId) -> Result<Vec<UserId>, DomainError> {
+        let ids: Vec<uuid::Uuid> = sqlx::query_scalar(
+            "SELECT following_id FROM follows WHERE follower_id=$1 AND state='accepted'"
+        )
+        .bind(user_id.as_uuid())
+        .fetch_all(&self.pool)
+        .await
+        .map_err(|e| DomainError::Internal(e.to_string()))?;
+        Ok(ids.into_iter().map(UserId::from_uuid).collect())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use chrono::Utc;
+    use domain::{models::user::User, value_objects::*};
+    use crate::user::PgUserRepository;
+    use domain::ports::UserRepository;
+
+    async fn seed_user(pool: &sqlx::PgPool, username: &str, email: &str) -> User {
+        let repo = PgUserRepository::new(pool.clone());
+        let u = User::new_local(UserId::new(), Username::new(username).unwrap(), Email::new(email).unwrap(), PasswordHash("h".into()));
+        repo.save(&u).await.unwrap(); u
+    }
+
+    #[sqlx::test(migrations = "./migrations")]
+    async fn save_and_find_follow(pool: sqlx::PgPool) {
+        let alice = seed_user(&pool, "alice", "alice@ex.com").await;
+        let bob   = seed_user(&pool, "bob",   "bob@ex.com").await;
+        let repo = PgFollowRepository::new(pool);
+        let follow = Follow { follower_id: alice.id.clone(), following_id: bob.id.clone(), state: FollowState::Accepted, ap_id: None, created_at: Utc::now() };
+        repo.save(&follow).await.unwrap();
+        let found = repo.find(&alice.id, &bob.id).await.unwrap().unwrap();
+        assert_eq!(found.state, FollowState::Accepted);
+    }
+
+    #[sqlx::test(migrations = "./migrations")]
+    async fn update_state(pool: sqlx::PgPool) {
+        let alice = seed_user(&pool, "alice", "alice@ex.com").await;
+        let bob   = seed_user(&pool, "bob",   "bob@ex.com").await;
+        let repo = PgFollowRepository::new(pool);
+        let follow = Follow { follower_id: alice.id.clone(), following_id: bob.id.clone(), state: FollowState::Pending, ap_id: None, created_at: Utc::now() };
+        repo.save(&follow).await.unwrap();
+        repo.update_state(&alice.id, &bob.id, &FollowState::Accepted).await.unwrap();
+        let found = repo.find(&alice.id, &bob.id).await.unwrap().unwrap();
+        assert_eq!(found.state, FollowState::Accepted);
+    }
+
+    #[sqlx::test(migrations = "./migrations")]
+    async fn get_accepted_following_ids(pool: sqlx::PgPool) {
+        let alice = seed_user(&pool, "alice", "alice@ex.com").await;
+        let bob   = seed_user(&pool, "bob",   "bob@ex.com").await;
+        let repo = PgFollowRepository::new(pool);
+        let follow = Follow { follower_id: alice.id.clone(), following_id: bob.id.clone(), state: FollowState::Accepted, ap_id: None, created_at: Utc::now() };
+        repo.save(&follow).await.unwrap();
+        let ids = repo.get_accepted_following_ids(&alice.id).await.unwrap();
+        assert_eq!(ids, vec![bob.id]);
+    }
+}

crates/adapters/postgres/src/lib.rs

@@ -0,0 +1,13 @@
+pub mod activitypub;
+pub mod api_key;
+pub mod block;
+pub mod boost;
+pub mod feed;
+pub mod follow;
+pub mod like;
+pub mod notification;
+pub mod remote_actor;
+pub mod tag;
+pub mod thought;
+pub mod top_friend;
+pub mod user;

crates/adapters/postgres/src/like.rs

@@ -0,0 +1,80 @@
+use async_trait::async_trait;
+use chrono::{DateTime, Utc};
+use sqlx::PgPool;
+use domain::{errors::DomainError, models::social::Like, ports::LikeRepository, value_objects::{LikeId, ThoughtId, UserId}};
+
+pub struct PgLikeRepository { pool: PgPool }
+impl PgLikeRepository { pub fn new(pool: PgPool) -> Self { Self { pool } } }
+
+#[async_trait]
+impl LikeRepository for PgLikeRepository {
+    async fn save(&self, l: &Like) -> Result<(), DomainError> {
+        sqlx::query(
+            "INSERT INTO likes(id,user_id,thought_id,ap_id,created_at) VALUES($1,$2,$3,$4,$5) ON CONFLICT(user_id,thought_id) DO NOTHING"
+        )
+        .bind(l.id.as_uuid()).bind(l.user_id.as_uuid()).bind(l.thought_id.as_uuid()).bind(&l.ap_id).bind(l.created_at)
+        .execute(&self.pool).await.map_err(|e| DomainError::Internal(e.to_string())).map(|_| ())
+    }
+
+    async fn delete(&self, user_id: &UserId, thought_id: &ThoughtId) -> Result<(), DomainError> {
+        let r = sqlx::query("DELETE FROM likes WHERE user_id=$1 AND thought_id=$2")
+            .bind(user_id.as_uuid()).bind(thought_id.as_uuid())
+            .execute(&self.pool).await.map_err(|e| DomainError::Internal(e.to_string()))?;
+        if r.rows_affected() == 0 { return Err(DomainError::NotFound); }
+        Ok(())
+    }
+
+    async fn find(&self, user_id: &UserId, thought_id: &ThoughtId) -> Result<Option<Like>, DomainError> {
+        #[derive(sqlx::FromRow)]
+        struct Row { id: uuid::Uuid, user_id: uuid::Uuid, thought_id: uuid::Uuid, ap_id: Option<String>, created_at: DateTime<Utc> }
+        sqlx::query_as::<_, Row>("SELECT id,user_id,thought_id,ap_id,created_at FROM likes WHERE user_id=$1 AND thought_id=$2")
+            .bind(user_id.as_uuid()).bind(thought_id.as_uuid())
+            .fetch_optional(&self.pool).await
+            .map_err(|e| DomainError::Internal(e.to_string()))
+            .map(|o| o.map(|r| Like { id: LikeId::from_uuid(r.id), user_id: UserId::from_uuid(r.user_id), thought_id: ThoughtId::from_uuid(r.thought_id), ap_id: r.ap_id, created_at: r.created_at }))
+    }
+
+    async fn count_for_thought(&self, thought_id: &ThoughtId) -> Result<i64, DomainError> {
+        sqlx::query_scalar("SELECT COUNT(*) FROM likes WHERE thought_id=$1")
+            .bind(thought_id.as_uuid()).fetch_one(&self.pool).await
+            .map_err(|e| DomainError::Internal(e.to_string()))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use chrono::Utc;
+    use domain::{models::{thought::{Thought, Visibility}, user::User}, value_objects::*};
+    use crate::{thought::PgThoughtRepository, user::PgUserRepository};
+    use domain::ports::{ThoughtRepository, UserRepository};
+
+    async fn seed(pool: &sqlx::PgPool) -> (User, Thought) {
+        let urepo = PgUserRepository::new(pool.clone());
+        let trepo = PgThoughtRepository::new(pool.clone());
+        let u = User::new_local(UserId::new(), Username::new("alice").unwrap(), Email::new("alice@ex.com").unwrap(), PasswordHash("h".into()));
+        urepo.save(&u).await.unwrap();
+        let t = Thought::new_local(ThoughtId::new(), u.id.clone(), Content::new_local("hi").unwrap(), None, Visibility::Public, None, false);
+        trepo.save(&t).await.unwrap();
+        (u, t)
+    }
+
+    #[sqlx::test(migrations = "./migrations")]
+    async fn like_and_count(pool: sqlx::PgPool) {
+        let (user, thought) = seed(&pool).await;
+        let repo = PgLikeRepository::new(pool);
+        let like = Like { id: LikeId::new(), user_id: user.id.clone(), thought_id: thought.id.clone(), ap_id: None, created_at: Utc::now() };
+        repo.save(&like).await.unwrap();
+        assert_eq!(repo.count_for_thought(&thought.id).await.unwrap(), 1);
+    }
+
+    #[sqlx::test(migrations = "./migrations")]
+    async fn unlike(pool: sqlx::PgPool) {
+        let (user, thought) = seed(&pool).await;
+        let repo = PgLikeRepository::new(pool);
+        let like = Like { id: LikeId::new(), user_id: user.id.clone(), thought_id: thought.id.clone(), ap_id: None, created_at: Utc::now() };
+        repo.save(&like).await.unwrap();
+        repo.delete(&user.id, &thought.id).await.unwrap();
+        assert_eq!(repo.count_for_thought(&thought.id).await.unwrap(), 0);
+    }
+}

crates/adapters/postgres/src/notification.rs

@@ -0,0 +1,91 @@
+use async_trait::async_trait;
+use chrono::{DateTime, Utc};
+use sqlx::PgPool;
+use domain::{errors::DomainError, models::{feed::{PageParams, Paginated}, notification::{Notification, NotificationType}}, ports::NotificationRepository, value_objects::{NotificationId, ThoughtId, UserId}};
+
+pub struct PgNotificationRepository { pool: PgPool }
+impl PgNotificationRepository { pub fn new(pool: PgPool) -> Self { Self { pool } } }
+
+#[async_trait]
+impl NotificationRepository for PgNotificationRepository {
+    async fn save(&self, n: &Notification) -> Result<(), DomainError> {
+        sqlx::query(
+            "INSERT INTO notifications(id,user_id,type,from_user_id,thought_id,read,created_at) VALUES($1,$2,$3,$4,$5,$6,$7)"
+        )
+        .bind(n.id.as_uuid()).bind(n.user_id.as_uuid()).bind(n.notification_type.as_str())
+        .bind(n.from_user_id.as_ref().map(|u| u.as_uuid()))
+        .bind(n.thought_id.as_ref().map(|t| t.as_uuid()))
+        .bind(n.read).bind(n.created_at)
+        .execute(&self.pool).await.map_err(|e| DomainError::Internal(e.to_string())).map(|_| ())
+    }
+
+    async fn list_for_user(&self, user_id: &UserId, page: &PageParams) -> Result<Paginated<Notification>, DomainError> {
+        let total: i64 = sqlx::query_scalar("SELECT COUNT(*) FROM notifications WHERE user_id=$1")
+            .bind(user_id.as_uuid()).fetch_one(&self.pool).await.map_err(|e| DomainError::Internal(e.to_string()))?;
+        #[derive(sqlx::FromRow)]
+        struct Row { id: uuid::Uuid, user_id: uuid::Uuid, r#type: String, from_user_id: Option<uuid::Uuid>, thought_id: Option<uuid::Uuid>, read: bool, created_at: DateTime<Utc> }
+        let rows = sqlx::query_as::<_, Row>(
+            "SELECT id,user_id,type,from_user_id,thought_id,read,created_at FROM notifications WHERE user_id=$1 ORDER BY created_at DESC LIMIT $2 OFFSET $3"
+        ).bind(user_id.as_uuid()).bind(page.limit()).bind(page.offset())
+        .fetch_all(&self.pool).await.map_err(|e| DomainError::Internal(e.to_string()))?;
+        let items = rows.into_iter().map(|r| Notification {
+            id: NotificationId::from_uuid(r.id), user_id: UserId::from_uuid(r.user_id),
+            notification_type: NotificationType::from_str(&r.r#type),
+            from_user_id: r.from_user_id.map(UserId::from_uuid),
+            thought_id: r.thought_id.map(ThoughtId::from_uuid),
+            read: r.read, created_at: r.created_at,
+        }).collect();
+        Ok(Paginated { items, total, page: page.page, per_page: page.per_page })
+    }
+
+    async fn mark_read(&self, id: &NotificationId, user_id: &UserId) -> Result<(), DomainError> {
+        sqlx::query("UPDATE notifications SET read=true WHERE id=$1 AND user_id=$2")
+            .bind(id.as_uuid()).bind(user_id.as_uuid())
+            .execute(&self.pool).await.map_err(|e| DomainError::Internal(e.to_string())).map(|_| ())
+    }
+
+    async fn mark_all_read(&self, user_id: &UserId) -> Result<(), DomainError> {
+        sqlx::query("UPDATE notifications SET read=true WHERE user_id=$1")
+            .bind(user_id.as_uuid())
+            .execute(&self.pool).await.map_err(|e| DomainError::Internal(e.to_string())).map(|_| ())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use chrono::Utc;
+    use domain::{models::{notification::NotificationType, user::User}, value_objects::*};
+    use crate::user::PgUserRepository;
+    use domain::ports::UserRepository;
+
+    async fn seed_user(pool: &sqlx::PgPool) -> User {
+        let repo = PgUserRepository::new(pool.clone());
+        let u = User::new_local(UserId::new(), Username::new("alice").unwrap(), Email::new("alice@ex.com").unwrap(), PasswordHash("h".into()));
+        repo.save(&u).await.unwrap(); u
+    }
+
+    #[sqlx::test(migrations = "./migrations")]
+    async fn save_and_list(pool: sqlx::PgPool) {
+        let user = seed_user(&pool).await;
+        let repo = PgNotificationRepository::new(pool);
+        use domain::models::feed::PageParams;
+        let n = Notification { id: NotificationId::new(), user_id: user.id.clone(), notification_type: NotificationType::Like, from_user_id: None, thought_id: None, read: false, created_at: Utc::now() };
+        repo.save(&n).await.unwrap();
+        let page = repo.list_for_user(&user.id, &PageParams { page: 1, per_page: 20 }).await.unwrap();
+        assert_eq!(page.total, 1);
+        assert!(!page.items[0].read);
+    }
+
+    #[sqlx::test(migrations = "./migrations")]
+    async fn mark_all_read(pool: sqlx::PgPool) {
+        let user = seed_user(&pool).await;
+        let repo = PgNotificationRepository::new(pool);
+        use domain::models::feed::PageParams;
+        let n = Notification { id: NotificationId::new(), user_id: user.id.clone(), notification_type: NotificationType::Follow, from_user_id: None, thought_id: None, read: false, created_at: Utc::now() };
+        repo.save(&n).await.unwrap();
+        repo.mark_all_read(&user.id).await.unwrap();
+        let page = repo.list_for_user(&user.id, &PageParams { page: 1, per_page: 20 }).await.unwrap();
+        assert!(page.items[0].read);
+    }
+}

crates/adapters/postgres/src/remote_actor.rs

@@ -0,0 +1,33 @@
+use async_trait::async_trait;
+use chrono::{DateTime, Utc};
+use sqlx::PgPool;
+use domain::{errors::DomainError, models::remote_actor::RemoteActor, ports::RemoteActorRepository};
+
+pub struct PgRemoteActorRepository { pool: PgPool }
+impl PgRemoteActorRepository { pub fn new(pool: PgPool) -> Self { Self { pool } } }
+
+#[async_trait]
+impl RemoteActorRepository for PgRemoteActorRepository {
+    async fn upsert(&self, a: &RemoteActor) -> Result<(), DomainError> {
+        sqlx::query(
+            "INSERT INTO remote_actors(url,handle,display_name,inbox_url,shared_inbox_url,public_key,last_fetched_at)
+             VALUES($1,$2,$3,$4,$5,$6,$7)
+             ON CONFLICT(url) DO UPDATE SET handle=EXCLUDED.handle,display_name=EXCLUDED.display_name,
+             inbox_url=EXCLUDED.inbox_url,shared_inbox_url=EXCLUDED.shared_inbox_url,
+             public_key=EXCLUDED.public_key,last_fetched_at=EXCLUDED.last_fetched_at"
+        )
+        .bind(&a.url).bind(&a.handle).bind(&a.display_name).bind(&a.inbox_url)
+        .bind(&a.shared_inbox_url).bind(&a.public_key).bind(a.last_fetched_at)
+        .execute(&self.pool).await.map_err(|e| DomainError::Internal(e.to_string())).map(|_| ())
+    }
+
+    async fn find_by_url(&self, url: &str) -> Result<Option<RemoteActor>, DomainError> {
+        #[derive(sqlx::FromRow)]
+        struct Row { url: String, handle: String, display_name: Option<String>, inbox_url: String, shared_inbox_url: Option<String>, public_key: String, last_fetched_at: DateTime<Utc> }
+        sqlx::query_as::<_, Row>(
+            "SELECT url,handle,display_name,inbox_url,shared_inbox_url,public_key,last_fetched_at FROM remote_actors WHERE url=$1"
+        ).bind(url).fetch_optional(&self.pool).await
+        .map_err(|e| DomainError::Internal(e.to_string()))
+        .map(|o| o.map(|r| RemoteActor { url: r.url, handle: r.handle, display_name: r.display_name, inbox_url: r.inbox_url, shared_inbox_url: r.shared_inbox_url, public_key: r.public_key, last_fetched_at: r.last_fetched_at }))
+    }
+}

crates/adapters/postgres/src/tag.rs

@@ -0,0 +1,87 @@
+use async_trait::async_trait;
+use sqlx::PgPool;
+use domain::{errors::DomainError, models::{feed::{PageParams, Paginated}, tag::Tag, thought::Thought}, ports::TagRepository, value_objects::ThoughtId};
+
+pub struct PgTagRepository { pool: PgPool }
+impl PgTagRepository { pub fn new(pool: PgPool) -> Self { Self { pool } } }
+
+#[async_trait]
+impl TagRepository for PgTagRepository {
+    async fn find_or_create(&self, name: &str) -> Result<Tag, DomainError> {
+        let name = name.to_lowercase();
+        sqlx::query("INSERT INTO tags(name) VALUES($1) ON CONFLICT(name) DO NOTHING")
+            .bind(&name).execute(&self.pool).await.map_err(|e| DomainError::Internal(e.to_string()))?;
+        #[derive(sqlx::FromRow)] struct Row { id: i32, name: String }
+        let row = sqlx::query_as::<_, Row>("SELECT id,name FROM tags WHERE name=$1").bind(&name)
+            .fetch_one(&self.pool).await.map_err(|e| DomainError::Internal(e.to_string()))?;
+        Ok(Tag { id: row.id, name: row.name })
+    }
+
+    async fn attach_to_thought(&self, thought_id: &ThoughtId, tag_id: i32) -> Result<(), DomainError> {
+        sqlx::query("INSERT INTO thought_tags(thought_id,tag_id) VALUES($1,$2) ON CONFLICT DO NOTHING")
+            .bind(thought_id.as_uuid()).bind(tag_id)
+            .execute(&self.pool).await.map_err(|e| DomainError::Internal(e.to_string())).map(|_| ())
+    }
+
+    async fn detach_from_thought(&self, thought_id: &ThoughtId) -> Result<(), DomainError> {
+        sqlx::query("DELETE FROM thought_tags WHERE thought_id=$1").bind(thought_id.as_uuid())
+            .execute(&self.pool).await.map_err(|e| DomainError::Internal(e.to_string())).map(|_| ())
+    }
+
+    async fn list_for_thought(&self, thought_id: &ThoughtId) -> Result<Vec<Tag>, DomainError> {
+        #[derive(sqlx::FromRow)] struct Row { id: i32, name: String }
+        sqlx::query_as::<_, Row>(
+            "SELECT t.id,t.name FROM tags t JOIN thought_tags tt ON tt.tag_id=t.id WHERE tt.thought_id=$1"
+        ).bind(thought_id.as_uuid()).fetch_all(&self.pool).await
+        .map_err(|e| DomainError::Internal(e.to_string()))
+        .map(|rows| rows.into_iter().map(|r| Tag { id: r.id, name: r.name }).collect())
+    }
+
+    async fn list_thoughts_by_tag(&self, tag_name: &str, page: &PageParams) -> Result<Paginated<Thought>, DomainError> {
+        let total: i64 = sqlx::query_scalar(
+            "SELECT COUNT(*) FROM thought_tags tt JOIN tags t ON t.id=tt.tag_id WHERE t.name=$1"
+        ).bind(tag_name).fetch_one(&self.pool).await.map_err(|e| DomainError::Internal(e.to_string()))?;
+
+        let rows = sqlx::query_as::<_, crate::thought::ThoughtRow>(
+            "SELECT th.id,th.user_id,th.content,th.in_reply_to_id,th.in_reply_to_url,th.ap_id,th.visibility,th.content_warning,th.sensitive,th.local,th.created_at,th.updated_at
+             FROM thoughts th JOIN thought_tags tt ON tt.thought_id=th.id JOIN tags t ON t.id=tt.tag_id
+             WHERE t.name=$1 ORDER BY th.created_at DESC LIMIT $2 OFFSET $3"
+        ).bind(tag_name).bind(page.limit()).bind(page.offset())
+        .fetch_all(&self.pool).await.map_err(|e| DomainError::Internal(e.to_string()))?;
+
+        Ok(Paginated { items: rows.into_iter().map(Thought::from).collect(), total, page: page.page, per_page: page.per_page })
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use domain::{models::{thought::{Thought, Visibility}, user::User}, value_objects::*};
+    use crate::{thought::PgThoughtRepository, user::PgUserRepository};
+    use domain::ports::{ThoughtRepository, UserRepository};
+
+    #[sqlx::test(migrations = "./migrations")]
+    async fn find_or_create_tag(pool: sqlx::PgPool) {
+        let repo = PgTagRepository::new(pool);
+        let t1 = repo.find_or_create("rust").await.unwrap();
+        let t2 = repo.find_or_create("rust").await.unwrap();
+        assert_eq!(t1.id, t2.id);
+        assert_eq!(t1.name, "rust");
+    }
+
+    #[sqlx::test(migrations = "./migrations")]
+    async fn attach_and_list(pool: sqlx::PgPool) {
+        let urepo = PgUserRepository::new(pool.clone());
+        let trepo = PgThoughtRepository::new(pool.clone());
+        let u = User::new_local(UserId::new(), Username::new("alice").unwrap(), Email::new("alice@ex.com").unwrap(), PasswordHash("h".into()));
+        urepo.save(&u).await.unwrap();
+        let t = Thought::new_local(ThoughtId::new(), u.id.clone(), Content::new_local("hi").unwrap(), None, Visibility::Public, None, false);
+        trepo.save(&t).await.unwrap();
+        let repo = PgTagRepository::new(pool);
+        let tag = repo.find_or_create("greetings").await.unwrap();
+        repo.attach_to_thought(&t.id, tag.id).await.unwrap();
+        let tags = repo.list_for_thought(&t.id).await.unwrap();
+        assert_eq!(tags.len(), 1);
+        assert_eq!(tags[0].name, "greetings");
+    }
+}

crates/adapters/postgres/src/thought.rs

@@ -0,0 +1,236 @@
+use async_trait::async_trait;
+use chrono::{DateTime, Utc};
+use sqlx::PgPool;
+use domain::{
+    errors::DomainError,
+    models::{
+        feed::{FeedEntry, PageParams, Paginated},
+        thought::{Thought, Visibility},
+        user::User,
+    },
+    ports::ThoughtRepository,
+    value_objects::{Content, Email, PasswordHash, ThoughtId, UserId, Username},
+};
+
+pub struct PgThoughtRepository { pool: PgPool }
+impl PgThoughtRepository { pub fn new(pool: PgPool) -> Self { Self { pool } } }
+
+#[derive(sqlx::FromRow)]
+pub(crate) struct ThoughtRow {
+    pub id: uuid::Uuid,
+    pub user_id: uuid::Uuid,
+    pub content: String,
+    pub in_reply_to_id: Option<uuid::Uuid>,
+    pub in_reply_to_url: Option<String>,
+    pub ap_id: Option<String>,
+    pub visibility: String,
+    pub content_warning: Option<String>,
+    pub sensitive: bool,
+    pub local: bool,
+    pub created_at: DateTime<Utc>,
+    pub updated_at: Option<DateTime<Utc>>,
+}
+
+impl From<ThoughtRow> for Thought {
+    fn from(r: ThoughtRow) -> Self {
+        Thought {
+            id: ThoughtId::from_uuid(r.id),
+            user_id: UserId::from_uuid(r.user_id),
+            content: Content::new_remote(r.content),
+            in_reply_to_id: r.in_reply_to_id.map(ThoughtId::from_uuid),
+            in_reply_to_url: r.in_reply_to_url,
+            ap_id: r.ap_id,
+            visibility: Visibility::from_str(&r.visibility),
+            content_warning: r.content_warning,
+            sensitive: r.sensitive,
+            local: r.local,
+            created_at: r.created_at,
+            updated_at: r.updated_at,
+        }
+    }
+}
+
+const THOUGHT_SELECT: &str =
+    "SELECT id,user_id,content,in_reply_to_id,in_reply_to_url,ap_id,visibility,content_warning,sensitive,local,created_at,updated_at FROM thoughts";
+
+#[async_trait]
+impl ThoughtRepository for PgThoughtRepository {
+    async fn save(&self, t: &Thought) -> Result<(), DomainError> {
+        sqlx::query(
+            "INSERT INTO thoughts(id,user_id,content,in_reply_to_id,in_reply_to_url,ap_id,visibility,content_warning,sensitive,local,created_at)
+             VALUES($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11)
+             ON CONFLICT(id) DO UPDATE SET content=EXCLUDED.content,updated_at=NOW()"
+        )
+        .bind(t.id.as_uuid())
+        .bind(t.user_id.as_uuid())
+        .bind(t.content.as_str())
+        .bind(t.in_reply_to_id.as_ref().map(|x| x.as_uuid()))
+        .bind(&t.in_reply_to_url)
+        .bind(&t.ap_id)
+        .bind(t.visibility.as_str())
+        .bind(&t.content_warning)
+        .bind(t.sensitive)
+        .bind(t.local)
+        .bind(t.created_at)
+        .execute(&self.pool)
+        .await
+        .map_err(|e| DomainError::Internal(e.to_string()))
+        .map(|_| ())
+    }
+
+    async fn find_by_id(&self, id: &ThoughtId) -> Result<Option<Thought>, DomainError> {
+        sqlx::query_as::<_, ThoughtRow>(&format!("{THOUGHT_SELECT} WHERE id=$1"))
+            .bind(id.as_uuid())
+            .fetch_optional(&self.pool)
+            .await
+            .map_err(|e| DomainError::Internal(e.to_string()))
+            .map(|o| o.map(Thought::from))
+    }
+
+    async fn delete(&self, id: &ThoughtId, user_id: &UserId) -> Result<(), DomainError> {
+        let r = sqlx::query("DELETE FROM thoughts WHERE id=$1 AND user_id=$2")
+            .bind(id.as_uuid())
+            .bind(user_id.as_uuid())
+            .execute(&self.pool)
+            .await
+            .map_err(|e| DomainError::Internal(e.to_string()))?;
+        if r.rows_affected() == 0 { return Err(DomainError::NotFound); }
+        Ok(())
+    }
+
+    async fn update_content(&self, id: &ThoughtId, content: &Content) -> Result<(), DomainError> {
+        sqlx::query("UPDATE thoughts SET content=$2,updated_at=NOW() WHERE id=$1")
+            .bind(id.as_uuid())
+            .bind(content.as_str())
+            .execute(&self.pool)
+            .await
+            .map_err(|e| DomainError::Internal(e.to_string()))
+            .map(|_| ())
+    }
+
+    async fn get_thread(&self, id: &ThoughtId) -> Result<Vec<Thought>, DomainError> {
+        sqlx::query_as::<_, ThoughtRow>(
+            &format!("{THOUGHT_SELECT} WHERE id=$1 OR in_reply_to_id=$1 ORDER BY created_at ASC")
+        )
+        .bind(id.as_uuid())
+        .fetch_all(&self.pool)
+        .await
+        .map_err(|e| DomainError::Internal(e.to_string()))
+        .map(|rows| rows.into_iter().map(Thought::from).collect())
+    }
+
+    async fn list_by_user(&self, user_id: &UserId, page: &PageParams) -> Result<Paginated<FeedEntry>, DomainError> {
+        let total: i64 = sqlx::query_scalar("SELECT COUNT(*) FROM thoughts WHERE user_id=$1")
+            .bind(user_id.as_uuid())
+            .fetch_one(&self.pool)
+            .await
+            .map_err(|e| DomainError::Internal(e.to_string()))?;
+
+        let rows = sqlx::query_as::<_, ThoughtRow>(
+            &format!("{THOUGHT_SELECT} WHERE user_id=$1 ORDER BY created_at DESC LIMIT $2 OFFSET $3")
+        )
+        .bind(user_id.as_uuid())
+        .bind(page.limit())
+        .bind(page.offset())
+        .fetch_all(&self.pool)
+        .await
+        .map_err(|e| DomainError::Internal(e.to_string()))?;
+
+        let author = sqlx::query_as::<_, crate::user::UserRow>(
+            "SELECT id,username,email,password_hash,display_name,bio,avatar_url,header_url,custom_css,local,ap_id,inbox_url,public_key,private_key,created_at,updated_at FROM users WHERE id=$1"
+        )
+        .bind(user_id.as_uuid())
+        .fetch_optional(&self.pool)
+        .await
+        .map_err(|e| DomainError::Internal(e.to_string()))?
+        .ok_or(DomainError::NotFound)?;
+        let author = User::from(author);
+
+        let items = rows.into_iter().map(|r| {
+            let thought = Thought::from(r);
+            FeedEntry {
+                thought,
+                author: author.clone(),
+                like_count: 0,
+                boost_count: 0,
+                reply_count: 0,
+                liked_by_viewer: false,
+                boosted_by_viewer: false,
+            }
+        }).collect();
+
+        Ok(Paginated { items, total, page: page.page, per_page: page.per_page })
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use domain::{models::{thought::{Thought, Visibility}, user::User}, value_objects::*};
+    use crate::user::PgUserRepository;
+    use domain::ports::UserRepository;
+
+    async fn seed_user(pool: &sqlx::PgPool, username: &str, email: &str) -> User {
+        let repo = PgUserRepository::new(pool.clone());
+        let u = User::new_local(
+            UserId::new(),
+            Username::new(username).unwrap(),
+            Email::new(email).unwrap(),
+            PasswordHash("h".into()),
+        );
+        repo.save(&u).await.unwrap();
+        u
+    }
+
+    #[sqlx::test(migrations = "./migrations")]
+    async fn save_and_find_thought(pool: sqlx::PgPool) {
+        let user = seed_user(&pool, "alice", "alice@ex.com").await;
+        let repo = PgThoughtRepository::new(pool);
+        let t = Thought::new_local(
+            ThoughtId::new(),
+            user.id.clone(),
+            Content::new_local("hello world").unwrap(),
+            None,
+            Visibility::Public,
+            None,
+            false,
+        );
+        repo.save(&t).await.unwrap();
+        let found = repo.find_by_id(&t.id).await.unwrap().unwrap();
+        assert_eq!(found.content.as_str(), "hello world");
+        assert!(found.local);
+    }
+
+    #[sqlx::test(migrations = "./migrations")]
+    async fn delete_thought(pool: sqlx::PgPool) {
+        let user = seed_user(&pool, "bob", "bob@ex.com").await;
+        let repo = PgThoughtRepository::new(pool);
+        let t = Thought::new_local(ThoughtId::new(), user.id.clone(), Content::new_local("bye").unwrap(), None, Visibility::Public, None, false);
+        repo.save(&t).await.unwrap();
+        repo.delete(&t.id, &user.id).await.unwrap();
+        assert!(repo.find_by_id(&t.id).await.unwrap().is_none());
+    }
+
+    #[sqlx::test(migrations = "./migrations")]
+    async fn delete_wrong_owner_returns_not_found(pool: sqlx::PgPool) {
+        let alice = seed_user(&pool, "alice", "alice@ex.com").await;
+        let bob = seed_user(&pool, "bob", "bob@ex.com").await;
+        let repo = PgThoughtRepository::new(pool);
+        let t = Thought::new_local(ThoughtId::new(), alice.id.clone(), Content::new_local("secret").unwrap(), None, Visibility::Public, None, false);
+        repo.save(&t).await.unwrap();
+        let err = repo.delete(&t.id, &bob.id).await.unwrap_err();
+        assert!(matches!(err, DomainError::NotFound));
+    }
+
+    #[sqlx::test(migrations = "./migrations")]
+    async fn get_thread_returns_root_and_replies(pool: sqlx::PgPool) {
+        let user = seed_user(&pool, "charlie", "charlie@ex.com").await;
+        let repo = PgThoughtRepository::new(pool);
+        let root = Thought::new_local(ThoughtId::new(), user.id.clone(), Content::new_local("root").unwrap(), None, Visibility::Public, None, false);
+        let reply = Thought::new_local(ThoughtId::new(), user.id.clone(), Content::new_local("reply").unwrap(), Some(root.id.clone()), Visibility::Public, None, false);
+        repo.save(&root).await.unwrap();
+        repo.save(&reply).await.unwrap();
+        let thread = repo.get_thread(&root.id).await.unwrap();
+        assert_eq!(thread.len(), 2);
+    }
+}

crates/adapters/postgres/src/top_friend.rs

@@ -0,0 +1,95 @@
+use async_trait::async_trait;
+use sqlx::PgPool;
+use domain::{errors::DomainError, models::{top_friend::TopFriend, user::User}, ports::TopFriendRepository, value_objects::UserId};
+
+pub struct PgTopFriendRepository { pool: PgPool }
+impl PgTopFriendRepository { pub fn new(pool: PgPool) -> Self { Self { pool } } }
+
+#[async_trait]
+impl TopFriendRepository for PgTopFriendRepository {
+    async fn set_top_friends(&self, user_id: &UserId, friends: Vec<(UserId, i16)>) -> Result<(), DomainError> {
+        let mut tx = self.pool.begin().await.map_err(|e| DomainError::Internal(e.to_string()))?;
+        sqlx::query("DELETE FROM top_friends WHERE user_id=$1")
+            .bind(user_id.as_uuid()).execute(&mut *tx).await.map_err(|e| DomainError::Internal(e.to_string()))?;
+        for (friend_id, pos) in friends {
+            sqlx::query("INSERT INTO top_friends(user_id,friend_id,position) VALUES($1,$2,$3)")
+                .bind(user_id.as_uuid()).bind(friend_id.as_uuid()).bind(pos)
+                .execute(&mut *tx).await.map_err(|e| DomainError::Internal(e.to_string()))?;
+        }
+        tx.commit().await.map_err(|e| DomainError::Internal(e.to_string()))
+    }
+
+    async fn list_for_user(&self, user_id: &UserId) -> Result<Vec<(TopFriend, User)>, DomainError> {
+        #[derive(sqlx::FromRow)]
+        struct Row {
+            tf_user_id: uuid::Uuid, friend_id: uuid::Uuid, position: i16,
+            id: uuid::Uuid, username: String, email: String, password_hash: String,
+            display_name: Option<String>, bio: Option<String>, avatar_url: Option<String>,
+            header_url: Option<String>, custom_css: Option<String>, local: bool,
+            ap_id: Option<String>, inbox_url: Option<String>, public_key: Option<String>,
+            private_key: Option<String>,
+            created_at: chrono::DateTime<chrono::Utc>, updated_at: chrono::DateTime<chrono::Utc>,
+        }
+        let rows = sqlx::query_as::<_, Row>(
+            "SELECT tf.user_id AS tf_user_id, tf.friend_id, tf.position,
+             u.id, u.username, u.email, u.password_hash, u.display_name, u.bio,
+             u.avatar_url, u.header_url, u.custom_css, u.local, u.ap_id, u.inbox_url,
+             u.public_key, u.private_key, u.created_at, u.updated_at
+             FROM top_friends tf JOIN users u ON u.id=tf.friend_id
+             WHERE tf.user_id=$1 ORDER BY tf.position"
+        ).bind(user_id.as_uuid()).fetch_all(&self.pool).await.map_err(|e| DomainError::Internal(e.to_string()))?;
+
+        Ok(rows.into_iter().map(|r| {
+            use domain::value_objects::{Email, PasswordHash, Username};
+            let tf = TopFriend { user_id: UserId::from_uuid(r.tf_user_id), friend_id: UserId::from_uuid(r.friend_id), position: r.position };
+            let u = User {
+                id: UserId::from_uuid(r.id), username: Username::from_trusted(r.username),
+                email: Email::from_trusted(r.email), password_hash: PasswordHash(r.password_hash),
+                display_name: r.display_name, bio: r.bio, avatar_url: r.avatar_url,
+                header_url: r.header_url, custom_css: r.custom_css, local: r.local,
+                ap_id: r.ap_id, inbox_url: r.inbox_url, public_key: r.public_key,
+                private_key: r.private_key, created_at: r.created_at, updated_at: r.updated_at,
+            };
+            (tf, u)
+        }).collect())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use domain::{models::user::User, value_objects::*};
+    use crate::user::PgUserRepository;
+    use domain::ports::UserRepository;
+
+    async fn seed_user(pool: &sqlx::PgPool, username: &str, email: &str) -> User {
+        let repo = PgUserRepository::new(pool.clone());
+        let u = User::new_local(UserId::new(), Username::new(username).unwrap(), Email::new(email).unwrap(), PasswordHash("h".into()));
+        repo.save(&u).await.unwrap(); u
+    }
+
+    #[sqlx::test(migrations = "./migrations")]
+    async fn set_and_list_top_friends(pool: sqlx::PgPool) {
+        let alice = seed_user(&pool, "alice", "alice@ex.com").await;
+        let bob   = seed_user(&pool, "bob",   "bob@ex.com").await;
+        let repo = PgTopFriendRepository::new(pool);
+        repo.set_top_friends(&alice.id, vec![(bob.id.clone(), 1)]).await.unwrap();
+        let friends = repo.list_for_user(&alice.id).await.unwrap();
+        assert_eq!(friends.len(), 1);
+        assert_eq!(friends[0].0.position, 1);
+        assert_eq!(friends[0].1.username.as_str(), "bob");
+    }
+
+    #[sqlx::test(migrations = "./migrations")]
+    async fn replace_top_friends(pool: sqlx::PgPool) {
+        let alice = seed_user(&pool, "alice", "alice@ex.com").await;
+        let bob   = seed_user(&pool, "bob",   "bob@ex.com").await;
+        let carol = seed_user(&pool, "carol", "carol@ex.com").await;
+        let repo = PgTopFriendRepository::new(pool);
+        repo.set_top_friends(&alice.id, vec![(bob.id.clone(), 1)]).await.unwrap();
+        repo.set_top_friends(&alice.id, vec![(carol.id.clone(), 1)]).await.unwrap();
+        let friends = repo.list_for_user(&alice.id).await.unwrap();
+        assert_eq!(friends.len(), 1);
+        assert_eq!(friends[0].1.username.as_str(), "carol");
+    }
+}

crates/adapters/postgres/src/user.rs

@@ -0,0 +1,237 @@
+use async_trait::async_trait;
+use chrono::{DateTime, Utc};
+use sqlx::PgPool;
+use domain::{
+    errors::DomainError,
+    models::{feed::UserSummary, user::User},
+    ports::UserRepository,
+    value_objects::{Email, PasswordHash, UserId, Username},
+};
+
+pub struct PgUserRepository { pool: PgPool }
+impl PgUserRepository { pub fn new(pool: PgPool) -> Self { Self { pool } } }
+
+#[derive(sqlx::FromRow)]
+pub(crate) struct UserRow {
+    pub id: uuid::Uuid,
+    pub username: String,
+    pub email: String,
+    pub password_hash: String,
+    pub display_name: Option<String>,
+    pub bio: Option<String>,
+    pub avatar_url: Option<String>,
+    pub header_url: Option<String>,
+    pub custom_css: Option<String>,
+    pub local: bool,
+    pub ap_id: Option<String>,
+    pub inbox_url: Option<String>,
+    pub public_key: Option<String>,
+    pub private_key: Option<String>,
+    pub created_at: DateTime<Utc>,
+    pub updated_at: DateTime<Utc>,
+}
+
+impl From<UserRow> for User {
+    fn from(r: UserRow) -> Self {
+        User {
+            id: UserId::from_uuid(r.id),
+            username: Username::from_trusted(r.username),
+            email: Email::from_trusted(r.email),
+            password_hash: PasswordHash(r.password_hash),
+            display_name: r.display_name,
+            bio: r.bio,
+            avatar_url: r.avatar_url,
+            header_url: r.header_url,
+            custom_css: r.custom_css,
+            local: r.local,
+            ap_id: r.ap_id,
+            inbox_url: r.inbox_url,
+            public_key: r.public_key,
+            private_key: r.private_key,
+            created_at: r.created_at,
+            updated_at: r.updated_at,
+        }
+    }
+}
+
+const USER_SELECT: &str = "SELECT id,username,email,password_hash,display_name,bio,avatar_url,header_url,custom_css,local,ap_id,inbox_url,public_key,private_key,created_at,updated_at FROM users";
+
+#[async_trait]
+impl UserRepository for PgUserRepository {
+    async fn find_by_id(&self, id: &UserId) -> Result<Option<User>, DomainError> {
+        sqlx::query_as::<_, UserRow>(&format!("{USER_SELECT} WHERE id=$1"))
+            .bind(id.as_uuid())
+            .fetch_optional(&self.pool)
+            .await
+            .map_err(|e| DomainError::Internal(e.to_string()))
+            .map(|o| o.map(User::from))
+    }
+
+    async fn find_by_username(&self, username: &Username) -> Result<Option<User>, DomainError> {
+        sqlx::query_as::<_, UserRow>(&format!("{USER_SELECT} WHERE username=$1"))
+            .bind(username.as_str())
+            .fetch_optional(&self.pool)
+            .await
+            .map_err(|e| DomainError::Internal(e.to_string()))
+            .map(|o| o.map(User::from))
+    }
+
+    async fn find_by_email(&self, email: &Email) -> Result<Option<User>, DomainError> {
+        sqlx::query_as::<_, UserRow>(&format!("{USER_SELECT} WHERE email=$1"))
+            .bind(email.as_str())
+            .fetch_optional(&self.pool)
+            .await
+            .map_err(|e| DomainError::Internal(e.to_string()))
+            .map(|o| o.map(User::from))
+    }
+
+    async fn save(&self, user: &User) -> Result<(), DomainError> {
+        sqlx::query(
+            "INSERT INTO users (id,username,email,password_hash,display_name,bio,avatar_url,header_url,custom_css,local,ap_id,inbox_url,public_key,private_key,created_at,updated_at)
+             VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16)
+             ON CONFLICT(id) DO UPDATE SET
+               username=EXCLUDED.username, email=EXCLUDED.email,
+               password_hash=EXCLUDED.password_hash, display_name=EXCLUDED.display_name,
+               bio=EXCLUDED.bio, avatar_url=EXCLUDED.avatar_url,
+               header_url=EXCLUDED.header_url, custom_css=EXCLUDED.custom_css,
+               local=EXCLUDED.local, ap_id=EXCLUDED.ap_id, inbox_url=EXCLUDED.inbox_url,
+               public_key=EXCLUDED.public_key, private_key=EXCLUDED.private_key,
+               updated_at=NOW()"
+        )
+        .bind(user.id.as_uuid())
+        .bind(user.username.as_str())
+        .bind(user.email.as_str())
+        .bind(&user.password_hash.0)
+        .bind(&user.display_name)
+        .bind(&user.bio)
+        .bind(&user.avatar_url)
+        .bind(&user.header_url)
+        .bind(&user.custom_css)
+        .bind(user.local)
+        .bind(&user.ap_id)
+        .bind(&user.inbox_url)
+        .bind(&user.public_key)
+        .bind(&user.private_key)
+        .bind(user.created_at)
+        .bind(user.updated_at)
+        .execute(&self.pool)
+        .await
+        .map_err(|e| DomainError::Internal(e.to_string()))
+        .map(|_| ())
+    }
+
+    async fn update_profile(&self, user_id: &UserId, display_name: Option<String>, bio: Option<String>, avatar_url: Option<String>, header_url: Option<String>, custom_css: Option<String>) -> Result<(), DomainError> {
+        sqlx::query(
+            "UPDATE users SET display_name=$2,bio=$3,avatar_url=$4,header_url=$5,custom_css=$6,updated_at=NOW() WHERE id=$1"
+        )
+        .bind(user_id.as_uuid())
+        .bind(display_name)
+        .bind(bio)
+        .bind(avatar_url)
+        .bind(header_url)
+        .bind(custom_css)
+        .execute(&self.pool)
+        .await
+        .map_err(|e| DomainError::Internal(e.to_string()))
+        .map(|_| ())
+    }
+
+    async fn list_with_stats(&self) -> Result<Vec<UserSummary>, DomainError> {
+        #[derive(sqlx::FromRow)]
+        struct Row {
+            id: uuid::Uuid,
+            username: String,
+            display_name: Option<String>,
+            avatar_url: Option<String>,
+            bio: Option<String>,
+            thought_count: i64,
+            follower_count: i64,
+            following_count: i64,
+        }
+        let rows = sqlx::query_as::<_, Row>(
+            "SELECT u.id, u.username, u.display_name, u.avatar_url, u.bio,
+             COUNT(DISTINCT t.id) AS thought_count,
+             COUNT(DISTINCT f1.follower_id) AS follower_count,
+             COUNT(DISTINCT f2.following_id) AS following_count
+             FROM users u
+             LEFT JOIN thoughts t ON t.user_id=u.id AND t.local=true
+             LEFT JOIN follows f1 ON f1.following_id=u.id AND f1.state='accepted'
+             LEFT JOIN follows f2 ON f2.follower_id=u.id AND f2.state='accepted'
+             WHERE u.local=true
+             GROUP BY u.id
+             ORDER BY u.username"
+        )
+        .fetch_all(&self.pool)
+        .await
+        .map_err(|e| DomainError::Internal(e.to_string()))?;
+
+        Ok(rows.into_iter().map(|r| UserSummary {
+            id: UserId::from_uuid(r.id),
+            username: r.username,
+            display_name: r.display_name,
+            avatar_url: r.avatar_url,
+            bio: r.bio,
+            thought_count: r.thought_count,
+            follower_count: r.follower_count,
+            following_count: r.following_count,
+        }).collect())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use domain::{models::user::User, value_objects::*};
+
+    #[sqlx::test(migrations = "./migrations")]
+    async fn save_and_find_by_id(pool: sqlx::PgPool) {
+        let repo = PgUserRepository::new(pool);
+        let user = User::new_local(
+            UserId::new(),
+            Username::new("alice").unwrap(),
+            Email::new("alice@ex.com").unwrap(),
+            PasswordHash("hash".into()),
+        );
+        repo.save(&user).await.unwrap();
+        let found = repo.find_by_id(&user.id).await.unwrap().unwrap();
+        assert_eq!(found.username.as_str(), "alice");
+        assert_eq!(found.email.as_str(), "alice@ex.com");
+    }
+
+    #[sqlx::test(migrations = "./migrations")]
+    async fn find_by_username_returns_none_when_missing(pool: sqlx::PgPool) {
+        let repo = PgUserRepository::new(pool);
+        let result = repo.find_by_username(&Username::new("ghost").unwrap()).await.unwrap();
+        assert!(result.is_none());
+    }
+
+    #[sqlx::test(migrations = "./migrations")]
+    async fn find_by_email(pool: sqlx::PgPool) {
+        let repo = PgUserRepository::new(pool);
+        let user = User::new_local(
+            UserId::new(),
+            Username::new("bob").unwrap(),
+            Email::new("bob@ex.com").unwrap(),
+            PasswordHash("hash".into()),
+        );
+        repo.save(&user).await.unwrap();
+        let found = repo.find_by_email(&Email::new("bob@ex.com").unwrap()).await.unwrap();
+        assert!(found.is_some());
+    }
+
+    #[sqlx::test(migrations = "./migrations")]
+    async fn update_profile_changes_fields(pool: sqlx::PgPool) {
+        let repo = PgUserRepository::new(pool);
+        let user = User::new_local(
+            UserId::new(),
+            Username::new("charlie").unwrap(),
+            Email::new("charlie@ex.com").unwrap(),
+            PasswordHash("hash".into()),
+        );
+        repo.save(&user).await.unwrap();
+        repo.update_profile(&user.id, Some("Charlie".into()), Some("bio".into()), None, None, None).await.unwrap();
+        let found = repo.find_by_id(&user.id).await.unwrap().unwrap();
+        assert_eq!(found.display_name.as_deref(), Some("Charlie"));
+        assert_eq!(found.bio.as_deref(), Some("bio"));
+    }
+}

crates/api-types/Cargo.toml

@@ -0,0 +1,9 @@
+[package]
+name = "api-types"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+serde  = { workspace = true }
+uuid   = { workspace = true }
+chrono = { workspace = true }

crates/api-types/src/lib.rs

@@ -0,0 +1,2 @@
+pub mod requests;
+pub mod responses;

crates/api-types/src/requests.rs

@@ -0,0 +1,71 @@
+use serde::Deserialize;
+use uuid::Uuid;
+
+#[derive(Deserialize)]
+pub struct RegisterRequest {
+    pub username: String,
+    pub email: String,
+    pub password: String,
+}
+
+#[derive(Deserialize)]
+pub struct LoginRequest {
+    pub email: String,
+    pub password: String,
+}
+
+#[derive(Deserialize)]
+pub struct CreateThoughtRequest {
+    pub content: String,
+    pub in_reply_to_id: Option<Uuid>,
+    pub visibility: Option<String>,
+    pub content_warning: Option<String>,
+    pub sensitive: Option<bool>,
+}
+
+#[derive(Deserialize)]
+pub struct EditThoughtRequest {
+    pub content: String,
+}
+
+#[derive(Deserialize)]
+pub struct UpdateProfileRequest {
+    pub display_name: Option<String>,
+    pub bio: Option<String>,
+    pub avatar_url: Option<String>,
+    pub header_url: Option<String>,
+    pub custom_css: Option<String>,
+}
+
+#[derive(Deserialize)]
+pub struct SetTopFriendsRequest {
+    pub friend_ids: Vec<Uuid>,
+}
+
+#[derive(Deserialize)]
+pub struct CreateApiKeyRequest {
+    pub name: String,
+}
+
+#[derive(Deserialize)]
+pub struct PaginationQuery {
+    pub page: Option<u64>,
+    pub per_page: Option<u64>,
+}
+
+impl PaginationQuery {
+    pub fn page(&self) -> u64 {
+        self.page.unwrap_or(1).max(1)
+    }
+
+    pub fn per_page(&self) -> u64 {
+        self.per_page.unwrap_or(20).min(100)
+    }
+}
+
+#[derive(Deserialize)]
+pub struct SearchQuery {
+    pub q: String,
+    pub page: Option<u64>,
+    pub per_page: Option<u64>,
+}

crates/api-types/src/responses.rs

@@ -0,0 +1,69 @@
+use chrono::{DateTime, Utc};
+use serde::Serialize;
+use uuid::Uuid;
+
+#[derive(Serialize)]
+pub struct AuthResponse {
+    pub token: String,
+    pub user: UserResponse,
+}
+
+#[derive(Serialize, Clone)]
+pub struct UserResponse {
+    pub id: Uuid,
+    pub username: String,
+    pub display_name: Option<String>,
+    pub bio: Option<String>,
+    pub avatar_url: Option<String>,
+    pub header_url: Option<String>,
+    pub local: bool,
+    pub created_at: DateTime<Utc>,
+}
+
+#[derive(Serialize, Clone)]
+pub struct ThoughtResponse {
+    pub id: Uuid,
+    pub content: String,
+    pub author: UserResponse,
+    pub in_reply_to_id: Option<Uuid>,
+    pub visibility: String,
+    pub content_warning: Option<String>,
+    pub sensitive: bool,
+    pub like_count: i64,
+    pub boost_count: i64,
+    pub reply_count: i64,
+    pub liked_by_viewer: bool,
+    pub boosted_by_viewer: bool,
+    pub created_at: DateTime<Utc>,
+    pub updated_at: Option<DateTime<Utc>>,
+}
+
+#[derive(Serialize)]
+pub struct PagedResponse<T: Serialize> {
+    pub items: Vec<T>,
+    pub total: i64,
+    pub page: u64,
+    pub per_page: u64,
+}
+
+#[derive(Serialize)]
+pub struct ApiKeyResponse {
+    pub id: Uuid,
+    pub name: String,
+    pub created_at: DateTime<Utc>,
+}
+
+#[derive(Serialize)]
+pub struct NotificationResponse {
+    pub id: Uuid,
+    pub notification_type: String,
+    pub from_user: Option<UserResponse>,
+    pub thought_id: Option<Uuid>,
+    pub read: bool,
+    pub created_at: DateTime<Utc>,
+}
+
+#[derive(Serialize)]
+pub struct ErrorResponse {
+    pub error: String,
+}

crates/application/Cargo.toml

@@ -0,0 +1,17 @@
+[package]
+name = "application"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+domain      = { workspace = true }
+async-trait = { workspace = true }
+thiserror   = { workspace = true }
+uuid        = { workspace = true }
+chrono      = { workspace = true }
+sha2        = "0.10"
+hex         = "0.4"
+
+[dev-dependencies]
+tokio  = { workspace = true, features = ["full"] }
+domain = { workspace = true, features = ["test-helpers"] }

crates/application/src/lib.rs

@@ -0,0 +1 @@
+pub mod use_cases;

crates/application/src/use_cases/api_keys.rs

@@ -0,0 +1,29 @@
+use chrono::Utc;
+use domain::{
+    errors::DomainError,
+    models::api_key::ApiKey,
+    ports::ApiKeyRepository,
+    value_objects::{ApiKeyId, UserId},
+};
+
+pub async fn list_api_keys(keys: &dyn ApiKeyRepository, user_id: &UserId) -> Result<Vec<ApiKey>, DomainError> {
+    keys.list_for_user(user_id).await
+}
+
+pub async fn create_api_key(keys: &dyn ApiKeyRepository, user_id: &UserId, name: String) -> Result<(ApiKey, String), DomainError> {
+    let raw_key = uuid::Uuid::new_v4().to_string().replace('-', "");
+    let key_hash = sha256_hex(&raw_key);
+    let key = ApiKey { id: ApiKeyId::new(), user_id: user_id.clone(), key_hash, name, created_at: Utc::now() };
+    keys.save(&key).await?;
+    Ok((key, raw_key))
+}
+
+pub async fn delete_api_key(keys: &dyn ApiKeyRepository, user_id: &UserId, key_id: &ApiKeyId) -> Result<(), DomainError> {
+    keys.delete(key_id, user_id).await
+}
+
+fn sha256_hex(s: &str) -> String {
+    use sha2::{Digest, Sha256};
+    let hash = Sha256::digest(s.as_bytes());
+    hex::encode(hash)
+}

crates/application/src/use_cases/auth.rs

@@ -0,0 +1,115 @@
+use domain::{
+    errors::DomainError,
+    models::user::User,
+    ports::{AuthService, EventPublisher, PasswordHasher, UserRepository},
+    value_objects::{Email, UserId, Username},
+};
+
+pub struct RegisterInput { pub username: String, pub email: String, pub password: String }
+#[derive(Debug)]
+pub struct RegisterOutput { pub user: User, pub token: String }
+
+pub async fn register(
+    users: &dyn UserRepository,
+    hasher: &dyn PasswordHasher,
+    auth: &dyn AuthService,
+    _events: &dyn EventPublisher,
+    input: RegisterInput,
+) -> Result<RegisterOutput, DomainError> {
+    let username = Username::new(input.username)?;
+    let email = Email::new(input.email)?;
+    if users.find_by_username(&username).await?.is_some() {
+        return Err(DomainError::Conflict("username taken".into()));
+    }
+    if users.find_by_email(&email).await?.is_some() {
+        return Err(DomainError::Conflict("email taken".into()));
+    }
+    let hash = hasher.hash(&input.password).await?;
+    let user = User::new_local(UserId::new(), username, email, hash);
+    users.save(&user).await?;
+    let token = auth.generate_token(&user.id)?;
+    Ok(RegisterOutput { user, token: token.token })
+}
+
+pub struct LoginInput { pub email: String, pub password: String }
+#[derive(Debug)]
+pub struct LoginOutput { pub user: User, pub token: String }
+
+pub async fn login(
+    users: &dyn UserRepository,
+    hasher: &dyn PasswordHasher,
+    auth: &dyn AuthService,
+    input: LoginInput,
+) -> Result<LoginOutput, DomainError> {
+    let email = Email::new(input.email)?;
+    let user = users.find_by_email(&email).await?.ok_or(DomainError::Unauthorized)?;
+    if !hasher.verify(&input.password, &user.password_hash).await? {
+        return Err(DomainError::Unauthorized);
+    }
+    let token = auth.generate_token(&user.id)?;
+    Ok(LoginOutput { user, token: token.token })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use async_trait::async_trait;
+    use domain::{
+        errors::DomainError,
+        ports::{AuthService, GeneratedToken, PasswordHasher},
+        testing::{NoOpEventPublisher, TestStore},
+        value_objects::{PasswordHash, UserId},
+    };
+
+    struct FakeHasher;
+    #[async_trait] impl PasswordHasher for FakeHasher {
+        async fn hash(&self, plain: &str) -> Result<PasswordHash, DomainError> { Ok(PasswordHash(plain.to_string())) }
+        async fn verify(&self, plain: &str, hash: &PasswordHash) -> Result<bool, DomainError> { Ok(plain == hash.0) }
+    }
+
+    struct FakeAuth;
+    impl AuthService for FakeAuth {
+        fn generate_token(&self, uid: &UserId) -> Result<GeneratedToken, DomainError> {
+            Ok(GeneratedToken { token: uid.to_string(), user_id: uid.clone() })
+        }
+        fn validate_token(&self, token: &str) -> Result<UserId, DomainError> {
+            Ok(UserId::from_uuid(uuid::Uuid::parse_str(token).map_err(|_| DomainError::Unauthorized)?))
+        }
+    }
+
+    fn input() -> RegisterInput {
+        RegisterInput { username: "alice".into(), email: "alice@ex.com".into(), password: "pw".into() }
+    }
+
+    #[tokio::test]
+    async fn register_creates_user() {
+        let store = TestStore::default();
+        let out = register(&store, &FakeHasher, &FakeAuth, &NoOpEventPublisher, input()).await.unwrap();
+        assert_eq!(out.user.username.as_str(), "alice");
+        assert!(!out.token.is_empty());
+    }
+
+    #[tokio::test]
+    async fn register_rejects_duplicate_username() {
+        let store = TestStore::default();
+        register(&store, &FakeHasher, &FakeAuth, &NoOpEventPublisher, input()).await.unwrap();
+        let err = register(&store, &FakeHasher, &FakeAuth, &NoOpEventPublisher, input()).await.unwrap_err();
+        assert!(matches!(err, DomainError::Conflict(_)));
+    }
+
+    #[tokio::test]
+    async fn login_succeeds_with_correct_password() {
+        let store = TestStore::default();
+        register(&store, &FakeHasher, &FakeAuth, &NoOpEventPublisher, input()).await.unwrap();
+        let out = login(&store, &FakeHasher, &FakeAuth, LoginInput { email: "alice@ex.com".into(), password: "pw".into() }).await.unwrap();
+        assert!(!out.token.is_empty());
+    }
+
+    #[tokio::test]
+    async fn login_fails_wrong_password() {
+        let store = TestStore::default();
+        register(&store, &FakeHasher, &FakeAuth, &NoOpEventPublisher, input()).await.unwrap();
+        let err = login(&store, &FakeHasher, &FakeAuth, LoginInput { email: "alice@ex.com".into(), password: "wrong".into() }).await.unwrap_err();
+        assert!(matches!(err, DomainError::Unauthorized));
+    }
+}

crates/application/src/use_cases/feed.rs

@@ -0,0 +1,43 @@
+use domain::{
+    errors::DomainError,
+    models::{
+        feed::{FeedEntry, PageParams, Paginated, UserSummary},
+        thought::Thought,
+        user::User,
+    },
+    ports::{FeedRepository, FollowRepository, TagRepository, ThoughtRepository, UserRepository},
+    value_objects::UserId,
+};
+
+pub async fn get_home_feed(feed: &dyn FeedRepository, follows: &dyn FollowRepository, user_id: &UserId, page: PageParams) -> Result<Paginated<FeedEntry>, DomainError> {
+    let following_ids = follows.get_accepted_following_ids(user_id).await?;
+    feed.home_feed(&following_ids, &page, Some(user_id)).await
+}
+
+pub async fn get_public_feed(feed: &dyn FeedRepository, viewer_id: Option<&UserId>, page: PageParams) -> Result<Paginated<FeedEntry>, DomainError> {
+    feed.public_feed(&page, viewer_id).await
+}
+
+pub async fn get_user_feed(thoughts: &dyn ThoughtRepository, user_id: &UserId, page: PageParams) -> Result<Paginated<FeedEntry>, DomainError> {
+    thoughts.list_by_user(user_id, &page).await
+}
+
+pub async fn get_followers(follows: &dyn FollowRepository, user_id: &UserId, page: PageParams) -> Result<Paginated<User>, DomainError> {
+    follows.list_followers(user_id, &page).await
+}
+
+pub async fn get_following(follows: &dyn FollowRepository, user_id: &UserId, page: PageParams) -> Result<Paginated<User>, DomainError> {
+    follows.list_following(user_id, &page).await
+}
+
+pub async fn get_by_tag(tags: &dyn TagRepository, tag_name: &str, page: PageParams) -> Result<Paginated<Thought>, DomainError> {
+    tags.list_thoughts_by_tag(tag_name, &page).await
+}
+
+pub async fn search(feed: &dyn FeedRepository, query: &str, page: PageParams, viewer_id: Option<&UserId>) -> Result<Paginated<FeedEntry>, DomainError> {
+    feed.search(query, &page, viewer_id).await
+}
+
+pub async fn list_users(users: &dyn UserRepository) -> Result<Vec<UserSummary>, DomainError> {
+    users.list_with_stats().await
+}

crates/application/src/use_cases/mod.rs

@@ -0,0 +1,6 @@
+pub mod api_keys;
+pub mod auth;
+pub mod feed;
+pub mod profile;
+pub mod social;
+pub mod thoughts;

crates/application/src/use_cases/profile.rs

@@ -0,0 +1,37 @@
+use domain::{
+    errors::DomainError,
+    models::{top_friend::TopFriend, user::User},
+    ports::{TopFriendRepository, UserRepository},
+    value_objects::{UserId, Username},
+};
+
+pub async fn get_user(users: &dyn UserRepository, user_id: &UserId) -> Result<User, DomainError> {
+    users.find_by_id(user_id).await?.ok_or(DomainError::NotFound)
+}
+
+pub async fn get_user_by_username(users: &dyn UserRepository, username: &str) -> Result<User, DomainError> {
+    let username = Username::from_trusted(username.to_string());
+    users.find_by_username(&username).await?.ok_or(DomainError::NotFound)
+}
+
+pub async fn update_profile(
+    users: &dyn UserRepository,
+    user_id: &UserId,
+    display_name: Option<String>,
+    bio: Option<String>,
+    avatar_url: Option<String>,
+    header_url: Option<String>,
+    custom_css: Option<String>,
+) -> Result<(), DomainError> {
+    users.update_profile(user_id, display_name, bio, avatar_url, header_url, custom_css).await
+}
+
+pub async fn get_top_friends(top_friends: &dyn TopFriendRepository, user_id: &UserId) -> Result<Vec<(TopFriend, User)>, DomainError> {
+    top_friends.list_for_user(user_id).await
+}
+
+pub async fn set_top_friends(top_friends: &dyn TopFriendRepository, user_id: &UserId, friend_ids: Vec<UserId>) -> Result<(), DomainError> {
+    if friend_ids.len() > 8 { return Err(DomainError::InvalidInput("top friends: max 8".into())); }
+    let friends: Vec<(UserId, i16)> = friend_ids.into_iter().enumerate().map(|(i, id)| (id, (i + 1) as i16)).collect();
+    top_friends.set_top_friends(user_id, friends).await
+}

crates/application/src/use_cases/social.rs

@@ -0,0 +1,117 @@
+use chrono::Utc;
+use domain::{
+    errors::DomainError,
+    events::DomainEvent,
+    models::social::{Block, Boost, Follow, FollowState, Like},
+    ports::{BlockRepository, BoostRepository, EventPublisher, FollowRepository, LikeRepository},
+    value_objects::{BoostId, LikeId, ThoughtId, UserId},
+};
+
+pub async fn like_thought(likes: &dyn LikeRepository, events: &dyn EventPublisher, user_id: &UserId, thought_id: &ThoughtId) -> Result<(), DomainError> {
+    let like = Like { id: LikeId::new(), user_id: user_id.clone(), thought_id: thought_id.clone(), ap_id: None, created_at: Utc::now() };
+    likes.save(&like).await?;
+    events.publish(&DomainEvent::LikeAdded { like_id: like.id, user_id: user_id.clone(), thought_id: thought_id.clone() }).await?;
+    Ok(())
+}
+
+pub async fn unlike_thought(likes: &dyn LikeRepository, events: &dyn EventPublisher, user_id: &UserId, thought_id: &ThoughtId) -> Result<(), DomainError> {
+    likes.delete(user_id, thought_id).await?;
+    events.publish(&DomainEvent::LikeRemoved { user_id: user_id.clone(), thought_id: thought_id.clone() }).await?;
+    Ok(())
+}
+
+pub async fn boost_thought(boosts: &dyn BoostRepository, events: &dyn EventPublisher, user_id: &UserId, thought_id: &ThoughtId) -> Result<(), DomainError> {
+    let boost = Boost { id: BoostId::new(), user_id: user_id.clone(), thought_id: thought_id.clone(), ap_id: None, created_at: Utc::now() };
+    boosts.save(&boost).await?;
+    events.publish(&DomainEvent::BoostAdded { boost_id: boost.id, user_id: user_id.clone(), thought_id: thought_id.clone() }).await?;
+    Ok(())
+}
+
+pub async fn unboost_thought(boosts: &dyn BoostRepository, events: &dyn EventPublisher, user_id: &UserId, thought_id: &ThoughtId) -> Result<(), DomainError> {
+    boosts.delete(user_id, thought_id).await?;
+    events.publish(&DomainEvent::BoostRemoved { user_id: user_id.clone(), thought_id: thought_id.clone() }).await?;
+    Ok(())
+}
+
+pub async fn follow_user(follows: &dyn FollowRepository, events: &dyn EventPublisher, follower_id: &UserId, following_id: &UserId) -> Result<(), DomainError> {
+    if follower_id == following_id { return Err(DomainError::InvalidInput("cannot follow yourself".into())); }
+    let follow = Follow { follower_id: follower_id.clone(), following_id: following_id.clone(), state: FollowState::Accepted, ap_id: None, created_at: Utc::now() };
+    follows.save(&follow).await?;
+    events.publish(&DomainEvent::FollowAccepted { follower_id: follower_id.clone(), following_id: following_id.clone() }).await?;
+    Ok(())
+}
+
+pub async fn unfollow_user(follows: &dyn FollowRepository, events: &dyn EventPublisher, follower_id: &UserId, following_id: &UserId) -> Result<(), DomainError> {
+    follows.delete(follower_id, following_id).await?;
+    events.publish(&DomainEvent::Unfollowed { follower_id: follower_id.clone(), following_id: following_id.clone() }).await?;
+    Ok(())
+}
+
+pub async fn accept_follow(follows: &dyn FollowRepository, events: &dyn EventPublisher, follower_id: &UserId, following_id: &UserId) -> Result<(), DomainError> {
+    follows.update_state(follower_id, following_id, &FollowState::Accepted).await?;
+    events.publish(&DomainEvent::FollowAccepted { follower_id: follower_id.clone(), following_id: following_id.clone() }).await?;
+    Ok(())
+}
+
+pub async fn reject_follow(follows: &dyn FollowRepository, events: &dyn EventPublisher, follower_id: &UserId, following_id: &UserId) -> Result<(), DomainError> {
+    follows.update_state(follower_id, following_id, &FollowState::Rejected).await?;
+    events.publish(&DomainEvent::FollowRejected { follower_id: follower_id.clone(), following_id: following_id.clone() }).await?;
+    Ok(())
+}
+
+pub async fn block_user(blocks: &dyn BlockRepository, events: &dyn EventPublisher, blocker_id: &UserId, blocked_id: &UserId) -> Result<(), DomainError> {
+    if blocker_id == blocked_id { return Err(DomainError::InvalidInput("cannot block yourself".into())); }
+    let block = Block { blocker_id: blocker_id.clone(), blocked_id: blocked_id.clone(), created_at: Utc::now() };
+    blocks.save(&block).await?;
+    events.publish(&DomainEvent::UserBlocked { blocker_id: blocker_id.clone(), blocked_id: blocked_id.clone() }).await?;
+    Ok(())
+}
+
+pub async fn unblock_user(blocks: &dyn BlockRepository, blocker_id: &UserId, blocked_id: &UserId) -> Result<(), DomainError> {
+    blocks.delete(blocker_id, blocked_id).await?;
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use domain::{
+        models::{thought::{Thought, Visibility}, user::User},
+        testing::TestStore,
+        value_objects::*,
+    };
+
+    fn user(name: &str) -> User {
+        User::new_local(UserId::new(), Username::new(name).unwrap(), Email::new(format!("{name}@ex.com")).unwrap(), PasswordHash("h".into()))
+    }
+
+    #[tokio::test]
+    async fn like_and_unlike() {
+        let store = TestStore::default();
+        let alice = user("alice");
+        let tid = ThoughtId::new();
+        store.thoughts.lock().unwrap().push(Thought::new_local(tid.clone(), alice.id.clone(), Content::new_local("hi").unwrap(), None, Visibility::Public, None, false));
+        like_thought(&store, &store, &alice.id, &tid).await.unwrap();
+        assert_eq!(store.likes.lock().unwrap().len(), 1);
+        unlike_thought(&store, &store, &alice.id, &tid).await.unwrap();
+        assert!(store.likes.lock().unwrap().is_empty());
+    }
+
+    #[tokio::test]
+    async fn follow_and_unfollow() {
+        let store = TestStore::default();
+        let alice = user("alice"); let bob = user("bob");
+        follow_user(&store, &store, &alice.id, &bob.id).await.unwrap();
+        assert_eq!(store.follows.lock().unwrap().len(), 1);
+        unfollow_user(&store, &store, &alice.id, &bob.id).await.unwrap();
+        assert!(store.follows.lock().unwrap().is_empty());
+    }
+
+    #[tokio::test]
+    async fn cannot_follow_self() {
+        let store = TestStore::default();
+        let alice = user("alice");
+        let err = follow_user(&store, &store, &alice.id, &alice.id).await.unwrap_err();
+        assert!(matches!(err, DomainError::InvalidInput(_)));
+    }
+}

crates/application/src/use_cases/thoughts.rs

@@ -0,0 +1,122 @@
+use domain::{
+    errors::DomainError,
+    events::DomainEvent,
+    models::thought::{Thought, Visibility},
+    ports::{EventPublisher, ThoughtRepository, UserRepository},
+    value_objects::{Content, ThoughtId, UserId},
+};
+
+pub struct CreateThoughtInput {
+    pub user_id: UserId,
+    pub content: String,
+    pub in_reply_to_id: Option<ThoughtId>,
+    pub visibility: Option<String>,
+    pub content_warning: Option<String>,
+    pub sensitive: bool,
+}
+pub struct CreateThoughtOutput { pub thought: Thought }
+
+pub async fn create_thought(
+    thoughts: &dyn ThoughtRepository,
+    _users: &dyn UserRepository,
+    events: &dyn EventPublisher,
+    input: CreateThoughtInput,
+) -> Result<CreateThoughtOutput, DomainError> {
+    let content = Content::new_local(input.content)?;
+    let visibility = input.visibility.as_deref().map(Visibility::from_str).unwrap_or(Visibility::Public);
+    let thought = Thought::new_local(
+        ThoughtId::new(), input.user_id,
+        content, input.in_reply_to_id.clone(),
+        visibility, input.content_warning, input.sensitive,
+    );
+    thoughts.save(&thought).await?;
+    events.publish(&DomainEvent::ThoughtCreated {
+        thought_id: thought.id.clone(),
+        user_id: thought.user_id.clone(),
+        in_reply_to_id: input.in_reply_to_id,
+    }).await?;
+    Ok(CreateThoughtOutput { thought })
+}
+
+pub async fn delete_thought(
+    thoughts: &dyn ThoughtRepository,
+    events: &dyn EventPublisher,
+    id: &ThoughtId,
+    user_id: &UserId,
+) -> Result<(), DomainError> {
+    let thought = thoughts.find_by_id(id).await?.ok_or(DomainError::NotFound)?;
+    if thought.user_id != *user_id { return Err(DomainError::NotFound); }
+    thoughts.delete(id, user_id).await?;
+    events.publish(&DomainEvent::ThoughtDeleted { thought_id: id.clone(), user_id: user_id.clone() }).await?;
+    Ok(())
+}
+
+pub async fn edit_thought(
+    thoughts: &dyn ThoughtRepository,
+    events: &dyn EventPublisher,
+    id: &ThoughtId,
+    user_id: &UserId,
+    new_content: String,
+) -> Result<(), DomainError> {
+    let thought = thoughts.find_by_id(id).await?.ok_or(DomainError::NotFound)?;
+    if thought.user_id != *user_id { return Err(DomainError::NotFound); }
+    let content = Content::new_local(new_content)?;
+    thoughts.update_content(id, &content).await?;
+    events.publish(&DomainEvent::ThoughtUpdated { thought_id: id.clone(), user_id: user_id.clone() }).await?;
+    Ok(())
+}
+
+pub async fn get_thought(thoughts: &dyn ThoughtRepository, id: &ThoughtId) -> Result<Thought, DomainError> {
+    thoughts.find_by_id(id).await?.ok_or(DomainError::NotFound)
+}
+
+pub async fn get_thread(thoughts: &dyn ThoughtRepository, id: &ThoughtId) -> Result<Vec<Thought>, DomainError> {
+    thoughts.get_thread(id).await
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use domain::{
+        models::user::User,
+        testing::{NoOpEventPublisher, TestStore},
+        value_objects::*,
+    };
+
+    fn user() -> User {
+        User::new_local(UserId::new(), Username::new("alice").unwrap(), Email::new("alice@ex.com").unwrap(), PasswordHash("h".into()))
+    }
+
+    fn input(uid: UserId) -> CreateThoughtInput {
+        CreateThoughtInput { user_id: uid, content: "hello".into(), in_reply_to_id: None, visibility: None, content_warning: None, sensitive: false }
+    }
+
+    #[tokio::test]
+    async fn create_thought_saves_and_emits_event() {
+        let store = TestStore::default();
+        let u = user(); store.users.lock().unwrap().push(u.clone());
+        let out = create_thought(&store, &store, &store, input(u.id.clone())).await.unwrap();
+        assert_eq!(out.thought.content.as_str(), "hello");
+        assert_eq!(store.events.lock().unwrap().len(), 1);
+    }
+
+    #[tokio::test]
+    async fn delete_own_thought_succeeds() {
+        let store = TestStore::default();
+        let u = user(); store.users.lock().unwrap().push(u.clone());
+        let out = create_thought(&store, &store, &NoOpEventPublisher, input(u.id.clone())).await.unwrap();
+        delete_thought(&store, &NoOpEventPublisher, &out.thought.id, &u.id).await.unwrap();
+        assert!(store.thoughts.lock().unwrap().is_empty());
+    }
+
+    #[tokio::test]
+    async fn delete_other_thought_returns_not_found() {
+        let store = TestStore::default();
+        let alice = user();
+        let bob = User::new_local(UserId::new(), Username::new("bob").unwrap(), Email::new("bob@ex.com").unwrap(), PasswordHash("h".into()));
+        store.users.lock().unwrap().extend([alice.clone(), bob.clone()]);
+        let out = create_thought(&store, &store, &NoOpEventPublisher, input(alice.id.clone())).await.unwrap();
+        let err = delete_thought(&store, &NoOpEventPublisher, &out.thought.id, &bob.id).await.unwrap_err();
+        assert!(matches!(err, DomainError::NotFound));
+    }
+}

crates/domain/Cargo.toml

@@ -0,0 +1,19 @@
+[package]
+name = "domain"
+version = "0.1.0"
+edition = "2021"
+
+[features]
+test-helpers = []
+
+[dependencies]
+async-trait = { workspace = true }
+thiserror   = { workspace = true }
+uuid        = { workspace = true }
+chrono      = { workspace = true }
+serde       = { workspace = true }
+futures     = { workspace = true }
+url         = { workspace = true }
+
+[dev-dependencies]
+tokio = { workspace = true, features = ["full"] }

crates/domain/src/errors.rs

@@ -0,0 +1,17 @@
+use thiserror::Error;
+
+#[derive(Debug, Error, Clone)]
+pub enum DomainError {
+    #[error("not found")]
+    NotFound,
+    #[error("unauthorized")]
+    Unauthorized,
+    #[error("forbidden")]
+    Forbidden,
+    #[error("conflict: {0}")]
+    Conflict(String),
+    #[error("invalid input: {0}")]
+    InvalidInput(String),
+    #[error("internal error: {0}")]
+    Internal(String),
+}

crates/domain/src/events.rs

@@ -0,0 +1,28 @@
+use crate::value_objects::{UserId, ThoughtId, LikeId, BoostId};
+
+#[derive(Debug, Clone)]
+pub enum DomainEvent {
+    ThoughtCreated { thought_id: ThoughtId, user_id: UserId, in_reply_to_id: Option<ThoughtId> },
+    ThoughtDeleted { thought_id: ThoughtId, user_id: UserId },
+    ThoughtUpdated { thought_id: ThoughtId, user_id: UserId },
+    LikeAdded    { like_id: LikeId, user_id: UserId, thought_id: ThoughtId },
+    LikeRemoved  { user_id: UserId, thought_id: ThoughtId },
+    BoostAdded   { boost_id: BoostId, user_id: UserId, thought_id: ThoughtId },
+    BoostRemoved { user_id: UserId, thought_id: ThoughtId },
+    FollowRequested { follower_id: UserId, following_id: UserId },
+    FollowAccepted  { follower_id: UserId, following_id: UserId },
+    FollowRejected  { follower_id: UserId, following_id: UserId },
+    Unfollowed   { follower_id: UserId, following_id: UserId },
+    UserBlocked  { blocker_id: UserId, blocked_id: UserId },
+}
+
+pub struct EventEnvelope {
+    pub event: DomainEvent,
+    pub ack:  Box<dyn Fn() + Send + Sync>,
+    pub nack: Box<dyn Fn() + Send + Sync>,
+}
+impl std::fmt::Debug for EventEnvelope {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("EventEnvelope").field("event", &self.event).finish()
+    }
+}

crates/domain/src/lib.rs

@@ -0,0 +1,8 @@
+pub mod errors;
+pub mod events;
+pub mod models;
+pub mod ports;
+pub mod value_objects;
+
+#[cfg(any(test, feature = "test-helpers"))]
+pub mod testing;

crates/domain/src/models/api_key.rs

@@ -0,0 +1,11 @@
+use chrono::{DateTime, Utc};
+use crate::value_objects::{ApiKeyId, UserId};
+
+#[derive(Debug, Clone)]
+pub struct ApiKey {
+    pub id: ApiKeyId,
+    pub user_id: UserId,
+    pub key_hash: String,
+    pub name: String,
+    pub created_at: DateTime<Utc>,
+}

crates/domain/src/models/feed.rs

@@ -0,0 +1,40 @@
+use crate::models::{user::User, thought::Thought};
+use crate::value_objects::UserId;
+
+#[derive(Debug, Clone)]
+pub struct UserSummary {
+    pub id: UserId,
+    pub username: String,
+    pub display_name: Option<String>,
+    pub avatar_url: Option<String>,
+    pub bio: Option<String>,
+    pub thought_count: i64,
+    pub follower_count: i64,
+    pub following_count: i64,
+}
+
+#[derive(Debug, Clone)]
+pub struct FeedEntry {
+    pub thought: Thought,
+    pub author: User,
+    pub like_count: i64,
+    pub boost_count: i64,
+    pub reply_count: i64,
+    pub liked_by_viewer: bool,
+    pub boosted_by_viewer: bool,
+}
+
+#[derive(Debug, Clone)]
+pub struct PageParams { pub page: u64, pub per_page: u64 }
+impl PageParams {
+    pub fn offset(&self) -> i64 { ((self.page.saturating_sub(1)) * self.per_page) as i64 }
+    pub fn limit(&self) -> i64 { self.per_page as i64 }
+}
+
+#[derive(Debug, Clone)]
+pub struct Paginated<T> {
+    pub items: Vec<T>,
+    pub total: i64,
+    pub page: u64,
+    pub per_page: u64,
+}

crates/domain/src/models/mod.rs

@@ -0,0 +1,9 @@
+pub mod api_key;
+pub mod feed;
+pub mod notification;
+pub mod remote_actor;
+pub mod social;
+pub mod tag;
+pub mod thought;
+pub mod top_friend;
+pub mod user;

crates/domain/src/models/notification.rs

@@ -0,0 +1,24 @@
+use chrono::{DateTime, Utc};
+use crate::value_objects::{NotificationId, UserId, ThoughtId};
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum NotificationType { Like, Boost, Follow, Mention, Reply }
+impl NotificationType {
+    pub fn from_str(s: &str) -> Self {
+        match s { "like" => Self::Like, "boost" => Self::Boost, "follow" => Self::Follow, "mention" => Self::Mention, _ => Self::Reply }
+    }
+    pub fn as_str(&self) -> &str {
+        match self { Self::Like => "like", Self::Boost => "boost", Self::Follow => "follow", Self::Mention => "mention", Self::Reply => "reply" }
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct Notification {
+    pub id: NotificationId,
+    pub user_id: UserId,
+    pub notification_type: NotificationType,
+    pub from_user_id: Option<UserId>,
+    pub thought_id: Option<ThoughtId>,
+    pub read: bool,
+    pub created_at: DateTime<Utc>,
+}

crates/domain/src/models/remote_actor.rs

@@ -0,0 +1,12 @@
+use chrono::{DateTime, Utc};
+
+#[derive(Debug, Clone)]
+pub struct RemoteActor {
+    pub url: String,
+    pub handle: String,
+    pub display_name: Option<String>,
+    pub inbox_url: String,
+    pub shared_inbox_url: Option<String>,
+    pub public_key: String,
+    pub last_fetched_at: DateTime<Utc>,
+}

crates/domain/src/models/social.rs

@@ -0,0 +1,47 @@
+use chrono::{DateTime, Utc};
+use crate::value_objects::{UserId, ThoughtId, LikeId, BoostId};
+
+#[derive(Debug, Clone)]
+pub struct Like {
+    pub id: LikeId,
+    pub user_id: UserId,
+    pub thought_id: ThoughtId,
+    pub ap_id: Option<String>,
+    pub created_at: DateTime<Utc>,
+}
+
+#[derive(Debug, Clone)]
+pub struct Boost {
+    pub id: BoostId,
+    pub user_id: UserId,
+    pub thought_id: ThoughtId,
+    pub ap_id: Option<String>,
+    pub created_at: DateTime<Utc>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum FollowState { Pending, Accepted, Rejected }
+impl FollowState {
+    pub fn from_str(s: &str) -> Self {
+        match s { "pending" => Self::Pending, "rejected" => Self::Rejected, _ => Self::Accepted }
+    }
+    pub fn as_str(&self) -> &str {
+        match self { Self::Pending => "pending", Self::Accepted => "accepted", Self::Rejected => "rejected" }
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct Follow {
+    pub follower_id: UserId,
+    pub following_id: UserId,
+    pub state: FollowState,
+    pub ap_id: Option<String>,
+    pub created_at: DateTime<Utc>,
+}
+
+#[derive(Debug, Clone)]
+pub struct Block {
+    pub blocker_id: UserId,
+    pub blocked_id: UserId,
+    pub created_at: DateTime<Utc>,
+}

crates/domain/src/models/tag.rs

@@ -0,0 +1,2 @@
+#[derive(Debug, Clone)]
+pub struct Tag { pub id: i32, pub name: String }

crates/domain/src/models/thought.rs

@@ -0,0 +1,45 @@
+use chrono::{DateTime, Utc};
+use crate::value_objects::{ThoughtId, UserId, Content};
+
+#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
+pub enum Visibility {
+    Public, Followers, Unlisted, Direct,
+}
+impl Visibility {
+    pub fn from_str(s: &str) -> Self {
+        match s { "followers" => Self::Followers, "unlisted" => Self::Unlisted, "direct" => Self::Direct, _ => Self::Public }
+    }
+    pub fn as_str(&self) -> &str {
+        match self { Self::Public => "public", Self::Followers => "followers", Self::Unlisted => "unlisted", Self::Direct => "direct" }
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct Thought {
+    pub id: ThoughtId,
+    pub user_id: UserId,
+    pub content: Content,
+    pub in_reply_to_id: Option<ThoughtId>,
+    pub in_reply_to_url: Option<String>,
+    pub ap_id: Option<String>,
+    pub visibility: Visibility,
+    pub content_warning: Option<String>,
+    pub sensitive: bool,
+    pub local: bool,
+    pub created_at: DateTime<Utc>,
+    pub updated_at: Option<DateTime<Utc>>,
+}
+
+impl Thought {
+    pub fn new_local(
+        id: ThoughtId, user_id: UserId, content: Content,
+        in_reply_to_id: Option<ThoughtId>, visibility: Visibility,
+        content_warning: Option<String>, sensitive: bool,
+    ) -> Self {
+        Self {
+            id, user_id, content, in_reply_to_id, in_reply_to_url: None, ap_id: None,
+            visibility, content_warning, sensitive, local: true,
+            created_at: Utc::now(), updated_at: None,
+        }
+    }
+}

crates/domain/src/models/top_friend.rs

@@ -0,0 +1,4 @@
+use crate::value_objects::UserId;
+
+#[derive(Debug, Clone)]
+pub struct TopFriend { pub user_id: UserId, pub friend_id: UserId, pub position: i16 }

crates/domain/src/models/user.rs

@@ -0,0 +1,35 @@
+use chrono::{DateTime, Utc};
+use crate::value_objects::{UserId, Username, Email, PasswordHash};
+
+#[derive(Debug, Clone)]
+pub struct User {
+    pub id: UserId,
+    pub username: Username,
+    pub email: Email,
+    pub password_hash: PasswordHash,
+    pub display_name: Option<String>,
+    pub bio: Option<String>,
+    pub avatar_url: Option<String>,
+    pub header_url: Option<String>,
+    pub custom_css: Option<String>,
+    pub local: bool,
+    pub ap_id: Option<String>,
+    pub inbox_url: Option<String>,
+    pub public_key: Option<String>,
+    pub private_key: Option<String>,
+    pub created_at: DateTime<Utc>,
+    pub updated_at: DateTime<Utc>,
+}
+
+impl User {
+    pub fn new_local(id: UserId, username: Username, email: Email, password_hash: PasswordHash) -> Self {
+        let now = Utc::now();
+        Self {
+            id, username, email, password_hash,
+            display_name: None, bio: None, avatar_url: None, header_url: None,
+            custom_css: None, local: true, ap_id: None, inbox_url: None,
+            public_key: None, private_key: None,
+            created_at: now, updated_at: now,
+        }
+    }
+}

crates/domain/src/ports.rs

@@ -0,0 +1,235 @@
+use async_trait::async_trait;
+use crate::{
+    errors::DomainError,
+    events::{DomainEvent, EventEnvelope},
+    models::{
+        api_key::ApiKey,
+        feed::{FeedEntry, PageParams, Paginated, UserSummary},
+        notification::Notification,
+        remote_actor::RemoteActor,
+        social::{Block, Boost, Follow, FollowState, Like},
+        tag::Tag,
+        thought::Thought,
+        top_friend::TopFriend,
+        user::User,
+    },
+    value_objects::{ApiKeyId, Content, Email, NotificationId, PasswordHash, ThoughtId, UserId, Username},
+};
+
+pub struct GeneratedToken { pub token: String, pub user_id: UserId }
+
+#[async_trait]
+pub trait AuthService: Send + Sync {
+    fn generate_token(&self, user_id: &UserId) -> Result<GeneratedToken, DomainError>;
+    fn validate_token(&self, token: &str) -> Result<UserId, DomainError>;
+}
+
+#[async_trait]
+pub trait PasswordHasher: Send + Sync {
+    async fn hash(&self, plain: &str) -> Result<PasswordHash, DomainError>;
+    async fn verify(&self, plain: &str, hash: &PasswordHash) -> Result<bool, DomainError>;
+}
+
+#[async_trait]
+pub trait EventPublisher: Send + Sync {
+    async fn publish(&self, event: &DomainEvent) -> Result<(), DomainError>;
+}
+
+pub trait EventConsumer: Send + Sync {
+    fn consume(&self) -> futures::stream::BoxStream<'_, Result<EventEnvelope, DomainError>>;
+}
+
+#[async_trait]
+pub trait UserRepository: Send + Sync {
+    async fn find_by_id(&self, id: &UserId) -> Result<Option<User>, DomainError>;
+    async fn find_by_username(&self, username: &Username) -> Result<Option<User>, DomainError>;
+    async fn find_by_email(&self, email: &Email) -> Result<Option<User>, DomainError>;
+    async fn save(&self, user: &User) -> Result<(), DomainError>;
+    async fn update_profile(&self, user_id: &UserId, display_name: Option<String>, bio: Option<String>, avatar_url: Option<String>, header_url: Option<String>, custom_css: Option<String>) -> Result<(), DomainError>;
+    async fn list_with_stats(&self) -> Result<Vec<UserSummary>, DomainError>;
+}
+
+#[async_trait]
+pub trait ThoughtRepository: Send + Sync {
+    async fn save(&self, thought: &Thought) -> Result<(), DomainError>;
+    async fn find_by_id(&self, id: &ThoughtId) -> Result<Option<Thought>, DomainError>;
+    async fn delete(&self, id: &ThoughtId, user_id: &UserId) -> Result<(), DomainError>;
+    async fn update_content(&self, id: &ThoughtId, content: &Content) -> Result<(), DomainError>;
+    async fn get_thread(&self, id: &ThoughtId) -> Result<Vec<Thought>, DomainError>;
+    async fn list_by_user(&self, user_id: &UserId, page: &PageParams) -> Result<Paginated<FeedEntry>, DomainError>;
+}
+
+#[async_trait]
+pub trait LikeRepository: Send + Sync {
+    async fn save(&self, like: &Like) -> Result<(), DomainError>;
+    async fn delete(&self, user_id: &UserId, thought_id: &ThoughtId) -> Result<(), DomainError>;
+    async fn find(&self, user_id: &UserId, thought_id: &ThoughtId) -> Result<Option<Like>, DomainError>;
+    async fn count_for_thought(&self, thought_id: &ThoughtId) -> Result<i64, DomainError>;
+}
+
+#[async_trait]
+pub trait BoostRepository: Send + Sync {
+    async fn save(&self, boost: &Boost) -> Result<(), DomainError>;
+    async fn delete(&self, user_id: &UserId, thought_id: &ThoughtId) -> Result<(), DomainError>;
+    async fn find(&self, user_id: &UserId, thought_id: &ThoughtId) -> Result<Option<Boost>, DomainError>;
+    async fn count_for_thought(&self, thought_id: &ThoughtId) -> Result<i64, DomainError>;
+}
+
+#[async_trait]
+pub trait FollowRepository: Send + Sync {
+    async fn save(&self, follow: &Follow) -> Result<(), DomainError>;
+    async fn delete(&self, follower_id: &UserId, following_id: &UserId) -> Result<(), DomainError>;
+    async fn find(&self, follower_id: &UserId, following_id: &UserId) -> Result<Option<Follow>, DomainError>;
+    async fn update_state(&self, follower_id: &UserId, following_id: &UserId, state: &FollowState) -> Result<(), DomainError>;
+    async fn list_followers(&self, user_id: &UserId, page: &PageParams) -> Result<Paginated<User>, DomainError>;
+    async fn list_following(&self, user_id: &UserId, page: &PageParams) -> Result<Paginated<User>, DomainError>;
+    async fn get_accepted_following_ids(&self, user_id: &UserId) -> Result<Vec<UserId>, DomainError>;
+}
+
+#[async_trait]
+pub trait BlockRepository: Send + Sync {
+    async fn save(&self, block: &Block) -> Result<(), DomainError>;
+    async fn delete(&self, blocker_id: &UserId, blocked_id: &UserId) -> Result<(), DomainError>;
+    async fn exists(&self, blocker_id: &UserId, blocked_id: &UserId) -> Result<bool, DomainError>;
+}
+
+#[async_trait]
+pub trait TagRepository: Send + Sync {
+    async fn find_or_create(&self, name: &str) -> Result<Tag, DomainError>;
+    async fn attach_to_thought(&self, thought_id: &ThoughtId, tag_id: i32) -> Result<(), DomainError>;
+    async fn detach_from_thought(&self, thought_id: &ThoughtId) -> Result<(), DomainError>;
+    async fn list_for_thought(&self, thought_id: &ThoughtId) -> Result<Vec<Tag>, DomainError>;
+    async fn list_thoughts_by_tag(&self, tag_name: &str, page: &PageParams) -> Result<Paginated<Thought>, DomainError>;
+}
+
+#[async_trait]
+pub trait ApiKeyRepository: Send + Sync {
+    async fn save(&self, key: &ApiKey) -> Result<(), DomainError>;
+    async fn find_by_hash(&self, key_hash: &str) -> Result<Option<ApiKey>, DomainError>;
+    async fn list_for_user(&self, user_id: &UserId) -> Result<Vec<ApiKey>, DomainError>;
+    async fn delete(&self, id: &ApiKeyId, user_id: &UserId) -> Result<(), DomainError>;
+}
+
+#[async_trait]
+pub trait TopFriendRepository: Send + Sync {
+    async fn set_top_friends(&self, user_id: &UserId, friends: Vec<(UserId, i16)>) -> Result<(), DomainError>;
+    async fn list_for_user(&self, user_id: &UserId) -> Result<Vec<(TopFriend, User)>, DomainError>;
+}
+
+#[async_trait]
+pub trait NotificationRepository: Send + Sync {
+    async fn save(&self, n: &Notification) -> Result<(), DomainError>;
+    async fn list_for_user(&self, user_id: &UserId, page: &PageParams) -> Result<Paginated<Notification>, DomainError>;
+    async fn mark_read(&self, id: &NotificationId, user_id: &UserId) -> Result<(), DomainError>;
+    async fn mark_all_read(&self, user_id: &UserId) -> Result<(), DomainError>;
+}
+
+#[async_trait]
+pub trait RemoteActorRepository: Send + Sync {
+    async fn upsert(&self, actor: &RemoteActor) -> Result<(), DomainError>;
+    async fn find_by_url(&self, url: &str) -> Result<Option<RemoteActor>, DomainError>;
+}
+
+#[async_trait]
+pub trait FeedRepository: Send + Sync {
+    async fn home_feed(&self, following_ids: &[UserId], page: &PageParams, viewer_id: Option<&UserId>) -> Result<Paginated<FeedEntry>, DomainError>;
+    async fn public_feed(&self, page: &PageParams, viewer_id: Option<&UserId>) -> Result<Paginated<FeedEntry>, DomainError>;
+    async fn search(&self, query: &str, page: &PageParams, viewer_id: Option<&UserId>) -> Result<Paginated<FeedEntry>, DomainError>;
+}
+
+#[async_trait]
+pub trait SearchPort: Send + Sync {
+    /// Full-text search over public thoughts, ranked by trigram similarity.
+    async fn search_thoughts(
+        &self,
+        query: &str,
+        page: &PageParams,
+        viewer_id: Option<&UserId>,
+    ) -> Result<Paginated<FeedEntry>, DomainError>;
+
+    /// Search users by username or display_name, ranked by trigram similarity.
+    async fn search_users(
+        &self,
+        query: &str,
+        page: &PageParams,
+    ) -> Result<Paginated<User>, DomainError>;
+}
+
+/// A local thought ready for AP serialization, with the author's username
+/// pre-joined so the handler can build AP URLs without a second query.
+#[derive(Debug, Clone)]
+pub struct OutboxEntry {
+    pub thought: crate::models::thought::Thought,
+    pub author_username: Username,
+}
+
+#[async_trait]
+pub trait ActivityPubRepository: Send + Sync {
+    // ── Outbox (local → remote) ──────────────────────────────────────
+
+    /// All public local thoughts for this actor. Used for outbox totals
+    /// and full-collection delivery.
+    async fn outbox_entries_for_actor(
+        &self,
+        user_id: &UserId,
+    ) -> Result<Vec<OutboxEntry>, DomainError>;
+
+    /// Cursor page of public local thoughts, newest-first, before `before`.
+    /// Used for OrderedCollectionPage responses.
+    async fn outbox_page_for_actor(
+        &self,
+        user_id: &UserId,
+        before: Option<chrono::DateTime<chrono::Utc>>,
+        limit: usize,
+    ) -> Result<Vec<OutboxEntry>, DomainError>;
+
+    // ── Remote actor resolution ──────────────────────────────────────
+
+    /// Find the local UserId for a remote actor by its AP URL.
+    async fn find_remote_actor_id(
+        &self,
+        actor_ap_url: &url::Url,
+    ) -> Result<Option<UserId>, DomainError>;
+
+    /// Ensure a remote actor placeholder exists; create one if absent.
+    /// Idempotent — safe to call multiple times with the same URL.
+    async fn intern_remote_actor(
+        &self,
+        actor_ap_url: &url::Url,
+    ) -> Result<UserId, DomainError>;
+
+    // ── Inbox processing (remote → local) ───────────────────────────
+
+    /// Persist an incoming remote Note. Idempotent on ap_id.
+    async fn accept_note(
+        &self,
+        ap_id: &url::Url,
+        author_id: &UserId,
+        content: &str,
+        published: chrono::DateTime<chrono::Utc>,
+        sensitive: bool,
+        content_warning: Option<String>,
+    ) -> Result<(), DomainError>;
+
+    /// Apply an Update to a previously accepted remote Note.
+    async fn apply_note_update(
+        &self,
+        ap_id: &url::Url,
+        new_content: &str,
+    ) -> Result<(), DomainError>;
+
+    /// Remove a specific remote Note (Delete activity). Only touches
+    /// remotely-originated thoughts.
+    async fn retract_note(&self, ap_id: &url::Url) -> Result<(), DomainError>;
+
+    /// Remove all Notes from a remote actor (actor-level Delete/Tombstone).
+    async fn retract_actor_notes(
+        &self,
+        actor_ap_url: &url::Url,
+    ) -> Result<(), DomainError>;
+
+    // ── Node-level stats ─────────────────────────────────────────────
+
+    /// Total locally-authored thought count for NodeInfo responses.
+    async fn count_local_notes(&self) -> Result<u64, DomainError>;
+}

crates/domain/src/testing.rs

@@ -0,0 +1,389 @@
+use std::sync::{Arc, Mutex};
+use async_trait::async_trait;
+use chrono::Utc;
+use url;
+use crate::{
+    errors::DomainError,
+    events::DomainEvent,
+    models::{
+        api_key::ApiKey,
+        feed::{FeedEntry, PageParams, Paginated, UserSummary},
+        notification::Notification,
+        remote_actor::RemoteActor,
+        social::{Block, Boost, Follow, FollowState, Like},
+        tag::Tag,
+        thought::Thought,
+        top_friend::TopFriend,
+        user::User,
+    },
+    ports::*,
+    value_objects::{ApiKeyId, Content, Email, NotificationId, PasswordHash, ThoughtId, UserId, Username},
+};
+
+#[derive(Default, Clone)]
+pub struct TestStore {
+    pub users:         Arc<Mutex<Vec<User>>>,
+    pub thoughts:      Arc<Mutex<Vec<Thought>>>,
+    pub likes:         Arc<Mutex<Vec<Like>>>,
+    pub boosts:        Arc<Mutex<Vec<Boost>>>,
+    pub follows:       Arc<Mutex<Vec<Follow>>>,
+    pub blocks:        Arc<Mutex<Vec<Block>>>,
+    pub tags:          Arc<Mutex<Vec<Tag>>>,
+    pub api_keys:      Arc<Mutex<Vec<ApiKey>>>,
+    pub top_friends:   Arc<Mutex<Vec<TopFriend>>>,
+    pub notifications: Arc<Mutex<Vec<Notification>>>,
+    pub events:        Arc<Mutex<Vec<DomainEvent>>>,
+}
+
+#[async_trait] impl UserRepository for TestStore {
+    async fn find_by_id(&self, id: &UserId) -> Result<Option<User>, DomainError> {
+        Ok(self.users.lock().unwrap().iter().find(|u| &u.id == id).cloned())
+    }
+    async fn find_by_username(&self, username: &Username) -> Result<Option<User>, DomainError> {
+        Ok(self.users.lock().unwrap().iter().find(|u| u.username.as_str() == username.as_str()).cloned())
+    }
+    async fn find_by_email(&self, email: &Email) -> Result<Option<User>, DomainError> {
+        Ok(self.users.lock().unwrap().iter().find(|u| u.email.as_str() == email.as_str()).cloned())
+    }
+    async fn save(&self, user: &User) -> Result<(), DomainError> {
+        let mut g = self.users.lock().unwrap();
+        g.retain(|u| u.id != user.id);
+        g.push(user.clone());
+        Ok(())
+    }
+    async fn update_profile(&self, user_id: &UserId, display_name: Option<String>, bio: Option<String>, avatar_url: Option<String>, header_url: Option<String>, custom_css: Option<String>) -> Result<(), DomainError> {
+        if let Some(u) = self.users.lock().unwrap().iter_mut().find(|u| &u.id == user_id) {
+            u.display_name = display_name;
+            u.bio = bio;
+            u.avatar_url = avatar_url;
+            u.header_url = header_url;
+            u.custom_css = custom_css;
+        }
+        Ok(())
+    }
+    async fn list_with_stats(&self) -> Result<Vec<UserSummary>, DomainError> { Ok(vec![]) }
+}
+
+#[async_trait] impl ThoughtRepository for TestStore {
+    async fn save(&self, t: &Thought) -> Result<(), DomainError> {
+        let mut g = self.thoughts.lock().unwrap();
+        g.retain(|x| x.id != t.id);
+        g.push(t.clone());
+        Ok(())
+    }
+    async fn find_by_id(&self, id: &ThoughtId) -> Result<Option<Thought>, DomainError> {
+        Ok(self.thoughts.lock().unwrap().iter().find(|t| &t.id == id).cloned())
+    }
+    async fn delete(&self, id: &ThoughtId, user_id: &UserId) -> Result<(), DomainError> {
+        let mut g = self.thoughts.lock().unwrap();
+        let before = g.len();
+        g.retain(|t| !(&t.id == id && &t.user_id == user_id));
+        if g.len() == before { return Err(DomainError::NotFound); }
+        Ok(())
+    }
+    async fn update_content(&self, id: &ThoughtId, content: &Content) -> Result<(), DomainError> {
+        if let Some(t) = self.thoughts.lock().unwrap().iter_mut().find(|t| &t.id == id) {
+            t.content = content.clone();
+            t.updated_at = Some(Utc::now());
+        }
+        Ok(())
+    }
+    async fn get_thread(&self, id: &ThoughtId) -> Result<Vec<Thought>, DomainError> {
+        Ok(self.thoughts.lock().unwrap().iter()
+            .filter(|t| t.in_reply_to_id.as_ref() == Some(id) || &t.id == id)
+            .cloned().collect())
+    }
+    async fn list_by_user(&self, _user_id: &UserId, _page: &PageParams) -> Result<Paginated<FeedEntry>, DomainError> {
+        Ok(Paginated { items: vec![], total: 0, page: 1, per_page: 20 })
+    }
+}
+
+#[async_trait] impl LikeRepository for TestStore {
+    async fn save(&self, like: &Like) -> Result<(), DomainError> {
+        let mut g = self.likes.lock().unwrap();
+        if g.iter().any(|l| l.user_id == like.user_id && l.thought_id == like.thought_id) {
+            return Err(DomainError::Conflict("already liked".into()));
+        }
+        g.push(like.clone());
+        Ok(())
+    }
+    async fn delete(&self, user_id: &UserId, thought_id: &ThoughtId) -> Result<(), DomainError> {
+        let mut g = self.likes.lock().unwrap();
+        let before = g.len();
+        g.retain(|l| !(&l.user_id == user_id && &l.thought_id == thought_id));
+        if g.len() == before { return Err(DomainError::NotFound); }
+        Ok(())
+    }
+    async fn find(&self, user_id: &UserId, thought_id: &ThoughtId) -> Result<Option<Like>, DomainError> {
+        Ok(self.likes.lock().unwrap().iter().find(|l| &l.user_id == user_id && &l.thought_id == thought_id).cloned())
+    }
+    async fn count_for_thought(&self, thought_id: &ThoughtId) -> Result<i64, DomainError> {
+        Ok(self.likes.lock().unwrap().iter().filter(|l| &l.thought_id == thought_id).count() as i64)
+    }
+}
+
+#[async_trait] impl BoostRepository for TestStore {
+    async fn save(&self, boost: &Boost) -> Result<(), DomainError> {
+        let mut g = self.boosts.lock().unwrap();
+        if g.iter().any(|b| b.user_id == boost.user_id && b.thought_id == boost.thought_id) {
+            return Err(DomainError::Conflict("already boosted".into()));
+        }
+        g.push(boost.clone());
+        Ok(())
+    }
+    async fn delete(&self, user_id: &UserId, thought_id: &ThoughtId) -> Result<(), DomainError> {
+        let mut g = self.boosts.lock().unwrap();
+        let before = g.len();
+        g.retain(|b| !(&b.user_id == user_id && &b.thought_id == thought_id));
+        if g.len() == before { return Err(DomainError::NotFound); }
+        Ok(())
+    }
+    async fn find(&self, user_id: &UserId, thought_id: &ThoughtId) -> Result<Option<Boost>, DomainError> {
+        Ok(self.boosts.lock().unwrap().iter().find(|b| &b.user_id == user_id && &b.thought_id == thought_id).cloned())
+    }
+    async fn count_for_thought(&self, thought_id: &ThoughtId) -> Result<i64, DomainError> {
+        Ok(self.boosts.lock().unwrap().iter().filter(|b| &b.thought_id == thought_id).count() as i64)
+    }
+}
+
+#[async_trait] impl FollowRepository for TestStore {
+    async fn save(&self, follow: &Follow) -> Result<(), DomainError> {
+        let mut g = self.follows.lock().unwrap();
+        g.retain(|f| !(f.follower_id == follow.follower_id && f.following_id == follow.following_id));
+        g.push(follow.clone());
+        Ok(())
+    }
+    async fn delete(&self, follower_id: &UserId, following_id: &UserId) -> Result<(), DomainError> {
+        let mut g = self.follows.lock().unwrap();
+        let before = g.len();
+        g.retain(|f| !(&f.follower_id == follower_id && &f.following_id == following_id));
+        if g.len() == before { return Err(DomainError::NotFound); }
+        Ok(())
+    }
+    async fn find(&self, follower_id: &UserId, following_id: &UserId) -> Result<Option<Follow>, DomainError> {
+        Ok(self.follows.lock().unwrap().iter().find(|f| &f.follower_id == follower_id && &f.following_id == following_id).cloned())
+    }
+    async fn update_state(&self, follower_id: &UserId, following_id: &UserId, state: &FollowState) -> Result<(), DomainError> {
+        if let Some(f) = self.follows.lock().unwrap().iter_mut().find(|f| &f.follower_id == follower_id && &f.following_id == following_id) {
+            f.state = state.clone();
+        }
+        Ok(())
+    }
+    async fn list_followers(&self, _user_id: &UserId, _p: &PageParams) -> Result<Paginated<User>, DomainError> {
+        Ok(Paginated { items: vec![], total: 0, page: 1, per_page: 20 })
+    }
+    async fn list_following(&self, _user_id: &UserId, _p: &PageParams) -> Result<Paginated<User>, DomainError> {
+        Ok(Paginated { items: vec![], total: 0, page: 1, per_page: 20 })
+    }
+    async fn get_accepted_following_ids(&self, user_id: &UserId) -> Result<Vec<UserId>, DomainError> {
+        Ok(self.follows.lock().unwrap().iter()
+            .filter(|f| &f.follower_id == user_id && f.state == FollowState::Accepted)
+            .map(|f| f.following_id.clone())
+            .collect())
+    }
+}
+
+#[async_trait] impl BlockRepository for TestStore {
+    async fn save(&self, block: &Block) -> Result<(), DomainError> {
+        self.blocks.lock().unwrap().push(block.clone());
+        Ok(())
+    }
+    async fn delete(&self, blocker_id: &UserId, blocked_id: &UserId) -> Result<(), DomainError> {
+        self.blocks.lock().unwrap().retain(|b| !(&b.blocker_id == blocker_id && &b.blocked_id == blocked_id));
+        Ok(())
+    }
+    async fn exists(&self, blocker_id: &UserId, blocked_id: &UserId) -> Result<bool, DomainError> {
+        Ok(self.blocks.lock().unwrap().iter().any(|b| &b.blocker_id == blocker_id && &b.blocked_id == blocked_id))
+    }
+}
+
+#[async_trait] impl TagRepository for TestStore {
+    async fn find_or_create(&self, name: &str) -> Result<Tag, DomainError> {
+        let mut g = self.tags.lock().unwrap();
+        if let Some(t) = g.iter().find(|t| t.name == name) { return Ok(t.clone()); }
+        let tag = Tag { id: g.len() as i32 + 1, name: name.to_string() };
+        g.push(tag.clone());
+        Ok(tag)
+    }
+    async fn attach_to_thought(&self, _tid: &ThoughtId, _tag_id: i32) -> Result<(), DomainError> { Ok(()) }
+    async fn detach_from_thought(&self, _tid: &ThoughtId) -> Result<(), DomainError> { Ok(()) }
+    async fn list_for_thought(&self, _tid: &ThoughtId) -> Result<Vec<Tag>, DomainError> { Ok(vec![]) }
+    async fn list_thoughts_by_tag(&self, _name: &str, _p: &PageParams) -> Result<Paginated<Thought>, DomainError> {
+        Ok(Paginated { items: vec![], total: 0, page: 1, per_page: 20 })
+    }
+}
+
+#[async_trait] impl ApiKeyRepository for TestStore {
+    async fn save(&self, key: &ApiKey) -> Result<(), DomainError> {
+        self.api_keys.lock().unwrap().push(key.clone());
+        Ok(())
+    }
+    async fn find_by_hash(&self, hash: &str) -> Result<Option<ApiKey>, DomainError> {
+        Ok(self.api_keys.lock().unwrap().iter().find(|k| k.key_hash == hash).cloned())
+    }
+    async fn list_for_user(&self, uid: &UserId) -> Result<Vec<ApiKey>, DomainError> {
+        Ok(self.api_keys.lock().unwrap().iter().filter(|k| &k.user_id == uid).cloned().collect())
+    }
+    async fn delete(&self, id: &ApiKeyId, uid: &UserId) -> Result<(), DomainError> {
+        self.api_keys.lock().unwrap().retain(|k| !(&k.id == id && &k.user_id == uid));
+        Ok(())
+    }
+}
+
+#[async_trait] impl TopFriendRepository for TestStore {
+    async fn set_top_friends(&self, user_id: &UserId, friends: Vec<(UserId, i16)>) -> Result<(), DomainError> {
+        let mut g = self.top_friends.lock().unwrap();
+        g.retain(|tf| &tf.user_id != user_id);
+        for (fid, pos) in friends {
+            g.push(TopFriend { user_id: user_id.clone(), friend_id: fid, position: pos });
+        }
+        Ok(())
+    }
+    async fn list_for_user(&self, _uid: &UserId) -> Result<Vec<(TopFriend, User)>, DomainError> { Ok(vec![]) }
+}
+
+#[async_trait] impl NotificationRepository for TestStore {
+    async fn save(&self, n: &Notification) -> Result<(), DomainError> {
+        self.notifications.lock().unwrap().push(n.clone());
+        Ok(())
+    }
+    async fn list_for_user(&self, uid: &UserId, _p: &PageParams) -> Result<Paginated<Notification>, DomainError> {
+        let items: Vec<_> = self.notifications.lock().unwrap().iter().filter(|n| &n.user_id == uid).cloned().collect();
+        let total = items.len() as i64;
+        Ok(Paginated { items, total, page: 1, per_page: 20 })
+    }
+    async fn mark_read(&self, id: &NotificationId, _uid: &UserId) -> Result<(), DomainError> {
+        if let Some(n) = self.notifications.lock().unwrap().iter_mut().find(|n| &n.id == id) {
+            n.read = true;
+        }
+        Ok(())
+    }
+    async fn mark_all_read(&self, uid: &UserId) -> Result<(), DomainError> {
+        for n in self.notifications.lock().unwrap().iter_mut().filter(|n| &n.user_id == uid) {
+            n.read = true;
+        }
+        Ok(())
+    }
+}
+
+#[async_trait] impl RemoteActorRepository for TestStore {
+    async fn upsert(&self, _a: &RemoteActor) -> Result<(), DomainError> { Ok(()) }
+    async fn find_by_url(&self, _url: &str) -> Result<Option<RemoteActor>, DomainError> { Ok(None) }
+}
+
+#[async_trait] impl FeedRepository for TestStore {
+    async fn home_feed(&self, _ids: &[UserId], _p: &PageParams, _v: Option<&UserId>) -> Result<Paginated<FeedEntry>, DomainError> {
+        Ok(Paginated { items: vec![], total: 0, page: 1, per_page: 20 })
+    }
+    async fn public_feed(&self, _p: &PageParams, _v: Option<&UserId>) -> Result<Paginated<FeedEntry>, DomainError> {
+        Ok(Paginated { items: vec![], total: 0, page: 1, per_page: 20 })
+    }
+    async fn search(&self, _q: &str, _p: &PageParams, _v: Option<&UserId>) -> Result<Paginated<FeedEntry>, DomainError> {
+        Ok(Paginated { items: vec![], total: 0, page: 1, per_page: 20 })
+    }
+}
+
+#[async_trait] impl SearchPort for TestStore {
+    async fn search_thoughts(&self, _q: &str, _p: &PageParams, _v: Option<&UserId>) -> Result<Paginated<FeedEntry>, DomainError> {
+        Ok(Paginated { items: vec![], total: 0, page: 1, per_page: 20 })
+    }
+    async fn search_users(&self, _q: &str, _p: &PageParams) -> Result<Paginated<User>, DomainError> {
+        Ok(Paginated { items: vec![], total: 0, page: 1, per_page: 20 })
+    }
+}
+
+#[async_trait] impl ActivityPubRepository for TestStore {
+    async fn outbox_entries_for_actor(&self, _uid: &UserId) -> Result<Vec<crate::ports::OutboxEntry>, DomainError> {
+        Ok(vec![])
+    }
+    async fn outbox_page_for_actor(&self, _uid: &UserId, _before: Option<chrono::DateTime<chrono::Utc>>, _limit: usize) -> Result<Vec<crate::ports::OutboxEntry>, DomainError> {
+        Ok(vec![])
+    }
+    async fn find_remote_actor_id(&self, actor_ap_url: &url::Url) -> Result<Option<UserId>, DomainError> {
+        let url = actor_ap_url.to_string();
+        Ok(self.users.lock().unwrap().iter()
+            .find(|u| u.ap_id.as_deref() == Some(&url))
+            .map(|u| u.id.clone()))
+    }
+    async fn intern_remote_actor(&self, actor_ap_url: &url::Url) -> Result<UserId, DomainError> {
+        if let Some(uid) = self.find_remote_actor_id(actor_ap_url).await? {
+            return Ok(uid);
+        }
+        let uid = UserId::new();
+        let handle = actor_ap_url.path().trim_start_matches('/').replace('/', "_");
+        let user = crate::models::user::User {
+            id: uid.clone(),
+            username: Username::from_trusted(handle.clone()),
+            email: Email::from_trusted(format!("{}@remote", uid)),
+            password_hash: PasswordHash("".into()),
+            display_name: None, bio: None, avatar_url: None, header_url: None,
+            custom_css: None, local: false,
+            ap_id: Some(actor_ap_url.to_string()),
+            inbox_url: None, public_key: None, private_key: None,
+            created_at: chrono::Utc::now(), updated_at: chrono::Utc::now(),
+        };
+        self.users.lock().unwrap().push(user);
+        Ok(uid)
+    }
+    async fn accept_note(&self, _ap_id: &url::Url, _author_id: &UserId, _content: &str, _published: chrono::DateTime<chrono::Utc>, _sensitive: bool, _content_warning: Option<String>) -> Result<(), DomainError> { Ok(()) }
+    async fn apply_note_update(&self, _ap_id: &url::Url, _new_content: &str) -> Result<(), DomainError> { Ok(()) }
+    async fn retract_note(&self, _ap_id: &url::Url) -> Result<(), DomainError> { Ok(()) }
+    async fn retract_actor_notes(&self, _actor_ap_url: &url::Url) -> Result<(), DomainError> { Ok(()) }
+    async fn count_local_notes(&self) -> Result<u64, DomainError> {
+        Ok(self.thoughts.lock().unwrap().iter().filter(|t| t.local).count() as u64)
+    }
+}
+
+#[async_trait] impl EventPublisher for TestStore {
+    async fn publish(&self, event: &DomainEvent) -> Result<(), DomainError> {
+        self.events.lock().unwrap().push(event.clone());
+        Ok(())
+    }
+}
+
+pub struct NoOpEventPublisher;
+#[async_trait] impl EventPublisher for NoOpEventPublisher {
+    async fn publish(&self, _e: &DomainEvent) -> Result<(), DomainError> { Ok(()) }
+}
+
+#[cfg(test)]
+mod ap_repo_tests {
+    use super::*;
+    use crate::value_objects::UserId;
+
+    #[tokio::test]
+    async fn test_store_outbox_returns_empty() {
+        let store = TestStore::default();
+        let result = store.outbox_entries_for_actor(&UserId::new()).await.unwrap();
+        assert!(result.is_empty());
+    }
+
+    #[tokio::test]
+    async fn test_store_intern_creates_placeholder() {
+        let store = TestStore::default();
+        let url = url::Url::parse("https://example.com/users/alice").unwrap();
+        let id1 = store.intern_remote_actor(&url).await.unwrap();
+        let id2 = store.intern_remote_actor(&url).await.unwrap();
+        assert_eq!(id1, id2, "intern must be idempotent");
+    }
+}
+
+#[cfg(test)]
+mod search_tests {
+    use super::*;
+    use crate::models::feed::PageParams;
+
+    #[tokio::test]
+    async fn test_store_search_thoughts_returns_empty() {
+        let store = TestStore::default();
+        let result = store.search_thoughts("hello", &PageParams { page: 1, per_page: 20 }, None).await.unwrap();
+        assert_eq!(result.total, 0);
+    }
+
+    #[tokio::test]
+    async fn test_store_search_users_returns_empty() {
+        let store = TestStore::default();
+        let result = store.search_users("alice", &PageParams { page: 1, per_page: 20 }).await.unwrap();
+        assert_eq!(result.total, 0);
+    }
+}

crates/domain/src/value_objects.rs

@@ -0,0 +1,117 @@
+use uuid::Uuid;
+use crate::errors::DomainError;
+
+macro_rules! uuid_id {
+    ($name:ident) => {
+        #[derive(Debug, Clone, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize)]
+        pub struct $name(Uuid);
+        impl $name {
+            pub fn new() -> Self { Self(Uuid::new_v4()) }
+            pub fn from_uuid(u: Uuid) -> Self { Self(u) }
+            pub fn as_uuid(&self) -> Uuid { self.0 }
+        }
+        impl Default for $name {
+            fn default() -> Self { Self::new() }
+        }
+        impl std::fmt::Display for $name {
+            fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                write!(f, "{}", self.0)
+            }
+        }
+    };
+}
+
+uuid_id!(UserId);
+uuid_id!(ThoughtId);
+uuid_id!(LikeId);
+uuid_id!(BoostId);
+uuid_id!(ApiKeyId);
+uuid_id!(NotificationId);
+
+#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
+pub struct Username(String);
+impl Username {
+    pub fn new(s: impl Into<String>) -> Result<Self, DomainError> {
+        let s = s.into();
+        if s.is_empty() || s.len() > 32 {
+            return Err(DomainError::InvalidInput("username: 1-32 chars".into()));
+        }
+        if !s.chars().all(|c| c.is_alphanumeric() || c == '_') {
+            return Err(DomainError::InvalidInput("username: alphanumeric or underscore only".into()));
+        }
+        Ok(Self(s))
+    }
+    pub fn from_trusted(s: String) -> Self { Self(s) }
+    pub fn as_str(&self) -> &str { &self.0 }
+}
+impl std::fmt::Display for Username {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { write!(f, "{}", self.0) }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
+pub struct Email(String);
+impl Email {
+    pub fn new(s: impl Into<String>) -> Result<Self, DomainError> {
+        let s = s.into().to_lowercase();
+        if !s.contains('@') || s.len() > 255 {
+            return Err(DomainError::InvalidInput("invalid email".into()));
+        }
+        Ok(Self(s))
+    }
+    pub fn from_trusted(s: String) -> Self { Self(s) }
+    pub fn as_str(&self) -> &str { &self.0 }
+}
+
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+pub struct PasswordHash(pub String);
+
+#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
+pub struct Content(String);
+impl Content {
+    pub fn new_local(s: impl Into<String>) -> Result<Self, DomainError> {
+        let s = s.into();
+        if s.is_empty() || s.len() > 128 {
+            return Err(DomainError::InvalidInput("content: 1-128 chars".into()));
+        }
+        Ok(Self(s))
+    }
+    pub fn new_remote(s: impl Into<String>) -> Self { Self(s.into()) }
+    pub fn as_str(&self) -> &str { &self.0 }
+}
+impl std::fmt::Display for Content {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { write!(f, "{}", self.0) }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn username_rejects_empty() {
+        assert!(Username::new("").is_err());
+    }
+    #[test]
+    fn username_rejects_too_long() {
+        assert!(Username::new("a".repeat(33)).is_err());
+    }
+    #[test]
+    fn username_rejects_invalid_chars() {
+        assert!(Username::new("hello world").is_err());
+    }
+    #[test]
+    fn username_accepts_valid() {
+        assert!(Username::new("hello_123").is_ok());
+    }
+    #[test]
+    fn content_local_rejects_over_128() {
+        assert!(Content::new_local("a".repeat(129)).is_err());
+    }
+    #[test]
+    fn content_local_accepts_128() {
+        assert!(Content::new_local("a".repeat(128)).is_ok());
+    }
+    #[test]
+    fn email_rejects_no_at() {
+        assert!(Email::new("notanemail").is_err());
+    }
+}

crates/presentation/Cargo.toml

@@ -0,0 +1,42 @@
+[package]
+name = "presentation"
+version = "0.1.0"
+edition = "2021"
+
+[[bin]]
+name = "thoughts"
+path = "src/main.rs"
+
+[dependencies]
+domain      = { workspace = true }
+application = { workspace = true }
+api-types   = { workspace = true }
+postgres    = { workspace = true }
+postgres-search = { workspace = true }
+auth        = { workspace = true }
+nats        = { workspace = true }
+async-nats  = { workspace = true }
+axum        = { workspace = true }
+sqlx        = { workspace = true }
+tower-http  = { workspace = true }
+tokio       = { workspace = true, features = ["full"] }
+serde       = { workspace = true }
+serde_json  = { workspace = true }
+uuid        = { workspace = true }
+chrono      = { workspace = true }
+tracing     = { workspace = true }
+tracing-subscriber = { workspace = true }
+dotenvy     = { workspace = true }
+async-trait = { workspace = true }
+sha2        = "0.10"
+hex         = "0.4"
+activitypub         = { workspace = true }
+activitypub-base    = { workspace = true }
+postgres-federation = { workspace = true }
+url                 = { workspace = true }
+activitypub_federation = "0.7.0-beta.11"
+
+[dev-dependencies]
+http-body-util = "0.1"
+tower          = "0.5"
+domain         = { workspace = true, features = ["test-helpers"] }

crates/presentation/src/errors.rs

@@ -0,0 +1,29 @@
+use axum::{http::StatusCode, response::{IntoResponse, Response}, Json};
+use domain::errors::DomainError;
+use api_types::responses::ErrorResponse;
+
+pub enum ApiError {
+    Domain(DomainError),
+    Unauthorized,
+    BadRequest(String),
+}
+
+impl From<DomainError> for ApiError {
+    fn from(e: DomainError) -> Self { Self::Domain(e) }
+}
+
+impl IntoResponse for ApiError {
+    fn into_response(self) -> Response {
+        let (status, msg) = match self {
+            Self::Domain(DomainError::NotFound)          => (StatusCode::NOT_FOUND, "not found".into()),
+            Self::Domain(DomainError::Unauthorized)      => (StatusCode::UNAUTHORIZED, "unauthorized".into()),
+            Self::Domain(DomainError::Forbidden)         => (StatusCode::FORBIDDEN, "forbidden".into()),
+            Self::Domain(DomainError::Conflict(m))       => (StatusCode::CONFLICT, m),
+            Self::Domain(DomainError::InvalidInput(m))   => (StatusCode::UNPROCESSABLE_ENTITY, m),
+            Self::Domain(DomainError::Internal(_))       => (StatusCode::INTERNAL_SERVER_ERROR, "internal server error".into()),
+            Self::Unauthorized                           => (StatusCode::UNAUTHORIZED, "unauthorized".into()),
+            Self::BadRequest(m)                          => (StatusCode::BAD_REQUEST, m),
+        };
+        (status, Json(ErrorResponse { error: msg })).into_response()
+    }
+}

crates/presentation/src/extractors.rs

@@ -0,0 +1,47 @@
+use axum::{extract::FromRequestParts, http::request::Parts};
+use domain::value_objects::UserId;
+use crate::{errors::ApiError, state::AppState};
+
+pub struct AuthUser(pub UserId);
+pub struct OptionalAuthUser(pub Option<UserId>);
+
+impl FromRequestParts<AppState> for AuthUser {
+    type Rejection = ApiError;
+    async fn from_request_parts(parts: &mut Parts, state: &AppState) -> Result<Self, ApiError> {
+        extract_user_id(parts, state).await?
+            .ok_or(ApiError::Unauthorized)
+            .map(AuthUser)
+    }
+}
+
+impl FromRequestParts<AppState> for OptionalAuthUser {
+    type Rejection = ApiError;
+    async fn from_request_parts(parts: &mut Parts, state: &AppState) -> Result<Self, ApiError> {
+        Ok(OptionalAuthUser(extract_user_id(parts, state).await?))
+    }
+}
+
+async fn extract_user_id(parts: &mut Parts, state: &AppState) -> Result<Option<UserId>, ApiError> {
+    if let Some(auth_header) = parts.headers.get("Authorization") {
+        if let Ok(s) = auth_header.to_str() {
+            if let Some(token) = s.strip_prefix("Bearer ") {
+                return state.auth.validate_token(token).map(Some).map_err(|_| ApiError::Unauthorized);
+            }
+        }
+    }
+    if let Some(key_header) = parts.headers.get("X-Api-Key") {
+        if let Ok(raw) = key_header.to_str() {
+            let hash = sha256_hex(raw);
+            if let Ok(Some(key)) = state.api_keys.find_by_hash(&hash).await {
+                return Ok(Some(key.user_id));
+            }
+        }
+    }
+    Ok(None)
+}
+
+fn sha256_hex(s: &str) -> String {
+    use sha2::{Digest, Sha256};
+    let hash = Sha256::digest(s.as_bytes());
+    hex::encode(hash)
+}

crates/presentation/src/handlers/api_keys.rs

@@ -0,0 +1,19 @@
+use axum::{extract::{Path, State}, http::StatusCode, Json};
+use uuid::Uuid;
+use api_types::{requests::CreateApiKeyRequest, responses::ApiKeyResponse};
+use application::use_cases::api_keys::{create_api_key, delete_api_key, list_api_keys};
+use domain::value_objects::ApiKeyId;
+use crate::{errors::ApiError, extractors::AuthUser, state::AppState};
+
+pub async fn get_api_keys(State(s): State<AppState>, AuthUser(uid): AuthUser) -> Result<Json<Vec<ApiKeyResponse>>, ApiError> {
+    let keys = list_api_keys(&*s.api_keys, &uid).await?;
+    Ok(Json(keys.into_iter().map(|k| ApiKeyResponse { id: k.id.as_uuid(), name: k.name, created_at: k.created_at }).collect()))
+}
+pub async fn post_api_key(State(s): State<AppState>, AuthUser(uid): AuthUser, Json(body): Json<CreateApiKeyRequest>) -> Result<Json<serde_json::Value>, ApiError> {
+    let (key, raw) = create_api_key(&*s.api_keys, &uid, body.name).await?;
+    Ok(Json(serde_json::json!({ "id": key.id.as_uuid(), "name": key.name, "key": raw })))
+}
+pub async fn delete_api_key_handler(State(s): State<AppState>, AuthUser(uid): AuthUser, Path(id): Path<Uuid>) -> Result<StatusCode, ApiError> {
+    delete_api_key(&*s.api_keys, &uid, &ApiKeyId::from_uuid(id)).await?;
+    Ok(StatusCode::NO_CONTENT)
+}

crates/presentation/src/handlers/auth.rs

@@ -0,0 +1,35 @@
+use axum::{extract::State, http::StatusCode, response::IntoResponse, Json};
+use api_types::{requests::{LoginRequest, RegisterRequest}, responses::{AuthResponse, UserResponse}};
+use application::use_cases::auth::{login, register, LoginInput, RegisterInput};
+use crate::{errors::ApiError, state::AppState};
+
+pub fn to_user_response(u: &domain::models::user::User) -> UserResponse {
+    UserResponse {
+        id: u.id.as_uuid(),
+        username: u.username.to_string(),
+        display_name: u.display_name.clone(),
+        bio: u.bio.clone(),
+        avatar_url: u.avatar_url.clone(),
+        header_url: u.header_url.clone(),
+        local: u.local,
+        created_at: u.created_at,
+    }
+}
+
+pub async fn post_register(State(s): State<AppState>, Json(body): Json<RegisterRequest>) -> Result<impl IntoResponse, ApiError> {
+    let out = register(&*s.users, &*s.hasher, &*s.auth, &*s.events, RegisterInput {
+        username: body.username,
+        email: body.email,
+        password: body.password,
+    }).await?;
+    let resp = AuthResponse { token: out.token, user: to_user_response(&out.user) };
+    Ok((StatusCode::CREATED, Json(resp)))
+}
+
+pub async fn post_login(State(s): State<AppState>, Json(body): Json<LoginRequest>) -> Result<impl IntoResponse, ApiError> {
+    let out = login(&*s.users, &*s.hasher, &*s.auth, LoginInput {
+        email: body.email,
+        password: body.password,
+    }).await?;
+    Ok(Json(AuthResponse { token: out.token, user: to_user_response(&out.user) }))
+}

crates/presentation/src/handlers/feed.rs

@@ -0,0 +1,64 @@
+use axum::{extract::{Path, Query, State}, Json};
+use api_types::requests::{PaginationQuery, SearchQuery};
+use application::use_cases::feed::{get_home_feed, get_public_feed, get_followers, get_following};
+use domain::models::feed::PageParams;
+use crate::{errors::ApiError, extractors::{AuthUser, OptionalAuthUser}, handlers::auth::to_user_response, state::AppState};
+use application::use_cases::profile::get_user_by_username;
+
+pub async fn home_feed(State(s): State<AppState>, AuthUser(uid): AuthUser, Query(q): Query<PaginationQuery>) -> Result<Json<serde_json::Value>, ApiError> {
+    let page = PageParams { page: q.page(), per_page: q.per_page() };
+    let result = get_home_feed(&*s.feed, &*s.follows, &uid, page).await?;
+    Ok(Json(serde_json::json!({ "items": result.items.iter().map(|e| e.thought.id.as_uuid()).collect::<Vec<_>>(), "total": result.total, "page": result.page })))
+}
+
+pub async fn public_feed(State(s): State<AppState>, OptionalAuthUser(viewer): OptionalAuthUser, Query(q): Query<PaginationQuery>) -> Result<Json<serde_json::Value>, ApiError> {
+    let page = PageParams { page: q.page(), per_page: q.per_page() };
+    let result = get_public_feed(&*s.feed, viewer.as_ref(), page).await?;
+    Ok(Json(serde_json::json!({ "items": result.items.iter().map(|e| e.thought.id.as_uuid()).collect::<Vec<_>>(), "total": result.total, "page": result.page })))
+}
+
+pub async fn search_handler(
+    State(s): State<AppState>,
+    OptionalAuthUser(viewer): OptionalAuthUser,
+    Query(q): Query<SearchQuery>,
+) -> Result<Json<serde_json::Value>, ApiError> {
+    let page = PageParams { page: q.page.unwrap_or(1), per_page: q.per_page.unwrap_or(20) };
+    let query = q.q.trim().to_string();
+
+    let (thoughts_result, users_result) = tokio::join!(
+        s.search.search_thoughts(&query, &page, viewer.as_ref()),
+        s.search.search_users(&query, &page),
+    );
+
+    let thoughts = thoughts_result?.items.into_iter().map(|e| serde_json::json!({
+        "id": e.thought.id.as_uuid(),
+        "content": e.thought.content.as_str(),
+        "author": to_user_response(&e.author),
+        "like_count": e.like_count,
+        "boost_count": e.boost_count,
+        "reply_count": e.reply_count,
+        "created_at": e.thought.created_at,
+    })).collect::<Vec<_>>();
+
+    let users = users_result?.items.into_iter().map(|u| to_user_response(&u)).collect::<Vec<_>>();
+
+    Ok(Json(serde_json::json!({
+        "query": query,
+        "thoughts": thoughts,
+        "users": users,
+    })))
+}
+
+pub async fn get_following_handler(State(s): State<AppState>, Path(username): Path<String>, Query(q): Query<PaginationQuery>) -> Result<Json<serde_json::Value>, ApiError> {
+    let user = get_user_by_username(&*s.users, &username).await?;
+    let page = PageParams { page: q.page(), per_page: q.per_page() };
+    let result = get_following(&*s.follows, &user.id, page).await?;
+    Ok(Json(serde_json::json!({ "total": result.total, "items": result.items.iter().map(to_user_response).collect::<Vec<_>>() })))
+}
+
+pub async fn get_followers_handler(State(s): State<AppState>, Path(username): Path<String>, Query(q): Query<PaginationQuery>) -> Result<Json<serde_json::Value>, ApiError> {
+    let user = get_user_by_username(&*s.users, &username).await?;
+    let page = PageParams { page: q.page(), per_page: q.per_page() };
+    let result = get_followers(&*s.follows, &user.id, page).await?;
+    Ok(Json(serde_json::json!({ "total": result.total, "items": result.items.iter().map(to_user_response).collect::<Vec<_>>() })))
+}

crates/presentation/src/handlers/mod.rs

@@ -0,0 +1,7 @@
+pub mod api_keys;
+pub mod auth;
+pub mod feed;
+pub mod notifications;
+pub mod social;
+pub mod thoughts;
+pub mod users;

crates/presentation/src/handlers/notifications.rs

@@ -0,0 +1,18 @@
+use axum::{extract::{Path, State}, http::StatusCode, Json};
+use uuid::Uuid;
+use domain::{models::feed::PageParams, value_objects::NotificationId};
+use crate::{errors::ApiError, extractors::AuthUser, state::AppState};
+
+pub async fn list_notifications(State(s): State<AppState>, AuthUser(uid): AuthUser) -> Result<Json<serde_json::Value>, ApiError> {
+    let page = PageParams { page: 1, per_page: 20 };
+    let result = s.notifications.list_for_user(&uid, &page).await?;
+    Ok(Json(serde_json::json!({ "total": result.total, "unread": result.items.iter().filter(|n| !n.read).count() })))
+}
+pub async fn mark_notification_read(State(s): State<AppState>, AuthUser(uid): AuthUser, Path(id): Path<Uuid>) -> Result<StatusCode, ApiError> {
+    s.notifications.mark_read(&NotificationId::from_uuid(id), &uid).await?;
+    Ok(StatusCode::NO_CONTENT)
+}
+pub async fn mark_all_read(State(s): State<AppState>, AuthUser(uid): AuthUser) -> Result<StatusCode, ApiError> {
+    s.notifications.mark_all_read(&uid).await?;
+    Ok(StatusCode::NO_CONTENT)
+}

crates/presentation/src/handlers/social.rs

@@ -0,0 +1,51 @@
+use axum::{extract::{Path, State}, http::StatusCode, Json};
+use uuid::Uuid;
+use api_types::requests::SetTopFriendsRequest;
+use application::use_cases::social::*;
+use application::use_cases::profile::{get_top_friends, set_top_friends, get_user_by_username};
+use domain::value_objects::{ThoughtId, UserId};
+use crate::{errors::ApiError, extractors::AuthUser, state::AppState};
+
+pub async fn post_like(State(s): State<AppState>, AuthUser(uid): AuthUser, Path(id): Path<Uuid>) -> Result<StatusCode, ApiError> {
+    like_thought(&*s.likes, &*s.events, &uid, &ThoughtId::from_uuid(id)).await?;
+    Ok(StatusCode::NO_CONTENT)
+}
+pub async fn delete_like(State(s): State<AppState>, AuthUser(uid): AuthUser, Path(id): Path<Uuid>) -> Result<StatusCode, ApiError> {
+    unlike_thought(&*s.likes, &*s.events, &uid, &ThoughtId::from_uuid(id)).await?;
+    Ok(StatusCode::NO_CONTENT)
+}
+pub async fn post_boost(State(s): State<AppState>, AuthUser(uid): AuthUser, Path(id): Path<Uuid>) -> Result<StatusCode, ApiError> {
+    boost_thought(&*s.boosts, &*s.events, &uid, &ThoughtId::from_uuid(id)).await?;
+    Ok(StatusCode::NO_CONTENT)
+}
+pub async fn delete_boost(State(s): State<AppState>, AuthUser(uid): AuthUser, Path(id): Path<Uuid>) -> Result<StatusCode, ApiError> {
+    unboost_thought(&*s.boosts, &*s.events, &uid, &ThoughtId::from_uuid(id)).await?;
+    Ok(StatusCode::NO_CONTENT)
+}
+pub async fn post_follow(State(s): State<AppState>, AuthUser(uid): AuthUser, Path(target): Path<Uuid>) -> Result<StatusCode, ApiError> {
+    follow_user(&*s.follows, &*s.events, &uid, &UserId::from_uuid(target)).await?;
+    Ok(StatusCode::NO_CONTENT)
+}
+pub async fn delete_follow(State(s): State<AppState>, AuthUser(uid): AuthUser, Path(target): Path<Uuid>) -> Result<StatusCode, ApiError> {
+    unfollow_user(&*s.follows, &*s.events, &uid, &UserId::from_uuid(target)).await?;
+    Ok(StatusCode::NO_CONTENT)
+}
+pub async fn post_block(State(s): State<AppState>, AuthUser(uid): AuthUser, Path(target): Path<Uuid>) -> Result<StatusCode, ApiError> {
+    block_user(&*s.blocks, &*s.events, &uid, &UserId::from_uuid(target)).await?;
+    Ok(StatusCode::NO_CONTENT)
+}
+pub async fn delete_block(State(s): State<AppState>, AuthUser(uid): AuthUser, Path(target): Path<Uuid>) -> Result<StatusCode, ApiError> {
+    unblock_user(&*s.blocks, &uid, &UserId::from_uuid(target)).await?;
+    Ok(StatusCode::NO_CONTENT)
+}
+pub async fn put_top_friends(State(s): State<AppState>, AuthUser(uid): AuthUser, Json(body): Json<SetTopFriendsRequest>) -> Result<StatusCode, ApiError> {
+    let ids: Vec<UserId> = body.friend_ids.into_iter().map(UserId::from_uuid).collect();
+    set_top_friends(&*s.top_friends, &uid, ids).await?;
+    Ok(StatusCode::NO_CONTENT)
+}
+pub async fn get_top_friends_handler(State(s): State<AppState>, Path(username): Path<String>) -> Result<Json<serde_json::Value>, ApiError> {
+    let user = get_user_by_username(&*s.users, &username).await?;
+    let friends = get_top_friends(&*s.top_friends, &user.id).await?;
+    let ids: Vec<Uuid> = friends.iter().map(|(tf, _)| tf.friend_id.as_uuid()).collect();
+    Ok(Json(serde_json::json!({ "top_friends": ids })))
+}

crates/presentation/src/handlers/thoughts.rs

@@ -0,0 +1,64 @@
+use axum::{extract::{Path, State}, http::StatusCode, response::IntoResponse, Json};
+use uuid::Uuid;
+use api_types::requests::{CreateThoughtRequest, EditThoughtRequest};
+use application::use_cases::thoughts::{create_thought, delete_thought, edit_thought, get_thought, get_thread, CreateThoughtInput};
+use domain::value_objects::ThoughtId;
+use crate::{errors::ApiError, extractors::{AuthUser, OptionalAuthUser}, handlers::auth::to_user_response, state::AppState};
+
+fn thought_to_json(t: &domain::models::thought::Thought, author: &domain::models::user::User, like_count: i64, boost_count: i64, reply_count: i64) -> serde_json::Value {
+    serde_json::json!({
+        "id": t.id.as_uuid(),
+        "content": t.content.as_str(),
+        "author": to_user_response(author),
+        "in_reply_to_id": t.in_reply_to_id.as_ref().map(|x| x.as_uuid()),
+        "visibility": t.visibility.as_str(),
+        "content_warning": t.content_warning,
+        "sensitive": t.sensitive,
+        "like_count": like_count,
+        "boost_count": boost_count,
+        "reply_count": reply_count,
+        "created_at": t.created_at,
+        "updated_at": t.updated_at,
+    })
+}
+
+pub async fn post_thought(State(s): State<AppState>, AuthUser(uid): AuthUser, Json(body): Json<CreateThoughtRequest>) -> Result<impl IntoResponse, ApiError> {
+    let in_reply_to = body.in_reply_to_id.map(ThoughtId::from_uuid);
+    let out = create_thought(&*s.thoughts, &*s.users, &*s.events, CreateThoughtInput {
+        user_id: uid.clone(),
+        content: body.content,
+        in_reply_to_id: in_reply_to,
+        visibility: body.visibility,
+        content_warning: body.content_warning,
+        sensitive: body.sensitive.unwrap_or(false),
+    }).await?;
+    let author = s.users.find_by_id(&uid).await?.ok_or(domain::errors::DomainError::NotFound)?;
+    Ok((StatusCode::CREATED, Json(thought_to_json(&out.thought, &author, 0, 0, 0))))
+}
+
+pub async fn get_thought_handler(State(s): State<AppState>, Path(id): Path<Uuid>, OptionalAuthUser(_viewer): OptionalAuthUser) -> Result<Json<serde_json::Value>, ApiError> {
+    let thought = get_thought(&*s.thoughts, &ThoughtId::from_uuid(id)).await?;
+    let author = s.users.find_by_id(&thought.user_id).await?.ok_or(domain::errors::DomainError::NotFound)?;
+    Ok(Json(thought_to_json(&thought, &author, 0, 0, 0)))
+}
+
+pub async fn delete_thought_handler(State(s): State<AppState>, AuthUser(uid): AuthUser, Path(id): Path<Uuid>) -> Result<StatusCode, ApiError> {
+    delete_thought(&*s.thoughts, &*s.events, &ThoughtId::from_uuid(id), &uid).await?;
+    Ok(StatusCode::NO_CONTENT)
+}
+
+pub async fn patch_thought(State(s): State<AppState>, AuthUser(uid): AuthUser, Path(id): Path<Uuid>, Json(body): Json<EditThoughtRequest>) -> Result<StatusCode, ApiError> {
+    edit_thought(&*s.thoughts, &*s.events, &ThoughtId::from_uuid(id), &uid, body.content).await?;
+    Ok(StatusCode::NO_CONTENT)
+}
+
+pub async fn get_thread_handler(State(s): State<AppState>, Path(id): Path<Uuid>) -> Result<Json<Vec<serde_json::Value>>, ApiError> {
+    let thoughts = get_thread(&*s.thoughts, &ThoughtId::from_uuid(id)).await?;
+    let mut items = Vec::new();
+    for t in &thoughts {
+        if let Ok(Some(author)) = s.users.find_by_id(&t.user_id).await {
+            items.push(thought_to_json(t, &author, 0, 0, 0));
+        }
+    }
+    Ok(Json(items))
+}

crates/presentation/src/handlers/users.rs

@@ -0,0 +1,15 @@
+use axum::{extract::{Path, State}, Json};
+use api_types::{requests::UpdateProfileRequest, responses::UserResponse};
+use application::use_cases::profile::{get_user_by_username, update_profile};
+use crate::{errors::ApiError, extractors::AuthUser, handlers::auth::to_user_response, state::AppState};
+
+pub async fn get_user(State(s): State<AppState>, Path(username): Path<String>) -> Result<Json<UserResponse>, ApiError> {
+    let user = get_user_by_username(&*s.users, &username).await?;
+    Ok(Json(to_user_response(&user)))
+}
+
+pub async fn patch_profile(State(s): State<AppState>, AuthUser(uid): AuthUser, Json(body): Json<UpdateProfileRequest>) -> Result<Json<UserResponse>, ApiError> {
+    update_profile(&*s.users, &uid, body.display_name, body.bio, body.avatar_url, body.header_url, body.custom_css).await?;
+    let user = s.users.find_by_id(&uid).await?.ok_or(domain::errors::DomainError::NotFound)?;
+    Ok(Json(to_user_response(&user)))
+}