feat: implement follow activity

Author: oknozor

.env

@@ -0,0 +1,2 @@
+# Only needed by sqlx to pick the database url
+DATABASE_URL="postgres://postgres:postgres@localhost/gill"

config.toml

@@ -1,4 +1,6 @@
 domain = "localhost:3000"
+debug = true
+port = 3000
 
 [database]
 host = "postgres"

crates/gill-api/src/api/user.rs

@@ -1,10 +1,10 @@
 use crate::error::AppError;
-use gill_settings::SETTINGS;
 use activitypub_federation::core::signatures::generate_actor_keypair;
 use axum::http::StatusCode;
 use axum::response::{IntoResponse, Response};
 use axum::{Extension, Json};
 use gill_db::user::{CreateSSHKey, CreateUser, User};
+use gill_settings::SETTINGS;
 use serde::{Deserialize, Serialize};
 use sqlx::PgPool;
 
@@ -19,16 +19,23 @@ pub async fn create(
     Json(user): Json<CreateUserDto>,
 ) -> Result<Response, AppError> {
     let keys = generate_actor_keypair()?;
-    println!("{:?}", SETTINGS);
+    let scheme = if gill_settings::debug_mod() {
+        "http://"
+    } else {
+        "https://"
+    };
+    let domain = &SETTINGS.domain;
+    let username = user.username;
+
     let user = CreateUser {
-        username: user.username.clone(),
-        email: user.email,
+        username: username.clone(),
+        email: Some(user.email),
         private_key: Some(keys.private_key),
         public_key: keys.public_key,
-        followers_url: format!("http://{}/apub/{}/followers", SETTINGS.domain, user.username),
-        outbox_url: format!("http://{}/apub/{}/outbox", SETTINGS.domain, user.username),
-        inbox_url: format!("http://{}/apub/{}/inbox", SETTINGS.domain, user.username),
-        activity_pub_id: format!("http://{}/apub/users/{}", SETTINGS.domain, user.username),
+        followers_url: format!("{scheme}{domain}/apub/{username}/followers"),
+        outbox_url: format!("{scheme}{domain}/apub/{username}/outbox"),
+        inbox_url: format!("{scheme}{domain}/apub/{username}/inbox"),
+        activity_pub_id: format!("{scheme}{domain}/apub/users/{username}"),
         domain: SETTINGS.domain.clone(),
         is_local: true,
     };

crates/gill-api/src/apub/activities/follow.rs

@@ -1,6 +1,7 @@
 use crate::apub::object::user::ApubUser;
 use crate::error::AppError;
 use crate::instance::InstanceHandle;
+
 use activitypub_federation::{core::object_id::ObjectId, data::Data, traits::ActivityHandler};
 use activitystreams_kinds::activity::FollowType;
 use axum::async_trait;
@@ -11,17 +12,17 @@ use url::Url;
 #[serde(rename_all = "camelCase")]
 pub struct Follow {
     id: Url,
-    pub actor: ObjectId<ApubUser>,
-    pub object: ObjectId<ApubUser>,
+    pub follower: ObjectId<ApubUser>,
+    pub followed: ObjectId<ApubUser>,
     r#type: FollowType,
 }
 
 impl Follow {
-    pub fn new(actor: ObjectId<ApubUser>, object: ObjectId<ApubUser>, id: Url) -> Follow {
+    pub fn new(follower: ObjectId<ApubUser>, followed: ObjectId<ApubUser>, id: Url) -> Follow {
         Follow {
             id,
-            actor,
-            object,
+            follower,
+            followed,
             r#type: Default::default(),
         }
     }
@@ -37,7 +38,7 @@ impl ActivityHandler for Follow {
     }
 
     fn actor(&self) -> &Url {
-        self.actor.inner()
+        self.follower.inner()
     }
 
     async fn verify(
@@ -53,8 +54,15 @@ impl ActivityHandler for Follow {
         data: &Data<Self::DataType>,
         _request_counter: &mut i32,
     ) -> Result<(), Self::Error> {
-        println!("Got APUB Follow event");
-        println!("{:?}", self);
+        let followed = ObjectId::<ApubUser>::new(self.followed)
+            .dereference_local(data)
+            .await?;
+
+        let follower = ObjectId::<ApubUser>::new(self.follower)
+            .dereference(data, data.local_instance(), &mut 0)
+            .await?;
+
+        followed.add_follower(follower.local_id(), data).await?;
         Ok(())
     }
 }

crates/gill-api/src/apub/mod.rs

@@ -1,4 +1,3 @@
-use std::string::ParseError;
 use crate::apub::object::user::{ApubUser, Person, PersonAcceptedActivities};
 use crate::error::AppError;
 use crate::instance::{Instance, InstanceHandle};
@@ -15,27 +14,28 @@ use axum::response::IntoResponse;
 use axum::routing::{get, post};
 use axum::{body, middleware, Extension, Json, Router};
 use http::{HeaderMap, Method, Request};
+
 use std::sync::Arc;
 use tower::ServiceBuilder;
 use tower_http::ServiceBuilderExt;
-use tracing::debug;
+
 use url::Url;
-use uuid::Uuid;
 
 pub mod activities;
 pub mod object;
 
 pub fn router(instance: Arc<Instance>) -> Router {
-    Router::new()
-        .route("/inbox", post(http_post_user_inbox))
-        // FIXME: the layer seems to apply to all route
-        // .layer(
-        //     ServiceBuilder::new()
-        //         .map_request_body(body::boxed)
-        //         .layer(middleware::from_fn(verify_request_payload)),
-        // )
-        .route("/users/:user_name", get(http_get_user))
-        .with_state(instance)
+    let public = Router::new().route("/users/:user_name", get(http_get_user));
+
+    let private = Router::new()
+        .route("/:user/inbox", post(http_post_user_inbox))
+        .layer(
+            ServiceBuilder::new()
+                .map_request_body(body::boxed)
+                .layer(middleware::from_fn(verify_request_payload)),
+        );
+
+    public.merge(private).with_state(instance)
 }
 
 async fn http_get_user(
@@ -51,7 +51,9 @@ async fn http_get_user(
         .into_apub(&data)
         .await;
 
-    Ok(ApubJson(WithContext::new_default(user?)))
+    let user = WithContext::new_default(user?);
+    println!("{:?}", user);
+    Ok(ApubJson(user))
 }
 
 async fn http_post_user_inbox(
@@ -73,4 +75,3 @@ async fn http_post_user_inbox(
     )
     .await
 }
-

crates/gill-api/src/apub/object/repository.rs

@@ -9,15 +9,23 @@ use activitypub_federation::{
     LocalInstance,
 };
 use activitystreams_kinds::actor::PersonType;
+use std::str::FromStr;
+
 use axum::async_trait;
-use gill_db::user::User;
+use gill_db::user::{CreateUser, User};
 use serde::{Deserialize, Serialize};
 use url::Url;
 use uuid::Uuid;
 
 #[derive(Debug, Clone)]
 pub struct ApubUser(User);
 
+impl From<User> for ApubUser {
+    fn from(user: User) -> Self {
+        ApubUser(user)
+    }
+}
+
 /// List of all activities which this actor can receive.
 #[derive(Deserialize, Serialize, Debug)]
 #[serde(untagged)]
@@ -32,14 +40,18 @@ pub struct Person {
     #[serde(rename = "type")]
     kind: PersonType,
     id: ObjectId<ApubUser>,
+    email: Option<String>,
+    username: String,
+    outbox: Url,
     inbox: Url,
+    domain: String,
+    followers: Url,
     public_key: PublicKey,
 }
 
 impl ApubUser {
     pub async fn followers(&self, instance: &InstanceHandle) -> Result<Vec<Url>, AppError> {
         let db = instance.database();
-
         let followers = self.0.get_followers(i64::MAX, 0, db).await?;
 
         let followers = followers
@@ -51,6 +63,16 @@ impl ApubUser {
         Ok(followers)
     }
 
+    pub async fn add_follower(
+        &self,
+        follower_id: i32,
+        instance: &InstanceHandle,
+    ) -> Result<(), AppError> {
+        let db = instance.database();
+        self.0.add_follower(follower_id, db).await?;
+        Ok(())
+    }
+
     pub fn followers_url(&self) -> Result<Url, AppError> {
         Url::parse(&self.0.followers_url).map_err(Into::into)
     }
@@ -59,6 +81,10 @@ impl ApubUser {
         &self.0.activity_pub_id
     }
 
+    pub fn local_id(&self) -> i32 {
+        self.0.id
+    }
+
     fn activity_pub_id_as_url(&self) -> Result<Url, AppError> {
         Ok(Url::parse(self.activity_pub_id())?)
     }
@@ -81,6 +107,10 @@ impl ApubUser {
         let activity_id = format!("https://{hostname}/activity/{uuid}", uuid = Uuid::new_v4());
         let activity_id = Url::parse(&activity_id)?;
         let follow = Follow::new(follower, following, activity_id);
+        tracing::debug!(
+            "Sending follow activity to user inboc {}",
+            other.shared_inbox_or_inbox()
+        );
         self.send(
             follow,
             vec![other.shared_inbox_or_inbox()],
@@ -126,16 +156,21 @@ impl ApubObject for ApubUser {
         data: &Self::DataType,
     ) -> Result<Option<Self>, Self::Error> {
         let db = data.database();
-        let user = User::by_activity_pub_id(object_id.as_str(), db).await.ok();
+        let user = User::by_activity_pub_id(object_id.as_str(), db).await?;
         Ok(user.map(ApubUser))
     }
 
     async fn into_apub(self, _data: &Self::DataType) -> Result<Self::ApubType, Self::Error> {
         Ok(Person {
             kind: Default::default(),
             id: ObjectId::new(self.activity_pub_id_as_url()?),
-            inbox: self.inbox(),
             public_key: self.public_key()?,
+            email: self.0.email,
+            username: self.0.username,
+            outbox: Url::parse(&self.0.outbox_url)?,
+            domain: self.0.domain,
+            inbox: Url::parse(&self.0.inbox_url)?,
+            followers: Url::parse(&self.0.followers_url)?,
         })
     }
 
@@ -156,7 +191,25 @@ impl ApubObject for ApubUser {
         let db = data.database();
         let id = Url::from(apub.id);
         let user = User::by_activity_pub_id(id.as_str(), db).await?;
-        Ok(ApubUser(user))
+        if let Some(user) = user {
+            Ok(ApubUser(user))
+        } else {
+            let user = CreateUser {
+                username: apub.username,
+                email: apub.email,
+                private_key: None,
+                public_key: apub.public_key.public_key_pem,
+                activity_pub_id: id.to_string(),
+                outbox_url: apub.outbox.to_string(),
+                inbox_url: apub.inbox.to_string(),
+                domain: apub.domain,
+                followers_url: apub.followers.to_string(),
+                is_local: false,
+            };
+
+            let user = User::create(user, db).await?;
+            Ok(ApubUser(user))
+        }
     }
 }
 
@@ -165,6 +218,6 @@ impl Actor for ApubUser {
         &self.0.public_key
     }
     fn inbox(&self) -> Url {
-        self.activity_pub_id_as_url().expect("Invalid inbox url")
+        Url::from_str(&self.0.inbox_url).expect("Invalid inbox url")
     }
 }

crates/gill-api/src/apub/object/user.rs

@@ -24,6 +24,3 @@ impl AppError {
         (StatusCode::NOT_FOUND, format!("{}", self.0)).into_response()
     }
 }
-
-
-

crates/gill-api/src/error.rs

@@ -1,23 +1,14 @@
-
 use crate::error::AppError;
 use crate::oauth::{oauth_client, AppState};
 use crate::{api, apub, view};
 
-
-
-
-use activitypub_federation::{
-    InstanceSettings, LocalInstance, UrlVerifier,
-};
+use activitypub_federation::{InstanceSettings, LocalInstance, UrlVerifier};
 use async_session::MemoryStore;
 use axum::async_trait;
 
-
-
-
 use axum::response::IntoResponse;
 
-
+use axum::routing::get;
 use axum::{Extension, Router};
 use gill_ipc::listener::IPCListener;
 use http::StatusCode;
@@ -30,9 +21,8 @@ use std::sync::Arc;
 use tower_http::services::ServeDir;
 use tower_http::trace::TraceLayer;
 
-
-use url::Url;
 use gill_settings::SETTINGS;
+use url::Url;
 
 use crate::syntax::{load_syntax, load_theme};
 
@@ -95,13 +85,17 @@ impl Instance {
             oauth_client,
             syntax_set,
             theme,
-            instance: instance.clone()
+            instance: instance.clone(),
         };
 
         let app = Router::new()
+            .route(
+                "/.well-known/webfinger",
+                get(crate::webfinger::webfinger).with_state(app_state.clone()),
+            )
             .nest("/api/v1/", api::router())
             .nest_service("/apub", apub::router(instance))
-            .nest_service("/", view::router(app_state))
+            .nest_service("/", view::router(app_state.clone()))
             .nest_service("/assets/", serve_dir)
             .layer(TraceLayer::new_for_http())
             .layer(Extension(db))

crates/gill-api/src/instance.rs

@@ -1,8 +1,8 @@
 pub mod api;
 pub mod apub;
-pub mod webfinger;
 pub mod error;
 pub mod instance;
 pub mod oauth;
 pub mod syntax;
-pub mod view;
+pub mod view;
+pub mod webfinger;