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

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 shared_inbox_url: Option<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>,
}

struct ActorUrls {
    ap_id: Url,
    inbox_url: Url,
    shared_inbox_url: Option<Url>,
    outbox_url: Url,
    followers_url: Url,
    following_url: Url,
}

impl ActorUrls {
    fn build(base_url: &str, user_id: uuid::Uuid) -> Self {
        let ap_id = crate::urls::actor_url(base_url, user_id);
        Self {
            inbox_url: Url::parse(&format!("{}/inbox", &ap_id)).expect("valid url"),
            shared_inbox_url: Url::parse(&format!("{}/inbox", base_url)).ok(),
            outbox_url: Url::parse(&format!("{}/outbox", &ap_id)).expect("valid url"),
            followers_url: Url::parse(&format!("{}/followers", &ap_id)).expect("valid url"),
            following_url: Url::parse(&format!("{}/following", &ap_id)).expect("valid url"),
            ap_id,
        }
    }
}

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 ActorUrls {
        ap_id,
        inbox_url,
        shared_inbox_url,
        outbox_url,
        followers_url,
        following_url,
    } = ActorUrls::build(&data.base_url, user_id);

    Ok(DbActor {
        user_id,
        username: user.username,
        public_key_pem: public_key,
        private_key_pem: Some(private_key),
        inbox_url,
        shared_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 ActorUrls {
            ap_id,
            inbox_url,
            shared_inbox_url,
            outbox_url,
            followers_url,
            following_url,
        } = ActorUrls::build(&data.base_url, user_id);

        Ok(Some(DbActor {
            user_id,
            username: user.username,
            public_key_pem: public_key,
            private_key_pem: private_key,
            inbox_url,
            shared_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 shared_inbox_url = json.endpoints.as_ref().map(|e| e.shared_inbox.to_string());
        let actor = RemoteActor {
            url: json.id.inner().to_string(),
            handle: json.preferred_username.clone(),
            inbox_url: json.inbox.to_string(),
            shared_inbox_url,
            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 shared_inbox_url = json
            .endpoints
            .as_ref()
            .and_then(|e| Url::parse(e.shared_inbox.as_str()).ok());
        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,
            shared_inbox_url,
            outbox_url,
            followers_url,
            following_url,
            ap_id,
            last_refreshed_at: Utc::now(),
            bio: json.summary.clone(),
            avatar_url: json.icon.as_ref().map(|i| i.url.clone()),
            banner_url: json.image.as_ref().map(|i| i.url.clone()),
            also_known_as: json.also_known_as.into_iter().next(),
            profile_url: json.url.clone(),
            attachment: json
                .attachment
                .iter()
                .map(|f| crate::user::ApProfileField {
                    name: f.name.clone(),
                    value: f.value.clone(),
                })
                .collect(),
        })
    }
}

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;