Revert Object trait id() ref

Version 0.7.0-beta.11
Add a public-aware deserializer for recipient URLs (#165 )
2026-04-25 22:40:47 -07:00 · 2026-04-24 11:31:10 +02:00 · 2026-04-24 11:25:06 +02:00 · 2026-04-15 13:39:03 +02:00 · 2026-04-15 13:38:29 +02:00 · 2026-03-16 11:39:46 +01:00
44 changed files with 4200 additions and 625 deletions
--- a/.gitignore
+++ b/.gitignore
@ -1,6 +1,5 @@
 /target
 /.idea
-/Cargo.lock
 perf.data*
 flamegraph.svg

--- a/.rustfmt.toml
+++ b/.rustfmt.toml
@ -1,4 +1,4 @@
-edition="2021"
-imports_layout="HorizontalVertical"
-imports_granularity="Crate"
-reorder_imports=true
+edition = "2021"
+imports_layout = "HorizontalVertical"
+imports_granularity = "Crate"
+reorder_imports = true
--- a/.woodpecker.yml
+++ b/.woodpecker.yml
@ -1,5 +1,5 @@
 variables:
-  - &rust_image "rust:1.82-bullseye"
+  - &rust_image "rust:1.91-bullseye"

 steps:
  cargo_fmt:
--- a/Cargo.lock
+++ b/Cargo.lock
--- a/Cargo.toml
+++ b/Cargo.toml
@ -1,6 +1,6 @@
 [package]
 name = "activitypub_federation"
-version = "0.6.4"
+version = "0.7.0-beta.11"
 edition = "2021"
 description = "High-level Activitypub framework"
 keywords = ["activitypub", "activitystreams", "federation", "fediverse"]
@ -12,11 +12,7 @@ documentation = "https://docs.rs/activitypub_federation/"
 default = ["actix-web", "axum"]
 actix-web = ["dep:actix-web", "dep:http02"]
 axum = ["dep:axum", "dep:tower"]
-diesel = ["dep:diesel"]
-
-[lints.rust]
-warnings = "deny"
-deprecated = "deny"
+axum-original-uri = ["dep:axum", "axum/original-uri"]

 [lints.clippy]
 perf = { level = "deny", priority = -1 }
@ -32,71 +28,71 @@ redundant_closure_for_method_calls = "deny"
 unwrap_used = "deny"

 [dependencies]
-chrono = { version = "0.4.38", features = ["clock"], default-features = false }
-serde = { version = "1.0.204", features = ["derive"] }
-async-trait = "0.1.81"
-url = { version = "2.5.2", features = ["serde"] }
-serde_json = { version = "1.0.120", features = ["preserve_order"] }
-reqwest = { version = "0.12.5", default-features = false, features = [
+chrono = { version = "0.4.42", features = ["clock"], default-features = false }
+serde = { version = "1.0.228", features = ["derive"] }
+async-trait = "0.1.89"
+url = { version = "2.5.8", features = ["serde"] }
+serde_json = { version = "1.0.149", features = ["preserve_order"] }
+reqwest = { version = "0.13.1", default-features = false, features = [
  "json",
  "stream",
-  "rustls-tls",
 ] }
-reqwest-middleware = "0.3.2"
-tracing = "0.1.40"
+reqwest-middleware = "0.5.0"
+tracing = "0.1.44"
 base64 = "0.22.1"
 rand = "0.8.5"
-rsa = "0.9.6"
-once_cell = "1.19.0"
-http = "1.1.0"
-sha2 = { version = "0.10.8", features = ["oid"] }
-thiserror = "1.0.62"
-derive_builder = "0.20.0"
-itertools = "0.13.0"
-dyn-clone = "1.0.17"
+rsa = "0.9.10"
+http = "1.4.0"
+sha2 = { version = "0.10.9", features = ["oid"] }
+thiserror = "2.0.17"
+derive_builder = "0.20.2"
+itertools = "0.14.0"
+dyn-clone = "1.0.20"
 enum_delegate = "0.2.0"
 httpdate = "1.0.3"
-http-signature-normalization-reqwest = { version = "0.12.0", default-features = false, features = [
+http-signature-normalization-reqwest = { version = "0.14.0", default-features = false, features = [
  "sha-2",
  "middleware",
  "default-spawner",
 ] }
 http-signature-normalization = "0.7.0"
-bytes = "1.6.1"
-futures-core = { version = "0.3.30", default-features = false }
-pin-project-lite = "0.2.14"
+bytes = "1.11.0"
+futures-core = { version = "0.3.31", default-features = false }
+pin-project-lite = "0.2.16"
 activitystreams-kinds = "0.3.0"
-regex = { version = "1.10.5", default-features = false, features = [
+regex = { version = "1.12.2", default-features = false, features = [
  "std",
  "unicode",
 ] }
-tokio = { version = "1.38.0", features = [
+tokio = { version = "1.49.0", features = [
  "sync",
  "rt",
  "rt-multi-thread",
  "time",
 ] }
-diesel = { version = "2.2.1", features = [
-  "postgres",
-], default-features = false, optional = true }
-futures = "0.3.30"
-moka = { version = "0.12.8", features = ["future"] }
+futures = "0.3.31"
+moka = { version = "0.12.12", features = ["future"] }
 either = "1.15.0"

 # Actix-web
-actix-web = { version = "4.8.0", default-features = false, optional = true }
+actix-web = { version = "4.12.1", default-features = false, optional = true }
 http02 = { package = "http", version = "0.2.12", optional = true }

 # Axum
-axum = { version = "0.7.5", features = ["json"], default-features = false, optional = true }
-tower = { version = "0.4.13", optional = true }
+axum = { version = "0.8.8", features = [
+  "json",
+], default-features = false, optional = true }
+tower = { version = "0.5.2", optional = true }

 [dev-dependencies]
-anyhow = "1.0.86"
-axum = { version = "0.7.5", features = ["macros"] }
-axum-extra = { version = "0.9.3", features = ["typed-header"] }
-env_logger = "0.11.3"
-tokio = { version = "1.38.0", features = ["full"] }
+anyhow = "1.0.100"
+axum = { version = "0.8.8", features = ["macros"] }
+axum-extra = { version = "0.12.5", features = ["typed-header"] }
+env_logger = "0.11.8"
+tokio = { version = "1.49.0", features = ["full"] }
+reqwest = { version = "0.13.1",features = [
+  "rustls"
+] }

 [profile.dev]
 strip = "symbols"
--- a/docs/07_fetching_data.md
+++ b/docs/07_fetching_data.md
@ -39,4 +39,4 @@ let user: DbUser = webfinger_resolve_actor("ruud@lemmy.world", &data).await?;
 # }).unwrap();
 ```

-Note that webfinger queries don't contain a leading `@`. It is possible tha there are multiple Activitypub IDs returned for a single webfinger query in case of multiple actors with the same name (for example Lemmy permits group and person with the same name). In this case `webfinger_resolve_actor` automatically loops and returns the first item which can be dereferenced successfully to the given type.
+Note that webfinger queries don't contain a leading `@`. It is possible that there are multiple Activitypub IDs returned for a single webfinger query in case of multiple actors with the same name (for example Lemmy permits group and person with the same name). In this case `webfinger_resolve_actor` automatically loops and returns the first item which can be dereferenced successfully to the given type.
--- a/docs/08_receiving_activities.md
+++ b/docs/08_receiving_activities.md
@ -1,6 +1,6 @@
 ## Sending and receiving activities

-Activitypub propagates actions across servers using `Activities`. For this each actor has an inbox and a public/private key pair. We already defined a `Person` actor with keypair. Whats left is to define an activity. This is similar to the way we defined `Person` and `Note` structs before. In this case we need to implement the [ActivityHandler](trait@crate::traits::ActivityHandler) trait.
+Activitypub propagates actions across servers using `Activities`. For this each actor has an inbox and a public/private key pair. We already defined a `Person` actor with keypair. Whats left is to define an activity. This is similar to the way we defined `Person` and `Note` structs before. In this case we need to implement the [Activity](trait@crate::traits::Activity) trait.

 ```
 # use serde::{Deserialize, Serialize};
@ -10,7 +10,7 @@ Activitypub propagates actions across servers using `Activities`. For this each
 # use activitypub_federation::fetch::object_id::ObjectId;
 # use activitypub_federation::traits::tests::{DbConnection, DbUser};
 # use activitystreams_kinds::activity::FollowType;
-# use activitypub_federation::traits::ActivityHandler;
+# use activitypub_federation::traits::Activity;
 # use activitypub_federation::config::Data;
 # async fn send_accept() -> Result<(), Error> { Ok(()) }

@ -25,7 +25,7 @@ pub struct Follow {
 }

 #[async_trait]
-impl ActivityHandler for Follow {
+impl Activity for Follow {
    type DataType = DbConnection;
    type Error = Error;

@ -59,14 +59,14 @@ Next its time to setup the actual HTTP handler for the inbox. For this we first
 # use activitypub_federation::axum::inbox::{ActivityData, receive_activity};
 # use activitypub_federation::config::Data;
 # use activitypub_federation::protocol::context::WithContext;
-# use activitypub_federation::traits::ActivityHandler;
+# use activitypub_federation::traits::Activity;
 # use activitypub_federation::traits::tests::{DbConnection, DbUser, Follow};
 # use serde::{Deserialize, Serialize};
 # use url::Url;

 #[derive(Deserialize, Serialize, Debug)]
 #[serde(untagged)]
-#[enum_delegate::implement(ActivityHandler)]
+#[enum_delegate::implement(Activity)]
 pub enum PersonAcceptedActivities {
    Follow(Follow),
 }
--- a/docs/10_fetching_objects_with_unknown_type.md
+++ b/docs/10_fetching_objects_with_unknown_type.md
@ -32,6 +32,13 @@ impl Object for SearchableDbObjects {
    type Kind = SearchableObjects;
    type Error = anyhow::Error;

+    fn id(&self) -> Url {
+        match self {
+            SearchableDbObjects::User(p) => p.federation_id.clone(),
+            SearchableDbObjects::Post(n) => n.federation_id.clone(),
+        }
+    }
+
    async fn read_from_id(
        object_id: Url,
        data: &Data<Self::DataType>,
--- a/examples/live_federation/activities/create_post.rs
+++ b/examples/live_federation/activities/create_post.rs
@ -11,7 +11,7 @@ use activitypub_federation::{
    fetch::object_id::ObjectId,
    kinds::activity::CreateType,
    protocol::{context::WithContext, helpers::deserialize_one_or_many},
-    traits::{ActivityHandler, Object},
+    traits::{Activity, Object},
 };
 use serde::{Deserialize, Serialize};
 use url::Url;
@ -50,7 +50,7 @@ impl CreatePost {
 }

 #[async_trait::async_trait]
-impl ActivityHandler for CreatePost {
+impl Activity for CreatePost {
    type DataType = DatabaseHandle;
    type Error = crate::error::Error;

--- a/examples/live_federation/main.rs
+++ b/examples/live_federation/main.rs
@ -55,8 +55,8 @@ async fn main() -> Result<(), Error> {
    info!("Listen with HTTP server on {BIND_ADDRESS}");
    let config = config.clone();
    let app = Router::new()
-        .route("/:user", get(http_get_user))
-        .route("/:user/inbox", post(http_post_user_inbox))
+        .route("/{user}", get(http_get_user))
+        .route("/{user}/inbox", post(http_post_user_inbox))
        .route("/.well-known/webfinger", get(webfinger))
        .layer(FederationMiddleware::new(config));

--- a/examples/live_federation/objects/person.rs
+++ b/examples/live_federation/objects/person.rs
@ -5,7 +5,7 @@ use activitypub_federation::{
    http_signatures::generate_actor_keypair,
    kinds::actor::PersonType,
    protocol::{public_key::PublicKey, verification::verify_domains_match},
-    traits::{ActivityHandler, Actor, Object},
+    traits::{Activity, Actor, Object},
 };
 use chrono::{DateTime, Utc};
 use serde::{Deserialize, Serialize};
@ -29,7 +29,7 @@ pub struct DbUser {
 /// List of all activities which this actor can receive.
 #[derive(Deserialize, Serialize, Debug)]
 #[serde(untagged)]
-#[enum_delegate::implement(ActivityHandler)]
+#[enum_delegate::implement(Activity)]
 pub enum PersonAcceptedActivities {
    CreateNote(CreatePost),
 }
@ -69,6 +69,10 @@ impl Object for DbUser {
    type Kind = Person;
    type Error = Error;

+    fn id(&self) -> Url {
+        self.ap_id.inner().clone()
+    }
+
    fn last_refreshed_at(&self) -> Option<DateTime<Utc>> {
        Some(self.last_refreshed_at)
    }
@ -122,10 +126,6 @@ impl Object for DbUser {
 }

 impl Actor for DbUser {
-    fn id(&self) -> Url {
-        self.ap_id.inner().clone()
-    }
-
    fn public_key_pem(&self) -> &str {
        &self.public_key
    }
--- a/examples/live_federation/objects/post.rs
+++ b/examples/live_federation/objects/post.rs
@ -50,6 +50,10 @@ impl Object for DbPost {
    type Kind = Note;
    type Error = Error;

+    fn id(&self) -> Url {
+        self.ap_id.inner().clone()
+    }
+
    async fn read_from_id(
        _object_id: Url,
        _data: &Data<Self::DataType>,
--- a/examples/local_federation/activities/accept.rs
+++ b/examples/local_federation/activities/accept.rs
@ -3,7 +3,7 @@ use activitypub_federation::{
    config::Data,
    fetch::object_id::ObjectId,
    kinds::activity::AcceptType,
-    traits::ActivityHandler,
+    traits::Activity,
 };
 use serde::{Deserialize, Serialize};
 use url::Url;
@ -30,7 +30,7 @@ impl Accept {
 }

 #[async_trait::async_trait]
-impl ActivityHandler for Accept {
+impl Activity for Accept {
    type DataType = DatabaseHandle;
    type Error = crate::error::Error;

--- a/examples/local_federation/activities/create_post.rs
+++ b/examples/local_federation/activities/create_post.rs
@ -8,7 +8,7 @@ use activitypub_federation::{
    fetch::object_id::ObjectId,
    kinds::activity::CreateType,
    protocol::helpers::deserialize_one_or_many,
-    traits::{ActivityHandler, Object},
+    traits::{Activity, Object},
 };
 use serde::{Deserialize, Serialize};
 use url::Url;
@ -38,7 +38,7 @@ impl CreatePost {
 }

 #[async_trait::async_trait]
-impl ActivityHandler for CreatePost {
+impl Activity for CreatePost {
    type DataType = DatabaseHandle;
    type Error = crate::error::Error;

--- a/examples/local_federation/activities/follow.rs
+++ b/examples/local_federation/activities/follow.rs
@ -8,7 +8,7 @@ use activitypub_federation::{
    config::Data,
    fetch::object_id::ObjectId,
    kinds::activity::FollowType,
-    traits::{ActivityHandler, Actor},
+    traits::{Activity, Actor},
 };
 use serde::{Deserialize, Serialize};
 use url::Url;
@ -35,7 +35,7 @@ impl Follow {
 }

 #[async_trait::async_trait]
-impl ActivityHandler for Follow {
+impl Activity for Follow {
    type DataType = DatabaseHandle;
    type Error = crate::error::Error;

--- a/examples/local_federation/actix_web/http.rs
+++ b/examples/local_federation/actix_web/http.rs
@ -8,7 +8,7 @@ use activitypub_federation::{
    config::{Data, FederationConfig, FederationMiddleware},
    fetch::webfinger::{build_webfinger_response, extract_webfinger_name},
    protocol::context::WithContext,
-    traits::{Actor, Object},
+    traits::Object,
    FEDERATION_CONTENT_TYPE,
 };
 use actix_web::{web, web::Bytes, App, HttpRequest, HttpResponse, HttpServer};
--- a/examples/local_federation/axum/http.rs
+++ b/examples/local_federation/axum/http.rs
@ -29,9 +29,10 @@ pub fn listen(config: &FederationConfig<DatabaseHandle>) -> Result<(), Error> {
    let hostname = config.domain();
    info!("Listening with axum on {hostname}");
    let config = config.clone();
+
    let app = Router::new()
-        .route("/:user/inbox", post(http_post_user_inbox))
-        .route("/:user", get(http_get_user))
+        .route("/{user}/inbox", post(http_post_user_inbox))
+        .route("/{user}", get(http_get_user))
        .route("/.well-known/webfinger", get(webfinger))
        .layer(FederationMiddleware::new(config));

--- a/examples/local_federation/objects/person.rs
+++ b/examples/local_federation/objects/person.rs
@ -13,7 +13,7 @@ use activitypub_federation::{
    http_signatures::generate_actor_keypair,
    kinds::actor::PersonType,
    protocol::{context::WithContext, public_key::PublicKey, verification::verify_domains_match},
-    traits::{ActivityHandler, Actor, Object},
+    traits::{Activity, Actor, Object},
 };
 use chrono::{DateTime, Utc};
 use serde::{Deserialize, Serialize};
@ -37,7 +37,7 @@ pub struct DbUser {
 /// List of all activities which this actor can receive.
 #[derive(Deserialize, Serialize, Debug)]
 #[serde(untagged)]
-#[enum_delegate::implement(ActivityHandler)]
+#[enum_delegate::implement(Activity)]
 pub enum PersonAcceptedActivities {
    Follow(Follow),
    Accept(Accept),
@ -103,16 +103,16 @@ impl DbUser {
        Ok(())
    }

-    pub(crate) async fn send<Activity>(
+    pub(crate) async fn send<A>(
        &self,
-        activity: Activity,
+        activity: A,
        recipients: Vec<Url>,
        use_queue: bool,
        data: &Data<DatabaseHandle>,
    ) -> Result<(), Error>
    where
-        Activity: ActivityHandler + Serialize + Debug + Send + Sync,
-        <Activity as ActivityHandler>::Error: From<anyhow::Error> + From<serde_json::Error>,
+        A: Activity + Serialize + Debug + Send + Sync,
+        <A as Activity>::Error: From<anyhow::Error> + From<serde_json::Error>,
    {
        let activity = WithContext::new_default(activity);
        // Send through queue in some cases and bypass it in others to test both code paths
@ -134,6 +134,10 @@ impl Object for DbUser {
    type Kind = Person;
    type Error = Error;

+    fn id(&self) -> Url {
+        self.ap_id.inner().clone()
+    }
+
    fn last_refreshed_at(&self) -> Option<DateTime<Utc>> {
        Some(self.last_refreshed_at)
    }
@ -187,10 +191,6 @@ impl Object for DbUser {
 }

 impl Actor for DbUser {
-    fn id(&self) -> Url {
-        self.ap_id.inner().clone()
-    }
-
    fn public_key_pem(&self) -> &str {
        &self.public_key
    }
--- a/examples/local_federation/objects/post.rs
+++ b/examples/local_federation/objects/post.rs
@ -47,6 +47,10 @@ impl Object for DbPost {
    type Kind = Note;
    type Error = Error;

+    fn id(&self) -> Url {
+        self.ap_id.inner().clone()
+    }
+
    async fn read_from_id(
        object_id: Url,
        data: &Data<Self::DataType>,
--- a/src/activity_queue.rs
+++ b/src/activity_queue.rs
@ -6,7 +6,7 @@ use crate::{
    activity_sending::{build_tasks, SendActivityTask},
    config::Data,
    error::Error,
-    traits::{ActivityHandler, Actor},
+    traits::{Activity, Actor},
 };

 use futures_core::Future;
@ -37,14 +37,14 @@ use url::Url;
 /// - `inboxes`: List of remote actor inboxes that should receive the activity. Ignores local actor
 ///   inboxes. Should be built by calling [crate::traits::Actor::shared_inbox_or_inbox]
 ///   for each target actor.
-pub async fn queue_activity<Activity, Datatype, ActorType>(
-    activity: &Activity,
+pub async fn queue_activity<A, Datatype, ActorType>(
+    activity: &A,
    actor: &ActorType,
    inboxes: Vec<Url>,
    data: &Data<Datatype>,
 ) -> Result<(), Error>
 where
-    Activity: ActivityHandler + Serialize + Debug,
+    A: Activity + Serialize + Debug,
    Datatype: Clone,
    ActorType: Actor,
 {
--- a/src/activity_sending.rs
+++ b/src/activity_sending.rs
@ -7,7 +7,7 @@ use crate::{
    error::Error,
    http_signatures::sign_request,
    reqwest_shim::ResponseExt,
-    traits::{ActivityHandler, Actor},
+    traits::{Activity, Actor},
    FEDERATION_CONTENT_TYPE,
 };
 use bytes::Bytes;
@ -54,14 +54,14 @@ impl SendActivityTask {
    /// - `inboxes`: List of remote actor inboxes that should receive the activity. Ignores local actor
    ///   inboxes. Should be built by calling [crate::traits::Actor::shared_inbox_or_inbox]
    ///   for each target actor.
-    pub async fn prepare<Activity, Datatype, ActorType>(
-        activity: &Activity,
+    pub async fn prepare<A, Datatype, ActorType>(
+        activity: &A,
        actor: &ActorType,
        inboxes: Vec<Url>,
        data: &Data<Datatype>,
    ) -> Result<Vec<SendActivityTask>, Error>
    where
-        Activity: ActivityHandler + Serialize + Debug,
+        A: Activity + Serialize + Debug,
        Datatype: Clone,
        ActorType: Actor,
    {
@ -136,14 +136,14 @@ impl SendActivityTask {
    }
 }

-pub(crate) async fn build_tasks<Activity, Datatype, ActorType>(
-    activity: &Activity,
+pub(crate) async fn build_tasks<A, Datatype, ActorType>(
+    activity: &A,
    actor: &ActorType,
    inboxes: Vec<Url>,
    data: &Data<Datatype>,
 ) -> Result<Vec<SendActivityTask>, Error>
 where
-    Activity: ActivityHandler + Serialize + Debug,
+    A: Activity + Serialize + Debug,
    Datatype: Clone,
    ActorType: Actor,
 {
--- a/src/actix_web/inbox.rs
+++ b/src/actix_web/inbox.rs
@ -6,7 +6,7 @@ use crate::{
    error::Error,
    http_signatures::{verify_body_hash, verify_signature},
    parse_received_activity,
-    traits::{ActivityHandler, Actor, Object},
+    traits::{Activity, Actor, Object},
 };
 use actix_web::{web::Bytes, HttpRequest, HttpResponse};
 use serde::de::DeserializeOwned;
@ -14,17 +14,77 @@ use tracing::debug;

 /// Handles incoming activities, verifying HTTP signatures and other checks
 ///
-/// After successful validation, activities are passed to respective [trait@ActivityHandler].
-pub async fn receive_activity<Activity, ActorT, Datatype>(
+/// After successful validation, activities are passed to respective [trait@Activity].
+pub async fn receive_activity<A, ActorT, Datatype>(
    request: HttpRequest,
    body: Bytes,
    data: &Data<Datatype>,
-) -> Result<HttpResponse, <Activity as ActivityHandler>::Error>
+) -> Result<HttpResponse, <A as Activity>::Error>
 where
-    Activity: ActivityHandler<DataType = Datatype> + DeserializeOwned + Send + 'static,
-    ActorT: Object<DataType = Datatype> + Actor + Send + 'static,
+    A: Activity<DataType = Datatype> + DeserializeOwned + Send + 'static,
+    ActorT: Object<DataType = Datatype> + Actor + Send + Sync + 'static,
    for<'de2> <ActorT as Object>::Kind: serde::Deserialize<'de2>,
-    <Activity as ActivityHandler>::Error: From<Error> + From<<ActorT as Object>::Error>,
+    <A as Activity>::Error: From<Error> + From<<ActorT as Object>::Error>,
+    <ActorT as Object>::Error: From<Error>,
+    Datatype: Clone,
+{
+    let (activity, _) = do_stuff::<A, ActorT, Datatype>(request, body, data).await?;
+
+    do_more_stuff(activity, data).await
+}
+
+/// Workaround required so we can use references for the hook, instead of cloning data.
+pub trait ReceiveActivityHook<A, ActorT, Datatype>
+where
+    A: Activity<DataType = Datatype> + DeserializeOwned + Send + Clone + 'static,
+    ActorT: Object<DataType = Datatype> + Actor + Send + Clone + 'static,
+    for<'de2> <ActorT as Object>::Kind: serde::Deserialize<'de2>,
+    <A as Activity>::Error: From<Error> + From<<ActorT as Object>::Error>,
+    <ActorT as Object>::Error: From<Error>,
+    Datatype: Clone,
+{
+    /// Called when a new activity is recived
+    fn hook(
+        self,
+        activity: &A,
+        actor: &ActorT,
+        data: &Data<Datatype>,
+    ) -> impl std::future::Future<Output = Result<(), <A as Activity>::Error>>;
+}
+
+/// Same as [receive_activity], only that it calls the provided hook function before
+/// calling activity verify and receive functions.
+pub async fn receive_activity_with_hook<A, ActorT, Datatype>(
+    request: HttpRequest,
+    body: Bytes,
+    hook: impl ReceiveActivityHook<A, ActorT, Datatype>,
+    data: &Data<Datatype>,
+) -> Result<HttpResponse, <A as Activity>::Error>
+where
+    A: Activity<DataType = Datatype> + DeserializeOwned + Send + Clone + 'static,
+    ActorT: Object<DataType = Datatype> + Actor + Send + Sync + Clone + 'static,
+    for<'de2> <ActorT as Object>::Kind: serde::Deserialize<'de2>,
+    <A as Activity>::Error: From<Error> + From<<ActorT as Object>::Error>,
+    <ActorT as Object>::Error: From<Error>,
+    Datatype: Clone,
+{
+    let (activity, actor) = do_stuff::<A, ActorT, Datatype>(request, body, data).await?;
+
+    hook.hook(&activity, &actor, data).await?;
+
+    do_more_stuff(activity, data).await
+}
+
+async fn do_stuff<A, ActorT, Datatype>(
+    request: HttpRequest,
+    body: Bytes,
+    data: &Data<Datatype>,
+) -> Result<(A, ActorT), <A as Activity>::Error>
+where
+    A: Activity<DataType = Datatype> + DeserializeOwned + Send + 'static,
+    ActorT: Object<DataType = Datatype> + Actor + Send + Sync + 'static,
+    for<'de2> <ActorT as Object>::Kind: serde::Deserialize<'de2>,
+    <A as Activity>::Error: From<Error> + From<<ActorT as Object>::Error>,
    <ActorT as Object>::Error: From<Error>,
    Datatype: Clone,
 {
@ -34,13 +94,24 @@ where
        .map(http_compat::header_value);
    verify_body_hash(digest_header.as_ref(), &body)?;

-    let (activity, actor) = parse_received_activity::<Activity, ActorT, _>(&body, data).await?;
+    let (activity, actor) = parse_received_activity::<A, ActorT, _>(&body, data).await?;

    let headers = http_compat::header_map(request.headers());
    let method = http_compat::method(request.method());
    let uri = http_compat::uri(request.uri());
    verify_signature(&headers, &method, &uri, actor.public_key_pem())?;

+    Ok((activity, actor))
+}
+
+async fn do_more_stuff<A, Datatype>(
+    activity: A,
+    data: &Data<Datatype>,
+) -> Result<HttpResponse, <A as Activity>::Error>
+where
+    A: Activity<DataType = Datatype> + DeserializeOwned + Send + 'static,
+    Datatype: Clone,
+{
    debug!("Receiving activity {}", activity.id().to_string());
    activity.verify(data).await?;
    activity.receive(data).await?;
@ -75,15 +146,38 @@ mod test {
    }

    #[tokio::test]
-    async fn test_receive_activity() {
+    async fn test_receive_activity_hook() {
        let (body, incoming_request, config) = setup_receive_test().await;
-        receive_activity::<Follow, DbUser, DbConnection>(
+        let res = receive_activity_with_hook::<Follow, DbUser, DbConnection>(
            incoming_request.to_http_request(),
            body,
+            Dummy,
            &config.to_request_data(),
        )
-        .await
-        .unwrap();
+        .await;
+        assert_eq!(res.err(), Some(Error::Other("test-error".to_string())));
+    }
+
+    struct Dummy;
+
+    impl<A, ActorT, Datatype> ReceiveActivityHook<A, ActorT, Datatype> for Dummy
+    where
+        A: Activity<DataType = Datatype> + DeserializeOwned + Send + Clone + 'static,
+        ActorT: Object<DataType = Datatype> + Actor + Send + Clone + 'static,
+        for<'de2> <ActorT as Object>::Kind: serde::Deserialize<'de2>,
+        <A as Activity>::Error: From<Error> + From<<ActorT as Object>::Error>,
+        <ActorT as Object>::Error: From<Error>,
+        Datatype: Clone,
+    {
+        async fn hook(
+            self,
+            _activity: &A,
+            _actor: &ActorT,
+            _data: &Data<Datatype>,
+        ) -> Result<(), <A as Activity>::Error> {
+            // ensure that hook gets called by returning this value
+            Err(Error::Other("test-error".to_string()).into())
+        }
    }

    #[tokio::test]
@ -122,14 +216,14 @@ mod test {
        let (_, _, config) = setup_receive_test().await;

        let actor = Url::parse("http://ds9.lemmy.ml/u/lemmy_alpha").unwrap();
-        let id = "http://localhost:123/1";
+        let activity_id = "http://localhost:123/1";
        let activity = json!({
          "actor": actor.as_str(),
          "to": ["https://www.w3.org/ns/activitystreams#Public"],
          "object": "http://ds9.lemmy.ml/post/1",
          "cc": ["http://enterprise.lemmy.ml/c/main"],
          "type": "Delete",
-          "id": id
+          "id": activity_id
        }
        );
        let body: Bytes = serde_json::to_vec(&activity).unwrap().into();
@ -144,8 +238,8 @@ mod test {
        .await;

        match res {
-            Err(Error::ParseReceivedActivity(_, url)) => {
-                assert_eq!(id, url.expect("has url").as_str());
+            Err(Error::ParseReceivedActivity { err: _, id }) => {
+                assert_eq!(activity_id, id.expect("has url").as_str());
            }
            _ => unreachable!(),
        }
--- a/src/actix_web/mod.rs
+++ b/src/actix_web/mod.rs
@ -4,6 +4,7 @@ mod http_compat;
 pub mod inbox;
 #[doc(hidden)]
 pub mod middleware;
+pub mod response;

 use crate::{
    config::Data,
@ -22,7 +23,7 @@ pub async fn signing_actor<A>(
    data: &Data<<A as Object>::DataType>,
 ) -> Result<A, <A as Object>::Error>
 where
-    A: Object + Actor,
+    A: Object + Actor + Send + Sync,
    <A as Object>::Error: From<Error>,
    for<'de2> <A as Object>::Kind: Deserialize<'de2>,
 {
--- a/src/actix_web/response.rs
+++ b/src/actix_web/response.rs
@ -0,0 +1,50 @@
+//! Generate HTTP responses for Activitypub ojects
+
+use crate::{
+    protocol::{context::WithContext, tombstone::Tombstone},
+    FEDERATION_CONTENT_TYPE,
+};
+use actix_web::HttpResponse;
+use http02::header::VARY;
+use serde::Serialize;
+use serde_json::Value;
+use url::Url;
+
+/// Generates HTTP response to serve the object for fetching from other instances.
+///
+/// If possible use [Object.http_response]
+/// which also handles redirects for remote objects and deletions.
+///
+/// `federation_context` is the value of `@context`.
+pub fn create_http_response<T: Serialize>(
+    data: T,
+    federation_context: &Value,
+) -> Result<HttpResponse, serde_json::Error> {
+    let json = serde_json::to_string_pretty(&WithContext::new(data, federation_context.clone()))?;
+
+    Ok(HttpResponse::Ok()
+        .content_type(FEDERATION_CONTENT_TYPE)
+        .insert_header((VARY, "Accept"))
+        .body(json))
+}
+
+pub(crate) fn create_tombstone_response(
+    id: Url,
+    federation_context: &Value,
+) -> Result<HttpResponse, serde_json::Error> {
+    let tombstone = Tombstone::new(id);
+    let json =
+        serde_json::to_string_pretty(&WithContext::new(tombstone, federation_context.clone()))?;
+
+    Ok(HttpResponse::Gone()
+        .content_type(FEDERATION_CONTENT_TYPE)
+        .status(actix_web::http::StatusCode::GONE)
+        .insert_header((VARY, "Accept"))
+        .body(json))
+}
+
+pub(crate) fn redirect_remote_object(url: &Url) -> HttpResponse {
+    let mut res = HttpResponse::PermanentRedirect();
+    res.insert_header((actix_web::http::header::LOCATION, url.as_str()));
+    res.finish()
+}
--- a/src/axum/inbox.rs
+++ b/src/axum/inbox.rs
@ -7,10 +7,9 @@ use crate::{
    error::Error,
    http_signatures::verify_signature,
    parse_received_activity,
-    traits::{ActivityHandler, Actor, Object},
+    traits::{Activity, Actor, Object},
 };
 use axum::{
-    async_trait,
    body::Body,
    extract::FromRequest,
    http::{Request, StatusCode},
@ -21,20 +20,20 @@ use serde::de::DeserializeOwned;
 use tracing::debug;

 /// Handles incoming activities, verifying HTTP signatures and other checks
-pub async fn receive_activity<Activity, ActorT, Datatype>(
+pub async fn receive_activity<A, ActorT, Datatype>(
    activity_data: ActivityData,
    data: &Data<Datatype>,
-) -> Result<(), <Activity as ActivityHandler>::Error>
+) -> Result<(), <A as Activity>::Error>
 where
-    Activity: ActivityHandler<DataType = Datatype> + DeserializeOwned + Send + 'static,
-    ActorT: Object<DataType = Datatype> + Actor + Send + 'static,
+    A: Activity<DataType = Datatype> + DeserializeOwned + Send + 'static,
+    ActorT: Object<DataType = Datatype> + Actor + Send + Sync + 'static,
    for<'de2> <ActorT as Object>::Kind: serde::Deserialize<'de2>,
-    <Activity as ActivityHandler>::Error: From<Error> + From<<ActorT as Object>::Error>,
+    <A as Activity>::Error: From<Error> + From<<ActorT as Object>::Error>,
    <ActorT as Object>::Error: From<Error>,
    Datatype: Clone,
 {
    let (activity, actor) =
-        parse_received_activity::<Activity, ActorT, _>(&activity_data.body, data).await?;
+        parse_received_activity::<A, ActorT, _>(&activity_data.body, data).await?;

    verify_signature(
        &activity_data.headers,
@ -58,7 +57,6 @@ pub struct ActivityData {
    body: Vec<u8>,
 }

-#[async_trait]
 impl<S> FromRequest<S> for ActivityData
 where
    S: Send + Sync,
@ -66,7 +64,21 @@ where
    type Rejection = Response;

    async fn from_request(req: Request<Body>, _state: &S) -> Result<Self, Self::Rejection> {
-        let (parts, body) = req.into_parts();
+        #[allow(unused_mut)]
+        let (mut parts, body) = req.into_parts();
+
+        // take the full URI to handle nested routers
+        // OriginalUri::from_request_parts has an Infallible error type
+        #[cfg(feature = "axum-original-uri")]
+        let uri = {
+            use axum::extract::{FromRequestParts, OriginalUri};
+            OriginalUri::from_request_parts(&mut parts, _state)
+                .await
+                .expect("infallible")
+                .0
+        };
+        #[cfg(not(feature = "axum-original-uri"))]
+        let uri = parts.uri;

        // this wont work if the body is an long running stream
        let bytes = axum::body::to_bytes(body, usize::MAX)
@ -76,7 +88,7 @@ where
        Ok(Self {
            headers: parts.headers,
            method: parts.method,
-            uri: parts.uri,
+            uri,
            body: bytes.to_vec(),
        })
    }
--- a/src/axum/middleware.rs
+++ b/src/axum/middleware.rs
@ -1,5 +1,5 @@
 use crate::config::{Data, FederationConfig, FederationMiddleware};
-use axum::{async_trait, body::Body, extract::FromRequestParts, http::Request, response::Response};
+use axum::{body::Body, extract::FromRequestParts, http::Request, response::Response};
 use http::{request::Parts, StatusCode};
 use std::task::{Context, Poll};
 use tower::{Layer, Service};
@ -43,7 +43,6 @@ where
    }
 }

-#[async_trait]
 impl<S, T: Clone + 'static> FromRequestParts<S> for Data<T>
 where
    S: Send + Sync,
--- a/src/config.rs
+++ b/src/config.rs
@ -19,29 +19,28 @@ use crate::{
    error::Error,
    http_signatures::sign_request,
    protocol::verification::verify_domains_match,
-    traits::{ActivityHandler, Actor},
+    traits::{Activity, Actor},
+    utils::validate_ip,
 };
 use async_trait::async_trait;
 use bytes::Bytes;
 use derive_builder::Builder;
 use dyn_clone::{clone_trait_object, DynClone};
 use moka::future::Cache;
-use once_cell::sync::Lazy;
 use regex::Regex;
 use reqwest::{redirect::Policy, Client, Request};
 use reqwest_middleware::{ClientWithMiddleware, RequestBuilder};
 use rsa::{pkcs8::DecodePrivateKey, RsaPrivateKey};
 use serde::de::DeserializeOwned;
 use std::{
-    net::IpAddr,
    ops::Deref,
    sync::{
        atomic::{AtomicU32, Ordering},
        Arc,
+        OnceLock,
    },
    time::Duration,
 };
-use tokio::net::lookup_host;
 use url::Url;

 /// Configuration for this library, with various federation related settings
@ -114,8 +113,10 @@ pub struct FederationConfig<T: Clone> {
    pub(crate) queue_retry_count: usize,
 }

-pub(crate) static DOMAIN_REGEX: Lazy<Regex> =
-    Lazy::new(|| Regex::new(r"^[a-zA-Z0-9.-]*$").expect("compile regex"));
+pub(crate) fn domain_regex() -> &'static Regex {
+    static DOMAIN_REGEX: OnceLock<Regex> = OnceLock::new();
+    DOMAIN_REGEX.get_or_init(|| Regex::new(r"^[a-zA-Z0-9.-]*$").expect("compile regex"))
+}

 impl<T: Clone> FederationConfig<T> {
    /// Returns a new config builder with default values.
@ -123,12 +124,9 @@ impl<T: Clone> FederationConfig<T> {
        FederationConfigBuilder::default()
    }

-    pub(crate) async fn verify_url_and_domain<Activity, Datatype>(
-        &self,
-        activity: &Activity,
-    ) -> Result<(), Error>
+    pub(crate) async fn verify_url_and_domain<A, Datatype>(&self, activity: &A) -> Result<(), Error>
    where
-        Activity: ActivityHandler<DataType = Datatype> + DeserializeOwned + Send + 'static,
+        A: Activity<DataType = Datatype> + DeserializeOwned + Send + 'static,
    {
        verify_domains_match(activity.id(), activity.actor())?;
        self.verify_url_valid(activity.id()).await?;
@ -174,7 +172,7 @@ impl<T: Clone> FederationConfig<T> {
        let Some(domain) = url.domain() else {
            return Err(Error::UrlVerificationError("Url must have a domain"));
        };
-        if !DOMAIN_REGEX.is_match(domain) {
+        if !domain_regex().is_match(domain) {
            return Err(Error::UrlVerificationError("Invalid characters in domain"));
        }

@ -184,30 +182,9 @@ impl<T: Clone> FederationConfig<T> {
                return Err(Error::UrlVerificationError("Explicit port is not allowed"));
            }

-            // Resolve domain and see if it points to private IP
-            // TODO: Use is_global() once stabilized
-            //       https://doc.rust-lang.org/std/net/enum.IpAddr.html#method.is_global
-            let invalid_ip =
-                lookup_host((domain.to_owned(), 80))
-                    .await?
-                    .any(|addr| match addr.ip() {
-                        IpAddr::V4(addr) => {
-                            addr.is_private()
-                                || addr.is_link_local()
-                                || addr.is_loopback()
-                                || addr.is_multicast()
-                        }
-                        IpAddr::V6(addr) => {
-                            addr.is_loopback()
-                        || addr.is_multicast()
-                        || ((addr.segments()[0] & 0xfe00) == 0xfc00) // is_unique_local
-                        || ((addr.segments()[0] & 0xffc0) == 0xfe80) // is_unicast_link_local
-                        }
-                    });
-            if invalid_ip {
-                return Err(Error::UrlVerificationError(
-                    "Localhost is only allowed in debug mode",
-                ));
+            let allow_local = std::env::var("DANGER_FEDERATION_ALLOW_LOCAL_IP").is_ok();
+            if !allow_local && validate_ip(&url).await.is_err() {
+                return Err(Error::DomainResolveError(domain.to_string()));
            }
        }

@ -256,7 +233,7 @@ impl<T: Clone> FederationConfigBuilder<T> {

        let private_key =
            RsaPrivateKey::from_pkcs8_pem(&private_key_pem).expect("Could not decode PEM data");
-        self.signed_fetch_actor = Some(Some(Arc::new((actor.id(), private_key))));
+        self.signed_fetch_actor = Some(Some(Arc::new((actor.id().clone(), private_key))));
        self
    }

@ -354,9 +331,10 @@ clone_trait_object!(UrlVerifier);
 /// prevent denial of service attacks, where an attacker triggers fetching of recursive objects.
 ///
 /// <https://www.w3.org/TR/activitypub/#security-recursive-objects>
+#[derive(Clone)]
 pub struct Data<T: Clone> {
    pub(crate) config: FederationConfig<T>,
-    pub(crate) request_counter: AtomicU32,
+    pub(crate) request_counter: RequestCounter,
 }

 impl<T: Clone> Data<T> {
@ -379,7 +357,7 @@ impl<T: Clone> Data<T> {
    }
    /// Total number of outgoing HTTP requests made with this data.
    pub fn request_count(&self) -> u32 {
-        self.request_counter.load(Ordering::Relaxed)
+        self.request_counter.0.load(Ordering::Relaxed)
    }

    /// Add HTTP signature to arbitrary request
@ -400,6 +378,15 @@ impl<T: Clone> Data<T> {
        )
        .await
    }
+
+    /// Resolve domain of the url and throw error if it points to local/private IP.
+    pub async fn is_valid_ip(&self, url: &Url) -> Result<(), Error> {
+        if self.config.debug {
+            return Ok(());
+        }
+
+        validate_ip(url).await
+    }
 }

 impl<T: Clone> Deref for Data<T> {
@ -410,6 +397,16 @@ impl<T: Clone> Deref for Data<T> {
    }
 }

+/// Wrapper to implement `Clone`
+#[derive(Default)]
+pub(crate) struct RequestCounter(pub(crate) AtomicU32);
+
+impl Clone for RequestCounter {
+    fn clone(&self) -> Self {
+        RequestCounter(self.0.load(Ordering::Relaxed).into())
+    }
+}
+
 /// Middleware for HTTP handlers which provides access to [Data]
 #[derive(Clone)]
 pub struct FederationMiddleware<T: Clone>(pub(crate) FederationConfig<T>);
--- a/src/error.rs
+++ b/src/error.rs
@ -28,6 +28,9 @@ pub enum Error {
    /// url verification error
    #[error("URL failed verification: {0}")]
    UrlVerificationError(&'static str),
+    /// Resolving domain points to local IP.
+    #[error("Resolving domain {0} points to local IP address. This may indicate an attacker attempting to access internal services. If intentional, you can ignore this error by setting DANGER_FEDERATION_ALLOW_LOCAL_IP=1")]
+    DomainResolveError(String),
    /// Incoming activity has invalid digest for body
    #[error("Incoming activity has invalid digest for body")]
    ActivityBodyDigestInvalid,
@ -44,11 +47,16 @@ pub enum Error {
    #[error("Failed to parse object {1} with content {2}: {0}")]
    ParseFetchedObject(serde_json::Error, Url, String),
    /// Failed to parse an activity received from another instance
-    #[error("Failed to parse incoming activity {}: {0}", match .1 {
+    #[error("Failed to parse incoming activity {}: {0}", match .id {
        Some(t) => format!("with id {t}"),
        None => String::new(),
    })]
-    ParseReceivedActivity(serde_json::Error, Option<Url>),
+    ParseReceivedActivity {
+        /// The parse error
+        err: serde_json::Error,
+        /// ID of the Activitypub object which caused this error
+        id: Option<Url>,
+    },
    /// Reqwest Middleware Error
    #[error(transparent)]
    ReqwestMiddleware(#[from] reqwest_middleware::Error),
--- a/src/fetch/collection_id.rs
+++ b/src/fetch/collection_id.rs
@ -102,92 +102,3 @@ where
        self.0.eq(&other.0) && self.1 == other.1
    }
 }
-
-#[cfg(feature = "diesel")]
-const _IMPL_DIESEL_NEW_TYPE_FOR_COLLECTION_ID: () = {
-    use diesel::{
-        backend::Backend,
-        deserialize::{FromSql, FromStaticSqlRow},
-        expression::AsExpression,
-        internal::derives::as_expression::Bound,
-        pg::Pg,
-        query_builder::QueryId,
-        serialize,
-        serialize::{Output, ToSql},
-        sql_types::{HasSqlType, SingleValue, Text},
-        Expression,
-        Queryable,
-    };
-
-    // TODO: this impl only works for Postgres db because of to_string() call which requires reborrow
-    impl<Kind, ST> ToSql<ST, Pg> for CollectionId<Kind>
-    where
-        Kind: Collection,
-        for<'de2> <Kind as Collection>::Kind: Deserialize<'de2>,
-        String: ToSql<ST, Pg>,
-    {
-        fn to_sql<'b>(&'b self, out: &mut Output<'b, '_, Pg>) -> serialize::Result {
-            let v = self.0.to_string();
-            <String as ToSql<Text, Pg>>::to_sql(&v, &mut out.reborrow())
-        }
-    }
-    impl<'expr, Kind, ST> AsExpression<ST> for &'expr CollectionId<Kind>
-    where
-        Kind: Collection,
-        for<'de2> <Kind as Collection>::Kind: Deserialize<'de2>,
-        Bound<ST, String>: Expression<SqlType = ST>,
-        ST: SingleValue,
-    {
-        type Expression = Bound<ST, &'expr str>;
-        fn as_expression(self) -> Self::Expression {
-            Bound::new(self.0.as_str())
-        }
-    }
-    impl<Kind, ST> AsExpression<ST> for CollectionId<Kind>
-    where
-        Kind: Collection,
-        for<'de2> <Kind as Collection>::Kind: Deserialize<'de2>,
-        Bound<ST, String>: Expression<SqlType = ST>,
-        ST: SingleValue,
-    {
-        type Expression = Bound<ST, String>;
-        fn as_expression(self) -> Self::Expression {
-            Bound::new(self.0.to_string())
-        }
-    }
-    impl<Kind, ST, DB> FromSql<ST, DB> for CollectionId<Kind>
-    where
-        Kind: Collection + Send + 'static,
-        for<'de2> <Kind as Collection>::Kind: Deserialize<'de2>,
-        String: FromSql<ST, DB>,
-        DB: Backend,
-        DB: HasSqlType<ST>,
-    {
-        fn from_sql(
-            raw: DB::RawValue<'_>,
-        ) -> Result<Self, Box<dyn ::std::error::Error + Send + Sync>> {
-            let string: String = FromSql::<ST, DB>::from_sql(raw)?;
-            Ok(CollectionId::parse(&string)?)
-        }
-    }
-    impl<Kind, ST, DB> Queryable<ST, DB> for CollectionId<Kind>
-    where
-        Kind: Collection + Send + 'static,
-        for<'de2> <Kind as Collection>::Kind: Deserialize<'de2>,
-        String: FromStaticSqlRow<ST, DB>,
-        DB: Backend,
-        DB: HasSqlType<ST>,
-    {
-        type Row = String;
-        fn build(row: Self::Row) -> diesel::deserialize::Result<Self> {
-            Ok(CollectionId::parse(&row)?)
-        }
-    }
-    impl<Kind> QueryId for CollectionId<Kind>
-    where
-        Kind: Collection + 'static,
-        for<'de2> <Kind as Collection>::Kind: Deserialize<'de2>,
-    {
-        type QueryId = Self;
-    }
-};
--- a/src/fetch/mod.rs
+++ b/src/fetch/mod.rs
@ -106,7 +106,7 @@ async fn fetch_object_http_with_accept<T: Clone, Kind: DeserializeOwned>(
    config.verify_url_valid(url).await?;
    info!("Fetching remote object {}", url.to_string());

-    let mut counter = data.request_counter.fetch_add(1, Ordering::SeqCst);
+    let mut counter = data.request_counter.0.fetch_add(1, Ordering::SeqCst);
    // fetch_add returns old value so we need to increment manually here
    counter += 1;
    if counter > config.http_fetch_limit {
--- a/src/fetch/object_id.rs
+++ b/src/fetch/object_id.rs
@ -10,7 +10,7 @@ use url::Url;

 impl<T> FromStr for ObjectId<T>
 where
-    T: Object + Send + Debug + 'static,
+    T: Object + Send + Sync + Debug + 'static,
    for<'de2> <T as Object>::Kind: Deserialize<'de2>,
 {
    type Err = url::ParseError;
@ -61,7 +61,7 @@ where

 impl<Kind> ObjectId<Kind>
 where
-    Kind: Object + Send + Debug + 'static,
+    Kind: Object + Send + Sync + Debug + 'static,
    for<'de2> <Kind as Object>::Kind: Deserialize<'de2>,
 {
    /// Construct a new objectid instance
@ -164,6 +164,7 @@ where
        if let Err(Error::ObjectDeleted(url)) = res {
            if let Some(db_object) = db_object {
                db_object.delete(data).await?;
+                return Ok(db_object);
            }
            return Err(Error::ObjectDeleted(url).into());
        }
@ -271,95 +272,6 @@ where
    }
 }

-#[cfg(feature = "diesel")]
-const _IMPL_DIESEL_NEW_TYPE_FOR_OBJECT_ID: () = {
-    use diesel::{
-        backend::Backend,
-        deserialize::{FromSql, FromStaticSqlRow},
-        expression::AsExpression,
-        internal::derives::as_expression::Bound,
-        pg::Pg,
-        query_builder::QueryId,
-        serialize,
-        serialize::{Output, ToSql},
-        sql_types::{HasSqlType, SingleValue, Text},
-        Expression,
-        Queryable,
-    };
-
-    // TODO: this impl only works for Postgres db because of to_string() call which requires reborrow
-    impl<Kind, ST> ToSql<ST, Pg> for ObjectId<Kind>
-    where
-        Kind: Object,
-        for<'de2> <Kind as Object>::Kind: Deserialize<'de2>,
-        String: ToSql<ST, Pg>,
-    {
-        fn to_sql<'b>(&'b self, out: &mut Output<'b, '_, Pg>) -> serialize::Result {
-            let v = self.0.to_string();
-            <String as ToSql<Text, Pg>>::to_sql(&v, &mut out.reborrow())
-        }
-    }
-    impl<'expr, Kind, ST> AsExpression<ST> for &'expr ObjectId<Kind>
-    where
-        Kind: Object,
-        for<'de2> <Kind as Object>::Kind: Deserialize<'de2>,
-        Bound<ST, String>: Expression<SqlType = ST>,
-        ST: SingleValue,
-    {
-        type Expression = Bound<ST, &'expr str>;
-        fn as_expression(self) -> Self::Expression {
-            Bound::new(self.0.as_str())
-        }
-    }
-    impl<Kind, ST> AsExpression<ST> for ObjectId<Kind>
-    where
-        Kind: Object,
-        for<'de2> <Kind as Object>::Kind: Deserialize<'de2>,
-        Bound<ST, String>: Expression<SqlType = ST>,
-        ST: SingleValue,
-    {
-        type Expression = Bound<ST, String>;
-        fn as_expression(self) -> Self::Expression {
-            Bound::new(self.0.to_string())
-        }
-    }
-    impl<Kind, ST, DB> FromSql<ST, DB> for ObjectId<Kind>
-    where
-        Kind: Object + Send + 'static,
-        for<'de2> <Kind as Object>::Kind: Deserialize<'de2>,
-        String: FromSql<ST, DB>,
-        DB: Backend,
-        DB: HasSqlType<ST>,
-    {
-        fn from_sql(
-            raw: DB::RawValue<'_>,
-        ) -> Result<Self, Box<dyn ::std::error::Error + Send + Sync>> {
-            let string: String = FromSql::<ST, DB>::from_sql(raw)?;
-            Ok(ObjectId::parse(&string)?)
-        }
-    }
-    impl<Kind, ST, DB> Queryable<ST, DB> for ObjectId<Kind>
-    where
-        Kind: Object + Send + 'static,
-        for<'de2> <Kind as Object>::Kind: Deserialize<'de2>,
-        String: FromStaticSqlRow<ST, DB>,
-        DB: Backend,
-        DB: HasSqlType<ST>,
-    {
-        type Row = String;
-        fn build(row: Self::Row) -> diesel::deserialize::Result<Self> {
-            Ok(ObjectId::parse(&row)?)
-        }
-    }
-    impl<Kind> QueryId for ObjectId<Kind>
-    where
-        Kind: Object + 'static,
-        for<'de2> <Kind as Object>::Kind: Deserialize<'de2>,
-    {
-        type QueryId = Self;
-    }
-};
-
 /// Internal only
 #[cfg(test)]
 #[allow(clippy::unwrap_used)]
--- a/src/fetch/webfinger.rs
+++ b/src/fetch/webfinger.rs
@ -1,5 +1,5 @@
 use crate::{
-    config::{Data, DOMAIN_REGEX},
+    config::{domain_regex, Data},
    error::Error,
    fetch::{fetch_object_http_with_accept, object_id::ObjectId},
    traits::{Actor, Object},
@ -7,10 +7,9 @@ use crate::{
 };
 use http::HeaderValue;
 use itertools::Itertools;
-use once_cell::sync::Lazy;
 use regex::Regex;
 use serde::{Deserialize, Serialize};
-use std::{collections::HashMap, fmt::Display};
+use std::{collections::HashMap, fmt::Display, sync::LazyLock};
 use tracing::debug;
 use url::Url;

@ -46,7 +45,7 @@ pub async fn webfinger_resolve_actor<T: Clone, Kind>(
    data: &Data<T>,
 ) -> Result<Kind, <Kind as Object>::Error>
 where
-    Kind: Object + Actor + Send + 'static + Object<DataType = T>,
+    Kind: Object + Actor + Send + Sync + 'static + Object<DataType = T>,
    for<'de2> <Kind as Object>::Kind: serde::Deserialize<'de2>,
    <Kind as Object>::Error: From<crate::error::Error> + Send + Sync + Display,
 {
@ -56,7 +55,7 @@ where
        .ok_or(WebFingerError::WrongFormat.into_crate_error())?;

    // For production mode make sure that domain doesnt contain any port or path.
-    if !data.config.debug && !DOMAIN_REGEX.is_match(domain) {
+    if !data.config.debug && !domain_regex().is_match(domain) {
        return Err(Error::UrlVerificationError("Invalid characters in domain").into());
    }

@ -89,6 +88,7 @@ where
            }
        })
        .filter_map(|l| l.href.clone())
+        .rev()
        .collect();

    for l in links {
@ -130,8 +130,8 @@ pub fn extract_webfinger_name<'i, T>(query: &'i str, data: &Data<T>) -> Result<&
 where
    T: Clone,
 {
-    static WEBFINGER_REGEX: Lazy<Regex> =
-        Lazy::new(|| Regex::new(r"^acct:([\p{L}0-9_\.\-]+)@(.*)$").expect("compile regex"));
+    static WEBFINGER_REGEX: LazyLock<Regex> =
+        LazyLock::new(|| Regex::new(r"^acct:([\p{L}0-9_\.\-]+)@(.*)$").expect("compile regex"));
    // Regex to extract usernames from webfinger query. Supports different alphabets using `\p{L}`.
    // TODO: This should use a URL parser
    let captures = WEBFINGER_REGEX
@ -223,7 +223,7 @@ pub fn build_webfinger_response_with_type(
 }

 /// A webfinger response with information about a `Person` or other type of actor.
-#[derive(Serialize, Deserialize, Debug, Default)]
+#[derive(Serialize, Deserialize, Debug, Default, PartialEq)]
 pub struct Webfinger {
    /// The actor which is described here, for example `acct:LemmyDev@mastodon.social`
    pub subject: String,
@ -238,7 +238,7 @@ pub struct Webfinger {
 }

 /// A single link included as part of a [Webfinger] response.
-#[derive(Serialize, Deserialize, Debug, Default)]
+#[derive(Serialize, Deserialize, Debug, Default, PartialEq)]
 pub struct WebfingerLink {
    /// Relationship of the link, such as `self` or `http://webfinger.net/rel/profile-page`
    pub rel: Option<String>,
--- a/src/http_signatures.rs
+++ b/src/http_signatures.rs
@ -19,7 +19,6 @@ use http_signature_normalization_reqwest::{
    prelude::{Config, SignExt},
    DefaultSpawner,
 };
-use once_cell::sync::Lazy;
 use reqwest::Request;
 use reqwest_middleware::RequestBuilder;
 use rsa::{
@ -30,7 +29,7 @@ use rsa::{
 };
 use serde::Deserialize;
 use sha2::{Digest, Sha256};
-use std::{collections::BTreeMap, fmt::Debug, time::Duration};
+use std::{collections::BTreeMap, fmt::Debug, sync::LazyLock, time::Duration};
 use tracing::debug;
 use url::Url;

@ -86,9 +85,9 @@ pub(crate) async fn sign_request(
    private_key: RsaPrivateKey,
    http_signature_compat: bool,
 ) -> Result<Request, Error> {
-    static CONFIG: Lazy<Config<DefaultSpawner>> =
-        Lazy::new(|| Config::new().set_expiration(EXPIRES_AFTER));
-    static CONFIG_COMPAT: Lazy<Config> = Lazy::new(|| {
+    static CONFIG: LazyLock<Config<DefaultSpawner>> =
+        LazyLock::new(|| Config::new().set_expiration(EXPIRES_AFTER));
+    static CONFIG_COMPAT: LazyLock<Config> = LazyLock::new(|| {
        Config::new()
            .mastodon_compat()
            .set_expiration(EXPIRES_AFTER)
@ -150,7 +149,7 @@ pub(crate) async fn signing_actor<'a, A, H>(
    data: &Data<<A as Object>::DataType>,
 ) -> Result<A, <A as Object>::Error>
 where
-    A: Object + Actor,
+    A: Object + Actor + Send + Sync,
    <A as Object>::Error: From<Error>,
    for<'de2> <A as Object>::Kind: Deserialize<'de2>,
    H: IntoIterator<Item = (&'a HeaderName, &'a HeaderValue)>,
@ -189,7 +188,7 @@ fn verify_signature_inner(
    uri: &Uri,
    public_key: &str,
 ) -> Result<(), Error> {
-    static CONFIG: Lazy<http_signature_normalization::Config> = Lazy::new(|| {
+    static CONFIG: LazyLock<http_signature_normalization::Config> = LazyLock::new(|| {
        http_signature_normalization::Config::new()
            .set_expiration(EXPIRES_AFTER)
            .require_digest()
@ -292,9 +291,10 @@ pub mod test {
    use rsa::{pkcs1::DecodeRsaPrivateKey, pkcs8::DecodePrivateKey};
    use std::str::FromStr;

-    static ACTOR_ID: Lazy<Url> = Lazy::new(|| Url::parse("https://example.com/u/alice").unwrap());
-    static INBOX_URL: Lazy<Url> =
-        Lazy::new(|| Url::parse("https://example.com/u/alice/inbox").unwrap());
+    static ACTOR_ID: LazyLock<Url> =
+        LazyLock::new(|| Url::parse("https://example.com/u/alice").unwrap());
+    static INBOX_URL: LazyLock<Url> =
+        LazyLock::new(|| Url::parse("https://example.com/u/alice/inbox").unwrap());

    #[tokio::test]
    async fn test_sign() {
--- a/src/lib.rs
+++ b/src/lib.rs
@ -23,12 +23,13 @@ pub mod http_signatures;
 pub mod protocol;
 pub(crate) mod reqwest_shim;
 pub mod traits;
+mod utils;

 use crate::{
    config::Data,
    error::Error,
    fetch::object_id::ObjectId,
-    traits::{ActivityHandler, Actor, Object},
+    traits::{Activity, Actor, Object},
 };
 pub use activitystreams_kinds as kinds;

@ -40,22 +41,22 @@ pub const FEDERATION_CONTENT_TYPE: &str = "application/activity+json";

 /// Deserialize incoming inbox activity to the given type, perform basic
 /// validation and extract the actor.
-async fn parse_received_activity<Activity, ActorT, Datatype>(
+async fn parse_received_activity<A, ActorT, Datatype>(
    body: &[u8],
    data: &Data<Datatype>,
-) -> Result<(Activity, ActorT), <Activity as ActivityHandler>::Error>
+) -> Result<(A, ActorT), <A as Activity>::Error>
 where
-    Activity: ActivityHandler<DataType = Datatype> + DeserializeOwned + Send + 'static,
-    ActorT: Object<DataType = Datatype> + Actor + Send + 'static,
+    A: Activity<DataType = Datatype> + DeserializeOwned + Send + 'static,
+    ActorT: Object<DataType = Datatype> + Actor + Send + Sync + 'static,
    for<'de2> <ActorT as Object>::Kind: serde::Deserialize<'de2>,
-    <Activity as ActivityHandler>::Error: From<Error> + From<<ActorT as Object>::Error>,
+    <A as Activity>::Error: From<Error> + From<<ActorT as Object>::Error>,
    <ActorT as Object>::Error: From<Error>,
    Datatype: Clone,
 {
-    let activity: Activity = serde_json::from_slice(body).map_err(|e| {
+    let activity: A = serde_json::from_slice(body).map_err(|err| {
        // Attempt to include activity id in error message
        let id = extract_id(body).ok();
-        Error::ParseReceivedActivity(e, id)
+        Error::ParseReceivedActivity { err, id }
    })?;
    data.config.verify_url_and_domain(&activity).await?;
    let actor = ObjectId::<ActorT>::from(activity.actor().clone())
--- a/src/protocol/context.rs
+++ b/src/protocol/context.rs
@ -19,7 +19,7 @@
 //! Ok::<(), serde_json::error::Error>(())
 //! ```

-use crate::{config::Data, traits::ActivityHandler};
+use crate::{config::Data, traits::Activity};
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
 use url::Url;
@ -55,12 +55,12 @@ impl<T> WithContext<T> {
 }

 #[async_trait::async_trait]
-impl<T> ActivityHandler for WithContext<T>
+impl<T> Activity for WithContext<T>
 where
-    T: ActivityHandler + Send + Sync,
+    T: Activity + Send + Sync,
 {
-    type DataType = <T as ActivityHandler>::DataType;
-    type Error = <T as ActivityHandler>::Error;
+    type DataType = <T as Activity>::DataType;
+    type Error = <T as Activity>::Error;

    fn id(&self) -> &Url {
        self.inner.id()
--- a/src/protocol/helpers.rs
+++ b/src/protocol/helpers.rs
@ -1,13 +1,22 @@
 //! Serde deserialization functions which help to receive differently shaped data

-use serde::{Deserialize, Deserializer};
+use activitystreams_kinds::public;
+use itertools::Itertools;
+use serde::{de::Error, Deserialize, Deserializer};
+use serde_json::Value;
+use url::Url;

-/// Deserialize JSON single value or array into Vec.
+/// Deserialize JSON single value or array into `Vec<Url>`.
 ///
 /// Useful if your application can handle multiple values for a field, but another federated
 /// platform only sends a single one.
 ///
+/// Also accepts common `Public` aliases for recipient fields. Some implementations send `Public`
+/// or `as:Public` instead of the canonical `https://www.w3.org/ns/activitystreams#Public` URL
+/// in fields such as `to` and `cc`.
+///
 /// ```
+/// # use activitypub_federation::kinds::public;
 /// # use activitypub_federation::protocol::helpers::deserialize_one_or_many;
 /// # use url::Url;
 /// #[derive(serde::Deserialize)]
@ -25,24 +34,39 @@ use serde::{Deserialize, Deserializer};
 ///      "https://lemmy.ml/u/bob"
 /// ]}"#)?;
 /// assert_eq!(multiple.to.len(), 2);
-/// Ok::<(), anyhow::Error>(())
-pub fn deserialize_one_or_many<'de, T, D>(deserializer: D) -> Result<Vec<T>, D::Error>
+///
+/// let note: Note = serde_json::from_str(r#"{"to": ["Public", "as:Public"]}"#)?;
+/// assert_eq!(note.to, vec![public()]);
+/// # Ok::<(), anyhow::Error>(())
+/// ```
+pub fn deserialize_one_or_many<'de, D>(deserializer: D) -> Result<Vec<Url>, D::Error>
 where
-    T: Deserialize<'de>,
    D: Deserializer<'de>,
 {
    #[derive(Deserialize)]
    #[serde(untagged)]
-    enum OneOrMany<T> {
-        One(T),
-        Many(Vec<T>),
+    enum OneOrMany {
+        Many(Vec<Value>),
+        One(Value),
    }

-    let result: OneOrMany<T> = Deserialize::deserialize(deserializer)?;
-    Ok(match result {
-        OneOrMany::Many(list) => list,
+    let result: OneOrMany = Deserialize::deserialize(deserializer)?;
+    let values = match result {
        OneOrMany::One(value) => vec![value],
+        OneOrMany::Many(values) => values,
+    };
+
+    values
+        .into_iter()
+        .map(|value| match value {
+            Value::String(value) if matches!(value.as_str(), "Public" | "as:Public") => {
+                Ok(public())
+            }
+            Value::String(value) => Url::parse(&value).map_err(D::Error::custom),
+            value => Url::deserialize(value).map_err(D::Error::custom),
        })
+        .collect::<Result<Vec<_>, _>>()
+        .map(|values| values.into_iter().unique().collect())
 }

 /// Deserialize JSON single value or single element array into single value.
@ -116,8 +140,35 @@ where
    Ok(inner)
 }

+/// Deserialize either single value or last item from an array into an optional field.
+pub fn deserialize_last<'de, T, D>(deserializer: D) -> Result<Option<T>, D::Error>
+where
+    T: Deserialize<'de>,
+    D: Deserializer<'de>,
+{
+    #[derive(Deserialize)]
+    #[serde(untagged)]
+    enum MaybeArray<T> {
+        Simple(T),
+        Array(Vec<T>),
+        None,
+    }
+
+    let result = Deserialize::deserialize(deserializer)?;
+    Ok(match result {
+        MaybeArray::Simple(value) => Some(value),
+        MaybeArray::Array(value) => value.into_iter().last(),
+        MaybeArray::None => None,
+    })
+}
+
 #[cfg(test)]
 mod tests {
+    use super::deserialize_one_or_many;
+    use activitystreams_kinds::public;
+    use anyhow::Result;
+    use serde::Deserialize;
+
    #[test]
    fn deserialize_one_multiple_values() {
        use crate::protocol::helpers::deserialize_one;
@ -133,4 +184,70 @@ mod tests {
        );
        assert!(note.is_err());
    }
+
+    #[test]
+    fn deserialize_one_or_many_single_public_aliases() -> Result<()> {
+        use url::Url;
+
+        #[derive(Deserialize)]
+        struct Note {
+            #[serde(deserialize_with = "deserialize_one_or_many")]
+            to: Vec<Url>,
+        }
+
+        for alias in ["Public", "as:Public"] {
+            let note = serde_json::from_str::<Note>(&format!(r#"{{"to": "{alias}"}}"#))?;
+            assert_eq!(note.to, vec![public()]);
+        }
+
+        Ok(())
+    }
+
+    #[test]
+    fn deserialize_one_or_many_array() -> Result<()> {
+        use url::Url;
+
+        #[derive(Deserialize)]
+        struct Note {
+            #[serde(deserialize_with = "deserialize_one_or_many")]
+            to: Vec<Url>,
+        }
+
+        let note = serde_json::from_str::<Note>(
+            r#"{
+                "to": [
+                    "https://example.com/c/main",
+                    "Public",
+                    "as:Public",
+                    "https://www.w3.org/ns/activitystreams#Public"
+                ]
+            }"#,
+        )?;
+
+        assert_eq!(
+            note.to,
+            vec![Url::parse("https://example.com/c/main")?, public(),]
+        );
+
+        Ok(())
+    }
+
+    #[test]
+    fn deserialize_one_or_many_leaves_other_strings_unchanged() -> Result<()> {
+        use url::Url;
+
+        #[derive(Deserialize)]
+        struct Note {
+            #[serde(deserialize_with = "deserialize_one_or_many")]
+            to: Vec<Url>,
+            content: String,
+        }
+
+        let note = serde_json::from_str::<Note>(r#"{"to": "Public", "content": "Public"}"#)?;
+
+        assert_eq!(note.to, vec![public()]);
+        assert_eq!(note.content, "Public");
+
+        Ok(())
+    }
 }
--- a/src/protocol/mod.rs
+++ b/src/protocol/mod.rs
@ -3,5 +3,6 @@
 pub mod context;
 pub mod helpers;
 pub mod public_key;
+pub mod tombstone;
 pub mod values;
 pub mod verification;
--- a/src/protocol/tombstone.rs
+++ b/src/protocol/tombstone.rs
@ -0,0 +1,27 @@
+//! Tombstone is used to serve deleted objects
+
+use crate::kinds::object::TombstoneType;
+use serde::{Deserialize, Serialize};
+use url::Url;
+
+/// Represents a local object that was deleted
+///
+/// <https://www.w3.org/TR/activitystreams-vocabulary/#dfn-tombstone>
+#[derive(Clone, Debug, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Tombstone {
+    /// Id of the deleted object
+    pub id: Url,
+    #[serde(rename = "type")]
+    pub(crate) kind: TombstoneType,
+}
+
+impl Tombstone {
+    /// Create a new tombstone for the given object id
+    pub fn new(id: Url) -> Tombstone {
+        Tombstone {
+            id,
+            kind: TombstoneType::Tombstone,
+        }
+    }
+}
--- a/src/protocol/verification.rs
+++ b/src/protocol/verification.rs
@ -63,7 +63,7 @@ pub fn verify_is_remote_object<Kind, R: Clone>(
    data: &Data<<Kind as Object>::DataType>,
 ) -> Result<(), Error>
 where
-    Kind: Object<DataType = R> + Send + 'static,
+    Kind: Object<DataType = R> + Send + Sync + 'static,
    for<'de2> <Kind as Object>::Kind: Deserialize<'de2>,
 {
    if id.is_local(data) {
--- a/src/reqwest_shim.rs
+++ b/src/reqwest_shim.rs
@ -10,8 +10,8 @@ use std::{
    task::{Context, Poll},
 };

-/// 200KB
-const MAX_BODY_SIZE: usize = 204800;
+/// 1 MB
+const MAX_BODY_SIZE: usize = 1024 * 1024;

 pin_project! {
    pub struct BytesFuture {
@ -66,7 +66,7 @@ impl Future for TextFuture {
 /// Reqwest doesn't limit the response body size by default nor does it offer an option to configure one.
 /// Since we have to fetch data from untrusted sources, not restricting the maximum size is a DoS hazard for us.
 ///
-/// This shim reimplements the `bytes`, `json`, and `text` functions and restricts the bodies to 100KB.
+/// This shim reimplements the `bytes`, `json`, and `text` functions and restricts the bodies length.
 ///
 /// TODO: Remove this shim as soon as reqwest gets support for size-limited bodies.
 pub trait ResponseExt {
--- a/src/traits/either.rs
+++ b/src/traits/either.rs
@ -18,8 +18,8 @@ pub enum UntaggedEither<L, R> {
 #[async_trait]
 impl<T, R, E, D> Object for Either<T, R>
 where
-    T: Object + Object<Error = E, DataType = D> + Send,
-    R: Object + Object<Error = E, DataType = D> + Send,
+    T: Object + Object<Error = E, DataType = D> + Send + Sync,
+    R: Object + Object<Error = E, DataType = D> + Send + Sync,
    <T as Object>::Kind: Send + Sync,
    <R as Object>::Kind: Send + Sync,
    D: Sync + Send + Clone,
@ -29,6 +29,14 @@ where
    type Kind = UntaggedEither<T::Kind, R::Kind>;
    type Error = E;

+    /// `id` field of the object
+    fn id(&self) -> Url {
+        match self {
+            Either::Left(l) => l.id(),
+            Either::Right(r) => r.id(),
+        }
+    }
+
    fn last_refreshed_at(&self) -> Option<DateTime<Utc>> {
        match self {
            Either::Left(l) => l.last_refreshed_at(),
@ -51,13 +59,20 @@ where
        Ok(None)
    }

-    async fn delete(self, data: &Data<Self::DataType>) -> Result<(), Self::Error> {
+    async fn delete(&self, data: &Data<Self::DataType>) -> Result<(), Self::Error> {
        match self {
            Either::Left(l) => l.delete(data).await,
            Either::Right(r) => r.delete(data).await,
        }
    }

+    fn is_deleted(&self) -> bool {
+        match self {
+            Either::Left(l) => l.is_deleted(),
+            Either::Right(r) => r.is_deleted(),
+        }
+    }
+
    async fn into_json(self, data: &Data<Self::DataType>) -> Result<Self::Kind, Self::Error> {
        Ok(match self {
            Either::Left(l) => UntaggedEither::Left(l.into_json(data).await?),
@ -88,20 +103,13 @@ where
 #[async_trait]
 impl<T, R, E, D> Actor for Either<T, R>
 where
-    T: Actor + Object + Object<Error = E, DataType = D> + Send + 'static,
-    R: Actor + Object + Object<Error = E, DataType = D> + Send + 'static,
+    T: Actor + Object + Object<Error = E, DataType = D> + Send + Sync + 'static,
+    R: Actor + Object + Object<Error = E, DataType = D> + Send + Sync + 'static,
    <T as Object>::Kind: Send + Sync,
    <R as Object>::Kind: Send + Sync,
    D: Sync + Send + Clone,
    E: From<Error> + Debug,
 {
-    fn id(&self) -> Url {
-        match self {
-            Either::Left(l) => l.id(),
-            Either::Right(r) => r.id(),
-        }
-    }
-
    fn public_key_pem(&self) -> &str {
        match self {
            Either::Left(l) => l.public_key_pem(),
--- a/src/traits/mod.rs
+++ b/src/traits/mod.rs
@ -9,6 +9,7 @@ use url::Url;

 /// `Either` implementations for traits
 pub mod either;
+pub mod tests;

 /// Helper for converting between database structs and federated protocol structs.
 ///
@ -52,6 +53,8 @@ pub mod either;
 ///     type Kind = Note;
 ///     type Error = anyhow::Error;
 ///
+/// fn id(&self) -> Url { self.ap_id.inner().clone() }
+///
 /// async fn read_from_id(object_id: Url, data: &Data<Self::DataType>) -> Result<Option<Self>, Self::Error> {
 ///         // Attempt to read object from local database. Return Ok(None) if not found.
 ///         let post: Option<DbPost> = data.read_post_from_json_id(object_id).await?;
@ -106,6 +109,9 @@ pub trait Object: Sized + Debug {
    /// Error type returned by handler methods
    type Error;

+    /// `id` field of the object
+    fn id(&self) -> Url;
+
    /// Returns the last time this object was updated.
    ///
    /// If this returns `Some` and the value is too long ago, the object is refetched from the
@ -130,10 +136,15 @@ pub trait Object: Sized + Debug {
    /// Mark remote object as deleted in local database.
    ///
    /// Called when a `Delete` activity is received, or if fetch returns a `Tombstone` object.
-    async fn delete(self, _data: &Data<Self::DataType>) -> Result<(), Self::Error> {
+    async fn delete(&self, _data: &Data<Self::DataType>) -> Result<(), Self::Error> {
        Ok(())
    }

+    /// Returns true if the object was deleted
+    fn is_deleted(&self) -> bool {
+        false
+    }
+
    /// Convert database type to Activitypub type.
    ///
    /// Called when a local object gets fetched by another instance over HTTP, or when an object
@ -159,6 +170,40 @@ pub trait Object: Sized + Debug {
    /// should write the received object to database. Note that there is no distinction between
    /// create and update, so an `upsert` operation should be used.
    async fn from_json(json: Self::Kind, data: &Data<Self::DataType>) -> Result<Self, Self::Error>;
+
+    /// Generates HTTP response to serve the object for fetching from other instances.
+    ///
+    /// - If the object has a remote domain, sends a redirect to the original instance.
+    /// - If [Object.is_deleted] returns true, returns a [crate::protocol::tombstone::Tombstone] instead.
+    /// - Otherwise serves the object JSON using [Object.into_json] and pretty-print
+    ///
+    /// `federation_context` is the value of `@context`.
+    #[cfg(feature = "actix-web")]
+    async fn http_response(
+        self,
+        federation_context: &serde_json::Value,
+        data: &Data<Self::DataType>,
+    ) -> Result<actix_web::HttpResponse, Self::Error>
+    where
+        Self::Error: From<serde_json::Error>,
+        Self::Kind: serde::Serialize + Send,
+    {
+        use crate::actix_web::response::{
+            create_http_response,
+            create_tombstone_response,
+            redirect_remote_object,
+        };
+        let id = self.id();
+        let res = if !data.config.is_local_url(&id) {
+            redirect_remote_object(&id)
+        } else if !self.is_deleted() {
+            let json = self.into_json(data).await?;
+            create_http_response(json, federation_context)?
+        } else {
+            create_tombstone_response(id.clone(), federation_context)?
+        };
+        Ok(res)
+    }
 }

 /// Handler for receiving incoming activities.
@ -168,7 +213,7 @@ pub trait Object: Sized + Debug {
 /// # use url::Url;
 /// # use activitypub_federation::fetch::object_id::ObjectId;
 /// # use activitypub_federation::config::Data;
-/// # use activitypub_federation::traits::ActivityHandler;
+/// # use activitypub_federation::traits::Activity;
 /// # use activitypub_federation::traits::tests::{DbConnection, DbUser};
 /// #[derive(serde::Deserialize)]
 /// struct Follow {
@ -180,7 +225,7 @@ pub trait Object: Sized + Debug {
 /// }
 ///
 /// #[async_trait::async_trait]
-/// impl ActivityHandler for Follow {
+/// impl Activity for Follow {
 ///     type DataType = DbConnection;
 ///     type Error = anyhow::Error;
 ///
@ -206,7 +251,7 @@ pub trait Object: Sized + Debug {
 /// ```
 #[async_trait]
 #[enum_delegate::register]
-pub trait ActivityHandler {
+pub trait Activity {
    /// App data type passed to handlers. Must be identical to
    /// [crate::config::FederationConfigBuilder::app_data] type.
    type DataType: Clone + Send + Sync;
@ -234,9 +279,6 @@ pub trait ActivityHandler {

 /// Trait to allow retrieving common Actor data.
 pub trait Actor: Object + Send + 'static {
-    /// `id` field of the actor
-    fn id(&self) -> Url;
-
    /// The actor's public key for verifying signatures of incoming activities.
    ///
    /// Use [generate_actor_keypair](crate::http_signatures::generate_actor_keypair) to create the
@ -254,7 +296,7 @@ pub trait Actor: Object + Send + 'static {

    /// Generates a public key struct for use in the actor json representation
    fn public_key(&self) -> PublicKey {
-        PublicKey::new(self.id(), self.public_key_pem().to_string())
+        PublicKey::new(self.id().clone(), self.public_key_pem().to_string())
    }

    /// The actor's shared inbox, if any
@ -270,9 +312,9 @@ pub trait Actor: Object + Send + 'static {

 /// Allow for boxing of enum variants
 #[async_trait]
-impl<T> ActivityHandler for Box<T>
+impl<T> Activity for Box<T>
 where
-    T: ActivityHandler + Send + Sync,
+    T: Activity + Send + Sync,
 {
    type DataType = T::DataType;
    type Error = T::Error;
@ -334,207 +376,3 @@ pub trait Collection: Sized {
        data: &Data<Self::DataType>,
    ) -> Result<Self, Self::Error>;
 }
-
-/// Some impls of these traits for use in tests. Dont use this from external crates.
-///
-/// TODO: Should be using `cfg[doctest]` but blocked by <https://github.com/rust-lang/rust/issues/67295>
-#[doc(hidden)]
-#[allow(clippy::unwrap_used)]
-pub mod tests {
-    use super::{async_trait, ActivityHandler, Actor, Data, Debug, Object, PublicKey, Url};
-    use crate::{
-        error::Error,
-        fetch::object_id::ObjectId,
-        http_signatures::{generate_actor_keypair, Keypair},
-        protocol::verification::verify_domains_match,
-    };
-    use activitystreams_kinds::{activity::FollowType, actor::PersonType};
-    use once_cell::sync::Lazy;
-    use serde::{Deserialize, Serialize};
-
-    #[derive(Clone)]
-    pub struct DbConnection;
-
-    impl DbConnection {
-        pub async fn read_post_from_json_id<T>(&self, _: Url) -> Result<Option<T>, Error> {
-            Ok(None)
-        }
-        pub async fn read_local_user(&self, _: &str) -> Result<DbUser, Error> {
-            todo!()
-        }
-        pub async fn upsert<T>(&self, _: &T) -> Result<(), Error> {
-            Ok(())
-        }
-        pub async fn add_follower(&self, _: DbUser, _: DbUser) -> Result<(), Error> {
-            Ok(())
-        }
-    }
-
-    #[derive(Clone, Debug, Deserialize, Serialize)]
-    #[serde(rename_all = "camelCase")]
-    pub struct Person {
-        #[serde(rename = "type")]
-        pub kind: PersonType,
-        pub preferred_username: String,
-        pub id: ObjectId<DbUser>,
-        pub inbox: Url,
-        pub public_key: PublicKey,
-    }
-    #[derive(Debug, Clone)]
-    pub struct DbUser {
-        pub name: String,
-        pub federation_id: Url,
-        pub inbox: Url,
-        pub public_key: String,
-        #[allow(dead_code)]
-        private_key: Option<String>,
-        pub followers: Vec<Url>,
-        pub local: bool,
-    }
-
-    pub static DB_USER_KEYPAIR: Lazy<Keypair> = Lazy::new(|| generate_actor_keypair().unwrap());
-
-    pub static DB_USER: Lazy<DbUser> = Lazy::new(|| DbUser {
-        name: String::new(),
-        federation_id: "https://localhost/123".parse().unwrap(),
-        inbox: "https://localhost/123/inbox".parse().unwrap(),
-        public_key: DB_USER_KEYPAIR.public_key.clone(),
-        private_key: Some(DB_USER_KEYPAIR.private_key.clone()),
-        followers: vec![],
-        local: false,
-    });
-
-    #[async_trait]
-    impl Object for DbUser {
-        type DataType = DbConnection;
-        type Kind = Person;
-        type Error = Error;
-
-        async fn read_from_id(
-            _object_id: Url,
-            _data: &Data<Self::DataType>,
-        ) -> Result<Option<Self>, Self::Error> {
-            Ok(Some(DB_USER.clone()))
-        }
-
-        async fn into_json(self, _data: &Data<Self::DataType>) -> Result<Self::Kind, Self::Error> {
-            Ok(Person {
-                preferred_username: self.name.clone(),
-                kind: Default::default(),
-                id: self.federation_id.clone().into(),
-                inbox: self.inbox.clone(),
-                public_key: self.public_key(),
-            })
-        }
-
-        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> {
-            Ok(DbUser {
-                name: json.preferred_username,
-                federation_id: json.id.into(),
-                inbox: json.inbox,
-                public_key: json.public_key.public_key_pem,
-                private_key: None,
-                followers: vec![],
-                local: false,
-            })
-        }
-    }
-
-    impl Actor for DbUser {
-        fn id(&self) -> Url {
-            self.federation_id.clone()
-        }
-
-        fn public_key_pem(&self) -> &str {
-            &self.public_key
-        }
-
-        fn private_key_pem(&self) -> Option<String> {
-            self.private_key.clone()
-        }
-
-        fn inbox(&self) -> Url {
-            self.inbox.clone()
-        }
-    }
-
-    #[derive(Deserialize, Serialize, Clone, Debug)]
-    #[serde(rename_all = "camelCase")]
-    pub struct Follow {
-        pub actor: ObjectId<DbUser>,
-        pub object: ObjectId<DbUser>,
-        #[serde(rename = "type")]
-        pub kind: FollowType,
-        pub id: Url,
-    }
-
-    #[async_trait]
-    impl ActivityHandler for Follow {
-        type DataType = DbConnection;
-        type Error = Error;
-
-        fn id(&self) -> &Url {
-            &self.id
-        }
-
-        fn actor(&self) -> &Url {
-            self.actor.inner()
-        }
-
-        async fn verify(&self, _: &Data<Self::DataType>) -> Result<(), Self::Error> {
-            Ok(())
-        }
-
-        async fn receive(self, _data: &Data<Self::DataType>) -> Result<(), Self::Error> {
-            Ok(())
-        }
-    }
-
-    #[derive(Clone, Debug, Deserialize, Serialize)]
-    #[serde(rename_all = "camelCase")]
-    pub struct Note {}
-    #[derive(Debug, Clone)]
-    pub struct DbPost {}
-
-    #[async_trait]
-    impl Object for DbPost {
-        type DataType = DbConnection;
-        type Kind = Note;
-        type Error = Error;
-
-        async fn read_from_id(
-            _: Url,
-            _: &Data<Self::DataType>,
-        ) -> Result<Option<Self>, Self::Error> {
-            todo!()
-        }
-
-        async fn into_json(self, _: &Data<Self::DataType>) -> Result<Self::Kind, Self::Error> {
-            todo!()
-        }
-
-        async fn verify(
-            _: &Self::Kind,
-            _: &Url,
-            _: &Data<Self::DataType>,
-        ) -> Result<(), Self::Error> {
-            todo!()
-        }
-
-        async fn from_json(_: Self::Kind, _: &Data<Self::DataType>) -> Result<Self, Self::Error> {
-            todo!()
-        }
-    }
-}
--- a/src/traits/tests.rs
+++ b/src/traits/tests.rs
@ -0,0 +1,201 @@
+#![doc(hidden)]
+#![allow(clippy::unwrap_used)]
+//! Some impls of these traits for use in tests. Dont use this from external crates.
+//!
+//! TODO: Should be using `cfg[doctest]` but blocked by <https://github.com/rust-lang/rust/issues/67295>
+
+use super::{async_trait, Activity, Actor, Data, Debug, Object, PublicKey, Url};
+use crate::{
+    error::Error,
+    fetch::object_id::ObjectId,
+    http_signatures::{generate_actor_keypair, Keypair},
+    protocol::verification::verify_domains_match,
+};
+use activitystreams_kinds::{activity::FollowType, actor::PersonType};
+use serde::{Deserialize, Serialize};
+use std::sync::LazyLock;
+
+#[derive(Clone)]
+pub struct DbConnection;
+
+impl DbConnection {
+    pub async fn read_post_from_json_id<T>(&self, _: Url) -> Result<Option<T>, Error> {
+        Ok(None)
+    }
+    pub async fn read_local_user(&self, _: &str) -> Result<DbUser, Error> {
+        todo!()
+    }
+    pub async fn upsert<T>(&self, _: &T) -> Result<(), Error> {
+        Ok(())
+    }
+    pub async fn add_follower(&self, _: DbUser, _: DbUser) -> Result<(), Error> {
+        Ok(())
+    }
+}
+
+#[derive(Clone, Debug, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Person {
+    #[serde(rename = "type")]
+    pub kind: PersonType,
+    pub preferred_username: String,
+    pub id: ObjectId<DbUser>,
+    pub inbox: Url,
+    pub public_key: PublicKey,
+}
+#[derive(Debug, Clone)]
+pub struct DbUser {
+    pub name: String,
+    pub federation_id: Url,
+    pub inbox: Url,
+    pub public_key: String,
+    #[allow(dead_code)]
+    private_key: Option<String>,
+    pub followers: Vec<Url>,
+    pub local: bool,
+}
+
+pub static DB_USER_KEYPAIR: LazyLock<Keypair> = LazyLock::new(|| generate_actor_keypair().unwrap());
+
+pub static DB_USER: LazyLock<DbUser> = LazyLock::new(|| DbUser {
+    name: String::new(),
+    federation_id: "https://localhost/123".parse().unwrap(),
+    inbox: "https://localhost/123/inbox".parse().unwrap(),
+    public_key: DB_USER_KEYPAIR.public_key.clone(),
+    private_key: Some(DB_USER_KEYPAIR.private_key.clone()),
+    followers: vec![],
+    local: false,
+});
+
+#[async_trait]
+impl Object for DbUser {
+    type DataType = DbConnection;
+    type Kind = Person;
+    type Error = Error;
+
+    fn id(&self) -> Url {
+        self.federation_id.clone()
+    }
+
+    async fn read_from_id(
+        _object_id: Url,
+        _data: &Data<Self::DataType>,
+    ) -> Result<Option<Self>, Self::Error> {
+        Ok(Some(DB_USER.clone()))
+    }
+
+    async fn into_json(self, _data: &Data<Self::DataType>) -> Result<Self::Kind, Self::Error> {
+        Ok(Person {
+            preferred_username: self.name.clone(),
+            kind: Default::default(),
+            id: self.federation_id.clone().into(),
+            inbox: self.inbox.clone(),
+            public_key: self.public_key(),
+        })
+    }
+
+    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> {
+        Ok(DbUser {
+            name: json.preferred_username,
+            federation_id: json.id.into(),
+            inbox: json.inbox,
+            public_key: json.public_key.public_key_pem,
+            private_key: None,
+            followers: vec![],
+            local: false,
+        })
+    }
+}
+
+impl Actor for DbUser {
+    fn public_key_pem(&self) -> &str {
+        &self.public_key
+    }
+
+    fn private_key_pem(&self) -> Option<String> {
+        self.private_key.clone()
+    }
+
+    fn inbox(&self) -> Url {
+        self.inbox.clone()
+    }
+}
+
+#[derive(Deserialize, Serialize, Clone, Debug)]
+#[serde(rename_all = "camelCase")]
+pub struct Follow {
+    pub actor: ObjectId<DbUser>,
+    pub object: ObjectId<DbUser>,
+    #[serde(rename = "type")]
+    pub kind: FollowType,
+    pub id: Url,
+}
+
+#[async_trait]
+impl Activity for Follow {
+    type DataType = DbConnection;
+    type Error = Error;
+
+    fn id(&self) -> &Url {
+        &self.id
+    }
+
+    fn actor(&self) -> &Url {
+        self.actor.inner()
+    }
+
+    async fn verify(&self, _: &Data<Self::DataType>) -> Result<(), Self::Error> {
+        Ok(())
+    }
+
+    async fn receive(self, _data: &Data<Self::DataType>) -> Result<(), Self::Error> {
+        Ok(())
+    }
+}
+
+#[derive(Clone, Debug, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Note {}
+#[derive(Debug, Clone)]
+pub struct DbPost {
+    pub federation_id: Url,
+}
+
+#[async_trait]
+impl Object for DbPost {
+    type DataType = DbConnection;
+    type Kind = Note;
+    type Error = Error;
+
+    fn id(&self) -> Url {
+        todo!()
+    }
+
+    async fn read_from_id(_: Url, _: &Data<Self::DataType>) -> Result<Option<Self>, Self::Error> {
+        todo!()
+    }
+
+    async fn into_json(self, _: &Data<Self::DataType>) -> Result<Self::Kind, Self::Error> {
+        todo!()
+    }
+
+    async fn verify(_: &Self::Kind, _: &Url, _: &Data<Self::DataType>) -> Result<(), Self::Error> {
+        todo!()
+    }
+
+    async fn from_json(_: Self::Kind, _: &Data<Self::DataType>) -> Result<Self, Self::Error> {
+        todo!()
+    }
+}
--- a/src/utils.rs
+++ b/src/utils.rs
@ -0,0 +1,78 @@
+use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};
+
+use crate::error::Error;
+use tokio::net::lookup_host;
+use url::{Host, Url};
+
+// TODO: Use is_global() once stabilized
+//       https://doc.rust-lang.org/std/net/enum.IpAddr.html#method.is_global
+pub(crate) async fn validate_ip(url: &Url) -> Result<(), Error> {
+    let mut ip = vec![];
+    let host = url
+        .host()
+        .ok_or(Error::UrlVerificationError("Url must have a domain"))?;
+    match host {
+        Host::Domain(domain) => ip.extend(
+            lookup_host((domain.to_owned(), 80))
+                .await?
+                .map(|s| s.ip().to_canonical()),
+        ),
+        Host::Ipv4(ipv4) => ip.push(ipv4.into()),
+        Host::Ipv6(ipv6) => ip.push(ipv6.into()),
+    };
+
+    let invalid_ip = ip.into_iter().any(|addr| match addr {
+        IpAddr::V4(addr) => v4_is_invalid(addr),
+        IpAddr::V6(addr) => v6_is_invalid(addr),
+    });
+    if invalid_ip {
+        return Err(Error::DomainResolveError(host.to_string()));
+    }
+    Ok(())
+}
+
+fn v4_is_invalid(v4: Ipv4Addr) -> bool {
+    v4.is_private()
+        || v4.is_loopback()
+        || v4.is_link_local()
+        || v4.is_multicast()
+        || v4.is_documentation()
+        || v4.is_unspecified()
+        || v4.is_broadcast()
+}
+
+fn v6_is_invalid(v6: Ipv6Addr) -> bool {
+    v6.is_loopback()
+        || v6.is_multicast()
+        || v6.is_unique_local()
+        || v6.is_unicast_link_local()
+        || v6.is_unspecified()
+        || v6_is_documentation(v6)
+        || v6.to_ipv4_mapped().is_some_and(v4_is_invalid)
+}
+
+fn v6_is_documentation(v6: std::net::Ipv6Addr) -> bool {
+    matches!(
+        v6.segments(),
+        [0x2001, 0xdb8, ..] | [0x3fff, 0..=0x0fff, ..]
+    )
+}
+
+#[cfg(test)]
+#[allow(clippy::unwrap_used)]
+mod test {
+    use super::*;
+
+    #[tokio::test]
+    async fn test_is_valid_ip() -> Result<(), Error> {
+        assert!(validate_ip(&Url::parse("http://example.com")?)
+            .await
+            .is_ok());
+        assert!(validate_ip(&Url::parse("http://172.66.147.243")?)
+            .await
+            .is_ok());
+        assert!(validate_ip(&Url::parse("http://localhost")?).await.is_err());
+        assert!(validate_ip(&Url::parse("http://127.0.0.1")?).await.is_err());
+        Ok(())
+    }
+}
Author	SHA1	Message	Date
Evie Viau-Chow-Stuart	754b2a0f3d	Revert Object trait id() ref	2026-04-25 22:40:47 -07:00
Felix Ableitner	588f431266	Version 0.7.0-beta.11	2026-04-24 11:31:10 +02:00
Hong Minhee (洪民憙)	838dd9e501	Add a public-aware deserializer for recipient URLs (#165 ) * Accept Public aliases in URL deserializer Update deserialize_one_or_many to deserialize recipient URL fields while accepting `Public` and `as:Public` as aliases for the canonical ActivityStreams public URL. Add focused tests for single and array inputs, and verify that unrelated string fields such as `content` are left unchanged. https://github.com/LemmyNet/lemmy/issues/6465 * Deduplicate deserialized recipients Drop repeated recipient URLs after deserialization so equivalent public aliases such as `Public`, `as:Public`, and the canonical public URL do not produce duplicate entries. Update the helper documentation and tests to match the deduplicated result.	2026-04-24 11:25:06 +02:00
Felix Ableitner	279d29d350	Version 0.7.0-beta.10	2026-04-15 13:39:03 +02:00
Nutomic	fcb69ebffe	Make IP check public (#164 ) * Make IP check public * change	2026-04-15 13:38:29 +02:00
Felix Ableitner	5e8e918003	Version 0.7.0-beta.9	2026-03-16 11:39:46 +01:00
Nutomic	4ae8532b17	Add some more IP checks (#162 )	2026-03-16 11:11:01 +01:00
Nutomic	f47fe58285	Better IP check (#161 )	2026-02-05 07:04:08 -05:00
Nutomic	f60afae428	Add to_canonical() for ip check (#160 )	2026-02-04 12:05:59 +01:00
Nutomic	11f95ff384	Improve error message, allow local IP federation via env var (#158 ) * Improve error message, allow local IP federation via env var (fixes #152) * fix	2026-01-28 08:44:39 -05:00
Nutomic	9d7bd965a4	Upgrade reqwest (#159 )	2026-01-28 14:40:03 +01:00
Nutomic	b5dd86ab07	Update deps (#157 )	2026-01-12 08:44:16 -05:00
Nutomic	a7da04c2d8	Revert parse order for webfinger results so community comes first (#156 )	2025-12-05 08:42:53 -05:00
Brad Dunbar	2acf037d79	Fix example path params (#153 ) Resolves the following error: thread 'main' (6023907) panicked at examples/live_federation/main.rs:58:10: Path segments must not start with `:`. For capture groups, use `{capture}`. If you meant to literally match a segment starting with a colon, call `without_v07_checks` on the router.	2025-11-21 10:03:20 +01:00
Brad Dunbar	99505b9567	Webfinger: impl PartialEq (#155 ) It'd be nice to be able to compare these in tests.	2025-11-21 09:53:13 +01:00
Brad Dunbar	06df2bc1d1	Fix future incompatibility warning (#154 ) These warnings are fixed in the [0.8.x branch][commits] of `num-bigint-dig`. warning: the following packages contain code that will be rejected by a future version of Rust: num-bigint-dig v0.8.4 [commits]: https://github.com/dignifiedquire/num-bigint/commits/0-8	2025-11-21 09:52:53 +01:00
Nutomic	8b2b746707	Handle null values with deserialize_last (#151 )	2025-10-17 21:09:32 +08:00
Felix Ableitner	545afcc719	Version 0.7.0-beta.8	2025-10-15 12:40:30 +02:00
Nutomic	105d13003a	Increase reqwest max body size (#150 )	2025-10-15 18:39:56 +08:00
Felix Ableitner	ec098cfaed	0.7.0-beta.7	2025-10-02 11:35:55 +02:00
Nutomic	1df24ab781	Return deleted object on resolve (#149 )	2025-10-02 17:30:12 +08:00
Felix Ableitner	6c97312f25	Version 0.7.0-beta.6	2025-07-28 11:23:03 +02:00
Nutomic	cd0f009f5f	Add helper deserialize_last() (#148 )	2025-07-28 11:22:36 +02:00
Felix Ableitner	0d0f498ddd	0.7.0-beta.5	2025-07-10 10:29:02 +02:00
Nutomic	fa27a0c0b4	Various additions and changes (#147 ) * Add methods Object.id(), Object.deleted() * Rename ActivityHandler to Activity * comments * fix * comment	2025-07-10 10:26:45 +02:00
Felix Ableitner	e18b13e253	Version 0.7.0-beta.4	2025-06-18 11:39:14 +02:00
Nutomic	659a6a3cff	Add hook for incoming activities (#146 ) * Add hook for incoming activities * sync version working * async working * remove generic * separate methods * testing * use trait to allow references	2025-06-18 11:38:34 +02:00
Felix Ableitner	7e876dd5ce	0.7.0-beta.3	2025-06-16 11:33:47 +02:00
dullbananas	6efa33f006	Implement Clone for Data struct (#145 ) * add clone impl * fmt * wrap field instead of implementing clone for whole data struct	2025-06-16 11:33:10 +02:00
Felix Ableitner	9d8e67bfbe	Version 0.7.0-beta.2	2025-06-05 15:41:49 +02:00
Felix Ableitner	0c583ed6ee	Feature flag for axum-original-uri	2025-06-05 15:40:49 +02:00
Felix Ableitner	ae7910e5f5	0.7.0-beta.1	2025-06-02 10:58:24 +02:00
Kevin Kuriakose	7994df3706	Use `OriginalUri` for Axum `ActivityData` (#141 ) * Use OriginalUri for axum ActivityData When the inbox path is under a nested `Router`, the received request has a URI with the common prefix stripped. This causes incoming signatures to be considered invalid since the path is different (see https://github.com/LemmyNet/activitypub-federation-rust/issues/107#issuecomment-2767428107) This commit uses `OriginalUri` for URI extraction instead, which will retrieve the full URI regardless of router nesting * Use router nesting for local_federation With `8c787f5`, router nesting is supported correctly in axum * Fix docs typo (#143) --------- Co-authored-by: Zami <szgie@proton.me> Co-authored-by: Felix Ableitner <me@nutomic.com>	2025-06-02 04:56:25 -04:00
Nutomic	80dce32279	Upgrade deps (#135 ) * Upgrade deps (#133) * Upgrade deps * fmt * fix * remove once_cell * upgrade rust * fix warnings * Upgrading deps. (#137) * Upgrading deps. * Axum upgrade. * Remove some uses of async_trait * Remove diesel feature * Rust 1.85 * fix once lock for domain regex * Revert "Remove some uses of async_trait" This reverts commit `51bf4b332e`. * update deps * Make it work with Lemmy --------- Co-authored-by: Dessalines <dessalines@users.noreply.github.com>	2025-06-02 04:39:58 -04:00
Zami	b13c1cc092	Fix docs typo (#143 )	2025-04-28 11:41:32 -04:00
Felix Ableitner	4c1c0f7928	0.6.5	2025-03-28 11:23:56 +01:00
Nutomic	b3dac33990	Fixes for either impl (#140 ) * Fixes for either impl * link	2025-03-27 15:58:45 +01:00