diff --git a/.doctor.exs b/.doctor.exs
new file mode 100644
index 000000000..bbbcb1585
--- /dev/null
+++ b/.doctor.exs
@@ -0,0 +1,15 @@
+%Doctor.Config{
+  exception_moduledoc_required: true,
+  failed: false,
+  ignore_modules: [Mobilizon.Web, Mobilizon.GraphQL.Schema, Mobilizon.Service.Activity.Renderer, Mobilizon.Service.Workers.Helper],
+  ignore_paths: [],
+  min_module_doc_coverage: 100,
+  min_module_spec_coverage: 50,
+  min_overall_doc_coverage: 100,
+  min_overall_spec_coverage: 90,
+  moduledoc_required: true,
+  raise: false,
+  reporter: Doctor.Reporters.Full,
+  struct_type_spec_required: true,
+  umbrella: false
+}
diff --git a/config/config.exs b/config/config.exs
index 9f125f79e..92d02872f 100644
--- a/config/config.exs
+++ b/config/config.exs
@@ -179,6 +179,8 @@ config :phoenix, :filter_parameters, ["password", "token"]
 config :absinthe, schema: Mobilizon.GraphQL.Schema
 config :absinthe, Absinthe.Logger, filter_variables: ["token", "password", "secret"]
 
+config :mobilizon, Mobilizon.Web.Gettext, one_module_per_locale: true
+
 config :ex_cldr,
   default_locale: "en",
   default_backend: Mobilizon.Cldr
@@ -189,7 +191,8 @@ config :http_signatures,
 config :mobilizon, :cldr,
   locales: [
     "fr",
-    "en"
+    "en",
+    "ru"
   ]
 
 config :mobilizon, :activitypub,
diff --git a/config/dev.exs b/config/dev.exs
index 660e6dd58..291bdc463 100644
--- a/config/dev.exs
+++ b/config/dev.exs
@@ -58,6 +58,8 @@ config :logger, :console, format: "[$level] $message\n", level: :debug
 
 config :mobilizon, Mobilizon.Service.Geospatial, service: Mobilizon.Service.Geospatial.Nominatim
 
+config :mobilizon, Mobilizon.Web.Gettext, allowed_locales: ["fr", "en"]
+
 # Set a higher stacktrace during development. Avoid configuring such
 # in production as building large stacktraces may be expensive.
 config :phoenix, :stacktrace_depth, 20
diff --git a/config/test.exs b/config/test.exs
index 4f024d17c..86dce9eb7 100644
--- a/config/test.exs
+++ b/config/test.exs
@@ -77,6 +77,8 @@ config :mobilizon, Mobilizon.Web.Auth.Guardian, secret_key: "some secret"
 
 config :mobilizon, :activitypub, sign_object_fetches: false
 
+config :mobilizon, Mobilizon.Web.Gettext, allowed_locales: ["fr", "en", "es", "ru"]
+
 config :junit_formatter, report_dir: "."
 
 if System.get_env("DOCKER", "false") == "false" && File.exists?("./config/test.secret.exs") do
diff --git a/js/src/components/Event/TagInput.vue b/js/src/components/Event/TagInput.vue
index 6537e50b8..e866819ba 100644
--- a/js/src/components/Event/TagInput.vue
+++ b/js/src/components/Event/TagInput.vue
@@ -29,19 +29,28 @@
 </template>
 <script lang="ts">
 import { Component, Prop, Vue } from "vue-property-decorator";
-import get from "lodash/get";
 import differenceBy from "lodash/differenceBy";
 import { ITag } from "../../types/tag.model";
+import { FILTER_TAGS } from "@/graphql/tags";
 
-@Component
+@Component({
+  apollo: {
+    tags: {
+      query: FILTER_TAGS,
+      variables() {
+        return {
+          filter: this.text,
+        };
+      },
+    },
+  },
+})
 export default class TagInput extends Vue {
-  @Prop({ required: false, default: () => [] }) data!: ITag[];
-
-  @Prop({ required: true, default: "value" }) path!: string;
-
   @Prop({ required: true }) value!: ITag[];
 
-  filteredTags: ITag[] = [];
+  tags!: ITag[];
+
+  text = "";
 
   private static componentId = 0;
 
@@ -53,13 +62,20 @@ export default class TagInput extends Vue {
     return `tag-input-${TagInput.componentId}`;
   }
 
-  getFilteredTags(text: string): void {
-    this.filteredTags = differenceBy(this.data, this.value, "id").filter(
+  async getFilteredTags(text: string): Promise<void> {
+    this.text = text;
+    await this.$apollo.queries.tags.refetch();
+  }
+
+  get filteredTags(): ITag[] {
+    return differenceBy(this.tags, this.value, "id").filter(
       (option) =>
-        get(option, this.path)
+        option.title
           .toString()
           .toLowerCase()
-          .indexOf(text.toLowerCase()) >= 0
+          .indexOf(this.text.toLowerCase()) >= 0 ||
+        option.slug.toString().toLowerCase().indexOf(this.text.toLowerCase()) >=
+          0
     );
   }
 
diff --git a/js/src/graphql/tags.ts b/js/src/graphql/tags.ts
index e59b4428c..eadd78ab8 100644
--- a/js/src/graphql/tags.ts
+++ b/js/src/graphql/tags.ts
@@ -9,16 +9,22 @@ export const TAG_FRAGMENT = gql`
 `;
 
 export const TAGS = gql`
-  query {
+  query Tags {
     tags {
-      id
       related {
-        id
-        slug
-        title
+        ...TagFragment
       }
-      slug
-      title
+      ...TagFragment
     }
   }
+  ${TAG_FRAGMENT}
+`;
+
+export const FILTER_TAGS = gql`
+  query FilterTags($filter: String) {
+    tags(filter: $filter) {
+      ...TagFragment
+    }
+  }
+  ${TAG_FRAGMENT}
 `;
diff --git a/js/src/i18n/es.json b/js/src/i18n/es.json
index 709428511..42d3b57a6 100644
--- a/js/src/i18n/es.json
+++ b/js/src/i18n/es.json
@@ -21,7 +21,6 @@
   "A discussion has been created or updated": "Se ha creado o actualizado una discusión",
   "A federated software": "Un software federado",
   "A fediverse account URL to follow for event updates": "Una URL de cuenta de fediverse a seguir para actualizaciones de eventos",
-  "A group with this name already exists": "Ya existe un grupo con este nombre",
   "A link to a page presenting the event schedule": "Un enlace a una página que presenta el calendario del evento",
   "A link to a page presenting the price options": "Un enlace a una página que presenta las opciones de precio",
   "A member has been updated": "Un miembro ha sido actualizado",
diff --git a/js/src/i18n/fr_FR.json b/js/src/i18n/fr_FR.json
index b7c34c035..d50acb09d 100644
--- a/js/src/i18n/fr_FR.json
+++ b/js/src/i18n/fr_FR.json
@@ -19,7 +19,6 @@
   "A discussion has been created or updated": "Une discussion a été créée ou mise à jour",
   "A federated software": "Un logiciel fédéré",
   "A fediverse account URL to follow for event updates": "Un compte sur le fediverse à suivre pour les mises à jour de l'événement",
-  "A group with this name already exists": "Un groupe avec ce nom existe déjà",
   "A link to a page presenting the event schedule": "Un lien vers une page présentant le programme de l'événement",
   "A link to a page presenting the price options": "Un lien vers une page présentant la tarification",
   "A member has been updated": "Un membre a été mis à jour",
diff --git a/js/src/views/Event/Edit.vue b/js/src/views/Event/Edit.vue
index 8c0f53b7b..0aa02ec65 100644
--- a/js/src/views/Event/Edit.vue
+++ b/js/src/views/Event/Edit.vue
@@ -31,7 +31,7 @@
           />
         </b-field>
 
-        <tag-input v-model="event.tags" :data="tags" path="title" />
+        <tag-input v-model="event.tags" />
 
         <b-field
           horizontal
@@ -556,8 +556,6 @@ import {
   IPerson,
   usernameWithDomain,
 } from "../../types/actor";
-import { TAGS } from "../../graphql/tags";
-import { ITag } from "../../types/tag.model";
 import {
   buildFileFromIMedia,
   buildFileVariable,
@@ -590,7 +588,6 @@ const DEFAULT_LIMIT_NUMBER_OF_PLACES = 10;
   },
   apollo: {
     currentActor: CURRENT_ACTOR_CLIENT,
-    tags: TAGS,
     config: CONFIG,
     identities: IDENTITIES,
     event: {
@@ -643,8 +640,6 @@ export default class EditEvent extends Vue {
 
   currentActor!: IActor;
 
-  tags: ITag[] = [];
-
   event: IEvent = new EventModel();
 
   unmodifiedEvent: IEvent = new EventModel();
diff --git a/js/src/views/Posts/Edit.vue b/js/src/views/Posts/Edit.vue
index f624148aa..682bfa2b8 100644
--- a/js/src/views/Posts/Edit.vue
+++ b/js/src/views/Posts/Edit.vue
@@ -67,7 +67,7 @@
           />
         </b-field>
 
-        <tag-input v-model="editablePost.tags" :data="tags" path="title" />
+        <tag-input v-model="editablePost.tags" />
 
         <div class="field">
           <label class="label">{{ $t("Post") }}</label>
@@ -166,7 +166,6 @@ import {
 } from "@/utils/image";
 import GroupMixin from "@/mixins/group";
 import { PostVisibility } from "@/types/enums";
-import { TAGS } from "../../graphql/tags";
 import { CONFIG } from "../../graphql/config";
 import {
   FETCH_POST,
@@ -187,7 +186,6 @@ import { FETCH_GROUP } from "@/graphql/group";
 
 @Component({
   apollo: {
-    tags: TAGS,
     config: CONFIG,
     group: {
       query: FETCH_GROUP,
diff --git a/js/src/views/Settings/AccountSettings.vue b/js/src/views/Settings/AccountSettings.vue
index 9c5a9e03f..4063081e3 100644
--- a/js/src/views/Settings/AccountSettings.vue
+++ b/js/src/views/Settings/AccountSettings.vue
@@ -320,6 +320,8 @@ export default class AccountSettings extends Vue {
         },
       });
 
+      this.oldPassword = "";
+      this.newPassword = "";
       this.$notifier.success(
         this.$t("The password was successfully changed") as string
       );
diff --git a/lib/config_provider.ex b/lib/config_provider.ex
index 6b393f23a..e199b0ead 100644
--- a/lib/config_provider.ex
+++ b/lib/config_provider.ex
@@ -4,8 +4,10 @@ defmodule Mobilizon.ConfigProvider do
   """
   @behaviour Config.Provider
 
+  @spec init(String.t()) :: String.t()
   def init(path) when is_binary(path), do: path
 
+  @spec load(Keyword.t(), String.t()) :: Keyword.t()
   def load(config, path) do
     config_path = System.get_env("MOBILIZON_CONFIG_PATH") || path
 
diff --git a/lib/federation/activity_pub/actions/accept.ex b/lib/federation/activity_pub/actions/accept.ex
new file mode 100644
index 000000000..63d153035
--- /dev/null
+++ b/lib/federation/activity_pub/actions/accept.ex
@@ -0,0 +1,169 @@
+defmodule Mobilizon.Federation.ActivityPub.Actions.Accept do
+  @moduledoc """
+  Accept things
+  """
+
+  alias Mobilizon.{Actors, Events}
+  alias Mobilizon.Actors.{Actor, Follower, Member}
+  alias Mobilizon.Events.Participant
+  alias Mobilizon.Federation.ActivityPub.{Audience, Refresher}
+  alias Mobilizon.Federation.ActivityStream
+  alias Mobilizon.Federation.ActivityStream.Convertible
+  alias Mobilizon.Service.Notifications.Scheduler
+  alias Mobilizon.Web.Endpoint
+  require Logger
+
+  import Mobilizon.Federation.ActivityPub.Utils,
+    only: [
+      make_accept_join_data: 2,
+      create_activity: 2,
+      maybe_federate: 1,
+      maybe_relay_if_group_activity: 1
+    ]
+
+  @type acceptable_types :: :join | :follow | :invite
+  @type acceptable_entities ::
+          accept_join_entities | accept_follow_entities | accept_invite_entities
+
+  @spec accept(acceptable_types, acceptable_entities, boolean, map) ::
+          {:ok, ActivityStream.t(), acceptable_entities}
+  def accept(type, entity, local \\ true, additional \\ %{}) do
+    Logger.debug("We're accepting something")
+
+    accept_res =
+      case type do
+        :join -> accept_join(entity, additional)
+        :follow -> accept_follow(entity, additional)
+        :invite -> accept_invite(entity, additional)
+      end
+
+    with {:ok, entity, update_data} <- accept_res do
+      {:ok, activity} = create_activity(update_data, local)
+      maybe_federate(activity)
+      maybe_relay_if_group_activity(activity)
+      {:ok, activity, entity}
+    end
+  end
+
+  @type accept_follow_entities :: Follower.t()
+
+  @spec accept_follow(Follower.t(), map) ::
+          {:ok, Follower.t(), Activity.t()} | {:error, Ecto.Changeset.t()}
+  defp accept_follow(%Follower{} = follower, additional) do
+    with {:ok, %Follower{} = follower} <- Actors.update_follower(follower, %{approved: true}) do
+      follower_as_data = Convertible.model_to_as(follower)
+
+      update_data =
+        make_accept_join_data(
+          follower_as_data,
+          Map.merge(additional, %{
+            "id" => "#{Endpoint.url()}/accept/follow/#{follower.id}",
+            "to" => [follower.actor.url],
+            "cc" => [],
+            "actor" => follower.target_actor.url
+          })
+        )
+
+      {:ok, follower, update_data}
+    end
+  end
+
+  @type accept_join_entities :: Participant.t() | Member.t()
+
+  @spec accept_join(Participant.t() | Member.t(), map) ::
+          {:ok, Participant.t() | Member.t(), Activity.t()} | {:error, Ecto.Changeset.t()}
+  defp accept_join(%Participant{} = participant, additional) do
+    with {:ok, %Participant{} = participant} <-
+           Events.update_participant(participant, %{role: :participant}) do
+      Absinthe.Subscription.publish(Endpoint, participant.actor,
+        event_person_participation_changed: participant.actor.id
+      )
+
+      Scheduler.trigger_notifications_for_participant(participant)
+      participant_as_data = Convertible.model_to_as(participant)
+      audience = Audience.get_audience(participant)
+
+      accept_join_data =
+        make_accept_join_data(
+          participant_as_data,
+          Map.merge(Map.merge(audience, additional), %{
+            "id" => "#{Endpoint.url()}/accept/join/#{participant.id}"
+          })
+        )
+
+      {:ok, participant, accept_join_data}
+    end
+  end
+
+  defp accept_join(%Member{} = member, additional) do
+    with {:ok, %Member{} = member} <-
+           Actors.update_member(member, %{role: :member}) do
+      Mobilizon.Service.Activity.Member.insert_activity(member,
+        subject: "member_approved"
+      )
+
+      maybe_refresh_group(member)
+
+      Absinthe.Subscription.publish(Endpoint, member.actor,
+        group_membership_changed: [
+          Actor.preferred_username_and_domain(member.parent),
+          member.actor.id
+        ]
+      )
+
+      member_as_data = Convertible.model_to_as(member)
+      audience = Audience.get_audience(member)
+
+      accept_join_data =
+        make_accept_join_data(
+          member_as_data,
+          Map.merge(Map.merge(audience, additional), %{
+            "id" => "#{Endpoint.url()}/accept/join/#{member.id}"
+          })
+        )
+
+      {:ok, member, accept_join_data}
+    end
+  end
+
+  @type accept_invite_entities :: Member.t()
+
+  @spec accept_invite(Member.t(), map()) ::
+          {:ok, Member.t(), Activity.t()} | {:error, Ecto.Changeset.t()}
+  defp accept_invite(
+         %Member{invited_by_id: invited_by_id, actor_id: actor_id} = member,
+         _additional
+       ) do
+    with %Actor{} = inviter <- Actors.get_actor!(invited_by_id),
+         %Actor{url: actor_url} <- Actors.get_actor!(actor_id),
+         {:ok, %Member{id: member_id} = member} <-
+           Actors.update_member(member, %{role: :member}) do
+      Mobilizon.Service.Activity.Member.insert_activity(member,
+        subject: "member_accepted_invitation"
+      )
+
+      maybe_refresh_group(member)
+
+      accept_data = %{
+        "type" => "Accept",
+        "attributedTo" => member.parent.url,
+        "to" => [inviter.url, member.parent.members_url],
+        "cc" => [member.parent.url],
+        "actor" => actor_url,
+        "object" => Convertible.model_to_as(member),
+        "id" => "#{Endpoint.url()}/accept/invite/member/#{member_id}"
+      }
+
+      {:ok, member, accept_data}
+    end
+  end
+
+  @spec maybe_refresh_group(Member.t()) :: :ok | nil
+  defp maybe_refresh_group(%Member{
+         parent: %Actor{domain: parent_domain, url: parent_url},
+         actor: %Actor{} = actor
+       }) do
+    unless is_nil(parent_domain),
+      do: Refresher.fetch_group(parent_url, actor)
+  end
+end
diff --git a/lib/federation/activity_pub/actions/announce.ex b/lib/federation/activity_pub/actions/announce.ex
new file mode 100644
index 000000000..125b563c0
--- /dev/null
+++ b/lib/federation/activity_pub/actions/announce.ex
@@ -0,0 +1,60 @@
+defmodule Mobilizon.Federation.ActivityPub.Actions.Announce do
+  @moduledoc """
+  Announce things
+  """
+  alias Mobilizon.Actors.Actor
+  alias Mobilizon.Federation.ActivityPub.Activity
+  alias Mobilizon.Federation.ActivityPub.Actor, as: ActivityPubActor
+  alias Mobilizon.Federation.ActivityStream
+  alias Mobilizon.Share
+
+  import Mobilizon.Federation.ActivityPub.Utils,
+    only: [
+      create_activity: 2,
+      maybe_federate: 1,
+      make_announce_data: 3,
+      make_announce_data: 4,
+      make_unannounce_data: 3
+    ]
+
+  @doc """
+  Announce (reshare) an activity to the world, using an activity of type `Announce`.
+  """
+  @spec announce(Actor.t(), ActivityStream.t(), String.t() | nil, boolean, boolean) ::
+          {:ok, Activity.t(), ActivityStream.t()} | {:error, any()}
+  def announce(
+        %Actor{} = actor,
+        object,
+        activity_id \\ nil,
+        local \\ true,
+        public \\ true
+      ) do
+    with {:ok, %Actor{id: object_owner_actor_id}} <-
+           ActivityPubActor.get_or_fetch_actor_by_url(object["actor"]),
+         {:ok, %Share{} = _share} <- Share.create(object["id"], actor.id, object_owner_actor_id) do
+      announce_data = make_announce_data(actor, object, activity_id, public)
+      {:ok, activity} = create_activity(announce_data, local)
+      :ok = maybe_federate(activity)
+      {:ok, activity, object}
+    end
+  end
+
+  @doc """
+  Cancel the announcement of an activity to the world, using an activity of type `Undo` an `Announce`.
+  """
+  @spec unannounce(Actor.t(), ActivityStream.t(), String.t() | nil, String.t() | nil, boolean) ::
+          {:ok, Activity.t(), ActivityStream.t()}
+  def unannounce(
+        %Actor{} = actor,
+        object,
+        activity_id \\ nil,
+        cancelled_activity_id \\ nil,
+        local \\ true
+      ) do
+    announce_activity = make_announce_data(actor, object, cancelled_activity_id)
+    unannounce_data = make_unannounce_data(actor, announce_activity, activity_id)
+    {:ok, unannounce_activity} = create_activity(unannounce_data, local)
+    maybe_federate(unannounce_activity)
+    {:ok, unannounce_activity, object}
+  end
+end
diff --git a/lib/federation/activity_pub/actions/create.ex b/lib/federation/activity_pub/actions/create.ex
new file mode 100644
index 000000000..fb2d1b3ba
--- /dev/null
+++ b/lib/federation/activity_pub/actions/create.ex
@@ -0,0 +1,71 @@
+defmodule Mobilizon.Federation.ActivityPub.Actions.Create do
+  @moduledoc """
+  Create things
+  """
+  alias Mobilizon.Tombstone
+  alias Mobilizon.Federation.ActivityPub.{Activity, Types}
+  require Logger
+
+  import Mobilizon.Federation.ActivityPub.Utils,
+    only: [
+      create_activity: 2,
+      maybe_federate: 1,
+      maybe_relay_if_group_activity: 1
+    ]
+
+  @type create_entities ::
+          :event | :comment | :discussion | :actor | :todo_list | :todo | :resource | :post
+
+  @doc """
+  Create an activity of type `Create`
+
+    * Creates the object, which returns AS data
+    * Wraps ActivityStreams data into a `Create` activity
+    * Creates an `Mobilizon.Federation.ActivityPub.Activity` from this
+    * Federates (asynchronously) the activity
+    * Returns the activity
+  """
+  @spec create(create_entities(), map(), boolean, map()) ::
+          {:ok, Activity.t(), Entity.t()}
+          | {:error, :entity_tombstoned | atom() | Ecto.Changeset.t()}
+  def create(type, args, local \\ false, additional \\ %{}) do
+    Logger.debug("creating an activity")
+    Logger.debug(inspect(args))
+
+    case check_for_tombstones(args) do
+      nil ->
+        case do_create(type, args, additional) do
+          {:ok, entity, create_data} ->
+            {:ok, activity} = create_activity(create_data, local)
+            maybe_federate(activity)
+            maybe_relay_if_group_activity(activity)
+            {:ok, activity, entity}
+
+          {:error, err} ->
+            {:error, err}
+        end
+
+      %Tombstone{} ->
+        {:error, :entity_tombstoned}
+    end
+  end
+
+  @spec do_create(create_entities(), map(), map()) ::
+          {:ok, Entity.t(), Activity.t()} | {:error, Ecto.Changeset.t() | atom()}
+  defp do_create(type, args, additional) do
+    case type do
+      :event -> Types.Events.create(args, additional)
+      :comment -> Types.Comments.create(args, additional)
+      :discussion -> Types.Discussions.create(args, additional)
+      :actor -> Types.Actors.create(args, additional)
+      :todo_list -> Types.TodoLists.create(args, additional)
+      :todo -> Types.Todos.create(args, additional)
+      :resource -> Types.Resources.create(args, additional)
+      :post -> Types.Posts.create(args, additional)
+    end
+  end
+
+  @spec check_for_tombstones(map()) :: Tombstone.t() | nil
+  defp check_for_tombstones(%{url: url}), do: Tombstone.find_tombstone(url)
+  defp check_for_tombstones(_), do: nil
+end
diff --git a/lib/federation/activity_pub/actions/delete.ex b/lib/federation/activity_pub/actions/delete.ex
new file mode 100644
index 000000000..8530f6f57
--- /dev/null
+++ b/lib/federation/activity_pub/actions/delete.ex
@@ -0,0 +1,33 @@
+defmodule Mobilizon.Federation.ActivityPub.Actions.Delete do
+  @moduledoc """
+  Delete things
+  """
+  alias Mobilizon.Actors.Actor
+  alias Mobilizon.Federation.ActivityPub.Activity
+  alias Mobilizon.Federation.ActivityPub.Types.{Entity, Managable, Ownable}
+  require Logger
+
+  import Mobilizon.Federation.ActivityPub.Utils,
+    only: [
+      create_activity: 2,
+      maybe_federate: 1,
+      maybe_relay_if_group_activity: 2,
+      check_for_actor_key_rotation: 1
+    ]
+
+  @doc """
+  Delete an entity, using an activity of type `Delete`
+  """
+  @spec delete(Entity.t(), Actor.t(), boolean, map) :: {:ok, Activity.t(), Entity.t()}
+  def delete(object, actor, local \\ true, additional \\ %{}) do
+    with {:ok, activity_data, actor, object} <-
+           Managable.delete(object, actor, local, additional),
+         group <- Ownable.group_actor(object),
+         :ok <- check_for_actor_key_rotation(actor),
+         {:ok, activity} <- create_activity(activity_data, local),
+         :ok <- maybe_federate(activity),
+         :ok <- maybe_relay_if_group_activity(activity, group) do
+      {:ok, activity, object}
+    end
+  end
+end
diff --git a/lib/federation/activity_pub/actions/flag.ex b/lib/federation/activity_pub/actions/flag.ex
new file mode 100644
index 000000000..50def2cde
--- /dev/null
+++ b/lib/federation/activity_pub/actions/flag.ex
@@ -0,0 +1,31 @@
+defmodule Mobilizon.Federation.ActivityPub.Actions.Flag do
+  @moduledoc """
+  Delete things
+  """
+  alias Mobilizon.Users
+  alias Mobilizon.Federation.ActivityPub.{Activity, Types}
+  alias Mobilizon.Web.Email.{Admin, Mailer}
+  require Logger
+
+  import Mobilizon.Federation.ActivityPub.Utils,
+    only: [
+      create_activity: 2,
+      maybe_federate: 1
+    ]
+
+  @spec flag(map, boolean, map) :: {:ok, Activity.t(), Report.t()} | {:error, Ecto.Changeset.t()}
+  def flag(args, local \\ false, additional \\ %{}) do
+    with {:ok, report, report_as_data} <- Types.Reports.flag(args, local, additional) do
+      {:ok, activity} = create_activity(report_as_data, local)
+      maybe_federate(activity)
+
+      Enum.each(Users.list_moderators(), fn moderator ->
+        moderator
+        |> Admin.report(report)
+        |> Mailer.send_email_later()
+      end)
+
+      {:ok, activity, report}
+    end
+  end
+end
diff --git a/lib/federation/activity_pub/actions/follow.ex b/lib/federation/activity_pub/actions/follow.ex
new file mode 100644
index 000000000..75f67de3f
--- /dev/null
+++ b/lib/federation/activity_pub/actions/follow.ex
@@ -0,0 +1,74 @@
+defmodule Mobilizon.Federation.ActivityPub.Actions.Follow do
+  @moduledoc """
+  Follow people
+  """
+
+  alias Mobilizon.Actors
+  alias Mobilizon.Actors.{Actor, Follower}
+  alias Mobilizon.Federation.ActivityPub.Types
+  alias Mobilizon.Federation.ActivityStream.Convertible
+  alias Mobilizon.Web.Endpoint
+  require Logger
+
+  import Mobilizon.Federation.ActivityPub.Utils,
+    only: [
+      create_activity: 2,
+      maybe_federate: 1,
+      make_unfollow_data: 4
+    ]
+
+  @doc """
+  Make an actor follow another, using an activity of type `Follow`
+  """
+  @spec follow(Actor.t(), Actor.t(), String.t() | nil, boolean, map) ::
+          {:ok, Activity.t(), Follower.t()} | {:error, atom | Ecto.Changeset.t() | String.t()}
+  def follow(
+        %Actor{} = follower,
+        %Actor{} = followed,
+        activity_id \\ nil,
+        local \\ true,
+        additional \\ %{}
+      ) do
+    if followed.id != follower.id do
+      case Types.Actors.follow(
+             follower,
+             followed,
+             local,
+             Map.merge(additional, %{"activity_id" => activity_id})
+           ) do
+        {:ok, activity_data, %Follower{} = follower} ->
+          {:ok, activity} = create_activity(activity_data, local)
+          maybe_federate(activity)
+          {:ok, activity, follower}
+
+        {:error, err} ->
+          {:error, err}
+      end
+    else
+      {:error, "Can't follow yourself"}
+    end
+  end
+
+  @doc """
+  Make an actor unfollow another, using an activity of type `Undo` a `Follow`.
+  """
+  @spec unfollow(Actor.t(), Actor.t(), String.t() | nil, boolean()) ::
+          {:ok, Activity.t(), Follower.t()} | {:error, String.t()}
+  def unfollow(%Actor{} = follower, %Actor{} = followed, activity_id \\ nil, local \\ true) do
+    with {:ok, %Follower{id: follow_id} = follow} <- Actors.unfollow(followed, follower) do
+      # We recreate the follow activity
+      follow_as_data =
+        Convertible.model_to_as(%{follow | actor: follower, target_actor: followed})
+
+      {:ok, follow_activity} = create_activity(follow_as_data, local)
+      activity_unfollow_id = activity_id || "#{Endpoint.url()}/unfollow/#{follow_id}/activity"
+
+      unfollow_data =
+        make_unfollow_data(follower, followed, follow_activity, activity_unfollow_id)
+
+      {:ok, activity} = create_activity(unfollow_data, local)
+      maybe_federate(activity)
+      {:ok, activity, follow}
+    end
+  end
+end
diff --git a/lib/federation/activity_pub/actions/invite.ex b/lib/federation/activity_pub/actions/invite.ex
new file mode 100644
index 000000000..18b065f9c
--- /dev/null
+++ b/lib/federation/activity_pub/actions/invite.ex
@@ -0,0 +1,86 @@
+defmodule Mobilizon.Federation.ActivityPub.Actions.Invite do
+  @moduledoc """
+  Invite people to things
+  """
+  alias Mobilizon.Actors
+  alias Mobilizon.Actors.{Actor, Member}
+  alias Mobilizon.Web.Email.Group
+  require Logger
+
+  import Mobilizon.Federation.ActivityPub.Utils,
+    only: [
+      create_activity: 2,
+      maybe_federate: 1,
+      maybe_relay_if_group_activity: 1
+    ]
+
+  @spec invite(Actor.t(), Actor.t(), Actor.t(), boolean, map()) ::
+          {:ok, map(), Member.t()} | {:error, :not_able_to_invite | Ecto.Changeset.t()}
+  def invite(
+        %Actor{url: group_url, id: group_id, members_url: members_url} = group,
+        %Actor{url: actor_url, id: actor_id} = actor,
+        %Actor{url: target_actor_url, id: target_actor_id} = _target_actor,
+        local \\ true,
+        additional \\ %{}
+      ) do
+    Logger.debug("Handling #{actor_url} invite to #{group_url} sent to #{target_actor_url}")
+
+    if is_able_to_invite?(actor, group) do
+      with {:ok, %Member{url: member_url} = member} <-
+             Actors.create_member(%{
+               parent_id: group_id,
+               actor_id: target_actor_id,
+               role: :invited,
+               invited_by_id: actor_id,
+               url: Map.get(additional, :url)
+             }) do
+        Mobilizon.Service.Activity.Member.insert_activity(member,
+          moderator: actor,
+          subject: "member_invited"
+        )
+
+        {:ok, activity} =
+          create_activity(
+            %{
+              "type" => "Invite",
+              "attributedTo" => group_url,
+              "actor" => actor_url,
+              "object" => group_url,
+              "target" => target_actor_url,
+              "id" => member_url
+            }
+            |> Map.merge(%{"to" => [target_actor_url, members_url], "cc" => [group_url]})
+            |> Map.merge(additional),
+            local
+          )
+
+        maybe_federate(activity)
+        maybe_relay_if_group_activity(activity)
+        Group.send_invite_to_user(member)
+        {:ok, activity, member}
+      end
+    else
+      {:error, :not_able_to_invite}
+    end
+  end
+
+  @spec is_able_to_invite?(Actor.t(), Actor.t()) :: boolean
+  defp is_able_to_invite?(%Actor{domain: actor_domain, id: actor_id}, %Actor{
+         domain: group_domain,
+         id: group_id
+       }) do
+    # If the actor comes from the same domain we trust it
+    if actor_domain == group_domain do
+      true
+    else
+      # If local group, we'll send the invite
+      case Actors.get_member(actor_id, group_id) do
+        {:ok, %Member{} = admin_member} ->
+          Member.is_administrator(admin_member)
+
+        _ ->
+          false
+      end
+    end
+  end
+end
diff --git a/lib/federation/activity_pub/actions/join.ex b/lib/federation/activity_pub/actions/join.ex
new file mode 100644
index 000000000..3c760b91b
--- /dev/null
+++ b/lib/federation/activity_pub/actions/join.ex
@@ -0,0 +1,51 @@
+defmodule Mobilizon.Federation.ActivityPub.Actions.Join do
+  @moduledoc """
+  Join things
+  """
+
+  alias Mobilizon.Actors.{Actor, Member}
+  alias Mobilizon.Events.{Event, Participant}
+  alias Mobilizon.Federation.ActivityPub.Types
+  require Logger
+
+  import Mobilizon.Federation.ActivityPub.Utils,
+    only: [
+      create_activity: 2,
+      maybe_federate: 1
+    ]
+
+  @doc """
+  Join an entity (an event or a group), using an activity of type `Join`
+  """
+  @spec join(Event.t(), Actor.t(), boolean, map) ::
+          {:ok, Activity.t(), Participant.t()} | {:error, :maximum_attendee_capacity}
+  @spec join(Actor.t(), Actor.t(), boolean, map) :: {:ok, Activity.t(), Member.t()}
+  def join(entity_to_join, actor_joining, local \\ true, additional \\ %{})
+
+  def join(%Event{} = event, %Actor{} = actor, local, additional) do
+    case Types.Events.join(event, actor, local, additional) do
+      {:ok, activity_data, participant} ->
+        {:ok, activity} = create_activity(activity_data, local)
+        maybe_federate(activity)
+        {:ok, activity, participant}
+
+      {:error, :maximum_attendee_capacity_reached} ->
+        {:error, :maximum_attendee_capacity_reached}
+
+      {:accept, accept} ->
+        accept
+    end
+  end
+
+  def join(%Actor{type: :Group} = group, %Actor{} = actor, local, additional) do
+    with {:ok, activity_data, %Member{} = member} <-
+           Types.Actors.join(group, actor, local, additional),
+         {:ok, activity} <- create_activity(activity_data, local),
+         :ok <- maybe_federate(activity) do
+      {:ok, activity, member}
+    else
+      {:accept, accept} ->
+        accept
+    end
+  end
+end
diff --git a/lib/federation/activity_pub/actions/leave.ex b/lib/federation/activity_pub/actions/leave.ex
new file mode 100644
index 000000000..aef1259a0
--- /dev/null
+++ b/lib/federation/activity_pub/actions/leave.ex
@@ -0,0 +1,104 @@
+defmodule Mobilizon.Federation.ActivityPub.Actions.Leave do
+  @moduledoc """
+  Leave things
+  """
+
+  alias Mobilizon.{Actors, Events}
+  alias Mobilizon.Actors.{Actor, Member}
+  alias Mobilizon.Events.{Event, Participant}
+  alias Mobilizon.Federation.ActivityPub.Audience
+  alias Mobilizon.Web.Endpoint
+  require Logger
+
+  import Mobilizon.Federation.ActivityPub.Utils,
+    only: [
+      create_activity: 2,
+      maybe_federate: 1,
+      maybe_relay_if_group_activity: 1
+    ]
+
+  @spec leave(Event.t(), Actor.t(), boolean, map) ::
+          {:ok, Activity.t(), Participant.t()}
+          | {:error, :is_only_organizer | :participant_not_found | Ecto.Changeset.t()}
+  @spec leave(Actor.t(), Actor.t(), boolean, map) ::
+          {:ok, Activity.t(), Member.t()} | {:error, atom() | Ecto.Changeset.t()}
+  def leave(object, actor, local \\ true, additional \\ %{})
+
+  @doc """
+  Leave an event or a group
+  """
+  def leave(
+        %Event{id: event_id, url: event_url} = _event,
+        %Actor{id: actor_id, url: actor_url} = _actor,
+        local,
+        additional
+      ) do
+    if Participant.is_not_only_organizer(event_id, actor_id) do
+      {:error, :is_only_organizer}
+    else
+      case Mobilizon.Events.get_participant(
+             event_id,
+             actor_id,
+             Map.get(additional, :metadata, %{})
+           ) do
+        {:ok, %Participant{} = participant} ->
+          case Events.delete_participant(participant) do
+            {:ok, %{participant: %Participant{} = participant}} ->
+              leave_data = %{
+                "type" => "Leave",
+                # If it's an exclusion it should be something else
+                "actor" => actor_url,
+                "object" => event_url,
+                "id" => "#{Endpoint.url()}/leave/event/#{participant.id}"
+              }
+
+              audience = Audience.get_audience(participant)
+              {:ok, activity} = create_activity(Map.merge(leave_data, audience), local)
+              maybe_federate(activity)
+              {:ok, activity, participant}
+
+            {:error, _type, %Ecto.Changeset{} = err, _} ->
+              {:error, err}
+          end
+
+        {:error, :participant_not_found} ->
+          {:error, :participant_not_found}
+      end
+    end
+  end
+
+  def leave(
+        %Actor{type: :Group, id: group_id, url: group_url, members_url: group_members_url},
+        %Actor{id: actor_id, url: actor_url},
+        local,
+        additional
+      ) do
+    with {:member, {:ok, %Member{id: member_id} = member}} <-
+           {:member, Actors.get_member(actor_id, group_id)},
+         {:is_not_only_admin, true} <-
+           {:is_not_only_admin,
+            Map.get(additional, :force_member_removal, false) ||
+              !Actors.is_only_administrator?(member_id, group_id)},
+         {:delete, {:ok, %Member{} = member}} <- {:delete, Actors.delete_member(member)} do
+      Mobilizon.Service.Activity.Member.insert_activity(member, subject: "member_quit")
+
+      leave_data = %{
+        "to" => [group_members_url],
+        "cc" => [group_url],
+        "attributedTo" => group_url,
+        "type" => "Leave",
+        "actor" => actor_url,
+        "object" => group_url
+      }
+
+      {:ok, activity} = create_activity(leave_data, local)
+      maybe_federate(activity)
+      maybe_relay_if_group_activity(activity)
+      {:ok, activity, member}
+    else
+      {:member, nil} -> {:error, :member_not_found}
+      {:is_not_only_admin, false} -> {:error, :is_not_only_admin}
+      {:error, %Ecto.Changeset{} = err} -> {:error, err}
+    end
+  end
+end
diff --git a/lib/federation/activity_pub/actions/move.ex b/lib/federation/activity_pub/actions/move.ex
new file mode 100644
index 000000000..037e0f5b9
--- /dev/null
+++ b/lib/federation/activity_pub/actions/move.ex
@@ -0,0 +1,30 @@
+defmodule Mobilizon.Federation.ActivityPub.Actions.Move do
+  @moduledoc """
+  Move things
+  """
+  alias Mobilizon.Resources.Resource
+  alias Mobilizon.Federation.ActivityPub.{Activity, Types}
+  require Logger
+
+  import Mobilizon.Federation.ActivityPub.Utils,
+    only: [
+      create_activity: 2,
+      maybe_federate: 1
+    ]
+
+  @spec move(:resource, Resource.t(), map, boolean, map) ::
+          {:ok, Activity.t(), Resource.t()} | {:error, Ecto.Changeset.t() | atom()}
+  def move(type, old_entity, args, local \\ false, additional \\ %{}) do
+    Logger.debug("We're moving something")
+    Logger.debug(inspect(args))
+
+    with {:ok, entity, update_data} <-
+           (case type do
+              :resource -> Types.Resources.move(old_entity, args, additional)
+            end) do
+      {:ok, activity} = create_activity(update_data, local)
+      maybe_federate(activity)
+      {:ok, activity, entity}
+    end
+  end
+end
diff --git a/lib/federation/activity_pub/actions/reject.ex b/lib/federation/activity_pub/actions/reject.ex
new file mode 100644
index 000000000..cdc0ae50e
--- /dev/null
+++ b/lib/federation/activity_pub/actions/reject.ex
@@ -0,0 +1,127 @@
+defmodule Mobilizon.Federation.ActivityPub.Actions.Reject do
+  @moduledoc """
+  Reject things
+  """
+
+  alias Mobilizon.{Actors, Events}
+  alias Mobilizon.Actors.{Actor, Follower, Member}
+  alias Mobilizon.Events.Participant
+  alias Mobilizon.Federation.ActivityPub.Actions.Accept
+  alias Mobilizon.Federation.ActivityPub.Audience
+  alias Mobilizon.Federation.ActivityStream
+  alias Mobilizon.Federation.ActivityStream.Convertible
+  alias Mobilizon.Web.Endpoint
+  require Logger
+
+  import Mobilizon.Federation.ActivityPub.Utils,
+    only: [
+      create_activity: 2,
+      maybe_federate: 1,
+      maybe_relay_if_group_activity: 1
+    ]
+
+  @spec reject(Accept.acceptable_types(), Accept.acceptable_entities(), boolean, map) ::
+          {:ok, ActivityStream.t(), Accept.acceptable_entities()}
+  def reject(type, entity, local \\ true, additional \\ %{}) do
+    {:ok, entity, update_data} =
+      case type do
+        :join -> reject_join(entity, additional)
+        :follow -> reject_follow(entity, additional)
+        :invite -> reject_invite(entity, additional)
+      end
+
+    with {:ok, activity} <- create_activity(update_data, local),
+         :ok <- maybe_federate(activity),
+         :ok <- maybe_relay_if_group_activity(activity) do
+      {:ok, activity, entity}
+    else
+      err ->
+        Logger.error("Something went wrong while creating an activity")
+        Logger.debug(inspect(err))
+        err
+    end
+  end
+
+  @spec reject_join(Participant.t(), map()) :: {:ok, Participant.t(), Activity.t()} | any()
+  defp reject_join(%Participant{} = participant, additional) do
+    with {:ok, %Participant{} = participant} <-
+           Events.update_participant(participant, %{role: :rejected}),
+         Absinthe.Subscription.publish(Endpoint, participant.actor,
+           event_person_participation_changed: participant.actor.id
+         ),
+         participant_as_data <- Convertible.model_to_as(participant),
+         audience <-
+           participant
+           |> Audience.get_audience()
+           |> Map.merge(additional),
+         reject_data <- %{
+           "type" => "Reject",
+           "object" => participant_as_data
+         },
+         update_data <-
+           reject_data
+           |> Map.merge(audience)
+           |> Map.merge(%{
+             "id" => "#{Endpoint.url()}/reject/join/#{participant.id}"
+           }) do
+      {:ok, participant, update_data}
+    else
+      err ->
+        Logger.error("Something went wrong while creating an update activity")
+        Logger.debug(inspect(err))
+        err
+    end
+  end
+
+  @spec reject_follow(Follower.t(), map()) :: {:ok, Follower.t(), Activity.t()} | any()
+  defp reject_follow(%Follower{} = follower, additional) do
+    with {:ok, %Follower{} = follower} <- Actors.delete_follower(follower),
+         follower_as_data <- Convertible.model_to_as(follower),
+         audience <-
+           follower.actor |> Audience.get_audience() |> Map.merge(additional),
+         reject_data <- %{
+           "to" => [follower.actor.url],
+           "type" => "Reject",
+           "actor" => follower.target_actor.url,
+           "object" => follower_as_data
+         },
+         update_data <-
+           audience
+           |> Map.merge(reject_data)
+           |> Map.merge(%{
+             "id" => "#{Endpoint.url()}/reject/follow/#{follower.id}"
+           }) do
+      {:ok, follower, update_data}
+    else
+      err ->
+        Logger.error("Something went wrong while creating an update activity")
+        Logger.debug(inspect(err))
+        err
+    end
+  end
+
+  @spec reject_invite(Member.t(), map()) :: {:ok, Member.t(), Activity.t()} | any
+  defp reject_invite(
+         %Member{invited_by_id: invited_by_id, actor_id: actor_id} = member,
+         _additional
+       ) do
+    with %Actor{} = inviter <- Actors.get_actor(invited_by_id),
+         %Actor{url: actor_url} <- Actors.get_actor(actor_id),
+         {:ok, %Member{url: member_url, id: member_id} = member} <-
+           Actors.delete_member(member),
+         Mobilizon.Service.Activity.Member.insert_activity(member,
+           subject: "member_rejected_invitation"
+         ),
+         accept_data <- %{
+           "type" => "Reject",
+           "actor" => actor_url,
+           "attributedTo" => member.parent.url,
+           "to" => [inviter.url, member.parent.members_url],
+           "cc" => [member.parent.url],
+           "object" => member_url,
+           "id" => "#{Endpoint.url()}/reject/invite/member/#{member_id}"
+         } do
+      {:ok, member, accept_data}
+    end
+  end
+end
diff --git a/lib/federation/activity_pub/actions/remove.ex b/lib/federation/activity_pub/actions/remove.ex
new file mode 100644
index 000000000..9663f5f91
--- /dev/null
+++ b/lib/federation/activity_pub/actions/remove.ex
@@ -0,0 +1,56 @@
+defmodule Mobilizon.Federation.ActivityPub.Actions.Remove do
+  @moduledoc """
+  Remove things
+  """
+  alias Mobilizon.Actors
+  alias Mobilizon.Actors.{Actor, Member}
+  alias Mobilizon.Federation.ActivityPub.Activity
+  alias Mobilizon.Web.Email.Group
+  require Logger
+
+  import Mobilizon.Federation.ActivityPub.Utils,
+    only: [
+      create_activity: 2,
+      maybe_federate: 1,
+      maybe_relay_if_group_activity: 1
+    ]
+
+  @doc """
+  Remove an activity, using an activity of type `Remove`
+  """
+  @spec remove(Member.t(), Actor.t(), Actor.t(), boolean, map) ::
+          {:ok, Activity.t(), Member.t()} | {:error, :member_not_found | Ecto.Changeset.t()}
+  def remove(
+        %Member{} = member,
+        %Actor{type: :Group, url: group_url, members_url: group_members_url},
+        %Actor{url: moderator_url} = moderator,
+        local,
+        _additional \\ %{}
+      ) do
+    with {:ok, %Member{id: member_id}} <- Actors.update_member(member, %{role: :rejected}),
+         %Member{} = member <- Actors.get_member(member_id) do
+      Mobilizon.Service.Activity.Member.insert_activity(member,
+        moderator: moderator,
+        subject: "member_removed"
+      )
+
+      Group.send_notification_to_removed_member(member)
+
+      remove_data = %{
+        "to" => [group_members_url],
+        "type" => "Remove",
+        "actor" => moderator_url,
+        "object" => member.url,
+        "origin" => group_url
+      }
+
+      {:ok, activity} = create_activity(remove_data, local)
+      maybe_federate(activity)
+      maybe_relay_if_group_activity(activity)
+      {:ok, activity, member}
+    else
+      nil -> {:error, :member_not_found}
+      {:error, %Ecto.Changeset{} = err} -> {:error, err}
+    end
+  end
+end
diff --git a/lib/federation/activity_pub/actions/update.ex b/lib/federation/activity_pub/actions/update.ex
new file mode 100644
index 000000000..1306934b6
--- /dev/null
+++ b/lib/federation/activity_pub/actions/update.ex
@@ -0,0 +1,44 @@
+defmodule Mobilizon.Federation.ActivityPub.Actions.Update do
+  @moduledoc """
+  Update things
+  """
+  alias Mobilizon.Federation.ActivityPub.Activity
+  alias Mobilizon.Federation.ActivityPub.Types.Managable
+  require Logger
+
+  import Mobilizon.Federation.ActivityPub.Utils,
+    only: [
+      create_activity: 2,
+      maybe_federate: 1,
+      maybe_relay_if_group_activity: 1
+    ]
+
+  @doc """
+  Create an activity of type `Update`
+
+    * Updates the object, which returns AS data
+    * Wraps ActivityStreams data into a `Update` activity
+    * Creates an `Mobilizon.Federation.ActivityPub.Activity` from this
+    * Federates (asynchronously) the activity
+    * Returns the activity
+  """
+  @spec update(Entity.t(), map(), boolean, map()) ::
+          {:ok, Activity.t(), Entity.t()} | {:error, atom() | Ecto.Changeset.t()}
+  def update(old_entity, args, local \\ false, additional \\ %{}) do
+    Logger.debug("updating an activity")
+    Logger.debug(inspect(args))
+
+    case Managable.update(old_entity, args, additional) do
+      {:ok, entity, update_data} ->
+        {:ok, activity} = create_activity(update_data, local)
+        maybe_federate(activity)
+        maybe_relay_if_group_activity(activity)
+        {:ok, activity, entity}
+
+      {:error, err} ->
+        Logger.error("Something went wrong while creating an activity")
+        Logger.debug(inspect(err))
+        {:error, err}
+    end
+  end
+end
diff --git a/lib/federation/activity_pub/activity.ex b/lib/federation/activity_pub/activity.ex
index 59a20ec82..258b72dd1 100644
--- a/lib/federation/activity_pub/activity.ex
+++ b/lib/federation/activity_pub/activity.ex
@@ -4,7 +4,7 @@ defmodule Mobilizon.Federation.ActivityPub.Activity do
   """
 
   @type t :: %__MODULE__{
-          data: String.t(),
+          data: map(),
           local: boolean,
           actor: Actor.t(),
           recipients: [String.t()]
diff --git a/lib/federation/activity_pub/activity_pub.ex b/lib/federation/activity_pub/activity_pub.ex
index 94a65a962..7dd39c604 100644
--- a/lib/federation/activity_pub/activity_pub.ex
+++ b/lib/federation/activity_pub/activity_pub.ex
@@ -12,108 +12,75 @@ defmodule Mobilizon.Federation.ActivityPub do
 
   alias Mobilizon.{
     Actors,
-    Config,
     Discussions,
     Events,
     Posts,
-    Resources,
-    Share,
-    Users
+    Resources
   }
 
-  alias Mobilizon.Actors.{Actor, Follower, Member}
+  alias Mobilizon.Actors.Actor
   alias Mobilizon.Discussions.Comment
-  alias Mobilizon.Events.{Event, Participant}
+  alias Mobilizon.Events.Event
   alias Mobilizon.Tombstone
 
   alias Mobilizon.Federation.ActivityPub.{
     Activity,
-    Audience,
-    Federator,
     Fetcher,
     Preloader,
-    Refresher,
-    Relay,
-    Transmogrifier,
-    Types,
-    Visibility
+    Relay
   }
 
-  alias Mobilizon.Federation.ActivityPub.Actor, as: ActivityPubActor
-
-  alias Mobilizon.Federation.ActivityPub.Types.{Managable, Ownable}
-
   alias Mobilizon.Federation.ActivityStream.Convertible
-  alias Mobilizon.Federation.HTTPSignatures.Signature
 
-  alias Mobilizon.Service.Notifications.Scheduler
   alias Mobilizon.Storage.Page
 
   alias Mobilizon.Web.Endpoint
-  alias Mobilizon.Web.Email.{Admin, Group, Mailer}
 
   require Logger
 
   @public_ap_adress "https://www.w3.org/ns/activitystreams#Public"
 
-  @doc """
-  Wraps an object into an activity
-  """
-  @spec create_activity(map(), boolean()) :: {:ok, Activity.t()}
-  def create_activity(map, local \\ true) when is_map(map) do
-    with map <- lazy_put_activity_defaults(map) do
-      {:ok,
-       %Activity{
-         data: map,
-         local: local,
-         actor: map["actor"],
-         recipients: get_recipients(map)
-       }}
-    end
-  end
-
   @doc """
   Fetch an object from an URL, from our local database of events and comments, then eventually remote
   """
   # TODO: Make database calls parallel
   @spec fetch_object_from_url(String.t(), Keyword.t()) ::
-          {:ok, struct()} | {:error, any()}
+          {:ok, struct()} | {:ok, atom(), struct()} | {:error, any()}
   def fetch_object_from_url(url, options \\ []) do
     Logger.info("Fetching object from url #{url}")
 
-    with {:not_http, true} <- {:not_http, String.starts_with?(url, "http")},
-         {:existing, nil} <-
-           {:existing, Tombstone.find_tombstone(url)},
-         {:existing, nil} <- {:existing, Events.get_event_by_url(url)},
-         {:existing, nil} <-
-           {:existing, Discussions.get_discussion_by_url(url)},
-         {:existing, nil} <- {:existing, Discussions.get_comment_from_url(url)},
-         {:existing, nil} <- {:existing, Resources.get_resource_by_url(url)},
-         {:existing, nil} <- {:existing, Posts.get_post_by_url(url)},
-         {:existing, nil} <-
-           {:existing, Actors.get_actor_by_url_2(url)},
-         {:existing, nil} <- {:existing, Actors.get_member_by_url(url)},
-         :ok <- Logger.info("Data for URL not found anywhere, going to fetch it"),
-         {:ok, _activity, entity} <- Fetcher.fetch_and_create(url, options) do
-      Logger.debug("Going to preload the new entity")
-      Preloader.maybe_preload(entity)
+    if String.starts_with?(url, "http") do
+      with {:existing, nil} <-
+             {:existing, Tombstone.find_tombstone(url)},
+           {:existing, nil} <- {:existing, Events.get_event_by_url(url)},
+           {:existing, nil} <-
+             {:existing, Discussions.get_discussion_by_url(url)},
+           {:existing, nil} <- {:existing, Discussions.get_comment_from_url(url)},
+           {:existing, nil} <- {:existing, Resources.get_resource_by_url(url)},
+           {:existing, nil} <- {:existing, Posts.get_post_by_url(url)},
+           {:existing, nil} <-
+             {:existing, Actors.get_actor_by_url_2(url)},
+           {:existing, nil} <- {:existing, Actors.get_member_by_url(url)},
+           :ok <- Logger.info("Data for URL not found anywhere, going to fetch it"),
+           {:ok, _activity, entity} <- Fetcher.fetch_and_create(url, options) do
+        Logger.debug("Going to preload the new entity")
+        Preloader.maybe_preload(entity)
+      else
+        {:existing, entity} ->
+          handle_existing_entity(url, entity, options)
+
+        {:error, e} ->
+          Logger.warn("Something failed while fetching url #{url} #{inspect(e)}")
+          {:error, e}
+      end
     else
-      {:existing, entity} ->
-        handle_existing_entity(url, entity, options)
-
-      {:error, e} ->
-        Logger.warn("Something failed while fetching url #{url} #{inspect(e)}")
-        {:error, e}
-
-      e ->
-        Logger.warn("Something failed while fetching url #{url} #{inspect(e)}")
-        {:error, e}
+      {:error, :url_not_http}
     end
   end
 
   @spec handle_existing_entity(String.t(), struct(), Keyword.t()) ::
           {:ok, struct()}
-          | {:ok, struct()}
+          | {:ok, atom(), struct()}
           | {:error, String.t(), struct()}
           | {:error, String.t()}
   defp handle_existing_entity(url, entity, options) do
@@ -128,13 +95,13 @@ defmodule Mobilizon.Federation.ActivityPub do
         {:ok, entity} = Preloader.maybe_preload(entity)
         {:error, status, entity}
 
-      err ->
-        err
+      {:error, err} ->
+        {:error, err}
     end
   end
 
   @spec refresh_entity(String.t(), struct(), Keyword.t()) ::
-          {:ok, struct()} | {:error, String.t(), struct()} | {:error, String.t()}
+          {:ok, struct()} | {:error, atom(), struct()} | {:error, atom()}
   defp refresh_entity(url, entity, options) do
     force_fetch = Keyword.get(options, :force, false)
 
@@ -145,573 +112,24 @@ defmodule Mobilizon.Federation.ActivityPub do
         {:ok, _activity, entity} ->
           {:ok, entity}
 
-        {:error, "Gone"} ->
-          {:error, "Gone", entity}
+        {:error, :http_gone} ->
+          {:error, :http_gone, entity}
 
-        {:error, "Not found"} ->
-          {:error, "Not found", entity}
+        {:error, :http_not_found} ->
+          {:error, :http_not_found, entity}
 
-        {:error, "Object origin check failed"} ->
-          {:error, "Object origin check failed"}
+        {:error, err} ->
+          {:error, err}
       end
     else
       {:ok, entity}
     end
   end
 
-  @doc """
-  Create an activity of type `Create`
-
-    * Creates the object, which returns AS data
-    * Wraps ActivityStreams data into a `Create` activity
-    * Creates an `Mobilizon.Federation.ActivityPub.Activity` from this
-    * Federates (asynchronously) the activity
-    * Returns the activity
-  """
-  @spec create(atom(), map(), boolean, map()) :: {:ok, Activity.t(), struct()} | any()
-  def create(type, args, local \\ false, additional \\ %{}) do
-    Logger.debug("creating an activity")
-    Logger.debug(inspect(args))
-
-    with {:tombstone, nil} <- {:tombstone, check_for_tombstones(args)},
-         {:ok, entity, create_data} <-
-           (case type do
-              :event -> Types.Events.create(args, additional)
-              :comment -> Types.Comments.create(args, additional)
-              :discussion -> Types.Discussions.create(args, additional)
-              :actor -> Types.Actors.create(args, additional)
-              :todo_list -> Types.TodoLists.create(args, additional)
-              :todo -> Types.Todos.create(args, additional)
-              :resource -> Types.Resources.create(args, additional)
-              :post -> Types.Posts.create(args, additional)
-            end),
-         {:ok, activity} <- create_activity(create_data, local),
-         :ok <- maybe_federate(activity),
-         :ok <- maybe_relay_if_group_activity(activity) do
-      {:ok, activity, entity}
-    else
-      err ->
-        Logger.error("Something went wrong while creating an activity")
-        Logger.debug(inspect(err))
-        err
-    end
-  end
-
-  @doc """
-  Create an activity of type `Update`
-
-    * Updates the object, which returns AS data
-    * Wraps ActivityStreams data into a `Update` activity
-    * Creates an `Mobilizon.Federation.ActivityPub.Activity` from this
-    * Federates (asynchronously) the activity
-    * Returns the activity
-  """
-  @spec update(struct(), map(), boolean, map()) :: {:ok, Activity.t(), struct()} | any()
-  def update(old_entity, args, local \\ false, additional \\ %{}) do
-    Logger.debug("updating an activity")
-    Logger.debug(inspect(args))
-
-    with {:ok, entity, update_data} <- Managable.update(old_entity, args, additional),
-         {:ok, activity} <- create_activity(update_data, local),
-         :ok <- maybe_federate(activity),
-         :ok <- maybe_relay_if_group_activity(activity) do
-      {:ok, activity, entity}
-    else
-      err ->
-        Logger.error("Something went wrong while creating an activity")
-        Logger.debug(inspect(err))
-        err
-    end
-  end
-
-  def accept(type, entity, local \\ true, additional \\ %{}) do
-    Logger.debug("We're accepting something")
-
-    {:ok, entity, update_data} =
-      case type do
-        :join -> accept_join(entity, additional)
-        :follow -> accept_follow(entity, additional)
-        :invite -> accept_invite(entity, additional)
-      end
-
-    with {:ok, activity} <- create_activity(update_data, local),
-         :ok <- maybe_federate(activity),
-         :ok <- maybe_relay_if_group_activity(activity) do
-      {:ok, activity, entity}
-    else
-      err ->
-        Logger.error("Something went wrong while creating an activity")
-        Logger.debug(inspect(err))
-        err
-    end
-  end
-
-  def reject(type, entity, local \\ true, additional \\ %{}) do
-    {:ok, entity, update_data} =
-      case type do
-        :join -> reject_join(entity, additional)
-        :follow -> reject_follow(entity, additional)
-        :invite -> reject_invite(entity, additional)
-      end
-
-    with {:ok, activity} <- create_activity(update_data, local),
-         :ok <- maybe_federate(activity),
-         :ok <- maybe_relay_if_group_activity(activity) do
-      {:ok, activity, entity}
-    else
-      err ->
-        Logger.error("Something went wrong while creating an activity")
-        Logger.debug(inspect(err))
-        err
-    end
-  end
-
-  def announce(
-        %Actor{} = actor,
-        object,
-        activity_id \\ nil,
-        local \\ true,
-        public \\ true
-      ) do
-    with {:ok, %Actor{id: object_owner_actor_id}} <-
-           ActivityPubActor.get_or_fetch_actor_by_url(object["actor"]),
-         {:ok, %Share{} = _share} <- Share.create(object["id"], actor.id, object_owner_actor_id),
-         announce_data <- make_announce_data(actor, object, activity_id, public),
-         {:ok, activity} <- create_activity(announce_data, local),
-         :ok <- maybe_federate(activity) do
-      {:ok, activity, object}
-    else
-      error ->
-        {:error, error}
-    end
-  end
-
-  def unannounce(
-        %Actor{} = actor,
-        object,
-        activity_id \\ nil,
-        cancelled_activity_id \\ nil,
-        local \\ true
-      ) do
-    with announce_activity <- make_announce_data(actor, object, cancelled_activity_id),
-         unannounce_data <- make_unannounce_data(actor, announce_activity, activity_id),
-         {:ok, unannounce_activity} <- create_activity(unannounce_data, local),
-         :ok <- maybe_federate(unannounce_activity) do
-      {:ok, unannounce_activity, object}
-    else
-      _e -> {:ok, object}
-    end
-  end
-
-  @doc """
-  Make an actor follow another
-  """
-  def follow(
-        %Actor{} = follower,
-        %Actor{} = followed,
-        activity_id \\ nil,
-        local \\ true,
-        additional \\ %{}
-      ) do
-    with {:different_actors, true} <- {:different_actors, followed.id != follower.id},
-         {:ok, activity_data, %Follower{} = follower} <-
-           Types.Actors.follow(
-             follower,
-             followed,
-             local,
-             Map.merge(additional, %{"activity_id" => activity_id})
-           ),
-         {:ok, activity} <- create_activity(activity_data, local),
-         :ok <- maybe_federate(activity) do
-      {:ok, activity, follower}
-    else
-      {:error, err, msg} when err in [:already_following, :suspended, :no_person] ->
-        {:error, msg}
-
-      {:different_actors, _} ->
-        {:error, "Can't follow yourself"}
-    end
-  end
-
-  @doc """
-  Make an actor unfollow another
-  """
-  @spec unfollow(Actor.t(), Actor.t(), String.t(), boolean()) :: {:ok, map()} | any()
-  def unfollow(%Actor{} = follower, %Actor{} = followed, activity_id \\ nil, local \\ true) do
-    with {:ok, %Follower{id: follow_id} = follow} <- Actors.unfollow(followed, follower),
-         # We recreate the follow activity
-         follow_as_data <-
-           Convertible.model_to_as(%{follow | actor: follower, target_actor: followed}),
-         {:ok, follow_activity} <- create_activity(follow_as_data, local),
-         activity_unfollow_id <-
-           activity_id || "#{Endpoint.url()}/unfollow/#{follow_id}/activity",
-         unfollow_data <-
-           make_unfollow_data(follower, followed, follow_activity, activity_unfollow_id),
-         {:ok, activity} <- create_activity(unfollow_data, local),
-         :ok <- maybe_federate(activity) do
-      {:ok, activity, follow}
-    else
-      err ->
-        Logger.debug("Error while unfollowing an actor #{inspect(err)}")
-        err
-    end
-  end
-
-  def delete(object, actor, local \\ true, additional \\ %{}) do
-    with {:ok, activity_data, actor, object} <-
-           Managable.delete(object, actor, local, additional),
-         group <- Ownable.group_actor(object),
-         :ok <- check_for_actor_key_rotation(actor),
-         {:ok, activity} <- create_activity(activity_data, local),
-         :ok <- maybe_federate(activity),
-         :ok <- maybe_relay_if_group_activity(activity, group) do
-      {:ok, activity, object}
-    end
-  end
-
-  def join(entity_to_join, actor_joining, local \\ true, additional \\ %{})
-
-  def join(%Event{} = event, %Actor{} = actor, local, additional) do
-    with {:ok, activity_data, participant} <- Types.Events.join(event, actor, local, additional),
-         {:ok, activity} <- create_activity(activity_data, local),
-         :ok <- maybe_federate(activity) do
-      {:ok, activity, participant}
-    else
-      {:maximum_attendee_capacity, err} ->
-        {:maximum_attendee_capacity, err}
-
-      {:accept, accept} ->
-        accept
-    end
-  end
-
-  def join(%Actor{type: :Group} = group, %Actor{} = actor, local, additional) do
-    with {:ok, activity_data, %Member{} = member} <-
-           Types.Actors.join(group, actor, local, additional),
-         {:ok, activity} <- create_activity(activity_data, local),
-         :ok <- maybe_federate(activity) do
-      {:ok, activity, member}
-    else
-      {:accept, accept} ->
-        accept
-    end
-  end
-
-  def leave(object, actor, local \\ true, additional \\ %{})
-
-  @doc """
-  Leave an event or a group
-  """
-  def leave(
-        %Event{id: event_id, url: event_url} = _event,
-        %Actor{id: actor_id, url: actor_url} = _actor,
-        local,
-        additional
-      ) do
-    with {:only_organizer, false} <-
-           {:only_organizer, Participant.is_not_only_organizer(event_id, actor_id)},
-         {:ok, %Participant{} = participant} <-
-           Mobilizon.Events.get_participant(
-             event_id,
-             actor_id,
-             Map.get(additional, :metadata, %{})
-           ),
-         {:ok, %Participant{} = participant} <-
-           Events.delete_participant(participant),
-         leave_data <- %{
-           "type" => "Leave",
-           # If it's an exclusion it should be something else
-           "actor" => actor_url,
-           "object" => event_url,
-           "id" => "#{Endpoint.url()}/leave/event/#{participant.id}"
-         },
-         audience <-
-           Audience.get_audience(participant),
-         {:ok, activity} <- create_activity(Map.merge(leave_data, audience), local),
-         :ok <- maybe_federate(activity) do
-      {:ok, activity, participant}
-    end
-  end
-
-  def leave(
-        %Actor{type: :Group, id: group_id, url: group_url, members_url: group_members_url},
-        %Actor{id: actor_id, url: actor_url},
-        local,
-        additional
-      ) do
-    with {:member, {:ok, %Member{id: member_id} = member}} <-
-           {:member, Actors.get_member(actor_id, group_id)},
-         {:is_not_only_admin, true} <-
-           {:is_not_only_admin,
-            Map.get(additional, :force_member_removal, false) ||
-              !Actors.is_only_administrator?(member_id, group_id)},
-         {:delete, {:ok, %Member{} = member}} <- {:delete, Actors.delete_member(member)},
-         Mobilizon.Service.Activity.Member.insert_activity(member, subject: "member_quit"),
-         leave_data <- %{
-           "to" => [group_members_url],
-           "cc" => [group_url],
-           "attributedTo" => group_url,
-           "type" => "Leave",
-           "actor" => actor_url,
-           "object" => group_url
-         },
-         {:ok, activity} <- create_activity(leave_data, local),
-         :ok <- maybe_federate(activity),
-         :ok <- maybe_relay_if_group_activity(activity) do
-      {:ok, activity, member}
-    end
-  end
-
-  def remove(
-        %Member{} = member,
-        %Actor{type: :Group, url: group_url, members_url: group_members_url},
-        %Actor{url: moderator_url} = moderator,
-        local,
-        _additional \\ %{}
-      ) do
-    with {:ok, %Member{id: member_id}} <- Actors.update_member(member, %{role: :rejected}),
-         %Member{} = member <- Actors.get_member(member_id),
-         {:ok, _} <-
-           Mobilizon.Service.Activity.Member.insert_activity(member,
-             moderator: moderator,
-             subject: "member_removed"
-           ),
-         :ok <- Group.send_notification_to_removed_member(member),
-         remove_data <- %{
-           "to" => [group_members_url],
-           "type" => "Remove",
-           "actor" => moderator_url,
-           "object" => member.url,
-           "origin" => group_url
-         },
-         {:ok, activity} <- create_activity(remove_data, local),
-         :ok <- maybe_federate(activity),
-         :ok <- maybe_relay_if_group_activity(activity) do
-      {:ok, activity, member}
-    end
-  end
-
-  @spec invite(Actor.t(), Actor.t(), Actor.t(), boolean, map()) ::
-          {:ok, map(), Member.t()} | {:error, :member_not_found}
-  def invite(
-        %Actor{url: group_url, id: group_id, members_url: members_url} = group,
-        %Actor{url: actor_url, id: actor_id} = actor,
-        %Actor{url: target_actor_url, id: target_actor_id} = _target_actor,
-        local \\ true,
-        additional \\ %{}
-      ) do
-    Logger.debug("Handling #{actor_url} invite to #{group_url} sent to #{target_actor_url}")
-
-    with {:is_able_to_invite, true} <- {:is_able_to_invite, is_able_to_invite(actor, group)},
-         {:ok, %Member{url: member_url} = member} <-
-           Actors.create_member(%{
-             parent_id: group_id,
-             actor_id: target_actor_id,
-             role: :invited,
-             invited_by_id: actor_id,
-             url: Map.get(additional, :url)
-           }),
-         {:ok, _} <-
-           Mobilizon.Service.Activity.Member.insert_activity(member,
-             moderator: actor,
-             subject: "member_invited"
-           ),
-         invite_data <- %{
-           "type" => "Invite",
-           "attributedTo" => group_url,
-           "actor" => actor_url,
-           "object" => group_url,
-           "target" => target_actor_url,
-           "id" => member_url
-         },
-         {:ok, activity} <-
-           create_activity(
-             invite_data
-             |> Map.merge(%{"to" => [target_actor_url, members_url], "cc" => [group_url]})
-             |> Map.merge(additional),
-             local
-           ),
-         :ok <- maybe_federate(activity),
-         :ok <- maybe_relay_if_group_activity(activity),
-         :ok <- Group.send_invite_to_user(member) do
-      {:ok, activity, member}
-    end
-  end
-
-  defp is_able_to_invite(%Actor{domain: actor_domain, id: actor_id}, %Actor{
-         domain: group_domain,
-         id: group_id
-       }) do
-    # If the actor comes from the same domain we trust it
-    if actor_domain == group_domain do
-      true
-    else
-      # If local group, we'll send the invite
-      with {:ok, %Member{} = admin_member} <- Actors.get_member(actor_id, group_id) do
-        Member.is_administrator(admin_member)
-      end
-    end
-  end
-
-  def move(type, old_entity, args, local \\ false, additional \\ %{}) do
-    Logger.debug("We're moving something")
-    Logger.debug(inspect(args))
-
-    with {:ok, entity, update_data} <-
-           (case type do
-              :resource -> Types.Resources.move(old_entity, args, additional)
-            end),
-         {:ok, activity} <- create_activity(update_data, local),
-         :ok <- maybe_federate(activity) do
-      {:ok, activity, entity}
-    else
-      err ->
-        Logger.error("Something went wrong while creating a Move activity")
-        Logger.debug(inspect(err))
-        err
-    end
-  end
-
-  def flag(args, local \\ false, additional \\ %{}) do
-    with {report, report_as_data} <- Types.Reports.flag(args, local, additional),
-         {:ok, activity} <- create_activity(report_as_data, local),
-         :ok <- maybe_federate(activity) do
-      Enum.each(Users.list_moderators(), fn moderator ->
-        moderator
-        |> Admin.report(report)
-        |> Mailer.send_email_later()
-      end)
-
-      {:ok, activity, report}
-    else
-      err ->
-        Logger.error("Something went wrong while creating an activity")
-        Logger.debug(inspect(err))
-        err
-    end
-  end
-
-  @spec is_create_activity?(Activity.t()) :: boolean
-  defp is_create_activity?(%Activity{data: %{"type" => "Create"}}), do: true
-  defp is_create_activity?(_), do: false
-
-  @spec convert_members_in_recipients(list(String.t())) :: {list(String.t()), list(Actor.t())}
-  defp convert_members_in_recipients(recipients) do
-    Enum.reduce(recipients, {recipients, []}, fn recipient, {recipients, member_actors} = acc ->
-      case Actors.get_group_by_members_url(recipient) do
-        # If the group is local just add external members
-        %Actor{domain: domain} = group when is_nil(domain) ->
-          {Enum.filter(recipients, fn recipient -> recipient != group.members_url end),
-           member_actors ++ Actors.list_external_actors_members_for_group(group)}
-
-        # If it's remote add the remote group actor as well
-        %Actor{} = group ->
-          {Enum.filter(recipients, fn recipient -> recipient != group.members_url end),
-           member_actors ++ Actors.list_external_actors_members_for_group(group) ++ [group]}
-
-        _ ->
-          acc
-      end
-    end)
-  end
-
-  defp convert_followers_in_recipients(recipients) do
-    Enum.reduce(recipients, {recipients, []}, fn recipient, {recipients, follower_actors} = acc ->
-      case Actors.get_actor_by_followers_url(recipient) do
-        %Actor{} = group ->
-          {Enum.filter(recipients, fn recipient -> recipient != group.followers_url end),
-           follower_actors ++ Actors.list_external_followers_for_actor(group)}
-
-        _ ->
-          acc
-      end
-    end)
-  end
-
-  # @spec is_announce_activity?(Activity.t()) :: boolean
-  # defp is_announce_activity?(%Activity{data: %{"type" => "Announce"}}), do: true
-  # defp is_announce_activity?(_), do: false
-
-  @doc """
-  Publish an activity to all appropriated audiences inboxes
-  """
-  # credo:disable-for-lines:47
-  @spec publish(Actor.t(), Activity.t()) :: :ok
-  def publish(actor, %Activity{recipients: recipients} = activity) do
-    Logger.debug("Publishing an activity")
-    Logger.debug(inspect(activity, pretty: true))
-
-    public = Visibility.is_public?(activity)
-    Logger.debug("is public ? #{public}")
-
-    if public && is_create_activity?(activity) && Config.get([:instance, :allow_relay]) do
-      Logger.info(fn -> "Relaying #{activity.data["id"]} out" end)
-
-      Relay.publish(activity)
-    end
-
-    recipients = Enum.uniq(recipients)
-
-    {recipients, followers} = convert_followers_in_recipients(recipients)
-
-    {recipients, members} = convert_members_in_recipients(recipients)
-
-    remote_inboxes =
-      (remote_actors(recipients) ++ followers ++ members)
-      |> Enum.map(fn actor -> actor.shared_inbox_url || actor.inbox_url end)
-      |> Enum.uniq()
-
-    {:ok, data} = Transmogrifier.prepare_outgoing(activity.data)
-    json = Jason.encode!(data)
-    Logger.debug(fn -> "Remote inboxes are : #{inspect(remote_inboxes)}" end)
-
-    Enum.each(remote_inboxes, fn inbox ->
-      Federator.enqueue(:publish_single_ap, %{
-        inbox: inbox,
-        json: json,
-        actor: actor,
-        id: activity.data["id"]
-      })
-    end)
-  end
-
-  @doc """
-  Publish an activity to a specific inbox
-  """
-  def publish_one(%{inbox: inbox, json: json, actor: actor, id: id}) do
-    Logger.info("Federating #{id} to #{inbox}")
-    %URI{host: host, path: path} = URI.parse(inbox)
-
-    digest = Signature.build_digest(json)
-    date = Signature.generate_date_header()
-
-    # request_target = Signature.generate_request_target("POST", path)
-
-    signature =
-      Signature.sign(actor, %{
-        "(request-target)": "post #{path}",
-        host: host,
-        "content-length": byte_size(json),
-        digest: digest,
-        date: date
-      })
-
-    Tesla.post(
-      inbox,
-      json,
-      headers: [
-        {"Content-Type", "application/activity+json"},
-        {"signature", signature},
-        {"digest", digest},
-        {"date", date}
-      ]
-    )
-  end
-
   @doc """
   Return all public activities (events & comments) for an actor
   """
-  @spec fetch_public_activities_for_actor(Actor.t(), integer(), integer()) :: map()
+  @spec fetch_public_activities_for_actor(Actor.t(), pos_integer(), pos_integer()) :: map()
   def fetch_public_activities_for_actor(%Actor{id: actor_id} = actor, page \\ 1, limit \\ 10) do
     %Actor{id: relay_actor_id} = Relay.get_actor()
 
@@ -758,217 +176,4 @@ defmodule Mobilizon.Federation.ActivityPub do
       local: local
     }
   end
-
-  # Get recipients for an activity or object
-  @spec get_recipients(map()) :: list()
-  defp get_recipients(data) do
-    Map.get(data, "to", []) ++ Map.get(data, "cc", [])
-  end
-
-  @spec check_for_tombstones(map()) :: Tombstone.t() | nil
-  defp check_for_tombstones(%{url: url}), do: Tombstone.find_tombstone(url)
-  defp check_for_tombstones(_), do: nil
-
-  @spec accept_follow(Follower.t(), map) :: {:ok, Follower.t(), Activity.t()} | any
-  defp accept_follow(%Follower{} = follower, additional) do
-    with {:ok, %Follower{} = follower} <- Actors.update_follower(follower, %{approved: true}),
-         follower_as_data <- Convertible.model_to_as(follower),
-         update_data <-
-           make_accept_join_data(
-             follower_as_data,
-             Map.merge(additional, %{
-               "id" => "#{Endpoint.url()}/accept/follow/#{follower.id}",
-               "to" => [follower.actor.url],
-               "cc" => [],
-               "actor" => follower.target_actor.url
-             })
-           ) do
-      {:ok, follower, update_data}
-    else
-      err ->
-        Logger.error("Something went wrong while creating an update activity")
-        Logger.debug(inspect(err))
-        err
-    end
-  end
-
-  @spec accept_join(Participant.t(), map) :: {:ok, Participant.t(), Activity.t()} | any
-  defp accept_join(%Participant{} = participant, additional) do
-    with {:ok, %Participant{} = participant} <-
-           Events.update_participant(participant, %{role: :participant}),
-         Absinthe.Subscription.publish(Endpoint, participant.actor,
-           event_person_participation_changed: participant.actor.id
-         ),
-         {:ok, _} <-
-           Scheduler.trigger_notifications_for_participant(participant),
-         participant_as_data <- Convertible.model_to_as(participant),
-         audience <-
-           Audience.get_audience(participant),
-         accept_join_data <-
-           make_accept_join_data(
-             participant_as_data,
-             Map.merge(Map.merge(audience, additional), %{
-               "id" => "#{Endpoint.url()}/accept/join/#{participant.id}"
-             })
-           ) do
-      {:ok, participant, accept_join_data}
-    else
-      err ->
-        Logger.error("Something went wrong while creating an update activity")
-        Logger.debug(inspect(err))
-        err
-    end
-  end
-
-  @spec accept_join(Member.t(), map) :: {:ok, Member.t(), Activity.t()} | any
-  defp accept_join(%Member{} = member, additional) do
-    with {:ok, %Member{} = member} <-
-           Actors.update_member(member, %{role: :member}),
-         {:ok, _} <-
-           Mobilizon.Service.Activity.Member.insert_activity(member,
-             subject: "member_approved"
-           ),
-         _ <- maybe_refresh_group(member),
-         Absinthe.Subscription.publish(Endpoint, member.actor,
-           group_membership_changed: [
-             Actor.preferred_username_and_domain(member.parent),
-             member.actor.id
-           ]
-         ),
-         member_as_data <- Convertible.model_to_as(member),
-         audience <-
-           Audience.get_audience(member),
-         accept_join_data <-
-           make_accept_join_data(
-             member_as_data,
-             Map.merge(Map.merge(audience, additional), %{
-               "id" => "#{Endpoint.url()}/accept/join/#{member.id}"
-             })
-           ) do
-      {:ok, member, accept_join_data}
-    else
-      err ->
-        Logger.error("Something went wrong while creating an update activity")
-        Logger.debug(inspect(err))
-        err
-    end
-  end
-
-  @spec accept_invite(Member.t(), map()) :: {:ok, Member.t(), Activity.t()} | any
-  defp accept_invite(
-         %Member{invited_by_id: invited_by_id, actor_id: actor_id} = member,
-         _additional
-       ) do
-    with %Actor{} = inviter <- Actors.get_actor(invited_by_id),
-         %Actor{url: actor_url} <- Actors.get_actor(actor_id),
-         {:ok, %Member{id: member_id} = member} <-
-           Actors.update_member(member, %{role: :member}),
-         {:ok, _} <-
-           Mobilizon.Service.Activity.Member.insert_activity(member,
-             subject: "member_accepted_invitation"
-           ),
-         _ <- maybe_refresh_group(member),
-         accept_data <- %{
-           "type" => "Accept",
-           "attributedTo" => member.parent.url,
-           "to" => [inviter.url, member.parent.members_url],
-           "cc" => [member.parent.url],
-           "actor" => actor_url,
-           "object" => Convertible.model_to_as(member),
-           "id" => "#{Endpoint.url()}/accept/invite/member/#{member_id}"
-         } do
-      {:ok, member, accept_data}
-    end
-  end
-
-  defp maybe_refresh_group(%Member{
-         parent: %Actor{domain: parent_domain, url: parent_url},
-         actor: %Actor{} = actor
-       }) do
-    unless is_nil(parent_domain),
-      do: Refresher.fetch_group(parent_url, actor)
-  end
-
-  @spec reject_join(Participant.t(), map()) :: {:ok, Participant.t(), Activity.t()} | any()
-  defp reject_join(%Participant{} = participant, additional) do
-    with {:ok, %Participant{} = participant} <-
-           Events.update_participant(participant, %{role: :rejected}),
-         Absinthe.Subscription.publish(Endpoint, participant.actor,
-           event_person_participation_changed: participant.actor.id
-         ),
-         participant_as_data <- Convertible.model_to_as(participant),
-         audience <-
-           participant
-           |> Audience.get_audience()
-           |> Map.merge(additional),
-         reject_data <- %{
-           "type" => "Reject",
-           "object" => participant_as_data
-         },
-         update_data <-
-           reject_data
-           |> Map.merge(audience)
-           |> Map.merge(%{
-             "id" => "#{Endpoint.url()}/reject/join/#{participant.id}"
-           }) do
-      {:ok, participant, update_data}
-    else
-      err ->
-        Logger.error("Something went wrong while creating an update activity")
-        Logger.debug(inspect(err))
-        err
-    end
-  end
-
-  @spec reject_follow(Follower.t(), map()) :: {:ok, Follower.t(), Activity.t()} | any()
-  defp reject_follow(%Follower{} = follower, additional) do
-    with {:ok, %Follower{} = follower} <- Actors.delete_follower(follower),
-         follower_as_data <- Convertible.model_to_as(follower),
-         audience <-
-           follower.actor |> Audience.get_audience() |> Map.merge(additional),
-         reject_data <- %{
-           "to" => [follower.actor.url],
-           "type" => "Reject",
-           "actor" => follower.target_actor.url,
-           "object" => follower_as_data
-         },
-         update_data <-
-           audience
-           |> Map.merge(reject_data)
-           |> Map.merge(%{
-             "id" => "#{Endpoint.url()}/reject/follow/#{follower.id}"
-           }) do
-      {:ok, follower, update_data}
-    else
-      err ->
-        Logger.error("Something went wrong while creating an update activity")
-        Logger.debug(inspect(err))
-        err
-    end
-  end
-
-  @spec reject_invite(Member.t(), map()) :: {:ok, Member.t(), Activity.t()} | any
-  defp reject_invite(
-         %Member{invited_by_id: invited_by_id, actor_id: actor_id} = member,
-         _additional
-       ) do
-    with %Actor{} = inviter <- Actors.get_actor(invited_by_id),
-         %Actor{url: actor_url} <- Actors.get_actor(actor_id),
-         {:ok, %Member{url: member_url, id: member_id} = member} <-
-           Actors.delete_member(member),
-         Mobilizon.Service.Activity.Member.insert_activity(member,
-           subject: "member_rejected_invitation"
-         ),
-         accept_data <- %{
-           "type" => "Reject",
-           "actor" => actor_url,
-           "attributedTo" => member.parent.url,
-           "to" => [inviter.url, member.parent.members_url],
-           "cc" => [member.parent.url],
-           "object" => member_url,
-           "id" => "#{Endpoint.url()}/reject/invite/member/#{member_id}"
-         } do
-      {:ok, member, accept_data}
-    end
-  end
 end
diff --git a/lib/federation/activity_pub/actor.ex b/lib/federation/activity_pub/actor.ex
index 3ac28f57d..7509ee7fe 100644
--- a/lib/federation/activity_pub/actor.ex
+++ b/lib/federation/activity_pub/actor.ex
@@ -14,65 +14,57 @@ defmodule Mobilizon.Federation.ActivityPub.Actor do
   @doc """
   Getting an actor from url, eventually creating it if we don't have it locally or if it needs an update
   """
-  @spec get_or_fetch_actor_by_url(String.t(), boolean) :: {:ok, Actor.t()} | {:error, String.t()}
+  @spec get_or_fetch_actor_by_url(url :: String.t(), preload :: boolean()) ::
+          {:ok, Actor.t()}
+          | {:error, make_actor_errors}
+          | {:error, :no_internal_relay_actor}
+          | {:error, :url_nil}
   def get_or_fetch_actor_by_url(url, preload \\ false)
 
-  def get_or_fetch_actor_by_url(nil, _preload), do: {:error, "Can't fetch a nil url"}
+  def get_or_fetch_actor_by_url(nil, _preload), do: {:error, :url_nil}
 
   def get_or_fetch_actor_by_url("https://www.w3.org/ns/activitystreams#Public", _preload) do
-    with %Actor{url: url} <- Relay.get_actor() do
-      get_or_fetch_actor_by_url(url)
-    end
+    %Actor{url: url} = Relay.get_actor()
+    get_or_fetch_actor_by_url(url)
   end
 
-  @spec get_or_fetch_actor_by_url(String.t(), boolean()) :: {:ok, Actor.t()} | {:error, any()}
   def get_or_fetch_actor_by_url(url, preload) do
-    with {:ok, %Actor{} = cached_actor} <- Actors.get_actor_by_url(url, preload),
-         false <- Actors.needs_update?(cached_actor) do
-      {:ok, cached_actor}
-    else
-      _ ->
-        # For tests, see https://github.com/jjh42/mock#not-supported---mocking-internal-function-calls and Mobilizon.Federation.ActivityPubTest
-        case __MODULE__.make_actor_from_url(url, preload) do
-          {:ok, %Actor{} = actor} ->
-            {:ok, actor}
-
-          {:error, err} ->
-            Logger.debug("Could not fetch by AP id")
-            Logger.debug(inspect(err))
-            {:error, "Could not fetch by AP id"}
+    case Actors.get_actor_by_url(url, preload) do
+      {:ok, %Actor{} = cached_actor} ->
+        if Actors.needs_update?(cached_actor) do
+          __MODULE__.make_actor_from_url(url, preload)
+        else
+          {:ok, cached_actor}
         end
+
+      {:error, :actor_not_found} ->
+        # For tests, see https://github.com/jjh42/mock#not-supported---mocking-internal-function-calls and Mobilizon.Federation.ActivityPubTest
+        __MODULE__.make_actor_from_url(url, preload)
     end
   end
 
+  @type make_actor_errors :: Fetcher.fetch_actor_errors() | :actor_is_local
+
   @doc """
   Create an actor locally by its URL (AP ID)
   """
-  @spec make_actor_from_url(String.t(), boolean()) ::
-          {:ok, %Actor{}} | {:error, :actor_deleted} | {:error, :http_error} | {:error, any()}
+  @spec make_actor_from_url(url :: String.t(), preload :: boolean()) ::
+          {:ok, Actor.t()} | {:error, make_actor_errors}
   def make_actor_from_url(url, preload \\ false) do
     if are_same_origin?(url, Endpoint.url()) do
-      {:error, "Can't make a local actor from URL"}
+      {:error, :actor_is_local}
     else
       case Fetcher.fetch_and_prepare_actor_from_url(url) do
-        # Just in case
-        {:ok, {:error, _e}} ->
-          raise ArgumentError, message: "Failed to make actor from url #{url}"
-
-        {:ok, data} ->
+        {:ok, data} when is_map(data) ->
           Actors.upsert_actor(data, preload)
 
         # Request returned 410
         {:error, :actor_deleted} ->
-          Logger.info("Actor was deleted")
+          Logger.info("Actor #{url} was deleted")
           {:error, :actor_deleted}
 
-        {:error, :http_error} ->
-          {:error, :http_error}
-
-        {:error, e} ->
-          Logger.warn("Failed to make actor from url #{url}")
-          {:error, e}
+        {:error, err} when err in [:http_error, :json_decode_error] ->
+          {:error, err}
       end
     end
   end
@@ -80,8 +72,8 @@ defmodule Mobilizon.Federation.ActivityPub.Actor do
   @doc """
   Find an actor in our local database or call WebFinger to find what's its AP ID is and then fetch it
   """
-  @spec find_or_make_actor_from_nickname(String.t(), atom() | nil) ::
-          {:ok, Actor.t()} | {:error, any()}
+  @spec find_or_make_actor_from_nickname(nickname :: String.t(), type :: atom() | nil) ::
+          {:ok, Actor.t()} | {:error, make_actor_errors | WebFinger.finger_errors()}
   def find_or_make_actor_from_nickname(nickname, type \\ nil) do
     case Actors.get_actor_by_name_with_preload(nickname, type) do
       %Actor{url: actor_url} = actor ->
@@ -96,20 +88,22 @@ defmodule Mobilizon.Federation.ActivityPub.Actor do
     end
   end
 
-  @spec find_or_make_group_from_nickname(String.t()) :: tuple()
+  @spec find_or_make_group_from_nickname(nick :: String.t()) ::
+          {:error, make_actor_errors | WebFinger.finger_errors()}
   def find_or_make_group_from_nickname(nick), do: find_or_make_actor_from_nickname(nick, :Group)
 
   @doc """
   Create an actor inside our database from username, using WebFinger to find out its AP ID and then fetch it
   """
-  @spec make_actor_from_nickname(String.t()) :: {:ok, %Actor{}} | {:error, any()}
+  @spec make_actor_from_nickname(nickname :: String.t(), preload :: boolean) ::
+          {:ok, Actor.t()} | {:error, make_actor_errors | WebFinger.finger_errors()}
   def make_actor_from_nickname(nickname, preload \\ false) do
     case WebFinger.finger(nickname) do
       {:ok, url} when is_binary(url) ->
         make_actor_from_url(url, preload)
 
-      _e ->
-        {:error, "No ActivityPub URL found in WebFinger"}
+      {:error, e} ->
+        {:error, e}
     end
   end
 end
diff --git a/lib/federation/activity_pub/audience.ex b/lib/federation/activity_pub/audience.ex
index 2b6a6be5b..d412ef36f 100644
--- a/lib/federation/activity_pub/audience.ex
+++ b/lib/federation/activity_pub/audience.ex
@@ -7,6 +7,7 @@ defmodule Mobilizon.Federation.ActivityPub.Audience do
   alias Mobilizon.Actors.{Actor, Member}
   alias Mobilizon.Discussions.{Comment, Discussion}
   alias Mobilizon.Events.{Event, Participant}
+  alias Mobilizon.Federation.ActivityPub.Types.Entity
   alias Mobilizon.Posts.Post
   alias Mobilizon.Storage.Repo
 
@@ -99,6 +100,8 @@ defmodule Mobilizon.Federation.ActivityPub.Audience do
     }
   end
 
+  @spec get_to_and_cc(Actor.t(), list(), :direct | :private | :public | :unlisted | {:list, any}) ::
+          {list(), list()}
   @doc """
   Determines the full audience based on mentions for an audience
 
@@ -118,7 +121,6 @@ defmodule Mobilizon.Federation.ActivityPub.Audience do
     * `to` : the mentioned actors and the eventual actor we're replying to
     * `cc` : none
   """
-  @spec get_to_and_cc(Actor.t(), list(), String.t()) :: {list(), list()}
   def get_to_and_cc(%Actor{} = actor, mentions, :public) do
     to = [@ap_public | mentions]
     cc = [actor.followers_url]
@@ -128,7 +130,6 @@ defmodule Mobilizon.Federation.ActivityPub.Audience do
     {to, cc}
   end
 
-  @spec get_to_and_cc(Actor.t(), list(), String.t()) :: {list(), list()}
   def get_to_and_cc(%Actor{} = actor, mentions, :unlisted) do
     to = [actor.followers_url | mentions]
     cc = [@ap_public]
@@ -138,7 +139,6 @@ defmodule Mobilizon.Federation.ActivityPub.Audience do
     {to, cc}
   end
 
-  @spec get_to_and_cc(Actor.t(), list(), String.t()) :: {list(), list()}
   def get_to_and_cc(%Actor{} = actor, mentions, :private) do
     {to, cc} = get_to_and_cc(actor, mentions, :direct)
 
@@ -147,7 +147,6 @@ defmodule Mobilizon.Federation.ActivityPub.Audience do
     {to, cc}
   end
 
-  @spec get_to_and_cc(Actor.t(), list(), String.t()) :: {list(), list()}
   def get_to_and_cc(_actor, mentions, :direct) do
     {mentions, []}
   end
@@ -156,22 +155,20 @@ defmodule Mobilizon.Federation.ActivityPub.Audience do
     {mentions, []}
   end
 
-  @spec maybe_add_group_members(List.t(), Actor.t()) :: List.t()
+  @spec maybe_add_group_members(list(String.t()), Actor.t()) :: list(String.t())
   defp maybe_add_group_members(collection, %Actor{type: :Group, members_url: members_url}) do
     [members_url | collection]
   end
 
   defp maybe_add_group_members(collection, %Actor{type: _}), do: collection
 
-  @spec maybe_add_followers(List.t(), Actor.t()) :: List.t()
+  @spec maybe_add_followers(list(String.t()), Actor.t()) :: list(String.t())
   defp maybe_add_followers(collection, %Actor{type: :Group, followers_url: followers_url}) do
     [followers_url | collection]
   end
 
   defp maybe_add_followers(collection, %Actor{type: _}), do: collection
 
-  def get_addressed_actors(mentioned_users, _), do: mentioned_users
-
   defp add_in_reply_to(%Comment{actor: %Actor{url: url}} = _comment), do: [url]
   defp add_in_reply_to(%Event{organizer_actor: %Actor{url: url}} = _event), do: [url]
   defp add_in_reply_to(_), do: []
@@ -239,29 +236,27 @@ defmodule Mobilizon.Federation.ActivityPub.Audience do
 
   @spec extract_actors_from_mentions(list(), Actor.t(), atom()) :: {list(), list()}
   defp extract_actors_from_mentions(mentions, actor, visibility) do
-    with mentioned_actors <- Enum.map(mentions, &process_mention/1),
-         addressed_actors <- get_addressed_actors(mentioned_actors, nil) do
-      get_to_and_cc(actor, addressed_actors, visibility)
-    end
+    get_to_and_cc(actor, Enum.map(mentions, &process_mention/1), visibility)
   end
 
+  @spec extract_actors_from_event(Event.t()) :: %{
+          String.t() => list(String.t())
+        }
   defp extract_actors_from_event(%Event{} = event) do
-    with {to, cc} <-
-           extract_actors_from_mentions(
-             event.mentions,
-             group_or_organizer_event(event),
-             event.visibility
-           ),
-         {to, cc} <-
-           {to,
-            Enum.uniq(
-              cc ++ add_comments_authors(event.comments) ++ add_shares_actors_followers(event.url)
-            )} do
-      %{"to" => to, "cc" => cc}
-    else
-      _ ->
-        %{"to" => [], "cc" => []}
-    end
+    {to, cc} =
+      extract_actors_from_mentions(
+        event.mentions,
+        group_or_organizer_event(event),
+        event.visibility
+      )
+
+    {to, cc} =
+      {to,
+       Enum.uniq(
+         cc ++ add_comments_authors(event.comments) ++ add_shares_actors_followers(event.url)
+       )}
+
+    %{"to" => to, "cc" => cc}
   end
 
   @spec group_or_organizer_event(Event.t()) :: Actor.t()
diff --git a/lib/federation/activity_pub/federator.ex b/lib/federation/activity_pub/federator.ex
index 4bed74643..ac145afff 100644
--- a/lib/federation/activity_pub/federator.ex
+++ b/lib/federation/activity_pub/federator.ex
@@ -12,17 +12,19 @@ defmodule Mobilizon.Federation.ActivityPub.Federator do
 
   alias Mobilizon.Actors.Actor
   alias Mobilizon.Federation.ActivityPub
-  alias Mobilizon.Federation.ActivityPub.{Activity, Transmogrifier}
   alias Mobilizon.Federation.ActivityPub.Actor, as: ActivityPubActor
+  alias Mobilizon.Federation.ActivityPub.Transmogrifier
 
   require Logger
 
   @max_jobs 20
 
+  @spec init(any()) :: {:ok, any()}
   def init(args) do
     {:ok, args}
   end
 
+  @spec start_link(any) :: GenServer.on_start()
   def start_link(_) do
     spawn(fn ->
       # 1 minute
@@ -39,6 +41,8 @@ defmodule Mobilizon.Federation.ActivityPub.Federator do
     )
   end
 
+  @spec handle(:publish | :publish_single_ap | atom(), Activity.t() | map()) ::
+          :ok | {:ok, Activity.t()} | Tesla.Env.result() | {:error, String.t()}
   def handle(:publish, activity) do
     Logger.debug(inspect(activity))
     Logger.debug(fn -> "Running publish for #{activity.data["id"]}" end)
@@ -46,7 +50,7 @@ defmodule Mobilizon.Federation.ActivityPub.Federator do
     with {:ok, %Actor{} = actor} <-
            ActivityPubActor.get_or_fetch_actor_by_url(activity.data["actor"]) do
       Logger.info(fn -> "Sending #{activity.data["id"]} out via AP" end)
-      ActivityPub.publish(actor, activity)
+      ActivityPub.Publisher.publish(actor, activity)
     end
   end
 
@@ -58,9 +62,6 @@ defmodule Mobilizon.Federation.ActivityPub.Federator do
       {:ok, activity, _data} ->
         {:ok, activity}
 
-      %Activity{} ->
-        Logger.info("Already had #{params["id"]}")
-
       e ->
         # Just drop those for now
         Logger.debug("Unhandled activity")
@@ -70,7 +71,7 @@ defmodule Mobilizon.Federation.ActivityPub.Federator do
   end
 
   def handle(:publish_single_ap, params) do
-    ActivityPub.publish_one(params)
+    ActivityPub.Publisher.publish_one(params)
   end
 
   def handle(type, _) do
@@ -78,6 +79,7 @@ defmodule Mobilizon.Federation.ActivityPub.Federator do
     {:error, "Don't know what to do with this"}
   end
 
+  @spec enqueue(atom(), map(), pos_integer()) :: :ok | {:ok, any()} | {:error, any()}
   def enqueue(type, payload, priority \\ 1) do
     Logger.debug("enqueue something with type #{inspect(type)}")
 
@@ -88,6 +90,7 @@ defmodule Mobilizon.Federation.ActivityPub.Federator do
     end
   end
 
+  @spec maybe_start_job(any(), any()) :: {any(), any()}
   def maybe_start_job(running_jobs, queue) do
     if :sets.size(running_jobs) < @max_jobs && queue != [] do
       {{type, payload}, queue} = queue_pop(queue)
@@ -99,6 +102,7 @@ defmodule Mobilizon.Federation.ActivityPub.Federator do
     end
   end
 
+  @spec handle_cast(any(), any()) :: {:noreply, any()}
   def handle_cast({:enqueue, type, payload, _priority}, state)
       when type in [:incoming_doc, :incoming_ap_doc] do
     %{in: {i_running_jobs, i_queue}, out: {o_running_jobs, o_queue}} = state
@@ -122,6 +126,7 @@ defmodule Mobilizon.Federation.ActivityPub.Federator do
     {:noreply, state}
   end
 
+  @spec handle_info({:DOWN, any(), :process, any, any()}, any) :: {:noreply, map()}
   def handle_info({:DOWN, ref, :process, _pid, _reason}, state) do
     %{in: {i_running_jobs, i_queue}, out: {o_running_jobs, o_queue}} = state
     i_running_jobs = :sets.del_element(ref, i_running_jobs)
@@ -132,11 +137,13 @@ defmodule Mobilizon.Federation.ActivityPub.Federator do
     {:noreply, %{in: {i_running_jobs, i_queue}, out: {o_running_jobs, o_queue}}}
   end
 
+  @spec enqueue_sorted(any(), any(), pos_integer()) :: any()
   def enqueue_sorted(queue, element, priority) do
     [%{item: element, priority: priority} | queue]
     |> Enum.sort_by(fn %{priority: priority} -> priority end)
   end
 
+  @spec queue_pop(list(any())) :: {any(), list(any())}
   def queue_pop([%{item: element} | queue]) do
     {element, queue}
   end
diff --git a/lib/federation/activity_pub/fetcher.ex b/lib/federation/activity_pub/fetcher.ex
index 71a7cfc1c..02895bcd0 100644
--- a/lib/federation/activity_pub/fetcher.ex
+++ b/lib/federation/activity_pub/fetcher.ex
@@ -15,125 +15,153 @@ defmodule Mobilizon.Federation.ActivityPub.Fetcher do
   import Mobilizon.Federation.ActivityPub.Utils,
     only: [maybe_date_fetch: 2, sign_fetch: 4, origin_check?: 2]
 
-  @spec fetch(String.t(), Keyword.t()) :: {:ok, map()}
+  import Mobilizon.Service.Guards, only: [is_valid_string: 1]
+
+  @spec fetch(String.t(), Keyword.t()) ::
+          {:ok, map()}
+          | {:error,
+             :invalid_url | :http_gone | :http_error | :http_not_found | :content_not_json}
   def fetch(url, options \\ []) do
     on_behalf_of = Keyword.get(options, :on_behalf_of, Relay.get_actor())
+    date = Signature.generate_date_header()
 
-    with false <- address_invalid(url),
-         date <- Signature.generate_date_header(),
-         headers <-
-           [{:Accept, "application/activity+json"}]
-           |> maybe_date_fetch(date)
-           |> sign_fetch(on_behalf_of, url, date),
-         client <-
-           ActivityPubClient.client(headers: headers),
-         {:ok, %Tesla.Env{body: data, status: code}} when code in 200..299 <-
-           ActivityPubClient.get(client, url) do
-      {:ok, data}
+    headers =
+      [{:Accept, "application/activity+json"}]
+      |> maybe_date_fetch(date)
+      |> sign_fetch(on_behalf_of, url, date)
+
+    client = ActivityPubClient.client(headers: headers)
+
+    if address_valid?(url) do
+      case ActivityPubClient.get(client, url) do
+        {:ok, %Tesla.Env{body: data, status: code}} when code in 200..299 and is_map(data) ->
+          {:ok, data}
+
+        {:ok, %Tesla.Env{status: 410}} ->
+          Logger.debug("Resource at #{url} is 410 Gone")
+          {:error, :http_gone}
+
+        {:ok, %Tesla.Env{status: 404}} ->
+          Logger.debug("Resource at #{url} is 404 Gone")
+          {:error, :http_not_found}
+
+        {:ok, %Tesla.Env{body: data}} when is_binary(data) ->
+          {:error, :content_not_json}
+
+        {:ok, %Tesla.Env{} = res} ->
+          Logger.debug("Resource returned bad HTTP code inspect #{res}")
+          {:error, :http_error}
+      end
     else
-      {:ok, %Tesla.Env{status: 410}} ->
-        Logger.debug("Resource at #{url} is 410 Gone")
-        {:error, "Gone"}
-
-      {:ok, %Tesla.Env{status: 404}} ->
-        Logger.debug("Resource at #{url} is 404 Gone")
-        {:error, "Not found"}
-
-      {:ok, %Tesla.Env{} = res} ->
-        {:error, res}
-
-      {:error, err} ->
-        {:error, err}
+      {:error, :invalid_url}
     end
   end
 
-  @spec fetch_and_create(String.t(), Keyword.t()) :: {:ok, map(), struct()}
+  @spec fetch_and_create(String.t(), Keyword.t()) ::
+          {:ok, map(), struct()} | {:error, atom()} | :error
   def fetch_and_create(url, options \\ []) do
-    with {:ok, data} when is_map(data) <- fetch(url, options),
-         {:origin_check, true} <- {:origin_check, origin_check?(url, data)},
-         params <- %{
-           "type" => "Create",
-           "to" => data["to"],
-           "cc" => data["cc"],
-           "actor" => data["actor"] || data["attributedTo"],
-           "attributedTo" => data["attributedTo"] || data["actor"],
-           "object" => data
-         } do
-      Transmogrifier.handle_incoming(params)
-    else
-      {:origin_check, false} ->
-        Logger.warn("Object origin check failed")
-        {:error, "Object origin check failed"}
+    case fetch(url, options) do
+      {:ok, data} when is_map(data) ->
+        if origin_check?(url, data) do
+          case Transmogrifier.handle_incoming(%{
+                 "type" => "Create",
+                 "to" => data["to"],
+                 "cc" => data["cc"],
+                 "actor" => data["actor"] || data["attributedTo"],
+                 "attributedTo" => data["attributedTo"] || data["actor"],
+                 "object" => data
+               }) do
+            {:ok, entity, structure} ->
+              {:ok, entity, structure}
 
-      # Returned content is not JSON
-      {:ok, data} when is_binary(data) ->
-        {:error, "Failed to parse content as JSON"}
+            {:error, error} when is_atom(error) ->
+              {:error, error}
+
+            :error ->
+              {:error, :transmogrifier_error}
+          end
+        else
+          Logger.warn("Object origin check failed")
+          {:error, :object_origin_check_failed}
+        end
 
       {:error, err} ->
         {:error, err}
     end
   end
 
-  @spec fetch_and_update(String.t(), Keyword.t()) :: {:ok, map(), struct()}
+  @spec fetch_and_update(String.t(), Keyword.t()) ::
+          {:ok, map(), struct()} | {:error, atom()}
   def fetch_and_update(url, options \\ []) do
-    with {:ok, data} when is_map(data) <- fetch(url, options),
-         {:origin_check, true} <- {:origin_check, origin_check(url, data)},
-         params <- %{
-           "type" => "Update",
-           "to" => data["to"],
-           "cc" => data["cc"],
-           "actor" => data["actor"] || data["attributedTo"],
-           "attributedTo" => data["attributedTo"] || data["actor"],
-           "object" => data
-         } do
-      Transmogrifier.handle_incoming(params)
-    else
-      {:origin_check, false} ->
-        {:error, "Object origin check failed"}
+    case fetch(url, options) do
+      {:ok, data} when is_map(data) ->
+        if origin_check(url, data) do
+          Transmogrifier.handle_incoming(%{
+            "type" => "Update",
+            "to" => data["to"],
+            "cc" => data["cc"],
+            "actor" => data["actor"] || data["attributedTo"],
+            "attributedTo" => data["attributedTo"] || data["actor"],
+            "object" => data
+          })
+        else
+          Logger.warn("Object origin check failed")
+          {:error, :object_origin_check_failed}
+        end
 
       {:error, err} ->
         {:error, err}
     end
   end
 
+  @type fetch_actor_errors ::
+          :json_decode_error | :actor_deleted | :http_error | :actor_not_allowed_type
+
   @doc """
   Fetching a remote actor's information through its AP ID
   """
-  @spec fetch_and_prepare_actor_from_url(String.t()) :: {:ok, map()} | {:error, atom()} | any()
+  @spec fetch_and_prepare_actor_from_url(String.t()) ::
+          {:ok, map()} | {:error, fetch_actor_errors}
   def fetch_and_prepare_actor_from_url(url) do
     Logger.debug("Fetching and preparing actor from url")
     Logger.debug(inspect(url))
 
-    res =
-      with {:ok, %{status: 200, body: body}} <-
-             Tesla.get(url,
-               headers: [{"Accept", "application/activity+json"}],
-               follow_redirect: true
-             ),
-           :ok <- Logger.debug("response okay, now decoding json"),
-           {:ok, data} <- Jason.decode(body) do
-        Logger.debug("Got activity+json response at actor's endpoint, now converting data")
-        {:ok, ActorConverter.as_to_model_data(data)}
-      else
-        # Actor is gone, probably deleted
-        {:ok, %{status: 410}} ->
-          Logger.info("Response HTTP 410")
-          {:error, :actor_deleted}
+    case Tesla.get(url,
+           headers: [{"Accept", "application/activity+json"}],
+           follow_redirect: true
+         ) do
+      {:ok, %{status: 200, body: body}} ->
+        Logger.debug("response okay, now decoding json")
 
-        {:ok, %Tesla.Env{}} ->
-          Logger.info("Non 200 HTTP Code")
-          {:error, :http_error}
+        case Jason.decode(body) do
+          {:ok, data} when is_map(data) ->
+            Logger.debug("Got activity+json response at actor's endpoint, now converting data")
 
-        {:error, e} ->
-          Logger.warn("Could not decode actor at fetch #{url}, #{inspect(e)}")
-          {:error, e}
+            case ActorConverter.as_to_model_data(data) do
+              {:error, :actor_not_allowed_type} ->
+                {:error, :actor_not_allowed_type}
 
-        e ->
-          Logger.warn("Could not decode actor at fetch #{url}, #{inspect(e)}")
-          {:error, e}
-      end
+              map when is_map(map) ->
+                {:ok, map}
+            end
 
-    res
+          {:error, %Jason.DecodeError{} = e} ->
+            Logger.warn("Could not decode actor at fetch #{url}, #{inspect(e)}")
+            {:error, :json_decode_error}
+        end
+
+      {:ok, %{status: 410}} ->
+        Logger.info("Response HTTP 410")
+        {:error, :actor_deleted}
+
+      {:ok, %Tesla.Env{}} ->
+        Logger.info("Non 200 HTTP Code")
+        {:error, :http_error}
+
+      {:error, error} ->
+        Logger.warn("Could not fetch actor at fetch #{url}, #{inspect(error)}")
+        {:error, :http_error}
+    end
   end
 
   @spec origin_check(String.t(), map()) :: boolean()
@@ -147,11 +175,9 @@ defmodule Mobilizon.Federation.ActivityPub.Fetcher do
     end
   end
 
-  @spec address_invalid(String.t()) :: false | {:error, :invalid_url}
-  defp address_invalid(address) do
-    with %URI{host: host, scheme: scheme} <- URI.parse(address),
-         true <- is_nil(host) or is_nil(scheme) do
-      {:error, :invalid_url}
-    end
+  @spec address_valid?(String.t()) :: boolean
+  defp address_valid?(address) do
+    %URI{host: host, scheme: scheme} = URI.parse(address)
+    is_valid_string(host) and is_valid_string(scheme)
   end
 end
diff --git a/lib/federation/activity_pub/permission.ex b/lib/federation/activity_pub/permission.ex
index 41a14afca..9a14c1671 100644
--- a/lib/federation/activity_pub/permission.ex
+++ b/lib/federation/activity_pub/permission.ex
@@ -13,6 +13,17 @@ defmodule Mobilizon.Federation.ActivityPub.Permission do
 
   @member_roles [:member, :moderator, :administrator]
 
+  @type object :: %{id: String.t(), url: String.t()}
+
+  @type permissions_member_role :: nil | :member | :moderator | :administrator
+
+  @type t :: %__MODULE__{
+          access: permissions_member_role,
+          create: permissions_member_role,
+          update: permissions_member_role,
+          delete: permissions_member_role
+        }
+
   @doc """
   Check that actor can access the object
   """
@@ -66,8 +77,8 @@ defmodule Mobilizon.Federation.ActivityPub.Permission do
 
   @spec can_manage_group_object?(
           existing_object_permissions(),
-          Actor.t(),
-          any()
+          %Actor{url: String.t()},
+          object()
         ) :: boolean()
   defp can_manage_group_object?(permission, %Actor{url: actor_url} = actor, object) do
     if Ownable.group_actor(object) != nil do
@@ -94,7 +105,7 @@ defmodule Mobilizon.Federation.ActivityPub.Permission do
     end
   end
 
-  @spec activity_actor_is_group_member?(Actor.t(), Entity.t(), atom()) :: boolean()
+  @spec activity_actor_is_group_member?(Actor.t(), object(), atom()) :: boolean()
   defp activity_actor_is_group_member?(
          %Actor{id: actor_id, url: actor_url},
          object,
diff --git a/lib/federation/activity_pub/publisher.ex b/lib/federation/activity_pub/publisher.ex
new file mode 100644
index 000000000..b2b90f502
--- /dev/null
+++ b/lib/federation/activity_pub/publisher.ex
@@ -0,0 +1,128 @@
+defmodule Mobilizon.Federation.ActivityPub.Publisher do
+  @moduledoc """
+  Handle publishing activities
+  """
+  alias Mobilizon.Actors
+  alias Mobilizon.Actors.Actor
+  alias Mobilizon.Config
+  alias Mobilizon.Federation.ActivityPub.{Activity, Federator, Relay, Transmogrifier, Visibility}
+  alias Mobilizon.Federation.HTTPSignatures.Signature
+  require Logger
+  import Mobilizon.Federation.ActivityPub.Utils, only: [remote_actors: 1]
+
+  @doc """
+  Publish an activity to all appropriated audiences inboxes
+  """
+  # credo:disable-for-lines:47
+  @spec publish(Actor.t(), Activity.t()) :: :ok
+  def publish(actor, %Activity{recipients: recipients} = activity) do
+    Logger.debug("Publishing an activity")
+    Logger.debug(inspect(activity, pretty: true))
+
+    public = Visibility.is_public?(activity)
+    Logger.debug("is public ? #{public}")
+
+    if public && is_create_activity?(activity) && Config.get([:instance, :allow_relay]) do
+      Logger.info(fn -> "Relaying #{activity.data["id"]} out" end)
+
+      Relay.publish(activity)
+    end
+
+    recipients = Enum.uniq(recipients)
+
+    {recipients, followers} = convert_followers_in_recipients(recipients)
+
+    {recipients, members} = convert_members_in_recipients(recipients)
+
+    remote_inboxes =
+      (remote_actors(recipients) ++ followers ++ members)
+      |> Enum.map(fn actor -> actor.shared_inbox_url || actor.inbox_url end)
+      |> Enum.uniq()
+
+    {:ok, data} = Transmogrifier.prepare_outgoing(activity.data)
+    json = Jason.encode!(data)
+    Logger.debug(fn -> "Remote inboxes are : #{inspect(remote_inboxes)}" end)
+
+    Enum.each(remote_inboxes, fn inbox ->
+      Federator.enqueue(:publish_single_ap, %{
+        inbox: inbox,
+        json: json,
+        actor: actor,
+        id: activity.data["id"]
+      })
+    end)
+  end
+
+  @doc """
+  Publish an activity to a specific inbox
+  """
+  @spec publish_one(%{inbox: String.t(), json: String.t(), actor: Actor.t(), id: String.t()}) ::
+          Tesla.Env.result()
+  def publish_one(%{inbox: inbox, json: json, actor: actor, id: id}) do
+    Logger.info("Federating #{id} to #{inbox}")
+    %URI{host: host, path: path} = URI.parse(inbox)
+
+    digest = Signature.build_digest(json)
+    date = Signature.generate_date_header()
+
+    # request_target = Signature.generate_request_target("POST", path)
+
+    signature =
+      Signature.sign(actor, %{
+        "(request-target)": "post #{path}",
+        host: host,
+        "content-length": byte_size(json),
+        digest: digest,
+        date: date
+      })
+
+    Tesla.post(
+      inbox,
+      json,
+      headers: [
+        {"Content-Type", "application/activity+json"},
+        {"signature", signature},
+        {"digest", digest},
+        {"date", date}
+      ]
+    )
+  end
+
+  @spec convert_followers_in_recipients(list(String.t())) :: {list(String.t()), list(String.t())}
+  defp convert_followers_in_recipients(recipients) do
+    Enum.reduce(recipients, {recipients, []}, fn recipient, {recipients, follower_actors} = acc ->
+      case Actors.get_actor_by_followers_url(recipient) do
+        %Actor{} = group ->
+          {Enum.filter(recipients, fn recipient -> recipient != group.followers_url end),
+           follower_actors ++ Actors.list_external_followers_for_actor(group)}
+
+        nil ->
+          acc
+      end
+    end)
+  end
+
+  @spec is_create_activity?(Activity.t()) :: boolean
+  defp is_create_activity?(%Activity{data: %{"type" => "Create"}}), do: true
+  defp is_create_activity?(_), do: false
+
+  @spec convert_members_in_recipients(list(String.t())) :: {list(String.t()), list(Actor.t())}
+  defp convert_members_in_recipients(recipients) do
+    Enum.reduce(recipients, {recipients, []}, fn recipient, {recipients, member_actors} = acc ->
+      case Actors.get_group_by_members_url(recipient) do
+        # If the group is local just add external members
+        %Actor{domain: domain} = group when is_nil(domain) ->
+          {Enum.filter(recipients, fn recipient -> recipient != group.members_url end),
+           member_actors ++ Actors.list_external_actors_members_for_group(group)}
+
+        # If it's remote add the remote group actor as well
+        %Actor{} = group ->
+          {Enum.filter(recipients, fn recipient -> recipient != group.members_url end),
+           member_actors ++ Actors.list_external_actors_members_for_group(group) ++ [group]}
+
+        _ ->
+          acc
+      end
+    end)
+  end
+end
diff --git a/lib/federation/activity_pub/refresher.ex b/lib/federation/activity_pub/refresher.ex
index 7385da96e..ae60edff6 100644
--- a/lib/federation/activity_pub/refresher.ex
+++ b/lib/federation/activity_pub/refresher.ex
@@ -8,13 +8,12 @@ defmodule Mobilizon.Federation.ActivityPub.Refresher do
   alias Mobilizon.Federation.ActivityPub
   alias Mobilizon.Federation.ActivityPub.Actor, as: ActivityPubActor
   alias Mobilizon.Federation.ActivityPub.{Fetcher, Relay, Transmogrifier, Utils}
-  alias Mobilizon.Service.ErrorReporting.Sentry
   require Logger
 
   @doc """
   Refresh a remote profile
   """
-  @spec refresh_profile(Actor.t()) :: {:ok, Actor.t()}
+  @spec refresh_profile(Actor.t()) :: {:ok, Actor.t()} | {:error, fetch_actor_errors()} | {:error}
   def refresh_profile(%Actor{domain: nil}), do: {:error, "Can only refresh remote actors"}
 
   def refresh_profile(%Actor{type: :Group, url: url, id: group_id} = group) do
@@ -27,84 +26,98 @@ defmodule Mobilizon.Federation.ActivityPub.Refresher do
           Relay.get_actor()
       end
 
-    with :ok <- fetch_group(url, on_behalf_of) do
-      {:ok, group}
+    case fetch_group(url, on_behalf_of) do
+      {:error, error} ->
+        {:error, error}
+
+      :ok ->
+        {:ok, group}
     end
   end
 
   def refresh_profile(%Actor{type: type, url: url}) when type in [:Person, :Application] do
-    with {:ok, %Actor{outbox_url: outbox_url} = actor} <-
-           ActivityPubActor.make_actor_from_url(url),
-         :ok <- fetch_collection(outbox_url, Relay.get_actor()) do
-      {:ok, actor}
+    case ActivityPubActor.make_actor_from_url(url) do
+      {:error, error} ->
+        {:error, error}
+
+      {:ok, %Actor{outbox_url: outbox_url} = actor} ->
+        case fetch_collection(outbox_url, Relay.get_actor()) do
+          :ok -> {:ok, actor}
+          {:error, error} -> {:error, error}
+        end
     end
   end
 
-  @spec fetch_group(String.t(), Actor.t()) :: :ok
+  @type fetch_actor_errors :: ActivityPubActor.make_actor_errors() | fetch_collection_errors()
+
+  @spec fetch_group(String.t(), Actor.t()) :: :ok | {:error, fetch_actor_errors}
   def fetch_group(group_url, %Actor{} = on_behalf_of) do
-    with {:ok,
-          %Actor{
-            outbox_url: outbox_url,
-            resources_url: resources_url,
-            members_url: members_url,
-            posts_url: posts_url,
-            todos_url: todos_url,
-            discussions_url: discussions_url,
-            events_url: events_url
-          }} <-
-           ActivityPubActor.make_actor_from_url(group_url),
-         :ok <- fetch_collection(outbox_url, on_behalf_of),
-         :ok <- fetch_collection(members_url, on_behalf_of),
-         :ok <- fetch_collection(resources_url, on_behalf_of),
-         :ok <- fetch_collection(posts_url, on_behalf_of),
-         :ok <- fetch_collection(todos_url, on_behalf_of),
-         :ok <- fetch_collection(discussions_url, on_behalf_of),
-         :ok <- fetch_collection(events_url, on_behalf_of) do
-      :ok
-    else
-      {:error, :actor_deleted} ->
-        {:error, :actor_deleted}
-
-      {:error, :http_error} ->
-        {:error, :http_error}
-
-      {:error, err} ->
-        Logger.error("Error while refreshing a group")
-
-        Sentry.capture_message("Error while refreshing a group",
-          extra: %{group_url: group_url}
-        )
-
-        Logger.debug(inspect(err))
+    case ActivityPubActor.make_actor_from_url(group_url) do
+      {:error, err}
+      when err in [:actor_deleted, :http_error, :json_decode_error, :actor_is_local] ->
+        Logger.debug("Error while making actor")
         {:error, err}
 
-      err ->
-        Logger.error("Error while refreshing a group")
+      {:ok,
+       %Actor{
+         outbox_url: outbox_url,
+         resources_url: resources_url,
+         members_url: members_url,
+         posts_url: posts_url,
+         todos_url: todos_url,
+         discussions_url: discussions_url,
+         events_url: events_url
+       }} ->
+        Logger.debug("Fetched group OK, now doing collections")
 
-        Sentry.capture_message("Error while refreshing a group",
-          extra: %{group_url: group_url}
-        )
-
-        Logger.debug(inspect(err))
-        err
+        with :ok <- fetch_collection(outbox_url, on_behalf_of),
+             :ok <- fetch_collection(members_url, on_behalf_of),
+             :ok <- fetch_collection(resources_url, on_behalf_of),
+             :ok <- fetch_collection(posts_url, on_behalf_of),
+             :ok <- fetch_collection(todos_url, on_behalf_of),
+             :ok <- fetch_collection(discussions_url, on_behalf_of),
+             :ok <- fetch_collection(events_url, on_behalf_of) do
+          :ok
+        else
+          {:error, err}
+          when err in [:error, :process_error, :fetch_error, :collection_url_nil] ->
+            Logger.debug("Error while fetching actor collection")
+            {:error, err}
+        end
     end
   end
 
-  def fetch_collection(nil, _on_behalf_of), do: :error
+  @typep fetch_collection_errors :: :process_error | :fetch_error | :collection_url_nil
+
+  @spec fetch_collection(String.t() | nil, any) ::
+          :ok | {:error, fetch_collection_errors}
+  def fetch_collection(nil, _on_behalf_of), do: {:error, :collection_url_nil}
 
   def fetch_collection(collection_url, on_behalf_of) do
     Logger.debug("Fetching and preparing collection from url")
     Logger.debug(inspect(collection_url))
 
-    with {:ok, data} <- Fetcher.fetch(collection_url, on_behalf_of: on_behalf_of),
-         :ok <- Logger.debug("Fetch ok, passing to process_collection"),
-         :ok <- process_collection(data, on_behalf_of) do
-      Logger.debug("Finished processing a collection")
-      :ok
+    case Fetcher.fetch(collection_url, on_behalf_of: on_behalf_of) do
+      {:ok, data} when is_map(data) ->
+        Logger.debug("Fetch ok, passing to process_collection")
+
+        case process_collection(data, on_behalf_of) do
+          :ok ->
+            Logger.debug("Finished processing a collection")
+            :ok
+
+          :error ->
+            Logger.debug("Failed to process collection #{collection_url}")
+            {:error, :process_error}
+        end
+
+      {:error, _err} ->
+        Logger.debug("Failed to fetch collection #{collection_url}")
+        {:error, :fetch_error}
     end
   end
 
-  @spec fetch_element(String.t(), Actor.t()) :: any()
+  @spec fetch_element(String.t(), Actor.t()) :: {:ok, struct()} | {:error, any()}
   def fetch_element(url, %Actor{} = on_behalf_of) do
     with {:ok, data} <- Fetcher.fetch(url, on_behalf_of: on_behalf_of) do
       case handling_element(data) do
@@ -114,6 +127,9 @@ defmodule Mobilizon.Federation.ActivityPub.Refresher do
         {:ok, entity} ->
           {:ok, entity}
 
+        :error ->
+          {:error, :err_fetching_element}
+
         err ->
           {:error, err}
       end
@@ -127,6 +143,7 @@ defmodule Mobilizon.Federation.ActivityPub.Refresher do
     |> Enum.each(&refresh_profile/1)
   end
 
+  @spec process_collection(map(), any()) :: :ok | :error
   defp process_collection(%{"type" => type, "orderedItems" => items}, _on_behalf_of)
        when type in ["OrderedCollection", "OrderedCollectionPage"] do
     Logger.debug(
@@ -168,6 +185,8 @@ defmodule Mobilizon.Federation.ActivityPub.Refresher do
   defp process_collection(_, _), do: :error
 
   # If we're handling an activity
+  @spec handling_element(map()) :: {:ok, any, struct} | :error
+  @spec handling_element(String.t()) :: {:ok, struct} | {:error, any()}
   defp handling_element(%{"type" => activity_type} = data)
        when activity_type in ["Create", "Update", "Delete"] do
     object = get_in(data, ["object"])
diff --git a/lib/federation/activity_pub/relay.ex b/lib/federation/activity_pub/relay.ex
index 90eb4cea2..52ab3fe6d 100644
--- a/lib/federation/activity_pub/relay.ex
+++ b/lib/federation/activity_pub/relay.ex
@@ -11,8 +11,7 @@ defmodule Mobilizon.Federation.ActivityPub.Relay do
   alias Mobilizon.Actors
   alias Mobilizon.Actors.{Actor, Follower}
 
-  alias Mobilizon.Federation.ActivityPub
-  alias Mobilizon.Federation.ActivityPub.{Activity, Transmogrifier}
+  alias Mobilizon.Federation.ActivityPub.{Actions, Activity, Transmogrifier}
   alias Mobilizon.Federation.ActivityPub.Actor, as: ActivityPubActor
   alias Mobilizon.Federation.WebFinger
   alias Mobilizon.Service.Workers.Background
@@ -27,76 +26,100 @@ defmodule Mobilizon.Federation.ActivityPub.Relay do
     get_actor()
   end
 
-  @spec get_actor() :: Actor.t() | {:error, Ecto.Changeset.t()}
+  @spec get_actor() :: Actor.t() | no_return
   def get_actor do
-    with {:ok, %Actor{} = actor} <-
-           Actors.get_or_create_internal_actor("relay") do
-      actor
+    case Actors.get_or_create_internal_actor("relay") do
+      {:ok, %Actor{} = actor} ->
+        actor
+
+      {:error, %Ecto.Changeset{} = _err} ->
+        raise("Relay actor not found")
     end
   end
 
-  @spec follow(String.t()) :: {:ok, Activity.t(), Follower.t()}
+  @spec follow(String.t()) ::
+          {:ok, Activity.t(), Follower.t()} | {:error, atom()} | {:error, String.t()}
   def follow(address) do
+    %Actor{} = local_actor = get_actor()
+
     with {:ok, target_instance} <- fetch_actor(address),
-         %Actor{} = local_actor <- get_actor(),
          {:ok, %Actor{} = target_actor} <-
            ActivityPubActor.get_or_fetch_actor_by_url(target_instance),
          {:ok, activity, follow} <- Follows.follow(local_actor, target_actor) do
       Logger.info("Relay: followed instance #{target_instance}; id=#{activity.data["id"]}")
       {:ok, activity, follow}
     else
-      {:error, e} ->
-        Logger.warn("Error while following remote instance: #{inspect(e)}")
-        {:error, e}
+      {:error, :person_no_follow} ->
+        Logger.warn("Only group and instances can be followed")
+        {:error, :person_no_follow}
 
-      e ->
+      {:error, e} ->
         Logger.warn("Error while following remote instance: #{inspect(e)}")
         {:error, e}
     end
   end
 
-  @spec unfollow(String.t()) :: {:ok, Activity.t(), Follower.t()}
+  @spec unfollow(String.t()) ::
+          {:ok, Activity.t(), Follower.t()} | {:error, atom()} | {:error, String.t()}
   def unfollow(address) do
+    %Actor{} = local_actor = get_actor()
+
     with {:ok, target_instance} <- fetch_actor(address),
-         %Actor{} = local_actor <- get_actor(),
          {:ok, %Actor{} = target_actor} <-
            ActivityPubActor.get_or_fetch_actor_by_url(target_instance),
          {:ok, activity, follow} <- Follows.unfollow(local_actor, target_actor) do
       Logger.info("Relay: unfollowed instance #{target_instance}: id=#{activity.data["id"]}")
       {:ok, activity, follow}
     else
-      e ->
+      {:error, e} ->
         Logger.warn("Error while unfollowing remote instance: #{inspect(e)}")
         {:error, e}
     end
   end
 
-  @spec accept(String.t()) :: {:ok, Activity.t(), Follower.t()}
+  @spec accept(String.t()) ::
+          {:ok, Activity.t(), Follower.t()} | {:error, atom()} | {:error, String.t()}
   def accept(address) do
     Logger.debug("We're trying to accept a relay subscription")
+    %Actor{} = local_actor = get_actor()
 
     with {:ok, target_instance} <- fetch_actor(address),
-         %Actor{} = local_actor <- get_actor(),
          {:ok, %Actor{} = target_actor} <-
            ActivityPubActor.get_or_fetch_actor_by_url(target_instance),
          {:ok, activity, follow} <- Follows.accept(target_actor, local_actor) do
       {:ok, activity, follow}
+    else
+      {:error, e} ->
+        Logger.warn("Error while accepting remote instance follow: #{inspect(e)}")
+        {:error, e}
     end
   end
 
+  @spec reject(String.t()) ::
+          {:ok, Activity.t(), Follower.t()} | {:error, atom()} | {:error, String.t()}
   def reject(address) do
     Logger.debug("We're trying to reject a relay subscription")
+    %Actor{} = local_actor = get_actor()
 
     with {:ok, target_instance} <- fetch_actor(address),
-         %Actor{} = local_actor <- get_actor(),
          {:ok, %Actor{} = target_actor} <-
            ActivityPubActor.get_or_fetch_actor_by_url(target_instance),
          {:ok, activity, follow} <- Follows.reject(target_actor, local_actor) do
       {:ok, activity, follow}
+    else
+      {:error, e} ->
+        Logger.warn("Error while rejecting remote instance follow: #{inspect(e)}")
+        {:error, e}
     end
   end
 
-  @spec refresh(String.t()) :: {:ok, any()}
+  @spec refresh(String.t()) ::
+          {:ok, Oban.Job.t()}
+          | {:error, Ecto.Changeset.t()}
+          | {:error, :bad_url}
+          | {:error, ActivityPubActor.make_actor_errors()}
+          | {:error, :no_internal_relay_actor}
+          | {:error, :url_nil}
   def refresh(address) do
     Logger.debug("We're trying to refresh a remote instance")
 
@@ -106,6 +129,10 @@ defmodule Mobilizon.Federation.ActivityPub.Relay do
       Background.enqueue("refresh_profile", %{
         "actor_id" => target_actor_id
       })
+    else
+      {:error, e} ->
+        Logger.warn("Error while refreshing remote instance: #{inspect(e)}")
+        {:error, e}
     end
   end
 
@@ -117,7 +144,7 @@ defmodule Mobilizon.Federation.ActivityPub.Relay do
          {object, object_id} <- fetch_object(object),
          id <- "#{object_id}/announces/#{actor_id}" do
       Logger.info("Publishing activity #{id} to all relays")
-      ActivityPub.announce(actor, object, id, true, false)
+      Actions.Announce.announce(actor, object, id, true, false)
     else
       e ->
         Logger.error("Error while getting local instance actor: #{inspect(e)}")
@@ -138,7 +165,8 @@ defmodule Mobilizon.Federation.ActivityPub.Relay do
 
   defp fetch_object(object) when is_binary(object), do: {object, object}
 
-  @spec fetch_actor(String.t()) :: {:ok, String.t()} | {:error, String.t()}
+  @spec fetch_actor(String.t()) ::
+          {:ok, String.t()} | {:error, WebFinger.finger_errors() | :bad_url}
   # Dirty hack
   defp fetch_actor("https://" <> address), do: fetch_actor(address)
   defp fetch_actor("http://" <> address), do: fetch_actor(address)
@@ -154,26 +182,15 @@ defmodule Mobilizon.Federation.ActivityPub.Relay do
         check_actor("relay@#{host}")
 
       true ->
-        {:error, "Bad URL"}
+        {:error, :bad_url}
     end
   end
 
-  @spec check_actor(String.t()) :: {:ok, String.t()} | {:error, String.t()}
+  @spec check_actor(String.t()) :: {:ok, String.t()} | {:error, WebFinger.finger_errors()}
   defp check_actor(username_and_domain) do
     case Actors.get_actor_by_name(username_and_domain) do
       %Actor{url: url} -> {:ok, url}
-      nil -> finger_actor(username_and_domain)
-    end
-  end
-
-  @spec finger_actor(String.t()) :: {:ok, String.t()} | {:error, String.t()}
-  defp finger_actor(nickname) do
-    case WebFinger.finger(nickname) do
-      {:ok, url} when is_binary(url) ->
-        {:ok, url}
-
-      _e ->
-        {:error, "No ActivityPub URL found in WebFinger"}
+      nil -> WebFinger.finger(username_and_domain)
     end
   end
 end
diff --git a/lib/federation/activity_pub/transmogrifier.ex b/lib/federation/activity_pub/transmogrifier.ex
index 0ebd70a04..5b957f34a 100644
--- a/lib/federation/activity_pub/transmogrifier.ex
+++ b/lib/federation/activity_pub/transmogrifier.ex
@@ -17,7 +17,7 @@ defmodule Mobilizon.Federation.ActivityPub.Transmogrifier do
   alias Mobilizon.Todos.{Todo, TodoList}
 
   alias Mobilizon.Federation.ActivityPub
-  alias Mobilizon.Federation.ActivityPub.{Activity, Permission, Relay, Utils}
+  alias Mobilizon.Federation.ActivityPub.{Actions, Activity, Permission, Relay, Utils}
   alias Mobilizon.Federation.ActivityPub.Actor, as: ActivityPubActor
   alias Mobilizon.Federation.ActivityPub.Types.Ownable
   alias Mobilizon.Federation.ActivityStream.{Converter, Convertible}
@@ -32,6 +32,7 @@ defmodule Mobilizon.Federation.ActivityPub.Transmogrifier do
   @doc """
   Handle incoming activities
   """
+  @spec handle_incoming(map()) :: :error | {:ok, any(), struct()}
   def handle_incoming(%{"id" => nil}), do: :error
   def handle_incoming(%{"id" => ""}), do: :error
 
@@ -49,7 +50,7 @@ defmodule Mobilizon.Federation.ActivityPub.Transmogrifier do
         local: false
       }
 
-      ActivityPub.flag(params, false)
+      Actions.Flag.flag(params, false)
     end
   end
 
@@ -76,17 +77,17 @@ defmodule Mobilizon.Federation.ActivityPub.Transmogrifier do
          {:ok, %Activity{} = activity, entity} <-
            (if is_data_for_comment_or_discussion?(object_data) do
               Logger.debug("Chosing to create a regular comment")
-              ActivityPub.create(:comment, object_data, false)
+              Actions.Create.create(:comment, object_data, false)
             else
               Logger.debug("Chosing to initialize or add a comment to a conversation")
-              ActivityPub.create(:discussion, object_data, false)
+              Actions.Create.create(:discussion, object_data, false)
             end) do
       {:ok, activity, entity}
     else
       {:existing_comment, {:ok, %Comment{} = comment}} ->
         {:ok, nil, comment}
 
-      {:error, :event_comments_are_closed} ->
+      {:error, :event_not_allow_commenting} ->
         Logger.debug("Tried to reply to an event for which comments are closed")
         :error
     end
@@ -109,7 +110,7 @@ defmodule Mobilizon.Federation.ActivityPub.Transmogrifier do
            object |> Converter.Event.as_to_model_data(),
          {:existing_event, nil} <- {:existing_event, Events.get_event_by_url(object_data.url)},
          {:ok, %Activity{} = activity, %Event{} = event} <-
-           ActivityPub.create(:event, object_data, false) do
+           Actions.Create.create(:event, object_data, false) do
       {:ok, activity, event}
     else
       {:existing_event, %Event{} = event} -> {:ok, nil, event}
@@ -145,7 +146,7 @@ defmodule Mobilizon.Federation.ActivityPub.Transmogrifier do
            %Actor{type: :Group} = group <- Actors.get_actor(object_data.parent_id),
            %Actor{} = actor <- Actors.get_actor(object_data.actor_id),
            {:ok, %Activity{} = activity, %Member{} = member} <-
-             ActivityPub.join(group, actor, false, %{
+             Actions.Join.join(group, actor, false, %{
                url: object_data.url,
                metadata: %{role: object_data.role}
              }) do
@@ -172,7 +173,7 @@ defmodule Mobilizon.Federation.ActivityPub.Transmogrifier do
          {:existing_post, nil} <-
            {:existing_post, Posts.get_post_by_url(object_data.url)},
          {:ok, %Activity{} = activity, %Post{} = post} <-
-           ActivityPub.create(:post, object_data, false) do
+           Actions.Create.create(:post, object_data, false) do
       {:ok, activity, post}
     else
       {:existing_post, %Post{} = post} ->
@@ -197,7 +198,7 @@ defmodule Mobilizon.Federation.ActivityPub.Transmogrifier do
         {:ok, nil, comment}
 
       {:ok, entity} ->
-        ActivityPub.delete(entity, Relay.get_actor(), false)
+        Actions.Delete.delete(entity, Relay.get_actor(), false)
     end
   end
 
@@ -206,10 +207,15 @@ defmodule Mobilizon.Federation.ActivityPub.Transmogrifier do
       ) do
     with {:ok, %Actor{} = followed} <- ActivityPubActor.get_or_fetch_actor_by_url(followed, true),
          {:ok, %Actor{} = follower} <- ActivityPubActor.get_or_fetch_actor_by_url(follower),
-         {:ok, activity, object} <- ActivityPub.follow(follower, followed, id, false) do
+         {:ok, activity, object} <-
+           Actions.Follow.follow(follower, followed, id, false) do
       {:ok, activity, object}
     else
-      e ->
+      {:error, :person_no_follow} ->
+        Logger.warn("Only group and instances can be followed")
+        :error
+
+      {:error, e} ->
         Logger.warn("Unable to handle Follow activity #{inspect(e)}")
         :error
     end
@@ -228,7 +234,9 @@ defmodule Mobilizon.Federation.ActivityPub.Transmogrifier do
          object_data when is_map(object_data) <-
            object |> Converter.TodoList.as_to_model_data(),
          {:ok, %Activity{} = activity, %TodoList{} = todo_list} <-
-           ActivityPub.create(:todo_list, object_data, false, %{"actor" => actor_url}) do
+           Actions.Create.create(:todo_list, object_data, false, %{
+             "actor" => actor_url
+           }) do
       {:ok, activity, todo_list}
     else
       {:error, :group_not_found} -> :error
@@ -247,7 +255,7 @@ defmodule Mobilizon.Federation.ActivityPub.Transmogrifier do
          object_data <-
            object |> Converter.Todo.as_to_model_data(),
          {:ok, %Activity{} = activity, %Todo{} = todo} <-
-           ActivityPub.create(:todo, object_data, false) do
+           Actions.Create.create(:todo, object_data, false) do
       {:ok, activity, todo}
     else
       {:existing_todo, %Todo{} = todo} -> {:ok, nil, todo}
@@ -272,7 +280,7 @@ defmodule Mobilizon.Federation.ActivityPub.Transmogrifier do
          {:member, true} <-
            {:member, Actors.is_member?(object_data.creator_id, object_data.actor_id)},
          {:ok, %Activity{} = activity, %Resource{} = resource} <-
-           ActivityPub.create(:resource, object_data, false) do
+           Actions.Create.create(:resource, object_data, false) do
       {:ok, activity, resource}
     else
       {:existing_resource, %Resource{} = resource} ->
@@ -383,7 +391,7 @@ defmodule Mobilizon.Federation.ActivityPub.Transmogrifier do
          object_data <-
            object |> Converter.Actor.as_to_model_data(),
          {:ok, %Activity{} = activity, %Actor{} = new_actor} <-
-           ActivityPub.update(old_actor, object_data, false) do
+           Actions.Update.update(old_actor, object_data, false) do
       {:ok, activity, new_actor}
     else
       e ->
@@ -411,7 +419,7 @@ defmodule Mobilizon.Federation.ActivityPub.Transmogrifier do
             Utils.origin_check?(actor_url, update_data) ||
               Permission.can_update_group_object?(actor, old_event)},
          {:ok, %Activity{} = activity, %Event{} = new_event} <-
-           ActivityPub.update(old_event, object_data, false) do
+           Actions.Update.update(old_event, object_data, false) do
       {:ok, activity, new_event}
     else
       _e ->
@@ -433,7 +441,7 @@ defmodule Mobilizon.Federation.ActivityPub.Transmogrifier do
          {:ok, old_entity} <- object |> Utils.get_url() |> ActivityPub.fetch_object_from_url(),
          object_data <- transform_object_data_for_discussion(object_data),
          {:ok, %Activity{} = activity, new_entity} <-
-           ActivityPub.update(old_entity, object_data, false) do
+           Actions.Update.update(old_entity, object_data, false) do
       {:ok, activity, new_entity}
     else
       _e ->
@@ -456,7 +464,7 @@ defmodule Mobilizon.Federation.ActivityPub.Transmogrifier do
             Utils.origin_check?(actor_url, update_data["object"]) ||
               Permission.can_update_group_object?(actor, old_post)},
          {:ok, %Activity{} = activity, %Post{} = new_post} <-
-           ActivityPub.update(old_post, object_data, false) do
+           Actions.Update.update(old_post, object_data, false) do
       {:ok, activity, new_post}
     else
       {:origin_check, _} ->
@@ -484,7 +492,7 @@ defmodule Mobilizon.Federation.ActivityPub.Transmogrifier do
             Utils.origin_check?(actor_url, update_data) ||
               Permission.can_update_group_object?(actor, old_resource)},
          {:ok, %Activity{} = activity, %Resource{} = new_resource} <-
-           ActivityPub.update(old_resource, object_data, false) do
+           Actions.Update.update(old_resource, object_data, false) do
       {:ok, activity, new_resource}
     else
       _e ->
@@ -505,7 +513,7 @@ defmodule Mobilizon.Federation.ActivityPub.Transmogrifier do
          object_data <- Converter.Member.as_to_model_data(object),
          {:ok, old_entity} <- object |> Utils.get_url() |> ActivityPub.fetch_object_from_url(),
          {:ok, %Activity{} = activity, new_entity} <-
-           ActivityPub.update(old_entity, object_data, false, %{moderator: actor}) do
+           Actions.Update.update(old_entity, object_data, false, %{moderator: actor}) do
       {:ok, activity, new_entity}
     else
       _e ->
@@ -522,7 +530,7 @@ defmodule Mobilizon.Federation.ActivityPub.Transmogrifier do
 
     with object_url <- Utils.get_url(object),
          {:ok, entity} <- ActivityPub.fetch_object_from_url(object_url) do
-      ActivityPub.delete(entity, Relay.get_actor(), false)
+      Actions.Delete.delete(entity, Relay.get_actor(), false)
     else
       {:ok, %Tombstone{} = tombstone} ->
         {:ok, nil, tombstone}
@@ -545,7 +553,13 @@ defmodule Mobilizon.Federation.ActivityPub.Transmogrifier do
          {:ok, %Actor{} = actor} <- ActivityPubActor.get_or_fetch_actor_by_url(actor),
          {:ok, object} <- fetch_obj_helper_as_activity_streams(object_id),
          {:ok, activity, object} <-
-           ActivityPub.unannounce(actor, object, id, cancelled_activity_id, false) do
+           Actions.Announce.unannounce(
+             actor,
+             object,
+             id,
+             cancelled_activity_id,
+             false
+           ) do
       {:ok, activity, object}
     else
       _e -> :error
@@ -563,7 +577,8 @@ defmodule Mobilizon.Federation.ActivityPub.Transmogrifier do
     with {:ok, %Actor{domain: nil} = followed} <-
            ActivityPubActor.get_or_fetch_actor_by_url(followed),
          {:ok, %Actor{} = follower} <- ActivityPubActor.get_or_fetch_actor_by_url(follower),
-         {:ok, activity, object} <- ActivityPub.unfollow(follower, followed, id, false) do
+         {:ok, activity, object} <-
+           Actions.Follow.unfollow(follower, followed, id, false) do
       {:ok, activity, object}
     else
       e ->
@@ -577,6 +592,8 @@ defmodule Mobilizon.Federation.ActivityPub.Transmogrifier do
   def handle_incoming(
         %{"type" => "Delete", "object" => object, "actor" => _actor, "id" => _id} = data
       ) do
+    Logger.info("Handle incoming to delete an object")
+
     with actor_url <- Utils.get_actor(data),
          {:actor, {:ok, %Actor{} = actor}} <-
            {:actor, ActivityPubActor.get_or_fetch_actor_by_url(actor_url)},
@@ -586,14 +603,14 @@ defmodule Mobilizon.Federation.ActivityPub.Transmogrifier do
            {:origin_check,
             Utils.origin_check_from_id?(actor_url, object_id) ||
               Permission.can_delete_group_object?(actor, object)},
-         {:ok, activity, object} <- ActivityPub.delete(object, actor, false) do
+         {:ok, activity, object} <- Actions.Delete.delete(object, actor, false) do
       {:ok, activity, object}
     else
       {:origin_check, false} ->
         Logger.warn("Object origin check failed")
         :error
 
-      {:actor, {:error, "Could not fetch by AP id"}} ->
+      {:actor, {:error, _err}} ->
         {:error, :unknown_actor}
 
       {:error, e} ->
@@ -630,7 +647,8 @@ defmodule Mobilizon.Federation.ActivityPub.Transmogrifier do
            {:origin_check,
             Utils.origin_check?(actor_url, data) ||
               Permission.can_update_group_object?(actor, old_resource)},
-         {:ok, activity, new_resource} <- ActivityPub.move(:resource, old_resource, object_data) do
+         {:ok, activity, new_resource} <-
+           Actions.Move.move(:resource, old_resource, object_data) do
       {:ok, activity, new_resource}
     else
       e ->
@@ -658,7 +676,7 @@ defmodule Mobilizon.Federation.ActivityPub.Transmogrifier do
          object <- Utils.get_url(object),
          {:ok, object} <- ActivityPub.fetch_object_from_url(object),
          {:ok, activity, object} <-
-           ActivityPub.join(object, actor, false, %{
+           Actions.Join.join(object, actor, false, %{
              url: id,
              metadata: %{message: Map.get(data, "participationMessage")}
            }) do
@@ -675,7 +693,7 @@ defmodule Mobilizon.Federation.ActivityPub.Transmogrifier do
          {:ok, %Actor{} = actor} <- ActivityPubActor.get_or_fetch_actor_by_url(actor),
          object <- Utils.get_url(object),
          {:ok, object} <- ActivityPub.fetch_object_from_url(object),
-         {:ok, activity, object} <- ActivityPub.leave(object, actor, false) do
+         {:ok, activity, object} <- Actions.Leave.leave(object, actor, false) do
       {:ok, activity, object}
     else
       {:only_organizer, true} ->
@@ -707,7 +725,7 @@ defmodule Mobilizon.Federation.ActivityPub.Transmogrifier do
          {:ok, %Actor{} = target} <-
            target |> Utils.get_url() |> ActivityPubActor.get_or_fetch_actor_by_url(),
          {:ok, activity, %Member{} = member} <-
-           ActivityPub.invite(object, actor, target, false, %{url: id}) do
+           Actions.Invite.invite(object, actor, target, false, %{url: id}) do
       {:ok, activity, member}
     end
   end
@@ -727,7 +745,7 @@ defmodule Mobilizon.Federation.ActivityPub.Transmogrifier do
            {:is_admin, Actors.get_member(moderator_id, group_id)},
          {:is_member, {:ok, %Member{role: role} = member}} when role != :rejected <-
            {:is_member, Actors.get_member(person_id, group_id)} do
-      ActivityPub.remove(member, group, moderator, false)
+      Actions.Remove.remove(member, group, moderator, false)
     else
       {:is_admin, {:ok, %Member{}}} ->
         Logger.warn(
@@ -779,7 +797,7 @@ defmodule Mobilizon.Federation.ActivityPub.Transmogrifier do
            {:follow, get_follow(follow_object)},
          {:same_actor, true} <- {:same_actor, actor.id == followed.id},
          {:ok, %Activity{} = activity, %Follower{approved: true} = follow} <-
-           ActivityPub.accept(
+           Actions.Accept.accept(
              :follow,
              follow,
              false
@@ -817,7 +835,7 @@ defmodule Mobilizon.Federation.ActivityPub.Transmogrifier do
            {:follow, get_follow(follow_object)},
          {:same_actor, true} <- {:same_actor, actor.id == followed.id},
          {:ok, activity, _} <-
-           ActivityPub.reject(:follow, follow) do
+           Actions.Reject.reject(:follow, follow) do
       {:ok, activity, follow}
     else
       {:follow, _err} ->
@@ -872,7 +890,7 @@ defmodule Mobilizon.Federation.ActivityPub.Transmogrifier do
          {:can_accept_event_join, true} <-
            {:can_accept_event_join, can_manage_event?(actor_accepting, event)},
          {:ok, %Activity{} = activity, %Participant{role: :participant} = participant} <-
-           ActivityPub.accept(
+           Actions.Accept.accept(
              :join,
              participant,
              false
@@ -904,7 +922,7 @@ defmodule Mobilizon.Federation.ActivityPub.Transmogrifier do
        when role in [:not_approved, :rejected, :invited] and type in [:join, :invite] do
     # Or maybe for groups it's the group that sends the Accept activity
     with {:ok, %Activity{} = activity, %Member{role: :member} = member} <-
-           ActivityPub.accept(
+           Actions.Accept.accept(
              type,
              member,
              false
@@ -922,7 +940,7 @@ defmodule Mobilizon.Federation.ActivityPub.Transmogrifier do
          {:can_accept_event_reject, true} <-
            {:can_accept_event_reject, can_manage_event?(actor_accepting, event)},
          {:ok, activity, participant} <-
-           ActivityPub.reject(:join, participant, false),
+           Actions.Reject.reject(:join, participant, false),
          :ok <- Participation.send_emails_to_local_user(participant) do
       {:ok, activity, participant}
     else
@@ -951,9 +969,9 @@ defmodule Mobilizon.Federation.ActivityPub.Transmogrifier do
   defp do_handle_incoming_reject_invite(invite_object, %Actor{} = actor_rejecting) do
     with {:invite, {:ok, %Member{role: :invited, actor_id: actor_id} = member}} <-
            {:invite, get_member(invite_object)},
-         {:same_actor, true} <- {:same_actor, actor_rejecting.id === actor_id},
+         {:same_actor, true} <- {:same_actor, actor_rejecting.id == actor_id},
          {:ok, activity, member} <-
-           ActivityPub.reject(:invite, member, false) do
+           Actions.Reject.reject(:invite, member, false) do
       {:ok, activity, member}
     end
   end
@@ -992,7 +1010,6 @@ defmodule Mobilizon.Federation.ActivityPub.Transmogrifier do
   end
 
   # Comment initiates a whole discussion only if it has full title
-  @spec is_data_for_comment_or_discussion?(map()) :: boolean()
   defp is_data_a_discussion_initialization?(object_data) do
     not Map.has_key?(object_data, :title) or
       is_nil(object_data.title) or object_data.title == ""
@@ -1106,22 +1123,22 @@ defmodule Mobilizon.Federation.ActivityPub.Transmogrifier do
   end
 
   defp is_group_object_gone(object_id) do
-    case ActivityPub.fetch_object_from_url(object_id, force: true) do
-      {:error, error_message, object} when error_message in ["Gone", "Not found"] ->
-        {:ok, object}
+    Logger.debug("is_group_object_gone #{object_id}")
 
+    case ActivityPub.fetch_object_from_url(object_id, force: true) do
       # comments are just emptied
       {:ok, %Comment{deleted_at: deleted_at} = object} when not is_nil(deleted_at) ->
         {:ok, object}
 
+      {:error, :http_gone, object} ->
+        Logger.debug("object is really gone")
+        {:ok, object}
+
       {:ok, %{url: url} = object} ->
         if Utils.are_same_origin?(url, Endpoint.url()),
           do: {:ok, object},
           else: {:error, "Group object URL remote"}
 
-      {:error, {:error, err}} ->
-        {:error, err}
-
       {:error, err} ->
         {:error, err}
 
@@ -1133,7 +1150,7 @@ defmodule Mobilizon.Federation.ActivityPub.Transmogrifier do
   # Before 1.0.4 the object of a "Remove" activity was an actor's URL
   # instead of the member's URL.
   # TODO: Remove in 1.2
-  @spec get_remove_object(map() | String.t()) :: {:ok, String.t() | integer()}
+  @spec get_remove_object(map() | String.t()) :: {:ok, integer()}
   defp get_remove_object(object) do
     case object |> Utils.get_url() |> ActivityPub.fetch_object_from_url() do
       {:ok, %Member{actor: %Actor{id: person_id}}} -> {:ok, person_id}
@@ -1156,7 +1173,7 @@ defmodule Mobilizon.Federation.ActivityPub.Transmogrifier do
     organizer_actor_id == actor_id
   end
 
-  defp can_manage_event?(_actor, _event) do
+  defp can_manage_event?(%Actor{} = _actor, %Event{} = _event) do
     false
   end
 end
diff --git a/lib/federation/activity_pub/types/actors.ex b/lib/federation/activity_pub/types/actors.ex
index f7d7d4d95..0ea7cb06f 100644
--- a/lib/federation/activity_pub/types/actors.ex
+++ b/lib/federation/activity_pub/types/actors.ex
@@ -1,10 +1,10 @@
 defmodule Mobilizon.Federation.ActivityPub.Types.Actors do
   @moduledoc false
   alias Mobilizon.Actors
-  alias Mobilizon.Actors.{Actor, Follower, Member}
-  alias Mobilizon.Federation.ActivityPub
-  alias Mobilizon.Federation.ActivityPub.{Audience, Permission, Relay}
+  alias Mobilizon.Actors.{Actor, Follower, Member, MemberRole}
+  alias Mobilizon.Federation.ActivityPub.{Actions, Audience, Permission, Relay}
   alias Mobilizon.Federation.ActivityPub.Types.Entity
+  alias Mobilizon.Federation.ActivityStream
   alias Mobilizon.Federation.ActivityStream.Convertible
   alias Mobilizon.GraphQL.API.Utils, as: APIUtils
   alias Mobilizon.Service.Activity.Group, as: GroupActivity
@@ -17,46 +17,57 @@ defmodule Mobilizon.Federation.ActivityPub.Types.Actors do
   @behaviour Entity
 
   @impl Entity
-  @spec create(map(), map()) :: {:ok, map()}
+  @spec create(map(), map()) ::
+          {:ok, Actor.t(), ActivityStream.t()} | {:error, Ecto.Changeset.t()}
   def create(args, additional) do
-    with args <- prepare_args_for_actor(args),
-         {:ok, %Actor{} = actor} <- Actors.create_actor(args),
-         {:ok, _} <-
-           GroupActivity.insert_activity(actor,
-             subject: "group_created",
-             actor_id: args.creator_actor_id
-           ),
-         actor_as_data <- Convertible.model_to_as(actor),
-         audience <- %{"to" => ["https://www.w3.org/ns/activitystreams#Public"], "cc" => []},
-         create_data <-
-           make_create_data(actor_as_data, Map.merge(audience, additional)) do
-      {:ok, actor, create_data}
+    args = prepare_args_for_actor(args)
+
+    case Actors.create_actor(args) do
+      {:ok, %Actor{} = actor} ->
+        GroupActivity.insert_activity(actor,
+          subject: "group_created",
+          actor_id: args.creator_actor_id
+        )
+
+        actor_as_data = Convertible.model_to_as(actor)
+        audience = %{"to" => ["https://www.w3.org/ns/activitystreams#Public"], "cc" => []}
+        create_data = make_create_data(actor_as_data, Map.merge(audience, additional))
+        {:ok, actor, create_data}
+
+      {:error, %Ecto.Changeset{} = err} ->
+        {:error, err}
     end
   end
 
   @impl Entity
-  @spec update(Actor.t(), map, map) :: {:ok, Actor.t(), Activity.t()} | any
+  @spec update(Actor.t(), map, map) ::
+          {:ok, Actor.t(), ActivityStream.t()} | {:error, Ecto.Changeset.t()}
   def update(%Actor{} = old_actor, args, additional) do
-    with {:ok, %Actor{} = new_actor} <- Actors.update_actor(old_actor, args),
-         {:ok, _} <-
-           GroupActivity.insert_activity(new_actor,
-             subject: "group_updated",
-             old_group: old_actor,
-             updater_actor: Map.get(args, :updater_actor)
-           ),
-         actor_as_data <- Convertible.model_to_as(new_actor),
-         {:ok, true} <- Cachex.del(:activity_pub, "actor_#{new_actor.preferred_username}"),
-         audience <-
-           Audience.get_audience(new_actor),
-         additional <- Map.merge(additional, %{"actor" => old_actor.url}),
-         update_data <- make_update_data(actor_as_data, Map.merge(audience, additional)) do
-      {:ok, new_actor, update_data}
+    case Actors.update_actor(old_actor, args) do
+      {:ok, %Actor{} = new_actor} ->
+        GroupActivity.insert_activity(new_actor,
+          subject: "group_updated",
+          old_group: old_actor,
+          updater_actor: Map.get(args, :updater_actor)
+        )
+
+        actor_as_data = Convertible.model_to_as(new_actor)
+        Cachex.del(:activity_pub, "actor_#{new_actor.preferred_username}")
+        audience = Audience.get_audience(new_actor)
+        additional = Map.merge(additional, %{"actor" => old_actor.url})
+        update_data = make_update_data(actor_as_data, Map.merge(audience, additional))
+        {:ok, new_actor, update_data}
+
+      {:error, %Ecto.Changeset{} = err} ->
+        {:error, err}
     end
   end
 
   @public_ap "https://www.w3.org/ns/activitystreams#Public"
 
   @impl Entity
+  @spec delete(Actor.t(), Actor.t(), boolean, map) ::
+          {:ok, ActivityStream.t(), Actor.t(), Actor.t()} | {:error, Ecto.Changeset.t()}
   def delete(
         %Actor{
           followers_url: followers_url,
@@ -89,21 +100,27 @@ defmodule Mobilizon.Federation.ActivityPub.Types.Actors do
 
     suspension = Map.get(additionnal, :suspension, false)
 
-    with {:ok, %Oban.Job{}} <-
-           Actors.delete_actor(target_actor,
-             # We completely delete the actor if the actor is remote
-             reserve_username: is_nil(domain),
-             suspension: suspension,
-             author_id: author_id
-           ) do
-      {:ok, activity_data, actor, target_actor}
+    case Actors.delete_actor(target_actor,
+           # We completely delete the actor if the actor is remote
+           reserve_username: is_nil(domain),
+           suspension: suspension,
+           author_id: author_id
+         ) do
+      {:ok, %Oban.Job{}} ->
+        {:ok, activity_data, actor, target_actor}
+
+      {:error, %Ecto.Changeset{} = err} ->
+        {:error, err}
     end
   end
 
+  @spec actor(Actor.t()) :: Actor.t() | nil
   def actor(%Actor{} = actor), do: actor
 
+  @spec group_actor(Actor.t()) :: Actor.t() | nil
   def group_actor(%Actor{} = actor), do: actor
 
+  @spec permissions(Actor.t()) :: Permission.t()
   def permissions(%Actor{} = _group) do
     %Permission{
       access: :member,
@@ -113,58 +130,74 @@ defmodule Mobilizon.Federation.ActivityPub.Types.Actors do
     }
   end
 
-  @spec join(Actor.t(), Actor.t(), boolean(), map()) :: {:ok, map(), Member.t()}
+  @spec join(Actor.t(), Actor.t(), boolean(), map()) :: {:ok, ActivityStreams.t(), Member.t()}
   def join(%Actor{type: :Group} = group, %Actor{} = actor, _local, additional) do
-    with role <-
-           additional
-           |> Map.get(:metadata, %{})
-           |> Map.get(:role, Mobilizon.Actors.get_default_member_role(group)),
-         {:ok, %Member{} = member} <-
-           Mobilizon.Actors.create_member(%{
-             role: role,
-             parent_id: group.id,
-             actor_id: actor.id,
-             url: Map.get(additional, :url),
-             metadata:
-               additional
-               |> Map.get(:metadata, %{})
-               |> Map.update(:message, nil, &String.trim(HTML.strip_tags(&1)))
-           }),
-         {:ok, _} <-
-           Mobilizon.Service.Activity.Member.insert_activity(member, subject: "member_joined"),
-         Absinthe.Subscription.publish(Endpoint, actor,
-           group_membership_changed: [Actor.preferred_username_and_domain(group), actor.id]
-         ),
-         join_data <- %{
-           "type" => "Join",
-           "id" => member.url,
-           "actor" => actor.url,
-           "object" => group.url
-         },
-         audience <-
-           Audience.get_audience(member) do
-      approve_if_default_role_is_member(
-        group,
-        actor,
-        Map.merge(join_data, audience),
-        member,
-        role
-      )
+    role =
+      additional
+      |> Map.get(:metadata, %{})
+      |> Map.get(:role, Mobilizon.Actors.get_default_member_role(group))
+
+    case Mobilizon.Actors.create_member(%{
+           role: role,
+           parent_id: group.id,
+           actor_id: actor.id,
+           url: Map.get(additional, :url),
+           metadata:
+             additional
+             |> Map.get(:metadata, %{})
+             |> Map.update(:message, nil, &String.trim(HTML.strip_tags(&1)))
+         }) do
+      {:ok, %Member{} = member} ->
+        Mobilizon.Service.Activity.Member.insert_activity(member, subject: "member_joined")
+
+        Absinthe.Subscription.publish(Endpoint, actor,
+          group_membership_changed: [Actor.preferred_username_and_domain(group), actor.id]
+        )
+
+        join_data = %{
+          "type" => "Join",
+          "id" => member.url,
+          "actor" => actor.url,
+          "object" => group.url
+        }
+
+        audience = Audience.get_audience(member)
+
+        approve_if_default_role_is_member(
+          group,
+          actor,
+          Map.merge(join_data, audience),
+          member,
+          role
+        )
+
+      {:error, %Ecto.Changeset{} = err} ->
+        {:error, err}
     end
   end
 
+  @spec follow(Actor.t(), Actor.t(), boolean, map) ::
+          {:accept, any}
+          | {:ok, ActivityStreams.t(), Follower.t()}
+          | {:error,
+             :person_no_follow | :already_following | :followed_suspended | Ecto.Changeset.t()}
   def follow(%Actor{} = follower_actor, %Actor{type: type} = followed, _local, additional)
       when type != :Person do
-    with {:ok, %Follower{} = follower} <-
-           Mobilizon.Actors.follow(followed, follower_actor, additional["activity_id"], false),
-         :ok <- FollowMailer.send_notification_to_admins(follower),
-         follower_as_data <- Convertible.model_to_as(follower) do
-      approve_if_manually_approves_followers(follower, follower_as_data)
+    case Mobilizon.Actors.follow(followed, follower_actor, additional["activity_id"], false) do
+      {:ok, %Follower{} = follower} ->
+        FollowMailer.send_notification_to_admins(follower)
+        follower_as_data = Convertible.model_to_as(follower)
+        approve_if_manually_approves_followers(follower, follower_as_data)
+
+      {:error, error} ->
+        {:error, error}
     end
   end
 
-  def follow(_, _, _, _), do: {:error, :no_person, "Only group and instances can be followed"}
+  # "Only group and instances can be followed"
+  def follow(_, _, _, _), do: {:error, :person_no_follow}
 
+  @spec prepare_args_for_actor(map) :: map
   defp prepare_args_for_actor(args) do
     args
     |> maybe_sanitize_username()
@@ -191,8 +224,14 @@ defmodule Mobilizon.Federation.ActivityPub.Types.Actors do
   defp maybe_sanitize_summary(args), do: args
 
   # Set the participant to approved if the default role for new participants is :participant
-  @spec approve_if_default_role_is_member(Actor.t(), Actor.t(), map(), Member.t(), atom()) ::
-          {:ok, map(), Member.t()}
+  @spec approve_if_default_role_is_member(
+          Actor.t(),
+          Actor.t(),
+          ActivityStreams.t(),
+          Member.t(),
+          MemberRole.t()
+        ) ::
+          {:ok, ActivityStreams.t(), Member.t()}
   defp approve_if_default_role_is_member(
          %Actor{type: :Group} = group,
          %Actor{} = actor,
@@ -202,17 +241,17 @@ defmodule Mobilizon.Federation.ActivityPub.Types.Actors do
        ) do
     if is_nil(group.domain) && !is_nil(actor.domain) do
       cond do
-        Mobilizon.Actors.get_default_member_role(group) === :member &&
+        Mobilizon.Actors.get_default_member_role(group) == :member &&
             role == :member ->
           {:accept,
-           ActivityPub.accept(
+           Actions.Accept.accept(
              :join,
              member,
              true,
              %{"actor" => group.url}
            )}
 
-        Mobilizon.Actors.get_default_member_role(group) === :not_approved &&
+        Mobilizon.Actors.get_default_member_role(group) == :not_approved &&
             role == :not_approved ->
           Scheduler.pending_membership_notification(group)
           {:ok, activity_data, member}
@@ -225,6 +264,11 @@ defmodule Mobilizon.Federation.ActivityPub.Types.Actors do
     end
   end
 
+  @spec approve_if_manually_approves_followers(
+          follower :: Follower.t(),
+          follow_as_data :: ActivityStreams.t()
+        ) ::
+          {:accept, any} | {:ok, ActivityStreams.t(), Follower.t()}
   defp approve_if_manually_approves_followers(
          %Follower{} = follower,
          follow_as_data
@@ -237,7 +281,7 @@ defmodule Mobilizon.Federation.ActivityPub.Types.Actors do
       Logger.debug("Target doesn't manually approves followers, we can accept right away")
 
       {:accept,
-       ActivityPub.accept(
+       Actions.Accept.accept(
          :follow,
          follower,
          true,
diff --git a/lib/federation/activity_pub/types/comments.ex b/lib/federation/activity_pub/types/comments.ex
index 2fedb789f..c8794b9a3 100644
--- a/lib/federation/activity_pub/types/comments.ex
+++ b/lib/federation/activity_pub/types/comments.ex
@@ -6,6 +6,7 @@ defmodule Mobilizon.Federation.ActivityPub.Types.Comments do
   alias Mobilizon.Events.{Event, EventOptions}
   alias Mobilizon.Federation.ActivityPub.{Audience, Permission}
   alias Mobilizon.Federation.ActivityPub.Types.Entity
+  alias Mobilizon.Federation.ActivityStream
   alias Mobilizon.Federation.ActivityStream.Converter.Utils, as: ConverterUtils
   alias Mobilizon.Federation.ActivityStream.Convertible
   alias Mobilizon.GraphQL.API.Utils, as: APIUtils
@@ -20,47 +21,56 @@ defmodule Mobilizon.Federation.ActivityPub.Types.Comments do
   @behaviour Entity
 
   @impl Entity
-  @spec create(map(), map()) :: {:ok, map()}
+  @spec create(map(), map()) ::
+          {:ok, Comment.t(), ActivityStream.t()}
+          | {:error, Ecto.Changeset.t()}
+          | {:error, :event_not_allow_commenting}
   def create(args, additional) do
-    with args <- prepare_args_for_comment(args),
-         :ok <- make_sure_event_allows_commenting(args),
-         {:ok, %Comment{discussion_id: discussion_id} = comment} <-
-           Discussions.create_comment(args),
-         {:ok, _} <-
-           CommentActivity.insert_activity(comment,
-             subject: "comment_posted"
-           ),
-         :ok <- maybe_publish_graphql_subscription(discussion_id),
-         comment_as_data <- Convertible.model_to_as(comment),
-         audience <-
-           Audience.get_audience(comment),
-         create_data <-
-           make_create_data(comment_as_data, Map.merge(audience, additional)) do
-      {:ok, comment, create_data}
-    end
-  end
+    args = prepare_args_for_comment(args)
 
-  @impl Entity
-  @spec update(Comment.t(), map(), map()) :: {:ok, Comment.t(), Activity.t()} | any()
-  def update(%Comment{} = old_comment, args, additional) do
-    with args <- prepare_args_for_comment_update(args),
-         {:ok, %Comment{} = new_comment} <- Discussions.update_comment(old_comment, args),
-         {:ok, true} <- Cachex.del(:activity_pub, "comment_#{new_comment.uuid}"),
-         comment_as_data <- Convertible.model_to_as(new_comment),
-         audience <-
-           Audience.get_audience(new_comment),
-         update_data <- make_update_data(comment_as_data, Map.merge(audience, additional)) do
-      {:ok, new_comment, update_data}
+    if event_allows_commenting?(args) do
+      case Discussions.create_comment(args) do
+        {:ok, %Comment{discussion_id: discussion_id} = comment} ->
+          CommentActivity.insert_activity(comment,
+            subject: "comment_posted"
+          )
+
+          maybe_publish_graphql_subscription(discussion_id)
+          comment_as_data = Convertible.model_to_as(comment)
+          audience = Audience.get_audience(comment)
+          create_data = make_create_data(comment_as_data, Map.merge(audience, additional))
+          {:ok, comment, create_data}
+
+        {:error, %Ecto.Changeset{} = err} ->
+          {:error, err}
+      end
     else
-      err ->
-        Logger.error("Something went wrong while creating an update activity")
-        Logger.debug(inspect(err))
-        err
+      {:error, :event_not_allow_commenting}
     end
   end
 
   @impl Entity
-  @spec delete(Comment.t(), Actor.t(), boolean, map()) :: {:ok, Comment.t()}
+  @spec update(Comment.t(), map(), map()) ::
+          {:ok, Comment.t(), ActivityStream.t()} | {:error, Ecto.Changeset.t()}
+  def update(%Comment{} = old_comment, args, additional) do
+    args = prepare_args_for_comment_update(args)
+
+    case Discussions.update_comment(old_comment, args) do
+      {:ok, %Comment{} = new_comment} ->
+        {:ok, true} = Cachex.del(:activity_pub, "comment_#{new_comment.uuid}")
+        comment_as_data = Convertible.model_to_as(new_comment)
+        audience = Audience.get_audience(new_comment)
+        update_data = make_update_data(comment_as_data, Map.merge(audience, additional))
+        {:ok, new_comment, update_data}
+
+      {:error, %Ecto.Changeset{} = err} ->
+        {:error, err}
+    end
+  end
+
+  @impl Entity
+  @spec delete(Comment.t(), Actor.t(), boolean, map()) ::
+          {:error, Ecto.Changeset.t()} | {:ok, ActivityStream.t(), Actor.t(), Comment.t()}
   def delete(
         %Comment{url: url, id: comment_id},
         %Actor{} = actor,
@@ -79,18 +89,21 @@ defmodule Mobilizon.Federation.ActivityPub.Types.Comments do
 
     force_deletion = Map.get(options, :force, false)
 
-    with audience <-
-           Audience.get_audience(comment),
-         {:ok, %Comment{} = updated_comment} <-
-           Discussions.delete_comment(comment, force: force_deletion),
-         {:ok, true} <- Cachex.del(:activity_pub, "comment_#{comment.uuid}"),
-         {:ok, %Tombstone{} = _tombstone} <-
-           Tombstone.create_tombstone(%{uri: comment.url, actor_id: actor.id}) do
-      Share.delete_all_by_uri(comment.url)
-      {:ok, Map.merge(activity_data, audience), actor, updated_comment}
+    audience = Audience.get_audience(comment)
+
+    case Discussions.delete_comment(comment, force: force_deletion) do
+      {:ok, %Comment{} = updated_comment} ->
+        Cachex.del(:activity_pub, "comment_#{comment.uuid}")
+        Tombstone.create_tombstone(%{uri: comment.url, actor_id: actor.id})
+        Share.delete_all_by_uri(comment.url)
+        {:ok, Map.merge(activity_data, audience), actor, updated_comment}
+
+      {:error, %Ecto.Changeset{} = err} ->
+        {:error, err}
     end
   end
 
+  @spec actor(Comment.t()) :: Actor.t() | nil
   def actor(%Comment{actor: %Actor{} = actor}), do: actor
 
   def actor(%Comment{actor_id: actor_id}) when not is_nil(actor_id),
@@ -98,6 +111,7 @@ defmodule Mobilizon.Federation.ActivityPub.Types.Comments do
 
   def actor(_), do: nil
 
+  @spec group_actor(Comment.t()) :: Actor.t() | nil
   def group_actor(%Comment{attributed_to: %Actor{} = group}), do: group
 
   def group_actor(%Comment{attributed_to_id: attributed_to_id}) when not is_nil(attributed_to_id),
@@ -105,6 +119,7 @@ defmodule Mobilizon.Federation.ActivityPub.Types.Comments do
 
   def group_actor(_), do: nil
 
+  @spec permissions(Comment.t()) :: Permission.t()
   def permissions(%Comment{}),
     do: %Permission{
       access: :member,
@@ -114,6 +129,7 @@ defmodule Mobilizon.Federation.ActivityPub.Types.Comments do
     }
 
   # Prepare and sanitize arguments for comments
+  @spec prepare_args_for_comment(map) :: map
   defp prepare_args_for_comment(args) do
     with in_reply_to_comment <-
            args |> Map.get(:in_reply_to_comment_id) |> Discussions.get_comment_with_preload(),
@@ -150,6 +166,7 @@ defmodule Mobilizon.Federation.ActivityPub.Types.Comments do
     end
   end
 
+  @spec prepare_args_for_comment_update(map) :: map
   defp prepare_args_for_comment_update(args) do
     with {text, mentions, tags} <-
            APIUtils.make_content_html(
@@ -174,32 +191,39 @@ defmodule Mobilizon.Federation.ActivityPub.Types.Comments do
 
   defp handle_event_for_comment(nil), do: nil
 
+  @spec maybe_publish_graphql_subscription(String.t() | integer() | nil) :: :ok
   defp maybe_publish_graphql_subscription(nil), do: :ok
 
   defp maybe_publish_graphql_subscription(discussion_id) do
-    with %Discussion{} = discussion <- Discussions.get_discussion(discussion_id) do
-      Absinthe.Subscription.publish(Endpoint, discussion,
-        discussion_comment_changed: discussion.slug
-      )
+    case Discussions.get_discussion(discussion_id) do
+      %Discussion{} = discussion ->
+        Absinthe.Subscription.publish(Endpoint, discussion,
+          discussion_comment_changed: discussion.slug
+        )
 
-      :ok
+        :ok
+
+      nil ->
+        :ok
     end
   end
 
-  defp make_sure_event_allows_commenting(%{
+  @spec event_allows_commenting?(%{
+          required(:actor_id) => String.t() | integer,
+          required(:event) => Event.t() | nil,
+          optional(atom) => any()
+        }) :: boolean
+  defp event_allows_commenting?(%{
          actor_id: actor_id,
          event: %Event{
            options: %EventOptions{comment_moderation: comment_moderation},
            organizer_actor_id: organizer_actor_id
          }
        }) do
-    if comment_moderation != :closed ||
-         to_string(actor_id) == to_string(organizer_actor_id) do
-      :ok
-    else
-      {:error, :event_comments_are_closed}
-    end
+    comment_moderation != :closed ||
+      to_string(actor_id) == to_string(organizer_actor_id)
   end
 
-  defp make_sure_event_allows_commenting(_), do: :ok
+  # Comments not attached to events
+  defp event_allows_commenting?(_), do: true
 end
diff --git a/lib/federation/activity_pub/types/discussions.ex b/lib/federation/activity_pub/types/discussions.ex
index 1fb013872..ec82e0937 100644
--- a/lib/federation/activity_pub/types/discussions.ex
+++ b/lib/federation/activity_pub/types/discussions.ex
@@ -6,6 +6,7 @@ defmodule Mobilizon.Federation.ActivityPub.Types.Discussions do
   alias Mobilizon.Discussions.{Comment, Discussion}
   alias Mobilizon.Federation.ActivityPub.{Audience, Permission}
   alias Mobilizon.Federation.ActivityPub.Types.Entity
+  alias Mobilizon.Federation.ActivityStream
   alias Mobilizon.Federation.ActivityStream.Convertible
   alias Mobilizon.GraphQL.API.Utils, as: APIUtils
   alias Mobilizon.Service.Activity.Discussion, as: DiscussionActivity
@@ -16,100 +17,120 @@ defmodule Mobilizon.Federation.ActivityPub.Types.Discussions do
   @behaviour Entity
 
   @impl Entity
-  @spec create(map(), map()) :: {:ok, map()}
+  @spec create(map(), map()) ::
+          {:ok, Discussion.t(), ActivityStream.t()}
+          | {:error, :discussion_not_found | :last_comment_not_found | Ecto.Changeset.t()}
   def create(%{discussion_id: discussion_id} = args, additional) when not is_nil(discussion_id) do
-    with args <- prepare_args(args),
-         %Discussion{} = discussion <- Discussions.get_discussion(discussion_id),
-         {:ok, %Discussion{last_comment_id: last_comment_id} = discussion} <-
-           Discussions.reply_to_discussion(discussion, args),
-         {:ok, _} <-
-           DiscussionActivity.insert_activity(discussion,
-             subject: "discussion_replied",
-             actor_id: Map.get(args, :creator_id, args.actor_id)
-           ),
-         %Comment{} = last_comment <- Discussions.get_comment_with_preload(last_comment_id),
-         :ok <- maybe_publish_graphql_subscription(discussion),
-         comment_as_data <- Convertible.model_to_as(last_comment),
-         audience <-
-           Audience.get_audience(discussion),
-         create_data <-
-           make_create_data(comment_as_data, Map.merge(audience, additional)) do
-      {:ok, discussion, create_data}
+    args = prepare_args(args)
+
+    case Discussions.get_discussion(discussion_id) do
+      %Discussion{} = discussion ->
+        case Discussions.reply_to_discussion(discussion, args) do
+          {:ok, %Discussion{last_comment_id: last_comment_id} = discussion} ->
+            DiscussionActivity.insert_activity(discussion,
+              subject: "discussion_replied",
+              actor_id: Map.get(args, :creator_id, args.actor_id)
+            )
+
+            case Discussions.get_comment_with_preload(last_comment_id) do
+              %Comment{} = last_comment ->
+                maybe_publish_graphql_subscription(discussion)
+                comment_as_data = Convertible.model_to_as(last_comment)
+                audience = Audience.get_audience(discussion)
+                create_data = make_create_data(comment_as_data, Map.merge(audience, additional))
+                {:ok, discussion, create_data}
+
+              nil ->
+                {:error, :last_comment_not_found}
+            end
+
+          {:error, _, %Ecto.Changeset{} = err, _} ->
+            {:error, err}
+        end
+
+      nil ->
+        {:error, :discussion_not_found}
     end
   end
 
   @impl Entity
-  @spec create(map(), map()) :: {:ok, map()}
   def create(args, additional) do
-    with args <- prepare_args(args),
-         {:ok, %Discussion{} = discussion} <-
-           Discussions.create_discussion(args),
-         {:ok, _} <-
-           DiscussionActivity.insert_activity(discussion, subject: "discussion_created"),
-         discussion_as_data <- Convertible.model_to_as(discussion),
-         audience <-
-           Audience.get_audience(discussion),
-         create_data <-
-           make_create_data(discussion_as_data, Map.merge(audience, additional)) do
-      {:ok, discussion, create_data}
+    args = prepare_args(args)
+
+    case Discussions.create_discussion(args) do
+      {:ok, %Discussion{} = discussion} ->
+        DiscussionActivity.insert_activity(discussion, subject: "discussion_created")
+        discussion_as_data = Convertible.model_to_as(discussion)
+        audience = Audience.get_audience(discussion)
+        create_data = make_create_data(discussion_as_data, Map.merge(audience, additional))
+        {:ok, discussion, create_data}
+
+      {:error, _, %Ecto.Changeset{} = err, _} ->
+        {:error, err}
     end
   end
 
   @impl Entity
-  @spec update(Discussion.t(), map(), map()) :: {:ok, Discussion.t(), Activity.t()} | any()
+  @spec update(Discussion.t(), map(), map()) ::
+          {:ok, Discussion.t(), ActivityStream.t()} | {:error, Ecto.Changeset.t()}
   def update(%Discussion{} = old_discussion, args, additional) do
-    with {:ok, %Discussion{} = new_discussion} <-
-           Discussions.update_discussion(old_discussion, args),
-         {:ok, _} <-
-           DiscussionActivity.insert_activity(new_discussion,
-             subject: "discussion_renamed",
-             old_discussion: old_discussion
-           ),
-         {:ok, true} <- Cachex.del(:activity_pub, "discussion_#{new_discussion.slug}"),
-         discussion_as_data <- Convertible.model_to_as(new_discussion),
-         audience <-
-           Audience.get_audience(new_discussion),
-         update_data <- make_update_data(discussion_as_data, Map.merge(audience, additional)) do
-      {:ok, new_discussion, update_data}
-    else
-      err ->
-        Logger.error("Something went wrong while creating an update activity")
-        Logger.debug(inspect(err))
-        err
+    case Discussions.update_discussion(old_discussion, args) do
+      {:ok, %Discussion{} = new_discussion} ->
+        DiscussionActivity.insert_activity(new_discussion,
+          subject: "discussion_renamed",
+          old_discussion: old_discussion
+        )
+
+        Cachex.del(:activity_pub, "discussion_#{new_discussion.slug}")
+        discussion_as_data = Convertible.model_to_as(new_discussion)
+        audience = Audience.get_audience(new_discussion)
+        update_data = make_update_data(discussion_as_data, Map.merge(audience, additional))
+        {:ok, new_discussion, update_data}
+
+      {:error, %Ecto.Changeset{} = err} ->
+        {:error, err}
     end
   end
 
   @impl Entity
-  @spec delete(Discussion.t(), Actor.t(), boolean, map()) :: {:ok, Discussion.t()}
+  @spec delete(Discussion.t(), Actor.t(), boolean, map()) ::
+          {:error, Ecto.Changeset.t()} | {:ok, ActivityStream.t(), Actor.t(), Discussion.t()}
   def delete(
         %Discussion{actor: group, url: url} = discussion,
         %Actor{} = actor,
         _local,
         _additionnal
       ) do
-    with {:ok, _} <- Discussions.delete_discussion(discussion),
-         {:ok, _} <-
-           DiscussionActivity.insert_activity(discussion,
-             subject: "discussion_deleted",
-             moderator: actor
-           ) do
-      # This is just fake
-      activity_data = %{
-        "type" => "Delete",
-        "actor" => actor.url,
-        "object" => Convertible.model_to_as(discussion),
-        "id" => url <> "/delete",
-        "to" => [group.members_url]
-      }
+    case Discussions.delete_discussion(discussion) do
+      {:error, _, %Ecto.Changeset{} = err, _} ->
+        {:error, err}
 
-      {:ok, activity_data, actor, discussion}
+      {:ok, %{comments: {_, _}}} ->
+        DiscussionActivity.insert_activity(discussion,
+          subject: "discussion_deleted",
+          moderator: actor
+        )
+
+        # This is just fake
+        activity_data = %{
+          "type" => "Delete",
+          "actor" => actor.url,
+          "object" => Convertible.model_to_as(discussion),
+          "id" => url <> "/delete",
+          "to" => [group.members_url]
+        }
+
+        {:ok, activity_data, actor, discussion}
     end
   end
 
+  @spec actor(Discussion.t()) :: Actor.t() | nil
   def actor(%Discussion{creator_id: creator_id}), do: Actors.get_actor(creator_id)
 
+  @spec group_actor(Discussion.t()) :: Actor.t() | nil
   def group_actor(%Discussion{actor_id: actor_id}), do: Actors.get_actor(actor_id)
 
+  @spec permissions(Discussion.t()) :: Permission.t()
   def permissions(%Discussion{}) do
     %Permission{access: :member, create: :member, update: :moderator, delete: :moderator}
   end
@@ -123,6 +144,7 @@ defmodule Mobilizon.Federation.ActivityPub.Types.Discussions do
     :ok
   end
 
+  @spec prepare_args(map) :: map
   defp prepare_args(args) do
     {text, _mentions, _tags} =
       APIUtils.make_content_html(
diff --git a/lib/federation/activity_pub/types/entity.ex b/lib/federation/activity_pub/types/entity.ex
index 3500294a5..c42b4cae1 100644
--- a/lib/federation/activity_pub/types/entity.ex
+++ b/lib/federation/activity_pub/types/entity.ex
@@ -28,16 +28,16 @@ defmodule Mobilizon.Federation.ActivityPub.Types.Entity do
   @moduledoc """
   ActivityPub entity behaviour
   """
-  @type t :: %{id: String.t()}
+  @type t :: %{required(:id) => any(), optional(:url) => String.t(), optional(atom()) => any()}
 
   @callback create(data :: any(), additionnal :: map()) ::
-              {:ok, t(), ActivityStream.t()}
+              {:ok, t(), ActivityStream.t()} | {:error, any()}
 
-  @callback update(struct :: t(), attrs :: map(), additionnal :: map()) ::
-              {:ok, t(), ActivityStream.t()}
+  @callback update(structure :: t(), attrs :: map(), additionnal :: map()) ::
+              {:ok, t(), ActivityStream.t()} | {:error, any()}
 
-  @callback delete(struct :: t(), Actor.t(), local :: boolean(), map()) ::
-              {:ok, ActivityStream.t(), Actor.t(), t()}
+  @callback delete(structure :: t(), actor :: Actor.t(), local :: boolean(), additionnal :: map()) ::
+              {:ok, ActivityStream.t(), Actor.t(), t()} | {:error, any()}
 end
 
 defprotocol Mobilizon.Federation.ActivityPub.Types.Managable do
@@ -45,46 +45,61 @@ defprotocol Mobilizon.Federation.ActivityPub.Types.Managable do
   ActivityPub entity Managable protocol.
   """
 
-  @spec update(Entity.t(), map(), map()) :: {:ok, Entity.t(), ActivityStream.t()}
   @doc """
   Updates a `Managable` entity with the appropriate attributes and returns the updated entity and an activitystream representation for it
   """
+  @spec update(Entity.t(), map(), map()) ::
+          {:ok, Entity.t(), ActivityStream.t()} | {:error, any()}
   def update(entity, attrs, additionnal)
 
-  @spec delete(Entity.t(), Actor.t(), boolean(), map()) ::
-          {:ok, ActivityStream.t(), Actor.t(), Entity.t()}
   @doc "Deletes an entity and returns the activitystream representation for it"
+  @spec delete(Entity.t(), Actor.t(), boolean(), map()) ::
+          {:ok, ActivityStream.t(), Actor.t(), Entity.t()} | {:error, any()}
   def delete(entity, actor, local, additionnal)
 end
 
 defprotocol Mobilizon.Federation.ActivityPub.Types.Ownable do
-  @type group_role :: :member | :moderator | :administrator | nil
-
-  @spec group_actor(Entity.t()) :: Actor.t() | nil
   @doc "Returns an eventual group for the entity"
+  @spec group_actor(Entity.t()) :: Actor.t() | nil
   def group_actor(entity)
 
-  @spec actor(Entity.t()) :: Actor.t() | nil
   @doc "Returns the actor for the entity"
+  @spec actor(Entity.t()) :: Actor.t() | nil
   def actor(entity)
 
+  @doc """
+  Returns the list of permissions for an entity
+  """
   @spec permissions(Entity.t()) :: Permission.t()
   def permissions(entity)
 end
 
 defimpl Managable, for: Event do
+  @spec update(Event.t(), map, map) ::
+          {:error, atom() | Ecto.Changeset.t()} | {:ok, Event.t(), ActivityStream.t()}
   defdelegate update(entity, attrs, additionnal), to: Events
+
+  @spec delete(entity :: Event.t(), actor :: Actor.t(), local :: boolean(), additionnal :: map()) ::
+          {:ok, ActivityStream.t(), Actor.t(), Event.t()} | {:error, atom() | Ecto.Changeset.t()}
   defdelegate delete(entity, actor, local, additionnal), to: Events
 end
 
 defimpl Ownable, for: Event do
+  @spec group_actor(Event.t()) :: Actor.t() | nil
   defdelegate group_actor(entity), to: Events
+  @spec actor(Event.t()) :: Actor.t() | nil
   defdelegate actor(entity), to: Events
+  @spec permissions(Event.t()) :: Permission.t()
   defdelegate permissions(entity), to: Events
 end
 
 defimpl Managable, for: Comment do
+  @spec update(Comment.t(), map, map) ::
+          {:error, Ecto.Changeset.t()} | {:ok, Comment.t(), ActivityStream.t()}
   defdelegate update(entity, attrs, additionnal), to: Comments
+
+  @spec delete(Comment.t(), Actor.t(), boolean, map) ::
+          {:error, Ecto.Changeset.t()} | {:ok, ActivityStream.t(), Actor.t(), Comment.t()}
   defdelegate delete(entity, actor, local, additionnal), to: Comments
 end
 
diff --git a/lib/federation/activity_pub/types/events.ex b/lib/federation/activity_pub/types/events.ex
index 221c1e888..b2a222298 100644
--- a/lib/federation/activity_pub/types/events.ex
+++ b/lib/federation/activity_pub/types/events.ex
@@ -3,10 +3,10 @@ defmodule Mobilizon.Federation.ActivityPub.Types.Events do
   alias Mobilizon.Actors
   alias Mobilizon.Actors.Actor
   alias Mobilizon.Events, as: EventsManager
-  alias Mobilizon.Events.{Event, Participant}
-  alias Mobilizon.Federation.ActivityPub
-  alias Mobilizon.Federation.ActivityPub.{Audience, Permission}
+  alias Mobilizon.Events.{Event, Participant, ParticipantRole}
+  alias Mobilizon.Federation.ActivityPub.{Actions, Audience, Permission}
   alias Mobilizon.Federation.ActivityPub.Types.Entity
+  alias Mobilizon.Federation.ActivityStream
   alias Mobilizon.Federation.ActivityStream.Converter.Utils, as: ConverterUtils
   alias Mobilizon.Federation.ActivityStream.Convertible
   alias Mobilizon.GraphQL.API.Utils, as: APIUtils
@@ -22,44 +22,53 @@ defmodule Mobilizon.Federation.ActivityPub.Types.Events do
   @behaviour Entity
 
   @impl Entity
-  @spec create(map(), map()) :: {:ok, map()}
+  @spec create(map(), map()) ::
+          {:ok, Event.t(), ActivityStream.t()} | {:error, Ecto.Changeset.t()}
   def create(args, additional) do
-    with args <- prepare_args_for_event(args),
-         {:ok, %Event{} = event} <- EventsManager.create_event(args),
-         {:ok, _} <-
-           EventActivity.insert_activity(event, subject: "event_created"),
-         event_as_data <- Convertible.model_to_as(event),
-         audience <-
-           Audience.get_audience(event),
-         create_data <-
-           make_create_data(event_as_data, Map.merge(audience, additional)) do
-      {:ok, event, create_data}
+    args = prepare_args_for_event(args)
+
+    case EventsManager.create_event(args) do
+      {:ok, %Event{} = event} ->
+        EventActivity.insert_activity(event, subject: "event_created")
+        event_as_data = Convertible.model_to_as(event)
+        audience = Audience.get_audience(event)
+        create_data = make_create_data(event_as_data, Map.merge(audience, additional))
+        {:ok, event, create_data}
+
+      {:error, _step, %Ecto.Changeset{} = err, _} ->
+        {:error, err}
+
+      {:error, %Ecto.Changeset{} = err} ->
+        {:error, err}
     end
   end
 
   @impl Entity
-  @spec update(Event.t(), map(), map()) :: {:ok, Event.t(), Activity.t()} | any()
+  @spec update(Event.t(), map(), map()) ::
+          {:ok, Event.t(), ActivityStream.t()} | {:error, Ecto.Changeset.t()}
   def update(%Event{} = old_event, args, additional) do
-    with args <- prepare_args_for_event(args),
-         {:ok, %Event{} = new_event} <- EventsManager.update_event(old_event, args),
-         {:ok, _} <-
-           EventActivity.insert_activity(new_event, subject: "event_updated"),
-         {:ok, true} <- Cachex.del(:activity_pub, "event_#{new_event.uuid}"),
-         event_as_data <- Convertible.model_to_as(new_event),
-         audience <-
-           Audience.get_audience(new_event),
-         update_data <- make_update_data(event_as_data, Map.merge(audience, additional)) do
-      {:ok, new_event, update_data}
-    else
-      err ->
-        Logger.error("Something went wrong while creating an update activity")
-        Logger.debug(inspect(err))
-        err
+    args = prepare_args_for_event(args)
+
+    case EventsManager.update_event(old_event, args) do
+      {:ok, %Event{} = new_event} ->
+        EventActivity.insert_activity(new_event, subject: "event_updated")
+        Cachex.del(:activity_pub, "event_#{new_event.uuid}")
+        event_as_data = Convertible.model_to_as(new_event)
+        audience = Audience.get_audience(new_event)
+        update_data = make_update_data(event_as_data, Map.merge(audience, additional))
+        {:ok, new_event, update_data}
+
+      {:error, _step, %Ecto.Changeset{} = err, _} ->
+        {:error, err}
+
+      {:error, err} ->
+        {:error, err}
     end
   end
 
   @impl Entity
-  @spec delete(Event.t(), Actor.t(), boolean, map()) :: {:ok, Event.t()}
+  @spec delete(Event.t(), Actor.t(), boolean, map()) ::
+          {:ok, ActivityStream.t(), Actor.t(), Event.t()} | {:error, Ecto.Changeset.t()}
   def delete(%Event{url: url} = event, %Actor{} = actor, _local, _additionnal) do
     activity_data = %{
       "type" => "Delete",
@@ -69,19 +78,27 @@ defmodule Mobilizon.Federation.ActivityPub.Types.Events do
       "id" => url <> "/delete"
     }
 
-    with audience <-
-           Audience.get_audience(event),
-         {:ok, %Event{} = event} <- EventsManager.delete_event(event),
-         {:ok, _} <-
-           EventActivity.insert_activity(event, subject: "event_deleted"),
-         {:ok, true} <- Cachex.del(:activity_pub, "event_#{event.uuid}"),
-         {:ok, %Tombstone{} = _tombstone} <-
-           Tombstone.create_tombstone(%{uri: event.url, actor_id: actor.id}) do
-      Share.delete_all_by_uri(event.url)
-      {:ok, Map.merge(activity_data, audience), actor, event}
+    audience = Audience.get_audience(event)
+
+    case EventsManager.delete_event(event) do
+      {:ok, %Event{} = event} ->
+        case Tombstone.create_tombstone(%{uri: event.url, actor_id: actor.id}) do
+          {:ok, %Tombstone{} = _tombstone} ->
+            EventActivity.insert_activity(event, subject: "event_deleted")
+            Cachex.del(:activity_pub, "event_#{event.uuid}")
+            Share.delete_all_by_uri(event.url)
+            {:ok, Map.merge(activity_data, audience), actor, event}
+
+          {:error, %Ecto.Changeset{} = err} ->
+            {:error, err}
+        end
+
+      {:error, %Ecto.Changeset{} = err} ->
+        {:error, err}
     end
   end
 
+  @spec actor(Event.t()) :: Actor.t() | nil
   def actor(%Event{organizer_actor: %Actor{} = actor}), do: actor
 
   def actor(%Event{organizer_actor_id: organizer_actor_id}),
@@ -89,6 +106,7 @@ defmodule Mobilizon.Federation.ActivityPub.Types.Events do
 
   def actor(_), do: nil
 
+  @spec group_actor(Event.t()) :: Actor.t() | nil
   def group_actor(%Event{attributed_to: %Actor{} = group}), do: group
 
   def group_actor(%Event{attributed_to_id: attributed_to_id}) when not is_nil(attributed_to_id),
@@ -96,6 +114,7 @@ defmodule Mobilizon.Federation.ActivityPub.Types.Events do
 
   def group_actor(_), do: nil
 
+  @spec permissions(Event.t()) :: Permission.t()
   def permissions(%Event{draft: draft, attributed_to_id: _attributed_to_id}) do
     %Permission{
       access: if(draft, do: nil, else: :member),
@@ -105,15 +124,18 @@ defmodule Mobilizon.Federation.ActivityPub.Types.Events do
     }
   end
 
+  @spec join(Event.t(), Actor.t(), boolean, map) ::
+          {:ok, ActivityStreams.t(), Participant.t()}
+          | {:accept, any()}
+          | {:error, :maximum_attendee_capacity_reached}
   def join(%Event{} = event, %Actor{} = actor, _local, additional) do
-    with {:maximum_attendee_capacity, true} <-
-           {:maximum_attendee_capacity, check_attendee_capacity(event)},
-         role <-
-           additional
-           |> Map.get(:metadata, %{})
-           |> Map.get(:role, Mobilizon.Events.get_default_participant_role(event)),
-         {:ok, %Participant{} = participant} <-
-           Mobilizon.Events.create_participant(%{
+    if check_attendee_capacity?(event) do
+      role =
+        additional
+        |> Map.get(:metadata, %{})
+        |> Map.get(:role, Mobilizon.Events.get_default_participant_role(event))
+
+      case Mobilizon.Events.create_participant(%{
              role: role,
              event_id: event.id,
              actor_id: actor.id,
@@ -122,31 +144,41 @@ defmodule Mobilizon.Federation.ActivityPub.Types.Events do
                additional
                |> Map.get(:metadata, %{})
                |> Map.update(:message, nil, &String.trim(HTML.strip_tags(&1)))
-           }),
-         join_data <- Convertible.model_to_as(participant),
-         audience <-
-           Audience.get_audience(participant) do
-      approve_if_default_role_is_participant(
-        event,
-        Map.merge(join_data, audience),
-        participant,
-        role
-      )
+           }) do
+        {:ok, %Participant{} = participant} ->
+          join_data = Convertible.model_to_as(participant)
+          audience = Audience.get_audience(participant)
+
+          approve_if_default_role_is_participant(
+            event,
+            Map.merge(join_data, audience),
+            participant,
+            role
+          )
+
+        {:error, %Ecto.Changeset{} = err} ->
+          {:error, err}
+      end
     else
-      {:maximum_attendee_capacity, err} ->
-        {:maximum_attendee_capacity, err}
+      {:error, :maximum_attendee_capacity_reached}
     end
   end
 
-  defp check_attendee_capacity(%Event{options: options} = event) do
-    with maximum_attendee_capacity <-
-           Map.get(options, :maximum_attendee_capacity) || 0 do
-      maximum_attendee_capacity == 0 ||
-        Mobilizon.Events.count_participant_participants(event.id) < maximum_attendee_capacity
-    end
+  @spec check_attendee_capacity?(Event.t()) :: boolean
+  defp check_attendee_capacity?(%Event{options: options} = event) do
+    maximum_attendee_capacity = Map.get(options, :maximum_attendee_capacity) || 0
+
+    maximum_attendee_capacity == 0 ||
+      Mobilizon.Events.count_participant_participants(event.id) < maximum_attendee_capacity
   end
 
   # Set the participant to approved if the default role for new participants is :participant
+  @spec approve_if_default_role_is_participant(
+          Event.t(),
+          ActivityStreams.t(),
+          Participant.t(),
+          ParticipantRole.t()
+        ) :: {:ok, ActivityStreams.t(), Participant.t()} | {:accept, any()}
   defp approve_if_default_role_is_participant(event, activity_data, participant, role) do
     case event do
       %Event{attributed_to: %Actor{id: group_id, url: group_url}} ->
@@ -161,29 +193,31 @@ defmodule Mobilizon.Federation.ActivityPub.Types.Events do
             {:ok, activity_data, participant}
         end
 
-      %Event{local: true} ->
+      %Event{attributed_to: nil, local: true} ->
         do_approve(event, activity_data, participant, role, %{
           "actor" => event.organizer_actor.url
         })
 
-      _ ->
+      %Event{} ->
         {:ok, activity_data, participant}
     end
   end
 
+  @spec do_approve(Event.t(), ActivityStreams.t(), Particpant.t(), ParticipantRole.t(), map()) ::
+          {:accept, any} | {:ok, ActivityStreams.t(), Participant.t()}
   defp do_approve(event, activity_data, participant, role, additionnal) do
     cond do
-      Mobilizon.Events.get_default_participant_role(event) === :participant &&
+      Mobilizon.Events.get_default_participant_role(event) == :participant &&
           role == :participant ->
         {:accept,
-         ActivityPub.accept(
+         Actions.Accept.accept(
            :join,
            participant,
            true,
            additionnal
          )}
 
-      Mobilizon.Events.get_default_participant_role(event) === :not_approved &&
+      Mobilizon.Events.get_default_participant_role(event) == :not_approved &&
           role == :not_approved ->
         Scheduler.pending_participation_notification(event)
         {:ok, activity_data, participant}
@@ -194,6 +228,7 @@ defmodule Mobilizon.Federation.ActivityPub.Types.Events do
   end
 
   # Prepare and sanitize arguments for events
+  @spec prepare_args_for_event(map) :: map
   defp prepare_args_for_event(args) do
     # If title is not set: we are not updating it
     args =
diff --git a/lib/federation/activity_pub/types/members.ex b/lib/federation/activity_pub/types/members.ex
index 8c55fa72a..8195fe847 100644
--- a/lib/federation/activity_pub/types/members.ex
+++ b/lib/federation/activity_pub/types/members.ex
@@ -1,14 +1,18 @@
 defmodule Mobilizon.Federation.ActivityPub.Types.Members do
   @moduledoc false
   alias Mobilizon.Actors
-  alias Mobilizon.Actors.{Actor, Member}
-  alias Mobilizon.Federation.ActivityPub
+  alias Mobilizon.Actors.{Actor, Member, MemberRole}
+  alias Mobilizon.Federation.ActivityPub.Actions
+  alias Mobilizon.Federation.ActivityStream
   alias Mobilizon.Federation.ActivityStream.Convertible
   alias Mobilizon.Service.Activity.Member, as: MemberActivity
   alias Mobilizon.Web.Endpoint
   require Logger
   import Mobilizon.Federation.ActivityPub.Utils, only: [make_update_data: 2]
 
+  @spec update(Member.t(), map, map) ::
+          {:ok, Member.t(), ActivityStream.t()}
+          | {:error, :member_not_found | :only_admin_left | Ecto.Changeset.t()}
   def update(
         %Member{
           parent: %Actor{id: group_id} = group,
@@ -19,43 +23,51 @@ defmodule Mobilizon.Federation.ActivityPub.Types.Members do
         %{role: updated_role} = args,
         %{moderator: %Actor{url: moderator_url, id: moderator_id} = moderator} = additional
       ) do
-    with additional <- Map.delete(additional, :moderator),
-         {:has_rights_to_update_role, {:ok, %Member{role: moderator_role}}}
-         when moderator_role in [:moderator, :administrator, :creator] <-
-           {:has_rights_to_update_role, Actors.get_member(moderator_id, group_id)},
-         {:is_only_admin, false} <-
-           {:is_only_admin, check_admins_left(member_id, group_id, current_role, updated_role)},
-         {:ok, %Member{} = member} <-
-           Actors.update_member(old_member, args),
-         {:ok, _} <-
-           MemberActivity.insert_activity(member,
-             old_member: old_member,
-             moderator: moderator,
-             subject: "member_updated"
-           ),
-         Absinthe.Subscription.publish(Endpoint, actor,
-           group_membership_changed: [Actor.preferred_username_and_domain(group), actor_id]
-         ),
-         {:ok, true} <- Cachex.del(:activity_pub, "member_#{member_id}"),
-         member_as_data <-
-           Convertible.model_to_as(member),
-         audience <- %{
-           "to" => [member.parent.members_url, member.actor.url],
-           "cc" => [member.parent.url],
-           "actor" => moderator_url,
-           "attributedTo" => [member.parent.url]
-         } do
-      update_data = make_update_data(member_as_data, Map.merge(audience, additional))
+    additional = Map.delete(additional, :moderator)
 
-      {:ok, member, update_data}
-    else
-      err ->
-        Logger.debug(inspect(err))
-        err
+    case Actors.get_member(moderator_id, group_id) do
+      {:error, :member_not_found} ->
+        {:error, :member_not_found}
+
+      {:ok, %Member{role: moderator_role}}
+      when moderator_role in [:moderator, :administrator, :creator] ->
+        if check_admins_left?(member_id, group_id, current_role, updated_role) do
+          {:error, :only_admin_left}
+        else
+          case Actors.update_member(old_member, args) do
+            {:error, %Ecto.Changeset{} = err} ->
+              {:error, err}
+
+            {:ok, %Member{} = member} ->
+              MemberActivity.insert_activity(member,
+                old_member: old_member,
+                moderator: moderator,
+                subject: "member_updated"
+              )
+
+              Absinthe.Subscription.publish(Endpoint, actor,
+                group_membership_changed: [Actor.preferred_username_and_domain(group), actor_id]
+              )
+
+              Cachex.del(:activity_pub, "member_#{member_id}")
+              member_as_data = Convertible.model_to_as(member)
+
+              audience = %{
+                "to" => [member.parent.members_url, member.actor.url],
+                "cc" => [member.parent.url],
+                "actor" => moderator_url,
+                "attributedTo" => [member.parent.url]
+              }
+
+              update_data = make_update_data(member_as_data, Map.merge(audience, additional))
+              {:ok, member, update_data}
+          end
+        end
     end
   end
 
   # Used only when a group is suspended
+  @spec delete(Member.t(), Actor.t(), boolean(), map()) :: {:ok, Activity.t(), Member.t()}
   def delete(
         %Member{parent: %Actor{} = group, actor: %Actor{} = actor} = _member,
         %Actor{},
@@ -63,16 +75,24 @@ defmodule Mobilizon.Federation.ActivityPub.Types.Members do
         _additionnal
       ) do
     Logger.debug("Deleting a member")
-    ActivityPub.leave(group, actor, local, %{force_member_removal: true})
+    Actions.Leave.leave(group, actor, local, %{force_member_removal: true})
   end
 
+  @spec actor(Member.t()) :: Actor.t() | nil
   def actor(%Member{actor_id: actor_id}),
     do: Actors.get_actor(actor_id)
 
+  @spec group_actor(Member.t()) :: Actor.t() | nil
   def group_actor(%Member{parent_id: parent_id}),
     do: Actors.get_actor(parent_id)
 
-  defp check_admins_left(member_id, group_id, current_role, updated_role) do
+  @spec check_admins_left?(
+          String.t() | integer,
+          String.t() | integer,
+          MemberRole.t(),
+          MemberRole.t()
+        ) :: boolean
+  defp check_admins_left?(member_id, group_id, current_role, updated_role) do
     Actors.is_only_administrator?(member_id, group_id) && current_role == :administrator &&
       updated_role != :administrator
   end
diff --git a/lib/federation/activity_pub/types/posts.ex b/lib/federation/activity_pub/types/posts.ex
index 279a8ba5e..1bca51fee 100644
--- a/lib/federation/activity_pub/types/posts.ex
+++ b/lib/federation/activity_pub/types/posts.ex
@@ -4,6 +4,7 @@ defmodule Mobilizon.Federation.ActivityPub.Types.Posts do
   alias Mobilizon.Actors.Actor
   alias Mobilizon.Federation.ActivityPub.{Audience, Permission}
   alias Mobilizon.Federation.ActivityPub.Types.Entity
+  alias Mobilizon.Federation.ActivityStream
   alias Mobilizon.Federation.ActivityStream.Converter.Utils, as: ConverterUtils
   alias Mobilizon.Federation.ActivityStream.Convertible
   alias Mobilizon.Posts.Post
@@ -17,6 +18,7 @@ defmodule Mobilizon.Federation.ActivityPub.Types.Posts do
   @public_ap "https://www.w3.org/ns/activitystreams#Public"
 
   @impl Entity
+  @spec create(map(), map()) :: {:ok, Post.t(), ActivityStream.t()}
   def create(args, additional) do
     with args <- prepare_args(args),
          {:ok, %Post{attributed_to_id: group_id, author_id: creator_id} = post} <-
@@ -37,6 +39,7 @@ defmodule Mobilizon.Federation.ActivityPub.Types.Posts do
   end
 
   @impl Entity
+  @spec update(Post.t(), map(), map()) :: {:ok, Post.t(), ActivityStream.t()}
   def update(%Post{} = post, args, additional) do
     with args <- prepare_args(args),
          {:ok, %Post{attributed_to_id: group_id, author_id: creator_id} = post} <-
@@ -60,6 +63,8 @@ defmodule Mobilizon.Federation.ActivityPub.Types.Posts do
   end
 
   @impl Entity
+  @spec delete(Post.t(), Actor.t(), boolean, map) ::
+          {:ok, ActivityStream.t(), Actor.t(), Post.t()}
   def delete(
         %Post{
           url: url,
@@ -86,12 +91,15 @@ defmodule Mobilizon.Federation.ActivityPub.Types.Posts do
     end
   end
 
+  @spec actor(Post.t()) :: Actor.t() | nil
   def actor(%Post{author_id: author_id}),
     do: Actors.get_actor(author_id)
 
+  @spec group_actor(Post.t()) :: Actor.t() | nil
   def group_actor(%Post{attributed_to_id: attributed_to_id}),
     do: Actors.get_actor(attributed_to_id)
 
+  @spec permissions(Post.t()) :: Permission.t()
   def permissions(%Post{}) do
     %Permission{
       access: :member,
@@ -101,6 +109,7 @@ defmodule Mobilizon.Federation.ActivityPub.Types.Posts do
     }
   end
 
+  @spec prepare_args(map()) :: map
   defp prepare_args(args) do
     args
     |> Map.update(:tags, [], &ConverterUtils.fetch_tags/1)
diff --git a/lib/federation/activity_pub/types/reports.ex b/lib/federation/activity_pub/types/reports.ex
index ded8a1882..ddcfd34ac 100644
--- a/lib/federation/activity_pub/types/reports.ex
+++ b/lib/federation/activity_pub/types/reports.ex
@@ -1,43 +1,53 @@
 defmodule Mobilizon.Federation.ActivityPub.Types.Reports do
   @moduledoc false
-  alias Mobilizon.{Actors, Discussions, Reports}
+  alias Mobilizon.{Actors, Discussions, Events, Reports}
   alias Mobilizon.Actors.Actor
+  alias Mobilizon.Events.Event
+  alias Mobilizon.Federation.ActivityStream
   alias Mobilizon.Federation.ActivityStream.Convertible
   alias Mobilizon.Reports.Report
   alias Mobilizon.Service.Formatter.HTML
   require Logger
 
+  @spec flag(map(), boolean(), map()) ::
+          {:ok, Report.t(), ActivityStream.t()} | {:error, Ecto.Changeset.t()}
   def flag(args, local \\ false, _additional \\ %{}) do
-    with {:build_args, args} <- {:build_args, prepare_args_for_report(args)},
-         {:create_report, {:ok, %Report{} = report}} <-
-           {:create_report, Reports.create_report(args)},
-         report_as_data <- Convertible.model_to_as(report),
-         cc <- if(local, do: [report.reported.url], else: []),
-         report_as_data <- Map.merge(report_as_data, %{"to" => [], "cc" => cc}) do
-      {report, report_as_data}
+    with {:ok, %Report{} = report} <- args |> prepare_args_for_report() |> Reports.create_report() do
+      report_as_data = Convertible.model_to_as(report)
+      cc = if(local, do: [report.reported.url], else: [])
+      report_as_data = Map.merge(report_as_data, %{"to" => [], "cc" => cc})
+      {:ok, report, report_as_data}
     end
   end
 
+  @spec prepare_args_for_report(map()) :: map()
   defp prepare_args_for_report(args) do
-    with {:reporter, %Actor{} = reporter_actor} <-
-           {:reporter, Actors.get_actor!(args.reporter_id)},
-         {:reported, %Actor{} = reported_actor} <-
-           {:reported, Actors.get_actor!(args.reported_id)},
-         content <- HTML.strip_tags(args.content),
-         event <- Discussions.get_comment(Map.get(args, :event_id)),
-         {:get_report_comments, comments} <-
-           {:get_report_comments,
-            Discussions.list_comments_by_actor_and_ids(
-              reported_actor.id,
-              Map.get(args, :comments_ids, [])
-            )} do
-      Map.merge(args, %{
-        reporter: reporter_actor,
-        reported: reported_actor,
-        content: content,
-        event: event,
-        comments: comments
-      })
-    end
+    %Actor{} = reporter_actor = Actors.get_actor!(args.reporter_id)
+    %Actor{} = reported_actor = Actors.get_actor!(args.reported_id)
+    content = HTML.strip_tags(args.content)
+
+    event_id = Map.get(args, :event_id)
+
+    event =
+      if is_nil(event_id) do
+        nil
+      else
+        {:ok, %Event{} = event} = Events.get_event(event_id)
+        event
+      end
+
+    comments =
+      Discussions.list_comments_by_actor_and_ids(
+        reported_actor.id,
+        Map.get(args, :comments_ids, [])
+      )
+
+    Map.merge(args, %{
+      reporter: reporter_actor,
+      reported: reported_actor,
+      content: content,
+      event: event,
+      comments: comments
+    })
   end
 end
diff --git a/lib/federation/activity_pub/types/resources.ex b/lib/federation/activity_pub/types/resources.ex
index 38f3b409e..9d5438b78 100644
--- a/lib/federation/activity_pub/types/resources.ex
+++ b/lib/federation/activity_pub/types/resources.ex
@@ -4,6 +4,7 @@ defmodule Mobilizon.Federation.ActivityPub.Types.Resources do
   alias Mobilizon.Actors.Actor
   alias Mobilizon.Federation.ActivityPub.Permission
   alias Mobilizon.Federation.ActivityPub.Types.Entity
+  alias alias Mobilizon.Federation.ActivityStream
   alias Mobilizon.Federation.ActivityStream.Convertible
   alias Mobilizon.Resources.Resource
   alias Mobilizon.Service.Activity.Resource, as: ResourceActivity
@@ -16,6 +17,9 @@ defmodule Mobilizon.Federation.ActivityPub.Types.Resources do
   @behaviour Entity
 
   @impl Entity
+  @spec create(map(), map()) ::
+          {:ok, Resource.t(), ActivityStream.t()}
+          | {:error, Ecto.Changeset.t() | :creator_not_found | :group_not_found}
   def create(%{type: type} = args, additional) do
     args =
       case type do
@@ -35,17 +39,18 @@ defmodule Mobilizon.Federation.ActivityPub.Types.Resources do
     with {:ok,
           %Resource{actor_id: group_id, creator_id: creator_id, parent_id: parent_id} = resource} <-
            Resources.create_resource(args),
-         {:ok, _} <- ResourceActivity.insert_activity(resource, subject: "resource_created"),
-         {:ok, %Actor{} = group} <- Actors.get_group_by_actor_id(group_id),
-         %Actor{url: creator_url} = creator <- Actors.get_actor(creator_id),
-         resource_as_data <-
-           Convertible.model_to_as(%{resource | actor: group, creator: creator}),
-         audience <- %{
-           "to" => [group.members_url],
-           "cc" => [],
-           "actor" => creator_url,
-           "attributedTo" => [creator_url]
-         } do
+         {:ok, %Actor{} = group, %Actor{url: creator_url} = creator} <-
+           group_and_creator(group_id, creator_id) do
+      ResourceActivity.insert_activity(resource, subject: "resource_created")
+      resource_as_data = Convertible.model_to_as(%{resource | actor: group, creator: creator})
+
+      audience = %{
+        "to" => [group.members_url],
+        "cc" => [],
+        "actor" => creator_url,
+        "attributedTo" => [creator_url]
+      }
+
       create_data =
         case parent_id do
           nil ->
@@ -58,14 +63,13 @@ defmodule Mobilizon.Federation.ActivityPub.Types.Resources do
         end
 
       {:ok, resource, create_data}
-    else
-      err ->
-        Logger.debug(inspect(err))
-        err
     end
   end
 
   @impl Entity
+  @spec update(Resource.t(), map(), map()) ::
+          {:ok, Resource.t(), ActivityStream.t()}
+          | {:error, Ecto.Changeset.t() | :creator_not_found | :group_not_found}
   def update(
         %Resource{parent_id: old_parent_id} = old_resource,
         %{parent_id: parent_id} = args,
@@ -79,31 +83,35 @@ defmodule Mobilizon.Federation.ActivityPub.Types.Resources do
   def update(%Resource{} = old_resource, %{title: title} = _args, additional) do
     with {:ok, %Resource{actor_id: group_id, creator_id: creator_id} = resource} <-
            Resources.update_resource(old_resource, %{title: title}),
-         {:ok, _} <-
-           ResourceActivity.insert_activity(resource,
-             subject: "resource_renamed",
-             old_resource: old_resource
-           ),
-         {:ok, %Actor{} = group} <- Actors.get_group_by_actor_id(group_id),
-         %Actor{url: creator_url} <- Actors.get_actor(creator_id),
-         resource_as_data <-
-           Convertible.model_to_as(%{resource | actor: group}),
-         audience <- %{
-           "to" => [group.members_url],
-           "cc" => [],
-           "actor" => creator_url,
-           "attributedTo" => [creator_url]
-         },
-         update_data <-
-           make_update_data(resource_as_data, Map.merge(audience, additional)) do
+         {:ok, %Actor{} = group, %Actor{url: creator_url}} <-
+           group_and_creator(group_id, creator_id) do
+      ResourceActivity.insert_activity(resource,
+        subject: "resource_renamed",
+        old_resource: old_resource
+      )
+
+      resource_as_data = Convertible.model_to_as(%{resource | actor: group})
+
+      audience = %{
+        "to" => [group.members_url],
+        "cc" => [],
+        "actor" => creator_url,
+        "attributedTo" => [creator_url]
+      }
+
+      update_data = make_update_data(resource_as_data, Map.merge(audience, additional))
       {:ok, resource, update_data}
-    else
-      err ->
-        Logger.debug(inspect(err))
-        err
     end
   end
 
+  @spec move(Resource.t(), map(), map()) ::
+          {:ok, Resource.t(), ActivityStream.t()}
+          | {:error,
+             Ecto.Changeset.t()
+             | :creator_not_found
+             | :group_not_found
+             | :new_parent_not_found
+             | :old_parent_not_found}
   def move(
         %Resource{parent_id: old_parent_id} = old_resource,
         %{parent_id: _new_parent_id} = args,
@@ -113,35 +121,34 @@ defmodule Mobilizon.Federation.ActivityPub.Types.Resources do
           %Resource{actor_id: group_id, creator_id: creator_id, parent_id: new_parent_id} =
             resource} <-
            Resources.update_resource(old_resource, args),
-         {:ok, _} <- ResourceActivity.insert_activity(resource, subject: "resource_moved"),
-         old_parent <- Resources.get_resource(old_parent_id),
-         new_parent <- Resources.get_resource(new_parent_id),
-         {:ok, %Actor{} = group} <- Actors.get_group_by_actor_id(group_id),
-         %Actor{url: creator_url} <- Actors.get_actor(creator_id),
-         resource_as_data <-
-           Convertible.model_to_as(%{resource | actor: group}),
-         audience <- %{
-           "to" => [group.members_url],
-           "cc" => [],
-           "actor" => creator_url,
-           "attributedTo" => [creator_url]
-         },
-         move_data <-
-           make_move_data(
-             resource_as_data,
-             old_parent,
-             new_parent,
-             Map.merge(audience, additional)
-           ) do
+         {:ok, old_parent, new_parent} <- parents(old_parent_id, new_parent_id),
+         {:ok, %Actor{} = group, %Actor{url: creator_url}} <-
+           group_and_creator(group_id, creator_id) do
+      ResourceActivity.insert_activity(resource, subject: "resource_moved")
+      resource_as_data = Convertible.model_to_as(%{resource | actor: group})
+
+      audience = %{
+        "to" => [group.members_url],
+        "cc" => [],
+        "actor" => creator_url,
+        "attributedTo" => [creator_url]
+      }
+
+      move_data =
+        make_move_data(
+          resource_as_data,
+          old_parent,
+          new_parent,
+          Map.merge(audience, additional)
+        )
+
       {:ok, resource, move_data}
-    else
-      err ->
-        Logger.debug(inspect(err))
-        err
     end
   end
 
   @impl Entity
+  @spec delete(Resource.t(), Actor.t(), boolean, map()) ::
+          {:ok, ActivityStream.t(), Actor.t(), Resource.t()} | {:error, Ecto.Changeset.t()}
   def delete(
         %Resource{url: url, actor: %Actor{url: group_url, members_url: members_url}} = resource,
         %Actor{url: actor_url} = actor,
@@ -159,19 +166,50 @@ defmodule Mobilizon.Federation.ActivityPub.Types.Resources do
       "to" => [members_url]
     }
 
-    with {:ok, _resource} <- Resources.delete_resource(resource),
-         {:ok, _} <- ResourceActivity.insert_activity(resource, subject: "resource_deleted"),
-         {:ok, true} <- Cachex.del(:activity_pub, "resource_#{resource.id}") do
-      {:ok, activity_data, actor, resource}
+    case Resources.delete_resource(resource) do
+      {:ok, _resource} ->
+        ResourceActivity.insert_activity(resource, subject: "resource_deleted")
+        Cachex.del(:activity_pub, "resource_#{resource.id}")
+        {:ok, activity_data, actor, resource}
+
+      {:error, %Ecto.Changeset{} = err} ->
+        {:error, err}
     end
   end
 
+  @spec actor(Todo.t()) :: Actor.t() | nil
   def actor(%Resource{creator_id: creator_id}),
     do: Actors.get_actor(creator_id)
 
+  @spec group_actor(Todo.t()) :: Actor.t() | nil
   def group_actor(%Resource{actor_id: actor_id}), do: Actors.get_actor(actor_id)
 
+  @spec permissions(TodoList.t()) :: Permission.t()
   def permissions(%Resource{}) do
     %Permission{access: :member, create: :member, update: :member, delete: :member}
   end
+
+  @spec group_and_creator(integer(), integer()) ::
+          {:ok, Actor.t(), Actor.t()} | {:error, :creator_not_found | :group_not_found}
+  defp group_and_creator(group_id, creator_id) do
+    case Actors.get_group_by_actor_id(group_id) do
+      {:ok, %Actor{} = group} ->
+        case Actors.get_actor(creator_id) do
+          %Actor{} = creator ->
+            {:ok, group, creator}
+
+          nil ->
+            {:error, :creator_not_found}
+        end
+
+      {:error, :group_not_found} ->
+        {:error, :group_not_found}
+    end
+  end
+
+  @spec parents(String.t(), String.t()) ::
+          {:ok, Resource.t(), Resource.t()}
+  defp parents(old_parent_id, new_parent_id) do
+    {:ok, Resources.get_resource(old_parent_id), Resources.get_resource(new_parent_id)}
+  end
 end
diff --git a/lib/federation/activity_pub/types/todo_lists.ex b/lib/federation/activity_pub/types/todo_lists.ex
index fcabf1020..fc2fa1bdc 100644
--- a/lib/federation/activity_pub/types/todo_lists.ex
+++ b/lib/federation/activity_pub/types/todo_lists.ex
@@ -13,36 +13,37 @@ defmodule Mobilizon.Federation.ActivityPub.Types.TodoLists do
   @behaviour Entity
 
   @impl Entity
-  @spec create(map(), map()) :: {:ok, map()}
+  @spec create(map(), map()) ::
+          {:ok, TodoList.t(), ActivityStream.t()}
+          | {:error, :group_not_found | Ecto.Changeset.t()}
   def create(args, additional) do
     with {:ok, %TodoList{actor_id: group_id} = todo_list} <- Todos.create_todo_list(args),
-         {:ok, %Actor{} = group} <- Actors.get_group_by_actor_id(group_id),
-         todo_list_as_data <- Convertible.model_to_as(%{todo_list | actor: group}),
-         audience <- %{"to" => [group.members_url], "cc" => []},
-         create_data <-
-           make_create_data(todo_list_as_data, Map.merge(audience, additional)) do
+         {:ok, %Actor{} = group} <- Actors.get_group_by_actor_id(group_id) do
+      todo_list_as_data = Convertible.model_to_as(%{todo_list | actor: group})
+      audience = %{"to" => [group.members_url], "cc" => []}
+      create_data = make_create_data(todo_list_as_data, Map.merge(audience, additional))
       {:ok, todo_list, create_data}
     end
   end
 
   @impl Entity
-  @spec update(TodoList.t(), map, map) :: {:ok, TodoList.t(), Activity.t()} | any
+  @spec update(TodoList.t(), map, map) ::
+          {:ok, TodoList.t(), ActivityStream.t()}
+          | {:error, Ecto.Changeset.t() | :group_not_found}
   def update(%TodoList{} = old_todo_list, args, additional) do
     with {:ok, %TodoList{actor_id: group_id} = todo_list} <-
            Todos.update_todo_list(old_todo_list, args),
-         {:ok, %Actor{} = group} <- Actors.get_group_by_actor_id(group_id),
-         todo_list_as_data <-
-           Convertible.model_to_as(%{todo_list | actor: group}),
-         audience <- %{"to" => [group.members_url], "cc" => []},
-         update_data <-
-           make_update_data(todo_list_as_data, Map.merge(audience, additional)) do
+         {:ok, %Actor{} = group} <- Actors.get_group_by_actor_id(group_id) do
+      todo_list_as_data = Convertible.model_to_as(%{todo_list | actor: group})
+      audience = %{"to" => [group.members_url], "cc" => []}
+      update_data = make_update_data(todo_list_as_data, Map.merge(audience, additional))
       {:ok, todo_list, update_data}
     end
   end
 
   @impl Entity
   @spec delete(TodoList.t(), Actor.t(), boolean(), map()) ::
-          {:ok, ActivityStream.t(), Actor.t(), TodoList.t()}
+          {:ok, ActivityStream.t(), Actor.t(), TodoList.t()} | {:error, Ecto.Changeset.t()}
   def delete(
         %TodoList{url: url, actor: %Actor{url: group_url}} = todo_list,
         %Actor{url: actor_url} = actor,
@@ -59,16 +60,23 @@ defmodule Mobilizon.Federation.ActivityPub.Types.TodoLists do
       "to" => [group_url]
     }
 
-    with {:ok, _todo_list} <- Todos.delete_todo_list(todo_list),
-         {:ok, true} <- Cachex.del(:activity_pub, "todo_list_#{todo_list.id}") do
-      {:ok, activity_data, actor, todo_list}
+    case Todos.delete_todo_list(todo_list) do
+      {:ok, _todo_list} ->
+        Cachex.del(:activity_pub, "todo_list_#{todo_list.id}")
+        {:ok, activity_data, actor, todo_list}
+
+      {:error, %Ecto.Changeset{} = err} ->
+        {:error, err}
     end
   end
 
+  @spec actor(TodoList.t()) :: nil
   def actor(%TodoList{}), do: nil
 
+  @spec group_actor(TodoList.t()) :: Actor.t() | nil
   def group_actor(%TodoList{actor_id: actor_id}), do: Actors.get_actor(actor_id)
 
+  @spec permissions(TodoList.t()) :: Permission.t()
   def permissions(%TodoList{}) do
     %Permission{access: :member, create: :member, update: :member, delete: :member}
   end
diff --git a/lib/federation/activity_pub/types/todos.ex b/lib/federation/activity_pub/types/todos.ex
index b12463cea..771b64863 100644
--- a/lib/federation/activity_pub/types/todos.ex
+++ b/lib/federation/activity_pub/types/todos.ex
@@ -1,9 +1,12 @@
 defmodule Mobilizon.Federation.ActivityPub.Types.Todos do
-  @moduledoc false
+  @moduledoc """
+  ActivityPub type handler for Todos
+  """
   alias Mobilizon.{Actors, Todos}
   alias Mobilizon.Actors.Actor
   alias Mobilizon.Federation.ActivityPub.Permission
   alias Mobilizon.Federation.ActivityPub.Types.Entity
+  alias Mobilizon.Federation.ActivityStream
   alias Mobilizon.Federation.ActivityStream.Convertible
   alias Mobilizon.Todos.{Todo, TodoList}
   import Mobilizon.Federation.ActivityPub.Utils, only: [make_create_data: 2, make_update_data: 2]
@@ -12,41 +15,75 @@ defmodule Mobilizon.Federation.ActivityPub.Types.Todos do
   @behaviour Entity
 
   @impl Entity
-  @spec create(map(), map()) :: {:ok, map()}
+  @spec create(map(), map()) ::
+          {:ok, Todo.t(), ActivityStream.t()} | {:error, Ecto.Changeset.t() | atom()}
   def create(args, additional) do
     with {:ok, %Todo{todo_list_id: todo_list_id, creator_id: creator_id} = todo} <-
            Todos.create_todo(args),
-         %TodoList{actor_id: group_id} = todo_list <- Todos.get_todo_list(todo_list_id),
-         %Actor{} = creator <- Actors.get_actor(creator_id),
-         {:ok, %Actor{} = group} <- Actors.get_group_by_actor_id(group_id),
-         todo <- %{todo | todo_list: %{todo_list | actor: group}, creator: creator},
-         todo_as_data <-
-           Convertible.model_to_as(todo),
-         audience <- %{"to" => [group.members_url], "cc" => []},
-         create_data <-
-           make_create_data(todo_as_data, Map.merge(audience, additional)) do
+         {:ok, %Actor{} = creator, %TodoList{} = todo_list, %Actor{} = group} <-
+           creator_todo_list_and_group(creator_id, todo_list_id) do
+      todo = %{todo | todo_list: %{todo_list | actor: group}, creator: creator}
+      todo_as_data = Convertible.model_to_as(todo)
+      audience = %{"to" => [group.members_url], "cc" => []}
+      create_data = make_create_data(todo_as_data, Map.merge(audience, additional))
       {:ok, todo, create_data}
     end
   end
 
   @impl Entity
-  @spec update(Todo.t(), map, map) :: {:ok, Todo.t(), Activity.t()} | any
+  @spec update(Todo.t(), map, map) ::
+          {:ok, Todo.t(), ActivityStream.t()}
+          | {:error, atom() | Ecto.Changeset.t()}
   def update(%Todo{} = old_todo, args, additional) do
     with {:ok, %Todo{todo_list_id: todo_list_id} = todo} <- Todos.update_todo(old_todo, args),
-         %TodoList{actor_id: group_id} = todo_list <- Todos.get_todo_list(todo_list_id),
-         {:ok, %Actor{} = group} <- Actors.get_group_by_actor_id(group_id),
-         todo_as_data <-
-           Convertible.model_to_as(%{todo | todo_list: %{todo_list | actor: group}}),
-         audience <- %{"to" => [group.members_url], "cc" => []},
-         update_data <-
-           make_update_data(todo_as_data, Map.merge(audience, additional)) do
+         {:ok, %TodoList{} = todo_list, %Actor{} = group} <- todo_list_and_group(todo_list_id) do
+      todo_as_data = Convertible.model_to_as(%{todo | todo_list: %{todo_list | actor: group}})
+      audience = %{"to" => [group.members_url], "cc" => []}
+      update_data = make_update_data(todo_as_data, Map.merge(audience, additional))
       {:ok, todo, update_data}
     end
   end
 
+  @spec creator_todo_list_and_group(integer(), String.t()) ::
+          {:ok, Actor.t(), TodoList.t(), Actor.t()}
+          | {:error, :creator_not_found | :group_not_found | :todo_list_not_found}
+  defp creator_todo_list_and_group(creator_id, todo_list_id) do
+    case Actors.get_actor(creator_id) do
+      %Actor{} = creator ->
+        case todo_list_and_group(todo_list_id) do
+          {:ok, %TodoList{} = todo_list, %Actor{} = group} ->
+            {:ok, creator, todo_list, group}
+
+          {:error, err} ->
+            {:error, err}
+        end
+
+      nil ->
+        {:error, :creator_not_found}
+    end
+  end
+
+  @spec todo_list_and_group(String.t()) ::
+          {:ok, TodoList.t(), Actor.t()} | {:error, :group_not_found | :todo_list_not_found}
+  defp todo_list_and_group(todo_list_id) do
+    case Todos.get_todo_list(todo_list_id) do
+      %TodoList{actor_id: group_id} = todo_list ->
+        case Actors.get_group_by_actor_id(group_id) do
+          {:ok, %Actor{} = group} ->
+            {:ok, todo_list, group}
+
+          {:error, :group_not_found} ->
+            {:error, :group_not_found}
+        end
+
+      nil ->
+        {:error, :todo_list_not_found}
+    end
+  end
+
   @impl Entity
-  @spec delete(Todo.t(), Actor.t(), boolean(), map()) ::
-          {:ok, ActivityStream.t(), Actor.t(), Todo.t()}
+  @spec delete(Todo.t(), Actor.t(), any(), any()) ::
+          {:ok, ActivityStream.t(), Actor.t(), Todo.t()} | {:error, Ecto.Changeset.t()}
   def delete(
         %Todo{url: url, creator: %Actor{url: group_url}} = todo,
         %Actor{url: actor_url} = actor,
@@ -59,18 +96,24 @@ defmodule Mobilizon.Federation.ActivityPub.Types.Todos do
       "actor" => actor_url,
       "type" => "Delete",
       "object" => Convertible.model_to_as(url),
-      "id" => url <> "/delete",
+      "id" => "#{url}/delete",
       "to" => [group_url]
     }
 
-    with {:ok, _todo} <- Todos.delete_todo(todo),
-         {:ok, true} <- Cachex.del(:activity_pub, "todo_#{todo.id}") do
-      {:ok, activity_data, actor, todo}
+    case Todos.delete_todo(todo) do
+      {:ok, _todo} ->
+        Cachex.del(:activity_pub, "todo_#{todo.id}")
+        {:ok, activity_data, actor, todo}
+
+      {:error, %Ecto.Changeset{} = err} ->
+        {:error, err}
     end
   end
 
+  @spec actor(Todo.t()) :: Actor.t() | nil
   def actor(%Todo{creator_id: creator_id}), do: Actors.get_actor(creator_id)
 
+  @spec group_actor(Todo.t()) :: Actor.t() | nil
   def group_actor(%Todo{todo_list_id: todo_list_id}) do
     case Todos.get_todo_list(todo_list_id) do
       %TodoList{actor_id: group_id} ->
@@ -81,6 +124,7 @@ defmodule Mobilizon.Federation.ActivityPub.Types.Todos do
     end
   end
 
+  @spec permissions(Todo.t()) :: Permission.t()
   def permissions(%Todo{}) do
     %Permission{access: :member, create: :member, update: :member, delete: :member}
   end
diff --git a/lib/federation/activity_pub/types/tombstones.ex b/lib/federation/activity_pub/types/tombstones.ex
index 9535d08ef..10d0a390b 100644
--- a/lib/federation/activity_pub/types/tombstones.ex
+++ b/lib/federation/activity_pub/types/tombstones.ex
@@ -4,6 +4,7 @@ defmodule Mobilizon.Federation.ActivityPub.Types.Tombstones do
   alias Mobilizon.Actors.Actor
   alias Mobilizon.Federation.ActivityPub.Permission
 
+  @spec actor(Tombstone.t()) :: Actor.t() | nil
   def actor(%Tombstone{actor: %Actor{id: actor_id}}), do: Actors.get_actor(actor_id)
 
   def actor(%Tombstone{actor_id: actor_id}) when not is_nil(actor_id),
@@ -11,8 +12,10 @@ defmodule Mobilizon.Federation.ActivityPub.Types.Tombstones do
 
   def actor(_), do: nil
 
+  @spec group_actor(any()) :: nil
   def group_actor(_), do: nil
 
+  @spec permissions(any()) :: Permission.t()
   def permissions(_) do
     %Permission{access: nil, create: nil, update: nil, delete: nil}
   end
diff --git a/lib/federation/activity_pub/utils.ex b/lib/federation/activity_pub/utils.ex
index 7282be86d..08879e01b 100644
--- a/lib/federation/activity_pub/utils.ex
+++ b/lib/federation/activity_pub/utils.ex
@@ -12,8 +12,7 @@ defmodule Mobilizon.Federation.ActivityPub.Utils do
   alias Mobilizon.Actors.Actor
   alias Mobilizon.Medias.Media
 
-  alias Mobilizon.Federation.ActivityPub
-  alias Mobilizon.Federation.ActivityPub.{Activity, Federator, Relay}
+  alias Mobilizon.Federation.ActivityPub.{Actions, Activity, Federator, Relay}
   alias Mobilizon.Federation.ActivityPub.Actor, as: ActivityPubActor
   alias Mobilizon.Federation.ActivityStream.Converter
   alias Mobilizon.Federation.HTTPSignatures
@@ -23,13 +22,35 @@ defmodule Mobilizon.Federation.ActivityPub.Utils do
 
   @actor_types ["Group", "Person", "Application"]
 
+  # Wraps an object into an activity
+  @spec create_activity(map(), boolean()) :: {:ok, Activity.t()}
+  def create_activity(map, local) when is_map(map) do
+    with map <- lazy_put_activity_defaults(map) do
+      {:ok,
+       %Activity{
+         data: map,
+         local: local,
+         actor: map["actor"],
+         recipients: get_recipients(map)
+       }}
+    end
+  end
+
+  # Get recipients for an activity or object
+  @spec get_recipients(map()) :: list()
+  defp get_recipients(data) do
+    Map.get(data, "to", []) ++ Map.get(data, "cc", [])
+  end
+
   # Some implementations send the actor URI as the actor field, others send the entire actor object,
   # so figure out what the actor's URI is based on what we have.
+  @spec get_url(map() | String.t() | list(String.t()) | any()) :: String.t() | nil
   def get_url(%{"id" => id}), do: id
   def get_url(id) when is_binary(id), do: id
   def get_url(ids) when is_list(ids), do: get_url(hd(ids))
   def get_url(_), do: nil
 
+  @spec make_json_ld_header :: map()
   def make_json_ld_header do
     %{
       "@context" => [
@@ -99,6 +120,7 @@ defmodule Mobilizon.Federation.ActivityPub.Utils do
     }
   end
 
+  @spec make_date :: String.t()
   def make_date do
     DateTime.utc_now() |> DateTime.truncate(:second) |> DateTime.to_iso8601()
   end
@@ -106,6 +128,7 @@ defmodule Mobilizon.Federation.ActivityPub.Utils do
   @doc """
   Enqueues an activity for federation if it's local
   """
+  @spec maybe_federate(activity :: Activity.t()) :: :ok
   def maybe_federate(%Activity{local: true} = activity) do
     Logger.debug("Maybe federate an activity")
 
@@ -129,6 +152,7 @@ defmodule Mobilizon.Federation.ActivityPub.Utils do
   Applies to activities sent by group members from outside this instance to a group of this instance,
   we then need to relay (`Announce`) the object to other members on other instances.
   """
+  @spec maybe_relay_if_group_activity(Activity.t(), Actor.t() | nil | list(Actor.t())) :: :ok
   def maybe_relay_if_group_activity(activity, attributed_to \\ nil)
 
   def maybe_relay_if_group_activity(
@@ -144,7 +168,7 @@ defmodule Mobilizon.Federation.ActivityPub.Utils do
         %Activity{data: %{"object" => object}},
         %Actor{url: attributed_to_url}
       )
-      when is_binary(object) do
+      when is_binary(object) and is_binary(attributed_to_url) do
     do_maybe_relay_if_group_activity(object, attributed_to_url)
   end
 
@@ -152,6 +176,7 @@ defmodule Mobilizon.Federation.ActivityPub.Utils do
     :ok
   end
 
+  @spec do_maybe_relay_if_group_activity(map(), list(String.t()) | String.t()) :: :ok
   defp do_maybe_relay_if_group_activity(object, attributed_to) when is_list(attributed_to),
     do: do_maybe_relay_if_group_activity(object, hd(attributed_to))
 
@@ -160,17 +185,17 @@ defmodule Mobilizon.Federation.ActivityPub.Utils do
 
     case Actors.get_local_group_by_url(attributed_to) do
       %Actor{} = group ->
-        case ActivityPub.announce(group, object, id, true, false) do
+        case Actions.Announce.announce(group, object, id, true, false) do
           {:ok, _activity, _object} ->
             Logger.info("Forwarded activity to external members of the group")
             :ok
 
-          _ ->
+          {:error, _err} ->
             Logger.info("Failed to forward activity to external members of the group")
             :error
         end
 
-      _ ->
+      nil ->
         :ok
     end
   end
@@ -198,6 +223,7 @@ defmodule Mobilizon.Federation.ActivityPub.Utils do
   Adds an id and a published data if they aren't there,
   also adds it to an included object
   """
+  @spec lazy_put_activity_defaults(map()) :: map()
   def lazy_put_activity_defaults(%{"object" => _object} = map) do
     if is_map(map["object"]) do
       object = lazy_put_object_defaults(map["object"])
@@ -214,6 +240,7 @@ defmodule Mobilizon.Federation.ActivityPub.Utils do
     Map.put_new_lazy(map, "published", &make_date/0)
   end
 
+  @spec get_actor(map()) :: String.t() | nil
   def get_actor(%{"actor" => actor}) when is_binary(actor) do
     actor
   end
@@ -241,6 +268,7 @@ defmodule Mobilizon.Federation.ActivityPub.Utils do
 
   Takes the actor or attributedTo attributes (considers only the first elem if they're an array)
   """
+  @spec origin_check?(String.t(), map()) :: boolean()
   def origin_check?(id, %{"type" => "Tombstone", "id" => tombstone_id}), do: id == tombstone_id
 
   def origin_check?(id, %{"actor" => actor, "attributedTo" => _attributed_to} = params)
@@ -282,6 +310,7 @@ defmodule Mobilizon.Federation.ActivityPub.Utils do
     compare_uris?(uri_1, uri_2)
   end
 
+  @spec compare_uris?(URI.t(), URI.t()) :: boolean()
   defp compare_uris?(%URI{} = id_uri, %URI{} = other_uri),
     do: id_uri.host == other_uri.host && id_uri.port == other_uri.port
 
@@ -311,7 +340,7 @@ defmodule Mobilizon.Federation.ActivityPub.Utils do
       {:ok, media} ->
         media
 
-      _ ->
+      {:error, _err} ->
         nil
     end
   end
@@ -509,7 +538,7 @@ defmodule Mobilizon.Federation.ActivityPub.Utils do
   @doc """
   Make add activity data
   """
-  @spec make_add_data(map(), map()) :: map()
+  @spec make_add_data(map(), map(), map()) :: map()
   def make_add_data(object, target, additional \\ %{}) do
     Logger.debug("Making add data")
     Logger.debug(inspect(object))
@@ -530,7 +559,7 @@ defmodule Mobilizon.Federation.ActivityPub.Utils do
   @doc """
   Make move activity data
   """
-  @spec make_add_data(map(), map()) :: map()
+  @spec make_move_data(map(), map(), map(), map()) :: map()
   def make_move_data(object, origin, target, additional \\ %{}) do
     Logger.debug("Making move data")
     Logger.debug(inspect(object))
@@ -554,6 +583,7 @@ defmodule Mobilizon.Federation.ActivityPub.Utils do
   @doc """
   Converts PEM encoded keys to a public key representation
   """
+  @spec pem_to_public_key(String.t()) :: {:RSAPublicKey, any(), any()}
   def pem_to_public_key(pem) do
     [key_code] = :public_key.pem_decode(pem)
     key = :public_key.pem_entry_decode(key_code)
@@ -567,6 +597,7 @@ defmodule Mobilizon.Federation.ActivityPub.Utils do
     end
   end
 
+  @spec pem_to_public_key_pem(String.t()) :: String.t()
   def pem_to_public_key_pem(pem) do
     public_key = pem_to_public_key(pem)
     public_key = :public_key.pem_entry_encode(:RSAPublicKey, public_key)
diff --git a/lib/federation/activity_stream.ex b/lib/federation/activity_stream.ex
index f6d7a8132..ee6b12123 100644
--- a/lib/federation/activity_stream.ex
+++ b/lib/federation/activity_stream.ex
@@ -3,5 +3,5 @@ defmodule Mobilizon.Federation.ActivityStream do
   The ActivityStream Type
   """
 
-  @type t :: map()
+  @type t :: %{String.t() => String.t() | list(String.t()) | map() | nil}
 end
diff --git a/lib/federation/activity_stream/converter/actor.ex b/lib/federation/activity_stream/converter/actor.ex
index 54c087a7c..59cc713f5 100644
--- a/lib/federation/activity_stream/converter/actor.ex
+++ b/lib/federation/activity_stream/converter/actor.ex
@@ -29,7 +29,7 @@ defmodule Mobilizon.Federation.ActivityStream.Converter.Actor do
   Converts an AP object data to our internal data structure.
   """
   @impl Converter
-  @spec as_to_model_data(map()) :: {:ok, map()}
+  @spec as_to_model_data(map()) :: map() | {:error, :actor_not_allowed_type}
   def as_to_model_data(%{"type" => type} = data) when type in @allowed_types do
     avatar =
       download_picture(get_in(data, ["icon", "url"]), get_in(data, ["icon", "name"]), "avatar")
@@ -64,7 +64,7 @@ defmodule Mobilizon.Federation.ActivityStream.Converter.Actor do
     }
   end
 
-  def as_to_model_data(_), do: :error
+  def as_to_model_data(_), do: {:error, :actor_not_allowed_type}
 
   @doc """
   Convert an actor struct to an ActivityStream representation.
@@ -135,7 +135,7 @@ defmodule Mobilizon.Federation.ActivityStream.Converter.Actor do
     end
   end
 
-  @spec download_picture(String.t() | nil, String.t(), String.t()) :: map()
+  @spec download_picture(String.t() | nil, String.t(), String.t()) :: map() | nil
   defp download_picture(nil, _name, _default_name), do: nil
 
   defp download_picture(url, name, default_name) do
diff --git a/lib/federation/activity_stream/converter/comment.ex b/lib/federation/activity_stream/converter/comment.ex
index d4ec756d9..eaa15ac01 100644
--- a/lib/federation/activity_stream/converter/comment.ex
+++ b/lib/federation/activity_stream/converter/comment.ex
@@ -38,52 +38,49 @@ defmodule Mobilizon.Federation.ActivityStream.Converter.Comment do
   Converts an AP object data to our internal data structure.
   """
   @impl Converter
-  @spec as_to_model_data(map) :: {:ok, map} | {:error, any()}
+  @spec as_to_model_data(map) :: map | {:error, atom}
   def as_to_model_data(object) do
     Logger.debug("We're converting raw ActivityStream data to a comment entity")
     Logger.debug(inspect(object))
 
-    with {%Actor{id: actor_id, domain: actor_domain}, attributed_to} <-
-           maybe_fetch_actor_and_attributed_to_id(object),
-         {:tags, tags} <- {:tags, fetch_tags(Map.get(object, "tag", []))},
-         {:mentions, mentions} <-
-           {:mentions, fetch_mentions(Map.get(object, "tag", []))},
-         discussion <-
-           Discussions.get_discussion_by_url(Map.get(object, "context")) do
-      Logger.debug("Inserting full comment")
-      Logger.debug(inspect(object))
+    tag_object = Map.get(object, "tag", [])
 
-      data = %{
-        text: object["content"],
-        url: object["id"],
-        # Will be used in conversations, ignored in basic comments
-        title: object["name"],
-        context: object["context"],
-        actor_id: actor_id,
-        attributed_to_id: if(is_nil(attributed_to), do: nil, else: attributed_to.id),
-        in_reply_to_comment_id: nil,
-        event_id: nil,
-        uuid: object["uuid"],
-        discussion_id: if(is_nil(discussion), do: nil, else: discussion.id),
-        tags: tags,
-        mentions: mentions,
-        local: is_nil(actor_domain),
-        visibility: if(Visibility.is_public?(object), do: :public, else: :private),
-        published_at: object["published"],
-        is_announcement: Map.get(object, "isAnnouncement", false)
-      }
+    case maybe_fetch_actor_and_attributed_to_id(object) do
+      {:ok, %Actor{id: actor_id, domain: actor_domain}, attributed_to} ->
+        Logger.debug("Inserting full comment")
+        Logger.debug(inspect(object))
 
-      Logger.debug("Converted object before fetching parents")
-      Logger.debug(inspect(data))
+        data = %{
+          text: object["content"],
+          url: object["id"],
+          # Will be used in conversations, ignored in basic comments
+          title: object["name"],
+          context: object["context"],
+          actor_id: actor_id,
+          attributed_to_id: if(is_nil(attributed_to), do: nil, else: attributed_to.id),
+          in_reply_to_comment_id: nil,
+          event_id: nil,
+          uuid: object["uuid"],
+          discussion_id: get_discussion_id(object),
+          tags: fetch_tags(tag_object),
+          mentions: fetch_mentions(tag_object),
+          local: is_nil(actor_domain),
+          visibility: if(Visibility.is_public?(object), do: :public, else: :private),
+          published_at: object["published"],
+          is_announcement: Map.get(object, "isAnnouncement", false)
+        }
 
-      data = maybe_fetch_parent_object(object, data)
+        Logger.debug("Converted object before fetching parents")
+        Logger.debug(inspect(data))
 
-      Logger.debug("Converted object after fetching parents")
-      Logger.debug(inspect(data))
-      data
-    else
-      {:ok, %Actor{suspended: true}} ->
-        :error
+        data = maybe_fetch_parent_object(object, data)
+
+        Logger.debug("Converted object after fetching parents")
+        Logger.debug(inspect(data))
+        data
+
+      {:error, err} ->
+        {:error, err}
     end
   end
 
@@ -94,9 +91,20 @@ defmodule Mobilizon.Federation.ActivityStream.Converter.Comment do
   """
   @impl Converter
   @spec model_to_as(CommentModel.t()) :: map
-  def model_to_as(%CommentModel{deleted_at: nil} = comment) do
+  def model_to_as(
+        %CommentModel{
+          deleted_at: nil,
+          attributed_to: attributed_to,
+          actor: %Actor{url: comment_actor_url}
+        } = comment
+      ) do
     to = determine_to(comment)
 
+    attributed_to =
+      if is_nil(attributed_to),
+        do: comment_actor_url,
+        else: Map.get(attributed_to, :url, comment_actor_url)
+
     object = %{
       "type" => "Note",
       "to" => to,
@@ -104,9 +112,7 @@ defmodule Mobilizon.Federation.ActivityStream.Converter.Comment do
       "content" => comment.text,
       "mediaType" => "text/html",
       "actor" => comment.actor.url,
-      "attributedTo" =>
-        if(is_nil(comment.attributed_to), do: nil, else: comment.attributed_to.url) ||
-          comment.actor.url,
+      "attributedTo" => attributed_to,
       "uuid" => comment.uuid,
       "id" => comment.url,
       "tag" => build_mentions(comment.mentions) ++ build_tags(comment.tags),
@@ -132,7 +138,6 @@ defmodule Mobilizon.Federation.ActivityStream.Converter.Comment do
   end
 
   @impl Converter
-  @spec model_to_as(CommentModel.t()) :: map
   def model_to_as(%CommentModel{} = comment) do
     Convertible.model_to_as(%TombstoneModel{
       uri: comment.url,
@@ -203,4 +208,13 @@ defmodule Mobilizon.Federation.ActivityStream.Converter.Comment do
       data
     end
   end
+
+  defp get_discussion_id(%{"context" => context}) do
+    case Discussions.get_discussion_by_url(context) do
+      %Discussion{id: discussion_id} -> discussion_id
+      nil -> nil
+    end
+  end
+
+  defp get_discussion_id(_object), do: nil
 end
diff --git a/lib/federation/activity_stream/converter/converter.ex b/lib/federation/activity_stream/converter/converter.ex
index 73b1ca69b..ceef41ff5 100644
--- a/lib/federation/activity_stream/converter/converter.ex
+++ b/lib/federation/activity_stream/converter/converter.ex
@@ -8,6 +8,6 @@ defmodule Mobilizon.Federation.ActivityStream.Converter do
 
   @type model_data :: map()
 
-  @callback as_to_model_data(as_data :: ActivityStream.t()) :: model_data()
+  @callback as_to_model_data(as_data :: ActivityStream.t()) :: model_data() | {:error, any()}
   @callback model_to_as(model :: struct()) :: ActivityStream.t()
 end
diff --git a/lib/federation/activity_stream/converter/discussion.ex b/lib/federation/activity_stream/converter/discussion.ex
index 2029923d6..3d611d1db 100644
--- a/lib/federation/activity_stream/converter/discussion.ex
+++ b/lib/federation/activity_stream/converter/discussion.ex
@@ -12,6 +12,7 @@ defmodule Mobilizon.Federation.ActivityStream.Converter.Discussion do
   alias Mobilizon.Federation.ActivityStream.{Converter, Convertible}
   alias Mobilizon.Federation.ActivityStream.Converter.Discussion, as: DiscussionConverter
   alias Mobilizon.Storage.Repo
+  import Mobilizon.Service.Guards, only: [is_valid_string: 1]
 
   require Logger
 
@@ -45,20 +46,28 @@ defmodule Mobilizon.Federation.ActivityStream.Converter.Discussion do
   end
 
   @impl Converter
-  @spec as_to_model_data(map) :: {:ok, map} | {:error, any()}
-  def as_to_model_data(%{"type" => "Note", "name" => name} = object) when not is_nil(name) do
-    with creator_url <- Map.get(object, "actor"),
-         {:ok, %Actor{id: creator_id, suspended: false}} <-
+  @spec as_to_model_data(map) :: map() | {:error, atom()}
+  def as_to_model_data(%{"type" => "Note", "name" => name} = object) when is_valid_string(name) do
+    case extract_actors(object) do
+      %{actor_id: actor_id, creator_id: creator_id} ->
+        %{actor_id: actor_id, creator_id: creator_id, title: name, url: object["id"]}
+
+      {:error, error} ->
+        {:error, error}
+    end
+  end
+
+  @spec extract_actors(map()) ::
+          %{actor_id: String.t(), creator_id: String.t()} | {:error, atom()}
+  defp extract_actors(%{"actor" => creator_url, "attributedTo" => actor_url} = _object)
+       when is_valid_string(creator_url) and is_valid_string(actor_url) do
+    with {:ok, %Actor{id: creator_id, suspended: false}} <-
            ActivityPubActor.get_or_fetch_actor_by_url(creator_url),
-         actor_url <- Map.get(object, "attributedTo"),
          {:ok, %Actor{id: actor_id, suspended: false}} <-
            ActivityPubActor.get_or_fetch_actor_by_url(actor_url) do
-      %{
-        title: name,
-        actor_id: actor_id,
-        creator_id: creator_id,
-        url: object["id"]
-      }
+      %{actor_id: actor_id, creator_id: creator_id}
+    else
+      {:error, error} -> {:error, error}
     end
   end
 end
diff --git a/lib/federation/activity_stream/converter/event.ex b/lib/federation/activity_stream/converter/event.ex
index 65825a32e..d9193efe7 100644
--- a/lib/federation/activity_stream/converter/event.ex
+++ b/lib/federation/activity_stream/converter/event.ex
@@ -45,50 +45,51 @@ defmodule Mobilizon.Federation.ActivityStream.Converter.Event do
   Converts an AP object data to our internal data structure.
   """
   @impl Converter
-  @spec as_to_model_data(map) :: {:ok, map()} | {:error, any()}
+  @spec as_to_model_data(map) :: map() | {:error, atom()}
   def as_to_model_data(object) do
-    with {%Actor{id: actor_id}, attributed_to} <-
-           maybe_fetch_actor_and_attributed_to_id(object),
-         {:address, address_id} <-
-           {:address, get_address(object["location"])},
-         {:tags, tags} <- {:tags, fetch_tags(object["tag"])},
-         {:mentions, mentions} <- {:mentions, fetch_mentions(object["tag"])},
-         {:visibility, visibility} <- {:visibility, get_visibility(object)},
-         {:options, options} <- {:options, get_options(object)},
-         {:metadata, metadata} <- {:metadata, get_metdata(object)},
-         [description: description, picture_id: picture_id, medias: medias] <-
-           process_pictures(object, actor_id) do
-      %{
-        title: object["name"],
-        description: description,
-        organizer_actor_id: actor_id,
-        attributed_to_id: if(is_nil(attributed_to), do: nil, else: attributed_to.id),
-        picture_id: picture_id,
-        medias: medias,
-        begins_on: object["startTime"],
-        ends_on: object["endTime"],
-        category: object["category"],
-        visibility: visibility,
-        join_options: Map.get(object, "joinMode", "free"),
-        local: is_local(object["id"]),
-        options: options,
-        metadata: metadata,
-        status: object |> Map.get("ical:status", "CONFIRMED") |> String.downcase(),
-        online_address: object |> Map.get("attachment", []) |> get_online_address(),
-        phone_address: object["phoneAddress"],
-        draft: object["draft"] == true,
-        url: object["id"],
-        uuid: object["uuid"],
-        tags: tags,
-        mentions: mentions,
-        physical_address_id: address_id,
-        updated_at: object["updated"],
-        publish_at: object["published"],
-        language: object["inLanguage"]
-      }
-    else
-      {:ok, %Actor{suspended: true}} ->
-        :error
+    case maybe_fetch_actor_and_attributed_to_id(object) do
+      {:ok, %Actor{id: actor_id}, attributed_to} ->
+        address_id = get_address(object["location"])
+        tags = fetch_tags(object["tag"])
+        mentions = fetch_mentions(object["tag"])
+        visibility = get_visibility(object)
+        options = get_options(object)
+        metadata = get_metdata(object)
+
+        [description: description, picture_id: picture_id, medias: medias] =
+          process_pictures(object, actor_id)
+
+        %{
+          title: object["name"],
+          description: description,
+          organizer_actor_id: actor_id,
+          attributed_to_id: if(is_nil(attributed_to), do: nil, else: attributed_to.id),
+          picture_id: picture_id,
+          medias: medias,
+          begins_on: object["startTime"],
+          ends_on: object["endTime"],
+          category: object["category"],
+          visibility: visibility,
+          join_options: Map.get(object, "joinMode", "free"),
+          local: is_local(object["id"]),
+          options: options,
+          metadata: metadata,
+          status: object |> Map.get("ical:status", "CONFIRMED") |> String.downcase(),
+          online_address: object |> Map.get("attachment", []) |> get_online_address(),
+          phone_address: object["phoneAddress"],
+          draft: object["draft"] == true,
+          url: object["id"],
+          uuid: object["uuid"],
+          tags: tags,
+          mentions: mentions,
+          physical_address_id: address_id,
+          updated_at: object["updated"],
+          publish_at: object["published"],
+          language: object["inLanguage"]
+        }
+
+      {:error, err} ->
+        {:error, err}
     end
   end
 
diff --git a/lib/federation/activity_stream/converter/event_metadata.ex b/lib/federation/activity_stream/converter/event_metadata.ex
index eca14d16b..eeee081b8 100644
--- a/lib/federation/activity_stream/converter/event_metadata.ex
+++ b/lib/federation/activity_stream/converter/event_metadata.ex
@@ -4,9 +4,11 @@ defmodule Mobilizon.Federation.ActivityStream.Converter.EventMetadata do
   """
 
   alias Mobilizon.Events.EventMetadata
+  alias Mobilizon.Federation.ActivityStream
 
   @property_value "PropertyValue"
 
+  @spec metadata_to_as(EventMetadata.t()) :: map()
   def metadata_to_as(%EventMetadata{type: :boolean, value: value, key: key})
       when value in ["true", "false"] do
     %{
@@ -47,6 +49,7 @@ defmodule Mobilizon.Federation.ActivityStream.Converter.EventMetadata do
     )
   end
 
+  @spec as_to_metadata(ActivityStream.t()) :: map()
   def as_to_metadata(%{"type" => @property_value, "propertyID" => key, "value" => value})
       when is_boolean(value) do
     %{type: :boolean, key: key, value: to_string(value)}
diff --git a/lib/federation/activity_stream/converter/media.ex b/lib/federation/activity_stream/converter/media.ex
index d89aa2de8..6b63caabe 100644
--- a/lib/federation/activity_stream/converter/media.ex
+++ b/lib/federation/activity_stream/converter/media.ex
@@ -6,6 +6,7 @@ defmodule Mobilizon.Federation.ActivityStream.Converter.Media do
   internal one, and back.
   """
 
+  alias Mobilizon.Federation.ActivityStream
   alias Mobilizon.Medias
   alias Mobilizon.Medias.Media, as: MediaModel
 
@@ -18,7 +19,7 @@ defmodule Mobilizon.Federation.ActivityStream.Converter.Media do
   @doc """
   Convert a media struct to an ActivityStream representation.
   """
-  @spec model_to_as(MediaModel.t()) :: map
+  @spec model_to_as(MediaModel.t()) :: ActivityStream.t()
   def model_to_as(%MediaModel{file: file}) do
     %{
       "type" => "Document",
@@ -31,29 +32,53 @@ defmodule Mobilizon.Federation.ActivityStream.Converter.Media do
   @doc """
   Save media data from raw data and return AS Link data.
   """
+  @spec find_or_create_media(map(), String.t() | integer()) ::
+          {:ok, MediaModel.t()} | {:error, atom() | String.t() | Ecto.Changeset.t()}
   def find_or_create_media(%{"type" => "Link", "href" => url}, actor_id),
-    do: find_or_create_media(url, actor_id)
+    do:
+      find_or_create_media(
+        %{"type" => "Document", "url" => url, "name" => "External media"},
+        actor_id
+      )
 
   def find_or_create_media(
         %{"type" => "Document", "url" => media_url, "name" => name},
         actor_id
       )
       when is_binary(media_url) do
-    with {:ok, %{body: body}} <- Tesla.get(media_url, opts: @http_options),
-         {:ok, %{url: url} = uploaded} <-
-           Upload.store(%{body: body, name: name}),
-         {:media_exists, nil} <- {:media_exists, Medias.get_media_by_url(url)} do
-      Medias.create_media(%{
-        file: Map.take(uploaded, [:url, :name, :content_type, :size]),
-        metadata: Map.take(uploaded, [:width, :height, :blurhash]),
-        actor_id: actor_id
-      })
-    else
-      {:media_exists, %MediaModel{file: _file} = media} ->
-        {:ok, media}
+    case upload_media(media_url, name) do
+      {:error, err} ->
+        {:error, err}
 
-      err ->
-        err
+      {:ok, %{url: url} = uploaded} ->
+        case Medias.get_media_by_url(url) do
+          %MediaModel{file: _file} = media ->
+            {:ok, media}
+
+          nil ->
+            Medias.create_media(%{
+              file: Map.take(uploaded, [:url, :name, :content_type, :size]),
+              metadata: Map.take(uploaded, [:width, :height, :blurhash]),
+              actor_id: actor_id
+            })
+        end
+    end
+  end
+
+  @spec upload_media(String.t(), String.t()) :: {:ok, map()} | {:error, atom() | String.t()}
+  defp upload_media(media_url, name) do
+    case Tesla.get(media_url, opts: @http_options) do
+      {:ok, %{body: body}} ->
+        case Upload.store(%{body: body, name: name}) do
+          {:ok, %{url: _url} = uploaded} ->
+            {:ok, uploaded}
+
+          {:error, err} ->
+            {:error, err}
+        end
+
+      {:error, err} ->
+        {:error, err}
     end
   end
 end
diff --git a/lib/federation/activity_stream/converter/member.ex b/lib/federation/activity_stream/converter/member.ex
index be4db50a5..3d33d1ae2 100644
--- a/lib/federation/activity_stream/converter/member.ex
+++ b/lib/federation/activity_stream/converter/member.ex
@@ -33,6 +33,7 @@ defmodule Mobilizon.Federation.ActivityStream.Converter.Member do
     }
   end
 
+  @spec as_to_model_data(map()) :: map()
   def as_to_model_data(%{
         "type" => "Member",
         "actor" => actor,
diff --git a/lib/federation/activity_stream/converter/post.ex b/lib/federation/activity_stream/converter/post.ex
index 0cb0dfee4..40f3eab43 100644
--- a/lib/federation/activity_stream/converter/post.ex
+++ b/lib/federation/activity_stream/converter/post.ex
@@ -18,6 +18,8 @@ defmodule Mobilizon.Federation.ActivityStream.Converter.Post do
       process_pictures: 2
     ]
 
+  import Mobilizon.Service.Guards, only: [is_valid_string: 1]
+
   @behaviour Converter
 
   defimpl Convertible, for: Post do
@@ -63,15 +65,15 @@ defmodule Mobilizon.Federation.ActivityStream.Converter.Post do
   Converts an AP object data to our internal data structure.
   """
   @impl Converter
-  @spec as_to_model_data(map) :: {:ok, map} | {:error, any()}
+  @spec as_to_model_data(map) :: map() | {:error, any()}
   def as_to_model_data(
         %{"type" => "Article", "actor" => creator, "attributedTo" => group_uri} = object
       ) do
     with {:ok, %Actor{id: attributed_to_id} = group} <- get_actor(group_uri),
-         {:ok, %Actor{id: author_id}} <- get_actor(creator),
-         {:visibility, visibility} <- {:visibility, get_visibility(object, group)},
-         [description: description, picture_id: picture_id, medias: medias] <-
-           process_pictures(object, attributed_to_id) do
+         {:ok, %Actor{id: author_id}} <- get_actor(creator) do
+      [description: description, picture_id: picture_id, medias: medias] =
+        process_pictures(object, attributed_to_id)
+
       %{
         title: object["name"],
         body: description,
@@ -82,7 +84,7 @@ defmodule Mobilizon.Federation.ActivityStream.Converter.Post do
         publish_at: object["published"],
         picture_id: picture_id,
         medias: medias,
-        visibility: visibility,
+        visibility: get_visibility(object, group),
         draft: object["draft"] == true
       }
     else
@@ -92,11 +94,12 @@ defmodule Mobilizon.Federation.ActivityStream.Converter.Post do
   end
 
   @spec get_actor(String.t() | map() | nil) :: {:ok, Actor.t()} | {:error, String.t()}
-  defp get_actor(nil), do: {:error, "nil property found for actor data"}
-
-  defp get_actor(actor),
+  defp get_actor(actor) when is_valid_string(actor),
     do: actor |> Utils.get_url() |> ActivityPubActor.get_or_fetch_actor_by_url()
 
+  defp get_actor(_), do: {:error, "nil property found for actor data"}
+
+  @spec to_date(DateTime.t() | NaiveDateTime.t() | nil) :: String.t() | nil
   defp to_date(nil), do: nil
   defp to_date(%DateTime{} = date), do: DateTime.to_iso8601(date)
   defp to_date(%NaiveDateTime{} = date), do: NaiveDateTime.to_iso8601(date)
diff --git a/lib/federation/activity_stream/converter/resource.ex b/lib/federation/activity_stream/converter/resource.ex
index a0d8ca6e7..becf41ded 100644
--- a/lib/federation/activity_stream/converter/resource.ex
+++ b/lib/federation/activity_stream/converter/resource.ex
@@ -56,18 +56,17 @@ defmodule Mobilizon.Federation.ActivityStream.Converter.Resource do
   Converts an AP object data to our internal data structure.
   """
   @impl Converter
-  @spec as_to_model_data(map) :: {:ok, map} | {:error, any()}
+  @spec as_to_model_data(map) :: map() | {:error, any()}
   def as_to_model_data(%{"type" => type, "actor" => creator, "attributedTo" => group} = object) do
     with {:ok, %Actor{id: actor_id, resources_url: resources_url}} <- get_actor(group),
-         {:ok, %Actor{id: creator_id}} <- get_actor(creator),
-         parent_id <- get_parent_id(object["context"], resources_url) do
+         {:ok, %Actor{id: creator_id}} <- get_actor(creator) do
       data = %{
         title: object["name"],
         summary: object["summary"],
         url: object["id"],
         actor_id: actor_id,
         creator_id: creator_id,
-        parent_id: parent_id,
+        parent_id: get_parent_id(object["context"], resources_url),
         published_at: object["published"]
       }
 
diff --git a/lib/federation/activity_stream/converter/todo.ex b/lib/federation/activity_stream/converter/todo.ex
index fdd6f38c8..3d470f6fd 100644
--- a/lib/federation/activity_stream/converter/todo.ex
+++ b/lib/federation/activity_stream/converter/todo.ex
@@ -47,27 +47,38 @@ defmodule Mobilizon.Federation.ActivityStream.Converter.Todo do
   Converts an AP object data to our internal data structure.
   """
   @impl Converter
-  @spec as_to_model_data(map) :: {:ok, map} | {:error, any()}
+  @spec as_to_model_data(map) :: map() | {:error, any()}
   def as_to_model_data(
         %{"type" => "Todo", "actor" => actor_url, "todoList" => todo_list_url} = object
       ) do
-    with {:ok, %Actor{id: creator_id} = _creator} <-
-           ActivityPubActor.get_or_fetch_actor_by_url(actor_url),
-         {:todo_list, %TodoList{id: todo_list_id}} <-
-           {:todo_list, Todos.get_todo_list_by_url(todo_list_url)} do
-      %{
-        title: object["name"],
-        status: object["status"],
-        url: object["id"],
-        todo_list_id: todo_list_id,
-        creator_id: creator_id,
-        published_at: object["published"]
-      }
-    else
-      {:todo_list, nil} ->
-        with {:ok, %TodoList{}} <- ActivityPub.fetch_object_from_url(todo_list_url) do
-          as_to_model_data(object)
+    case ActivityPubActor.get_or_fetch_actor_by_url(actor_url) do
+      {:ok, %Actor{id: creator_id} = _creator} ->
+        case Todos.get_todo_list_by_url(todo_list_url) do
+          %TodoList{id: todo_list_id} ->
+            %{
+              title: object["name"],
+              status: object["status"],
+              url: object["id"],
+              todo_list_id: todo_list_id,
+              creator_id: creator_id,
+              published_at: object["published"]
+            }
+
+          nil ->
+            case ActivityPub.fetch_object_from_url(todo_list_url) do
+              {:ok, _, %TodoList{}} ->
+                as_to_model_data(object)
+
+              {:ok, %TodoList{}} ->
+                as_to_model_data(object)
+
+              {:error, err} ->
+                {:error, err}
+            end
         end
+
+      {:error, err} ->
+        {:error, err}
     end
   end
 end
diff --git a/lib/federation/activity_stream/converter/todo_list.ex b/lib/federation/activity_stream/converter/todo_list.ex
index 76ad46fc7..4491ab389 100644
--- a/lib/federation/activity_stream/converter/todo_list.ex
+++ b/lib/federation/activity_stream/converter/todo_list.ex
@@ -37,7 +37,7 @@ defmodule Mobilizon.Federation.ActivityStream.Converter.TodoList do
   Converts an AP object data to our internal data structure.
   """
   @impl Converter
-  @spec as_to_model_data(map) :: {:ok, map} | {:error, any()}
+  @spec as_to_model_data(map) :: map() | {:error, :group_not_found}
   def as_to_model_data(%{"type" => "TodoList", "actor" => actor_url} = object) do
     case ActivityPubActor.get_or_fetch_actor_by_url(actor_url) do
       {:ok, %Actor{type: :Group, id: group_id} = _group} ->
diff --git a/lib/federation/activity_stream/converter/utils.ex b/lib/federation/activity_stream/converter/utils.ex
index a78456bd2..a01be5bde 100644
--- a/lib/federation/activity_stream/converter/utils.ex
+++ b/lib/federation/activity_stream/converter/utils.ex
@@ -111,7 +111,6 @@ defmodule Mobilizon.Federation.ActivityStream.Converter.Utils do
     acc ++ [%{actor_id: actor_id}]
   end
 
-  @spec create_mention(map(), list()) :: list()
   defp create_mention(mention, acc) when is_map(mention) do
     with true <- mention["type"] == "Mention",
          {:ok, %Actor{id: actor_id}} <-
@@ -128,22 +127,34 @@ defmodule Mobilizon.Federation.ActivityStream.Converter.Utils do
     create_mention(mention, acc)
   end
 
-  @spec maybe_fetch_actor_and_attributed_to_id(map()) :: {Actor.t() | nil, Actor.t() | nil}
+  @spec maybe_fetch_actor_and_attributed_to_id(map()) ::
+          {:ok, Actor.t(), Actor.t() | nil} | {:error, atom()}
   def maybe_fetch_actor_and_attributed_to_id(%{
         "actor" => actor_url,
         "attributedTo" => attributed_to_url
       })
       when is_nil(attributed_to_url) do
-    {fetch_actor(actor_url), nil}
+    case fetch_actor(actor_url) do
+      {:ok, %Actor{} = actor} ->
+        {:ok, actor, nil}
+
+      {:error, err} ->
+        {:error, err}
+    end
   end
 
-  @spec maybe_fetch_actor_and_attributed_to_id(map()) :: {Actor.t() | nil, Actor.t() | nil}
   def maybe_fetch_actor_and_attributed_to_id(%{
         "actor" => actor_url,
         "attributedTo" => attributed_to_url
       })
       when is_nil(actor_url) do
-    {fetch_actor(attributed_to_url), nil}
+    case fetch_actor(attributed_to_url) do
+      {:ok, %Actor{} = actor} ->
+        {:ok, actor, nil}
+
+      {:error, err} ->
+        {:error, err}
+    end
   end
 
   # Only when both actor and attributedTo fields are both filled is when we can return both
@@ -152,9 +163,12 @@ defmodule Mobilizon.Federation.ActivityStream.Converter.Utils do
         "attributedTo" => attributed_to_url
       })
       when actor_url != attributed_to_url do
-    with actor <- fetch_actor(actor_url),
-         attributed_to <- fetch_actor(attributed_to_url) do
-      {actor, attributed_to}
+    with {:ok, %Actor{} = actor} <- fetch_actor(actor_url),
+         {:ok, %Actor{} = attributed_to} <- fetch_actor(attributed_to_url) do
+      {:ok, actor, attributed_to}
+    else
+      {:error, err} ->
+        {:error, err}
     end
   end
 
@@ -162,16 +176,25 @@ defmodule Mobilizon.Federation.ActivityStream.Converter.Utils do
   def maybe_fetch_actor_and_attributed_to_id(%{
         "attributedTo" => attributed_to_url
       }) do
-    {fetch_actor(attributed_to_url), nil}
+    case fetch_actor(attributed_to_url) do
+      {:ok, %Actor{} = attributed_to} -> {:ok, attributed_to, nil}
+      {:error, err} -> {:error, err}
+    end
   end
 
-  def maybe_fetch_actor_and_attributed_to_id(_), do: {nil, nil}
+  def maybe_fetch_actor_and_attributed_to_id(_), do: {:error, :no_actor_found}
 
-  @spec fetch_actor(String.t()) :: Actor.t()
+  @spec fetch_actor(String.t()) :: {:ok, Actor.t()} | {:error, atom()}
   defp fetch_actor(actor_url) do
-    with {:ok, %Actor{suspended: false} = actor} <-
-           ActivityPubActor.get_or_fetch_actor_by_url(actor_url) do
-      actor
+    case ActivityPubActor.get_or_fetch_actor_by_url(actor_url) do
+      {:ok, %Actor{suspended: false} = actor} ->
+        {:ok, actor}
+
+      {:ok, %Actor{suspended: true} = _actor} ->
+        {:error, :actor_suspended}
+
+      {:error, err} ->
+        {:error, err}
     end
   end
 
@@ -203,12 +226,17 @@ defmodule Mobilizon.Federation.ActivityStream.Converter.Utils do
       |> Map.new()
 
     picture_id =
-      with banner when is_map(banner) <- get_banner_picture(attachements),
-           {:ok, %Media{id: picture_id}} <-
-             MediaConverter.find_or_create_media(banner, actor_id) do
-        picture_id
-      else
-        _err ->
+      case get_banner_picture(attachements) do
+        banner when is_map(banner) ->
+          case MediaConverter.find_or_create_media(banner, actor_id) do
+            {:error, _err} ->
+              nil
+
+            {:ok, %Media{id: picture_id}} ->
+              picture_id
+          end
+
+        _ ->
           nil
       end
 
diff --git a/lib/federation/http_signatures/signature.ex b/lib/federation/http_signatures/signature.ex
index e68251d3b..2d7003ebf 100644
--- a/lib/federation/http_signatures/signature.ex
+++ b/lib/federation/http_signatures/signature.ex
@@ -19,7 +19,7 @@ defmodule Mobilizon.Federation.HTTPSignatures.Signature do
 
   @spec key_id_to_actor_url(String.t()) :: String.t()
   def key_id_to_actor_url(key_id) do
-    %{path: path} =
+    %URI{path: path} =
       uri =
       key_id
       |> URI.parse()
@@ -29,7 +29,7 @@ defmodule Mobilizon.Federation.HTTPSignatures.Signature do
       if is_nil(path) do
         uri
       else
-        Map.put(uri, :path, String.trim_trailing(path, "/publickey"))
+        %URI{uri | path: String.trim_trailing(path, "/publickey")}
       end
 
     URI.to_string(uri)
@@ -78,15 +78,25 @@ defmodule Mobilizon.Federation.HTTPSignatures.Signature do
     end
   end
 
+  @spec fetch_public_key(Plug.Conn.t()) ::
+          {:ok, String.t()}
+          | {:error, :actor_fetch_error | :actor_not_fetchable | :pem_decode_error}
   def fetch_public_key(conn) do
     with %{"keyId" => kid} <- HTTPSignatures.signature_for_conn(conn),
          actor_id <- key_id_to_actor_url(kid),
          :ok <- Logger.debug("Fetching public key for #{actor_id}"),
          {:ok, public_key} <- get_public_key_for_url(actor_id) do
       {:ok, public_key}
+    else
+      {:error, err} ->
+        {:error, err}
     end
   end
 
+  @spec refetch_public_key(Plug.Conn.t()) ::
+          {:ok, String.t()}
+          | {:error, :actor_fetch_error | :actor_not_fetchable | :pem_decode_error,
+             :actor_is_local}
   def refetch_public_key(conn) do
     with %{"keyId" => kid} <- HTTPSignatures.signature_for_conn(conn),
          actor_id <- key_id_to_actor_url(kid),
@@ -94,9 +104,13 @@ defmodule Mobilizon.Federation.HTTPSignatures.Signature do
          {:ok, _actor} <- ActivityPubActor.make_actor_from_url(actor_id),
          {:ok, public_key} <- get_public_key_for_url(actor_id) do
       {:ok, public_key}
+    else
+      {:error, err} ->
+        {:error, err}
     end
   end
 
+  @spec sign(Actor.t(), map()) :: String.t() | {:error, :pem_decode_error} | no_return
   def sign(%Actor{domain: domain, keys: keys} = actor, headers) when is_nil(domain) do
     Logger.debug("Signing a payload on behalf of #{actor.url}")
     Logger.debug("headers")
@@ -112,14 +126,17 @@ defmodule Mobilizon.Federation.HTTPSignatures.Signature do
     raise ArgumentError, message: "Can't do a signature on remote actor #{url}"
   end
 
+  @spec generate_date_header :: String.t()
   def generate_date_header, do: generate_date_header(NaiveDateTime.utc_now())
 
   def generate_date_header(%NaiveDateTime{} = date) do
     Timex.format!(date, "{WDshort}, {0D} {Mshort} {YYYY} {h24}:{m}:{s} GMT")
   end
 
+  @spec generate_request_target(String.t(), String.t()) :: String.t()
   def generate_request_target(method, path), do: "#{method} #{path}"
 
+  @spec build_digest(String.t()) :: String.t()
   def build_digest(body) do
     "SHA-256=#{:sha256 |> :crypto.hash(body) |> Base.encode64()}"
   end
diff --git a/lib/federation/web_finger/web_finger.ex b/lib/federation/web_finger/web_finger.ex
index 1eddb189b..65790eb25 100644
--- a/lib/federation/web_finger/web_finger.ex
+++ b/lib/federation/web_finger/web_finger.ex
@@ -19,11 +19,15 @@ defmodule Mobilizon.Federation.WebFinger do
   require Logger
   import SweetXml
 
+  @doc """
+  Returns the Web Host Metadata (for `/.well-known/host-meta`) representation for the instance, following RFC6414.
+  """
+  @spec host_meta :: String.t()
   def host_meta do
     base_url = Endpoint.url()
     %URI{host: host} = URI.parse(base_url)
 
-    {
+    XmlBuilder.to_doc({
       :XRD,
       %{
         xmlns: "http://docs.oasis-open.org/ns/xri/xrd-1.0",
@@ -43,10 +47,13 @@ defmodule Mobilizon.Federation.WebFinger do
           }
         }
       ]
-    }
-    |> XmlBuilder.to_doc()
+    })
   end
 
+  @doc """
+  Returns the Webfinger representation for the instance, following RFC7033.
+  """
+  @spec webfinger(String.t(), String.t()) :: {:ok, map} | {:error, :actor_not_found}
   def webfinger(resource, "JSON") do
     host = Endpoint.host()
     regex = ~r/(acct:)?(?<name>\w+)@#{host}/
@@ -61,15 +68,18 @@ defmodule Mobilizon.Federation.WebFinger do
             {:ok, represent_actor(actor, "JSON")}
 
           _e ->
-            {:error, "Couldn't find actor"}
+            {:error, :actor_not_found}
         end
     end
   end
 
-  @spec represent_actor(Actor.t()) :: struct()
+  @doc """
+  Return an `Mobilizon.Actors.Actor` Webfinger representation (as JSON)
+  """
+  @spec represent_actor(Actor.t()) :: map()
+  @spec represent_actor(Actor.t(), String.t()) :: map()
   def represent_actor(%Actor{} = actor), do: represent_actor(actor, "JSON")
 
-  @spec represent_actor(Actor.t(), String.t()) :: struct()
   def represent_actor(%Actor{} = actor, "JSON") do
     links =
       [
@@ -89,6 +99,7 @@ defmodule Mobilizon.Federation.WebFinger do
     }
   end
 
+  @spec maybe_add_avatar(list(map()), Actor.t()) :: list(map())
   defp maybe_add_avatar(data, %Actor{avatar: avatar}) when not is_nil(avatar) do
     data ++
       [
@@ -102,6 +113,7 @@ defmodule Mobilizon.Federation.WebFinger do
 
   defp maybe_add_avatar(data, _actor), do: data
 
+  @spec maybe_add_profile_page(list(map()), Actor.t()) :: list(map())
   defp maybe_add_profile_page(data, %Actor{type: :Group, url: url}) do
     data ++
       [
@@ -115,37 +127,76 @@ defmodule Mobilizon.Federation.WebFinger do
 
   defp maybe_add_profile_page(data, _actor), do: data
 
+  @type finger_errors ::
+          :host_not_found | :address_invalid | :http_error | :webfinger_information_not_json
+
   @doc """
   Finger an actor to retreive it's ActivityPub ID/URL
 
-  Fetches the Extensible Resource Descriptor endpoint `/.well-known/host-meta` to find the Webfinger endpoint (usually `/.well-known/webfinger?resource=`) with `find_webfinger_endpoint/1` and then performs a Webfinger query to get the ActivityPub ID associated to an actor.
+  Fetches the Extensible Resource Descriptor endpoint `/.well-known/host-meta` to find the Webfinger endpoint (usually `/.well-known/webfinger?resource=`) and then performs a Webfinger query to get the ActivityPub ID associated to an actor.
   """
-  @spec finger(String.t()) :: {:ok, String.t()} | {:error, atom()}
+  @spec finger(String.t()) ::
+          {:ok, String.t()}
+          | {:error, finger_errors}
   def finger(actor) do
     actor = String.trim_leading(actor, "@")
 
-    with address when is_binary(address) <- apply_webfinger_endpoint(actor),
-         false <- address_invalid(address),
-         {:ok, %{body: body, status: code}} when code in 200..299 <-
-           WebfingerClient.get(address),
-         {:ok, %{"url" => url}} <- webfinger_from_json(body) do
-      {:ok, url}
-    else
-      e ->
-        Logger.debug("Couldn't finger #{actor}")
-        Logger.debug(inspect(e))
-        {:error, e}
+    case validate_endpoint(actor) do
+      {:ok, address} ->
+        case fetch_webfinger_data(address) do
+          {:ok, %{"url" => url}} ->
+            {:ok, url}
+
+          {:error, err} ->
+            Logger.debug("Couldn't process webfinger data for #{actor}")
+            {:error, err}
+        end
+
+      {:error, err} ->
+        Logger.debug("Couldn't find webfinger endpoint for #{actor}")
+        {:error, err}
     end
   end
 
-  @doc """
-  Fetches the Extensible Resource Descriptor endpoint `/.well-known/host-meta` to find the Webfinger endpoint (usually `/.well-known/webfinger?resource=`)
-  """
-  @spec find_webfinger_endpoint(String.t()) :: String.t()
-  def find_webfinger_endpoint(domain) when is_binary(domain) do
+  @spec fetch_webfinger_data(String.t()) ::
+          {:ok, map()} | {:error, :webfinger_information_not_json | :http_error}
+  defp fetch_webfinger_data(address) do
+    case WebfingerClient.get(address) do
+      {:ok, %{body: body, status: code}} when code in 200..299 ->
+        webfinger_from_json(body)
+
+      _ ->
+        {:error, :http_error}
+    end
+  end
+
+  @spec validate_endpoint(String.t()) ::
+          {:ok, String.t()} | {:error, :address_invalid | :host_not_found}
+  defp validate_endpoint(actor) do
+    case apply_webfinger_endpoint(actor) do
+      address when is_binary(address) ->
+        if address_invalid(address) do
+          {:error, :address_invalid}
+        else
+          {:ok, address}
+        end
+
+      _ ->
+        {:error, :host_not_found}
+    end
+  end
+
+  # Fetches the Extensible Resource Descriptor endpoint `/.well-known/host-meta`
+  # to find the Webfinger endpoint (usually `/.well-known/webfinger?resource=`)
+  @spec find_webfinger_endpoint(String.t()) ::
+          {:ok, String.t()} | {:error, :link_not_found} | {:error, any()}
+  defp find_webfinger_endpoint(domain) when is_binary(domain) do
     with {:ok, %{body: body}} <- fetch_document("http://#{domain}/.well-known/host-meta"),
          link_template when is_binary(link_template) <- find_link_from_template(body) do
       {:ok, link_template}
+    else
+      {:error, :link_not_found} -> {:error, :link_not_found}
+      {:error, error} -> {:error, error}
     end
   end
 
diff --git a/lib/federation/web_finger/xml_builder.ex b/lib/federation/web_finger/xml_builder.ex
index 76cc2cbea..a45df0dde 100644
--- a/lib/federation/web_finger/xml_builder.ex
+++ b/lib/federation/web_finger/xml_builder.ex
@@ -5,42 +5,54 @@
 
 defmodule Mobilizon.Federation.WebFinger.XmlBuilder do
   @moduledoc """
-  Builds XRD for WebFinger host_meta.
+  Extremely basic XML encoder. Builds XRD for WebFinger host_meta.
   """
 
-  def to_xml({tag, attributes, content}) do
+  @typep content :: list({tag :: atom(), attributes :: map()}) | String.t()
+  @typep document :: {tag :: atom(), attributes :: map(), content :: content}
+
+  @doc """
+  Return the XML representation for a document.
+  """
+  @spec to_doc(document :: document) :: String.t()
+  def to_doc(document), do: ~s(<?xml version="1.0" encoding="UTF-8"?>) <> to_xml(document)
+
+  @spec to_xml(document) :: String.t()
+  @spec to_xml({tag :: atom(), attributes :: map()}) :: String.t()
+  @spec to_xml({tag :: atom(), content :: content}) :: String.t()
+  @spec to_xml(content :: content) :: String.t()
+  defp to_xml({tag, attributes, content}) do
     open_tag = make_open_tag(tag, attributes)
     content_xml = to_xml(content)
 
     "<#{open_tag}>#{content_xml}</#{tag}>"
   end
 
-  def to_xml({tag, %{} = attributes}) do
+  defp to_xml({tag, %{} = attributes}) do
     open_tag = make_open_tag(tag, attributes)
 
     "<#{open_tag} />"
   end
 
-  def to_xml({tag, content}), do: to_xml({tag, %{}, content})
+  defp to_xml({tag, content}), do: to_xml({tag, %{}, content})
 
-  def to_xml(content) when is_binary(content), do: to_string(content)
+  defp to_xml(content) when is_binary(content), do: to_string(content)
 
-  def to_xml(content) when is_list(content) do
+  defp to_xml(content) when is_list(content) do
     content
     |> Enum.map(&to_xml/1)
     |> Enum.join()
   end
 
-  def to_xml(%NaiveDateTime{} = time), do: NaiveDateTime.to_iso8601(time)
-
-  def to_doc(content), do: ~s(<?xml version="1.0" encoding="UTF-8"?>) <> to_xml(content)
+  defp to_xml(%NaiveDateTime{} = time), do: NaiveDateTime.to_iso8601(time)
 
+  @spec make_open_tag(tag :: atom, attributes :: map()) :: String.t()
   defp make_open_tag(tag, attributes) do
     attributes_string =
       attributes
       |> Enum.map(fn {attribute, value} -> "#{attribute}=\"#{value}\"" end)
       |> Enum.join(" ")
 
-    [tag, attributes_string] |> Enum.join(" ") |> String.trim()
+    [to_string(tag), attributes_string] |> Enum.join(" ") |> String.trim()
   end
 end
diff --git a/lib/graphql/api/comments.ex b/lib/graphql/api/comments.ex
index 9b7b659b0..f8dd17b5b 100644
--- a/lib/graphql/api/comments.ex
+++ b/lib/graphql/api/comments.ex
@@ -5,8 +5,7 @@ defmodule Mobilizon.GraphQL.API.Comments do
 
   alias Mobilizon.Actors.Actor
   alias Mobilizon.Discussions.Comment
-  alias Mobilizon.Federation.ActivityPub
-  alias Mobilizon.Federation.ActivityPub.Activity
+  alias Mobilizon.Federation.ActivityPub.{Actions, Activity}
   alias Mobilizon.GraphQL.API.Utils
 
   @doc """
@@ -15,7 +14,7 @@ defmodule Mobilizon.GraphQL.API.Comments do
   @spec create_comment(map) :: {:ok, Activity.t(), Comment.t()} | any
   def create_comment(args) do
     args = extract_pictures_from_comment_body(args)
-    ActivityPub.create(:comment, args, true)
+    Actions.Create.create(:comment, args, true)
   end
 
   @doc """
@@ -24,7 +23,7 @@ defmodule Mobilizon.GraphQL.API.Comments do
   @spec update_comment(Comment.t(), map()) :: {:ok, Activity.t(), Comment.t()} | any
   def update_comment(%Comment{} = comment, args) do
     args = extract_pictures_from_comment_body(args)
-    ActivityPub.update(comment, args, true)
+    Actions.Update.update(comment, args, true)
   end
 
   @doc """
@@ -32,7 +31,7 @@ defmodule Mobilizon.GraphQL.API.Comments do
   """
   @spec delete_comment(Comment.t(), Actor.t()) :: {:ok, Activity.t(), Comment.t()} | any
   def delete_comment(%Comment{} = comment, %Actor{} = actor) do
-    ActivityPub.delete(comment, actor, true)
+    Actions.Delete.delete(comment, actor, true)
   end
 
   @doc """
@@ -42,7 +41,7 @@ defmodule Mobilizon.GraphQL.API.Comments do
   def create_discussion(args) do
     args = extract_pictures_from_comment_body(args)
 
-    ActivityPub.create(
+    Actions.Create.create(
       :discussion,
       args,
       true
diff --git a/lib/graphql/api/events.ex b/lib/graphql/api/events.ex
index 5e7e5bf2c..d71a37f48 100644
--- a/lib/graphql/api/events.ex
+++ b/lib/graphql/api/events.ex
@@ -6,8 +6,7 @@ defmodule Mobilizon.GraphQL.API.Events do
   alias Mobilizon.Actors.Actor
   alias Mobilizon.Events.Event
 
-  alias Mobilizon.Federation.ActivityPub
-  alias Mobilizon.Federation.ActivityPub.{Activity, Utils}
+  alias Mobilizon.Federation.ActivityPub.{Actions, Activity, Utils}
   alias Mobilizon.GraphQL.API.Utils, as: APIUtils
 
   @doc """
@@ -15,15 +14,8 @@ defmodule Mobilizon.GraphQL.API.Events do
   """
   @spec create_event(map) :: {:ok, Activity.t(), Event.t()} | any
   def create_event(args) do
-    with organizer_actor <- Map.get(args, :organizer_actor),
-         args <- extract_pictures_from_event_body(args, organizer_actor),
-         args <-
-           Map.update(args, :picture, nil, fn picture ->
-             process_picture(picture, organizer_actor)
-           end) do
-      # For now we don't federate drafts but it will be needed if we want to edit them as groups
-      ActivityPub.create(:event, args, should_federate(args))
-    end
+    # For now we don't federate drafts but it will be needed if we want to edit them as groups
+    Actions.Create.create(:event, prepare_args(args), should_federate(args))
   end
 
   @doc """
@@ -31,21 +23,26 @@ defmodule Mobilizon.GraphQL.API.Events do
   """
   @spec update_event(map, Event.t()) :: {:ok, Activity.t(), Event.t()} | any
   def update_event(args, %Event{} = event) do
-    with organizer_actor <- Map.get(args, :organizer_actor),
-         args <- extract_pictures_from_event_body(args, organizer_actor),
-         args <-
-           Map.update(args, :picture, nil, fn picture ->
-             process_picture(picture, organizer_actor)
-           end) do
-      ActivityPub.update(event, args, should_federate(args))
-    end
+    Actions.Update.update(event, prepare_args(args), should_federate(args))
   end
 
   @doc """
   Trigger the deletion of an event
   """
+  @spec delete_event(Event.t(), Actor.t(), boolean()) :: {:ok, Activity.t(), Entity.t()} | any()
   def delete_event(%Event{} = event, %Actor{} = actor, federate \\ true) do
-    ActivityPub.delete(event, actor, federate)
+    Actions.Delete.delete(event, actor, federate)
+  end
+
+  @spec prepare_args(map) :: map
+  defp prepare_args(args) do
+    organizer_actor = Map.get(args, :organizer_actor)
+
+    args
+    |> extract_pictures_from_event_body(organizer_actor)
+    |> Map.update(:picture, nil, fn picture ->
+      process_picture(picture, organizer_actor)
+    end)
   end
 
   defp process_picture(nil, _), do: nil
@@ -75,6 +72,7 @@ defmodule Mobilizon.GraphQL.API.Events do
 
   defp extract_pictures_from_event_body(args, _), do: args
 
+  @spec should_federate(map()) :: boolean
   defp should_federate(%{attributed_to_id: attributed_to_id}) when not is_nil(attributed_to_id),
     do: true
 
diff --git a/lib/graphql/api/follows.ex b/lib/graphql/api/follows.ex
index b47cb75f1..0f75f7e83 100644
--- a/lib/graphql/api/follows.ex
+++ b/lib/graphql/api/follows.ex
@@ -6,73 +6,81 @@ defmodule Mobilizon.GraphQL.API.Follows do
   alias Mobilizon.Actors
   alias Mobilizon.Actors.{Actor, Follower}
 
-  alias Mobilizon.Federation.ActivityPub
-  alias Mobilizon.Federation.ActivityPub.Activity
+  alias Mobilizon.Federation.ActivityPub.{Actions, Activity}
 
   require Logger
 
+  @doc """
+  Make an actor (`follower`) follow another (`followed`).
+  """
+  @spec follow(follower :: Actor.t(), followed :: Actor.t()) ::
+          {:ok, Activity.t(), Mobilizon.Actors.Follower.t()}
+          | {:error, String.t()}
   def follow(%Actor{} = follower, %Actor{} = followed) do
-    case ActivityPub.follow(follower, followed) do
-      {:ok, activity, follow} ->
-        {:ok, activity, follow}
-
-      {:error, e} ->
-        Logger.warn("Error while following actor: #{inspect(e)}")
-        {:error, e}
-
-      e ->
-        Logger.warn("Error while following actor: #{inspect(e)}")
-        {:error, e}
-    end
+    Actions.Follow.follow(follower, followed)
   end
 
+  @doc """
+  Make an actor (`follower`) unfollow another (`followed`).
+  """
+  @spec unfollow(follower :: Actor.t(), followed :: Actor.t()) ::
+          {:ok, Activity.t(), Mobilizon.Actors.Follower.t()}
+          | {:error, String.t()}
   def unfollow(%Actor{} = follower, %Actor{} = followed) do
-    case ActivityPub.unfollow(follower, followed) do
-      {:ok, activity, follow} ->
-        {:ok, activity, follow}
-
-      e ->
-        Logger.warn("Error while unfollowing actor: #{inspect(e)}")
-        {:error, e}
-    end
+    Actions.Follow.unfollow(follower, followed)
   end
 
-  def accept(%Actor{} = follower, %Actor{} = followed) do
-    Logger.debug("We're trying to accept a follow")
+  @doc """
+  Make an actor (`followed`) accept the follow from another (`follower`).
+  """
+  @spec accept(follower :: Actor.t(), followed :: Actor.t()) ::
+          {:ok, Activity.t(), Mobilizon.Actors.Follower.t()}
+          | {:error, String.t()}
+  def accept(%Actor{url: follower_url} = follower, %Actor{url: followed_url} = followed) do
+    Logger.debug(
+      "We're trying to accept a follow: #{followed_url} is accepting #{follower_url} follow request."
+    )
+
+    case Actors.is_following(follower, followed) do
+      %Follower{approved: false} = follow ->
+        Actions.Accept.accept(
+          :follow,
+          follow,
+          true
+        )
 
-    with %Follower{approved: false} = follow <-
-           Actors.is_following(follower, followed),
-         {:ok, %Activity{} = activity, %Follower{approved: true} = follow} <-
-           ActivityPub.accept(
-             :follow,
-             follow,
-             true
-           ) do
-      {:ok, activity, follow}
-    else
       %Follower{approved: true} ->
         {:error, "Follow already accepted"}
+
+      nil ->
+        {:error, "Can't accept follow: #{follower_url} is not following #{followed_url}."}
     end
   end
 
-  def reject(%Actor{} = follower, %Actor{} = followed) do
-    Logger.debug("We're trying to reject a follow")
+  @doc """
+  Make an actor (`followed`) reject the follow from another (`follower`).
+  """
+  @spec reject(follower :: Actor.t(), followed :: Actor.t()) ::
+          {:ok, Activity.t(), Mobilizon.Actors.Follower.t()}
+          | {:error, String.t()}
+  def reject(%Actor{url: follower_url} = follower, %Actor{url: followed_url} = followed) do
+    Logger.debug(
+      "We're trying to reject a follow: #{followed_url} is rejecting #{follower_url} follow request."
+    )
 
-    with {:follower, %Follower{} = follow} <-
-           {:follower, Actors.is_following(follower, followed)},
-         {:ok, %Activity{} = activity, %Follower{} = follow} <-
-           ActivityPub.reject(
-             :follow,
-             follow,
-             true
-           ) do
-      {:ok, activity, follow}
-    else
-      {:follower, nil} ->
-        {:error, "Follow not found"}
-
-      {:follower, %Follower{approved: true}} ->
+    case Actors.is_following(follower, followed) do
+      %Follower{approved: true} ->
         {:error, "Follow already accepted"}
+
+      %Follower{} = follow ->
+        Actions.Reject.reject(
+          :follow,
+          follow,
+          true
+        )
+
+      nil ->
+        {:error, "Follow not found"}
     end
   end
 end
diff --git a/lib/graphql/api/groups.ex b/lib/graphql/api/groups.ex
index c8c9a1658..28919d5d9 100644
--- a/lib/graphql/api/groups.ex
+++ b/lib/graphql/api/groups.ex
@@ -6,39 +6,35 @@ defmodule Mobilizon.GraphQL.API.Groups do
   alias Mobilizon.Actors
   alias Mobilizon.Actors.Actor
 
-  alias Mobilizon.Federation.ActivityPub
-  alias Mobilizon.Federation.ActivityPub.Activity
+  alias Mobilizon.Federation.ActivityPub.{Actions, Activity}
   alias Mobilizon.Service.Formatter.HTML
 
   @doc """
   Create a group
   """
-  @spec create_group(map) :: {:ok, Activity.t(), Actor.t()} | any
+  @spec create_group(map) ::
+          {:ok, Activity.t(), Actor.t()}
+          | {:error, String.t() | Ecto.Changeset.t()}
   def create_group(args) do
-    with preferred_username <-
-           args |> Map.get(:preferred_username) |> HTML.strip_tags() |> String.trim(),
-         {:existing_group, nil} <-
-           {:existing_group, Actors.get_local_actor_by_name(preferred_username)},
-         args <- args |> Map.put(:type, :Group),
-         {:ok, %Activity{} = activity, %Actor{} = group} <-
-           ActivityPub.create(:actor, args, true, %{"actor" => args.creator_actor.url}) do
-      {:ok, activity, group}
-    else
-      {:existing_group, _} ->
-        {:error, "A group with this name already exists"}
+    preferred_username =
+      args |> Map.get(:preferred_username) |> HTML.strip_tags() |> String.trim()
+
+    args = args |> Map.put(:type, :Group)
+
+    case Actors.get_local_actor_by_name(preferred_username) do
+      nil ->
+        Actions.Create.create(:actor, args, true, %{"actor" => args.creator_actor.url})
+
+      %Actor{} ->
+        {:error, "A profile or group with that name already exists"}
     end
   end
 
-  @spec create_group(map) :: {:ok, Activity.t(), Actor.t()} | any
+  @spec update_group(map) ::
+          {:ok, Activity.t(), Actor.t()} | {:error, :group_not_found | Ecto.Changeset.t()}
   def update_group(%{id: id} = args) do
-    with {:existing_group, {:ok, %Actor{type: :Group} = group}} <-
-           {:existing_group, Actors.get_group_by_actor_id(id)},
-         {:ok, %Activity{} = activity, %Actor{} = group} <-
-           ActivityPub.update(group, args, true, %{"actor" => args.updater_actor.url}) do
-      {:ok, activity, group}
-    else
-      {:existing_group, _} ->
-        {:error, "A group with this name already exists"}
+    with {:ok, %Actor{type: :Group} = group} <- Actors.get_group_by_actor_id(id) do
+      Actions.Update.update(group, args, true, %{"actor" => args.updater_actor.url})
     end
   end
 end
diff --git a/lib/graphql/api/participations.ex b/lib/graphql/api/participations.ex
index 55ce95c11..5b2325d5d 100644
--- a/lib/graphql/api/participations.ex
+++ b/lib/graphql/api/participations.ex
@@ -6,28 +6,27 @@ defmodule Mobilizon.GraphQL.API.Participations do
   alias Mobilizon.Actors.Actor
   alias Mobilizon.Events
   alias Mobilizon.Events.{Event, Participant}
-  alias Mobilizon.Federation.ActivityPub
-  alias Mobilizon.Federation.ActivityPub.Activity
+  alias Mobilizon.Federation.ActivityPub.{Actions, Activity}
   alias Mobilizon.Service.Notifications.Scheduler
   alias Mobilizon.Web.Email.Participation
 
-  @spec join(Event.t(), Actor.t(), map()) :: {:ok, Activity.t(), Participant.t()}
+  @spec join(Event.t(), Actor.t(), map()) ::
+          {:ok, Activity.t(), Participant.t()} | {:error, :already_participant}
   def join(%Event{id: event_id} = event, %Actor{id: actor_id} = actor, args \\ %{}) do
-    with {:error, :participant_not_found} <-
-           Mobilizon.Events.get_participant(event_id, actor_id, args),
-         {:ok, activity, participant} <-
-           ActivityPub.join(event, actor, Map.get(args, :local, true), %{metadata: args}) do
-      {:ok, activity, participant}
+    case Mobilizon.Events.get_participant(event_id, actor_id, args) do
+      {:ok, %Participant{}} ->
+        {:error, :already_participant}
+
+      {:error, :participant_not_found} ->
+        Actions.Join.join(event, actor, Map.get(args, :local, true), %{metadata: args})
     end
   end
 
-  @spec leave(Event.t(), Actor.t()) :: {:ok, Activity.t(), Participant.t()}
-  def leave(%Event{} = event, %Actor{} = actor, args \\ %{}) do
-    with {:ok, activity, participant} <-
-           ActivityPub.leave(event, actor, Map.get(args, :local, true), %{metadata: args}) do
-      {:ok, activity, participant}
-    end
-  end
+  @spec leave(Event.t(), Actor.t(), map()) ::
+          {:ok, Activity.t(), Participant.t()}
+          | {:error, :is_only_organizer | :participant_not_found | Ecto.Changeset.t()}
+  def leave(%Event{} = event, %Actor{} = actor, args \\ %{}),
+    do: Actions.Leave.leave(event, actor, Map.get(args, :local, true), %{metadata: args})
 
   @doc """
   Update participation status
@@ -36,7 +35,6 @@ defmodule Mobilizon.GraphQL.API.Participations do
   def update(%Participant{} = participation, %Actor{} = moderator, :participant),
     do: accept(participation, moderator)
 
-  @spec update(Participant.t(), Actor.t(), atom()) :: {:ok, Activity.t(), Participant.t()}
   def update(%Participant{} = participation, %Actor{} = _moderator, :not_approved) do
     with {:ok, %Participant{} = participant} <-
            Events.update_participant(participation, %{role: :not_approved}) do
@@ -45,7 +43,6 @@ defmodule Mobilizon.GraphQL.API.Participations do
     end
   end
 
-  @spec update(Participant.t(), Actor.t(), atom()) :: {:ok, Activity.t(), Participant.t()}
   def update(%Participant{} = participation, %Actor{} = moderator, :rejected),
     do: reject(participation, moderator)
 
@@ -54,15 +51,18 @@ defmodule Mobilizon.GraphQL.API.Participations do
          %Participant{} = participation,
          %Actor{} = moderator
        ) do
-    with {:ok, activity, %Participant{role: :participant} = participation} <-
-           ActivityPub.accept(
-             :join,
-             participation,
-             true,
-             %{"actor" => moderator.url}
-           ),
-         :ok <- Participation.send_emails_to_local_user(participation) do
-      {:ok, activity, participation}
+    case Actions.Accept.accept(
+           :join,
+           participation,
+           true,
+           %{"actor" => moderator.url}
+         ) do
+      {:ok, activity, %Participant{role: :participant} = participation} ->
+        Participation.send_emails_to_local_user(participation)
+        {:ok, activity, participation}
+
+      {:error, err} ->
+        {:error, err}
     end
   end
 
@@ -72,7 +72,7 @@ defmodule Mobilizon.GraphQL.API.Participations do
          %Actor{} = moderator
        ) do
     with {:ok, activity, %Participant{role: :rejected} = participation} <-
-           ActivityPub.reject(
+           Actions.Reject.reject(
              :join,
              participation,
              true,
diff --git a/lib/graphql/api/reports.ex b/lib/graphql/api/reports.ex
index e56547654..c418594b3 100644
--- a/lib/graphql/api/reports.ex
+++ b/lib/graphql/api/reports.ex
@@ -9,82 +9,82 @@ defmodule Mobilizon.GraphQL.API.Reports do
   alias Mobilizon.Reports.{Note, Report, ReportStatus}
   alias Mobilizon.Users.User
 
-  alias Mobilizon.Federation.ActivityPub
-  alias Mobilizon.Federation.ActivityPub.Activity
+  alias Mobilizon.Federation.ActivityPub.{Actions, Activity}
 
   @doc """
   Create a report/flag on an actor, and optionally on an event or on comments.
   """
+  @spec report(map()) :: {:ok, Activity.t(), Report.t()} | {:error, Ecto.Changeset.t()}
   def report(args) do
-    case {:make_activity, ActivityPub.flag(args, Map.get(args, :forward, false) == true)} do
-      {:make_activity, {:ok, %Activity{} = activity, %Report{} = report}} ->
-        {:ok, activity, report}
-
-      {:make_activity, err} ->
-        {:error, err}
-    end
+    Actions.Flag.flag(args, Map.get(args, :forward, false) == true)
   end
 
   @doc """
   Update the state of a report
   """
+  @spec update_report_status(Actor.t(), Report.t(), ReportStatus.t()) ::
+          {:ok, Report.t()} | {:error, Ecto.Changeset.t() | String.t()}
   def update_report_status(%Actor{} = actor, %Report{} = report, state) do
-    with {:valid_state, true} <-
-           {:valid_state, ReportStatus.valid_value?(state)},
-         {:ok, report} <- ReportsAction.update_report(report, %{"status" => state}),
-         {:ok, _} <- Admin.log_action(actor, "update", report) do
-      {:ok, report}
+    if ReportStatus.valid_value?(state) do
+      with {:ok, %Report{} = report} <- ReportsAction.update_report(report, %{"status" => state}) do
+        Admin.log_action(actor, "update", report)
+        {:ok, report}
+      end
     else
-      {:valid_state, false} -> {:error, "Unsupported state"}
+      {:error, "Unsupported state"}
     end
   end
 
   @doc """
   Create a note on a report
   """
-  @spec create_report_note(Report.t(), Actor.t(), String.t()) :: {:ok, Note.t()}
+  @spec create_report_note(Report.t(), Actor.t(), String.t()) ::
+          {:ok, Note.t()} | {:error, String.t() | Ecto.Changeset.t()}
   def create_report_note(
         %Report{id: report_id},
         %Actor{id: moderator_id, user_id: user_id} = moderator,
         content
       ) do
-    with %User{role: role} <- Users.get_user!(user_id),
-         {:role, true} <- {:role, role in [:administrator, :moderator]},
-         {:ok, %Note{} = note} <-
-           Mobilizon.Reports.create_note(%{
-             "report_id" => report_id,
-             "moderator_id" => moderator_id,
-             "content" => content
-           }),
-         {:ok, _} <- Admin.log_action(moderator, "create", note) do
-      {:ok, note}
+    %User{role: role} = Users.get_user!(user_id)
+
+    if role in [:administrator, :moderator] do
+      with {:ok, %Note{} = note} <-
+             Mobilizon.Reports.create_note(%{
+               "report_id" => report_id,
+               "moderator_id" => moderator_id,
+               "content" => content
+             }),
+           {:ok, _} <- Admin.log_action(moderator, "create", note) do
+        {:ok, note}
+      end
     else
-      {:role, false} ->
-        {:error, "You need to be a moderator or an administrator to create a note on a report"}
+      {:error, "You need to be a moderator or an administrator to create a note on a report"}
     end
   end
 
   @doc """
   Delete a report note
   """
-  @spec delete_report_note(Note.t(), Actor.t()) :: {:ok, Note.t()}
+  @spec delete_report_note(Note.t(), Actor.t()) ::
+          {:ok, Note.t()} | {:error, Ecto.Changeset.t() | String.t()}
   def delete_report_note(
         %Note{moderator_id: note_moderator_id} = note,
         %Actor{id: moderator_id, user_id: user_id} = moderator
       ) do
-    with {:same_actor, true} <- {:same_actor, note_moderator_id == moderator_id},
-         %User{role: role} <- Users.get_user!(user_id),
-         {:role, true} <- {:role, role in [:administrator, :moderator]},
-         {:ok, %Note{} = note} <-
-           Mobilizon.Reports.delete_note(note),
-         {:ok, _} <- Admin.log_action(moderator, "delete", note) do
-      {:ok, note}
-    else
-      {:role, false} ->
-        {:error, "You need to be a moderator or an administrator to create a note on a report"}
+    if note_moderator_id == moderator_id do
+      %User{role: role} = Users.get_user!(user_id)
 
-      {:same_actor, false} ->
-        {:error, "You can only remove your own notes"}
+      if role in [:administrator, :moderator] do
+        with {:ok, %Note{} = note} <-
+               Mobilizon.Reports.delete_note(note),
+             {:ok, _} <- Admin.log_action(moderator, "delete", note) do
+          {:ok, note}
+        end
+      else
+        {:error, "You need to be a moderator or an administrator to create a note on a report"}
+      end
+    else
+      {:error, "You can only remove your own notes"}
     end
   end
 end
diff --git a/lib/graphql/api/search.ex b/lib/graphql/api/search.ex
index f5b342256..6252cb04e 100644
--- a/lib/graphql/api/search.ex
+++ b/lib/graphql/api/search.ex
@@ -59,8 +59,8 @@ defmodule Mobilizon.GraphQL.API.Search do
   @doc """
   Search events
   """
-  @spec search_events(String.t(), integer | nil, integer | nil) ::
-          {:ok, Page.t()} | {:error, String.t()}
+  @spec search_events(map(), integer | nil, integer | nil) ::
+          {:ok, Page.t()}
   def search_events(%{term: term} = args, page \\ 1, limit \\ 10) do
     term = String.trim(term)
 
@@ -78,6 +78,7 @@ defmodule Mobilizon.GraphQL.API.Search do
     end
   end
 
+  @spec interact(String.t()) :: {:ok, struct()} | {:error, :not_found}
   def interact(uri) do
     case ActivityPub.fetch_object_from_url(uri) do
       {:ok, object} ->
diff --git a/lib/graphql/api/utils.ex b/lib/graphql/api/utils.ex
index e15b0e0b9..1effea583 100644
--- a/lib/graphql/api/utils.ex
+++ b/lib/graphql/api/utils.ex
@@ -10,7 +10,7 @@ defmodule Mobilizon.GraphQL.API.Utils do
   @doc """
   Creates HTML content from text and mentions
   """
-  @spec make_content_html(String.t(), list(), String.t()) :: String.t()
+  @spec make_content_html(String.t(), list(), String.t()) :: {String.t(), list(), list()}
   def make_content_html(text, additional_tags, content_type) do
     with {text, mentions, tags} <- format_input(text, content_type, []) do
       {text, mentions, additional_tags ++ Enum.map(tags, fn {_, tag} -> tag end)}
diff --git a/lib/graphql/error.ex b/lib/graphql/error.ex
index e6b87b2c8..561567c5b 100644
--- a/lib/graphql/error.ex
+++ b/lib/graphql/error.ex
@@ -8,11 +8,19 @@ defmodule Mobilizon.GraphQL.Error do
   alias Mobilizon.Web.Gettext, as: GettextBackend
   import Mobilizon.Web.Gettext, only: [dgettext: 2]
 
+  @type t :: %{code: atom(), message: String.t(), status_code: pos_integer(), field: atom()}
+
   defstruct [:code, :message, :status_code, :field]
 
+  @type error :: {:error, any()} | {:error, any(), any(), any()} | atom()
+
+  @doc """
+  Normalize an error to return `t`.
+  """
   # Error Tuples
   # ------------
   # Regular errors
+  @spec normalize(error | list(error) | String.t() | any()) :: t()
   def normalize({:error, reason}) do
     handle(reason)
   end
diff --git a/lib/graphql/middleware/current_actor_provider.ex b/lib/graphql/middleware/current_actor_provider.ex
new file mode 100644
index 000000000..d34eb2a9e
--- /dev/null
+++ b/lib/graphql/middleware/current_actor_provider.ex
@@ -0,0 +1,40 @@
+defmodule Mobilizon.GraphQL.Middleware.CurrentActorProvider do
+  @moduledoc """
+  Absinthe Error Handler
+  """
+  alias Mobilizon.Actors.Actor
+  alias Mobilizon.Users
+  alias Mobilizon.Users.User
+
+  @behaviour Absinthe.Middleware
+
+  @impl Absinthe.Middleware
+  @spec call(Absinthe.Resolution.t(), any) :: Absinthe.Resolution.t()
+  def call(
+        %Absinthe.Resolution{context: %{current_user: %User{id: user_id} = user} = context} =
+          resolution,
+        _config
+      ) do
+    case Cachex.fetch(:default_actors, to_string(user_id), fn -> default(user) end) do
+      {status, %Actor{} = current_actor} when status in [:ok, :commit] ->
+        context = Map.put(context, :current_actor, current_actor)
+        %Absinthe.Resolution{resolution | context: context}
+
+      {_, nil} ->
+        resolution
+    end
+  end
+
+  def call(%Absinthe.Resolution{} = resolution, _config), do: resolution
+
+  @spec default(User.t()) :: {:commit, Actor.t()} | {:ignore, nil}
+  defp default(%User{} = user) do
+    case Users.get_actor_for_user(user) do
+      %Actor{} = actor ->
+        {:commit, actor}
+
+      nil ->
+        {:ignore, nil}
+    end
+  end
+end
diff --git a/lib/graphql/resolvers/activity.ex b/lib/graphql/resolvers/activity.ex
index 7184fd573..56d5b7adf 100644
--- a/lib/graphql/resolvers/activity.ex
+++ b/lib/graphql/resolvers/activity.ex
@@ -4,7 +4,8 @@ defmodule Mobilizon.GraphQL.Resolvers.Activity do
   """
 
   import Mobilizon.Users.Guards
-  alias Mobilizon.{Activities, Actors, Users}
+  alias Mobilizon.{Activities, Actors}
+  alias Mobilizon.Activities.Activity
   alias Mobilizon.Actors.Actor
   alias Mobilizon.Service.Activity.Utils
   alias Mobilizon.Storage.Page
@@ -12,11 +13,12 @@ defmodule Mobilizon.GraphQL.Resolvers.Activity do
 
   require Logger
 
+  @spec group_activity(Actor.t(), map(), Absinthe.Resolution.t()) ::
+          {:ok, Page.t(Activity.t())} | {:error, :unauthorized | :unauthenticated}
   def group_activity(%Actor{type: :Group, id: group_id}, %{page: page, limit: limit} = args, %{
-        context: %{current_user: %User{role: role} = user}
+        context: %{current_user: %User{role: role}, current_actor: %Actor{id: actor_id}}
       }) do
-    with {:actor, %Actor{id: actor_id} = _actor} <- {:actor, Users.get_actor_for_user(user)},
-         {:member, true} <- {:member, Actors.is_member?(actor_id, group_id) or is_moderator(role)} do
+    if Actors.is_member?(actor_id, group_id) or is_moderator(role) do
       %Page{total: total, elements: elements} =
         Activities.list_group_activities_for_member(
           group_id,
@@ -30,8 +32,7 @@ defmodule Mobilizon.GraphQL.Resolvers.Activity do
 
       {:ok, %Page{total: total, elements: elements}}
     else
-      {:member, false} ->
-        {:error, :unauthorized}
+      {:error, :unauthorized}
     end
   end
 
diff --git a/lib/graphql/resolvers/actor.ex b/lib/graphql/resolvers/actor.ex
index c1279d9b9..b8b91321f 100644
--- a/lib/graphql/resolvers/actor.ex
+++ b/lib/graphql/resolvers/actor.ex
@@ -4,15 +4,17 @@ defmodule Mobilizon.GraphQL.Resolvers.Actor do
   """
 
   import Mobilizon.Users.Guards
-  alias Mobilizon.{Actors, Admin, Users}
+  alias Mobilizon.{Actors, Admin}
   alias Mobilizon.Actors.Actor
-  alias Mobilizon.Federation.ActivityPub
+  alias Mobilizon.Federation.ActivityPub.Actions
   alias Mobilizon.Service.Workers.Background
   alias Mobilizon.Users.User
   import Mobilizon.Web.Gettext, only: [dgettext: 2]
 
   require Logger
 
+  @spec refresh_profile(any(), map(), Absinthe.Resolution.t()) ::
+          {:ok, Actor.t()} | {:error, String.t()}
   def refresh_profile(_parent, %{id: id}, %{context: %{current_user: %User{role: role}}})
       when is_admin(role) do
     case Actors.get_actor(id) do
@@ -31,40 +33,38 @@ defmodule Mobilizon.GraphQL.Resolvers.Actor do
     end
   end
 
+  @spec suspend_profile(any(), map(), Absinthe.Resolution.t()) ::
+          {:ok, Actor.t()} | {:error, String.t()}
   def suspend_profile(_parent, %{id: id}, %{
-        context: %{current_user: %User{role: role} = user}
+        context: %{
+          current_user: %User{role: role},
+          current_actor: %Actor{} = moderator_actor
+        }
       })
       when is_moderator(role) do
-    with {:moderator_actor, %Actor{} = moderator_actor} <-
-           {:moderator_actor, Users.get_actor_for_user(user)},
-         %Actor{suspended: false} = actor <- Actors.get_actor_with_preload(id) do
-      case actor do
-        # Suspend a group on this instance
-        %Actor{type: :Group, domain: nil} ->
-          Logger.debug("We're suspending a group on this very instance")
-          ActivityPub.delete(actor, moderator_actor, true, %{suspension: true})
-          Admin.log_action(moderator_actor, "suspend", actor)
-          {:ok, actor}
+    case Actors.get_actor_with_preload(id) do
+      # Suspend a group on this instance
+      %Actor{suspended: false, type: :Group, domain: nil} = actor ->
+        Logger.debug("We're suspending a group on this very instance")
+        Actions.Delete.delete(actor, moderator_actor, true, %{suspension: true})
+        Admin.log_action(moderator_actor, "suspend", actor)
+        {:ok, actor}
 
-        # Delete a remote actor
-        %Actor{domain: domain} when not is_nil(domain) ->
-          Logger.debug("We're just deleting a remote instance")
-          Actors.delete_actor(actor, suspension: true)
-          Admin.log_action(moderator_actor, "suspend", actor)
-          {:ok, actor}
+      # Delete a remote actor
+      %Actor{suspended: false, domain: domain} = actor when not is_nil(domain) ->
+        Logger.debug("We're just deleting a remote instance")
+        Actors.delete_actor(actor, suspension: true)
+        Admin.log_action(moderator_actor, "suspend", actor)
+        {:ok, actor}
 
-        %Actor{domain: nil} ->
-          {:error, dgettext("errors", "No remote profile found with this ID")}
-      end
-    else
-      {:moderator_actor, nil} ->
-        {:error, dgettext("errors", "No profile found for the moderator user")}
+      %Actor{suspended: false, domain: nil} ->
+        {:error, dgettext("errors", "No remote profile found with this ID")}
 
       %Actor{suspended: true} ->
         {:error, dgettext("errors", "Profile already suspended")}
 
-      {:error, _} ->
-        {:error, dgettext("errors", "Error while performing background task")}
+      nil ->
+        {:error, dgettext("errors", "Profile not found")}
     end
   end
 
@@ -72,13 +72,16 @@ defmodule Mobilizon.GraphQL.Resolvers.Actor do
     {:error, dgettext("errors", "Only moderators and administrators can suspend a profile")}
   end
 
+  @spec unsuspend_profile(any(), map(), Absinthe.Resolution.t()) ::
+          {:ok, Actor.t()} | {:error, String.t()}
   def unsuspend_profile(_parent, %{id: id}, %{
-        context: %{current_user: %User{role: role} = user}
+        context: %{
+          current_user: %User{role: role},
+          current_actor: %Actor{} = moderator_actor
+        }
       })
       when is_moderator(role) do
-    with {:moderator_actor, %Actor{} = moderator_actor} <-
-           {:moderator_actor, Users.get_actor_for_user(user)},
-         %Actor{suspended: true} = actor <-
+    with %Actor{suspended: true} = actor <-
            Actors.get_actor_with_preload(id, true),
          {:delete_tombstones, {_, nil}} <-
            {:delete_tombstones, Mobilizon.Tombstone.delete_actor_tombstones(id)},
diff --git a/lib/graphql/resolvers/admin.ex b/lib/graphql/resolvers/admin.ex
index 42d3cd061..efaccaad1 100644
--- a/lib/graphql/resolvers/admin.ex
+++ b/lib/graphql/resolvers/admin.ex
@@ -6,14 +6,13 @@ defmodule Mobilizon.GraphQL.Resolvers.Admin do
   import Mobilizon.Users.Guards
 
   alias Mobilizon.{Actors, Admin, Config, Events}
-  alias Mobilizon.Actors.Actor
+  alias Mobilizon.Actors.{Actor, Follower}
   alias Mobilizon.Admin.{ActionLog, Setting}
   alias Mobilizon.Cldr.Language
   alias Mobilizon.Config
   alias Mobilizon.Discussions.Comment
   alias Mobilizon.Events.Event
-  alias Mobilizon.Federation.ActivityPub
-  alias Mobilizon.Federation.ActivityPub.Relay
+  alias Mobilizon.Federation.ActivityPub.{Actions, Relay}
   alias Mobilizon.Reports.{Note, Report}
   alias Mobilizon.Service.Statistics
   alias Mobilizon.Storage.Page
@@ -21,6 +20,8 @@ defmodule Mobilizon.GraphQL.Resolvers.Admin do
   import Mobilizon.Web.Gettext
   require Logger
 
+  @spec list_action_logs(any(), map(), Absinthe.Resolution.t()) ::
+          {:ok, Page.t(ActionLog.t())} | {:error, String.t()}
   def list_action_logs(
         _parent,
         %{page: page, limit: limit},
@@ -38,10 +39,10 @@ defmodule Mobilizon.GraphQL.Resolvers.Admin do
                          id: id,
                          inserted_at: inserted_at
                        } = action_log ->
-          with data when is_map(data) <-
-                 transform_action_log(String.to_existing_atom(target_type), action, action_log) do
-            Map.merge(data, %{actor: actor, id: id, inserted_at: inserted_at})
-          end
+          target_type
+          |> String.to_existing_atom()
+          |> transform_action_log(action, action_log)
+          |> Map.merge(%{actor: actor, id: id, inserted_at: inserted_at})
         end)
         |> Enum.filter(& &1)
 
@@ -53,6 +54,7 @@ defmodule Mobilizon.GraphQL.Resolvers.Admin do
     {:error, dgettext("errors", "You need to be logged-in and a moderator to list action logs")}
   end
 
+  @spec transform_action_log(module(), atom(), ActionLog.t()) :: map()
   defp transform_action_log(
          Report,
          :update,
@@ -123,6 +125,7 @@ defmodule Mobilizon.GraphQL.Resolvers.Admin do
   end
 
   # Changes are stored as %{"key" => "value"} so we need to convert them back as struct
+  @spec convert_changes_to_struct(module(), map()) :: struct()
   defp convert_changes_to_struct(struct, %{"report_id" => _report_id} = changes) do
     with data <- for({key, val} <- changes, into: %{}, do: {String.to_existing_atom(key), val}),
          data <- Map.put(data, :report, Mobilizon.Reports.get_report(data.report_id)) do
@@ -143,6 +146,8 @@ defmodule Mobilizon.GraphQL.Resolvers.Admin do
   end
 
   # datetimes are not unserialized as DateTime/NaiveDateTime so we do it manually with changeset data
+  @spec process_eventual_type(Ecto.Changeset.t(), String.t(), String.t() | nil) ::
+          DateTime.t() | NaiveDateTime.t() | any()
   defp process_eventual_type(changeset, key, val) do
     cond do
       changeset[String.to_existing_atom(key)] == :utc_datetime and not is_nil(val) ->
@@ -158,6 +163,7 @@ defmodule Mobilizon.GraphQL.Resolvers.Admin do
     end
   end
 
+  @spec get_list_of_languages(any(), any(), any()) :: {:ok, String.t()} | {:error, any()}
   def get_list_of_languages(_parent, %{codes: codes}, _resolution) when is_list(codes) do
     locale = Gettext.get_locale()
     locale = if Cldr.known_locale_name?(locale), do: locale, else: "en"
@@ -187,6 +193,8 @@ defmodule Mobilizon.GraphQL.Resolvers.Admin do
     end
   end
 
+  @spec get_dashboard(any(), any(), Absinthe.Resolution.t()) ::
+          {:ok, map()} | {:error, String.t()}
   def get_dashboard(_parent, _args, %{context: %{current_user: %User{role: role}}})
       when is_admin(role) do
     last_public_event_published =
@@ -225,6 +233,7 @@ defmodule Mobilizon.GraphQL.Resolvers.Admin do
      )}
   end
 
+  @spec get_settings(any(), any(), Absinthe.Resolution.t()) :: {:ok, map()} | {:error, String.t()}
   def get_settings(_parent, _args, %{
         context: %{current_user: %User{role: role}}
       })
@@ -237,6 +246,8 @@ defmodule Mobilizon.GraphQL.Resolvers.Admin do
      dgettext("errors", "You need to be logged-in and an administrator to access admin settings")}
   end
 
+  @spec save_settings(any(), map(), Absinthe.Resolution.t()) ::
+          {:ok, map()} | {:error, String.t()}
   def save_settings(_parent, args, %{
         context: %{current_user: %User{role: role}}
       })
@@ -261,6 +272,8 @@ defmodule Mobilizon.GraphQL.Resolvers.Admin do
      dgettext("errors", "You need to be logged-in and an administrator to save admin settings")}
   end
 
+  @spec list_relay_followers(any(), map(), Absinthe.Resolution.t()) ::
+          {:ok, Page.t(Follower.t())} | {:error, :unauthorized | :unauthenticated}
   def list_relay_followers(
         _parent,
         %{page: page, limit: limit},
@@ -283,6 +296,8 @@ defmodule Mobilizon.GraphQL.Resolvers.Admin do
     {:error, :unauthenticated}
   end
 
+  @spec list_relay_followings(any(), map(), Absinthe.Resolution.t()) ::
+          {:ok, Page.t(Follower.t())} | {:error, :unauthorized | :unauthenticated}
   def list_relay_followings(
         _parent,
         %{page: page, limit: limit},
@@ -305,28 +320,34 @@ defmodule Mobilizon.GraphQL.Resolvers.Admin do
     {:error, :unauthenticated}
   end
 
+  @spec create_relay(any(), map(), Absinthe.Resolution.t()) ::
+          {:ok, Follower.t()} | {:error, any()}
   def create_relay(_parent, %{address: address}, %{context: %{current_user: %User{role: role}}})
       when is_admin(role) do
     case Relay.follow(address) do
       {:ok, _activity, follow} ->
         {:ok, follow}
 
-      {:error, err} when is_binary(err) ->
+      {:error, err} ->
         {:error, err}
     end
   end
 
+  @spec remove_relay(any(), map(), Absinthe.Resolution.t()) ::
+          {:ok, Follower.t()} | {:error, any()}
   def remove_relay(_parent, %{address: address}, %{context: %{current_user: %User{role: role}}})
       when is_admin(role) do
     case Relay.unfollow(address) do
       {:ok, _activity, follow} ->
         {:ok, follow}
 
-      {:error, {:error, err}} when is_binary(err) ->
+      {:error, err} ->
         {:error, err}
     end
   end
 
+  @spec accept_subscription(any(), map(), Absinthe.Resolution.t()) ::
+          {:ok, Follower.t()} | {:error, any()}
   def accept_subscription(
         _parent,
         %{address: address},
@@ -337,14 +358,13 @@ defmodule Mobilizon.GraphQL.Resolvers.Admin do
       {:ok, _activity, follow} ->
         {:ok, follow}
 
-      {:error, {:error, err}} when is_binary(err) ->
-        {:error, err}
-
-      {:error, err} when is_binary(err) ->
+      {:error, err} ->
         {:error, err}
     end
   end
 
+  @spec reject_subscription(any(), map(), Absinthe.Resolution.t()) ::
+          {:ok, Follower.t()} | {:error, any()}
   def reject_subscription(
         _parent,
         %{address: address},
@@ -355,15 +375,12 @@ defmodule Mobilizon.GraphQL.Resolvers.Admin do
       {:ok, _activity, follow} ->
         {:ok, follow}
 
-      {:error, {:error, err}} when is_binary(err) ->
-        {:error, err}
-
-      {:error, err} when is_binary(err) ->
+      {:error, err} ->
         {:error, err}
     end
   end
 
-  @spec eventually_update_instance_actor(map()) :: :ok
+  @spec eventually_update_instance_actor(map()) :: :ok | {:error, :instance_actor_update_failure}
   defp eventually_update_instance_actor(admin_setting_args) do
     args = %{}
     new_instance_description = Map.get(admin_setting_args, :instance_description)
@@ -385,16 +402,18 @@ defmodule Mobilizon.GraphQL.Resolvers.Admin do
         do: Map.put(args, :name, new_instance_name),
         else: args
 
-    with {:changes, true} <- {:changes, args != %{}},
-         %Actor{} = instance_actor <- Relay.get_actor(),
-         {:ok, _activity, _actor} <- ActivityPub.update(instance_actor, args, true) do
-      :ok
-    else
-      {:changes, false} ->
-        :ok
+    if args != %{} do
+      %Actor{} = instance_actor = Relay.get_actor()
 
-      err ->
-        err
+      case Actions.Update.update(instance_actor, args, true) do
+        {:ok, _activity, _actor} ->
+          :ok
+
+        {:error, _err} ->
+          {:error, :instance_actor_update_failure}
+      end
+    else
+      :ok
     end
   end
 end
diff --git a/lib/graphql/resolvers/comment.ex b/lib/graphql/resolvers/comment.ex
index 0e2998bb6..115b654e1 100644
--- a/lib/graphql/resolvers/comment.ex
+++ b/lib/graphql/resolvers/comment.ex
@@ -3,7 +3,7 @@ defmodule Mobilizon.GraphQL.Resolvers.Comment do
   Handles the comment-related GraphQL calls.
   """
 
-  alias Mobilizon.{Actors, Admin, Discussions, Events, Users}
+  alias Mobilizon.{Actors, Admin, Discussions, Events}
   alias Mobilizon.Actors.Actor
   alias Mobilizon.Discussions.Comment, as: CommentModel
   alias Mobilizon.Events.{Event, EventOptions}
@@ -14,39 +14,44 @@ defmodule Mobilizon.GraphQL.Resolvers.Comment do
 
   require Logger
 
+  @spec get_thread(any(), map(), Absinthe.Resolution.t()) :: {:ok, [CommentModel.t()]}
   def get_thread(_parent, %{id: thread_id}, _context) do
     {:ok, Discussions.get_thread_replies(thread_id)}
   end
 
+  @spec create_comment(any(), map(), Absinthe.Resolution.t()) ::
+          {:ok, CommentModel.t()} | {:error, :unauthorized | :not_found | any() | String.t()}
   def create_comment(
         _parent,
         %{event_id: event_id} = args,
         %{
           context: %{
-            current_user: %User{} = user
+            current_actor: %Actor{id: actor_id}
           }
         }
       ) do
-    with %Actor{id: actor_id} <- Users.get_actor_for_user(user),
-         {:find_event,
-          {:ok,
-           %Event{
-             options: %EventOptions{comment_moderation: comment_moderation},
-             organizer_actor_id: organizer_actor_id
-           }}} <-
-           {:find_event, Events.get_event(event_id)},
-         {:allowed, true} <-
-           {:allowed, comment_moderation != :closed || actor_id == organizer_actor_id},
-         args <- Map.put(args, :actor_id, actor_id),
-         {:ok, _, %CommentModel{} = comment} <-
-           Comments.create_comment(args) do
-      {:ok, comment}
-    else
-      {:error, err} ->
-        {:error, err}
+    case Events.get_event(event_id) do
+      {:ok,
+       %Event{
+         options: %EventOptions{comment_moderation: comment_moderation},
+         organizer_actor_id: organizer_actor_id
+       }} ->
+        if comment_moderation != :closed || actor_id == organizer_actor_id do
+          args = Map.put(args, :actor_id, actor_id)
 
-      {:allowed, false} ->
-        {:error, :unauthorized}
+          case Comments.create_comment(args) do
+            {:ok, _, %CommentModel{} = comment} ->
+              {:ok, comment}
+
+            {:error, err} ->
+              {:error, err}
+          end
+        else
+          {:error, :unauthorized}
+        end
+
+      {:error, :event_not_found} ->
+        {:error, :not_found}
     end
   end
 
@@ -54,21 +59,33 @@ defmodule Mobilizon.GraphQL.Resolvers.Comment do
     {:error, dgettext("errors", "You are not allowed to create a comment if not connected")}
   end
 
+  @spec update_comment(any(), map(), Absinthe.Resolution.t()) ::
+          {:ok, CommentModel.t()} | {:error, :unauthorized | :not_found | any() | String.t()}
   def update_comment(
         _parent,
         %{text: text, comment_id: comment_id},
         %{
           context: %{
-            current_user: %User{} = user
+            current_actor: %Actor{id: actor_id}
           }
         }
       ) do
-    with {:actor, %Actor{id: actor_id} = _actor} <- {:actor, Users.get_actor_for_user(user)},
-         %CommentModel{actor_id: comment_actor_id} = comment <-
-           Mobilizon.Discussions.get_comment_with_preload(comment_id),
-         true <- actor_id === comment_actor_id,
-         {:ok, _, %CommentModel{} = comment} <- Comments.update_comment(comment, %{text: text}) do
-      {:ok, comment}
+    case Mobilizon.Discussions.get_comment_with_preload(comment_id) do
+      %CommentModel{actor_id: comment_actor_id} = comment ->
+        if actor_id == comment_actor_id do
+          case Comments.update_comment(comment, %{text: text}) do
+            {:ok, _, %CommentModel{} = comment} ->
+              {:ok, comment}
+
+            {:error, err} ->
+              {:error, err}
+          end
+        else
+          {:error, dgettext("errors", "You are not the comment creator")}
+        end
+
+      nil ->
+        {:error, :not_found}
     end
   end
 
@@ -81,31 +98,34 @@ defmodule Mobilizon.GraphQL.Resolvers.Comment do
         %{comment_id: comment_id},
         %{
           context: %{
-            current_user: %User{role: role} = user
+            current_user: %User{role: role},
+            current_actor: %Actor{id: actor_id} = actor
           }
         }
       ) do
-    with {:actor, %Actor{id: actor_id} = actor} <- {:actor, Users.get_actor_for_user(user)},
-         %CommentModel{deleted_at: nil} = comment <-
-           Discussions.get_comment_with_preload(comment_id) do
-      cond do
-        {:comment_can_be_managed, true} == CommentModel.can_be_managed_by(comment, actor_id) ->
-          do_delete_comment(comment, actor)
+    case Discussions.get_comment_with_preload(comment_id) do
+      %CommentModel{deleted_at: nil} = comment ->
+        cond do
+          {:comment_can_be_managed, true} == CommentModel.can_be_managed_by(comment, actor_id) ->
+            do_delete_comment(comment, actor)
 
-        role in [:moderator, :administrator] ->
-          with {:ok, res} <- do_delete_comment(comment, actor),
-               %Actor{} = actor <- Actors.get_actor(actor_id) do
-            Admin.log_action(actor, "delete", comment)
+          role in [:moderator, :administrator] ->
+            with {:ok, res} <- do_delete_comment(comment, actor),
+                 %Actor{} = actor <- Actors.get_actor(actor_id) do
+              Admin.log_action(actor, "delete", comment)
 
-            {:ok, res}
-          end
+              {:ok, res}
+            end
+
+          true ->
+            {:error, dgettext("errors", "You cannot delete this comment")}
+        end
 
-        true ->
-          {:error, dgettext("errors", "You cannot delete this comment")}
-      end
-    else
       %CommentModel{deleted_at: deleted_at} when not is_nil(deleted_at) ->
         {:error, dgettext("errors", "Comment is already deleted")}
+
+      nil ->
+        {:error, dgettext("errors", "Comment not found")}
     end
   end
 
@@ -113,10 +133,15 @@ defmodule Mobilizon.GraphQL.Resolvers.Comment do
     {:error, dgettext("errors", "You are not allowed to delete a comment if not connected")}
   end
 
+  @spec do_delete_comment(CommentModel.t(), Actor.t()) ::
+          {:ok, CommentModel.t()} | {:error, any()}
   defp do_delete_comment(%CommentModel{} = comment, %Actor{} = actor) do
-    with {:ok, _, %CommentModel{} = comment} <-
-           Comments.delete_comment(comment, actor) do
-      {:ok, comment}
+    case Comments.delete_comment(comment, actor) do
+      {:ok, _, %CommentModel{} = comment} ->
+        {:ok, comment}
+
+      {:error, err} ->
+        {:error, err}
     end
   end
 end
diff --git a/lib/graphql/resolvers/config.ex b/lib/graphql/resolvers/config.ex
index 170993bb9..7b50a8987 100644
--- a/lib/graphql/resolvers/config.ex
+++ b/lib/graphql/resolvers/config.ex
@@ -8,6 +8,7 @@ defmodule Mobilizon.GraphQL.Resolvers.Config do
   @doc """
   Gets config.
   """
+  @spec get_config(any(), map(), Absinthe.Resolution.t()) :: {:ok, map()}
   def get_config(_parent, _params, %{context: %{ip: ip}}) do
     geolix = Geolix.lookup(ip)
 
@@ -28,6 +29,7 @@ defmodule Mobilizon.GraphQL.Resolvers.Config do
     {:ok, data}
   end
 
+  @spec terms(any(), map(), Absinthe.Resolution.t()) :: {:ok, map()}
   def terms(_parent, %{locale: locale}, _resolution) do
     type = Config.instance_terms_type()
 
@@ -41,6 +43,7 @@ defmodule Mobilizon.GraphQL.Resolvers.Config do
     {:ok, %{body_html: body_html, type: type, url: url}}
   end
 
+  @spec privacy(any(), map(), Absinthe.Resolution.t()) :: {:ok, map()}
   def privacy(_parent, %{locale: locale}, _resolution) do
     type = Config.instance_privacy_type()
 
@@ -54,6 +57,7 @@ defmodule Mobilizon.GraphQL.Resolvers.Config do
     {:ok, %{body_html: body_html, type: type, url: url}}
   end
 
+  @spec config_cache :: map()
   defp config_cache do
     case Cachex.fetch(:config, "full_config", fn _key ->
            case build_config_cache() do
@@ -62,10 +66,11 @@ defmodule Mobilizon.GraphQL.Resolvers.Config do
            end
          end) do
       {status, value} when status in [:ok, :commit] -> value
-      _err -> nil
+      _err -> %{}
     end
   end
 
+  @spec build_config_cache :: map()
   defp build_config_cache do
     %{
       name: Config.instance_name(),
diff --git a/lib/graphql/resolvers/discussion.ex b/lib/graphql/resolvers/discussion.ex
index 9603f3cf1..d42e5c135 100644
--- a/lib/graphql/resolvers/discussion.ex
+++ b/lib/graphql/resolvers/discussion.ex
@@ -3,26 +3,27 @@ defmodule Mobilizon.GraphQL.Resolvers.Discussion do
   Handles the group-related GraphQL calls.
   """
 
-  alias Mobilizon.{Actors, Discussions, Users}
+  alias Mobilizon.{Actors, Discussions}
   alias Mobilizon.Actors.Actor
   alias Mobilizon.Discussions.{Comment, Discussion}
-  alias Mobilizon.Federation.ActivityPub
+  alias Mobilizon.Federation.ActivityPub.Actions
   alias Mobilizon.GraphQL.API.Comments
   alias Mobilizon.Storage.Page
   alias Mobilizon.Users.User
   import Mobilizon.Web.Gettext
 
+  @spec find_discussions_for_actor(Actor.t(), map(), Absinthe.Resolution.t()) ::
+          {:ok, Page.t(Discussion.t())} | {:error, :unauthenticated}
   def find_discussions_for_actor(
         %Actor{id: group_id},
         %{page: page, limit: limit},
         %{
           context: %{
-            current_user: %User{} = user
+            current_actor: %Actor{id: actor_id}
           }
         }
       ) do
-    with {:actor, %Actor{id: actor_id} = _actor} <- {:actor, Users.get_actor_for_user(user)},
-         {:member, true} <- {:member, Actors.is_member?(actor_id, group_id)},
+    with {:member, true} <- {:member, Actors.is_member?(actor_id, group_id)},
          {:ok, %Actor{type: :Group} = group} <- Actors.get_group_by_actor_id(group_id) do
       {:ok, Discussions.find_discussions_for_actor(group, page, limit)}
     else
@@ -31,30 +32,42 @@ defmodule Mobilizon.GraphQL.Resolvers.Discussion do
     end
   end
 
-  def find_discussions_for_actor(%Actor{}, _args, _resolution) do
+  def find_discussions_for_actor(%Actor{}, _args, %{
+        context: %{
+          current_user: %User{}
+        }
+      }) do
     {:ok, %Page{total: 0, elements: []}}
   end
 
+  def find_discussions_for_actor(%Actor{}, _args, _resolution), do: {:error, :unauthenticated}
+
+  @spec get_discussion(any(), map(), Absinthe.Resolution.t()) ::
+          {:ok, Discussion.t()} | {:error, :unauthorized | :discussion_not_found | String.t()}
   def get_discussion(_parent, %{id: id}, %{
         context: %{
-          current_user: %User{} = user
+          current_actor: %Actor{id: creator_id}
         }
       }) do
-    with {:actor, %Actor{id: creator_id} = _actor} <- {:actor, Users.get_actor_for_user(user)},
-         %Discussion{actor_id: actor_id} = discussion <-
-           Discussions.get_discussion(id),
-         {:member, true} <- {:member, Actors.is_member?(creator_id, actor_id)} do
-      {:ok, discussion}
+    case Discussions.get_discussion(id) do
+      %Discussion{actor_id: actor_id} = discussion ->
+        if Actors.is_member?(creator_id, actor_id) do
+          {:ok, discussion}
+        else
+          {:error, :unauthorized}
+        end
+
+      nil ->
+        {:error, :discussion_not_found}
     end
   end
 
   def get_discussion(_parent, %{slug: slug}, %{
         context: %{
-          current_user: %User{} = user
+          current_actor: %Actor{id: creator_id}
         }
       }) do
-    with {:actor, %Actor{id: creator_id} = _actor} <- {:actor, Users.get_actor_for_user(user)},
-         %Discussion{actor_id: actor_id} = discussion <-
+    with %Discussion{actor_id: actor_id} = discussion <-
            Discussions.get_discussion_by_slug(slug),
          {:member, true} <- {:member, Actors.is_member?(creator_id, actor_id)} do
       {:ok, discussion}
@@ -76,6 +89,8 @@ defmodule Mobilizon.GraphQL.Resolvers.Discussion do
   def get_discussion(_parent, _args, _resolution),
     do: {:error, dgettext("errors", "You need to be logged-in to access discussions")}
 
+  @spec get_comments_for_discussion(Discussion.t(), map(), Absinthe.Resolution.t()) ::
+          {:ok, Page.t(Discussion.t())}
   def get_comments_for_discussion(
         %Discussion{id: discussion_id},
         %{page: page, limit: limit},
@@ -84,48 +99,54 @@ defmodule Mobilizon.GraphQL.Resolvers.Discussion do
     {:ok, Discussions.get_comments_for_discussion(discussion_id, page, limit)}
   end
 
+  @spec create_discussion(any(), map(), Absinthe.Resolution.t()) ::
+          {:ok, Discussion.t()}
+          | {:error, Ecto.Changeset.t() | String.t() | :unauthorized | :unauthenticated}
   def create_discussion(
         _parent,
         %{title: title, text: text, actor_id: group_id},
         %{
           context: %{
-            current_user: %User{} = user
+            current_actor: %Actor{id: creator_id}
           }
         }
       ) do
-    with {:actor, %Actor{id: creator_id} = _actor} <- {:actor, Users.get_actor_for_user(user)},
-         {:member, true} <- {:member, Actors.is_member?(creator_id, group_id)},
-         {:ok, _activity, %Discussion{} = discussion} <-
-           Comments.create_discussion(%{
+    if Actors.is_member?(creator_id, group_id) do
+      case Comments.create_discussion(%{
              title: title,
              text: text,
              actor_id: group_id,
              creator_id: creator_id,
              attributed_to_id: group_id
            }) do
-      {:ok, discussion}
-    else
-      {:error, type, err, _} when type in [:discussion, :comment] ->
-        {:error, err}
+        {:ok, _activity, %Discussion{} = discussion} ->
+          {:ok, discussion}
 
-      {:member, false} ->
-        {:error, :unauthorized}
+        {:error, %Ecto.Changeset{} = err} ->
+          {:error, err}
+
+        {:error, _err} ->
+          {:error, dgettext("errors", "Error while creating a discussion")}
+      end
+    else
+      {:error, :unauthorized}
     end
   end
 
   def create_discussion(_, _, _), do: {:error, :unauthenticated}
 
+  @spec reply_to_discussion(any(), map(), Absinthe.Resolution.t()) ::
+          {:ok, Discussion.t()} | {:error, :discussion_not_found | :unauthenticated}
   def reply_to_discussion(
         _parent,
         %{text: text, discussion_id: discussion_id},
         %{
           context: %{
-            current_user: %User{} = user
+            current_actor: %Actor{id: creator_id}
           }
         }
       ) do
-    with {:actor, %Actor{id: creator_id} = _actor} <- {:actor, Users.get_actor_for_user(user)},
-         {:no_discussion,
+    with {:no_discussion,
           %Discussion{
             actor_id: actor_id,
             last_comment: %Comment{
@@ -155,22 +176,22 @@ defmodule Mobilizon.GraphQL.Resolvers.Discussion do
 
   def reply_to_discussion(_, _, _), do: {:error, :unauthenticated}
 
-  @spec update_discussion(map(), map(), map()) :: {:ok, Discussion.t()}
+  @spec update_discussion(map(), map(), map()) ::
+          {:ok, Discussion.t()} | {:error, :unauthorized | :unauthenticated}
   def update_discussion(
         _parent,
         %{title: title, discussion_id: discussion_id},
         %{
           context: %{
-            current_user: %User{} = user
+            current_actor: %Actor{id: creator_id}
           }
         }
       ) do
-    with {:actor, %Actor{id: creator_id} = _actor} <- {:actor, Users.get_actor_for_user(user)},
-         {:no_discussion, %Discussion{actor_id: actor_id} = discussion} <-
+    with {:no_discussion, %Discussion{actor_id: actor_id} = discussion} <-
            {:no_discussion, Discussions.get_discussion(discussion_id)},
          {:member, true} <- {:member, Actors.is_member?(creator_id, actor_id)},
          {:ok, _activity, %Discussion{} = discussion} <-
-           ActivityPub.update(
+           Actions.Update.update(
              discussion,
              %{
                title: title
@@ -185,17 +206,19 @@ defmodule Mobilizon.GraphQL.Resolvers.Discussion do
 
   def update_discussion(_, _, _), do: {:error, :unauthenticated}
 
+  @spec delete_discussion(any(), map(), Absinthe.Resolution.t()) ::
+          {:ok, Discussion.t()} | {:error, String.t() | :unauthorized | :unauthenticated}
   def delete_discussion(_parent, %{discussion_id: discussion_id}, %{
         context: %{
-          current_user: %User{} = user
+          current_user: %User{},
+          current_actor: %Actor{id: creator_id} = actor
         }
       }) do
-    with {:actor, %Actor{id: creator_id} = actor} <- {:actor, Users.get_actor_for_user(user)},
-         {:no_discussion, %Discussion{actor_id: actor_id} = discussion} <-
+    with {:no_discussion, %Discussion{actor_id: actor_id} = discussion} <-
            {:no_discussion, Discussions.get_discussion(discussion_id)},
          {:member, true} <- {:member, Actors.is_member?(creator_id, actor_id)},
          {:ok, _activity, %Discussion{} = discussion} <-
-           ActivityPub.delete(discussion, actor) do
+           Actions.Delete.delete(discussion, actor) do
       {:ok, discussion}
     else
       {:no_discussion, _} ->
diff --git a/lib/graphql/resolvers/event.ex b/lib/graphql/resolvers/event.ex
index 318bd75ed..d5119bf6b 100644
--- a/lib/graphql/resolvers/event.ex
+++ b/lib/graphql/resolvers/event.ex
@@ -3,7 +3,7 @@ defmodule Mobilizon.GraphQL.Resolvers.Event do
   Handles the event-related GraphQL calls.
   """
 
-  alias Mobilizon.{Actors, Admin, Events, Users}
+  alias Mobilizon.{Actors, Admin, Events}
   alias Mobilizon.Actors.Actor
   alias Mobilizon.Config
   alias Mobilizon.Events.{Event, EventParticipantStats}
@@ -21,14 +21,17 @@ defmodule Mobilizon.GraphQL.Resolvers.Event do
   @event_max_limit 100
   @number_of_related_events 3
 
+  @spec organizer_for_event(Event.t(), map(), Absinthe.Resolution.t()) ::
+          {:ok, Actor.t() | nil} | {:error, String.t()}
   def organizer_for_event(
         %Event{attributed_to_id: attributed_to_id, organizer_actor_id: organizer_actor_id},
         _args,
-        %{context: %{current_user: %User{role: user_role} = user}} = _resolution
+        %{
+          context: %{current_user: %User{role: user_role}, current_actor: %Actor{id: actor_id}}
+        } = _resolution
       )
       when not is_nil(attributed_to_id) do
     with %Actor{id: group_id} <- Actors.get_actor(attributed_to_id),
-         %Actor{id: actor_id} <- Users.get_actor_for_user(user),
          {:member, true} <-
            {:member, Actors.is_member?(actor_id, group_id) or is_moderator(user_role)},
          %Actor{} = actor <- Actors.get_actor(organizer_actor_id) do
@@ -61,6 +64,8 @@ defmodule Mobilizon.GraphQL.Resolvers.Event do
     end
   end
 
+  @spec list_events(any(), map(), Absinthe.Resolution.t()) ::
+          {:ok, Page.t(Event.t())} | {:error, :events_max_limit_reached}
   def list_events(
         _parent,
         %{page: page, limit: limit, order_by: order_by, direction: direction},
@@ -74,13 +79,13 @@ defmodule Mobilizon.GraphQL.Resolvers.Event do
     {:error, :events_max_limit_reached}
   end
 
+  @spec find_private_event(any(), map(), Absinthe.Resolution.t()) ::
+          {:ok, Event.t()} | {:error, :event_not_found}
   defp find_private_event(
          _parent,
          %{uuid: uuid},
-         %{context: %{current_user: %User{} = user}} = _resolution
+         %{context: %{current_actor: %Actor{} = profile}} = _resolution
        ) do
-    %Actor{} = profile = Users.get_actor_for_user(user)
-
     case Events.get_event_by_uuid_with_preload(uuid) do
       # Event attributed to group
       %Event{attributed_to: %Actor{}} = event ->
@@ -107,6 +112,8 @@ defmodule Mobilizon.GraphQL.Resolvers.Event do
     {:error, :event_not_found}
   end
 
+  @spec find_event(any(), map(), Absinthe.Resolution.t()) ::
+          {:ok, Event.t()} | {:error, :event_not_found}
   def find_event(parent, %{uuid: uuid} = args, %{context: context} = resolution) do
     with {:has_event, %Event{} = event} <-
            {:has_event, Events.get_public_event_by_uuid_with_preload(uuid)},
@@ -133,15 +140,15 @@ defmodule Mobilizon.GraphQL.Resolvers.Event do
   @doc """
   List participants for event (through an event request)
   """
+  @spec list_participants_for_event(Event.t(), map(), Absinthe.Resolution.t()) ::
+          {:ok, Page.t(Participant.t())} | {:error, String.t()}
   def list_participants_for_event(
         %Event{id: event_id} = event,
         %{page: page, limit: limit, roles: roles},
-        %{context: %{current_user: %User{} = user}} = _resolution
+        %{context: %{current_actor: %Actor{} = actor}} = _resolution
       ) do
-    with %Actor{} = actor <- Users.get_actor_for_user(user),
-         # Check that moderator has right
-         {:event_can_be_managed, true} <-
-           {:event_can_be_managed, can_event_be_updated_by?(event, actor)} do
+    # Check that moderator has right
+    if can_event_be_updated_by?(event, actor) do
       roles =
         case roles do
           nil ->
@@ -160,9 +167,8 @@ defmodule Mobilizon.GraphQL.Resolvers.Event do
       participants = Events.list_participants_for_event(event_id, roles, page, limit)
       {:ok, participants}
     else
-      {:event_can_be_managed, _} ->
-        {:error,
-         dgettext("errors", "Provided profile doesn't have moderator permissions on this event")}
+      {:error,
+       dgettext("errors", "Provided profile doesn't have moderator permissions on this event")}
     end
   end
 
@@ -170,6 +176,7 @@ defmodule Mobilizon.GraphQL.Resolvers.Event do
     {:ok, %{total: 0, elements: []}}
   end
 
+  @spec stats_participants(Event.t(), map(), Absinthe.Resolution.t()) :: {:ok, map()}
   def stats_participants(
         %Event{participant_stats: %EventParticipantStats{} = stats, id: event_id} = _event,
         _args,
@@ -202,6 +209,7 @@ defmodule Mobilizon.GraphQL.Resolvers.Event do
   @doc """
   List related events
   """
+  @spec list_related_events(Event.t(), map(), Absinthe.Resolution.t()) :: {:ok, list(Event.t())}
   def list_related_events(
         %Event{tags: tags, organizer_actor: organizer_actor, uuid: uuid},
         _args,
@@ -243,11 +251,14 @@ defmodule Mobilizon.GraphQL.Resolvers.Event do
     {:ok, events}
   end
 
+  @spec uniq_events(list(Event.t())) :: list(Event.t())
   defp uniq_events(events), do: Enum.uniq_by(events, fn event -> event.uuid end)
 
   @doc """
   Create an event
   """
+  @spec create_event(any(), map(), Absinthe.Resolution.t()) ::
+          {:ok, Event.t()} | {:error, String.t() | Ecto.Changeset.t()}
   def create_event(
         _parent,
         %{organizer_actor_id: organizer_actor_id} = args,
@@ -287,15 +298,17 @@ defmodule Mobilizon.GraphQL.Resolvers.Event do
   @doc """
   Update an event
   """
+  @spec update_event(any(), map(), Absinthe.Resolution.t()) ::
+          {:ok, Event.t()} | {:error, String.t() | Ecto.Changeset.t()}
   def update_event(
         _parent,
         %{event_id: event_id} = args,
-        %{context: %{current_user: %User{} = user}} = _resolution
+        %{context: %{current_user: %User{} = user, current_actor: %Actor{} = actor}} = _resolution
       ) do
     # See https://github.com/absinthe-graphql/absinthe/issues/490
-    with args <- Map.put(args, :options, args[:options] || %{}),
-         {:ok, %Event{} = event} <- Events.get_event_with_preload(event_id),
-         %Actor{} = actor <- Users.get_actor_for_user(user),
+    args = Map.put(args, :options, args[:options] || %{})
+
+    with {:ok, %Event{} = event} <- Events.get_event_with_preload(event_id),
          {:ok, args} <- verify_profile_change(args, event, user, actor),
          {:event_can_be_managed, true} <-
            {:event_can_be_managed, can_event_be_updated_by?(event, actor)},
@@ -319,7 +332,7 @@ defmodule Mobilizon.GraphQL.Resolvers.Event do
       {:new_actor, _} ->
         {:error, dgettext("errors", "You can't attribute this event to this profile.")}
 
-      {:error, _, %Ecto.Changeset{} = error, _} ->
+      {:error, %Ecto.Changeset{} = error} ->
         {:error, error}
     end
   end
@@ -331,30 +344,37 @@ defmodule Mobilizon.GraphQL.Resolvers.Event do
   @doc """
   Delete an event
   """
+  @spec delete_event(any(), map(), Absinthe.Resolution.t()) ::
+          {:ok, Event.t()} | {:error, String.t() | Ecto.Changeset.t()}
   def delete_event(
         _parent,
         %{event_id: event_id},
-        %{context: %{current_user: %User{role: role} = user}}
+        %{
+          context: %{
+            current_user: %User{role: role},
+            current_actor: %Actor{id: actor_id} = actor
+          }
+        }
       ) do
-    with {:ok, %Event{local: is_local} = event} <- Events.get_event_with_preload(event_id),
-         %Actor{id: actor_id} = actor <- Users.get_actor_for_user(user) do
-      cond do
-        {:event_can_be_managed, true} ==
-            {:event_can_be_managed, can_event_be_deleted_by?(event, actor)} ->
-          do_delete_event(event, actor)
+    case Events.get_event_with_preload(event_id) do
+      {:ok, %Event{local: is_local} = event} ->
+        cond do
+          {:event_can_be_managed, true} ==
+              {:event_can_be_managed, can_event_be_deleted_by?(event, actor)} ->
+            do_delete_event(event, actor)
 
-        role in [:moderator, :administrator] ->
-          with {:ok, res} <- do_delete_event(event, actor, !is_local),
-               %Actor{} = actor <- Actors.get_actor(actor_id) do
-            Admin.log_action(actor, "delete", event)
+          role in [:moderator, :administrator] ->
+            with {:ok, res} <- do_delete_event(event, actor, !is_local),
+                 %Actor{} = actor <- Actors.get_actor(actor_id) do
+              Admin.log_action(actor, "delete", event)
 
-            {:ok, res}
-          end
+              {:ok, res}
+            end
+
+          true ->
+            {:error, dgettext("errors", "You cannot delete this event")}
+        end
 
-        true ->
-          {:error, dgettext("errors", "You cannot delete this event")}
-      end
-    else
       {:error, :event_not_found} ->
         {:error, dgettext("errors", "Event not found")}
     end
@@ -364,6 +384,7 @@ defmodule Mobilizon.GraphQL.Resolvers.Event do
     {:error, dgettext("errors", "You need to be logged-in to delete an event")}
   end
 
+  @spec do_delete_event(Event.t(), Actor.t(), boolean()) :: {:ok, map()}
   defp do_delete_event(%Event{} = event, %Actor{} = actor, federate \\ true)
        when is_boolean(federate) do
     with {:ok, _activity, event} <- API.Events.delete_event(event, actor) do
@@ -371,6 +392,7 @@ defmodule Mobilizon.GraphQL.Resolvers.Event do
     end
   end
 
+  @spec is_organizer_group_member?(map()) :: boolean()
   defp is_organizer_group_member?(%{
          attributed_to_id: attributed_to_id,
          organizer_actor_id: organizer_actor_id
@@ -382,6 +404,7 @@ defmodule Mobilizon.GraphQL.Resolvers.Event do
 
   defp is_organizer_group_member?(_), do: true
 
+  @spec verify_profile_change(map(), Event.t(), User.t(), Actor.t()) :: {:ok, map()}
   defp verify_profile_change(
          args,
          %Event{attributed_to: %Actor{}},
diff --git a/lib/graphql/resolvers/event/utils.ex b/lib/graphql/resolvers/event/utils.ex
index e6c7e8c24..613dcadd4 100644
--- a/lib/graphql/resolvers/event/utils.ex
+++ b/lib/graphql/resolvers/event/utils.ex
@@ -6,7 +6,10 @@ defmodule Mobilizon.GraphQL.Resolvers.Event.Utils do
   alias Mobilizon.Actors.Actor
   alias Mobilizon.Events.Event
   alias Mobilizon.Federation.ActivityPub.Permission
+  import Mobilizon.Service.Guards, only: [is_valid_string: 1]
 
+  @spec can_event_be_updated_by?(%Event{id: String.t()}, Actor.t()) ::
+          boolean
   def can_event_be_updated_by?(
         %Event{attributed_to: %Actor{type: :Group}} = event,
         %Actor{} = actor_member
@@ -21,10 +24,13 @@ defmodule Mobilizon.GraphQL.Resolvers.Event.Utils do
     Event.can_be_managed_by?(event, actor_member_id)
   end
 
+  @spec can_event_be_deleted_by?(%Event{id: String.t(), url: String.t()}, Actor.t()) ::
+          boolean
   def can_event_be_deleted_by?(
-        %Event{attributed_to: %Actor{type: :Group}} = event,
+        %Event{attributed_to: %Actor{type: :Group}, id: event_id, url: event_url} = event,
         %Actor{} = actor_member
-      ) do
+      )
+      when is_valid_string(event_id) and is_valid_string(event_url) do
     Permission.can_delete_group_object?(actor_member, event)
   end
 
diff --git a/lib/graphql/resolvers/followers.ex b/lib/graphql/resolvers/followers.ex
index 950115a5a..b75520542 100644
--- a/lib/graphql/resolvers/followers.ex
+++ b/lib/graphql/resolvers/followers.ex
@@ -4,9 +4,9 @@ defmodule Mobilizon.GraphQL.Resolvers.Followers do
   """
 
   import Mobilizon.Users.Guards
-  alias Mobilizon.{Actors, Users}
+  alias Mobilizon.Actors
   alias Mobilizon.Actors.{Actor, Follower}
-  alias Mobilizon.Federation.ActivityPub
+  alias Mobilizon.Federation.ActivityPub.Actions
   alias Mobilizon.Storage.Page
   alias Mobilizon.Users.User
 
@@ -16,17 +16,16 @@ defmodule Mobilizon.GraphQL.Resolvers.Followers do
         %{page: page, limit: limit} = args,
         %{
           context: %{
-            current_user: %User{role: user_role} = user
+            current_user: %User{role: user_role},
+            current_actor: %Actor{id: actor_id}
           }
         }
       ) do
-    with {:actor, %Actor{id: actor_id} = _actor} <- {:actor, Users.get_actor_for_user(user)},
-         {:member, true} <-
-           {:member, Actors.is_moderator?(actor_id, group_id) or is_moderator(user_role)} do
+    if Actors.is_moderator?(actor_id, group_id) or is_moderator(user_role) do
       {:ok,
        Actors.list_paginated_followers_for_actor(group, Map.get(args, :approved), page, limit)}
     else
-      _ -> {:error, :unauthorized}
+      {:error, :unauthorized}
     end
   end
 
@@ -35,19 +34,18 @@ defmodule Mobilizon.GraphQL.Resolvers.Followers do
   @spec update_follower(any(), map(), map()) :: {:ok, Follower.t()} | {:error, any()}
   def update_follower(_, %{id: follower_id, approved: approved}, %{
         context: %{
-          current_user: %User{} = user
+          current_actor: %Actor{id: actor_id}
         }
       }) do
-    with {:actor, %Actor{id: actor_id} = _actor} <- {:actor, Users.get_actor_for_user(user)},
-         %Follower{target_actor: %Actor{type: :Group, id: group_id}} = follower <-
+    with %Follower{target_actor: %Actor{type: :Group, id: group_id}} = follower <-
            Actors.get_follower(follower_id),
          {:member, true} <-
            {:member, Actors.is_moderator?(actor_id, group_id)},
          {:ok, _activity, %Follower{} = follower} <-
            (if approved do
-              ActivityPub.accept(:follow, follower)
+              Actions.Accept.accept(:follow, follower)
             else
-              ActivityPub.reject(:follow, follower)
+              Actions.Reject.reject(:follow, follower)
             end) do
       {:ok, follower}
     else
diff --git a/lib/graphql/resolvers/group.ex b/lib/graphql/resolvers/group.ex
index e5ed6a2f3..2ef9460fd 100644
--- a/lib/graphql/resolvers/group.ex
+++ b/lib/graphql/resolvers/group.ex
@@ -4,9 +4,9 @@ defmodule Mobilizon.GraphQL.Resolvers.Group do
   """
 
   import Mobilizon.Users.Guards
-  alias Mobilizon.{Actors, Events, Users}
+  alias Mobilizon.{Actors, Events}
   alias Mobilizon.Actors.{Actor, Member}
-  alias Mobilizon.Federation.ActivityPub
+  alias Mobilizon.Federation.ActivityPub.Actions
   alias Mobilizon.Federation.ActivityPub.Actor, as: ActivityPubActor
   alias Mobilizon.GraphQL.API
   alias Mobilizon.Users.User
@@ -15,6 +15,12 @@ defmodule Mobilizon.GraphQL.Resolvers.Group do
 
   require Logger
 
+  @spec find_group(
+          any,
+          %{:preferred_username => binary, optional(any) => any},
+          Absinthe.Resolution.t()
+        ) ::
+          {:error, :group_not_found} | {:ok, Actor.t()}
   @doc """
   Find a group
   """
@@ -23,34 +29,30 @@ defmodule Mobilizon.GraphQL.Resolvers.Group do
         %{preferred_username: name} = args,
         %{
           context: %{
-            current_user: %User{} = user
+            current_actor: %Actor{id: actor_id}
           }
         }
       ) do
-    with {:group, {:ok, %Actor{id: group_id, suspended: false} = group}} <-
-           {:group, ActivityPubActor.find_or_make_group_from_nickname(name)},
-         {:actor, %Actor{id: actor_id} = _actor} <- {:actor, Users.get_actor_for_user(user)},
-         {:member, true} <- {:member, Actors.is_member?(actor_id, group_id)} do
-      {:ok, group}
-    else
-      {:member, false} ->
-        find_group(parent, args, nil)
+    case ActivityPubActor.find_or_make_group_from_nickname(name) do
+      {:ok, %Actor{id: group_id, suspended: false} = group} ->
+        if Actors.is_member?(actor_id, group_id) do
+          {:ok, group}
+        else
+          find_group(parent, args, nil)
+        end
 
-      {:group, _} ->
+      {:error, _err} ->
         {:error, :group_not_found}
-
-      _ ->
-        {:error, :unknown}
     end
   end
 
   def find_group(_parent, %{preferred_username: name}, _resolution) do
-    with {:ok, %Actor{suspended: false} = actor} <-
-           ActivityPubActor.find_or_make_group_from_nickname(name),
-         %Actor{} = actor <- restrict_fields_for_non_member_request(actor) do
-      {:ok, actor}
-    else
-      _ ->
+    case ActivityPubActor.find_or_make_group_from_nickname(name) do
+      {:ok, %Actor{suspended: false} = actor} ->
+        %Actor{} = actor = restrict_fields_for_non_member_request(actor)
+        {:ok, actor}
+
+      {:error, _err} ->
         {:error, :group_not_found}
     end
   end
@@ -58,13 +60,18 @@ defmodule Mobilizon.GraphQL.Resolvers.Group do
   @doc """
   Get a group
   """
+  @spec get_group(any(), map(), Absinthe.Resolution.t()) ::
+          {:ok, Actor.t()} | {:error, String.t()}
   def get_group(_parent, %{id: id}, %{context: %{current_user: %User{role: role}}}) do
-    with %Actor{type: :Group, suspended: suspended} = actor <-
-           Actors.get_actor_with_preload(id, true),
-         true <- suspended == false or is_moderator(role) do
-      {:ok, actor}
-    else
-      _ ->
+    case Actors.get_actor_with_preload(id, true) do
+      %Actor{type: :Group, suspended: suspended} = actor ->
+        if suspended == false or is_moderator(role) do
+          {:ok, actor}
+        else
+          {:error, dgettext("errors", "Group with ID %{id} not found", id: id)}
+        end
+
+      nil ->
         {:error, dgettext("errors", "Group with ID %{id} not found", id: id)}
     end
   end
@@ -72,6 +79,8 @@ defmodule Mobilizon.GraphQL.Resolvers.Group do
   @doc """
   Lists all groups
   """
+  @spec list_groups(any(), map(), Absinthe.Resolution.t()) ::
+          {:ok, Page.t(Actor.t())} | {:error, String.t()}
   def list_groups(
         _parent,
         %{
@@ -96,6 +105,7 @@ defmodule Mobilizon.GraphQL.Resolvers.Group do
     do: {:error, dgettext("errors", "You may not list groups unless moderator.")}
 
   # TODO Move me to somewhere cleaner
+  @spec save_attached_pictures(map()) :: map()
   defp save_attached_pictures(args) do
     Enum.reduce([:avatar, :banner], args, fn key, args ->
       if is_map(args) && Map.has_key?(args, key) && !is_nil(args[key][:media]) do
@@ -114,17 +124,18 @@ defmodule Mobilizon.GraphQL.Resolvers.Group do
   @doc """
   Create a new group. The creator is automatically added as admin
   """
+  @spec create_group(any(), map(), Absinthe.Resolution.t()) ::
+          {:ok, Actor.t()} | {:error, String.t()}
   def create_group(
         _parent,
         args,
         %{
           context: %{
-            current_user: user
+            current_actor: %Actor{id: creator_actor_id} = creator_actor
           }
         }
       ) do
-    with %Actor{id: creator_actor_id} = creator_actor <- Users.get_actor_for_user(user),
-         args when is_map(args) <- Map.update(args, :preferred_username, "", &String.downcase/1),
+    with args when is_map(args) <- Map.update(args, :preferred_username, "", &String.downcase/1),
          args when is_map(args) <- Map.put(args, :creator_actor, creator_actor),
          args when is_map(args) <- Map.put(args, :creator_actor_id, creator_actor_id),
          {:picture, args} when is_map(args) <- {:picture, save_attached_pictures(args)},
@@ -147,32 +158,35 @@ defmodule Mobilizon.GraphQL.Resolvers.Group do
   @doc """
   Update a group. The creator is automatically added as admin
   """
+  @spec update_group(any(), map(), Absinthe.Resolution.t()) ::
+          {:ok, Actor.t()} | {:error, String.t()}
   def update_group(
         _parent,
         %{id: group_id} = args,
         %{
           context: %{
-            current_user: %User{} = user
+            current_actor: %Actor{} = updater_actor
           }
         }
       ) do
-    with %Actor{} = updater_actor <- Users.get_actor_for_user(user),
-         {:administrator, true} <-
-           {:administrator, Actors.is_administrator?(updater_actor.id, group_id)},
-         args when is_map(args) <- Map.put(args, :updater_actor, updater_actor),
-         {:picture, args} when is_map(args) <- {:picture, save_attached_pictures(args)},
-         {:ok, _activity, %Actor{type: :Group} = group} <-
-           API.Groups.update_group(args) do
-      {:ok, group}
+    if Actors.is_administrator?(updater_actor.id, group_id) do
+      args = Map.put(args, :updater_actor, updater_actor)
+
+      case save_attached_pictures(args) do
+        {:error, :file_too_large} ->
+          {:error, dgettext("errors", "The provided picture is too heavy")}
+
+        map when is_map(map) ->
+          case API.Groups.update_group(args) do
+            {:ok, _activity, %Actor{type: :Group} = group} ->
+              {:ok, group}
+
+            {:error, _err} ->
+              {:error, dgettext("errors", "Failed to update the group")}
+          end
+      end
     else
-      {:picture, {:error, :file_too_large}} ->
-        {:error, dgettext("errors", "The provided picture is too heavy")}
-
-      {:error, err} when is_binary(err) ->
-        {:error, err}
-
-      {:administrator, false} ->
-        {:error, dgettext("errors", "Profile is not administrator for the group")}
+      {:error, dgettext("errors", "Profile is not administrator for the group")}
     end
   end
 
@@ -183,20 +197,21 @@ defmodule Mobilizon.GraphQL.Resolvers.Group do
   @doc """
   Delete an existing group
   """
+  @spec delete_group(any(), map(), Absinthe.Resolution.t()) ::
+          {:ok, %{id: integer()}} | {:error, String.t()}
   def delete_group(
         _parent,
         %{group_id: group_id},
         %{
           context: %{
-            current_user: user
+            current_actor: %Actor{id: actor_id} = actor
           }
         }
       ) do
-    with %Actor{id: actor_id} = actor <- Users.get_actor_for_user(user),
-         {:ok, %Actor{} = group} <- Actors.get_group_by_actor_id(group_id),
+    with {:ok, %Actor{} = group} <- Actors.get_group_by_actor_id(group_id),
          {:ok, %Member{} = member} <- Actors.get_member(actor_id, group.id),
          {:is_admin, true} <- {:is_admin, Member.is_administrator(member)},
-         {:ok, _activity, group} <- ActivityPub.delete(group, actor, true) do
+         {:ok, _activity, group} <- Actions.Delete.delete(group, actor, true) do
       {:ok, %{id: group.id}}
     else
       {:error, :group_not_found} ->
@@ -218,16 +233,17 @@ defmodule Mobilizon.GraphQL.Resolvers.Group do
   @doc """
   Join an existing group
   """
+  @spec join_group(any(), map(), Absinthe.Resolution.t()) ::
+          {:ok, Member.t()} | {:error, String.t()}
   def join_group(_parent, %{group_id: group_id} = args, %{
-        context: %{current_user: %User{} = user}
+        context: %{current_actor: %Actor{} = actor}
       }) do
-    with %Actor{} = actor <- Users.get_actor_for_user(user),
-         {:ok, %Actor{type: :Group} = group} <-
+    with {:ok, %Actor{type: :Group} = group} <-
            Actors.get_group_by_actor_id(group_id),
          {:error, :member_not_found} <- Actors.get_member(actor.id, group.id),
          {:is_able_to_join, true} <- {:is_able_to_join, Member.can_be_joined(group)},
          {:ok, _activity, %Member{} = member} <-
-           ActivityPub.join(group, actor, true, args) do
+           Actions.Join.join(group, actor, true, args) do
       {:ok, member}
     else
       {:error, :group_not_found} ->
@@ -248,18 +264,20 @@ defmodule Mobilizon.GraphQL.Resolvers.Group do
   @doc """
   Leave a existing group
   """
+  @spec leave_group(any(), map(), Absinthe.Resolution.t()) ::
+          {:ok, Member.t()} | {:error, String.t()}
   def leave_group(
         _parent,
         %{group_id: group_id},
         %{
           context: %{
-            current_user: %User{} = user
+            current_actor: %Actor{} = actor
           }
         }
       ) do
-    with {:actor, %Actor{} = actor} <- {:actor, Users.get_actor_for_user(user)},
-         {:group, %Actor{type: :Group} = group} <- {:group, Actors.get_actor(group_id)},
-         {:ok, _activity, %Member{} = member} <- ActivityPub.leave(group, actor, true) do
+    with {:group, %Actor{type: :Group} = group} <- {:group, Actors.get_actor(group_id)},
+         {:ok, _activity, %Member{} = member} <-
+           Actions.Leave.leave(group, actor, true) do
       {:ok, member}
     else
       {:error, :member_not_found} ->
@@ -268,7 +286,7 @@ defmodule Mobilizon.GraphQL.Resolvers.Group do
       {:group, nil} ->
         {:error, dgettext("errors", "Group not found")}
 
-      {:is_not_only_admin, false} ->
+      {:error, :is_not_only_admin} ->
         {:error,
          dgettext("errors", "You can't leave this group because you are the only administrator")}
     end
@@ -278,6 +296,8 @@ defmodule Mobilizon.GraphQL.Resolvers.Group do
     {:error, dgettext("errors", "You need to be logged-in to leave a group")}
   end
 
+  @spec find_events_for_group(Actor.t(), map(), Absinthe.Resolution.t()) ::
+          {:ok, Page.t(Event.t())}
   def find_events_for_group(
         %Actor{id: group_id} = group,
         %{
@@ -286,13 +306,12 @@ defmodule Mobilizon.GraphQL.Resolvers.Group do
         } = args,
         %{
           context: %{
-            current_user: %User{role: user_role} = user
+            current_user: %User{role: user_role},
+            current_actor: %Actor{id: actor_id}
           }
         }
       ) do
-    with {:actor, %Actor{id: actor_id} = _actor} <- {:actor, Users.get_actor_for_user(user)},
-         {:member, true} <-
-           {:member, Actors.is_member?(actor_id, group_id) or is_moderator(user_role)} do
+    if Actors.is_member?(actor_id, group_id) or is_moderator(user_role) do
       # TODO : Handle public / restricted to group members events
       {:ok,
        Events.list_organized_events_for_group(
@@ -304,8 +323,7 @@ defmodule Mobilizon.GraphQL.Resolvers.Group do
          limit
        )}
     else
-      {:member, false} ->
-        find_events_for_group(group, args, nil)
+      find_events_for_group(group, args, nil)
     end
   end
 
@@ -328,16 +346,15 @@ defmodule Mobilizon.GraphQL.Resolvers.Group do
      )}
   end
 
+  @spec restrict_fields_for_non_member_request(Actor.t()) :: Actor.t()
   defp restrict_fields_for_non_member_request(%Actor{} = group) do
-    Map.merge(
-      group,
-      %{
-        followers: [],
+    %Actor{
+      group
+      | followers: [],
         followings: [],
         organized_events: [],
         comments: [],
         feed_tokens: []
-      }
-    )
+    }
   end
 end
diff --git a/lib/graphql/resolvers/media.ex b/lib/graphql/resolvers/media.ex
index 20ab8e90d..9a7ce5d3f 100644
--- a/lib/graphql/resolvers/media.ex
+++ b/lib/graphql/resolvers/media.ex
@@ -4,7 +4,7 @@ defmodule Mobilizon.GraphQL.Resolvers.Media do
   """
 
   alias Mobilizon.Actors.Actor
-  alias Mobilizon.{Medias, Users}
+  alias Mobilizon.Medias
   alias Mobilizon.Medias.Media
   alias Mobilizon.Users.User
   import Mobilizon.Web.Gettext
@@ -44,10 +44,9 @@ defmodule Mobilizon.GraphQL.Resolvers.Media do
   def upload_media(
         _parent,
         %{file: %Plug.Upload{} = file} = args,
-        %{context: %{current_user: %User{} = user}}
+        %{context: %{current_actor: %Actor{id: actor_id}}}
       ) do
-    with %Actor{id: actor_id} <- Users.get_actor_for_user(user),
-         {:ok,
+    with {:ok,
           %{
             name: _name,
             url: url,
@@ -94,6 +93,7 @@ defmodule Mobilizon.GraphQL.Resolvers.Media do
     else
       {:media, nil} -> {:error, :not_found}
       {:is_owned, _} -> {:error, :unauthorized}
+      {:error, :enofile} -> {:error, "File not found"}
     end
   end
 
diff --git a/lib/graphql/resolvers/member.ex b/lib/graphql/resolvers/member.ex
index 44b9caed4..9c2793254 100644
--- a/lib/graphql/resolvers/member.ex
+++ b/lib/graphql/resolvers/member.ex
@@ -4,9 +4,9 @@ defmodule Mobilizon.GraphQL.Resolvers.Member do
   """
 
   import Mobilizon.Users.Guards
-  alias Mobilizon.{Actors, Users}
+  alias Mobilizon.Actors
   alias Mobilizon.Actors.{Actor, Member}
-  alias Mobilizon.Federation.ActivityPub
+  alias Mobilizon.Federation.ActivityPub.Actions
   alias Mobilizon.Federation.ActivityPub.Actor, as: ActivityPubActor
   alias Mobilizon.Storage.Page
   alias Mobilizon.Users.User
@@ -17,16 +17,16 @@ defmodule Mobilizon.GraphQL.Resolvers.Member do
 
   If actor requesting is not part of the group, we only return the number of members, not members
   """
+  @spec find_members_for_group(Actor.t(), map(), Absinthe.Resolution.t()) ::
+          {:ok, Page.t(Member.t())}
   def find_members_for_group(
         %Actor{id: group_id} = group,
         %{page: page, limit: limit, roles: roles},
         %{
-          context: %{current_user: %User{role: user_role} = user}
+          context: %{current_user: %User{role: user_role}, current_actor: %Actor{id: actor_id}}
         } = _resolution
       ) do
-    with %Actor{id: actor_id} <- Users.get_actor_for_user(user),
-         {:member, true} <-
-           {:member, Actors.is_member?(actor_id, group_id) or is_moderator(user_role)} do
+    if Actors.is_member?(actor_id, group_id) or is_moderator(user_role) do
       roles =
         case roles do
           "" ->
@@ -42,27 +42,25 @@ defmodule Mobilizon.GraphQL.Resolvers.Member do
       %Page{} = page = Actors.list_members_for_group(group, roles, page, limit)
       {:ok, page}
     else
-      {:member, false} ->
-        # Actor is not member of group, fallback to public
-        with %Page{} = page <- Actors.list_members_for_group(group) do
-          {:ok, %Page{page | elements: []}}
-        end
-    end
-  end
-
-  def find_members_for_group(%Actor{} = group, _args, _resolution) do
-    with %Page{} = page <- Actors.list_members_for_group(group) do
+      # Actor is not member of group, fallback to public
+      %Page{} = page = Actors.list_members_for_group(group)
       {:ok, %Page{page | elements: []}}
     end
   end
 
+  def find_members_for_group(%Actor{} = group, _args, _resolution) do
+    %Page{} = page = Actors.list_members_for_group(group)
+    {:ok, %Page{page | elements: []}}
+  end
+
+  @spec invite_member(any(), map(), Absinthe.Resolution.t()) ::
+          {:ok, Member.t()} | {:error, String.t()}
   def invite_member(
         _parent,
         %{group_id: group_id, target_actor_username: target_actor_username},
-        %{context: %{current_user: %User{} = user}}
+        %{context: %{current_actor: %Actor{id: actor_id} = actor}}
       ) do
-    with %Actor{id: actor_id} = actor <- Users.get_actor_for_user(user),
-         {:ok, %Actor{} = group} <- Actors.get_group_by_actor_id(group_id),
+    with {:ok, %Actor{} = group} <- Actors.get_group_by_actor_id(group_id),
          {:has_rights_to_invite, {:ok, %Member{role: role}}}
          when role in [:moderator, :administrator, :creator] <-
            {:has_rights_to_invite, Actors.get_member(actor_id, group_id)},
@@ -73,7 +71,8 @@ defmodule Mobilizon.GraphQL.Resolvers.Member do
             ActivityPubActor.find_or_make_actor_from_nickname(target_actor_username)},
          {:existant, true} <-
            {:existant, check_member_not_existant_or_rejected(target_actor_id, group.id)},
-         {:ok, _activity, %Member{} = member} <- ActivityPub.invite(group, actor, target_actor) do
+         {:ok, _activity, %Member{} = member} <-
+           Actions.Invite.invite(group, actor, target_actor) do
       {:ok, member}
     else
       {:error, :group_not_found} ->
@@ -97,13 +96,16 @@ defmodule Mobilizon.GraphQL.Resolvers.Member do
     end
   end
 
-  def accept_invitation(_parent, %{id: member_id}, %{context: %{current_user: %User{} = user}}) do
-    with %Actor{id: actor_id} <- Users.get_actor_for_user(user),
-         %Member{actor: %Actor{id: member_actor_id}} = member <-
+  @spec accept_invitation(any(), map(), Absinthe.Resolution.t()) ::
+          {:ok, Member.t()} | {:error, String.t()}
+  def accept_invitation(_parent, %{id: member_id}, %{
+        context: %{current_actor: %Actor{id: actor_id}}
+      }) do
+    with %Member{actor: %Actor{id: member_actor_id}} = member <-
            Actors.get_member(member_id),
-         {:is_same_actor, true} <- {:is_same_actor, member_actor_id === actor_id},
+         {:is_same_actor, true} <- {:is_same_actor, member_actor_id == actor_id},
          {:ok, _activity, %Member{} = member} <-
-           ActivityPub.accept(
+           Actions.Accept.accept(
              :invite,
              member,
              true
@@ -115,13 +117,16 @@ defmodule Mobilizon.GraphQL.Resolvers.Member do
     end
   end
 
-  def reject_invitation(_parent, %{id: member_id}, %{context: %{current_user: %User{} = user}}) do
-    with %Actor{id: actor_id} <- Users.get_actor_for_user(user),
-         {:invitation_exists, %Member{actor: %Actor{id: member_actor_id}} = member} <-
+  @spec reject_invitation(any(), map(), Absinthe.Resolution.t()) ::
+          {:ok, Member.t()} | {:error, String.t()}
+  def reject_invitation(_parent, %{id: member_id}, %{
+        context: %{current_actor: %Actor{id: actor_id}}
+      }) do
+    with {:invitation_exists, %Member{actor: %Actor{id: member_actor_id}} = member} <-
            {:invitation_exists, Actors.get_member(member_id)},
-         {:is_same_actor, true} <- {:is_same_actor, member_actor_id === actor_id},
+         {:is_same_actor, true} <- {:is_same_actor, member_actor_id == actor_id},
          {:ok, _activity, %Member{} = member} <-
-           ActivityPub.reject(
+           Actions.Reject.reject(
              :invite,
              member,
              true
@@ -136,19 +141,20 @@ defmodule Mobilizon.GraphQL.Resolvers.Member do
     end
   end
 
+  @spec update_member(any(), map(), Absinthe.Resolution.t()) ::
+          {:ok, Member.t()} | {:error, String.t()}
   def update_member(_parent, %{member_id: member_id, role: role}, %{
-        context: %{current_user: %User{} = user}
+        context: %{current_actor: %Actor{} = moderator}
       }) do
-    with %Actor{} = moderator <- Users.get_actor_for_user(user),
-         %Member{} = member <- Actors.get_member(member_id),
+    with %Member{} = member <- Actors.get_member(member_id),
          {:ok, _activity, %Member{} = member} <-
-           ActivityPub.update(member, %{role: role}, true, %{moderator: moderator}) do
+           Actions.Update.update(member, %{role: role}, true, %{moderator: moderator}) do
       {:ok, member}
     else
-      {:has_rights_to_update_role, {:error, :member_not_found}} ->
+      {:error, :member_not_found} ->
         {:error, dgettext("errors", "You are not a moderator or admin for this group")}
 
-      {:is_only_admin, true} ->
+      {:error, :only_admin_left} ->
         {:error,
          dgettext(
            "errors",
@@ -160,16 +166,18 @@ defmodule Mobilizon.GraphQL.Resolvers.Member do
   def update_member(_parent, _args, _resolution),
     do: {:error, "You must be logged-in to update a member"}
 
+  @spec remove_member(any(), map(), Absinthe.Resolution.t()) ::
+          {:ok, Member.t()} | {:error, String.t()}
   def remove_member(_parent, %{member_id: member_id, group_id: group_id}, %{
-        context: %{current_user: %User{} = user}
+        context: %{current_actor: %Actor{id: moderator_id} = moderator}
       }) do
-    with %Actor{id: moderator_id} = moderator <- Users.get_actor_for_user(user),
-         %Member{role: role} = member when role != :rejected <- Actors.get_member(member_id),
+    with %Member{role: role} = member when role != :rejected <- Actors.get_member(member_id),
          %Actor{type: :Group} = group <- Actors.get_actor(group_id),
          {:has_rights_to_remove, {:ok, %Member{role: role}}}
          when role in [:moderator, :administrator, :creator] <-
            {:has_rights_to_remove, Actors.get_member(moderator_id, group_id)},
-         {:ok, _activity, %Member{}} <- ActivityPub.remove(member, group, moderator, true) do
+         {:ok, _activity, %Member{}} <-
+           Actions.Remove.remove(member, group, moderator, true) do
       {:ok, member}
     else
       %Member{role: :rejected} ->
diff --git a/lib/graphql/resolvers/participant.ex b/lib/graphql/resolvers/participant.ex
index 9c41217fb..df3ab9bff 100644
--- a/lib/graphql/resolvers/participant.ex
+++ b/lib/graphql/resolvers/participant.ex
@@ -2,7 +2,7 @@ defmodule Mobilizon.GraphQL.Resolvers.Participant do
   @moduledoc """
   Handles the participation-related GraphQL calls.
   """
-  alias Mobilizon.{Actors, Config, Crypto, Events, Users}
+  alias Mobilizon.{Actors, Config, Crypto, Events}
   alias Mobilizon.Actors.Actor
   alias Mobilizon.Events.{Event, Participant}
   alias Mobilizon.GraphQL.API.Participations
@@ -16,6 +16,8 @@ defmodule Mobilizon.GraphQL.Resolvers.Participant do
   @doc """
   Join an event for an regular or anonymous actor
   """
+  @spec actor_join_event(any(), map(), Absinthe.Resolution.t()) ::
+          {:ok, Participant.t()} | {:error, String.t()}
   def actor_join_event(
         _parent,
         %{actor_id: actor_id, event_id: event_id} = args,
@@ -117,7 +119,7 @@ defmodule Mobilizon.GraphQL.Resolvers.Participant do
            |> Map.put(:actor, actor) do
       {:ok, participant}
     else
-      {:maximum_attendee_capacity, _} ->
+      {:error, :maximum_attendee_capacity_reached} ->
         {:error, dgettext("errors", "The event has already reached its maximum capacity")}
 
       {:has_event, _} ->
@@ -127,47 +129,65 @@ defmodule Mobilizon.GraphQL.Resolvers.Participant do
       {:error, :event_not_found} ->
         {:error, dgettext("errors", "Event id not found")}
 
-      {:ok, %Participant{}} ->
+      {:error, :already_participant} ->
         {:error, dgettext("errors", "You are already a participant of this event")}
     end
   end
 
+  @spec check_anonymous_participation(String.t(), String.t()) ::
+          {:ok, Event.t()} | {:error, String.t()}
+  defp check_anonymous_participation(actor_id, event_id) do
+    cond do
+      Config.anonymous_participation?() == false ->
+        {:error, dgettext("errors", "Anonymous participation is not enabled")}
+
+      to_string(Config.anonymous_actor_id()) != actor_id ->
+        {:error, dgettext("errors", "The anonymous actor ID is invalid")}
+
+      true ->
+        case Mobilizon.Events.get_event_with_preload(event_id) do
+          {:ok, %Event{} = event} ->
+            {:ok, event}
+
+          {:error, :event_not_found} ->
+            {:error,
+             dgettext("errors", "Event with this ID %{id} doesn't exist", id: inspect(event_id))}
+        end
+    end
+  end
+
   @doc """
   Leave an event for an anonymous actor
   """
+  @spec actor_leave_event(any(), map(), Absinthe.Resolution.t()) ::
+          {:ok, map()} | {:error, String.t()}
   def actor_leave_event(
         _parent,
         %{actor_id: actor_id, event_id: event_id, token: token},
         _resolution
       )
       when not is_nil(token) do
-    with {:anonymous_participation_enabled, true} <-
-           {:anonymous_participation_enabled, Config.anonymous_participation?()},
-         {:anonymous_actor_id, true} <-
-           {:anonymous_actor_id, to_string(Config.anonymous_actor_id()) == actor_id},
-         {:has_event, {:ok, %Event{} = event}} <-
-           {:has_event, Mobilizon.Events.get_event_with_preload(event_id)},
-         %Actor{} = actor <- Actors.get_actor_with_preload(actor_id),
-         {:ok, _activity, %Participant{id: participant_id} = _participant} <-
-           Participations.leave(event, actor, %{local: false, cancellation_token: token}) do
-      {:ok, %{event: %{id: event_id}, actor: %{id: actor_id}, id: participant_id}}
-    else
-      {:has_event, _} ->
-        {:error,
-         dgettext("errors", "Event with this ID %{id} doesn't exist", id: inspect(event_id))}
+    case check_anonymous_participation(actor_id, event_id) do
+      {:ok, %Event{} = event} ->
+        %Actor{} = actor = Actors.get_actor_with_preload!(actor_id)
 
-      {:is_owned, nil} ->
-        {:error, dgettext("errors", "Profile is not owned by authenticated user")}
+        case Participations.leave(event, actor, %{local: false, cancellation_token: token}) do
+          {:ok, _activity, %Participant{id: participant_id} = _participant} ->
+            {:ok, %{event: %{id: event_id}, actor: %{id: actor_id}, id: participant_id}}
 
-      {:only_organizer, true} ->
-        {:error,
-         dgettext(
-           "errors",
-           "You can't leave event because you're the only event creator participant"
-         )}
+          {:error, :is_only_organizer} ->
+            {:error,
+             dgettext(
+               "errors",
+               "You can't leave event because you're the only event creator participant"
+             )}
 
-      {:error, :participant_not_found} ->
-        {:error, dgettext("errors", "Participant not found")}
+          {:error, :participant_not_found} ->
+            {:error, dgettext("errors", "Participant not found")}
+
+          {:error, _err} ->
+            {:error, dgettext("errors", "Failed to leave the event")}
+        end
     end
   end
 
@@ -188,7 +208,7 @@ defmodule Mobilizon.GraphQL.Resolvers.Participant do
       {:is_owned, nil} ->
         {:error, dgettext("errors", "Profile is not owned by authenticated user")}
 
-      {:only_organizer, true} ->
+      {:error, :is_only_organizer} ->
         {:error,
          dgettext(
            "errors",
@@ -204,19 +224,19 @@ defmodule Mobilizon.GraphQL.Resolvers.Participant do
     {:error, dgettext("errors", "You need to be logged-in to leave an event")}
   end
 
+  @spec update_participation(any(), map(), Absinthe.Resolution.t()) ::
+          {:ok, Participation.t()} | {:error, String.t()}
   def update_participation(
         _parent,
         %{id: participation_id, role: new_role},
         %{
           context: %{
-            current_user: user
+            current_actor: %Actor{} = moderator_actor
           }
         }
       ) do
-    # Check that moderator provided is rightly authenticated
-    with %Actor{} = moderator_actor <- Users.get_actor_for_user(user),
-         # Check that participation already exists
-         {:has_participation, %Participant{role: old_role, event_id: event_id} = participation} <-
+    # Check that participation already exists
+    with {:has_participation, %Participant{role: old_role, event_id: event_id} = participation} <-
            {:has_participation, Events.get_participant(participation_id)},
          {:same_role, false} <- {:same_role, new_role == old_role},
          # Check that moderator has right
diff --git a/lib/graphql/resolvers/person.ex b/lib/graphql/resolvers/person.ex
index b8818fae3..709927d40 100644
--- a/lib/graphql/resolvers/person.ex
+++ b/lib/graphql/resolvers/person.ex
@@ -12,7 +12,7 @@ defmodule Mobilizon.GraphQL.Resolvers.Person do
   alias Mobilizon.Users.User
   import Mobilizon.Web.Gettext
 
-  alias Mobilizon.Federation.ActivityPub
+  alias Mobilizon.Federation.ActivityPub.Actions
   alias Mobilizon.Federation.ActivityPub.Actor, as: ActivityPubActor
   require Logger
 
@@ -21,6 +21,8 @@ defmodule Mobilizon.GraphQL.Resolvers.Person do
   @doc """
   Get a person
   """
+  @spec get_person(any(), map(), Absinthe.Resolution.t()) ::
+          {:ok, Actor.t()} | {:error, String.t() | :unauthorized}
   def get_person(_parent, %{id: id}, %{context: %{current_user: %User{role: role}}}) do
     with %Actor{suspended: suspended} = actor <- Actors.get_actor_with_preload(id, true),
          true <- suspended == false or is_moderator(role) do
@@ -36,6 +38,8 @@ defmodule Mobilizon.GraphQL.Resolvers.Person do
   @doc """
   Find a person
   """
+  @spec fetch_person(any(), map(), Absinthe.Resolution.t()) ::
+          {:ok, Actor.t()} | {:error, String.t() | :unauthorized | :unauthenticated}
   def fetch_person(_parent, %{preferred_username: preferred_username}, %{
         context: %{current_user: %User{} = user}
       }) do
@@ -57,6 +61,8 @@ defmodule Mobilizon.GraphQL.Resolvers.Person do
 
   def fetch_person(_parent, _args, _resolution), do: {:error, :unauthenticated}
 
+  @spec list_persons(any(), map(), Absinthe.Resolution.t()) ::
+          {:ok, Page.t(Actor.t())} | {:error, :unauthorized | :unauthenticated}
   def list_persons(
         _parent,
         %{
@@ -91,8 +97,14 @@ defmodule Mobilizon.GraphQL.Resolvers.Person do
   @doc """
   Returns the current actor for the currently logged-in user
   """
-  def get_current_person(_parent, _args, %{context: %{current_user: user}}) do
-    {:ok, Users.get_actor_for_user(user)}
+  @spec get_current_person(any, any, Absinthe.Resolution.t()) ::
+          {:error, :unauthenticated | :no_current_person} | {:ok, Actor.t()}
+  def get_current_person(_parent, _args, %{context: %{current_actor: %Actor{} = actor}}) do
+    {:ok, actor}
+  end
+
+  def get_current_person(_parent, _args, %{context: %{current_user: %User{}}}) do
+    {:error, :no_current_person}
   end
 
   def get_current_person(_parent, _args, _resolution) do
@@ -102,6 +114,8 @@ defmodule Mobilizon.GraphQL.Resolvers.Person do
   @doc """
   Returns the list of identities for the logged-in user
   """
+  @spec identities(any, any, Absinthe.Resolution.t()) ::
+          {:error, :unauthenticated} | {:ok, list(Actor.t())}
   def identities(_parent, _args, %{context: %{current_user: user}}) do
     {:ok, Users.get_actors_for_user(user)}
   end
@@ -113,6 +127,8 @@ defmodule Mobilizon.GraphQL.Resolvers.Person do
   @doc """
   This function is used to create more identities from an existing user
   """
+  @spec create_person(any(), map(), Absinthe.Resolution.t()) ::
+          {:ok, Actor.t()} | {:error, String.t() | :unauthenticated}
   def create_person(
         _parent,
         %{preferred_username: _preferred_username} = args,
@@ -140,6 +156,8 @@ defmodule Mobilizon.GraphQL.Resolvers.Person do
   @doc """
   This function is used to update an existing identity
   """
+  @spec update_person(any(), map(), Absinthe.Resolution.t()) ::
+          {:ok, Actor.t()} | {:error, String.t() | :unauthenticated}
   def update_person(
         _parent,
         %{id: id} = args,
@@ -148,21 +166,24 @@ defmodule Mobilizon.GraphQL.Resolvers.Person do
     require Logger
     args = Map.put(args, :user_id, user.id)
 
-    with {:find_actor, %Actor{} = actor} <-
-           {:find_actor, Actors.get_actor(id)},
-         {:is_owned, %Actor{}} <- User.owns_actor(user, actor.id),
-         {:picture, args} when is_map(args) <- {:picture, save_attached_pictures(args)},
-         {:ok, _activity, %Actor{} = actor} <- ActivityPub.update(actor, args, true) do
-      {:ok, actor}
-    else
-      {:picture, {:error, :file_too_large}} ->
-        {:error, dgettext("errors", "The provided picture is too heavy")}
+    case owned_actor(user, id) do
+      {:ok, %Actor{} = actor} ->
+        case save_attached_pictures(args) do
+          args when is_map(args) ->
+            case Actions.Update.update(actor, args, true) do
+              {:ok, _activity, %Actor{} = actor} ->
+                {:ok, actor}
 
-      {:find_actor, nil} ->
-        {:error, dgettext("errors", "Profile not found")}
+              {:error, err} ->
+                {:error, err}
+            end
 
-      {:is_owned, nil} ->
-        {:error, dgettext("errors", "Profile is not owned by authenticated user")}
+          {:error, :file_too_large} ->
+            {:error, dgettext("errors", "The provided picture is too heavy")}
+        end
+
+      {:error, err} ->
+        {:error, err}
     end
   end
 
@@ -173,30 +194,27 @@ defmodule Mobilizon.GraphQL.Resolvers.Person do
   @doc """
   This function is used to delete an existing identity
   """
+  @spec delete_person(any(), map(), Absinthe.Resolution.t()) ::
+          {:ok, Actor.t()} | {:error, String.t() | :unauthenticated}
   def delete_person(
         _parent,
         %{id: id} = _args,
-        %{context: %{current_user: user}} = _resolution
+        %{context: %{current_user: %User{} = user}} = _resolution
       ) do
-    with {:find_actor, %Actor{} = actor} <-
-           {:find_actor, Actors.get_actor(id)},
-         {:is_owned, %Actor{}} <- User.owns_actor(user, actor.id),
-         {:last_identity, false} <- {:last_identity, last_identity?(user)},
-         {:last_admin, false} <- {:last_admin, last_admin_of_a_group?(actor.id)},
-         {:ok, actor} <- Actors.delete_actor(actor) do
-      {:ok, actor}
-    else
-      {:find_actor, nil} ->
-        {:error, dgettext("errors", "Profile not found")}
+    case owned_actor(user, id) do
+      {:ok, %Actor{} = actor} ->
+        if last_identity?(user) do
+          {:error, dgettext("errors", "Cannot remove the last identity of a user")}
+        else
+          if last_admin_of_a_group?(actor.id) do
+            {:error, dgettext("errors", "Cannot remove the last administrator of a group")}
+          else
+            Actors.delete_actor(actor)
+          end
+        end
 
-      {:last_identity, true} ->
-        {:error, dgettext("errors", "Cannot remove the last identity of a user")}
-
-      {:last_admin, true} ->
-        {:error, dgettext("errors", "Cannot remove the last administrator of a group")}
-
-      {:is_owned, nil} ->
-        {:error, dgettext("errors", "Profile is not owned by authenticated user")}
+      {:error, err} ->
+        {:error, err}
     end
   end
 
@@ -204,95 +222,135 @@ defmodule Mobilizon.GraphQL.Resolvers.Person do
     {:error, :unauthenticated}
   end
 
+  @spec owned_actor(User.t(), integer() | String.t()) :: {:error, String.t()} | {:ok, Actor.t()}
+  defp owned_actor(%User{} = user, actor_id) do
+    with {:find_actor, %Actor{} = actor} <-
+           {:find_actor, Actors.get_actor(actor_id)},
+         {:is_owned, %Actor{}} <- User.owns_actor(user, actor.id) do
+      {:ok, actor}
+    else
+      {:find_actor, nil} ->
+        {:error, dgettext("errors", "Profile not found")}
+
+      {:is_owned, nil} ->
+        {:error, dgettext("errors", "Profile is not owned by authenticated user")}
+    end
+  end
+
+  @spec last_identity?(User.t()) :: boolean
   defp last_identity?(user) do
     length(Users.get_actors_for_user(user)) <= 1
   end
 
+  @spec save_attached_pictures(map()) :: map() | {:error, any()}
   defp save_attached_pictures(args) do
-    with args when is_map(args) <- save_attached_picture(args, :avatar),
-         args when is_map(args) <- save_attached_picture(args, :banner) do
-      args
+    case save_attached_picture(args, :avatar) do
+      {:error, err} ->
+        {:error, err}
+
+      args when is_map(args) ->
+        case save_attached_picture(args, :banner) do
+          {:error, err} ->
+            {:error, err}
+
+          args when is_map(args) ->
+            args
+        end
     end
   end
 
+  @spec save_attached_picture(map(), :avatar | :banner) :: map() | {:error, any}
   defp save_attached_picture(args, key) do
     if Map.has_key?(args, key) && !is_nil(args[key][:media]) do
-      with media when is_map(media) <- save_picture(args[key][:media], key) do
-        Map.put(args, key, media)
+      case save_picture(args[key][:media], key) do
+        {:error, err} ->
+          {:error, err}
+
+        media when is_map(media) ->
+          Map.put(args, key, media)
       end
     else
       args
     end
   end
 
+  @spec save_picture(map(), :avatar | :banner) :: {:ok, map()} | {:error, any()}
   defp save_picture(media, key) do
-    with {:ok, %{name: name, url: url, content_type: content_type, size: size}} <-
-           Upload.store(media.file, type: key, description: media.alt) do
-      %{"name" => name, "url" => url, "content_type" => content_type, "size" => size}
+    case Upload.store(media.file, type: key, description: media.alt) do
+      {:ok, %{name: name, url: url, content_type: content_type, size: size}} ->
+        %{"name" => name, "url" => url, "content_type" => content_type, "size" => size}
+
+      {:error, err} ->
+        {:error, err}
     end
   end
 
   @doc """
   This function is used to register a person afterwards the user has been created (but not activated)
   """
+  @spec register_person(any(), map(), Absinthe.Resolution.t()) ::
+          {:ok, Actor.t()} | {:error, String.t()}
   def register_person(_parent, args, _resolution) do
     # When registering, email is assumed confirmed (unlike changing email)
-    with {:ok, %User{} = user} <- Users.get_user_by_email(args.email, unconfirmed: false),
-         user_actor <- Users.get_actor_for_user(user),
-         no_actor <- is_nil(user_actor),
-         {:no_actor, true} <- {:no_actor, no_actor},
-         args <- Map.update(args, :preferred_username, "", &String.downcase/1),
-         args <- Map.put(args, :user_id, user.id),
-         {:picture, args} when is_map(args) <- {:picture, save_attached_pictures(args)},
-         {:ok, %Actor{} = new_person} <- Actors.new_person(args, true) do
-      {:ok, new_person}
-    else
-      {:picture, {:error, :file_too_large}} ->
-        {:error, dgettext("errors", "The provided picture is too heavy")}
+    case Users.get_user_by_email(args.email, unconfirmed: false) do
+      {:ok, %User{} = user} ->
+        if is_nil(Users.get_actor_for_user(user)) do
+          # No profile yet, we can create one
+          case prepare_args(args, user) do
+            args when is_map(args) ->
+              Actors.new_person(args, true)
+
+            {:error, :file_too_large} ->
+              {:error, dgettext("errors", "The provided picture is too heavy")}
+
+            {:error, _err} ->
+              {:error, dgettext("errors", "Error while uploading pictures")}
+          end
+        else
+          {:error, dgettext("errors", "You already have a profile for this user")}
+        end
 
       {:error, :user_not_found} ->
         {:error, dgettext("errors", "No user with this email was found")}
-
-      {:no_actor, _} ->
-        {:error, dgettext("errors", "You already have a profile for this user")}
-
-      {:error, %Ecto.Changeset{} = e} ->
-        {:error, e}
     end
   end
 
+  @spec prepare_args(map(), User.t()) :: map() | {:error, any()}
+  defp prepare_args(args, %User{} = user) do
+    args
+    |> Map.update(:preferred_username, "", &String.downcase/1)
+    |> Map.put(:user_id, user.id)
+    |> save_attached_pictures()
+  end
+
   @doc """
   Returns the participations, optionally restricted to an event
   """
+  @spec person_participations(Actor.t(), map(), Absinthe.Resolution.t()) ::
+          {:ok, Page.t(Participant.t())} | {:error, :unauthorized | String.t()}
   def person_participations(
         %Actor{id: actor_id} = person,
         %{event_id: event_id},
         %{context: %{current_user: %User{} = user}}
       ) do
-    with {:can_get_participations, true} <-
-           {:can_get_participations, user_can_access_person_details?(person, user)},
-         {:no_participant, {:ok, %Participant{} = participant}} <-
-           {:no_participant, Events.get_participant(event_id, actor_id)} do
-      {:ok, %Page{elements: [participant], total: 1}}
+    if user_can_access_person_details?(person, user) do
+      case Events.get_participant(event_id, actor_id) do
+        {:ok, %Participant{} = participant} -> {:ok, %Page{elements: [participant], total: 1}}
+        {:error, :participant_not_found} -> {:ok, %Page{elements: [], total: 0}}
+      end
     else
-      {:is_owned, nil} ->
-        {:error, dgettext("errors", "Profile is not owned by authenticated user")}
-
-      {:no_participant, _} ->
-        {:ok, %Page{elements: [], total: 0}}
+      {:error, :unauthorized}
     end
   end
 
   def person_participations(%Actor{} = person, %{page: page, limit: limit}, %{
         context: %{current_user: %User{} = user}
       }) do
-    with {:can_get_participations, true} <-
-           {:can_get_participations, user_can_access_person_details?(person, user)},
-         %Page{} = page <- Events.list_event_participations_for_actor(person, page, limit) do
+    if user_can_access_person_details?(person, user) do
+      %Page{} = page = Events.list_event_participations_for_actor(person, page, limit)
       {:ok, page}
     else
-      {:can_get_participations, false} ->
-        {:error, dgettext("errors", "Profile is not owned by authenticated user")}
+      {:error, dgettext("errors", "Profile is not owned by authenticated user")}
     end
   end
 
@@ -303,24 +361,23 @@ defmodule Mobilizon.GraphQL.Resolvers.Person do
   def person_memberships(%Actor{id: actor_id} = person, %{group: group}, %{
         context: %{current_user: %User{} = user}
       }) do
-    with {:can_get_memberships, true} <-
-           {:can_get_memberships, user_can_access_person_details?(person, user)},
-         {:group, %Actor{id: group_id}} <- {:group, Actors.get_actor_by_name(group, :Group)},
-         {:ok, %Member{} = membership} <- Actors.get_member(actor_id, group_id),
-         memberships <- %Page{
+    if user_can_access_person_details?(person, user) do
+      with {:group, %Actor{id: group_id}} <- {:group, Actors.get_actor_by_name(group, :Group)},
+           {:ok, %Member{} = membership} <- Actors.get_member(actor_id, group_id) do
+        {:ok,
+         %Page{
            total: 1,
            elements: [Repo.preload(membership, [:actor, :parent, :invited_by])]
-         } do
-      {:ok, memberships}
+         }}
+      else
+        {:error, :member_not_found} ->
+          {:ok, %Page{total: 0, elements: []}}
+
+        {:group, nil} ->
+          {:error, :group_not_found}
+      end
     else
-      {:error, :member_not_found} ->
-        {:ok, %Page{total: 0, elements: []}}
-
-      {:group, nil} ->
-        {:error, :group_not_found}
-
-      {:can_get_memberships, _} ->
-        {:error, dgettext("errors", "Profile is not owned by authenticated user")}
+      {:error, dgettext("errors", "Profile is not owned by authenticated user")}
     end
   end
 
@@ -341,6 +398,8 @@ defmodule Mobilizon.GraphQL.Resolvers.Person do
     end
   end
 
+  @spec user_for_person(Actor.t(), map(), Absinthe.Resolution.t()) ::
+          {:ok, User.t() | nil} | {:error, String.t() | nil}
   def user_for_person(%Actor{type: :Person, user_id: user_id}, _args, %{
         context: %{current_user: %User{role: role}}
       })
@@ -359,6 +418,8 @@ defmodule Mobilizon.GraphQL.Resolvers.Person do
 
   def user_for_person(_, _args, _resolution), do: {:error, nil}
 
+  @spec organized_events_for_person(Actor.t(), map(), Absinthe.Resolution.t()) ::
+          {:ok, Page.t(Event.t())} | {:error, :unauthorized}
   def organized_events_for_person(
         %Actor{} = person,
         %{page: page, limit: limit},
@@ -366,13 +427,11 @@ defmodule Mobilizon.GraphQL.Resolvers.Person do
           context: %{current_user: %User{} = user}
         }
       ) do
-    with {:can_get_events, true} <-
-           {:can_get_events, user_can_access_person_details?(person, user)},
-         %Page{} = page <- Events.list_organized_events_for_actor(person, page, limit) do
+    if user_can_access_person_details?(person, user) do
+      %Page{} = page = Events.list_organized_events_for_actor(person, page, limit)
       {:ok, page}
     else
-      {:can_get_events, false} ->
-        {:error, :unauthorized}
+      {:error, :unauthorized}
     end
   end
 
diff --git a/lib/graphql/resolvers/post.ex b/lib/graphql/resolvers/post.ex
index 0ea6b21e1..70ad40cdc 100644
--- a/lib/graphql/resolvers/post.ex
+++ b/lib/graphql/resolvers/post.ex
@@ -4,10 +4,9 @@ defmodule Mobilizon.GraphQL.Resolvers.Post do
   """
 
   import Mobilizon.Users.Guards
-  alias Mobilizon.{Actors, Posts, Users}
+  alias Mobilizon.{Actors, Posts}
   alias Mobilizon.Actors.Actor
-  alias Mobilizon.Federation.ActivityPub
-  alias Mobilizon.Federation.ActivityPub.{Permission, Utils}
+  alias Mobilizon.Federation.ActivityPub.{Actions, Permission, Utils}
   alias Mobilizon.Posts.Post
   alias Mobilizon.Storage.Page
   alias Mobilizon.Users.User
@@ -22,23 +21,22 @@ defmodule Mobilizon.GraphQL.Resolvers.Post do
 
   Returns only if actor requesting is a member of the group
   """
+  @spec find_posts_for_group(Actor.t(), map(), Absinthe.Resolution.t()) :: {:ok, Page.t(Post.t())}
   def find_posts_for_group(
         %Actor{id: group_id} = group,
         %{page: page, limit: limit} = args,
         %{
           context: %{
-            current_user: %User{role: user_role} = user
+            current_user: %User{role: user_role},
+            current_actor: %Actor{id: actor_id}
           }
         } = _resolution
       ) do
-    with %Actor{id: actor_id} <- Users.get_actor_for_user(user),
-         {:member, true} <-
-           {:member, Actors.is_member?(actor_id, group_id) or is_moderator(user_role)},
-         %Page{} = page <- Posts.get_posts_for_group(group, page, limit) do
+    if Actors.is_member?(actor_id, group_id) or is_moderator(user_role) do
+      %Page{} = page = Posts.get_posts_for_group(group, page, limit)
       {:ok, page}
     else
-      {:member, _} ->
-        find_posts_for_group(group, args, nil)
+      find_posts_for_group(group, args, nil)
     end
   end
 
@@ -47,9 +45,8 @@ defmodule Mobilizon.GraphQL.Resolvers.Post do
         %{page: page, limit: limit},
         _resolution
       ) do
-    with %Page{} = page <- Posts.get_public_posts_for_group(group, page, limit) do
-      {:ok, page}
-    end
+    %Page{} = page = Posts.get_public_posts_for_group(group, page, limit)
+    {:ok, page}
   end
 
   def find_posts_for_group(
@@ -60,18 +57,19 @@ defmodule Mobilizon.GraphQL.Resolvers.Post do
     {:ok, %Page{total: 0, elements: []}}
   end
 
+  @spec get_post(any(), map(), Absinthe.Resolution.t()) ::
+          {:ok, Post.t()} | {:error, :post_not_found}
   def get_post(
         parent,
         %{slug: slug},
         %{
           context: %{
-            current_user: %User{role: user_role} = user
+            current_user: %User{role: user_role},
+            current_actor: %Actor{} = current_profile
           }
         } = _resolution
       ) do
-    with {:current_actor, %Actor{} = current_profile} <-
-           {:current_actor, Users.get_actor_for_user(user)},
-         {:post, %Post{attributed_to: %Actor{}} = post} <-
+    with {:post, %Post{attributed_to: %Actor{}} = post} <-
            {:post, Posts.get_post_by_slug_with_preloads(slug)},
          {:member, true} <-
            {:member,
@@ -102,17 +100,18 @@ defmodule Mobilizon.GraphQL.Resolvers.Post do
     {:error, :post_not_found}
   end
 
+  @spec create_post(any(), map(), Absinthe.Resolution.t()) ::
+          {:ok, Post.t()} | {:error, String.t()}
   def create_post(
         _parent,
         %{attributed_to_id: group_id} = args,
         %{
           context: %{
-            current_user: %User{} = user
+            current_actor: %Actor{id: actor_id}
           }
         } = _resolution
       ) do
-    with %Actor{id: actor_id} <- Users.get_actor_for_user(user),
-         {:member, true} <- {:member, Actors.is_member?(actor_id, group_id)},
+    with {:member, true} <- {:member, Actors.is_member?(actor_id, group_id)},
          %Actor{} = group <- Actors.get_actor(group_id),
          args <-
            Map.update(args, :picture, nil, fn picture ->
@@ -120,7 +119,7 @@ defmodule Mobilizon.GraphQL.Resolvers.Post do
            end),
          args <- extract_pictures_from_post_body(args, actor_id),
          {:ok, _, %Post{} = post} <-
-           ActivityPub.create(
+           Actions.Create.create(
              :post,
              args
              |> Map.put(:author_id, actor_id)
@@ -142,17 +141,18 @@ defmodule Mobilizon.GraphQL.Resolvers.Post do
     {:error, dgettext("errors", "You need to be logged-in to create posts")}
   end
 
+  @spec update_post(any(), map(), Absinthe.Resolution.t()) ::
+          {:ok, Post.t()} | {:error, String.t()}
   def update_post(
         _parent,
         %{id: id} = args,
         %{
           context: %{
-            current_user: %User{} = user
+            current_actor: %Actor{id: actor_id, url: actor_url}
           }
         } = _resolution
       ) do
     with {:uuid, {:ok, _uuid}} <- {:uuid, Ecto.UUID.cast(id)},
-         %Actor{id: actor_id, url: actor_url} <- Users.get_actor_for_user(user),
          {:post, %Post{attributed_to: %Actor{id: group_id} = group} = post} <-
            {:post, Posts.get_post_with_preloads(id)},
          args <-
@@ -162,7 +162,7 @@ defmodule Mobilizon.GraphQL.Resolvers.Post do
          args <- extract_pictures_from_post_body(args, actor_id),
          {:member, true} <- {:member, Actors.is_member?(actor_id, group_id)},
          {:ok, _, %Post{} = post} <-
-           ActivityPub.update(post, args, true, %{"actor" => actor_url}) do
+           Actions.Update.update(post, args, true, %{"actor" => actor_url}) do
       {:ok, post}
     else
       {:uuid, :error} ->
@@ -180,22 +180,23 @@ defmodule Mobilizon.GraphQL.Resolvers.Post do
     {:error, dgettext("errors", "You need to be logged-in to update posts")}
   end
 
+  @spec delete_post(any(), map(), Absinthe.Resolution.t()) ::
+          {:ok, Post.t()} | {:error, String.t()}
   def delete_post(
         _parent,
         %{id: post_id},
         %{
           context: %{
-            current_user: %User{} = user
+            current_actor: %Actor{id: actor_id} = actor
           }
         } = _resolution
       ) do
     with {:uuid, {:ok, _uuid}} <- {:uuid, Ecto.UUID.cast(post_id)},
-         %Actor{id: actor_id} = actor <- Users.get_actor_for_user(user),
          {:post, %Post{attributed_to: %Actor{id: group_id}} = post} <-
            {:post, Posts.get_post_with_preloads(post_id)},
          {:member, true} <- {:member, Actors.is_member?(actor_id, group_id)},
          {:ok, _, %Post{} = post} <-
-           ActivityPub.delete(post, actor) do
+           Actions.Delete.delete(post, actor) do
       {:ok, post}
     else
       {:uuid, :error} ->
@@ -213,6 +214,7 @@ defmodule Mobilizon.GraphQL.Resolvers.Post do
     {:error, dgettext("errors", "You need to be logged-in to delete posts")}
   end
 
+  @spec process_picture(map() | nil, Actor.t()) :: nil | map()
   defp process_picture(nil, _), do: nil
   defp process_picture(%{media_id: _picture_id} = args, _), do: args
 
diff --git a/lib/graphql/resolvers/push_subscription.ex b/lib/graphql/resolvers/push_subscription.ex
index dd2018dbf..5501fa8b2 100644
--- a/lib/graphql/resolvers/push_subscription.ex
+++ b/lib/graphql/resolvers/push_subscription.ex
@@ -10,6 +10,8 @@ defmodule Mobilizon.GraphQL.Resolvers.PushSubscription do
   @doc """
   List all of an user's registered push subscriptions
   """
+  @spec list_user_push_subscriptions(any(), map(), Absinthe.Resolution.t()) ::
+          {:ok, Page.t(PushSubscription.t())} | {:error, :unauthenticated}
   def list_user_push_subscriptions(_parent, %{page: page, limit: limit}, %{
         context: %{current_user: %User{id: user_id}}
       }) do
@@ -22,6 +24,8 @@ defmodule Mobilizon.GraphQL.Resolvers.PushSubscription do
   @doc """
   Register a push subscription
   """
+  @spec register_push_subscription(any(), map(), Absinthe.Resolution.t()) ::
+          {:ok, String.t()} | {:error, String.t()}
   def register_push_subscription(_parent, args, %{
         context: %{current_user: %User{id: user_id}}
       }) do
diff --git a/lib/graphql/resolvers/report.ex b/lib/graphql/resolvers/report.ex
index feed38ec2..f5a0b8f12 100644
--- a/lib/graphql/resolvers/report.ex
+++ b/lib/graphql/resolvers/report.ex
@@ -5,7 +5,7 @@ defmodule Mobilizon.GraphQL.Resolvers.Report do
 
   import Mobilizon.Users.Guards
 
-  alias Mobilizon.{Actors, Config, Reports, Users}
+  alias Mobilizon.{Actors, Config, Reports}
   alias Mobilizon.Actors.Actor
   alias Mobilizon.Reports.{Note, Report}
   alias Mobilizon.Users.User
@@ -13,6 +13,8 @@ defmodule Mobilizon.GraphQL.Resolvers.Report do
 
   alias Mobilizon.GraphQL.API
 
+  @spec list_reports(any(), map(), Absinthe.Resolution.t()) ::
+          {:ok, Page.t(Report.t())} | {:error, String.t()}
   def list_reports(
         _parent,
         %{page: page, limit: limit, status: status},
@@ -26,6 +28,8 @@ defmodule Mobilizon.GraphQL.Resolvers.Report do
     {:error, dgettext("errors", "You need to be logged-in and a moderator to list reports")}
   end
 
+  @spec get_report(any(), map(), Absinthe.Resolution.t()) ::
+          {:ok, Report.t()} | {:error, String.t()}
   def get_report(_parent, %{id: id}, %{context: %{current_user: %User{role: role}}})
       when is_moderator(role) do
     case Mobilizon.Reports.get_report(id) do
@@ -44,16 +48,17 @@ defmodule Mobilizon.GraphQL.Resolvers.Report do
   @doc """
   Create a report, either logged-in or anonymously
   """
+  @spec create_report(any(), map(), Absinthe.Resolution.t()) ::
+          {:ok, Report.t()} | {:error, String.t()}
   def create_report(
         _parent,
         args,
-        %{context: %{current_user: %User{} = user}} = _resolution
+        %{context: %{current_actor: %Actor{id: reporter_id}}} = _resolution
       ) do
-    with %Actor{id: reporter_id} <- Users.get_actor_for_user(user),
-         {:ok, _, %Report{} = report} <-
-           args |> Map.put(:reporter_id, reporter_id) |> API.Reports.report() do
-      {:ok, report}
-    else
+    case args |> Map.put(:reporter_id, reporter_id) |> API.Reports.report() do
+      {:ok, _, %Report{} = report} ->
+        {:ok, report}
+
       _error ->
         {:error, dgettext("errors", "Error while saving report")}
     end
@@ -81,14 +86,15 @@ defmodule Mobilizon.GraphQL.Resolvers.Report do
   @doc """
   Update a report's status
   """
+  @spec update_report(any(), map(), Absinthe.Resolution.t()) ::
+          {:ok, Report.t()} | {:error, String.t()}
   def update_report(
         _parent,
         %{report_id: report_id, status: status},
-        %{context: %{current_user: %User{role: role} = user}}
+        %{context: %{current_user: %User{role: role}, current_actor: %Actor{} = actor}}
       )
       when is_moderator(role) do
-    with %Actor{} = actor <- Users.get_actor_for_user(user),
-         %Report{} = report <- Mobilizon.Reports.get_report(report_id),
+    with %Report{} = report <- Mobilizon.Reports.get_report(report_id),
          {:ok, %Report{} = report} <- API.Reports.update_report_status(actor, report, status) do
       {:ok, report}
     else
@@ -101,28 +107,28 @@ defmodule Mobilizon.GraphQL.Resolvers.Report do
     {:error, dgettext("errors", "You need to be logged-in and a moderator to update a report")}
   end
 
+  @spec create_report_note(any(), map(), Absinthe.Resolution.t()) :: {:ok, Note.t()}
   def create_report_note(
         _parent,
         %{report_id: report_id, content: content},
-        %{context: %{current_user: %User{role: role} = user}}
+        %{context: %{current_user: %User{role: role}, current_actor: %Actor{id: moderator_id}}}
       )
       when is_moderator(role) do
-    with %Actor{id: moderator_id} <- Users.get_actor_for_user(user),
-         %Report{} = report <- Reports.get_report(report_id),
+    with %Report{} = report <- Reports.get_report(report_id),
          %Actor{} = moderator <- Actors.get_local_actor_with_preload(moderator_id),
          {:ok, %Note{} = note} <- API.Reports.create_report_note(report, moderator, content) do
       {:ok, note}
     end
   end
 
+  @spec delete_report_note(any(), map(), Absinthe.Resolution.t()) :: {:ok, map()}
   def delete_report_note(
         _parent,
         %{note_id: note_id},
-        %{context: %{current_user: %User{role: role} = user}}
+        %{context: %{current_user: %User{role: role}, current_actor: %Actor{id: moderator_id}}}
       )
       when is_moderator(role) do
-    with %Actor{id: moderator_id} <- Users.get_actor_for_user(user),
-         %Note{} = note <- Reports.get_note(note_id),
+    with %Note{} = note <- Reports.get_note(note_id),
          %Actor{} = moderator <- Actors.get_local_actor_with_preload(moderator_id),
          {:ok, %Note{} = note} <- API.Reports.delete_report_note(note, moderator) do
       {:ok, %{id: note.id}}
diff --git a/lib/graphql/resolvers/resource.ex b/lib/graphql/resolvers/resource.ex
index 3aa7b5322..f10f35c84 100644
--- a/lib/graphql/resolvers/resource.ex
+++ b/lib/graphql/resolvers/resource.ex
@@ -3,9 +3,9 @@ defmodule Mobilizon.GraphQL.Resolvers.Resource do
   Handles the resources-related GraphQL calls
   """
 
-  alias Mobilizon.{Actors, Resources, Users}
+  alias Mobilizon.{Actors, Resources}
   alias Mobilizon.Actors.Actor
-  alias Mobilizon.Federation.ActivityPub
+  alias Mobilizon.Federation.ActivityPub.Actions
   alias Mobilizon.Resources.Resource
   alias Mobilizon.Resources.Resource.Metadata
   alias Mobilizon.Service.RichMedia.Parser
@@ -21,17 +21,18 @@ defmodule Mobilizon.GraphQL.Resolvers.Resource do
 
   Returns only if actor requesting is a member of the group
   """
+  @spec find_resources_for_group(Actor.t(), map(), Absinthe.Resolution.t()) ::
+          {:ok, Page.t(Resource.t())}
   def find_resources_for_group(
         %Actor{id: group_id} = group,
         %{page: page, limit: limit},
         %{
           context: %{
-            current_user: %User{} = user
+            current_actor: %Actor{id: actor_id}
           }
         } = _resolution
       ) do
-    with %Actor{id: actor_id} <- Users.get_actor_for_user(user),
-         {:member, true} <- {:member, Actors.is_member?(actor_id, group_id)},
+    with {:member, true} <- {:member, Actors.is_member?(actor_id, group_id)},
          %Page{} = page <- Resources.get_resources_for_group(group, page, limit) do
       {:ok, page}
     else
@@ -48,17 +49,18 @@ defmodule Mobilizon.GraphQL.Resolvers.Resource do
     {:ok, %Page{total: 0, elements: []}}
   end
 
+  @spec find_resources_for_parent(Resource.t(), map(), Absinthe.Resolution.t()) ::
+          {:ok, Page.t(Resource.t())}
   def find_resources_for_parent(
         %Resource{actor_id: group_id} = parent,
         %{page: page, limit: limit},
         %{
           context: %{
-            current_user: %User{} = user
+            current_actor: %Actor{id: actor_id}
           }
         } = _resolution
       ) do
-    with %Actor{id: actor_id} <- Users.get_actor_for_user(user),
-         {:member, true} <- {:member, Actors.is_member?(actor_id, group_id)},
+    with {:member, true} <- {:member, Actors.is_member?(actor_id, group_id)},
          %Page{} = page <- Resources.get_resources_for_folder(parent, page, limit) do
       {:ok, page}
     end
@@ -67,18 +69,18 @@ defmodule Mobilizon.GraphQL.Resolvers.Resource do
   def find_resources_for_parent(_parent, _args, _resolution),
     do: {:ok, %Page{total: 0, elements: []}}
 
+  @spec get_resource(any(), map(), Absinthe.Resolution.t()) ::
+          {:ok, Resource.t()} | {:error, :group_not_found | :resource_not_found | String.t()}
   def get_resource(
         _parent,
         %{path: path, username: username},
         %{
           context: %{
-            current_user: %User{} = user
+            current_actor: %Actor{id: actor_id}
           }
         } = _resolution
       ) do
-    with {:current_actor, %Actor{id: actor_id}} <-
-           {:current_actor, Users.get_actor_for_user(user)},
-         {:group, %Actor{id: group_id}} <- {:group, Actors.get_actor_by_name(username, :Group)},
+    with {:group, %Actor{id: group_id}} <- {:group, Actors.get_actor_by_name(username, :Group)},
          {:member, true} <- {:member, Actors.is_member?(actor_id, group_id)},
          {:resource, %Resource{} = resource} <-
            {:resource, Resources.get_resource_by_group_and_path_with_preloads(group_id, path)} do
@@ -94,21 +96,22 @@ defmodule Mobilizon.GraphQL.Resolvers.Resource do
     {:error, dgettext("errors", "You need to be logged-in to access resources")}
   end
 
+  @spec create_resource(any(), map(), Absinthe.Resolution.t()) ::
+          {:ok, Resource.t()} | {:error, String.t()}
   def create_resource(
         _parent,
         %{actor_id: group_id} = args,
         %{
           context: %{
-            current_user: %User{} = user
+            current_actor: %Actor{id: actor_id}
           }
         } = _resolution
       ) do
-    with %Actor{id: actor_id} <- Users.get_actor_for_user(user),
-         {:member, true} <- {:member, Actors.is_member?(actor_id, group_id)},
+    with {:member, true} <- {:member, Actors.is_member?(actor_id, group_id)},
          parent <- get_eventual_parent(args),
          {:own_check, true} <- {:own_check, check_resource_owned_by_group(parent, group_id)},
          {:ok, _, %Resource{} = resource} <-
-           ActivityPub.create(
+           Actions.Create.create(
              :resource,
              args
              |> Map.put(:actor_id, group_id)
@@ -133,28 +136,36 @@ defmodule Mobilizon.GraphQL.Resolvers.Resource do
     {:error, dgettext("errors", "You need to be logged-in to create resources")}
   end
 
+  @spec update_resource(any(), map(), Absinthe.Resolution.t()) ::
+          {:ok, Resource.t()} | {:error, String.t()}
   def update_resource(
         _parent,
         %{id: resource_id} = args,
         %{
           context: %{
-            current_user: %User{} = user
+            current_actor: %Actor{id: actor_id, url: actor_url}
           }
         } = _resolution
       ) do
-    with %Actor{id: actor_id, url: actor_url} <- Users.get_actor_for_user(user),
-         {:resource, %Resource{actor_id: group_id} = resource} <-
-           {:resource, Resources.get_resource_with_preloads(resource_id)},
-         {:member, true} <- {:member, Actors.is_member?(actor_id, group_id)},
-         {:ok, _, %Resource{} = resource} <-
-           ActivityPub.update(resource, args, true, %{"actor" => actor_url}) do
-      {:ok, resource}
-    else
-      {:resource, _} ->
-        {:error, dgettext("errors", "Resource doesn't exist")}
+    case Resources.get_resource_with_preloads(resource_id) do
+      %Resource{actor_id: group_id} = resource ->
+        if Actors.is_member?(actor_id, group_id) do
+          case Actions.Update.update(resource, args, true, %{"actor" => actor_url}) do
+            {:ok, _, %Resource{} = resource} ->
+              {:ok, resource}
 
-      {:member, _} ->
-        {:error, dgettext("errors", "Profile is not member of group")}
+            {:error, %Ecto.Changeset{} = err} ->
+              {:error, err}
+
+            {:error, err} when is_atom(err) ->
+              {:error, dgettext("errors", "Unknown error while updating resource")}
+          end
+        else
+          {:error, dgettext("errors", "Profile is not member of group")}
+        end
+
+      nil ->
+        {:error, dgettext("errors", "Resource doesn't exist")}
     end
   end
 
@@ -162,21 +173,22 @@ defmodule Mobilizon.GraphQL.Resolvers.Resource do
     {:error, dgettext("errors", "You need to be logged-in to update resources")}
   end
 
+  @spec delete_resource(any(), map(), Absinthe.Resolution.t()) ::
+          {:ok, Resource.t()} | {:error, String.t()}
   def delete_resource(
         _parent,
         %{id: resource_id},
         %{
           context: %{
-            current_user: %User{} = user
+            current_actor: %Actor{id: actor_id} = actor
           }
         } = _resolution
       ) do
-    with %Actor{id: actor_id} = actor <- Users.get_actor_for_user(user),
-         {:resource, %Resource{parent_id: _parent_id, actor_id: group_id} = resource} <-
+    with {:resource, %Resource{parent_id: _parent_id, actor_id: group_id} = resource} <-
            {:resource, Resources.get_resource_with_preloads(resource_id)},
          {:member, true} <- {:member, Actors.is_member?(actor_id, group_id)},
          {:ok, _, %Resource{} = resource} <-
-           ActivityPub.delete(resource, actor) do
+           Actions.Delete.delete(resource, actor) do
       {:ok, resource}
     else
       {:resource, _} ->
@@ -191,6 +203,8 @@ defmodule Mobilizon.GraphQL.Resolvers.Resource do
     {:error, dgettext("errors", "You need to be logged-in to delete resources")}
   end
 
+  @spec preview_resource_link(any(), map(), Absinthe.Resolution.t()) ::
+          {:ok, Metadata.t()} | {:error, String.t() | :unknown_resource}
   def preview_resource_link(
         _parent,
         %{resource_url: resource_url},
@@ -218,6 +232,8 @@ defmodule Mobilizon.GraphQL.Resolvers.Resource do
     {:error, dgettext("errors", "You need to be logged-in to view a resource preview")}
   end
 
+  @spec proxyify_pictures(Metadata.t(), map(), Absinthe.Resolution.t()) ::
+          {:ok, String.t() | nil} | {:error, String.t()}
   def proxyify_pictures(%Metadata{} = metadata, _args, %{
         definition: %{schema_node: %{name: name}}
       }) do
diff --git a/lib/graphql/resolvers/search.ex b/lib/graphql/resolvers/search.ex
index 9d3a68ffb..6daf445b0 100644
--- a/lib/graphql/resolvers/search.ex
+++ b/lib/graphql/resolvers/search.ex
@@ -2,12 +2,16 @@ defmodule Mobilizon.GraphQL.Resolvers.Search do
   @moduledoc """
   Handles the event-related GraphQL calls
   """
-
+  alias Mobilizon.Actors.Actor
+  alias Mobilizon.Events.Event
   alias Mobilizon.GraphQL.API.Search
+  alias Mobilizon.Storage.Page
 
   @doc """
   Search persons
   """
+  @spec search_persons(any(), map(), Absinthe.Resolution.t()) ::
+          {:ok, Page.t(Actor.t())} | {:error, String.t()}
   def search_persons(_parent, %{page: page, limit: limit} = args, _resolution) do
     Search.search_actors(Map.put(args, :minimum_visibility, :private), page, limit, :Person)
   end
@@ -15,6 +19,8 @@ defmodule Mobilizon.GraphQL.Resolvers.Search do
   @doc """
   Search groups
   """
+  @spec search_groups(any(), map(), Absinthe.Resolution.t()) ::
+          {:ok, Page.t(Actor.t())} | {:error, String.t()}
   def search_groups(_parent, %{page: page, limit: limit} = args, _resolution) do
     Search.search_actors(args, page, limit, :Group)
   end
@@ -22,10 +28,13 @@ defmodule Mobilizon.GraphQL.Resolvers.Search do
   @doc """
   Search events
   """
+  @spec search_events(any(), map(), Absinthe.Resolution.t()) ::
+          {:ok, Page.t(Event.t())} | {:error, String.t()}
   def search_events(_parent, %{page: page, limit: limit} = args, _resolution) do
     Search.search_events(args, page, limit)
   end
 
+  @spec interact(any(), map(), Absinthe.Resolution.t()) :: {:ok, struct} | {:error, :not_found}
   def interact(_parent, %{uri: uri}, _resolution) do
     Search.interact(uri)
   end
diff --git a/lib/graphql/resolvers/statistics.ex b/lib/graphql/resolvers/statistics.ex
index c451cde40..c199c76c6 100644
--- a/lib/graphql/resolvers/statistics.ex
+++ b/lib/graphql/resolvers/statistics.ex
@@ -8,6 +8,7 @@ defmodule Mobilizon.GraphQL.Resolvers.Statistics do
   @doc """
   Gets config.
   """
+  @spec get_statistics(any(), any(), any()) :: {:ok, map()}
   def get_statistics(_parent, _params, _context) do
     {:ok,
      %{
diff --git a/lib/graphql/resolvers/tag.ex b/lib/graphql/resolvers/tag.ex
index e842f81cd..8257187e1 100644
--- a/lib/graphql/resolvers/tag.ex
+++ b/lib/graphql/resolvers/tag.ex
@@ -6,9 +6,12 @@ defmodule Mobilizon.GraphQL.Resolvers.Tag do
   alias Mobilizon.{Events, Posts}
   alias Mobilizon.Events.{Event, Tag}
   alias Mobilizon.Posts.Post
+  alias Mobilizon.Storage.Page
 
-  def list_tags(_parent, %{page: page, limit: limit}, _resolution) do
-    tags = Mobilizon.Events.list_tags(page, limit)
+  @spec list_tags(any(), map(), Absinthe.Resolution.t()) :: {:ok, Page.t(Tag.t())}
+  def list_tags(_parent, %{page: page, limit: limit} = args, _resolution) do
+    filter = Map.get(args, :filter)
+    tags = Mobilizon.Events.list_tags(filter, page, limit)
 
     {:ok, tags}
   end
@@ -18,6 +21,7 @@ defmodule Mobilizon.GraphQL.Resolvers.Tag do
 
   From an event or a struct with an url
   """
+  @spec list_tags_for_event(Event.t(), map(), Absinthe.Resolution.t()) :: {:ok, list(Tag.t())}
   def list_tags_for_event(%Event{id: id}, _args, _resolution) do
     {:ok, Events.list_tags_for_event(id)}
   end
@@ -32,6 +36,7 @@ defmodule Mobilizon.GraphQL.Resolvers.Tag do
   @doc """
   Retrieve the list of tags for a post
   """
+  @spec list_tags_for_post(Post.t(), map(), Absinthe.Resolution.t()) :: {:ok, list(Tag.t())}
   def list_tags_for_post(%Post{id: id}, _args, _resolution) do
     {:ok, Posts.list_tags_for_post(id)}
   end
@@ -49,9 +54,8 @@ defmodule Mobilizon.GraphQL.Resolvers.Tag do
   @doc """
   Retrieve the list of related tags for a parent tag
   """
+  @spec list_tags_for_post(Tag.t(), map(), Absinthe.Resolution.t()) :: {:ok, list(Tag.t())}
   def get_related_tags(%Tag{} = tag, _args, _resolution) do
-    with tags <- Events.list_tag_neighbors(tag) do
-      {:ok, tags}
-    end
+    {:ok, Events.list_tag_neighbors(tag)}
   end
 end
diff --git a/lib/graphql/resolvers/todos.ex b/lib/graphql/resolvers/todos.ex
index e6c2d504f..f8a269ea5 100644
--- a/lib/graphql/resolvers/todos.ex
+++ b/lib/graphql/resolvers/todos.ex
@@ -3,12 +3,11 @@ defmodule Mobilizon.GraphQL.Resolvers.Todos do
   Handles the todos related GraphQL calls
   """
 
-  alias Mobilizon.{Actors, Todos, Users}
+  alias Mobilizon.{Actors, Todos}
   alias Mobilizon.Actors.Actor
-  alias Mobilizon.Federation.ActivityPub
+  alias Mobilizon.Federation.ActivityPub.Actions
   alias Mobilizon.Storage.Page
   alias Mobilizon.Todos.{Todo, TodoList}
-  alias Mobilizon.Users.User
   import Mobilizon.Web.Gettext
 
   require Logger
@@ -18,15 +17,16 @@ defmodule Mobilizon.GraphQL.Resolvers.Todos do
 
   Returns only if actor requesting is a member of the group
   """
+  @spec find_todo_lists_for_group(Actor.t(), map(), Absinthe.Resolution.t()) ::
+          {:ok, Page.t(TodoList.t())}
   def find_todo_lists_for_group(
         %Actor{id: group_id} = group,
         _args,
         %{
-          context: %{current_user: %User{} = user}
+          context: %{current_actor: %Actor{id: actor_id}}
         } = _resolution
       ) do
-    with %Actor{id: actor_id} <- Users.get_actor_for_user(user),
-         {:member, true} <- {:member, Actors.is_member?(actor_id, group_id)},
+    with {:member, true} <- {:member, Actors.is_member?(actor_id, group_id)},
          %Page{} = page <- Todos.get_todo_lists_for_group(group) do
       {:ok, page}
     else
@@ -41,15 +41,16 @@ defmodule Mobilizon.GraphQL.Resolvers.Todos do
     {:ok, %Page{total: 0, elements: []}}
   end
 
+  @spec find_todo_lists_for_group(TodoList.t(), map(), Absinthe.Resolution.t()) ::
+          {:ok, Page.t(Todo.t())} | {:error, String.t()}
   def find_todos_for_todo_list(
         %TodoList{actor_id: group_id} = todo_list,
         _args,
         %{
-          context: %{current_user: %User{} = user}
+          context: %{current_actor: %Actor{id: actor_id}}
         } = _resolution
       ) do
-    with %Actor{id: actor_id} <- Users.get_actor_for_user(user),
-         {:member, true} <- {:member, Actors.is_member?(actor_id, group_id)},
+    with {:member, true} <- {:member, Actors.is_member?(actor_id, group_id)},
          %Page{} = page <- Todos.get_todos_for_todo_list(todo_list) do
       {:ok, page}
     else
@@ -58,15 +59,16 @@ defmodule Mobilizon.GraphQL.Resolvers.Todos do
     end
   end
 
+  @spec get_todo_list(any(), map(), Absinthe.Resolution.t()) ::
+          {:ok, TodoList.t()} | {:error, String.t()}
   def get_todo_list(
         _parent,
         %{id: todo_list_id},
         %{
-          context: %{current_user: %User{} = user}
+          context: %{current_actor: %Actor{id: actor_id}}
         } = _resolution
       ) do
-    with {:actor, %Actor{id: actor_id}} <- {:actor, Users.get_actor_for_user(user)},
-         {:todo, %TodoList{actor_id: group_id} = todo} <-
+    with {:todo, %TodoList{actor_id: group_id} = todo} <-
            {:todo, Todos.get_todo_list(todo_list_id)},
          {:member, true} <- {:member, Actors.is_member?(actor_id, group_id)} do
       {:ok, todo}
@@ -82,19 +84,28 @@ defmodule Mobilizon.GraphQL.Resolvers.Todos do
     end
   end
 
+  @spec create_todo_list(any(), map(), Absinthe.Resolution.t()) ::
+          {:ok, TodoList.t()} | {:error, String.t()}
   def create_todo_list(
         _parent,
         %{group_id: group_id} = args,
         %{
-          context: %{current_user: %User{} = user}
+          context: %{current_actor: %Actor{id: actor_id}}
         } = _resolution
       ) do
-    with {:actor, %Actor{id: actor_id} = _actor} <- {:actor, Users.get_actor_for_user(user)},
-         {:member, true} <- {:member, Actors.is_member?(actor_id, group_id)},
+    with {:member, true} <- {:member, Actors.is_member?(actor_id, group_id)},
          {:ok, _, %TodoList{} = todo_list} <-
-           ActivityPub.create(:todo_list, Map.put(args, :actor_id, group_id), true, %{}) do
+           Actions.Create.create(
+             :todo_list,
+             Map.put(args, :actor_id, group_id),
+             true,
+             %{}
+           ) do
       {:ok, todo_list}
     else
+      {:actor, nil} ->
+        {:error, dgettext("errors", "No profile found for user")}
+
       {:member, _} ->
         {:error, dgettext("errors", "Profile is not member of group")}
     end
@@ -112,7 +123,7 @@ defmodule Mobilizon.GraphQL.Resolvers.Todos do
   #          {:todo_list, Todos.get_todo_list(todo_list_id)},
   #        {:member, true} <- {:member, Actors.is_member?(actor_id, group_id)},
   #        {:ok, _, %TodoList{} = todo} <-
-  #          ActivityPub.update_todo_list(todo_list, actor, true, %{}) do
+  #          Actions.Update.update_todo_list(todo_list, actor, true, %{}) do
   #     {:ok, todo}
   #   else
   #     {:todo_list, _} ->
@@ -135,7 +146,7 @@ defmodule Mobilizon.GraphQL.Resolvers.Todos do
   #          {:todo_list, Todos.get_todo_list(todo_list_id)},
   #        {:member, true} <- {:member, Actors.is_member?(actor_id, group_id)},
   #        {:ok, _, %TodoList{} = todo} <-
-  #          ActivityPub.delete_todo_list(todo_list, actor, true, %{}) do
+  #          Actions.Delete.delete_todo_list(todo_list, actor, true, %{}) do
   #     {:ok, todo}
   #   else
   #     {:todo_list, _} ->
@@ -146,15 +157,15 @@ defmodule Mobilizon.GraphQL.Resolvers.Todos do
   #   end
   # end
 
+  @spec get_todo(any(), map(), Absinthe.Resolution.t()) :: {:ok, Todo.t()} | {:error, String.t()}
   def get_todo(
         _parent,
         %{id: todo_id},
         %{
-          context: %{current_user: %User{} = user}
+          context: %{current_actor: %Actor{id: actor_id}}
         } = _resolution
       ) do
-    with {:actor, %Actor{id: actor_id}} <- {:actor, Users.get_actor_for_user(user)},
-         {:todo, %Todo{todo_list_id: todo_list_id} = todo} <-
+    with {:todo, %Todo{todo_list_id: todo_list_id} = todo} <-
            {:todo, Todos.get_todo(todo_id)},
          {:todo_list, %TodoList{actor_id: group_id}} <-
            {:todo_list, Todos.get_todo_list(todo_list_id)},
@@ -172,21 +183,30 @@ defmodule Mobilizon.GraphQL.Resolvers.Todos do
     end
   end
 
+  @spec create_todo(any(), map(), Absinthe.Resolution.t()) ::
+          {:ok, Todo.t()} | {:error, String.t()}
   def create_todo(
         _parent,
         %{todo_list_id: todo_list_id} = args,
         %{
-          context: %{current_user: %User{} = user}
+          context: %{current_actor: %Actor{id: actor_id}}
         } = _resolution
       ) do
-    with {:actor, %Actor{id: actor_id} = _actor} <- {:actor, Users.get_actor_for_user(user)},
-         {:todo_list, %TodoList{actor_id: group_id} = _todo_list} <-
+    with {:todo_list, %TodoList{actor_id: group_id} = _todo_list} <-
            {:todo_list, Todos.get_todo_list(todo_list_id)},
          {:member, true} <- {:member, Actors.is_member?(actor_id, group_id)},
          {:ok, _, %Todo{} = todo} <-
-           ActivityPub.create(:todo, Map.put(args, :creator_id, actor_id), true, %{}) do
+           Actions.Create.create(
+             :todo,
+             Map.put(args, :creator_id, actor_id),
+             true,
+             %{}
+           ) do
       {:ok, todo}
     else
+      {:actor, nil} ->
+        {:error, dgettext("errors", "No profile found for user")}
+
       {:todo_list, _} ->
         {:error, dgettext("errors", "Todo list doesn't exist")}
 
@@ -195,23 +215,27 @@ defmodule Mobilizon.GraphQL.Resolvers.Todos do
     end
   end
 
+  @spec update_todo(any(), map(), Absinthe.Resolution.t()) ::
+          {:ok, Todo.t()} | {:error, String.t()}
   def update_todo(
         _parent,
         %{id: todo_id} = args,
         %{
-          context: %{current_user: %User{} = user}
+          context: %{current_actor: %Actor{id: actor_id}}
         } = _resolution
       ) do
-    with {:actor, %Actor{id: actor_id} = _actor} <- {:actor, Users.get_actor_for_user(user)},
-         {:todo, %Todo{todo_list_id: todo_list_id} = todo} <-
+    with {:todo, %Todo{todo_list_id: todo_list_id} = todo} <-
            {:todo, Todos.get_todo(todo_id)},
          {:todo_list, %TodoList{actor_id: group_id}} <-
            {:todo_list, Todos.get_todo_list(todo_list_id)},
          {:member, true} <- {:member, Actors.is_member?(actor_id, group_id)},
          {:ok, _, %Todo{} = todo} <-
-           ActivityPub.update(todo, args, true, %{}) do
+           Actions.Update.update(todo, args, true, %{}) do
       {:ok, todo}
     else
+      {:actor, nil} ->
+        {:error, dgettext("errors", "No profile found for user")}
+
       {:todo_list, _} ->
         {:error, dgettext("errors", "Todo list doesn't exist")}
 
@@ -237,7 +261,7 @@ defmodule Mobilizon.GraphQL.Resolvers.Todos do
   #          {:todo_list, Todos.get_todo_list(todo_list_id)},
   #        {:member, true} <- {:member, Actors.is_member?(actor_id, group_id)},
   #        {:ok, _, %Todo{} = todo} <-
-  #          ActivityPub.delete_todo(todo, actor, true, %{}) do
+  #          Actions.Delete.delete_todo(todo, actor, true, %{}) do
   #     {:ok, todo}
   #   else
   #     {:todo_list, _} ->
diff --git a/lib/graphql/resolvers/user.ex b/lib/graphql/resolvers/user.ex
index 24ba9c7c8..d24cfdab3 100644
--- a/lib/graphql/resolvers/user.ex
+++ b/lib/graphql/resolvers/user.ex
@@ -7,8 +7,7 @@ defmodule Mobilizon.GraphQL.Resolvers.User do
 
   alias Mobilizon.{Actors, Admin, Config, Events, Users}
   alias Mobilizon.Actors.Actor
-  alias Mobilizon.Federation.ActivityPub
-  alias Mobilizon.Federation.ActivityPub.Relay
+  alias Mobilizon.Federation.ActivityPub.{Actions, Relay}
   alias Mobilizon.Service.Auth.Authenticator
   alias Mobilizon.Storage.{Page, Repo}
   alias Mobilizon.Users.{Setting, User}
@@ -21,6 +20,7 @@ defmodule Mobilizon.GraphQL.Resolvers.User do
   @doc """
   Find an user by its ID
   """
+  @spec find_user(any(), map(), Absinthe.Resolution.t()) :: {:ok, User.t()} | {:error, String.t()}
   def find_user(_parent, %{id: id}, %{context: %{current_user: %User{role: role}}})
       when is_moderator(role) do
     with {:ok, %User{} = user} <- Users.get_user_with_actors(id) do
@@ -31,6 +31,8 @@ defmodule Mobilizon.GraphQL.Resolvers.User do
   @doc """
   Return current logged-in user
   """
+  @spec get_current_user(any, map(), Absinthe.Resolution.t()) ::
+          {:error, :unauthenticated} | {:ok, Mobilizon.Users.User.t()}
   def get_current_user(_parent, _args, %{context: %{current_user: %User{} = user}}) do
     {:ok, user}
   end
@@ -42,6 +44,8 @@ defmodule Mobilizon.GraphQL.Resolvers.User do
   @doc """
   List instance users
   """
+  @spec list_users(any(), map(), Absinthe.Resolution.t()) ::
+          {:ok, Page.t(User.t())} | {:error, :unauthorized}
   def list_users(
         _parent,
         %{email: email, page: page, limit: limit, sort: sort, direction: direction},
@@ -58,6 +62,8 @@ defmodule Mobilizon.GraphQL.Resolvers.User do
   @doc """
   Login an user. Returns a token and the user
   """
+  @spec login_user(any(), map(), Absinthe.Resolution.t()) ::
+          {:ok, map()} | {:error, :user_not_found | String.t()}
   def login_user(_parent, %{email: email, password: password}, %{context: context}) do
     with {:ok,
           %{
@@ -65,9 +71,8 @@ defmodule Mobilizon.GraphQL.Resolvers.User do
             refresh_token: _refresh_token,
             user: %User{} = user
           } = user_and_tokens} <- Authenticator.authenticate(email, password),
-         {:ok, %User{} = user} <- update_user_login_information(user, context),
-         user_and_tokens <- Map.put(user_and_tokens, :user, user) do
-      {:ok, user_and_tokens}
+         {:ok, %User{} = user} <- update_user_login_information(user, context) do
+      {:ok, %{user_and_tokens | user: user}}
     else
       {:error, :user_not_found} ->
         {:error, :user_not_found}
@@ -87,6 +92,8 @@ defmodule Mobilizon.GraphQL.Resolvers.User do
   @doc """
   Refresh a token
   """
+  @spec refresh_token(any(), map(), Absinthe.Resolution.t()) ::
+          {:ok, map()} | {:error, String.t()}
   def refresh_token(_parent, %{refresh_token: refresh_token}, _resolution) do
     with {:ok, user, _claims} <- Auth.Guardian.resource_from_token(refresh_token),
          {:ok, _old, {exchanged_token, _claims}} <-
@@ -105,6 +112,9 @@ defmodule Mobilizon.GraphQL.Resolvers.User do
     {:error, dgettext("errors", "You need to have an existing token to get a refresh token")}
   end
 
+  @spec logout(any(), map(), Absinthe.Resolution.t()) ::
+          {:ok, String.t()}
+          | {:error, :token_not_found | :unable_to_logout | :unauthenticated | :invalid_argument}
   def logout(_parent, %{refresh_token: refresh_token}, %{context: %{current_user: %User{}}}) do
     with {:ok, _claims} <- Auth.Guardian.decode_and_verify(refresh_token, %{"typ" => "refresh"}),
          {:ok, _claims} <- Auth.Guardian.revoke(refresh_token) do
@@ -133,7 +143,7 @@ defmodule Mobilizon.GraphQL.Resolvers.User do
     - create the user
     - send a validation email to the user
   """
-  @spec create_user(any, map, any) :: tuple
+  @spec create_user(any, %{email: String.t()}, any) :: {:ok, User.t()} | {:error, String.t()}
   def create_user(_parent, %{email: email} = args, _resolution) do
     with :registration_ok <- check_registration_config(email),
          :not_deny_listed <- check_registration_denylist(email),
@@ -160,20 +170,22 @@ defmodule Mobilizon.GraphQL.Resolvers.User do
     end
   end
 
-  @spec check_registration_config(map) :: atom
+  @spec check_registration_config(String.t()) ::
+          :registration_ok | :registration_closed | :not_allowlisted
   defp check_registration_config(email) do
     cond do
       Config.instance_registrations_open?() ->
         :registration_ok
 
       Config.instance_registrations_allowlist?() ->
-        check_allow_listed_email?(email)
+        check_allow_listed_email(email)
 
       true ->
         :registration_closed
     end
   end
 
+  @spec check_registration_denylist(String.t()) :: :deny_listed | :not_deny_listed
   defp check_registration_denylist(email) do
     # Remove everything behind the +
     email = String.replace(email, ~r/(\+.*)(?=\@)/, "")
@@ -183,8 +195,8 @@ defmodule Mobilizon.GraphQL.Resolvers.User do
       else: :not_deny_listed
   end
 
-  @spec check_allow_listed_email?(String.t()) :: :registration_ok | :not_allowlisted
-  defp check_allow_listed_email?(email) do
+  @spec check_allow_listed_email(String.t()) :: :registration_ok | :not_allowlisted
+  defp check_allow_listed_email(email) do
     if email_in_list(email, Config.instance_registrations_allowlist()),
       do: :registration_ok,
       else: :not_allowlisted
@@ -199,23 +211,29 @@ defmodule Mobilizon.GraphQL.Resolvers.User do
   @doc """
   Validate an user, get its actor and a token
   """
+  @spec validate_user(map(), %{token: String.t()}, map()) :: {:ok, map()} | {:error, String.t()}
   def validate_user(_parent, %{token: token}, _resolution) do
-    with {:check_confirmation_token, {:ok, %User{} = user}} <-
-           {:check_confirmation_token, Email.User.check_confirmation_token(token)},
-         {:get_actor, actor} <- {:get_actor, Users.get_actor_for_user(user)},
-         {:ok, %{access_token: access_token, refresh_token: refresh_token}} <-
-           Authenticator.generate_tokens(user) do
-      {:ok,
-       %{
-         access_token: access_token,
-         refresh_token: refresh_token,
-         user: Map.put(user, :default_actor, actor)
-       }}
-    else
-      error ->
-        Logger.info("Unable to validate user with token #{token}")
-        Logger.debug(inspect(error))
+    case Email.User.check_confirmation_token(token) do
+      {:ok, %User{} = user} ->
+        actor = Users.get_actor_for_user(user)
 
+        {:ok, %{access_token: access_token, refresh_token: refresh_token}} =
+          Authenticator.generate_tokens(user)
+
+        {:ok,
+         %{
+           access_token: access_token,
+           refresh_token: refresh_token,
+           user: Map.put(user, :default_actor, actor)
+         }}
+
+      {:error, :invalid_token} ->
+        Logger.info("Invalid token #{token} to validate user")
+        {:error, dgettext("errors", "Unable to validate user")}
+
+      {:error, %Ecto.Changeset{} = err} ->
+        Logger.info("Unable to validate user with token #{token}")
+        Logger.debug(inspect(err))
         {:error, dgettext("errors", "Unable to validate user")}
     end
   end
@@ -267,12 +285,25 @@ defmodule Mobilizon.GraphQL.Resolvers.User do
   @doc """
   Reset the password from an user
   """
+  @spec reset_password(map(), %{password: String.t(), token: String.t()}, map()) ::
+          {:ok, map()} | {:error, String.t()}
   def reset_password(_parent, %{password: password, token: token}, _resolution) do
-    with {:ok, %User{email: email} = user} <-
-           Email.User.check_reset_password_token(password, token),
-         {:ok, %{access_token: access_token, refresh_token: refresh_token}} <-
-           Authenticator.authenticate(email, password) do
-      {:ok, %{access_token: access_token, refresh_token: refresh_token, user: user}}
+    case Email.User.check_reset_password_token(password, token) do
+      {:ok, %User{email: email} = user} ->
+        {:ok, tokens} = Authenticator.authenticate(email, password)
+        {:ok, Map.put(tokens, :user, user)}
+
+      {:error, %Ecto.Changeset{errors: [password: {"registration.error.password_too_short", _}]}} ->
+        {:error,
+         gettext(
+           "The password you have choosen is too short. Please make sure your password contains at least 6 charaters."
+         )}
+
+      {:error, _err} ->
+        {:error,
+         gettext(
+           "The token you provided is invalid. Make sure that the URL is exactly the one provided inside the email you got."
+         )}
     end
   end
 
@@ -280,12 +311,12 @@ defmodule Mobilizon.GraphQL.Resolvers.User do
   def change_default_actor(
         _parent,
         %{preferred_username: username},
-        %{context: %{current_user: user}}
+        %{context: %{current_user: %User{id: user_id} = user}}
       ) do
-    with %Actor{id: actor_id} <- Actors.get_local_actor_by_name(username),
+    with %Actor{id: actor_id} = actor <- Actors.get_local_actor_by_name(username),
          {:user_actor, true} <-
            {:user_actor, actor_id in Enum.map(Users.get_actors_for_user(user), & &1.id)},
-         %User{} = user <- Users.update_user_default_actor(user.id, actor_id) do
+         %User{} = user <- Users.update_user_default_actor(user_id, actor) do
       {:ok, user}
     else
       {:user_actor, _} ->
@@ -369,6 +400,9 @@ defmodule Mobilizon.GraphQL.Resolvers.User do
            |> Repo.update() do
       {:ok, user}
     else
+      {:can_change_password, false} ->
+        {:error, dgettext("errors", "You cannot change your password.")}
+
       {:current_password, _} ->
         {:error, dgettext("errors", "The current password is invalid")}
 
@@ -408,14 +442,18 @@ defmodule Mobilizon.GraphQL.Resolvers.User do
 
       {:ok, user}
     else
-      {:current_password, _} ->
+      {:current_password, {:error, _}} ->
         {:error, dgettext("errors", "The password provided is invalid")}
 
       {:same_email, true} ->
         {:error, dgettext("errors", "The new email must be different")}
 
-      {:email_valid, _} ->
+      {:email_valid, false} ->
         {:error, dgettext("errors", "The new email doesn't seem to be valid")}
+
+      {:error, %Ecto.Changeset{} = err} ->
+        Logger.debug(inspect(err))
+        {:error, dgettext("errors", "Failed to update user email")}
     end
   end
 
@@ -423,30 +461,37 @@ defmodule Mobilizon.GraphQL.Resolvers.User do
     {:error, dgettext("errors", "You need to be logged-in to change your email")}
   end
 
+  @spec validate_email(map(), %{token: String.t()}, map()) ::
+          {:ok, User.t()} | {:error, String.t()}
   def validate_email(_parent, %{token: token}, _resolution) do
-    with {:get, %User{} = user} <- {:get, Users.get_user_by_activation_token(token)},
-         {:ok, %User{} = user} <- Users.validate_email(user) do
-      {:ok, user}
-    else
-      {:get, nil} ->
+    case Users.get_user_by_activation_token(token) do
+      %User{} = user ->
+        case Users.validate_email(user) do
+          {:ok, %User{} = user} ->
+            {:ok, user}
+
+          {:error, %Ecto.Changeset{} = err} ->
+            Logger.debug(inspect(err))
+            {:error, dgettext("errors", "Failed to validate user email")}
+        end
+
+      nil ->
         {:error, dgettext("errors", "Invalid activation token")}
     end
   end
 
   def delete_account(_parent, %{user_id: user_id}, %{
-        context: %{current_user: %User{role: role} = moderator_user}
+        context: %{
+          current_user: %User{role: role},
+          current_actor: %Actor{} = moderator_actor
+        }
       })
       when is_moderator(role) do
-    with {:moderator_actor, %Actor{} = moderator_actor} <-
-           {:moderator_actor, Users.get_actor_for_user(moderator_user)},
-         %User{disabled: false} = user <- Users.get_user(user_id),
+    with %User{disabled: false} = user <- Users.get_user(user_id),
          {:ok, %User{}} <-
            do_delete_account(%User{} = user, actor_performing: Relay.get_actor()) do
       Admin.log_action(moderator_actor, "delete", user)
     else
-      {:moderator_actor, nil} ->
-        {:error, dgettext("errors", "No profile found for the moderator user")}
-
       %User{disabled: true} ->
         {:error, dgettext("errors", "User already disabled")}
     end
@@ -488,7 +533,7 @@ defmodule Mobilizon.GraphQL.Resolvers.User do
          :ok <-
            Enum.each(actors, fn actor ->
              actor_performing = Keyword.get(options, :actor_performing, actor)
-             ActivityPub.delete(actor, actor_performing, true)
+             Actions.Delete.delete(actor, actor_performing, true)
            end),
          # Delete user
          {:ok, user} <-
@@ -547,12 +592,17 @@ defmodule Mobilizon.GraphQL.Resolvers.User do
   def update_locale(_parent, %{locale: locale}, %{
         context: %{current_user: %User{locale: current_locale} = user}
       }) do
-    with true <- current_locale != locale,
-         {:ok, %User{} = updated_user} <- Users.update_user(user, %{locale: locale}) do
-      {:ok, updated_user}
+    if current_locale != locale do
+      case Users.update_user(user, %{locale: locale}) do
+        {:ok, %User{} = updated_user} ->
+          {:ok, updated_user}
+
+        {:error, %Ecto.Changeset{} = err} ->
+          Logger.debug(err)
+          {:error, dgettext("errors", "Error while updating locale")}
+      end
     else
-      false ->
-        {:ok, user}
+      {:ok, user}
     end
   end
 
diff --git a/lib/graphql/resolvers/users/activity_settings.ex b/lib/graphql/resolvers/users/activity_settings.ex
index f3a76e2e3..df78f3711 100644
--- a/lib/graphql/resolvers/users/activity_settings.ex
+++ b/lib/graphql/resolvers/users/activity_settings.ex
@@ -4,10 +4,12 @@ defmodule Mobilizon.GraphQL.Resolvers.Users.ActivitySettings do
   """
 
   alias Mobilizon.Users
-  alias Mobilizon.Users.User
+  alias Mobilizon.Users.{ActivitySetting, User}
 
   require Logger
 
+  @spec user_activity_settings(any(), map(), Absinthe.Resolution.t()) ::
+          {:ok, list(ActivitySetting.t())} | {:error, :unauthenticated}
   def user_activity_settings(_parent, _args, %{context: %{current_user: %User{} = user}}) do
     {:ok, Users.activity_settings_for_user(user)}
   end
@@ -16,6 +18,8 @@ defmodule Mobilizon.GraphQL.Resolvers.Users.ActivitySettings do
     {:error, :unauthenticated}
   end
 
+  @spec upsert_user_activity_setting(any(), map(), Absinthe.Resolution.t()) ::
+          {:ok, ActivitySetting.t()} | {:error, :unauthenticated}
   def upsert_user_activity_setting(_parent, args, %{context: %{current_user: %User{id: user_id}}}) do
     Users.create_activity_setting(Map.put(args, :user_id, user_id))
   end
diff --git a/lib/graphql/schema.ex b/lib/graphql/schema.ex
index 74f3f9a38..5ce92d9ed 100644
--- a/lib/graphql/schema.ex
+++ b/lib/graphql/schema.ex
@@ -20,7 +20,7 @@ defmodule Mobilizon.GraphQL.Schema do
   alias Mobilizon.Actors.{Actor, Follower, Member}
   alias Mobilizon.Discussions.Comment
   alias Mobilizon.Events.{Event, Participant}
-  alias Mobilizon.GraphQL.Middleware.ErrorHandler
+  alias Mobilizon.GraphQL.Middleware.{CurrentActorProvider, ErrorHandler}
   alias Mobilizon.GraphQL.Schema
   alias Mobilizon.Storage.Repo
 
@@ -194,8 +194,9 @@ defmodule Mobilizon.GraphQL.Schema do
     import_fields(:discussion_subscriptions)
   end
 
+  @spec middleware(list(module()), any(), map()) :: list(module())
   def middleware(middleware, _field, %{identifier: type}) when type in [:query, :mutation] do
-    middleware ++ [ErrorHandler]
+    [CurrentActorProvider] ++ middleware ++ [ErrorHandler]
   end
 
   def middleware(middleware, _field, _object) do
diff --git a/lib/graphql/schema/tag.ex b/lib/graphql/schema/tag.ex
index f2db09449..d995c8cff 100644
--- a/lib/graphql/schema/tag.ex
+++ b/lib/graphql/schema/tag.ex
@@ -23,6 +23,7 @@ defmodule Mobilizon.GraphQL.Schema.TagType do
   object :tag_queries do
     @desc "Get the list of tags"
     field :tags, non_null(list_of(:tag)) do
+      arg(:filter, :string, description: "The filter to apply to the search")
       arg(:page, :integer, default_value: 1, description: "The page in the paginated tags list")
       arg(:limit, :integer, default_value: 10, description: "The limit of tags per page")
       resolve(&Tag.list_tags/3)
diff --git a/lib/mix/tasks/mobilizon/actors/new.ex b/lib/mix/tasks/mobilizon/actors/new.ex
index 48124d816..b79a0ef04 100644
--- a/lib/mix/tasks/mobilizon/actors/new.ex
+++ b/lib/mix/tasks/mobilizon/actors/new.ex
@@ -94,7 +94,7 @@ defmodule Mix.Tasks.Mobilizon.Actors.New do
       {:admin, nil} ->
         shell_error("Profile with username #{Keyword.get(options, :group_admin)} wasn't found")
 
-      {:error, :insert_group, %Ecto.Changeset{errors: errors}, _} ->
+      {:error, %Ecto.Changeset{errors: errors}} ->
         shell_error(inspect(errors))
         shell_error("Error while creating group because of the above reason")
     end
diff --git a/lib/mix/tasks/mobilizon/actors/refresh.ex b/lib/mix/tasks/mobilizon/actors/refresh.ex
index 893af5f2b..9c1b20d06 100644
--- a/lib/mix/tasks/mobilizon/actors/refresh.ex
+++ b/lib/mix/tasks/mobilizon/actors/refresh.ex
@@ -71,9 +71,6 @@ defmodule Mix.Tasks.Mobilizon.Actors.Refresh do
         Actor #{preferred_username} refreshed
         """)
 
-      {:actor, nil} ->
-        shell_error("Error: No such actor")
-
       {:error, err} when is_binary(err) ->
         shell_error(err)
 
diff --git a/lib/mix/tasks/mobilizon/actors/utils.ex b/lib/mix/tasks/mobilizon/actors/utils.ex
index fd7e2e911..28daefdf7 100644
--- a/lib/mix/tasks/mobilizon/actors/utils.ex
+++ b/lib/mix/tasks/mobilizon/actors/utils.ex
@@ -25,7 +25,7 @@ defmodule Mix.Tasks.Mobilizon.Actors.Utils do
   end
 
   # Profile from name
-  @spec username_and_name(String.t() | nil, String.t() | nil) :: String.t()
+  @spec username_and_name(String.t() | nil, String.t() | nil) :: {String.t(), String.t()}
   def username_and_name(nil, profile_name) do
     {generate_username(profile_name), profile_name}
   end
@@ -50,6 +50,8 @@ defmodule Mix.Tasks.Mobilizon.Actors.Utils do
     new_person
   end
 
+  @spec create_group(Actor.t(), String.t(), String.t(), Keyword.t()) ::
+          {:ok, Actor.t()} | {:error, Ecto.Changeset.t()}
   def create_group(%Actor{id: admin_id}, username, name, _options \\ []) do
     {username, name} = username_and_name(username, name)
 
diff --git a/lib/mix/tasks/mobilizon/common.ex b/lib/mix/tasks/mobilizon/common.ex
index 8cc3ccffe..e390c2568 100644
--- a/lib/mix/tasks/mobilizon/common.ex
+++ b/lib/mix/tasks/mobilizon/common.ex
@@ -9,6 +9,7 @@ defmodule Mix.Tasks.Mobilizon.Common do
   """
   require Logger
 
+  @spec start_mobilizon :: any()
   def start_mobilizon do
     if mix_task?(), do: Mix.Task.run("app.config")
 
@@ -21,10 +22,12 @@ defmodule Mix.Tasks.Mobilizon.Common do
     {:ok, _} = Application.ensure_all_started(:mobilizon)
   end
 
+  @spec get_option(Keyword.t(), atom(), String.t(), String.t() | nil, String.t() | nil) :: any()
   def get_option(options, opt, prompt, defval \\ nil, defname \\ nil) do
     Keyword.get(options, opt) || shell_prompt(prompt, defval, defname)
   end
 
+  @spec shell_prompt(String.t(), String.t() | nil, String.t() | nil) :: String.t()
   def shell_prompt(prompt, defval \\ nil, defname \\ nil) do
     prompt_message = "#{prompt} [#{defname || defval}] "
 
@@ -48,6 +51,7 @@ defmodule Mix.Tasks.Mobilizon.Common do
     end
   end
 
+  @spec shell_yes?(String.t()) :: boolean()
   def shell_yes?(message) do
     if mix_shell?(),
       do: Mix.shell().yes?("Continue?"),
@@ -61,7 +65,7 @@ defmodule Mix.Tasks.Mobilizon.Common do
       else: IO.puts(message)
   end
 
-  @spec shell_error(String.t()) :: :ok
+  @spec shell_error(String.t(), Keyword.t()) :: nil | no_return
   def shell_error(message, options \\ []) do
     if mix_shell?() do
       Mix.shell().error(message)
@@ -75,10 +79,13 @@ defmodule Mix.Tasks.Mobilizon.Common do
   end
 
   @doc "Performs a safe check whether `Mix.shell/0` is available (does not raise if Mix is not loaded)"
+  @spec mix_shell? :: boolean
   def mix_shell?, do: :erlang.function_exported(Mix, :shell, 0)
 
+  @spec mix_task? :: boolean
   def mix_task?, do: :erlang.function_exported(Mix.Task, :run, 1)
 
+  @spec escape_sh_path(String.t()) :: String.t()
   def escape_sh_path(path) do
     ~S(') <> String.replace(path, ~S('), ~S(\')) <> ~S(')
   end
@@ -97,6 +104,7 @@ defmodule Mix.Tasks.Mobilizon.Common do
     end
   end
 
+  @spec show_subtasks_for_module(module()) :: :ok
   def show_subtasks_for_module(module_name) do
     tasks = list_subtasks_for_module(module_name)
 
@@ -107,7 +115,7 @@ defmodule Mix.Tasks.Mobilizon.Common do
     end)
   end
 
-  @spec list_subtasks_for_module(atom()) :: list({String.t(), String.t()})
+  @spec list_subtasks_for_module(module()) :: list({String.t(), String.t()})
   def list_subtasks_for_module(module_name) do
     Application.load(:mobilizon)
     {:ok, modules} = :application.get_key(:mobilizon, :modules)
@@ -121,10 +129,12 @@ defmodule Mix.Tasks.Mobilizon.Common do
     |> Enum.map(&format_module/1)
   end
 
+  @spec format_module(module()) :: {String.t(), String.t() | nil}
   defp format_module(module) do
     {format_name(to_string(module)), shortdoc(module)}
   end
 
+  @spec format_name(String.t()) :: String.t()
   defp format_name("Elixir.Mix.Tasks.Mobilizon." <> task_name) do
     String.downcase(task_name)
   end
diff --git a/lib/mix/tasks/mobilizon/create_bot.ex b/lib/mix/tasks/mobilizon/create_bot.ex
index a01d0f592..3cc0ba139 100644
--- a/lib/mix/tasks/mobilizon/create_bot.ex
+++ b/lib/mix/tasks/mobilizon/create_bot.ex
@@ -13,11 +13,12 @@ defmodule Mix.Tasks.Mobilizon.CreateBot do
   require Logger
 
   @shortdoc "Create bot"
+  @spec run(list(String.t())) :: Bot.t() | :ok
   def run([email, name, summary, type, url]) do
     start_mobilizon()
 
     with {:ok, %User{} = user} <- Users.get_user_by_email(email, activated: true),
-         actor <- Actors.register_bot(%{name: name, summary: summary}),
+         {:ok, actor} <- Actors.register_bot(%{name: name, summary: summary}),
          {:ok, %Bot{} = bot} <-
            Actors.create_bot(%{
              "type" => type,
diff --git a/lib/mix/tasks/mobilizon/ecto.ex b/lib/mix/tasks/mobilizon/ecto.ex
index 5ce88e5e1..a2079e457 100644
--- a/lib/mix/tasks/mobilizon/ecto.ex
+++ b/lib/mix/tasks/mobilizon/ecto.ex
@@ -10,7 +10,7 @@ defmodule Mix.Tasks.Mobilizon.Ecto do
   @doc """
   Ensures the given repository's migrations path exists on the file system.
   """
-  @spec ensure_migrations_path(Ecto.Repo.t(), Keyword.t()) :: String.t()
+  @spec ensure_migrations_path(Ecto.Repo.t(), Keyword.t()) :: String.t() | no_return
   def ensure_migrations_path(repo, opts) do
     path = opts[:migrations_path] || Path.join(source_repo_priv(repo), "migrations")
 
@@ -39,6 +39,7 @@ defmodule Mix.Tasks.Mobilizon.Ecto do
     Path.join(Application.app_dir(:mobilizon), priv)
   end
 
+  @spec raise_missing_migrations(String.t(), Ecto.Repo.t()) :: no_return
   defp raise_missing_migrations(path, repo) do
     raise("""
     Could not find migrations directory #{inspect(path)}
diff --git a/lib/mix/tasks/mobilizon/instance.ex b/lib/mix/tasks/mobilizon/instance.ex
index af4d844b1..c2529b117 100644
--- a/lib/mix/tasks/mobilizon/instance.ex
+++ b/lib/mix/tasks/mobilizon/instance.ex
@@ -35,6 +35,7 @@ defmodule Mix.Tasks.Mobilizon.Instance do
   @preferred_cli_env "prod"
 
   @shortdoc "Generates a new config"
+  @spec run(list(binary())) :: no_return
   def run(["gen" | options]) do
     {options, [], []} =
       OptionParser.parse(
diff --git a/lib/mix/tasks/mobilizon/site_map.ex b/lib/mix/tasks/mobilizon/site_map.ex
index d35c94990..05acd0008 100644
--- a/lib/mix/tasks/mobilizon/site_map.ex
+++ b/lib/mix/tasks/mobilizon/site_map.ex
@@ -11,6 +11,7 @@ defmodule Mix.Tasks.Mobilizon.SiteMap do
   @preferred_cli_env "prod"
 
   @shortdoc "Generates a new Sitemap"
+  @spec run(list(String.t())) :: :ok
   def run(["generate"]) do
     start_mobilizon()
 
diff --git a/lib/mix/tasks/mobilizon/users/clean.ex b/lib/mix/tasks/mobilizon/users/clean.ex
index 04f6f22dc..336af5ab6 100644
--- a/lib/mix/tasks/mobilizon/users/clean.ex
+++ b/lib/mix/tasks/mobilizon/users/clean.ex
@@ -71,7 +71,7 @@ defmodule Mix.Tasks.Mobilizon.Users.Clean do
     end)
   end
 
-  @spec result(boolean(), boolean()) :: :ok
+  @spec result(boolean(), non_neg_integer()) :: :ok
   defp result(dry_run, nb_deleted_users) do
     if dry_run do
       shell_info("#{nb_deleted_users} users would have been deleted")
diff --git a/lib/mix/tasks/mobilizon/users/modify.ex b/lib/mix/tasks/mobilizon/users/modify.ex
index 42309b54f..ae02ed564 100644
--- a/lib/mix/tasks/mobilizon/users/modify.ex
+++ b/lib/mix/tasks/mobilizon/users/modify.ex
@@ -54,13 +54,20 @@ defmodule Mix.Tasks.Mobilizon.Users.Modify do
            ),
          {:makes_changes, true} <- {:makes_changes, attrs != %{}},
          {:ok, %User{} = user} <- Users.update_user(user, attrs) do
+      status =
+        case user.confirmed_at do
+          %DateTime{} = confirmed_at ->
+            "Activated on #{DateTime.to_string(confirmed_at)} (UTC)"
+
+          _ ->
+            "disabled"
+        end
+
       shell_info("""
       An user has been modified with the following information:
         - email: #{user.email}
         - Role: #{user.role}
-        - account status: #{if user.confirmed_at,
-        do: "activated on #{DateTime.to_string(user.confirmed_at)} (UTC)",
-        else: "disabled"}
+        - account status: #{status}
       """)
     else
       {:makes_changes, false} ->
diff --git a/lib/mix/tasks/mobilizon/users/new.ex b/lib/mix/tasks/mobilizon/users/new.ex
index b34f730d5..db013f7c1 100644
--- a/lib/mix/tasks/mobilizon/users/new.ex
+++ b/lib/mix/tasks/mobilizon/users/new.ex
@@ -78,6 +78,8 @@ defmodule Mix.Tasks.Mobilizon.Users.New do
     shell_error("mobilizon.users.new requires an email as argument")
   end
 
+  @spec create_user(String.t(), String.t() | nil, String.t(), Keyword.t()) ::
+          {:ok, User.t()} | {:error, Ecto.Changeset.t()}
   defp create_user(email, provider, password, options) do
     role = get_role(options)
 
@@ -96,6 +98,8 @@ defmodule Mix.Tasks.Mobilizon.Users.New do
     end
   end
 
+  @spec create_database_user(String.t(), String.t(), role()) ::
+          {:ok, User.t()} | {:error, Ecto.Changeset.t()}
   defp create_database_user(email, password, role) do
     Users.register(%{
       email: email,
@@ -107,6 +111,8 @@ defmodule Mix.Tasks.Mobilizon.Users.New do
     })
   end
 
+  @spec create_user_from_provider(String.t(), String.t(), role()) ::
+          {:ok, User.t()} | {:error, Ecto.Changeset.t()}
   defp create_user_from_provider(email, provider, role) do
     Users.create_external(email, provider, %{role: role})
   end
@@ -137,6 +143,7 @@ defmodule Mix.Tasks.Mobilizon.Users.New do
     end
   end
 
+  @spec check_password_and_provider_options(Keyword.t()) :: nil | no_return()
   defp check_password_and_provider_options(options) do
     if Keyword.get(options, :password) != nil && Keyword.get(options, :provider) != nil do
       shell_error("""
diff --git a/lib/mix/tasks/mobilizon/users/show.ex b/lib/mix/tasks/mobilizon/users/show.ex
index 60ed9accc..c559f87f7 100644
--- a/lib/mix/tasks/mobilizon/users/show.ex
+++ b/lib/mix/tasks/mobilizon/users/show.ex
@@ -17,11 +17,18 @@ defmodule Mix.Tasks.Mobilizon.Users.Show do
 
     with {:ok, %User{} = user} <- Users.get_user_by_email(email),
          actors <- Users.get_actors_for_user(user) do
+      status =
+        case user.confirmed_at do
+          %DateTime{} = confirmed_at ->
+            "Activated on #{DateTime.to_string(confirmed_at)} (UTC)"
+
+          _ ->
+            "disabled"
+        end
+
       shell_info("""
       Informations for the user #{user.email}:
-        - account status: #{if user.confirmed_at,
-        do: "Activated on #{DateTime.to_string(user.confirmed_at)} (UTC)",
-        else: "disabled"}
+        - account status: #{status}
         - Role: #{user.role}
         #{display_actors(actors)}
       """)
diff --git a/lib/mobilizon.ex b/lib/mobilizon.ex
index 59f98f7af..a701de012 100644
--- a/lib/mobilizon.ex
+++ b/lib/mobilizon.ex
@@ -59,6 +59,7 @@ defmodule Mobilizon do
         cachex_spec(:config, 10, 60, 60),
         cachex_spec(:rich_media_cache, 10, 60, 60),
         cachex_spec(:activity_pub, 2500, 3, 15),
+        cachex_spec(:default_actors, 2500, 3, 15),
         %{
           id: :cache_key_value,
           start: {Cachex, :start_link, [:key_value]}
diff --git a/lib/mobilizon/activities/activities.ex b/lib/mobilizon/activities/activities.ex
index 7d7e75803..3989463b8 100644
--- a/lib/mobilizon/activities/activities.ex
+++ b/lib/mobilizon/activities/activities.ex
@@ -70,6 +70,7 @@ defmodule Mobilizon.Activities do
       [%Activity{}, ...]
 
   """
+  @spec list_activities :: list(Activity.t())
   def list_activities do
     Repo.all(Activity)
   end
@@ -161,6 +162,7 @@ defmodule Mobilizon.Activities do
       ** (Ecto.NoResultsError)
 
   """
+  @spec get_activity!(integer()) :: Activity.t()
   def get_activity!(id), do: Repo.get!(Activity, id)
 
   @doc """
@@ -175,6 +177,7 @@ defmodule Mobilizon.Activities do
       {:error, %Ecto.Changeset{}}
 
   """
+  @spec create_activity(map()) :: {:ok, Activity.t()} | {:error, Ecto.Changeset.t()}
   def create_activity(attrs \\ %{}) do
     %Activity{}
     |> Activity.changeset(attrs)
@@ -186,10 +189,13 @@ defmodule Mobilizon.Activities do
     Repo.preload(activity, @activity_preloads)
   end
 
+  @spec object_types :: list(String.t())
   def object_types, do: @object_type
 
+  @spec subjects :: list(String.t())
   def subjects, do: @subjects
 
+  @spec activity_types :: list(String.t())
   def activity_types, do: @activity_types
 
   @spec filter_object_type(Query.t(), atom() | nil) :: Query.t()
diff --git a/lib/mobilizon/activities/activity.ex b/lib/mobilizon/activities/activity.ex
index 08698d2eb..6e1681e2d 100644
--- a/lib/mobilizon/activities/activity.ex
+++ b/lib/mobilizon/activities/activity.ex
@@ -15,7 +15,8 @@ defmodule Mobilizon.Activities.Activity do
     :message,
     :message_params,
     :object_type,
-    :object_id
+    :object_id,
+    :object
   ]
   @attrs @required_attrs ++ @optional_attrs
 
@@ -28,6 +29,7 @@ defmodule Mobilizon.Activities.Activity do
           message_params: map(),
           object_type: ObjectType.t(),
           object_id: String.t(),
+          object: map(),
           author: Actor.t(),
           group: Actor.t()
         }
@@ -41,12 +43,14 @@ defmodule Mobilizon.Activities.Activity do
     field(:message_params, :map, default: %{})
     field(:object_type, ObjectType)
     field(:object_id, :string)
+    field(:object, :map, virtual: true)
     field(:inserted_at, :utc_datetime)
     belongs_to(:author, Actor)
     belongs_to(:group, Actor)
   end
 
   @doc false
+  @spec changeset(t | Ecto.Schema.t(), map) :: Ecto.Changeset.t()
   def changeset(activity, attrs) do
     activity
     |> cast(attrs, @attrs)
diff --git a/lib/mobilizon/actors/actor.ex b/lib/mobilizon/actors/actor.ex
index 1bfa41c31..ff0df5afc 100644
--- a/lib/mobilizon/actors/actor.ex
+++ b/lib/mobilizon/actors/actor.ex
@@ -11,7 +11,7 @@ defmodule Mobilizon.Actors.Actor do
   alias Mobilizon.Actors.{ActorOpenness, ActorType, ActorVisibility, Follower, Member}
   alias Mobilizon.Addresses.Address
   alias Mobilizon.Discussions.Comment
-  alias Mobilizon.Events.{Event, FeedToken}
+  alias Mobilizon.Events.{Event, FeedToken, Participant}
   alias Mobilizon.Medias.File
   alias Mobilizon.Reports.{Note, Report}
   alias Mobilizon.Users.User
@@ -23,6 +23,7 @@ defmodule Mobilizon.Actors.Actor do
   require Logger
 
   @type t :: %__MODULE__{
+          id: integer(),
           url: String.t(),
           outbox_url: String.t(),
           inbox_url: String.t(),
@@ -33,8 +34,8 @@ defmodule Mobilizon.Actors.Actor do
           posts_url: String.t(),
           events_url: String.t(),
           type: ActorType.t(),
-          name: String.t(),
-          domain: String.t(),
+          name: String.t() | nil,
+          domain: String.t() | nil,
           summary: String.t(),
           preferred_username: String.t(),
           keys: String.t(),
@@ -42,12 +43,13 @@ defmodule Mobilizon.Actors.Actor do
           openness: ActorOpenness.t(),
           visibility: ActorVisibility.t(),
           suspended: boolean,
-          avatar: File.t(),
-          banner: File.t(),
+          avatar: File.t() | nil,
+          banner: File.t() | nil,
           user: User.t(),
           followers: [Follower.t()],
           followings: [Follower.t()],
           organized_events: [Event.t()],
+          participations: [Participant.t()],
           comments: [Comment.t()],
           feed_tokens: [FeedToken.t()],
           created_reports: [Report.t()],
@@ -184,6 +186,7 @@ defmodule Mobilizon.Actors.Actor do
     has_many(:created_reports, Report, foreign_key: :reporter_id)
     has_many(:subject_reports, Report, foreign_key: :reported_id)
     has_many(:report_notes, Note, foreign_key: :moderator_id)
+    has_many(:participations, Participant, foreign_key: :actor_id)
     has_many(:mentions, Mention)
     has_many(:shares, Share, foreign_key: :actor_id)
     has_many(:owner_shares, Share, foreign_key: :owner_actor_id)
@@ -243,7 +246,7 @@ defmodule Mobilizon.Actors.Actor do
   end
 
   @doc false
-  @spec changeset(t, map) :: Ecto.Changeset.t()
+  @spec changeset(t | Ecto.Schema.t(), map) :: Ecto.Changeset.t()
   def changeset(%__MODULE__{} = actor, attrs) do
     actor
     |> cast(attrs, @attrs)
@@ -278,7 +281,7 @@ defmodule Mobilizon.Actors.Actor do
   @doc """
   Changeset for person registration.
   """
-  @spec registration_changeset(t, map) :: Ecto.Changeset.t()
+  @spec registration_changeset(t | Ecto.Schema.t(), map) :: Ecto.Changeset.t()
   def registration_changeset(%__MODULE__{} = actor, attrs) do
     actor
     |> cast(attrs, @registration_attrs)
@@ -293,19 +296,14 @@ defmodule Mobilizon.Actors.Actor do
   """
   @spec remote_actor_creation_changeset(map) :: Ecto.Changeset.t()
   def remote_actor_creation_changeset(attrs) do
-    changeset =
-      %__MODULE__{}
-      |> cast(attrs, @remote_actor_creation_attrs)
-      |> validate_required(@remote_actor_creation_required_attrs)
-      |> common_changeset(attrs)
-      |> unique_username_validator()
-      |> validate_required(:domain)
-      |> validate_length(:summary, max: 5000)
-      |> validate_length(:preferred_username, max: 100)
-
-    Logger.debug("Remote actor creation: #{inspect(changeset)}")
-
-    changeset
+    %__MODULE__{}
+    |> cast(attrs, @remote_actor_creation_attrs)
+    |> validate_required(@remote_actor_creation_required_attrs)
+    |> common_changeset(attrs)
+    |> unique_username_validator()
+    |> validate_required(:domain)
+    |> validate_length(:summary, max: 5000)
+    |> validate_length(:preferred_username, max: 100)
   end
 
   @spec common_changeset(Ecto.Changeset.t(), map()) :: Ecto.Changeset.t()
@@ -323,8 +321,8 @@ defmodule Mobilizon.Actors.Actor do
   @doc """
   Changeset for group creation
   """
-  @spec group_creation_changeset(t, map) :: Ecto.Changeset.t()
-  def group_creation_changeset(%__MODULE__{} = actor, params) do
+  @spec group_creation_changeset(t | Ecto.Schema.t(), map) :: Ecto.Changeset.t()
+  def group_creation_changeset(actor, params) do
     actor
     |> cast(params, @group_creation_attrs)
     |> build_urls(:Group)
@@ -416,12 +414,8 @@ defmodule Mobilizon.Actors.Actor do
   @spec build_relay_creation_attrs :: Ecto.Changeset.t()
   def build_relay_creation_attrs do
     data = %{
-      name: Config.get([:instance, :name], "Mobilizon"),
-      summary:
-        Config.get(
-          [:instance, :description],
-          "An internal service actor for this Mobilizon instance"
-        ),
+      name: Config.instance_name(),
+      summary: Config.instance_description(),
       keys: Crypto.generate_rsa_2048_private_key(),
       preferred_username: "relay",
       domain: nil,
diff --git a/lib/mobilizon/actors/actors.ex b/lib/mobilizon/actors/actors.ex
index 07e7e5d05..0213df66d 100644
--- a/lib/mobilizon/actors/actors.ex
+++ b/lib/mobilizon/actors/actors.ex
@@ -12,16 +12,12 @@ defmodule Mobilizon.Actors do
 
   alias Mobilizon.Actors.{Actor, Bot, Follower, Member}
   alias Mobilizon.Addresses.Address
-  alias Mobilizon.{Crypto, Events}
+  alias Mobilizon.Crypto
   alias Mobilizon.Events.FeedToken
-  alias Mobilizon.Federation.ActivityPub
-  alias Mobilizon.Medias.File
-  alias Mobilizon.Service.ErrorReporting.Sentry
   alias Mobilizon.Service.Workers
   alias Mobilizon.Storage.{Page, Repo}
   alias Mobilizon.Users
   alias Mobilizon.Users.User
-  alias Mobilizon.Web.Email.Group
   alias Mobilizon.Web.Upload
 
   require Logger
@@ -61,7 +57,6 @@ defmodule Mobilizon.Actors do
   @administrator_roles [:creator, :administrator]
   @moderator_roles [:moderator] ++ @administrator_roles
   @member_roles [:member] ++ @moderator_roles
-  @actor_preloads [:user, :organized_events, :comments]
 
   @doc """
   Gets a single actor.
@@ -80,13 +75,20 @@ defmodule Mobilizon.Actors do
   @doc """
   Gets an actor with preloaded relations.
   """
-  @spec get_actor_with_preload(integer | String.t()) :: Actor.t() | nil
+  @spec get_actor_with_preload(integer | String.t(), boolean) :: Actor.t() | nil
   def get_actor_with_preload(id, include_suspended \\ false) do
     id
     |> actor_with_preload_query(include_suspended)
     |> Repo.one()
   end
 
+  @spec get_actor_with_preload!(integer | String.t(), boolean) :: Actor.t()
+  def get_actor_with_preload!(id, include_suspended \\ false) do
+    id
+    |> actor_with_preload_query(include_suspended)
+    |> Repo.one!()
+  end
+
   @doc """
   Gets a local actor with preloaded relations.
   """
@@ -151,11 +153,9 @@ defmodule Mobilizon.Actors do
   @doc """
   Gets an actor by name.
   """
-  @spec get_actor_by_name(String.t(), atom | nil) :: Actor.t() | nil
+  @spec get_actor_by_name(String.t(), ActorType.t() | nil) :: Actor.t() | nil
   def get_actor_by_name(name, type \\ nil) do
-    query = from(a in Actor)
-
-    query
+    Actor
     |> filter_by_type(type)
     |> filter_by_name(name |> String.trim() |> String.trim_leading("@") |> String.split("@"))
     |> Repo.one()
@@ -166,9 +166,7 @@ defmodule Mobilizon.Actors do
   """
   @spec get_local_actor_by_name(String.t()) :: Actor.t() | nil
   def get_local_actor_by_name(name) do
-    query = from(a in Actor)
-
-    query
+    Actor
     |> filter_by_name([name])
     |> Repo.one()
   end
@@ -215,7 +213,8 @@ defmodule Mobilizon.Actors do
   @doc """
   Creates a new person actor.
   """
-  @spec new_person(map) :: {:ok, Actor.t()} | {:error, Ecto.Changeset.t()}
+  @spec new_person(map, default_actor :: boolean()) ::
+          {:ok, Actor.t()} | {:error, Ecto.Changeset.t()}
   def new_person(args, default_actor \\ false) do
     args = Map.put(args, :keys, Crypto.generate_rsa_2048_private_key())
 
@@ -300,6 +299,7 @@ defmodule Mobilizon.Actors do
 
   @delete_actor_default_options [reserve_username: true, suspension: false]
 
+  @spec delete_actor(Actor.t(), Keyword.t()) :: {:error, Ecto.Changeset.t()} | {:ok, Oban.Job.t()}
   def delete_actor(%Actor{} = actor, options \\ @delete_actor_default_options) do
     delete_actor_options = Keyword.merge(@delete_actor_default_options, options)
 
@@ -311,98 +311,6 @@ defmodule Mobilizon.Actors do
     })
   end
 
-  @doc """
-  Deletes an actor.
-  """
-  @spec perform(atom(), Actor.t()) :: {:ok, Actor.t()} | {:error, Ecto.Changeset.t()}
-  def perform(:delete_actor, %Actor{type: type} = actor, options \\ @delete_actor_default_options) do
-    Logger.info("Going to delete actor #{actor.url}")
-    actor = Repo.preload(actor, @actor_preloads)
-
-    delete_actor_options = Keyword.merge(@delete_actor_default_options, options)
-    Logger.debug(inspect(delete_actor_options))
-
-    if type == :Group do
-      delete_eventual_local_members(actor, delete_actor_options)
-    end
-
-    multi =
-      Multi.new()
-      |> Multi.run(:delete_organized_events, fn _, _ -> delete_actor_organized_events(actor) end)
-      |> Multi.run(:empty_comments, fn _, _ -> delete_actor_empty_comments(actor) end)
-      |> Multi.run(:remove_banner, fn _, _ -> remove_banner(actor) end)
-      |> Multi.run(:remove_avatar, fn _, _ -> remove_avatar(actor) end)
-
-    multi =
-      case type do
-        :Group ->
-          multi
-          |> Multi.run(:delete_remote_members, fn _, _ ->
-            delete_group_elements(actor, :remote_members)
-          end)
-          |> Multi.run(:delete_group_organized_events, fn _, _ ->
-            delete_group_elements(actor, :events)
-          end)
-          |> Multi.run(:delete_group_posts, fn _, _ ->
-            delete_group_elements(actor, :posts)
-          end)
-          |> Multi.run(:delete_group_resources, fn _, _ ->
-            delete_group_elements(actor, :resources)
-          end)
-          |> Multi.run(:delete_group_todo_lists, fn _, _ ->
-            delete_group_elements(actor, :todo_lists)
-          end)
-          |> Multi.run(:delete_group_discussions, fn _, _ ->
-            delete_group_elements(actor, :discussions)
-          end)
-
-        :Person ->
-          # When deleting a profile, reset default_actor_id
-          Multi.run(multi, :reset_default_actor_id, fn _, _ ->
-            reset_default_actor_id(actor)
-          end)
-
-        _ ->
-          multi
-      end
-
-    multi =
-      if Keyword.get(delete_actor_options, :reserve_username, true) do
-        Multi.update(multi, :actor, Actor.delete_changeset(actor))
-      else
-        Multi.delete(multi, :actor, actor)
-      end
-
-    Logger.debug("Going to run the transaction")
-
-    case Repo.transaction(multi) do
-      {:ok, %{actor: %Actor{} = actor}} ->
-        {:ok, true} = Cachex.del(:activity_pub, "actor_#{actor.preferred_username}")
-        Logger.info("Deleted actor #{actor.url}")
-        {:ok, actor}
-
-      {:error, remove, error, _} when remove in [:remove_banner, :remove_avatar] ->
-        Logger.error("Error while deleting actor's banner or avatar")
-
-        Sentry.capture_message("Error while deleting actor's banner or avatar",
-          extra: %{err: error}
-        )
-
-        Logger.debug(inspect(error, pretty: true))
-        {:error, error}
-
-      err ->
-        Logger.error("Unknown error while deleting actor")
-
-        Sentry.capture_message("Error while deleting actor's banner or avatar",
-          extra: %{err: err}
-        )
-
-        Logger.debug(inspect(err, pretty: true))
-        {:error, err}
-    end
-  end
-
   @spec actor_key_rotation(Actor.t()) :: {:ok, Actor.t()} | {:error, Ecto.Changeset.t()}
   def actor_key_rotation(%Actor{} = actor) do
     actor
@@ -420,8 +328,8 @@ defmodule Mobilizon.Actors do
           String.t(),
           boolean,
           boolean,
-          integer,
-          integer
+          integer | nil,
+          integer | nil
         ) :: Page.t()
   def list_actors(
         type \\ :Person,
@@ -464,7 +372,23 @@ defmodule Mobilizon.Actors do
     |> Page.build_page(page, limit)
   end
 
-  @spec filter_actors(Ecto.Query.t(), String.t(), String.t(), String.t(), boolean(), boolean()) ::
+  @spec list_suspended_actors_to_purge(Keyword.t()) :: list(Actors.t())
+  def list_suspended_actors_to_purge(options) do
+    suspension_days = Keyword.get(options, :suspension, 30)
+
+    Actor
+    |> filter_suspended_days(suspension_days)
+    |> Repo.all()
+  end
+
+  @spec filter_actors(
+          Ecto.Queryable.t(),
+          String.t(),
+          String.t(),
+          String.t(),
+          boolean(),
+          boolean()
+        ) ::
           Ecto.Query.t()
   defp filter_actors(
          query,
@@ -500,14 +424,27 @@ defmodule Mobilizon.Actors do
   defp filter_remote(query, true), do: filter_local(query)
   defp filter_remote(query, false), do: filter_external(query)
 
-  @spec filter_suspended(Ecto.Query.t(), boolean()) :: Ecto.Query.t()
+  @spec filter_suspended(Ecto.Queryable.t(), boolean()) :: Ecto.Query.t()
   defp filter_suspended(query, true), do: where(query, [a], a.suspended)
   defp filter_suspended(query, false), do: where(query, [a], not a.suspended)
 
-  @spec filter_out_anonymous_actor_id(Ecto.Query.t(), integer() | String.t()) :: Ecto.Query.t()
+  @spec filter_out_anonymous_actor_id(Ecto.Queryable.t(), integer() | String.t()) ::
+          Ecto.Query.t()
   defp filter_out_anonymous_actor_id(query, anonymous_actor_id),
     do: where(query, [a], a.id != ^anonymous_actor_id)
 
+  @spec filter_suspended_days(Ecto.Queryable.t(), integer()) :: Ecto.Query.t()
+  defp filter_suspended_days(query, suspended_days) do
+    expiration_date = DateTime.add(DateTime.utc_now(), suspended_days * 24 * -3600)
+
+    where(
+      query,
+      [a],
+      a.suspended and
+        a.updated_at > ^expiration_date
+    )
+  end
+
   @doc """
   Returns the list of local actors by their username.
   """
@@ -536,8 +473,9 @@ defmodule Mobilizon.Actors do
         limit \\ nil
       ) do
     anonymous_actor_id = Mobilizon.Config.anonymous_actor_id()
+    query = from(a in Actor)
 
-    Actor
+    query
     |> actor_by_username_or_name_query(term)
     |> actors_for_location(Keyword.get(options, :location), Keyword.get(options, :radius))
     |> filter_by_types(Keyword.get(options, :actor_type, :Group))
@@ -582,21 +520,21 @@ defmodule Mobilizon.Actors do
     end
   end
 
-  @spec get_local_group_by_url(String.t()) :: Actor.t()
+  @spec get_local_group_by_url(String.t()) :: Actor.t() | nil
   def get_local_group_by_url(group_url) do
     group_query()
     |> where([q], q.url == ^group_url and is_nil(q.domain))
     |> Repo.one()
   end
 
-  @spec get_group_by_members_url(String.t()) :: Actor.t()
+  @spec get_group_by_members_url(String.t()) :: Actor.t() | nil
   def get_group_by_members_url(members_url) do
     group_query()
     |> where([q], q.members_url == ^members_url)
     |> Repo.one()
   end
 
-  @spec get_actor_by_followers_url(String.t()) :: Actor.t()
+  @spec get_actor_by_followers_url(String.t()) :: Actor.t() | nil
   def get_actor_by_followers_url(followers_url) do
     Actor
     |> where([q], q.followers_url == ^followers_url)
@@ -610,21 +548,25 @@ defmodule Mobilizon.Actors do
   """
   @spec create_group(map) :: {:ok, Actor.t()} | {:error, Ecto.Changeset.t()}
   def create_group(attrs \\ %{}) do
-    local = Map.get(attrs, :local, true)
+    if Map.get(attrs, :local, true) do
+      multi =
+        Multi.new()
+        |> Multi.insert(:insert_group, Actor.group_creation_changeset(%Actor{}, attrs))
+        |> Multi.insert(:add_admin_member, fn %{insert_group: group} ->
+          Member.changeset(%Member{}, %{
+            parent_id: group.id,
+            actor_id: attrs.creator_actor_id,
+            role: :administrator
+          })
+        end)
+        |> Repo.transaction()
 
-    if local do
-      with {:ok, %{insert_group: %Actor{} = group, add_admin_member: %Member{} = _admin_member}} <-
-             Multi.new()
-             |> Multi.insert(:insert_group, Actor.group_creation_changeset(%Actor{}, attrs))
-             |> Multi.insert(:add_admin_member, fn %{insert_group: group} ->
-               Member.changeset(%Member{}, %{
-                 parent_id: group.id,
-                 actor_id: attrs.creator_actor_id,
-                 role: :administrator
-               })
-             end)
-             |> Repo.transaction() do
-        {:ok, group}
+      case multi do
+        {:ok, %{insert_group: %Actor{} = group, add_admin_member: %Member{} = _admin_member}} ->
+          {:ok, group}
+
+        {:error, _err, %Ecto.Changeset{} = err, _} ->
+          {:error, err}
       end
     else
       %Actor{}
@@ -698,7 +640,7 @@ defmodule Mobilizon.Actors do
   @doc """
   Gets a single member.
   """
-  @spec get_member(integer | String.t()) :: {:ok, Member.t()} | nil
+  @spec get_member(integer | String.t()) :: Member.t() | nil
   def get_member(id) do
     Member
     |> Repo.get(id)
@@ -715,7 +657,7 @@ defmodule Mobilizon.Actors do
   @doc """
   Gets a single member of an actor (for example a group).
   """
-  @spec get_member(integer | String.t(), integer | String.t()) ::
+  @spec get_member(actor_id :: integer | String.t(), parent_id :: integer | String.t()) ::
           {:ok, Member.t()} | {:error, :member_not_found}
   def get_member(actor_id, parent_id) do
     case Repo.get_by(Member, actor_id: actor_id, parent_id: parent_id) do
@@ -818,18 +760,21 @@ defmodule Mobilizon.Actors do
   """
   @spec create_member(map) :: {:ok, Member.t()} | {:error, Ecto.Changeset.t()}
   def create_member(attrs \\ %{}) do
-    with {:ok, %Member{} = member} <-
-           %Member{}
-           |> Member.changeset(attrs)
-           |> Repo.insert(
-             on_conflict: {:replace_all_except, [:id, :url, :actor_id, :parent_id]},
-             conflict_target: [:actor_id, :parent_id],
-             # See https://hexdocs.pm/ecto/Ecto.Repo.html#c:insert/2-upserts,
-             # when doing an upsert with on_conflict, PG doesn't return whether it's an insert or upsert
-             # so we need to refresh the fields
-             returning: true
-           ) do
-      {:ok, Repo.preload(member, [:actor, :parent, :invited_by])}
+    case %Member{}
+         |> Member.changeset(attrs)
+         |> Repo.insert(
+           on_conflict: {:replace_all_except, [:id, :url, :actor_id, :parent_id]},
+           conflict_target: [:actor_id, :parent_id],
+           # See https://hexdocs.pm/ecto/Ecto.Repo.html#c:insert/2-upserts,
+           # when doing an upsert with on_conflict, PG doesn't return whether it's an insert or upsert
+           # so we need to refresh the fields
+           returning: true
+         ) do
+      {:ok, %Member{} = member} ->
+        {:ok, Repo.preload(member, [:actor, :parent, :invited_by])}
+
+      {:error, %Ecto.Changeset{} = err} ->
+        {:error, err}
     end
   end
 
@@ -881,6 +826,13 @@ defmodule Mobilizon.Actors do
     |> Page.build_page(page, limit)
   end
 
+  @spec list_all_local_members_for_group(Actor.t()) :: Member.t()
+  def list_all_local_members_for_group(%Actor{id: group_id, type: :Group} = _group) do
+    group_id
+    |> group_internal_member_query()
+    |> Repo.all()
+  end
+
   @spec list_local_members_for_group(Actor.t(), integer | nil, integer | nil) :: Page.t()
   def list_local_members_for_group(
         %Actor{id: group_id, type: :Group} = _group,
@@ -995,7 +947,7 @@ defmodule Mobilizon.Actors do
   @doc """
   Creates a bot.
   """
-  @spec create_bot(map) :: {:ok, Bot.t()} | {:error, Ecto.Changeset.t()}
+  @spec create_bot(attrs :: map) :: {:ok, Bot.t()} | {:error, Ecto.Changeset.t()}
   def create_bot(attrs \\ %{}) do
     %Bot{}
     |> Bot.changeset(attrs)
@@ -1005,7 +957,8 @@ defmodule Mobilizon.Actors do
   @doc """
   Registers a new bot.
   """
-  @spec register_bot(map) :: {:ok, Actor.t()} | {:error, Ecto.Changeset.t()}
+  @spec register_bot(%{name: String.t(), summary: String.t()}) ::
+          {:ok, Actor.t()} | {:error, Ecto.Changeset.t()}
   def register_bot(%{name: name, summary: summary}) do
     attrs = %{
       preferred_username: name,
@@ -1020,7 +973,8 @@ defmodule Mobilizon.Actors do
     |> Repo.insert()
   end
 
-  @spec get_or_create_internal_actor(String.t()) :: {:ok, Actor.t()}
+  @spec get_or_create_internal_actor(String.t()) ::
+          {:ok, Actor.t()} | {:error, Ecto.Changeset.t()}
   def get_or_create_internal_actor(username) do
     case username |> Actor.build_url(:page) |> get_actor_by_url() do
       {:ok, %Actor{} = actor} ->
@@ -1105,13 +1059,16 @@ defmodule Mobilizon.Actors do
   @doc """
   Creates a follower.
   """
-  @spec create_follower(map) :: {:ok, Follower.t()} | {:error, Ecto.Changeset.t()}
+  @spec create_follower(attrs :: map) :: {:ok, Follower.t()} | {:error, Ecto.Changeset.t()}
   def create_follower(attrs \\ %{}) do
-    with {:ok, %Follower{} = follower} <-
-           %Follower{}
-           |> Follower.changeset(attrs)
-           |> Repo.insert() do
-      {:ok, Repo.preload(follower, [:actor, :target_actor])}
+    case %Follower{}
+         |> Follower.changeset(attrs)
+         |> Repo.insert() do
+      {:ok, %Follower{} = follower} ->
+        {:ok, Repo.preload(follower, [:actor, :target_actor])}
+
+      {:error, %Ecto.Changeset{} = err} ->
+        {:error, err}
     end
   end
 
@@ -1267,31 +1224,35 @@ defmodule Mobilizon.Actors do
   @doc """
   Makes an actor following another actor.
   """
-  @spec follow(Actor.t(), Actor.t(), String.t() | nil, boolean | nil) ::
-          {:ok, Follower.t()} | {:error, atom, String.t()}
+  @spec follow(
+          followed :: Actor.t(),
+          follower :: Actor.t(),
+          url :: String.t() | nil,
+          approved :: boolean | nil
+        ) ::
+          {:ok, Follower.t()}
+          | {:error, :already_following | :followed_suspended | Ecto.Changeset.t()}
   def follow(%Actor{} = followed, %Actor{} = follower, url \\ nil, approved \\ true) do
-    with {:suspended, false} <- {:suspended, followed.suspended},
-         # Check if followed has blocked follower
-         {:already_following, nil} <- {:already_following, is_following(follower, followed)} do
-      Logger.info(
-        "Making #{Actor.preferred_username_and_domain(follower)} follow #{Actor.preferred_username_and_domain(followed)} " <>
-          "(approved: #{approved})"
-      )
-
-      create_follower(%{
-        "actor_id" => follower.id,
-        "target_actor_id" => followed.id,
-        "approved" => approved,
-        "url" => url
-      })
+    if followed.suspended do
+      {:error, :followed_suspended}
     else
-      {:already_following, %Follower{}} ->
-        {:error, :already_following,
-         "Could not follow actor: you are already following #{Actor.preferred_username_and_domain(followed)}"}
+      case is_following(follower, followed) do
+        %Follower{} ->
+          {:error, :already_following}
 
-      {:suspended, _} ->
-        {:error, :suspended,
-         "Could not follow actor: #{Actor.preferred_username_and_domain(followed)} has been suspended"}
+        nil ->
+          Logger.info(
+            "Making #{Actor.preferred_username_and_domain(follower)} follow #{Actor.preferred_username_and_domain(followed)} " <>
+              "(approved: #{approved})"
+          )
+
+          create_follower(%{
+            "actor_id" => follower.id,
+            "target_actor_id" => followed.id,
+            "approved" => approved,
+            "url" => url
+          })
+      end
     end
   end
 
@@ -1345,7 +1306,8 @@ defmodule Mobilizon.Actors do
     end
   end
 
-  @spec schedule_key_rotation(Actor.t(), integer()) :: nil
+  # TODO: Move me otherwhere
+  @spec schedule_key_rotation(Actor.t(), integer()) :: :ok
   def schedule_key_rotation(%Actor{id: actor_id} = actor, delay) do
     Cachex.put(:actor_key_rotation, actor_id, true)
 
@@ -1354,36 +1316,6 @@ defmodule Mobilizon.Actors do
     :ok
   end
 
-  @spec remove_banner(Actor.t()) :: {:ok, Actor.t()}
-  defp remove_banner(%Actor{banner: nil} = actor), do: {:ok, actor}
-
-  defp remove_banner(%Actor{banner: %File{url: url}} = actor) do
-    safe_remove_file(url, actor)
-    {:ok, actor}
-  end
-
-  @spec remove_avatar(Actor.t()) :: {:ok, Actor.t()}
-  defp remove_avatar(%Actor{avatar: nil} = actor), do: {:ok, actor}
-
-  defp remove_avatar(%Actor{avatar: %File{url: url}} = actor) do
-    safe_remove_file(url, actor)
-    {:ok, actor}
-  end
-
-  @spec safe_remove_file(String.t(), Actor.t()) :: {:ok, Actor.t()}
-  defp safe_remove_file(url, %Actor{} = actor) do
-    case Upload.remove(url) do
-      {:ok, _value} ->
-        {:ok, actor}
-
-      {:error, error} ->
-        Logger.error("Error while removing an upload file")
-        Logger.debug(inspect(error))
-
-        {:ok, actor}
-    end
-  end
-
   @spec delete_files_if_media_changed(Ecto.Changeset.t()) :: Ecto.Changeset.t()
   defp delete_files_if_media_changed(%Ecto.Changeset{changes: changes, data: data} = changeset) do
     Enum.each([:avatar, :banner], fn key ->
@@ -1437,7 +1369,7 @@ defmodule Mobilizon.Actors do
     )
   end
 
-  @spec actor_by_username_or_name_query(Ecto.Query.t(), String.t()) :: Ecto.Query.t()
+  @spec actor_by_username_or_name_query(Ecto.Queryable.t(), String.t()) :: Ecto.Query.t()
   defp actor_by_username_or_name_query(query, ""), do: query
 
   defp actor_by_username_or_name_query(query, username) do
@@ -1464,9 +1396,9 @@ defmodule Mobilizon.Actors do
     )
   end
 
-  @spec actors_for_location(Ecto.Query.t(), String.t(), integer()) :: Ecto.Query.t()
+  @spec actors_for_location(Ecto.Queryable.t(), String.t(), integer()) :: Ecto.Query.t()
   defp actors_for_location(query, location, radius)
-       when is_valid_string?(location) and not is_nil(radius) do
+       when is_valid_string(location) and not is_nil(radius) do
     with {lon, lat} <- Geohax.decode(location),
          point <- Geo.WKT.decode!("SRID=4326;POINT(#{lon} #{lat})") do
       query
@@ -1580,7 +1512,7 @@ defmodule Mobilizon.Actors do
     |> select([m, _a], m)
   end
 
-  @spec filter_member_role(Ecto.Query.t(), list(atom()) | atom()) :: Ecto.Query.t()
+  @spec filter_member_role(Ecto.Queryable.t(), list(atom()) | atom()) :: Ecto.Query.t()
   defp filter_member_role(query, []), do: query
 
   defp filter_member_role(query, roles) when is_list(roles) do
@@ -1703,24 +1635,24 @@ defmodule Mobilizon.Actors do
     |> order_by(desc: :updated_at)
   end
 
-  @spec filter_local(Ecto.Query.t()) :: Ecto.Query.t()
+  @spec filter_local(Ecto.Queryable.t()) :: Ecto.Query.t()
   defp filter_local(query) do
     from(a in query, where: is_nil(a.domain))
   end
 
-  @spec filter_external(Ecto.Query.t()) :: Ecto.Query.t()
+  @spec filter_external(Ecto.Queryable.t()) :: Ecto.Query.t()
   defp filter_external(query) do
     from(a in query, where: not is_nil(a.domain))
   end
 
-  @spec filter_follower_actors_external(Ecto.Query.t()) :: Ecto.Query.t()
+  @spec filter_follower_actors_external(Ecto.Queryable.t()) :: Ecto.Query.t()
   defp filter_follower_actors_external(query) do
     query
     |> where([_f, a], not is_nil(a.domain))
     |> preload([f, a], [:target_actor, :actor])
   end
 
-  @spec filter_by_type(Ecto.Query.t(), ActorType.t()) :: Ecto.Query.t()
+  @spec filter_by_type(Ecto.Queryable.t(), ActorType.t() | nil) :: Ecto.Queryable.t()
   defp filter_by_type(query, type)
        when type in [:Person, :Group, :Application, :Service, :Organisation] do
     from(a in query, where: a.type == ^type)
@@ -1728,12 +1660,12 @@ defmodule Mobilizon.Actors do
 
   defp filter_by_type(query, _type), do: query
 
-  @spec filter_by_types(Ecto.Query.t(), [ActorType.t()]) :: Ecto.Query.t()
+  @spec filter_by_types(Ecto.Queryable.t(), [ActorType.t()]) :: Ecto.Query.t()
   defp filter_by_types(query, types) do
     from(a in query, where: a.type in ^types)
   end
 
-  @spec filter_by_minimum_visibility(Ecto.Query.t(), atom()) :: Ecto.Query.t()
+  @spec filter_by_minimum_visibility(Ecto.Queryable.t(), atom()) :: Ecto.Query.t()
   defp filter_by_minimum_visibility(query, :private), do: query
 
   defp filter_by_minimum_visibility(query, :restricted) do
@@ -1748,9 +1680,9 @@ defmodule Mobilizon.Actors do
     from(a in query, where: a.visibility == ^:public)
   end
 
-  @spec filter_by_name(Ecto.Query.t(), [String.t()]) :: Ecto.Query.t()
+  @spec filter_by_name(query :: Ecto.Queryable.t(), [String.t()]) :: Ecto.Query.t()
   defp filter_by_name(query, [name]) do
-    from(a in query, where: a.preferred_username == ^name and is_nil(a.domain))
+    where(query, [a], a.preferred_username == ^name and is_nil(a.domain))
   end
 
   defp filter_by_name(query, [name, domain]) do
@@ -1761,6 +1693,7 @@ defmodule Mobilizon.Actors do
     end
   end
 
+  @spec filter_followed_by_approved_status(Ecto.Queryable.t(), boolean() | nil) :: Ecto.Query.t()
   defp filter_followed_by_approved_status(query, nil), do: query
 
   defp filter_followed_by_approved_status(query, approved) do
@@ -1770,141 +1703,4 @@ defmodule Mobilizon.Actors do
   @spec preload_followers(Actor.t(), boolean) :: Actor.t()
   defp preload_followers(actor, true), do: Repo.preload(actor, [:followers])
   defp preload_followers(actor, false), do: actor
-
-  defp delete_actor_organized_events(%Actor{organized_events: organized_events} = actor) do
-    res =
-      Enum.map(organized_events, fn event ->
-        event =
-          Repo.preload(event, [
-            :organizer_actor,
-            :participants,
-            :picture,
-            :mentions,
-            :comments,
-            :attributed_to,
-            :tags,
-            :physical_address,
-            :contacts,
-            :media
-          ])
-
-        ActivityPub.delete(event, actor, false)
-      end)
-
-    if Enum.all?(res, fn {status, _, _} -> status == :ok end) do
-      {:ok, res}
-    else
-      {:error, res}
-    end
-  end
-
-  defp delete_actor_empty_comments(%Actor{comments: comments} = actor) do
-    res =
-      Enum.map(comments, fn comment ->
-        comment =
-          Repo.preload(comment, [
-            :actor,
-            :mentions,
-            :event,
-            :in_reply_to_comment,
-            :origin_comment,
-            :attributed_to,
-            :tags
-          ])
-
-        ActivityPub.delete(comment, actor, false)
-      end)
-
-    if Enum.all?(res, fn {status, _, _} -> status == :ok end) do
-      {:ok, res}
-    else
-      {:error, res}
-    end
-  end
-
-  defp delete_group_elements(%Actor{type: :Group} = actor, type) do
-    Logger.debug("delete_group_elements #{inspect(type)}")
-
-    method =
-      case type do
-        :remote_members -> &list_remote_members_for_group/3
-        :events -> &Events.list_simple_organized_events_for_group/3
-        :posts -> &Mobilizon.Posts.get_posts_for_group/3
-        :resources -> &Mobilizon.Resources.get_resources_for_group/3
-        :todo_lists -> &Mobilizon.Todos.get_todo_lists_for_group/3
-        :discussions -> &Mobilizon.Discussions.find_discussions_for_actor/3
-      end
-
-    res =
-      actor
-      |> accumulate_paginated_elements(method)
-      |> Enum.map(fn element -> ActivityPub.delete(element, actor, false) end)
-
-    if Enum.all?(res, fn {status, _, _} -> status == :ok end) do
-      Logger.debug("Return OK for all #{to_string(type)}")
-      {:ok, res}
-    else
-      Logger.debug("Something failed #{inspect(res)}")
-      {:error, res}
-    end
-  end
-
-  @spec reset_default_actor_id(Actor.t()) :: {:ok, User.t()} | {:error, :user_not_found}
-  defp reset_default_actor_id(%Actor{type: :Person, user: %User{id: user_id} = user, id: actor_id}) do
-    Logger.debug("reset_default_actor_id")
-
-    new_actor_id =
-      user
-      |> Users.get_actors_for_user()
-      |> Enum.map(& &1.id)
-      |> Enum.find(&(&1 !== actor_id))
-
-    {:ok, Users.update_user_default_actor(user_id, new_actor_id)}
-  rescue
-    _e in Ecto.NoResultsError ->
-      {:error, :user_not_found}
-  end
-
-  defp reset_default_actor_id(%Actor{type: :Person, user: nil}), do: {:ok, nil}
-
-  defp accumulate_paginated_elements(
-         %Actor{} = actor,
-         method,
-         elements \\ [],
-         page \\ 1,
-         limit \\ 10
-       ) do
-    Logger.debug("accumulate_paginated_elements")
-    %Page{total: total, elements: new_elements} = method.(actor, page, limit)
-    elements = elements ++ new_elements
-    count = length(elements)
-
-    if count < total do
-      accumulate_paginated_elements(actor, method, elements, page + 1, limit)
-    else
-      Logger.debug("Found #{count} group elements to delete")
-      elements
-    end
-  end
-
-  # This one is not in the Multi transaction because it sends activities
-  defp delete_eventual_local_members(%Actor{} = group, options) do
-    suspended? = Keyword.get(options, :suspension, false)
-
-    group
-    |> accumulate_paginated_elements(&list_local_members_for_group/3)
-    |> Enum.map(fn member ->
-      if suspended? do
-        Group.send_group_suspension_notification(member)
-      else
-        with author_id when not is_nil(author_id) <- Keyword.get(options, :author_id),
-             %Actor{} = author <- get_actor(author_id) do
-          Group.send_group_deletion_notification(member, author)
-        end
-      end
-
-      member
-    end)
-    |> Enum.map(fn member -> ActivityPub.delete(member, group, false) end)
-  end
 end
diff --git a/lib/mobilizon/actors/bot.ex b/lib/mobilizon/actors/bot.ex
index 7946ec14f..6c3af7f40 100644
--- a/lib/mobilizon/actors/bot.ex
+++ b/lib/mobilizon/actors/bot.ex
@@ -32,7 +32,7 @@ defmodule Mobilizon.Actors.Bot do
   end
 
   @doc false
-  @spec changeset(t, map) :: Ecto.Changeset.t()
+  @spec changeset(t | Ecto.Schema.t(), map) :: Ecto.Changeset.t()
   def changeset(%__MODULE__{} = bot, attrs) do
     bot
     |> cast(attrs, @attrs)
diff --git a/lib/mobilizon/actors/follower.ex b/lib/mobilizon/actors/follower.ex
index e77bc0154..396fb4b63 100644
--- a/lib/mobilizon/actors/follower.ex
+++ b/lib/mobilizon/actors/follower.ex
@@ -12,10 +12,13 @@ defmodule Mobilizon.Actors.Follower do
   alias Mobilizon.Web.Endpoint
 
   @type t :: %__MODULE__{
+          id: String.t(),
           approved: boolean,
           url: String.t(),
           target_actor: Actor.t(),
-          actor: Actor.t()
+          actor: Actor.t(),
+          inserted_at: DateTime.t(),
+          updated_at: DateTime.t()
         }
 
   @required_attrs [:url, :approved, :target_actor_id, :actor_id]
@@ -35,7 +38,7 @@ defmodule Mobilizon.Actors.Follower do
   end
 
   @doc false
-  @spec changeset(t, map) :: Ecto.Changeset.t()
+  @spec changeset(follower :: t | Ecto.Schema.t(), attrs :: map) :: Ecto.Changeset.t()
   def changeset(follower, attrs) do
     follower
     |> cast(attrs, @attrs)
diff --git a/lib/mobilizon/actors/member.ex b/lib/mobilizon/actors/member.ex
index e2481b0fc..424361472 100644
--- a/lib/mobilizon/actors/member.ex
+++ b/lib/mobilizon/actors/member.ex
@@ -8,18 +8,21 @@ defmodule Mobilizon.Actors.Member do
   import Ecto.Changeset
 
   alias Mobilizon.Actors.{Actor, MemberRole}
+  alias Mobilizon.Actors.Member.Metadata
   alias Mobilizon.Web.Endpoint
 
   @type t :: %__MODULE__{
+          id: String.t(),
+          url: String.t(),
           role: MemberRole.t(),
           parent: Actor.t(),
-          actor: Actor.t()
+          actor: Actor.t(),
+          metadata: Metadata.t()
         }
 
   @required_attrs [:parent_id, :actor_id, :url]
   @optional_attrs [:role, :invited_by_id]
   @attrs @required_attrs ++ @optional_attrs
-  @metadata_attrs []
 
   @primary_key {:id, :binary_id, autogenerate: true}
   schema "members" do
@@ -27,9 +30,7 @@ defmodule Mobilizon.Actors.Member do
     field(:url, :string)
     field(:member_since, :utc_datetime)
 
-    embeds_one :metadata, Metadata, on_replace: :delete do
-      # TODO : Use this space to put notes when someone is invited / requested to join
-    end
+    embeds_one(:metadata, Metadata, on_replace: :delete)
 
     belongs_to(:invited_by, Actor)
     belongs_to(:parent, Actor)
@@ -59,11 +60,11 @@ defmodule Mobilizon.Actors.Member do
   def is_administrator(%__MODULE__{}), do: false
 
   @doc false
-  @spec changeset(t, map) :: Ecto.Changeset.t()
+  @spec changeset(t | Ecto.Schema.t(), map) :: Ecto.Changeset.t()
   def changeset(%__MODULE__{} = member, attrs) do
     member
     |> cast(attrs, @attrs)
-    |> cast_embed(:metadata, with: &metadata_changeset/2)
+    |> cast_embed(:metadata)
     |> ensure_url()
     |> update_member_since()
     |> validate_required(@required_attrs)
@@ -72,11 +73,6 @@ defmodule Mobilizon.Actors.Member do
     |> unique_constraint(:url, name: :members_url_index)
   end
 
-  defp metadata_changeset(schema, params) do
-    schema
-    |> cast(params, @metadata_attrs)
-  end
-
   # If there's a blank URL that's because we're doing the first insert
   @spec ensure_url(Ecto.Changeset.t()) :: Ecto.Changeset.t()
   defp ensure_url(%Ecto.Changeset{data: %__MODULE__{url: nil}} = changeset) do
diff --git a/lib/mobilizon/actors/member/metadata.ex b/lib/mobilizon/actors/member/metadata.ex
new file mode 100644
index 000000000..ad4a251d1
--- /dev/null
+++ b/lib/mobilizon/actors/member/metadata.ex
@@ -0,0 +1,27 @@
+defmodule Mobilizon.Actors.Member.Metadata do
+  @moduledoc """
+  Represents metadata on a membership
+  """
+
+  use Ecto.Schema
+  import Ecto.Changeset
+
+  @type t :: %__MODULE__{}
+
+  @required_attrs []
+
+  @optional_attrs []
+
+  @attrs @required_attrs ++ @optional_attrs
+
+  embedded_schema do
+    # TODO : Use this space to put notes when someone is invited / requested to join
+  end
+
+  @doc false
+  @spec changeset(t | Ecto.Schema.t(), map) :: Ecto.Changeset.t()
+  def changeset(schema, params) do
+    schema
+    |> cast(params, @attrs)
+  end
+end
diff --git a/lib/mobilizon/addresses/address.ex b/lib/mobilizon/addresses/address.ex
index d1de602b5..edd02ac81 100644
--- a/lib/mobilizon/addresses/address.ex
+++ b/lib/mobilizon/addresses/address.ex
@@ -57,7 +57,7 @@ defmodule Mobilizon.Addresses.Address do
   end
 
   @doc false
-  @spec changeset(t, map) :: Ecto.Changeset.t()
+  @spec changeset(t | Ecto.Schema.t(), map) :: Ecto.Changeset.t()
   def changeset(%__MODULE__{} = address, attrs) do
     address
     |> cast(attrs, @attrs)
@@ -73,6 +73,7 @@ defmodule Mobilizon.Addresses.Address do
     put_change(changeset, :url, url)
   end
 
+  @spec coords(nil | t) :: nil | {float, float}
   def coords(nil), do: nil
 
   def coords(%__MODULE__{} = address) do
@@ -81,6 +82,7 @@ defmodule Mobilizon.Addresses.Address do
     end
   end
 
+  @spec representation(nil | t) :: nil | String.t()
   def representation(nil), do: nil
 
   def representation(%__MODULE__{} = address) do
diff --git a/lib/mobilizon/addresses/addresses.ex b/lib/mobilizon/addresses/addresses.ex
index 68137e000..6d1440ebb 100644
--- a/lib/mobilizon/addresses/addresses.ex
+++ b/lib/mobilizon/addresses/addresses.ex
@@ -118,7 +118,7 @@ defmodule Mobilizon.Addresses do
     )
   end
 
-  @spec order_by_coords(Ecto.Query.t(), map | nil) :: Ecto.Query.t()
+  @spec order_by_coords(Ecto.Queryable.t(), map | nil) :: Ecto.Query.t()
   defp order_by_coords(query, nil), do: query
 
   defp order_by_coords(query, coords) do
@@ -128,7 +128,7 @@ defmodule Mobilizon.Addresses do
     )
   end
 
-  @spec filter_by_contry(Ecto.Query.t(), String.t() | nil) :: Ecto.Query.t()
+  @spec filter_by_contry(Ecto.Queryable.t(), String.t() | nil) :: Ecto.Query.t()
   defp filter_by_contry(query, nil), do: query
 
   defp filter_by_contry(query, country) do
diff --git a/lib/mobilizon/admin/action_log.ex b/lib/mobilizon/admin/action_log.ex
index 9aa98000d..a40a8b700 100644
--- a/lib/mobilizon/admin/action_log.ex
+++ b/lib/mobilizon/admin/action_log.ex
@@ -35,7 +35,7 @@ defmodule Mobilizon.Admin.ActionLog do
   end
 
   @doc false
-  @spec changeset(t, map) :: Ecto.Changeset.t()
+  @spec changeset(t | Ecto.Schema.t(), map) :: Ecto.Changeset.t()
   def changeset(%__MODULE__{} = action_log, attrs) do
     action_log
     |> cast(attrs, @attrs)
diff --git a/lib/mobilizon/admin/admin.ex b/lib/mobilizon/admin/admin.ex
index 21cb7cf1a..a1e68c617 100644
--- a/lib/mobilizon/admin/admin.ex
+++ b/lib/mobilizon/admin/admin.ex
@@ -45,7 +45,8 @@ defmodule Mobilizon.Admin do
   @doc """
   Log an admin action
   """
-  @spec log_action(Actor.t(), String.t(), String.t()) :: {:ok, ActionLog.t()}
+  @spec log_action(Actor.t(), String.t(), struct()) ::
+          {:ok, ActionLog.t()} | {:error, Ecto.Changeset.t() | :user_not_moderator}
   def log_action(%Actor{user_id: user_id, id: actor_id}, action, target) do
     with %User{role: role} <- Users.get_user!(user_id),
          {:role, true} <- {:role, role in [:administrator, :moderator]},
@@ -58,6 +59,9 @@ defmodule Mobilizon.Admin do
              "changes" => stringify_struct(target)
            }) do
       {:ok, create_action_log}
+    else
+      {:role, false} ->
+        {:error, :user_not_moderator}
     end
   end
 
@@ -109,12 +113,7 @@ defmodule Mobilizon.Admin do
     end
   end
 
-  def set_admin_setting_value(group, name, value) do
-    Setting
-    |> Setting.changeset(%{group: group, name: name, value: value})
-    |> Repo.insert(on_conflict: :replace_all, conflict_target: [:group, :name])
-  end
-
+  @spec save_settings(String.t(), map()) :: {:ok, any} | {:error, any}
   def save_settings(group, args) do
     Multi.new()
     |> do_save_setting(group, args)
@@ -125,6 +124,7 @@ defmodule Mobilizon.Admin do
     Setting |> where([s], s.group == ^group) |> Repo.delete_all()
   end
 
+  @spec do_save_setting(Ecto.Multi.t(), String.t(), map()) :: Ecto.Multi.t()
   defp do_save_setting(transaction, _group, args) when args == %{}, do: transaction
 
   defp do_save_setting(transaction, group, args) do
@@ -147,6 +147,7 @@ defmodule Mobilizon.Admin do
     do_save_setting(transaction, group, rest)
   end
 
+  @spec convert_to_string(any()) :: String.t()
   defp convert_to_string(val) do
     case val do
       val when is_list(val) -> Jason.encode!(val)
diff --git a/lib/mobilizon/admin/setting.ex b/lib/mobilizon/admin/setting.ex
index 894a4ad92..a505358ec 100644
--- a/lib/mobilizon/admin/setting.ex
+++ b/lib/mobilizon/admin/setting.ex
@@ -9,6 +9,12 @@ defmodule Mobilizon.Admin.Setting do
   @optional_attrs [:value]
   @attrs @required_attrs ++ @optional_attrs
 
+  @type t :: %{
+          group: String.t(),
+          name: String.t(),
+          value: String.t()
+        }
+
   schema "admin_settings" do
     field(:group, :string)
     field(:name, :string)
@@ -18,6 +24,7 @@ defmodule Mobilizon.Admin.Setting do
   end
 
   @doc false
+  @spec changeset(t | Ecto.Schema.t(), map) :: Ecto.Changeset.t()
   def changeset(setting, attrs) do
     setting
     |> cast(attrs, @attrs)
diff --git a/lib/mobilizon/cli.ex b/lib/mobilizon/cli.ex
index 91d105d3d..56016063c 100644
--- a/lib/mobilizon/cli.ex
+++ b/lib/mobilizon/cli.ex
@@ -9,6 +9,7 @@ defmodule Mobilizon.CLI do
   """
   alias Mix.Tasks.Mobilizon.Ecto.{Migrate, Rollback}
 
+  @spec run(String.t()) :: any()
   def run(args) do
     [task | args] = String.split(args)
 
@@ -43,11 +44,13 @@ defmodule Mobilizon.CLI do
     end
   end
 
-  def migrate(args) do
+  @spec migrate(String.t()) :: any()
+  defp migrate(args) do
     Migrate.run(args)
   end
 
-  def rollback(args) do
+  @spec rollback(String.t()) :: any()
+  defp rollback(args) do
     Rollback.run(args)
   end
 end
diff --git a/lib/mobilizon/config.ex b/lib/mobilizon/config.ex
index 4b7496902..0f51d151c 100644
--- a/lib/mobilizon/config.ex
+++ b/lib/mobilizon/config.ex
@@ -4,10 +4,27 @@ defmodule Mobilizon.Config do
   """
 
   alias Mobilizon.Actors
-  alias Mobilizon.Actors.Actor
   alias Mobilizon.Service.GitStatus
+  require Logger
 
-  @spec instance_config :: keyword
+  @type mobilizon_config :: [
+          name: String.t(),
+          description: String.t(),
+          hostname: String.t(),
+          registrations_open: boolean(),
+          languages: list(String.t()),
+          default_language: String.t(),
+          registration_email_allowlist: list(String.t()),
+          registration_email_denylist: list(String.t()),
+          demo: boolean(),
+          repository: String.t(),
+          email_from: String.t(),
+          email_reply_to: String.t(),
+          federating: boolean(),
+          remove_orphan_uploads: boolean()
+        ]
+
+  @spec instance_config :: mobilizon_config
   def instance_config, do: Application.get_env(:mobilizon, :instance)
 
   @spec instance_name :: String.t()
@@ -36,10 +53,10 @@ defmodule Mobilizon.Config do
         "instance_long_description"
       )
 
-  @spec instance_slogan :: String.t()
+  @spec instance_slogan :: String.t() | nil
   def instance_slogan, do: Mobilizon.Admin.get_admin_setting_value("instance", "instance_slogan")
 
-  @spec contact :: String.t()
+  @spec contact :: String.t() | nil
   def contact do
     Mobilizon.Admin.get_admin_setting_value("instance", "contact")
   end
@@ -54,7 +71,7 @@ defmodule Mobilizon.Config do
     Mobilizon.Admin.get_admin_setting_value("instance", "instance_terms_type", "DEFAULT")
   end
 
-  @spec instance_terms_url :: String.t()
+  @spec instance_terms_url :: String.t() | nil
   def instance_terms_url do
     Mobilizon.Admin.get_admin_setting_value("instance", "instance_terms_url")
   end
@@ -139,10 +156,10 @@ defmodule Mobilizon.Config do
   def instance_user_agent,
     do: "#{instance_hostname()} - Mobilizon #{instance_version()}"
 
-  @spec instance_federating :: String.t()
+  @spec instance_federating :: boolean()
   def instance_federating, do: instance_config()[:federating]
 
-  @spec instance_geocoding_provider :: atom()
+  @spec instance_geocoding_provider :: module()
   def instance_geocoding_provider,
     do: get_in(Application.get_env(:mobilizon, Mobilizon.Service.Geospatial), [:service])
 
@@ -150,63 +167,90 @@ defmodule Mobilizon.Config do
   def instance_geocoding_autocomplete,
     do: instance_geocoding_provider() !== Mobilizon.Service.Geospatial.Nominatim
 
+  @spec maps_config :: [
+          tiles: [endpoint: String.t(), attribution: String.t()],
+          rounting: [type: atom]
+        ]
+  defp maps_config, do: Application.get_env(:mobilizon, :maps)
+
   @spec instance_maps_tiles_endpoint :: String.t()
-  def instance_maps_tiles_endpoint, do: Application.get_env(:mobilizon, :maps)[:tiles][:endpoint]
+  def instance_maps_tiles_endpoint, do: maps_config()[:tiles][:endpoint]
 
   @spec instance_maps_tiles_attribution :: String.t()
   def instance_maps_tiles_attribution,
-    do: Application.get_env(:mobilizon, :maps)[:tiles][:attribution]
+    do: maps_config()[:tiles][:attribution]
 
   @spec instance_maps_routing_type :: atom()
   def instance_maps_routing_type,
-    do: Application.get_env(:mobilizon, :maps)[:routing][:type]
+    do: maps_config()[:routing][:type]
+
+  @typep anonymous_config_type :: [
+           participation: [
+             allowed: boolean,
+             validation: [
+               email: [enabled: boolean(), confirmation_required: boolean()],
+               captcha: [enabled: boolean()]
+             ]
+           ],
+           event_creation: [
+             allowed: boolean,
+             validation: [
+               email: [enabled: boolean(), confirmation_required: boolean()],
+               captcha: [enabled: boolean()]
+             ]
+           ],
+           reports: [
+             allowed: boolean()
+           ]
+         ]
+
+  @spec anonymous_config :: anonymous_config_type
+  defp anonymous_config, do: Application.get_env(:mobilizon, :anonymous)
 
   @spec anonymous_participation? :: boolean
   def anonymous_participation?,
-    do: Application.get_env(:mobilizon, :anonymous)[:participation][:allowed]
+    do: anonymous_config()[:participation][:allowed]
 
   @spec anonymous_participation_email_required? :: boolean
   def anonymous_participation_email_required?,
-    do: Application.get_env(:mobilizon, :anonymous)[:participation][:validation][:email][:enabled]
+    do: anonymous_config()[:participation][:validation][:email][:enabled]
 
   @spec anonymous_participation_email_confirmation_required? :: boolean
   def anonymous_participation_email_confirmation_required?,
     do:
-      Application.get_env(:mobilizon, :anonymous)[:participation][:validation][:email][
+      anonymous_config()[:participation][:validation][:email][
         :confirmation_required
       ]
 
   @spec anonymous_participation_email_captcha_required? :: boolean
   def anonymous_participation_email_captcha_required?,
-    do:
-      Application.get_env(:mobilizon, :anonymous)[:participation][:validation][:captcha][:enabled]
+    do: anonymous_config()[:participation][:validation][:captcha][:enabled]
 
   @spec anonymous_event_creation? :: boolean
   def anonymous_event_creation?,
-    do: Application.get_env(:mobilizon, :anonymous)[:event_creation][:allowed]
+    do: anonymous_config()[:event_creation][:allowed]
 
   @spec anonymous_event_creation_email_required? :: boolean
   def anonymous_event_creation_email_required?,
-    do:
-      Application.get_env(:mobilizon, :anonymous)[:event_creation][:validation][:email][:enabled]
+    do: anonymous_config()[:event_creation][:validation][:email][:enabled]
 
   @spec anonymous_event_creation_email_confirmation_required? :: boolean
   def anonymous_event_creation_email_confirmation_required?,
     do:
-      Application.get_env(:mobilizon, :anonymous)[:event_creation][:validation][:email][
+      anonymous_config()[:event_creation][:validation][:email][
         :confirmation_required
       ]
 
   @spec anonymous_event_creation_email_captcha_required? :: boolean
   def anonymous_event_creation_email_captcha_required?,
     do:
-      Application.get_env(:mobilizon, :anonymous)[:event_creation][:validation][:captcha][
+      anonymous_config()[:event_creation][:validation][:captcha][
         :enabled
       ]
 
   @spec anonymous_reporting? :: boolean
   def anonymous_reporting?,
-    do: Application.get_env(:mobilizon, :anonymous)[:reports][:allowed]
+    do: anonymous_config()[:reports][:allowed]
 
   @spec oauth_consumer_strategies() :: list({atom(), String.t()})
   def oauth_consumer_strategies do
@@ -226,6 +270,7 @@ defmodule Mobilizon.Config do
   @spec ldap_enabled? :: boolean()
   def ldap_enabled?, do: get([:ldap, :enabled], false)
 
+  @spec instance_resource_providers :: list(%{type: atom, software: atom, endpoint: String.t()})
   def instance_resource_providers do
     types = get_in(Application.get_env(:mobilizon, Mobilizon.Service.ResourceProviders), [:types])
 
@@ -249,20 +294,25 @@ defmodule Mobilizon.Config do
     end
   end
 
+  @spec instance_group_feature_enabled? :: boolean
   def instance_group_feature_enabled?,
     do: :mobilizon |> Application.get_env(:groups) |> Keyword.get(:enabled)
 
+  @spec instance_event_creation_enabled? :: boolean
   def instance_event_creation_enabled?,
     do: :mobilizon |> Application.get_env(:events) |> Keyword.get(:creation)
 
+  @spec anonymous_actor_id :: integer
   def anonymous_actor_id, do: get_cached_value(:anonymous_actor_id)
+  @spec relay_actor_id :: integer
   def relay_actor_id, do: get_cached_value(:relay_actor_id)
+  @spec admin_settings :: map
   def admin_settings, do: get_cached_value(:admin_config)
 
-  @spec get(module | atom) :: any
+  @spec get(keys :: module | atom | [module | atom]) :: any
   def get(key), do: get(key, nil)
 
-  @spec get([module | atom]) :: any
+  @spec get(keys :: [module | atom], default :: any) :: any
   def get([key], default), do: get(key, default)
 
   def get([parent_key | keys], default) do
@@ -272,10 +322,10 @@ defmodule Mobilizon.Config do
     end
   end
 
-  @spec get(module | atom, any) :: any
+  @spec get(key :: module | atom, default :: any) :: any
   def get(key, default), do: Application.get_env(:mobilizon, key, default)
 
-  @spec get!(module | atom) :: any
+  @spec get!(key :: module | atom) :: any | no_return
   def get!(key) do
     value = get(key, nil)
 
@@ -286,6 +336,7 @@ defmodule Mobilizon.Config do
     end
   end
 
+  @spec put(keys :: [module | atom], value :: any) :: :ok
   def put([key], value), do: put(key, value)
 
   def put([parent_key | keys], value) do
@@ -296,6 +347,7 @@ defmodule Mobilizon.Config do
     Application.put_env(:mobilizon, parent_key, parent)
   end
 
+  @spec put(keys :: module | atom, value :: any) :: :ok
   def put(key, value) do
     Application.put_env(:mobilizon, key, value)
   end
@@ -303,11 +355,16 @@ defmodule Mobilizon.Config do
   @spec to_boolean(boolean | String.t()) :: boolean
   defp to_boolean(boolean), do: "true" == String.downcase("#{boolean}")
 
+  @spec get_cached_value(atom) :: String.t() | integer | map
   defp get_cached_value(key) do
     case Cachex.fetch(:config, key, fn key ->
            case create_cache(key) do
-             value when not is_nil(value) -> {:commit, value}
-             err -> {:ignore, err}
+             {:ok, value} when not is_nil(value) ->
+               {:commit, value}
+
+             {:error, err} ->
+               Logger.debug("Failed to cache config value, returned: #{inspect(err)}")
+               {:ignore, err}
            end
          end) do
       {status, value} when status in [:ok, :commit] -> value
@@ -315,23 +372,29 @@ defmodule Mobilizon.Config do
     end
   end
 
-  @spec create_cache(atom()) :: integer()
+  @spec create_cache(atom()) :: {:ok, integer() | map()} | {:error, Ecto.Changeset.t()}
   defp create_cache(:anonymous_actor_id) do
-    with {:ok, %Actor{id: actor_id}} <- Actors.get_or_create_internal_actor("anonymous") do
-      actor_id
+    case Actors.get_or_create_internal_actor("anonymous") do
+      {:ok, %{id: actor_id}} ->
+        {:ok, actor_id}
+
+      {:error, err} ->
+        {:error, err}
     end
   end
 
-  @spec create_cache(atom()) :: integer()
   defp create_cache(:relay_actor_id) do
-    with {:ok, %Actor{id: actor_id}} <- Actors.get_or_create_internal_actor("relay") do
-      actor_id
+    case Actors.get_or_create_internal_actor("relay") do
+      {:ok, %{id: actor_id}} ->
+        {:ok, actor_id}
+
+      {:error, err} ->
+        {:error, err}
     end
   end
 
-  @spec create_cache(atom()) :: map()
   defp create_cache(:admin_config) do
-    %{
+    data = %{
       instance_description: instance_description(),
       instance_long_description: instance_long_description(),
       instance_name: instance_name(),
@@ -347,12 +410,16 @@ defmodule Mobilizon.Config do
       instance_rules: instance_rules(),
       instance_languages: instance_languages()
     }
+
+    {:ok, data}
   end
 
+  @spec clear_config_cache :: {:ok | :error, integer}
   def clear_config_cache do
     Cachex.clear(:config)
   end
 
+  @spec generate_terms(String.t()) :: String.t()
   def generate_terms(locale) do
     Gettext.put_locale(locale)
 
@@ -367,6 +434,7 @@ defmodule Mobilizon.Config do
     )
   end
 
+  @spec generate_privacy(String.t()) :: String.t()
   def generate_privacy(locale) do
     Gettext.put_locale(locale)
 
@@ -377,6 +445,7 @@ defmodule Mobilizon.Config do
     )
   end
 
+  @spec instance_contact_html :: String.t()
   defp instance_contact_html do
     contact = contact()
 
diff --git a/lib/mobilizon/discussions/comment.ex b/lib/mobilizon/discussions/comment.ex
index 3141e4aea..6ae10d27e 100644
--- a/lib/mobilizon/discussions/comment.ex
+++ b/lib/mobilizon/discussions/comment.ex
@@ -20,6 +20,7 @@ defmodule Mobilizon.Discussions.Comment do
   @type t :: %__MODULE__{
           text: String.t(),
           url: String.t(),
+          id: integer(),
           local: boolean,
           visibility: CommentVisibility.t(),
           uuid: Ecto.UUID.t(),
@@ -87,7 +88,7 @@ defmodule Mobilizon.Discussions.Comment do
   end
 
   @doc false
-  @spec changeset(t, map) :: Ecto.Changeset.t()
+  @spec changeset(t | Ecto.Schema.t(), map) :: Ecto.Changeset.t()
   def changeset(%__MODULE__{} = comment, attrs) do
     comment
     |> common_changeset(attrs)
diff --git a/lib/mobilizon/discussions/discussion.ex b/lib/mobilizon/discussions/discussion.ex
index 99ac93795..5d5f513e8 100644
--- a/lib/mobilizon/discussions/discussion.ex
+++ b/lib/mobilizon/discussions/discussion.ex
@@ -4,6 +4,7 @@ defmodule Mobilizon.Discussions.Discussion.TitleSlug do
   """
   use EctoAutoslugField.Slug, from: [:title, :id], to: :slug
 
+  @spec build_slug([String.t()], Ecto.Changeset.t()) :: String.t()
   def build_slug([title, id], %Ecto.Changeset{valid?: true}) do
     [title, ShortUUID.encode!(id)]
     |> Enum.join("-")
@@ -31,6 +32,7 @@ defmodule Mobilizon.Discussions.Discussion do
   import Mobilizon.Web.Gettext, only: [dgettext: 2]
 
   @type t :: %__MODULE__{
+          id: String.t(),
           creator: Actor.t(),
           actor: Actor.t(),
           title: String.t(),
@@ -59,7 +61,7 @@ defmodule Mobilizon.Discussions.Discussion do
   end
 
   @doc false
-  @spec changeset(t, map) :: Ecto.Changeset.t()
+  @spec changeset(t | Ecto.Schema.t(), map) :: Ecto.Changeset.t()
   def changeset(%__MODULE__{} = discussion, attrs) do
     discussion
     |> cast(attrs, @attrs)
diff --git a/lib/mobilizon/discussions/discussions.ex b/lib/mobilizon/discussions/discussions.ex
index 5c10d0e92..cc4d15814 100644
--- a/lib/mobilizon/discussions/discussions.ex
+++ b/lib/mobilizon/discussions/discussions.ex
@@ -71,7 +71,7 @@ defmodule Mobilizon.Discussions do
   We only get first comment of thread, and count replies.
   Read: https://hexdocs.pm/absinthe/ecto.html#dataloader
   """
-  @spec query(atom(), map()) :: Ecto.Queryable.t()
+  @spec query(atom(), map()) :: Ecto.Query.t()
   def query(Comment, %{top_level: true}) do
     Comment
     |> join(:left, [c], r in Comment, on: r.origin_comment_id == c.id)
@@ -158,7 +158,7 @@ defmodule Mobilizon.Discussions do
   Gets a comment by its URL, with all associations loaded.
   Raises `Ecto.NoResultsError` if the comment does not exist.
   """
-  @spec get_comment_from_url_with_preload(String.t()) :: Comment.t()
+  @spec get_comment_from_url_with_preload!(String.t()) :: Comment.t()
   def get_comment_from_url_with_preload!(url) do
     Comment
     |> Repo.get_by!(url: url)
@@ -168,7 +168,7 @@ defmodule Mobilizon.Discussions do
   @doc """
   Gets a comment by its UUID, with all associations loaded.
   """
-  @spec get_comment_from_uuid_with_preload(String.t()) :: Comment.t()
+  @spec get_comment_from_uuid_with_preload(String.t()) :: Comment.t() | nil
   def get_comment_from_uuid_with_preload(uuid) do
     Comment
     |> Repo.get_by(uuid: uuid)
@@ -249,8 +249,7 @@ defmodule Mobilizon.Discussions do
         {:ok, comment}
       end
     else
-      comment
-      |> Repo.delete()
+      Repo.delete(comment)
     end
   end
 
@@ -356,7 +355,7 @@ defmodule Mobilizon.Discussions do
   @doc """
   Get a discussion by it's slug
   """
-  @spec get_discussion_by_slug(String.t()) :: Discussion.t()
+  @spec get_discussion_by_slug(String.t()) :: Discussion.t() | nil
   def get_discussion_by_slug(discussion_slug) do
     Discussion
     |> Repo.get_by(slug: discussion_slug)
@@ -378,8 +377,8 @@ defmodule Mobilizon.Discussions do
   @doc """
   Creates a discussion.
   """
-  @spec create_discussion(map) :: {:ok, Comment.t()} | {:error, Changeset.t()}
-  def create_discussion(attrs \\ %{}) do
+  @spec create_discussion(map()) :: {:ok, Discussion.t()} | {:error, atom(), Changeset.t(), map()}
+  def create_discussion(attrs) do
     with {:ok, %{comment: %Comment{} = _comment, discussion: %Discussion{} = discussion}} <-
            Multi.new()
            |> Multi.insert(
@@ -413,19 +412,26 @@ defmodule Mobilizon.Discussions do
   @doc """
   Create a response to a discussion
   """
-  @spec reply_to_discussion(Discussion.t(), map()) :: {:ok, Discussion.t()}
+  @spec reply_to_discussion(Discussion.t(), map()) ::
+          {:ok, Discussion.t()} | {:error, atom(), Ecto.Changeset.t(), map()}
   def reply_to_discussion(%Discussion{id: discussion_id} = discussion, attrs \\ %{}) do
+    attrs =
+      Map.merge(attrs, %{
+        discussion_id: discussion_id,
+        actor_id: Map.get(attrs, :creator_id, Map.get(attrs, :actor_id))
+      })
+
+    changeset =
+      Comment.changeset(
+        %Comment{},
+        attrs
+      )
+
     with {:ok, %{comment: %Comment{} = comment, discussion: %Discussion{} = discussion}} <-
            Multi.new()
            |> Multi.insert(
              :comment,
-             Comment.changeset(
-               %Comment{},
-               Map.merge(attrs, %{
-                 discussion_id: discussion_id,
-                 actor_id: Map.get(attrs, :creator_id, attrs.actor_id)
-               })
-             )
+             changeset
            )
            |> Multi.update(:discussion, fn %{comment: %Comment{id: comment_id}} ->
              Discussion.changeset(
@@ -436,7 +442,7 @@ defmodule Mobilizon.Discussions do
            |> Repo.transaction(),
          # Discussion is not updated
          %Comment{} = comment <- Repo.preload(comment, @comment_preloads) do
-      {:ok, Map.put(discussion, :last_comment, comment)}
+      {:ok, %Discussion{discussion | last_comment: comment}}
     end
   end
 
@@ -454,7 +460,8 @@ defmodule Mobilizon.Discussions do
   @doc """
   Delete a discussion.
   """
-  @spec delete_discussion(Discussion.t()) :: {:ok, Discussion.t()} | {:error, Changeset.t()}
+  @spec delete_discussion(Discussion.t()) ::
+          {:ok, %{comments: {integer() | nil, any()}}} | {:error, :comments, Changeset.t(), map()}
   def delete_discussion(%Discussion{id: discussion_id}) do
     Multi.new()
     |> Multi.delete_all(:comments, fn _ ->
@@ -464,7 +471,7 @@ defmodule Mobilizon.Discussions do
     |> Repo.transaction()
   end
 
-  @spec public_comments_for_actor_query(String.t() | integer()) :: [Comment.t()]
+  @spec public_comments_for_actor_query(String.t() | integer()) :: Ecto.Query.t()
   defp public_comments_for_actor_query(actor_id) do
     Comment
     |> where([c], c.actor_id == ^actor_id and c.visibility in ^@public_visibility)
@@ -472,7 +479,7 @@ defmodule Mobilizon.Discussions do
     |> preload_for_comment()
   end
 
-  @spec public_replies_for_thread_query(String.t() | integer()) :: [Comment.t()]
+  @spec public_replies_for_thread_query(String.t() | integer()) :: Ecto.Query.t()
   defp public_replies_for_thread_query(comment_id) do
     Comment
     |> where([c], c.origin_comment_id == ^comment_id and c.visibility in ^@public_visibility)
@@ -495,11 +502,11 @@ defmodule Mobilizon.Discussions do
     )
   end
 
-  @spec filter_comments_under_events(Ecto.Query.t()) :: Ecto.Query.t()
+  @spec filter_comments_under_events(Ecto.Queryable.t()) :: Ecto.Query.t()
   defp filter_comments_under_events(query) do
     where(query, [c], is_nil(c.discussion_id) and not is_nil(c.event_id))
   end
 
-  @spec preload_for_comment(Ecto.Query.t()) :: Ecto.Query.t()
+  @spec preload_for_comment(Ecto.Queryable.t()) :: Ecto.Query.t()
   defp preload_for_comment(query), do: preload(query, ^@comment_preloads)
 end
diff --git a/lib/mobilizon/events/event.ex b/lib/mobilizon/events/event.ex
index b4a46d7b1..6c726cb72 100644
--- a/lib/mobilizon/events/event.ex
+++ b/lib/mobilizon/events/event.ex
@@ -35,6 +35,7 @@ defmodule Mobilizon.Events.Event do
   alias Mobilizon.Web.Router.Helpers, as: Routes
 
   @type t :: %__MODULE__{
+          id: integer(),
           url: String.t(),
           local: boolean,
           begins_on: DateTime.t(),
@@ -46,16 +47,16 @@ defmodule Mobilizon.Events.Event do
           draft: boolean,
           visibility: EventVisibility.t(),
           join_options: JoinOptions.t(),
-          publish_at: DateTime.t(),
+          publish_at: DateTime.t() | nil,
           uuid: Ecto.UUID.t(),
-          online_address: String.t(),
+          online_address: String.t() | nil,
           phone_address: String.t(),
           category: String.t(),
           options: EventOptions.t(),
           organizer_actor: Actor.t(),
-          attributed_to: Actor.t(),
-          physical_address: Address.t(),
-          picture: Media.t(),
+          attributed_to: Actor.t() | nil,
+          physical_address: Address.t() | nil,
+          picture: Media.t() | nil,
           media: [Media.t()],
           tracks: [Track.t()],
           sessions: [Session.t()],
@@ -130,7 +131,7 @@ defmodule Mobilizon.Events.Event do
   end
 
   @doc false
-  @spec changeset(t, map) :: Changeset.t()
+  @spec changeset(t | Ecto.Schema.t(), map) :: Changeset.t()
   def changeset(%__MODULE__{} = event, attrs) do
     attrs = Map.update(attrs, :uuid, Ecto.UUID.generate(), & &1)
     attrs = Map.update(attrs, :url, Routes.page_url(Endpoint, :event, attrs.uuid), & &1)
@@ -206,6 +207,7 @@ defmodule Mobilizon.Events.Event do
 
   defp put_tags(%Changeset{} = changeset, _), do: changeset
 
+  @spec process_tag(map() | Tag.t()) :: Tag.t() | Ecto.Changeset.t()
   # We need a changeset instead of a raw struct because of slug which is generated in changeset
   defp process_tag(%{id: id} = _tag) do
     Events.get_tag(id)
@@ -248,13 +250,8 @@ defmodule Mobilizon.Events.Event do
   # In case the provided picture is an existing one
   @spec put_picture(Changeset.t(), map) :: Changeset.t()
   defp put_picture(%Changeset{} = changeset, %{picture: %{media_id: id} = _picture}) do
-    case Medias.get_media!(id) do
-      %Media{} = picture ->
-        put_assoc(changeset, :picture, picture)
-
-      _ ->
-        changeset
-    end
+    %Media{} = picture = Medias.get_media!(id)
+    put_assoc(changeset, :picture, picture)
   end
 
   # In case it's a new picture
@@ -293,4 +290,12 @@ defmodule Mobilizon.Events.Event do
 
   defp put_creator_if_published(%Changeset{} = changeset, _),
     do: cast_embed(changeset, :participant_stats)
+
+  @doc """
+  Whether we can show the event. Returns false if the organizer actor or group is suspended
+  """
+  @spec show?(t) :: boolean()
+  def show?(%__MODULE__{attributed_to: %Actor{suspended: true}}), do: false
+  def show?(%__MODULE__{organizer_actor: %Actor{suspended: true}}), do: false
+  def show?(%__MODULE__{}), do: true
 end
diff --git a/lib/mobilizon/events/event_metadata.ex b/lib/mobilizon/events/event_metadata.ex
index 6ef9add33..3e9115fe7 100644
--- a/lib/mobilizon/events/event_metadata.ex
+++ b/lib/mobilizon/events/event_metadata.ex
@@ -36,7 +36,7 @@ defmodule Mobilizon.Events.EventMetadata do
   end
 
   @doc false
-  @spec changeset(t, map) :: Ecto.Changeset.t()
+  @spec changeset(t | Ecto.Schema.t(), map) :: Ecto.Changeset.t()
   def changeset(%__MODULE__{} = event_metadata, attrs) do
     event_metadata
     |> cast(attrs, @attrs)
diff --git a/lib/mobilizon/events/event_options.ex b/lib/mobilizon/events/event_options.ex
index 6f1f5832c..303369755 100644
--- a/lib/mobilizon/events/event_options.ex
+++ b/lib/mobilizon/events/event_options.ex
@@ -64,7 +64,7 @@ defmodule Mobilizon.Events.EventOptions do
   end
 
   @doc false
-  @spec changeset(t, map) :: Ecto.Changeset.t()
+  @spec changeset(t | Ecto.Schema.t(), map) :: Ecto.Changeset.t()
   def changeset(%__MODULE__{} = event_options, attrs) do
     event_options
     |> cast(attrs, @attrs)
diff --git a/lib/mobilizon/events/event_participant_stats.ex b/lib/mobilizon/events/event_participant_stats.ex
index 5ba4c11f5..ea59494ec 100644
--- a/lib/mobilizon/events/event_participant_stats.ex
+++ b/lib/mobilizon/events/event_participant_stats.ex
@@ -40,7 +40,7 @@ defmodule Mobilizon.Events.EventParticipantStats do
   end
 
   @doc false
-  @spec changeset(t, map) :: Ecto.Changeset.t()
+  @spec changeset(t | Ecto.Schema.t(), map) :: Ecto.Changeset.t()
   def changeset(%__MODULE__{} = event_options, attrs) do
     event_options
     |> cast(attrs, @attrs)
diff --git a/lib/mobilizon/events/events.ex b/lib/mobilizon/events/events.ex
index af3bb0f25..f543d12ba 100644
--- a/lib/mobilizon/events/events.ex
+++ b/lib/mobilizon/events/events.ex
@@ -263,7 +263,10 @@ defmodule Mobilizon.Events do
   @doc """
   Creates an event.
   """
-  @spec create_event(map) :: {:ok, Event.t()} | {:error, Changeset.t()}
+  @spec create_event(map) ::
+          {:ok, Event.t()}
+          | {:error, Changeset.t()}
+          | {:error, :update | :write, Changeset.t(), map()}
   def create_event(attrs \\ %{}) do
     with {:ok, %{insert: %Event{} = event}} <- do_create_event(attrs),
          %Event{} = event <- Repo.preload(event, @event_preloads) do
@@ -278,7 +281,10 @@ defmodule Mobilizon.Events do
   end
 
   # We start by inserting the event and then insert a first participant if the event is not a draft
-  @spec do_create_event(map) :: {:ok, Event.t()} | {:error, Changeset.t()}
+  @spec do_create_event(map) ::
+          {:ok, %{insert: Event.t(), write: Participant.t() | nil}}
+          | {:error, Changeset.t()}
+          | {:error, :update | :write, Changeset.t(), map()}
   defp do_create_event(attrs) do
     Multi.new()
     |> Multi.insert(:insert, Event.changeset(%Event{}, attrs))
@@ -307,7 +313,10 @@ defmodule Mobilizon.Events do
 
   We start by updating the event and then insert a first participant if the event is not a draft anymore
   """
-  @spec update_event(Event.t(), map) :: {:ok, Event.t()} | {:error, Changeset.t()}
+  @spec update_event(Event.t(), map) ::
+          {:ok, Event.t()}
+          | {:error, Changeset.t()}
+          | {:error, :update | :write, Changeset.t(), map()}
   def update_event(%Event{draft: old_draft} = old_event, attrs) do
     with %Event{} = old_event <- Repo.preload(old_event, @event_preloads),
          %Changeset{changes: changes} = changeset <-
@@ -359,7 +368,7 @@ defmodule Mobilizon.Events do
   Deletes an event.
   Raises an exception if it fails.
   """
-  @spec delete_event(Event.t()) :: Event.t()
+  @spec delete_event!(Event.t()) :: Event.t()
   def delete_event!(%Event{} = event), do: Repo.delete!(event)
 
   @doc """
@@ -394,7 +403,7 @@ defmodule Mobilizon.Events do
     |> Repo.stream()
   end
 
-  @spec list_public_local_events(integer | nil, integer | nil) :: Page.t()
+  @spec list_public_local_events(integer | nil, integer | nil) :: Page.t(Event.t())
   def list_public_local_events(page \\ nil, limit \\ nil) do
     Event
     |> filter_public_visibility()
@@ -448,11 +457,12 @@ defmodule Mobilizon.Events do
 
   @spec list_organized_events_for_group(
           Actor.t(),
+          EventVisibility.t(),
           DateTime.t() | nil,
           DateTime.t() | nil,
           integer | nil,
           integer | nil
-        ) :: Page.t()
+        ) :: Page.t(Event.t())
   def list_organized_events_for_group(
         %Actor{id: group_id},
         visibility \\ :public,
@@ -631,9 +641,10 @@ defmodule Mobilizon.Events do
   @doc """
   Returns the list of tags.
   """
-  @spec list_tags(integer | nil, integer | nil) :: [Tag.t()]
-  def list_tags(page \\ nil, limit \\ nil) do
+  @spec list_tags(String.t() | nil, integer | nil, integer | nil) :: [Tag.t()]
+  def list_tags(filter \\ nil, page \\ nil, limit \\ nil) do
     Tag
+    |> tag_filter(filter)
     |> Page.paginate(page, limit)
     |> Repo.all()
   end
@@ -728,7 +739,9 @@ defmodule Mobilizon.Events do
       nil
 
   """
-  @spec get_participant(integer) :: Participant.t()
+  @spec get_participant(integer) :: Participant.t() | nil
+  @spec get_participant(integer | String.t(), integer | String.t(), map()) ::
+          {:ok, Participant.t()} | {:error, :participant_not_found}
   def get_participant(participant_id) do
     Participant
     |> where([p], p.id == ^participant_id)
@@ -739,8 +752,6 @@ defmodule Mobilizon.Events do
   @doc """
   Gets a single participation for an event and actor.
   """
-  @spec get_participant(integer | String.t(), integer | String.t(), map()) ::
-          {:ok, Participant.t()} | {:error, :participant_not_found}
   def get_participant(event_id, actor_id, params \\ %{})
 
   # This one if to check someone doesn't go to the same event twice
@@ -1039,21 +1050,18 @@ defmodule Mobilizon.Events do
   Deletes a participant.
   """
   @spec delete_participant(Participant.t()) ::
-          {:ok, Participant.t()} | {:error, Changeset.t()}
+          {:ok, %{participant: Participant.t()}}
+          | {:error, :participant | :update_event_participation_stats, Changeset.t(), map()}
   def delete_participant(%Participant{role: old_role} = participant) do
-    with {:ok, %{participant: %Participant{} = participant}} <-
-           Multi.new()
-           |> Multi.delete(:participant, participant)
-           |> Multi.run(:update_event_participation_stats, fn _repo,
-                                                              %{
-                                                                participant:
-                                                                  %Participant{} = participant
-                                                              } ->
-             update_participant_stats(participant, old_role, nil)
-           end)
-           |> Repo.transaction() do
-      {:ok, participant}
-    end
+    Multi.new()
+    |> Multi.delete(:participant, participant)
+    |> Multi.run(:update_event_participation_stats, fn _repo,
+                                                       %{
+                                                         participant: %Participant{} = participant
+                                                       } ->
+      update_participant_stats(participant, old_role, nil)
+    end)
+    |> Repo.transaction()
   end
 
   defp update_participant_stats(
@@ -1329,7 +1337,7 @@ defmodule Mobilizon.Events do
     )
   end
 
-  @spec user_events_query(Ecto.Query.t(), number()) :: Ecto.Query.t()
+  @spec user_events_query(Ecto.Queryable.t(), number()) :: Ecto.Query.t()
   defp user_events_query(query, user_id) do
     from(
       e in query,
@@ -1372,7 +1380,7 @@ defmodule Mobilizon.Events do
     )
   end
 
-  @spec events_for_begins_on(Ecto.Query.t(), map()) :: Ecto.Query.t()
+  @spec events_for_begins_on(Ecto.Queryable.t(), map()) :: Ecto.Query.t()
   defp events_for_begins_on(query, args) do
     begins_on = Map.get(args, :begins_on, DateTime.utc_now())
 
@@ -1380,7 +1388,7 @@ defmodule Mobilizon.Events do
     |> where([q], q.begins_on >= ^begins_on)
   end
 
-  @spec events_for_ends_on(Ecto.Query.t(), map()) :: Ecto.Query.t()
+  @spec events_for_ends_on(Ecto.Queryable.t(), map()) :: Ecto.Query.t()
   defp events_for_ends_on(query, args) do
     ends_on = Map.get(args, :ends_on)
 
@@ -1395,8 +1403,8 @@ defmodule Mobilizon.Events do
         )
   end
 
-  @spec events_for_tags(Ecto.Query.t(), map()) :: Ecto.Query.t()
-  defp events_for_tags(query, %{tags: tags}) when is_valid_string?(tags) do
+  @spec events_for_tags(Ecto.Queryable.t(), map()) :: Ecto.Query.t()
+  defp events_for_tags(query, %{tags: tags}) when is_valid_string(tags) do
     query
     |> join(:inner, [q], te in "events_tags", on: q.id == te.event_id)
     |> join(:inner, [q, ..., te], t in Tag, on: te.tag_id == t.id)
@@ -1405,12 +1413,12 @@ defmodule Mobilizon.Events do
 
   defp events_for_tags(query, _args), do: query
 
-  @spec events_for_location(Ecto.Query.t(), map()) :: Ecto.Query.t()
+  @spec events_for_location(Ecto.Queryable.t(), map()) :: Ecto.Query.t()
   defp events_for_location(query, %{radius: radius}) when is_nil(radius),
     do: query
 
   defp events_for_location(query, %{location: location, radius: radius})
-       when is_valid_string?(location) and not is_nil(radius) do
+       when is_valid_string(location) and not is_nil(radius) do
     with {lon, lat} <- Geohax.decode(location),
          point <- Geo.WKT.decode!("SRID=4326;POINT(#{lon} #{lat})") do
       query
@@ -1471,6 +1479,16 @@ defmodule Mobilizon.Events do
     from(t in Tag, where: t.title == ^title, limit: 1)
   end
 
+  @spec tag_filter(Ecto.Queryable.t(), String.t() | nil) :: Ecto.Query.t()
+  defp tag_filter(query, nil), do: query
+  defp tag_filter(query, ""), do: query
+
+  defp tag_filter(query, filter) when is_binary(filter) do
+    query
+    |> where([q], ilike(q.slug, ^"%#{filter}%"))
+    |> or_where([q], ilike(q.title, ^"%#{filter}%"))
+  end
+
   @spec tags_for_event_query(integer) :: Ecto.Query.t()
   defp tags_for_event_query(event_id) do
     from(
@@ -1500,7 +1518,7 @@ defmodule Mobilizon.Events do
     )
   end
 
-  @spec tag_relation_union_subquery(Ecto.Query.t(), integer) :: Ecto.Query.t()
+  @spec tag_relation_union_subquery(Ecto.Queryable.t(), integer) :: Ecto.Query.t()
   defp tag_relation_union_subquery(subquery, tag_id) do
     from(
       tr in TagRelation,
@@ -1510,7 +1528,7 @@ defmodule Mobilizon.Events do
     )
   end
 
-  @spec tag_neighbors_query(Ecto.Query.t(), integer, integer) :: Ecto.Query.t()
+  @spec tag_neighbors_query(Ecto.Queryable.t(), integer, integer) :: Ecto.Query.t()
   defp tag_neighbors_query(subquery, relation_minimum, limit) do
     from(
       t in Tag,
@@ -1662,38 +1680,34 @@ defmodule Mobilizon.Events do
     from(tk in FeedToken, where: tk.actor_id == ^actor_id, preload: [:actor, :user])
   end
 
-  @spec filter_public_visibility(Ecto.Query.t()) :: Ecto.Query.t()
+  @spec filter_public_visibility(Ecto.Queryable.t()) :: Ecto.Query.t()
   defp filter_public_visibility(query) do
     from(e in query, where: e.visibility == ^:public)
   end
 
-  @spec filter_unlisted_and_public_visibility(Ecto.Query.t()) :: Ecto.Query.t()
+  @spec filter_unlisted_and_public_visibility(Ecto.Queryable.t()) :: Ecto.Query.t()
   defp filter_unlisted_and_public_visibility(query) do
     from(q in query, where: q.visibility in ^@public_visibility)
   end
 
-  @spec filter_not_event_uuid(Ecto.Query.t(), String.t() | nil) :: Ecto.Query.t()
+  @spec filter_not_event_uuid(Ecto.Queryable.t(), String.t() | nil) :: Ecto.Query.t()
   defp filter_not_event_uuid(query, nil), do: query
 
   defp filter_not_event_uuid(query, not_event_uuid) do
     from(e in query, where: e.uuid != ^not_event_uuid)
   end
 
-  @spec filter_draft(Ecto.Query.t(), boolean) :: Ecto.Query.t()
+  @spec filter_draft(Ecto.Queryable.t(), boolean) :: Ecto.Query.t()
   defp filter_draft(query, is_draft \\ false) do
     from(e in query, where: e.draft == ^is_draft)
   end
 
-  @spec filter_cancelled_events(Ecto.Query.t(), boolean()) :: Ecto.Query.t()
-  defp filter_cancelled_events(query, hide_cancelled \\ true)
-
-  defp filter_cancelled_events(query, false), do: query
-
-  defp filter_cancelled_events(query, true) do
+  @spec filter_cancelled_events(Ecto.Queryable.t()) :: Ecto.Query.t()
+  defp filter_cancelled_events(query) do
     from(e in query, where: e.status != ^:cancelled)
   end
 
-  @spec filter_future_events(Ecto.Query.t(), boolean) :: Ecto.Query.t()
+  @spec filter_future_events(Ecto.Queryable.t(), boolean) :: Ecto.Query.t()
   defp filter_future_events(query, true) do
     from(q in query,
       where: q.begins_on > ^DateTime.utc_now()
@@ -1702,12 +1716,12 @@ defmodule Mobilizon.Events do
 
   defp filter_future_events(query, false), do: query
 
-  @spec filter_local(Ecto.Query.t()) :: Ecto.Query.t()
+  @spec filter_local(Ecto.Queryable.t()) :: Ecto.Query.t()
   defp filter_local(query) do
     where(query, [q], q.local == true)
   end
 
-  @spec filter_local_or_from_followed_instances_events(Ecto.Query.t()) ::
+  @spec filter_local_or_from_followed_instances_events(Ecto.Queryable.t()) ::
           Ecto.Query.t()
   defp filter_local_or_from_followed_instances_events(query) do
     follower_actor_id = Mobilizon.Config.relay_actor_id()
@@ -1721,22 +1735,22 @@ defmodule Mobilizon.Events do
     )
   end
 
-  @spec filter_approved_role(Ecto.Query.t()) :: Ecto.Query.t()
+  @spec filter_approved_role(Ecto.Queryable.t()) :: Ecto.Query.t()
   defp filter_approved_role(query) do
     filter_role(query, [:not_approved, :rejected])
   end
 
-  @spec filter_participant_role(Ecto.Query.t()) :: Ecto.Query.t()
+  @spec filter_participant_role(Ecto.Queryable.t()) :: Ecto.Query.t()
   defp filter_participant_role(query) do
     filter_role(query, :participant)
   end
 
-  @spec filter_rejected_role(Ecto.Query.t()) :: Ecto.Query.t()
+  @spec filter_rejected_role(Ecto.Queryable.t()) :: Ecto.Query.t()
   defp filter_rejected_role(query) do
     filter_role(query, :rejected)
   end
 
-  @spec filter_role(Ecto.Query.t(), list(atom())) :: Ecto.Query.t()
+  @spec filter_role(Ecto.Queryable.t(), list(atom()) | atom()) :: Ecto.Query.t()
   def filter_role(query, []), do: query
 
   def filter_role(query, roles) when is_list(roles) do
@@ -1818,6 +1832,6 @@ defmodule Mobilizon.Events do
   defp participation_order_begins_on_desc(query),
     do: order_by(query, [_p, e, _a], desc: e.begins_on)
 
-  @spec preload_for_event(Ecto.Query.t()) :: Ecto.Query.t()
+  @spec preload_for_event(Ecto.Queryable.t()) :: Ecto.Query.t()
   defp preload_for_event(query), do: preload(query, ^@event_preloads)
 end
diff --git a/lib/mobilizon/events/feed_token.ex b/lib/mobilizon/events/feed_token.ex
index d2f255db6..68b1e29db 100644
--- a/lib/mobilizon/events/feed_token.ex
+++ b/lib/mobilizon/events/feed_token.ex
@@ -12,7 +12,7 @@ defmodule Mobilizon.Events.FeedToken do
 
   @type t :: %__MODULE__{
           token: Ecto.UUID.t(),
-          actor: Actor.t(),
+          actor: Actor.t() | nil,
           user: User.t()
         }
 
@@ -31,7 +31,7 @@ defmodule Mobilizon.Events.FeedToken do
   end
 
   @doc false
-  @spec changeset(t, map) :: Ecto.Changeset.t()
+  @spec changeset(t | Ecto.Schema.t(), map) :: Ecto.Changeset.t()
   def changeset(%__MODULE__{} = feed_token, attrs) do
     feed_token
     |> cast(attrs, @attrs)
diff --git a/lib/mobilizon/events/participant.ex b/lib/mobilizon/events/participant.ex
index 1670e786e..a6eb24f9f 100644
--- a/lib/mobilizon/events/participant.ex
+++ b/lib/mobilizon/events/participant.ex
@@ -10,11 +10,12 @@ defmodule Mobilizon.Events.Participant do
   alias Mobilizon.Actors.Actor
   alias Mobilizon.Events
   alias Mobilizon.Events.{Event, ParticipantRole}
-  alias Mobilizon.Web.Email.Checker
+  alias Mobilizon.Events.Participant.Metadata
 
   alias Mobilizon.Web.Endpoint
 
   @type t :: %__MODULE__{
+          id: String.t(),
           role: ParticipantRole.t(),
           url: String.t(),
           event: Event.t(),
@@ -24,7 +25,6 @@ defmodule Mobilizon.Events.Participant do
 
   @required_attrs [:url, :role, :event_id, :actor_id]
   @attrs @required_attrs
-  @metadata_attrs [:email, :confirmation_token, :cancellation_token, :message, :locale]
 
   @timestamps_opts [type: :utc_datetime]
 
@@ -33,13 +33,7 @@ defmodule Mobilizon.Events.Participant do
     field(:role, ParticipantRole, default: :participant)
     field(:url, :string)
 
-    embeds_one :metadata, Metadata, on_replace: :delete do
-      field(:email, :string)
-      field(:confirmation_token, :string)
-      field(:cancellation_token, :string)
-      field(:message, :string)
-      field(:locale, :string)
-    end
+    embeds_one(:metadata, Metadata, on_replace: :delete)
 
     belongs_to(:event, Event, primary_key: true)
     belongs_to(:actor, Actor, primary_key: true)
@@ -64,22 +58,16 @@ defmodule Mobilizon.Events.Participant do
   end
 
   @doc false
-  @spec changeset(t, map) :: Ecto.Changeset.t()
+  @spec changeset(t | Ecto.Schema.t(), map) :: Ecto.Changeset.t()
   def changeset(%__MODULE__{} = participant, attrs) do
     participant
     |> cast(attrs, @attrs)
-    |> cast_embed(:metadata, with: &metadata_changeset/2)
+    |> cast_embed(:metadata)
     |> ensure_url()
     |> validate_required(@required_attrs)
     |> unique_constraint(:actor_id, name: :participants_event_id_actor_id_index)
   end
 
-  defp metadata_changeset(schema, params) do
-    schema
-    |> cast(params, @metadata_attrs)
-    |> Checker.validate_changeset()
-  end
-
   # If there's a blank URL that's because we're doing the first insert
   @spec ensure_url(Ecto.Changeset.t()) :: Ecto.Changeset.t()
   defp ensure_url(%Ecto.Changeset{data: %__MODULE__{url: nil}} = changeset) do
diff --git a/lib/mobilizon/events/participant_metadata.ex b/lib/mobilizon/events/participant_metadata.ex
new file mode 100644
index 000000000..279575f9b
--- /dev/null
+++ b/lib/mobilizon/events/participant_metadata.ex
@@ -0,0 +1,36 @@
+defmodule Mobilizon.Events.Participant.Metadata do
+  @moduledoc """
+  Participation stats on event
+  """
+
+  use Ecto.Schema
+  import Ecto.Changeset
+  alias Mobilizon.Web.Email.Checker
+
+  @type t :: %__MODULE__{
+          email: String.t(),
+          confirmation_token: String.t(),
+          cancellation_token: String.t(),
+          message: String.t(),
+          locale: String.t()
+        }
+
+  @attrs [:email, :confirmation_token, :cancellation_token, :message, :locale]
+
+  @derive Jason.Encoder
+  embedded_schema do
+    field(:email, :string)
+    field(:confirmation_token, :string)
+    field(:cancellation_token, :string)
+    field(:message, :string)
+    field(:locale, :string)
+  end
+
+  @doc false
+  @spec changeset(t | Ecto.Schema.t(), map) :: Ecto.Changeset.t()
+  def changeset(schema, params) do
+    schema
+    |> cast(params, @attrs)
+    |> Checker.validate_changeset()
+  end
+end
diff --git a/lib/mobilizon/events/session.ex b/lib/mobilizon/events/session.ex
index 3804d8935..efceb755a 100644
--- a/lib/mobilizon/events/session.ex
+++ b/lib/mobilizon/events/session.ex
@@ -56,7 +56,7 @@ defmodule Mobilizon.Events.Session do
   end
 
   @doc false
-  @spec changeset(t, map) :: Ecto.Changeset.t()
+  @spec changeset(t | Ecto.Schema.t(), map) :: Ecto.Changeset.t()
   def changeset(%__MODULE__{} = session, attrs) do
     session
     |> cast(attrs, @attrs)
diff --git a/lib/mobilizon/events/tag.ex b/lib/mobilizon/events/tag.ex
index b4fc428eb..128c2388d 100644
--- a/lib/mobilizon/events/tag.ex
+++ b/lib/mobilizon/events/tag.ex
@@ -29,7 +29,7 @@ defmodule Mobilizon.Events.Tag do
   end
 
   @doc false
-  @spec changeset(t, map) :: Ecto.Changeset.t()
+  @spec changeset(t | Ecto.Schema.t(), map) :: Ecto.Changeset.t()
   def changeset(%__MODULE__{} = tag, attrs) do
     tag
     |> cast(attrs, @attrs)
diff --git a/lib/mobilizon/events/tag_relation.ex b/lib/mobilizon/events/tag_relation.ex
index 2d038358f..91c7b4b0b 100644
--- a/lib/mobilizon/events/tag_relation.ex
+++ b/lib/mobilizon/events/tag_relation.ex
@@ -28,7 +28,7 @@ defmodule Mobilizon.Events.TagRelation do
   end
 
   @doc false
-  @spec changeset(t, map) :: Ecto.Changeset.t()
+  @spec changeset(t | Ecto.Schema.t(), map) :: Ecto.Changeset.t()
   def changeset(%__MODULE__{} = tag, attrs) do
     # Return if tag_id or link_id are not set because it will fail later otherwise
     with %Ecto.Changeset{errors: [], changes: changes} = changeset <-
diff --git a/lib/mobilizon/events/track.ex b/lib/mobilizon/events/track.ex
index dd626a823..d2802e150 100644
--- a/lib/mobilizon/events/track.ex
+++ b/lib/mobilizon/events/track.ex
@@ -33,7 +33,7 @@ defmodule Mobilizon.Events.Track do
   end
 
   @doc false
-  @spec changeset(t, map) :: Ecto.Changeset.t()
+  @spec changeset(t | Ecto.Schema.t(), map) :: Ecto.Changeset.t()
   def changeset(%__MODULE__{} = track, attrs) do
     track
     |> cast(attrs, @attrs)
diff --git a/lib/mobilizon/medias/file.ex b/lib/mobilizon/medias/file.ex
index ada4d15a7..5efa28e16 100644
--- a/lib/mobilizon/medias/file.ex
+++ b/lib/mobilizon/medias/file.ex
@@ -29,7 +29,7 @@ defmodule Mobilizon.Medias.File do
   end
 
   @doc false
-  @spec changeset(t, map) :: Ecto.Changeset.t()
+  @spec changeset(t | Ecto.Schema.t(), map) :: Ecto.Changeset.t()
   def changeset(%__MODULE__{} = file, attrs) do
     file
     |> cast(attrs, @attrs)
diff --git a/lib/mobilizon/medias/media.ex b/lib/mobilizon/medias/media.ex
index 0133b5bfc..224252a52 100644
--- a/lib/mobilizon/medias/media.ex
+++ b/lib/mobilizon/medias/media.ex
@@ -5,7 +5,7 @@ defmodule Mobilizon.Medias.Media do
 
   use Ecto.Schema
 
-  import Ecto.Changeset, only: [cast: 3, cast_embed: 2, cast_embed: 3]
+  import Ecto.Changeset, only: [cast: 3, cast_embed: 2]
 
   alias Mobilizon.Actors.Actor
   alias Mobilizon.Discussions.Comment
@@ -20,16 +20,12 @@ defmodule Mobilizon.Medias.Media do
           actor: Actor.t()
         }
 
-  @metadata_attrs [:height, :width, :blurhash]
+  @attrs [:actor_id]
 
   schema "medias" do
     embeds_one(:file, File, on_replace: :update)
 
-    embeds_one :metadata, Metadata, on_replace: :update do
-      field(:height, :integer)
-      field(:width, :integer)
-      field(:blurhash, :string)
-    end
+    embeds_one(:metadata, Metadata, on_replace: :update)
 
     belongs_to(:actor, Actor)
     has_many(:event_picture, Event, foreign_key: :picture_id)
@@ -42,18 +38,11 @@ defmodule Mobilizon.Medias.Media do
   end
 
   @doc false
-  @spec changeset(t, map) :: Ecto.Changeset.t()
+  @spec changeset(t | Ecto.Schema.t(), map) :: Ecto.Changeset.t()
   def changeset(%__MODULE__{} = media, attrs) do
     media
-    |> cast(attrs, [:actor_id])
+    |> cast(attrs, @attrs)
     |> cast_embed(:file)
-    |> cast_embed(:metadata, with: &metadata_changeset/2)
-  end
-
-  @doc false
-  @spec changeset(struct(), map) :: Ecto.Changeset.t()
-  def metadata_changeset(metadata, attrs) do
-    metadata
-    |> cast(attrs, @metadata_attrs)
+    |> cast_embed(:metadata)
   end
 end
diff --git a/lib/mobilizon/medias/media/metadata.ex b/lib/mobilizon/medias/media/metadata.ex
new file mode 100644
index 000000000..b2d947da9
--- /dev/null
+++ b/lib/mobilizon/medias/media/metadata.ex
@@ -0,0 +1,38 @@
+defmodule Mobilizon.Medias.Media.Metadata do
+  @moduledoc """
+  Represents a media metadata
+  """
+
+  use Ecto.Schema
+  import Ecto.Changeset
+
+  @type t :: %__MODULE__{
+          width: non_neg_integer(),
+          height: non_neg_integer(),
+          blurhash: String.t()
+        }
+
+  @required_attrs []
+
+  @optional_attrs [
+    :width,
+    :height,
+    :blurhash
+  ]
+
+  @attrs @required_attrs ++ @optional_attrs
+
+  @primary_key false
+  embedded_schema do
+    field(:height, :integer)
+    field(:width, :integer)
+    field(:blurhash, :string)
+  end
+
+  @doc false
+  @spec changeset(t | Ecto.Schema.t(), map) :: Ecto.Changeset.t()
+  def changeset(schema, params) do
+    schema
+    |> cast(params, @attrs)
+  end
+end
diff --git a/lib/mobilizon/medias/medias.ex b/lib/mobilizon/medias/medias.ex
index 7b4362621..a706e8b1c 100644
--- a/lib/mobilizon/medias/medias.ex
+++ b/lib/mobilizon/medias/medias.ex
@@ -130,7 +130,7 @@ defmodule Mobilizon.Medias do
       |> Multi.run(:remove, fn _repo, %{media: %Media{file: %File{url: url}} = media} ->
         case Upload.remove(url) do
           {:error, err} ->
-            if err =~ "doesn't exist" and Keyword.get(opts, :ignore_file_not_found, false) do
+            if err == :enofile and Keyword.get(opts, :ignore_file_not_found, false) do
               Logger.info("Deleting media and ignoring absent file.")
               {:ok, media}
             else
diff --git a/lib/mobilizon/mentions/mention.ex b/lib/mobilizon/mentions/mention.ex
index a1473d22e..952d91e4b 100644
--- a/lib/mobilizon/mentions/mention.ex
+++ b/lib/mobilizon/mentions/mention.ex
@@ -31,6 +31,7 @@ defmodule Mobilizon.Mention do
   end
 
   @doc false
+  @spec changeset(t | Ecto.Schema.t(), map) :: Ecto.Changeset.t()
   def changeset(event, attrs) do
     event
     |> cast(attrs, @attrs)
diff --git a/lib/mobilizon/posts/post.ex b/lib/mobilizon/posts/post.ex
index cb40587b5..a19693716 100644
--- a/lib/mobilizon/posts/post.ex
+++ b/lib/mobilizon/posts/post.ex
@@ -4,6 +4,7 @@ defmodule Mobilizon.Posts.Post.TitleSlug do
   """
   use EctoAutoslugField.Slug, from: [:title, :id], to: :slug
 
+  @spec build_slug([String.t()], any()) :: String.t() | nil
   def build_slug([title, id], _changeset) do
     [title, ShortUUID.encode!(id)]
     |> Enum.join("-")
@@ -31,6 +32,7 @@ defmodule Mobilizon.Posts.Post do
   import Mobilizon.Web.Gettext
 
   @type t :: %__MODULE__{
+          id: String.t(),
           url: String.t(),
           local: boolean,
           slug: String.t(),
@@ -82,6 +84,7 @@ defmodule Mobilizon.Posts.Post do
   @attrs @required_attrs ++ @optional_attrs
 
   @doc false
+  @spec changeset(t | Ecto.Schema.t(), map) :: Ecto.Changeset.t()
   def changeset(%__MODULE__{} = post, attrs) do
     post
     |> cast(attrs, @attrs)
@@ -153,17 +156,20 @@ defmodule Mobilizon.Posts.Post do
   # In case the provided picture is an existing one
   @spec put_picture(Changeset.t(), map) :: Changeset.t()
   defp put_picture(%Changeset{} = changeset, %{picture: %{picture_id: id} = _picture}) do
-    case Medias.get_media!(id) do
-      %Media{} = picture ->
-        put_assoc(changeset, :picture, picture)
-
-      _ ->
-        changeset
-    end
+    %Media{} = picture = Medias.get_media!(id)
+    put_assoc(changeset, :picture, picture)
   end
 
   # In case it's a new picture
   defp put_picture(%Changeset{} = changeset, _attrs) do
     cast_assoc(changeset, :picture)
   end
+
+  @doc """
+  Whether we can show the post. Returns false if the organizer actor or group is suspended
+  """
+  @spec show?(t) :: boolean()
+  def show?(%__MODULE__{attributed_to: %Actor{suspended: true}}), do: false
+  def show?(%__MODULE__{author: %Actor{suspended: true}}), do: false
+  def show?(%__MODULE__{}), do: true
 end
diff --git a/lib/mobilizon/posts/posts.ex b/lib/mobilizon/posts/posts.ex
index e967e1ee7..d7bd9294f 100644
--- a/lib/mobilizon/posts/posts.ex
+++ b/lib/mobilizon/posts/posts.ex
@@ -21,6 +21,7 @@ defmodule Mobilizon.Posts do
     :private
   ])
 
+  @spec list_public_local_posts(integer | nil, integer | nil) :: Page.t(Post.t())
   def list_public_local_posts(page \\ nil, limit \\ nil) do
     Post
     |> filter_public()
@@ -144,12 +145,12 @@ defmodule Mobilizon.Posts do
     )
   end
 
-  @spec filter_public(Ecto.Query.t()) :: Ecto.Query.t()
+  @spec filter_public(Ecto.Queryable.t()) :: Ecto.Query.t()
   defp filter_public(query) do
     where(query, [p], p.visibility == ^:public and not p.draft)
   end
 
-  @spec filter_local(Ecto.Query.t()) :: Ecto.Query.t()
+  @spec filter_local(Ecto.Queryable.t()) :: Ecto.Query.t()
   defp filter_local(query) do
     where(query, [q], q.local == true)
   end
@@ -161,7 +162,7 @@ defmodule Mobilizon.Posts do
     |> preload_post_associations()
   end
 
-  @spec preload_post_associations(Ecto.Query.t(), list()) :: Ecto.Query.t()
+  @spec preload_post_associations(Ecto.Queryable.t(), list()) :: Ecto.Query.t()
   defp preload_post_associations(query, associations \\ @post_preloads) do
     preload(query, ^associations)
   end
diff --git a/lib/mobilizon/reports/note.ex b/lib/mobilizon/reports/note.ex
index 560f62469..2ef998612 100644
--- a/lib/mobilizon/reports/note.ex
+++ b/lib/mobilizon/reports/note.ex
@@ -32,7 +32,7 @@ defmodule Mobilizon.Reports.Note do
   end
 
   @doc false
-  @spec changeset(t, map) :: Ecto.Changeset.t()
+  @spec changeset(t | Ecto.Schema.t(), map) :: Ecto.Changeset.t()
   def changeset(%__MODULE__{} = note, attrs) do
     note
     |> cast(attrs, @attrs)
diff --git a/lib/mobilizon/reports/report.ex b/lib/mobilizon/reports/report.ex
index 20e556a6b..4d958cba6 100644
--- a/lib/mobilizon/reports/report.ex
+++ b/lib/mobilizon/reports/report.ex
@@ -15,6 +15,7 @@ defmodule Mobilizon.Reports.Report do
   alias Mobilizon.Web.Endpoint
 
   @type t :: %__MODULE__{
+          id: integer(),
           content: String.t(),
           status: ReportStatus.t(),
           url: String.t(),
@@ -56,7 +57,7 @@ defmodule Mobilizon.Reports.Report do
   end
 
   @doc false
-  @spec changeset(t, map) :: Ecto.Changeset.t()
+  @spec changeset(t | Ecto.Schema.t(), map) :: Ecto.Changeset.t()
   def changeset(%__MODULE__{} = report, attrs) do
     report
     |> cast(attrs, @attrs)
diff --git a/lib/mobilizon/resources/resource.ex b/lib/mobilizon/resources/resource.ex
index cf2b75205..6fdb13e73 100644
--- a/lib/mobilizon/resources/resource.ex
+++ b/lib/mobilizon/resources/resource.ex
@@ -10,14 +10,16 @@ defmodule Mobilizon.Resources.Resource do
   import EctoEnum
   defenum(TypeEnum, folder: 0, link: 1, picture: 20, pad: 30, calc: 40, visio: 50)
   alias Mobilizon.Actors.Actor
+  alias Mobilizon.Resources.Resource.Metadata
 
   @type t :: %__MODULE__{
+          id: String.t(),
           title: String.t(),
           summary: String.t(),
           url: String.t(),
           resource_url: String.t(),
           type: atom(),
-          metadata: Mobilizon.Resources.Resource.Metadata.t(),
+          metadata: Metadata.t(),
           children: list(__MODULE__),
           parent: __MODULE__,
           actor: Actor.t(),
@@ -37,20 +39,7 @@ defmodule Mobilizon.Resources.Resource do
     field(:local, :boolean, default: true)
     field(:published_at, :utc_datetime)
 
-    embeds_one :metadata, Metadata, on_replace: :delete do
-      field(:type, :string)
-      field(:title, :string)
-      field(:description, :string)
-      field(:image_remote_url, :string)
-      field(:width, :integer)
-      field(:height, :integer)
-      field(:author_name, :string)
-      field(:author_url, :string)
-      field(:provider_name, :string)
-      field(:provider_url, :string)
-      field(:html, :string)
-      field(:favicon_url, :string)
-    end
+    embeds_one(:metadata, Metadata, on_replace: :delete)
 
     has_many(:children, __MODULE__, foreign_key: :parent_id)
     belongs_to(:parent, __MODULE__, type: :binary_id)
@@ -63,26 +52,13 @@ defmodule Mobilizon.Resources.Resource do
   @required_attrs [:title, :url, :actor_id, :creator_id, :type, :path, :published_at]
   @optional_attrs [:summary, :parent_id, :resource_url, :local]
   @attrs @required_attrs ++ @optional_attrs
-  @metadata_attrs [
-    :type,
-    :title,
-    :description,
-    :image_remote_url,
-    :width,
-    :height,
-    :author_name,
-    :author_url,
-    :provider_name,
-    :provider_url,
-    :html,
-    :favicon_url
-  ]
 
   @doc false
+  @spec changeset(t | Ecto.Schema.t(), map) :: Ecto.Changeset.t()
   def changeset(resource, attrs) do
     resource
     |> cast(attrs, @attrs)
-    |> cast_embed(:metadata, with: &metadata_changeset/2)
+    |> cast_embed(:metadata)
     |> ensure_url(:resource)
     |> maybe_add_published_at()
     |> validate_resource_or_folder()
@@ -90,11 +66,6 @@ defmodule Mobilizon.Resources.Resource do
     |> unique_constraint(:url, name: :resource_url_index)
   end
 
-  defp metadata_changeset(schema, params) do
-    schema
-    |> cast(params, @metadata_attrs)
-  end
-
   @spec validate_resource_or_folder(Changeset.t()) :: Changeset.t()
   defp validate_resource_or_folder(%Changeset{} = changeset) do
     with {status, type} when status in [:changes, :data] <- fetch_field(changeset, :type),
diff --git a/lib/mobilizon/resources/resource/metadata.ex b/lib/mobilizon/resources/resource/metadata.ex
new file mode 100644
index 000000000..f8f66c8a6
--- /dev/null
+++ b/lib/mobilizon/resources/resource/metadata.ex
@@ -0,0 +1,64 @@
+defmodule Mobilizon.Resources.Resource.Metadata do
+  @moduledoc """
+  Represents a resource metadata
+  """
+
+  use Ecto.Schema
+  import Ecto.Changeset
+
+  @type t :: %__MODULE__{
+          type: String.t(),
+          title: String.t(),
+          image_remote_url: String.t(),
+          width: non_neg_integer(),
+          height: non_neg_integer(),
+          author_name: String.t(),
+          author_url: String.t(),
+          provider_name: String.t(),
+          provider_url: String.t(),
+          html: String.t(),
+          favicon_url: String.t()
+        }
+
+  @required_attrs []
+
+  @optional_attrs [
+    :type,
+    :title,
+    :description,
+    :image_remote_url,
+    :width,
+    :height,
+    :author_name,
+    :author_url,
+    :provider_name,
+    :provider_url,
+    :html,
+    :favicon_url
+  ]
+
+  @attrs @required_attrs ++ @optional_attrs
+
+  @primary_key false
+  embedded_schema do
+    field(:type, :string)
+    field(:title, :string)
+    field(:description, :string)
+    field(:image_remote_url, :string)
+    field(:width, :integer)
+    field(:height, :integer)
+    field(:author_name, :string)
+    field(:author_url, :string)
+    field(:provider_name, :string)
+    field(:provider_url, :string)
+    field(:html, :string)
+    field(:favicon_url, :string)
+  end
+
+  @doc false
+  @spec changeset(t | Ecto.Schema.t(), map) :: Ecto.Changeset.t()
+  def changeset(schema, params) do
+    schema
+    |> cast(params, @attrs)
+  end
+end
diff --git a/lib/mobilizon/share.ex b/lib/mobilizon/share.ex
index 734628340..03924b405 100644
--- a/lib/mobilizon/share.ex
+++ b/lib/mobilizon/share.ex
@@ -29,6 +29,7 @@ defmodule Mobilizon.Share do
   end
 
   @doc false
+  @spec changeset(t | Ecto.Schema.t(), map()) :: Ecto.Changeset.t()
   def changeset(share, attrs) do
     share
     |> cast(attrs, @attrs)
diff --git a/lib/mobilizon/storage/page.ex b/lib/mobilizon/storage/page.ex
index 68fc8aab3..43b9ebc5b 100644
--- a/lib/mobilizon/storage/page.ex
+++ b/lib/mobilizon/storage/page.ex
@@ -12,9 +12,9 @@ defmodule Mobilizon.Storage.Page do
     :elements
   ]
 
-  @type t :: %__MODULE__{
+  @type t(structure) :: %__MODULE__{
           total: integer,
-          elements: struct
+          elements: list(structure)
         }
 
   @doc """
@@ -23,7 +23,7 @@ defmodule Mobilizon.Storage.Page do
   `field` is use to define the field that will be used for the count aggregate, which should be the same as the field used for order_by
     See https://stackoverflow.com/q/12693089/10204399
   """
-  @spec build_page(Ecto.Query.t(), integer | nil, integer | nil, atom()) :: t
+  @spec build_page(Ecto.Queryable.t(), integer | nil, integer | nil, atom()) :: t(any)
   def build_page(query, page, limit, field \\ :id) do
     [total, elements] =
       [
@@ -39,7 +39,7 @@ defmodule Mobilizon.Storage.Page do
   @doc """
   Add limit and offset to the query.
   """
-  @spec paginate(Ecto.Query.t() | struct, integer | nil, integer | nil) :: Ecto.Query.t()
+  @spec paginate(Ecto.Queryable.t() | struct, integer | nil, integer | nil) :: Ecto.Query.t()
   def paginate(query, page \\ 1, size \\ 10)
 
   def paginate(query, page, _size) when is_nil(page), do: paginate(query)
diff --git a/lib/mobilizon/storage/repo.ex b/lib/mobilizon/storage/repo.ex
index 3b209a3cc..67796d3d4 100644
--- a/lib/mobilizon/storage/repo.ex
+++ b/lib/mobilizon/storage/repo.ex
@@ -10,6 +10,7 @@ defmodule Mobilizon.Storage.Repo do
   @doc """
   Dynamically loads the repository url from the DATABASE_URL environment variable.
   """
+  @spec init(any(), any()) :: any()
   def init(_, opts) do
     {:ok, opts}
   end
diff --git a/lib/mobilizon/todos/todo.ex b/lib/mobilizon/todos/todo.ex
index 82ed0906d..50dee5001 100644
--- a/lib/mobilizon/todos/todo.ex
+++ b/lib/mobilizon/todos/todo.ex
@@ -10,6 +10,8 @@ defmodule Mobilizon.Todos.Todo do
   alias Mobilizon.Todos.TodoList
 
   @type t :: %__MODULE__{
+          id: String.t(),
+          url: String.t(),
           status: boolean(),
           title: String.t(),
           due_date: DateTime.t(),
@@ -40,6 +42,7 @@ defmodule Mobilizon.Todos.Todo do
   @attrs @required_attrs ++ @optional_attrs
 
   @doc false
+  @spec changeset(t | Ecto.Schema.t(), map) :: Ecto.Changeset.t()
   def changeset(todo, attrs) do
     todo
     |> cast(attrs, @attrs)
diff --git a/lib/mobilizon/todos/todo_list.ex b/lib/mobilizon/todos/todo_list.ex
index 5ef31afbe..49a406b13 100644
--- a/lib/mobilizon/todos/todo_list.ex
+++ b/lib/mobilizon/todos/todo_list.ex
@@ -10,6 +10,8 @@ defmodule Mobilizon.Todos.TodoList do
   alias Mobilizon.Todos.Todo
 
   @type t :: %__MODULE__{
+          id: String.t(),
+          url: String.t(),
           title: String.t(),
           todos: [Todo.t()],
           actor: Actor.t(),
@@ -34,6 +36,7 @@ defmodule Mobilizon.Todos.TodoList do
   @attrs @required_attrs ++ @optional_attrs
 
   @doc false
+  @spec changeset(t | Ecto.Schema.t(), map) :: Ecto.Changeset.t()
   def changeset(todo_list, attrs) do
     todo_list
     |> cast(attrs, @attrs)
diff --git a/lib/mobilizon/tombstone.ex b/lib/mobilizon/tombstone.ex
index 7b464b6c7..62beb6f99 100644
--- a/lib/mobilizon/tombstone.ex
+++ b/lib/mobilizon/tombstone.ex
@@ -26,20 +26,21 @@ defmodule Mobilizon.Tombstone do
   end
 
   @doc false
+  @spec changeset(t | Ecto.Schema.t(), map()) :: Ecto.Changeset.t()
   def changeset(%__MODULE__{} = tombstone, attrs) do
     tombstone
     |> cast(attrs, @attrs)
     |> validate_required(@required_attrs)
   end
 
-  @spec create_tombstone(map) :: {:ok, Ecto.Schema.t()} | {:error, Ecto.Changeset.t()}
+  @spec create_tombstone(map) :: {:ok, t()} | {:error, Ecto.Changeset.t()}
   def create_tombstone(attrs) do
     %__MODULE__{}
     |> changeset(attrs)
     |> Repo.insert(on_conflict: :replace_all, conflict_target: :uri)
   end
 
-  @spec find_tombstone(String.t()) :: Ecto.Schema.t() | nil
+  @spec find_tombstone(String.t()) :: t() | nil
   def find_tombstone(uri) do
     __MODULE__
     |> Ecto.Query.where([t], t.uri == ^uri)
@@ -54,6 +55,7 @@ defmodule Mobilizon.Tombstone do
     |> Repo.delete_all()
   end
 
+  @spec delete_uri_tombstone(String.t()) :: {integer(), nil}
   def delete_uri_tombstone(uri) do
     __MODULE__
     |> Ecto.Query.where(uri: ^uri)
diff --git a/lib/mobilizon/users/activity_setting.ex b/lib/mobilizon/users/activity_setting.ex
index 12f956c50..acc5db428 100644
--- a/lib/mobilizon/users/activity_setting.ex
+++ b/lib/mobilizon/users/activity_setting.ex
@@ -25,6 +25,7 @@ defmodule Mobilizon.Users.ActivitySetting do
   end
 
   @doc false
+  @spec changeset(t | Ecto.Schema.t(), map) :: Ecto.Changeset.t()
   def changeset(activity_setting, attrs) do
     activity_setting
     |> cast(attrs, @attrs)
diff --git a/lib/mobilizon/users/push_subscription.ex b/lib/mobilizon/users/push_subscription.ex
index 737139f2f..d70433ebc 100644
--- a/lib/mobilizon/users/push_subscription.ex
+++ b/lib/mobilizon/users/push_subscription.ex
@@ -6,6 +6,14 @@ defmodule Mobilizon.Users.PushSubscription do
   alias Mobilizon.Users.User
   import Ecto.Changeset
 
+  @type t :: %__MODULE__{
+          digest: String.t(),
+          user: User.t(),
+          endpoint: String.t(),
+          auth: String.t(),
+          p256dh: String.t()
+        }
+
   @primary_key {:id, :binary_id, autogenerate: true}
   schema "user_push_subscriptions" do
     field(:digest, :string)
@@ -17,6 +25,7 @@ defmodule Mobilizon.Users.PushSubscription do
   end
 
   @doc false
+  @spec changeset(t | Ecto.Schema.t(), map) :: Ecto.Changeset.t()
   def changeset(push_subscription, attrs) do
     push_subscription
     |> cast(attrs, [:user_id, :endpoint, :auth, :p256dh])
diff --git a/lib/mobilizon/users/setting.ex b/lib/mobilizon/users/setting.ex
index b4f7d01df..6dab9b52d 100644
--- a/lib/mobilizon/users/setting.ex
+++ b/lib/mobilizon/users/setting.ex
@@ -6,6 +6,7 @@ defmodule Mobilizon.Users.Setting do
   use Ecto.Schema
   import Ecto.Changeset
   alias Mobilizon.Users.{NotificationPendingNotificationDelay, User}
+  alias Mobilizon.Users.Setting.Location
 
   @type t :: %__MODULE__{
           timezone: String.t(),
@@ -19,6 +20,12 @@ defmodule Mobilizon.Users.Setting do
           user: User.t()
         }
 
+  @type location :: %{
+          name: String.t(),
+          range: integer,
+          geohash: String.t()
+        }
+
   @required_attrs [:user_id]
 
   @optional_attrs [
@@ -34,8 +41,6 @@ defmodule Mobilizon.Users.Setting do
 
   @attrs @required_attrs ++ @optional_attrs
 
-  @location_attrs [:name, :range, :geohash]
-
   @primary_key {:user_id, :id, autogenerate: false}
   schema "user_settings" do
     field(:timezone, :string)
@@ -54,11 +59,7 @@ defmodule Mobilizon.Users.Setting do
     field(:group_notifications, NotificationPendingNotificationDelay, default: :one_day)
     field(:last_notification_sent, :utc_datetime)
 
-    embeds_one :location, Location, on_replace: :update, primary_key: false do
-      field(:name, :string)
-      field(:range, :integer)
-      field(:geohash, :string)
-    end
+    embeds_one(:location, Location, on_replace: :update)
 
     belongs_to(:user, User, primary_key: true, type: :id, foreign_key: :id, define_field: false)
 
@@ -66,15 +67,11 @@ defmodule Mobilizon.Users.Setting do
   end
 
   @doc false
+  @spec changeset(t | Ecto.Schema.t(), map) :: Ecto.Changeset.t()
   def changeset(setting, attrs) do
     setting
     |> cast(attrs, @attrs)
-    |> cast_embed(:location, with: &location_changeset/2)
+    |> cast_embed(:location)
     |> validate_required(@required_attrs)
   end
-
-  def location_changeset(schema, params) do
-    schema
-    |> cast(params, @location_attrs)
-  end
 end
diff --git a/lib/mobilizon/users/setting/location.ex b/lib/mobilizon/users/setting/location.ex
new file mode 100644
index 000000000..c403e2da6
--- /dev/null
+++ b/lib/mobilizon/users/setting/location.ex
@@ -0,0 +1,38 @@
+defmodule Mobilizon.Users.Setting.Location do
+  @moduledoc """
+  Represents user location information
+  """
+
+  use Ecto.Schema
+  import Ecto.Changeset
+
+  @type t :: %__MODULE__{
+          name: String.t(),
+          range: non_neg_integer(),
+          geohash: String.t()
+        }
+
+  @required_attrs []
+
+  @optional_attrs [
+    :name,
+    :range,
+    :geohash
+  ]
+
+  @attrs @required_attrs ++ @optional_attrs
+
+  @primary_key false
+  embedded_schema do
+    field(:name, :string)
+    field(:range, :integer)
+    field(:geohash, :string)
+  end
+
+  @doc false
+  @spec changeset(t | Ecto.Schema.t(), map) :: Ecto.Changeset.t()
+  def changeset(schema, params) do
+    schema
+    |> cast(params, @attrs)
+  end
+end
diff --git a/lib/mobilizon/users/user.ex b/lib/mobilizon/users/user.ex
index 3cfdaaa8d..78427214e 100644
--- a/lib/mobilizon/users/user.ex
+++ b/lib/mobilizon/users/user.ex
@@ -19,7 +19,7 @@ defmodule Mobilizon.Users.User do
           password_hash: String.t(),
           password: String.t(),
           role: UserRole.t(),
-          confirmed_at: DateTime.t(),
+          confirmed_at: DateTime.t() | nil,
           confirmation_sent_at: DateTime.t(),
           confirmation_token: String.t(),
           reset_password_sent_at: DateTime.t(),
@@ -32,7 +32,10 @@ defmodule Mobilizon.Users.User do
           last_sign_in_at: DateTime.t(),
           last_sign_in_ip: String.t(),
           current_sign_in_ip: String.t(),
-          current_sign_in_at: DateTime.t()
+          current_sign_in_at: DateTime.t(),
+          activity_settings: [ActivitySetting.t()],
+          settings: Setting.t(),
+          unconfirmed_email: String.t() | nil
         }
 
   @required_attrs [:email]
@@ -96,7 +99,7 @@ defmodule Mobilizon.Users.User do
   end
 
   @doc false
-  @spec changeset(t, map) :: Ecto.Changeset.t()
+  @spec changeset(t | Ecto.Schema.t(), map) :: Ecto.Changeset.t()
   def changeset(%__MODULE__{} = user, attrs) do
     changeset =
       user
@@ -129,7 +132,6 @@ defmodule Mobilizon.Users.User do
   def registration_changeset(%__MODULE__{} = user, attrs) do
     user
     |> changeset(attrs)
-    |> cast_assoc(:default_actor)
     |> validate_required(@registration_required_attrs)
     |> hash_password()
     |> save_confirmation_token()
@@ -148,7 +150,6 @@ defmodule Mobilizon.Users.User do
   def auth_provider_changeset(%__MODULE__{} = user, attrs) do
     user
     |> changeset(attrs)
-    |> cast_assoc(:default_actor)
     |> put_change(:confirmed_at, DateTime.utc_now() |> DateTime.truncate(:second))
     |> validate_required(@auth_provider_required_attrs)
   end
diff --git a/lib/mobilizon/users/users.ex b/lib/mobilizon/users/users.ex
index 271c962de..e54beea30 100644
--- a/lib/mobilizon/users/users.ex
+++ b/lib/mobilizon/users/users.ex
@@ -42,7 +42,7 @@ defmodule Mobilizon.Users do
     end
   end
 
-  @spec create_external(String.t(), String.t(), Map.t()) ::
+  @spec create_external(String.t(), String.t(), map()) ::
           {:ok, User.t()} | {:error, Ecto.Changeset.t()}
   def create_external(email, provider, args \\ %{}) do
     with {:ok, %User{} = user} <-
@@ -107,7 +107,7 @@ defmodule Mobilizon.Users do
   @doc """
   Get an user by its activation token.
   """
-  @spec get_user_by_activation_token(String.t()) :: Actor.t() | nil
+  @spec get_user_by_activation_token(String.t()) :: User.t() | nil
   def get_user_by_activation_token(token) do
     token
     |> user_by_activation_token_query()
@@ -117,7 +117,7 @@ defmodule Mobilizon.Users do
   @doc """
   Get an user by its reset password token.
   """
-  @spec get_user_by_reset_password_token(String.t()) :: Actor.t()
+  @spec get_user_by_reset_password_token(String.t()) :: User.t() | nil
   def get_user_by_reset_password_token(token) do
     token
     |> user_by_reset_password_token_query()
@@ -263,22 +263,26 @@ defmodule Mobilizon.Users do
   Updates user's default actor.
   Raises `Ecto.NoResultsError` if the user does not exist.
   """
-  @spec update_user_default_actor(integer | String.t(), integer | String.t()) :: User.t()
-  def update_user_default_actor(user_id, actor_id) do
-    with _ <-
-           user_id
-           |> update_user_default_actor_query(actor_id)
-           |> Repo.update_all([]) do
-      user_id
-      |> get_user!()
-      |> Repo.preload([:default_actor])
-    end
+  @spec update_user_default_actor(integer | String.t(), Actor.t() | nil) :: User.t()
+  def update_user_default_actor(user_id, actor) do
+    actor_id = if is_nil(actor), do: nil, else: actor.id
+
+    user_id
+    |> update_user_default_actor_query(actor_id)
+    |> Repo.update_all([])
+
+    Cachex.put(:default_actors, to_string(user_id), actor)
+
+    user_id
+    |> get_user!()
+    |> Repo.preload([:default_actor])
   end
 
   @doc """
   Returns the list of users.
   """
-  @spec list_users(String.t(), integer | nil, integer | nil, atom | nil, atom | nil) :: Page.t()
+  @spec list_users(String.t(), integer | nil, integer | nil, atom | nil, atom | nil) ::
+          Page.t(User.t())
   def list_users(email \\ "", page \\ nil, limit \\ nil, sort \\ nil, direction \\ nil)
 
   def list_users("", page, limit, sort, direction) do
@@ -338,10 +342,10 @@ defmodule Mobilizon.Users do
   """
   def get_setting!(user_id), do: Repo.get!(Setting, user_id)
 
-  @spec get_setting(User.t()) :: Setting.t()
+  @spec get_setting(User.t()) :: Setting.t() | nil
   def get_setting(%User{id: user_id}), do: get_setting(user_id)
 
-  @spec get_setting(String.t() | integer()) :: Setting.t()
+  @spec get_setting(String.t() | integer()) :: Setting.t() | nil
   def get_setting(user_id), do: Repo.get(Setting, user_id)
 
   @doc """
@@ -356,6 +360,7 @@ defmodule Mobilizon.Users do
       {:error, %Ecto.Changeset{}}
 
   """
+  @spec create_setting(map()) :: {:ok, Setting.t()} | {:error, Ecto.Changeset.t()}
   def create_setting(attrs \\ %{}) do
     %Setting{}
     |> Setting.changeset(attrs)
@@ -445,6 +450,8 @@ defmodule Mobilizon.Users do
       {:error, %Ecto.Changeset{}}
 
   """
+  @spec create_push_subscription(map()) ::
+          {:ok, PushSubscription.t()} | {:error, Ecto.Changeset.t()}
   def create_push_subscription(attrs \\ %{}) do
     %PushSubscription{}
     |> PushSubscription.changeset(attrs)
@@ -593,7 +600,7 @@ defmodule Mobilizon.Users do
     from(a in Actor, where: a.user_id == ^user_id)
   end
 
-  @spec update_user_default_actor_query(integer | String.t(), integer | String.t()) ::
+  @spec update_user_default_actor_query(integer | String.t(), integer | String.t() | nil) ::
           Ecto.Query.t()
   defp update_user_default_actor_query(user_id, actor_id) do
     from(
diff --git a/lib/service/activity/comment.ex b/lib/service/activity/comment.ex
index b2d8b4067..2c62e00bf 100644
--- a/lib/service/activity/comment.ex
+++ b/lib/service/activity/comment.ex
@@ -51,11 +51,11 @@ defmodule Mobilizon.Service.Activity.Comment do
     "object_type" => :comment
   }
 
+  @spec handle_notification(Keyword.t(), notification_type, Comment.t(), Event.t(), Keyword.t()) ::
+          Keyword.t()
   defp handle_notification(global_res, function, comment, event, options) do
-    case notify(function, comment, event, options) do
-      {:ok, res} -> Keyword.put(global_res, function, res)
-      _ -> Keyword.put(global_res, function, :error)
-    end
+    {:ok, res} = notify(function, comment, event, options)
+    Keyword.put(global_res, function, res)
   end
 
   @spec legacy_notifier_enqueue(map()) :: :ok
@@ -66,11 +66,11 @@ defmodule Mobilizon.Service.Activity.Comment do
     )
   end
 
-  @type notification_type :: atom()
+  @type notification_type :: :mentionned | :announcement | :organizer
 
   # An actor is mentionned
   @spec notify(notification_type(), Comment.t(), Event.t(), Keyword.t()) ::
-          {:ok, Oban.Job.t()} | {:ok, :skipped}
+          {:ok, :enqueued} | {:ok, :skipped}
   defp notify(
          :mentionned,
          %Comment{actor_id: actor_id, id: comment_id, mentions: mentions},
diff --git a/lib/service/activity/group.ex b/lib/service/activity/group.ex
index 5a18a7c84..234540217 100644
--- a/lib/service/activity/group.ex
+++ b/lib/service/activity/group.ex
@@ -10,31 +10,35 @@ defmodule Mobilizon.Service.Activity.Group do
   @behaviour Activity
 
   @impl Activity
+  @spec insert_activity(Actor.t(), Keyword.t()) ::
+          {:ok, Job.t()} | {:ok, nil} | {:error, Ecto.Changeset.t()}
   def insert_activity(group, options \\ [])
 
   def insert_activity(
         %Actor{type: :Group, id: group_id},
         options
       ) do
-    with %Actor{type: :Group} = group <- Actors.get_actor(group_id),
-         subject when not is_nil(subject) <- Keyword.get(options, :subject),
-         actor_id <- Keyword.get(options, :actor_id),
-         default_updater_actor <- Actors.get_actor(actor_id),
-         %Actor{id: actor_id} <-
-           Keyword.get(options, :updater_actor, default_updater_actor),
-         old_group <- Keyword.get(options, :old_group) do
-      ActivityBuilder.enqueue(:build_activity, %{
-        "type" => "group",
-        "subject" => subject,
-        "subject_params" => subject_params(group, subject, old_group),
-        "group_id" => group.id,
-        "author_id" => actor_id,
-        "object_type" => "group",
-        "object_id" => to_string(group.id),
-        "inserted_at" => DateTime.utc_now()
-      })
-    else
-      _ -> {:ok, nil}
+    subject = Keyword.get(options, :subject)
+    actor_id = Keyword.get(options, :actor_id)
+    default_updater_actor = Actors.get_actor(actor_id)
+    %Actor{id: actor_id} = Keyword.get(options, :updater_actor, default_updater_actor)
+    old_group = Keyword.get(options, :old_group)
+
+    case Actors.get_actor(group_id) do
+      %Actor{type: :Group} = group ->
+        ActivityBuilder.enqueue(:build_activity, %{
+          "type" => "group",
+          "subject" => subject,
+          "subject_params" => subject_params(group, subject, old_group),
+          "group_id" => group.id,
+          "author_id" => actor_id,
+          "object_type" => "group",
+          "object_id" => to_string(group.id),
+          "inserted_at" => DateTime.utc_now()
+        })
+
+      nil ->
+        {:ok, nil}
     end
   end
 
diff --git a/lib/service/activity/member.ex b/lib/service/activity/member.ex
index b0e7d997e..704a55e6e 100644
--- a/lib/service/activity/member.ex
+++ b/lib/service/activity/member.ex
@@ -40,7 +40,7 @@ defmodule Mobilizon.Service.Activity.Member do
     Actors.get_member(member_id)
   end
 
-  @spec get_author(Member.t(), Member.t() | nil) :: String.t() | integer()
+  @spec get_author(Member.t(), Member.t() | nil) :: integer()
   defp get_author(%Member{actor_id: actor_id}, options) do
     moderator = Keyword.get(options, :moderator)
 
diff --git a/lib/service/activity/renderer/renderer.ex b/lib/service/activity/renderer/renderer.ex
index 87e1d56d1..14eb6693f 100644
--- a/lib/service/activity/renderer/renderer.ex
+++ b/lib/service/activity/renderer/renderer.ex
@@ -19,9 +19,17 @@ defmodule Mobilizon.Service.Activity.Renderer do
   require Logger
   import Mobilizon.Web.Gettext, only: [dgettext: 3]
 
-  @type render :: %{body: String.t(), url: String.t()}
+  @type render :: %{
+          body: String.t(),
+          url: String.t(),
+          timestamp: String.t(),
+          locale: String.t(),
+          title: String.t()
+        }
 
-  @callback render(entity :: Activity.t(), Keyword.t()) :: render()
+  @type common_render :: %{body: String.t(), url: String.t()}
+
+  @callback render(entity :: Activity.t(), Keyword.t()) :: common_render()
 
   @spec render(Activity.t()) :: render()
   def render(%Activity{} = activity, options \\ []) do
@@ -43,6 +51,7 @@ defmodule Mobilizon.Service.Activity.Renderer do
     res
   end
 
+  @spec do_render(Activity.t(), Keyword.t()) :: common_render()
   defp do_render(%Activity{type: type} = activity, options) do
     case type do
       :discussion -> Discussion.render(activity, options)
diff --git a/lib/service/activity/utils.ex b/lib/service/activity/utils.ex
index 7a0f15754..ecfd33b69 100644
--- a/lib/service/activity/utils.ex
+++ b/lib/service/activity/utils.ex
@@ -14,7 +14,7 @@ defmodule Mobilizon.Service.Activity.Utils do
 
   @spec add_activity_object(Activity.t()) :: Activity.t()
   def add_activity_object(%Activity{} = activity) do
-    Map.put(activity, :object, ActivityService.object(activity))
+    %Activity{activity | object: ActivityService.object(activity)}
   end
 
   @spec transform_params(map()) :: list()
diff --git a/lib/service/actor_suspension.ex b/lib/service/actor_suspension.ex
new file mode 100644
index 000000000..e5f104eb2
--- /dev/null
+++ b/lib/service/actor_suspension.ex
@@ -0,0 +1,255 @@
+defmodule Mobilizon.Service.ActorSuspension do
+  @moduledoc """
+  Handle actor suspensions
+  """
+
+  alias Ecto.Multi
+  alias Mobilizon.{Actors, Events, Users}
+  alias Mobilizon.Actors.{Actor, Member}
+  alias Mobilizon.Discussions.{Comment, Discussion}
+  alias Mobilizon.Events.{Event, Participant}
+  alias Mobilizon.Medias.File
+  alias Mobilizon.Posts.Post
+  alias Mobilizon.Resources.Resource
+  alias Mobilizon.Storage.Repo
+  alias Mobilizon.Users.User
+  alias Mobilizon.Web.Email.Actor, as: ActorEmail
+  alias Mobilizon.Web.Email.Group
+  alias Mobilizon.Web.Upload
+  require Logger
+  import Ecto.Query
+
+  @actor_preloads [:user, :organized_events, :comments]
+  @delete_actor_default_options [reserve_username: true, suspension: false]
+
+  @doc """
+  Deletes an actor.
+  """
+  @spec suspend_actor(Actor.t(), Keyword.t()) :: {:ok, Actor.t()} | {:error, Ecto.Changeset.t()}
+  def suspend_actor(%Actor{} = actor, options \\ @delete_actor_default_options) do
+    Logger.info("Going to delete actor #{actor.url}")
+    actor = Repo.preload(actor, @actor_preloads)
+
+    delete_actor_options = Keyword.merge(@delete_actor_default_options, options)
+    Logger.debug(inspect(delete_actor_options))
+
+    send_suspension_notification(actor)
+    notify_event_participants_from_suspension(actor)
+    delete_participations(actor)
+
+    multi =
+      Multi.new()
+      |> maybe_reset_actor_id(actor)
+      |> delete_actor_empty_comments(actor)
+      |> Multi.run(:remove_banner, fn _, _ -> remove_banner(actor) end)
+      |> Multi.run(:remove_avatar, fn _, _ -> remove_avatar(actor) end)
+
+    multi =
+      if Keyword.get(delete_actor_options, :reserve_username, true) do
+        multi
+        |> delete_actor_events(actor)
+        |> delete_posts(actor)
+        |> delete_ressources(actor)
+        |> delete_discussions(actor)
+        |> delete_members(actor)
+        |> Multi.update(:actor, Actor.delete_changeset(actor))
+      else
+        Multi.delete(multi, :actor, actor)
+      end
+
+    Logger.debug("Going to run the transaction")
+
+    case Repo.transaction(multi) do
+      {:ok, %{actor: %Actor{} = actor}} ->
+        {:ok, true} = Cachex.del(:activity_pub, "actor_#{actor.preferred_username}")
+        Logger.info("Deleted actor #{actor.url}")
+        {:ok, actor}
+
+      {:error, remove, error, _} when remove in [:remove_banner, :remove_avatar] ->
+        Logger.error("Error while deleting actor's banner or avatar")
+
+        Sentry.capture_message("Error while deleting actor's banner or avatar",
+          extra: %{err: error}
+        )
+
+        Logger.debug(inspect(error, pretty: true))
+        {:error, error}
+
+      err ->
+        Logger.error("Unknown error while deleting actor")
+
+        Sentry.capture_message("Error while deleting actor's banner or avatar",
+          extra: %{err: err}
+        )
+
+        Logger.debug(inspect(err, pretty: true))
+        {:error, err}
+    end
+  end
+
+  # When deleting a profile, reset default_actor_id
+  @spec maybe_reset_actor_id(Multi.t(), Actor.t()) :: Multi.t()
+  defp maybe_reset_actor_id(%Multi{} = multi, %Actor{type: :Person} = actor) do
+    Multi.run(multi, :reset_default_actor_id, fn _, _ ->
+      reset_default_actor_id(actor)
+    end)
+  end
+
+  defp maybe_reset_actor_id(%Multi{} = multi, %Actor{type: :Group} = _actor) do
+    multi
+  end
+
+  defp delete_actor_empty_comments(%Multi{} = multi, %Actor{id: actor_id}) do
+    now = DateTime.utc_now() |> DateTime.truncate(:second)
+
+    Multi.update_all(multi, :empty_comments, where(Comment, [c], c.actor_id == ^actor_id),
+      set: [
+        text: nil,
+        actor_id: nil,
+        deleted_at: now
+      ]
+    )
+  end
+
+  @spec notify_event_participants_from_suspension(Actor.t()) :: :ok
+  defp notify_event_participants_from_suspension(%Actor{id: actor_id} = actor) do
+    actor
+    |> get_actor_organizer_events_participations()
+    |> preload([:actor, :event])
+    |> Repo.all()
+    |> Enum.filter(fn %Participant{actor: %Actor{id: participant_actor_id}} ->
+      participant_actor_id != actor_id
+    end)
+    |> Enum.each(&ActorEmail.send_notification_event_participants_from_suspension(&1, actor))
+  end
+
+  @spec get_actor_organizer_events_participations(Actor.t()) :: Ecto.Query.t()
+  defp get_actor_organizer_events_participations(%Actor{type: :Person, id: actor_id}) do
+    do_get_actor_organizer_events_participations()
+    |> where([_p, e], e.organizer_actor_id == ^actor_id)
+  end
+
+  defp get_actor_organizer_events_participations(%Actor{type: :Group, id: actor_id}) do
+    do_get_actor_organizer_events_participations()
+    |> where([_p, e], e.attributed_to_id == ^actor_id)
+  end
+
+  @spec do_get_actor_organizer_events_participations :: Ecto.Query.t()
+  defp do_get_actor_organizer_events_participations do
+    Participant
+    |> join(:inner, [p], e in Event, on: p.event_id == e.id)
+    |> where([_p, e], e.begins_on > ^DateTime.utc_now())
+    |> where([p, _e], p.role in [:participant, :moderator, :administrator])
+  end
+
+  @spec delete_actor_events(Ecto.Multi.t(), Actor.t()) :: Ecto.Multi.t()
+  defp delete_actor_events(%Multi{} = multi, %Actor{type: :Person, id: actor_id}) do
+    Multi.delete_all(multi, :delete_events, where(Event, [e], e.organizer_actor_id == ^actor_id))
+  end
+
+  defp delete_actor_events(%Multi{} = multi, %Actor{type: :Group, id: actor_id}) do
+    Multi.delete_all(multi, :delete_events, where(Event, [e], e.attributed_to_id == ^actor_id))
+  end
+
+  defp delete_posts(%Multi{} = multi, %Actor{type: :Person, id: actor_id}) do
+    Multi.delete_all(multi, :delete_posts, where(Post, [e], e.author_id == ^actor_id))
+  end
+
+  defp delete_posts(%Multi{} = multi, %Actor{type: :Group, id: actor_id}) do
+    Multi.delete_all(multi, :delete_posts, where(Post, [e], e.attributed_to_id == ^actor_id))
+  end
+
+  defp delete_ressources(%Multi{} = multi, %Actor{type: :Person, id: actor_id}) do
+    Multi.delete_all(multi, :delete_resources, where(Resource, [e], e.creator_id == ^actor_id))
+  end
+
+  defp delete_ressources(%Multi{} = multi, %Actor{type: :Group, id: actor_id}) do
+    Multi.delete_all(multi, :delete_resources, where(Resource, [e], e.actor_id == ^actor_id))
+  end
+
+  # Keep discussions just in case, comments are already emptied
+  defp delete_discussions(%Multi{} = multi, %Actor{type: :Person}) do
+    multi
+  end
+
+  defp delete_discussions(%Multi{} = multi, %Actor{type: :Group, id: actor_id}) do
+    Multi.delete_all(multi, :delete_discussions, where(Discussion, [e], e.actor_id == ^actor_id))
+  end
+
+  @spec delete_participations(Actor.t()) :: :ok
+  defp delete_participations(%Actor{type: :Person} = actor) do
+    %Actor{participations: participations} = Repo.preload(actor, [:participations])
+    Enum.each(participations, &Events.delete_participant/1)
+  end
+
+  defp delete_participations(%Actor{type: :Group}), do: :ok
+
+  @spec delete_members(Multi.t(), Actor.t()) :: Multi.t()
+  defp delete_members(%Multi{} = multi, %Actor{type: :Person, id: actor_id}) do
+    Multi.delete_all(multi, :delete_members, where(Member, [e], e.actor_id == ^actor_id))
+  end
+
+  defp delete_members(%Multi{} = multi, %Actor{type: :Group, id: actor_id}) do
+    Multi.delete_all(multi, :delete_members, where(Member, [e], e.parent_id == ^actor_id))
+  end
+
+  @spec reset_default_actor_id(Actor.t()) :: {:ok, User.t() | nil} | {:error, :user_not_found}
+  defp reset_default_actor_id(%Actor{type: :Person, user: %User{id: user_id} = user, id: actor_id}) do
+    Logger.debug("reset_default_actor_id")
+
+    new_actor =
+      user
+      |> Users.get_actors_for_user()
+      |> Enum.find(&(&1.id !== actor_id))
+
+    {:ok, Users.update_user_default_actor(user_id, new_actor)}
+  rescue
+    _e in Ecto.NoResultsError ->
+      {:error, :user_not_found}
+  end
+
+  defp reset_default_actor_id(%Actor{type: :Person, user: nil}), do: {:ok, nil}
+
+  @spec remove_banner(Actor.t()) :: {:ok, Actor.t()}
+  defp remove_banner(%Actor{banner: nil} = actor), do: {:ok, actor}
+
+  defp remove_banner(%Actor{banner: %File{url: url}} = actor) do
+    safe_remove_file(url, actor)
+    {:ok, actor}
+  end
+
+  @spec remove_avatar(Actor.t()) :: {:ok, Actor.t()}
+  defp remove_avatar(%Actor{avatar: avatar} = actor) do
+    case avatar do
+      %File{url: url} ->
+        safe_remove_file(url, actor)
+        {:ok, actor}
+
+      nil ->
+        {:ok, actor}
+    end
+  end
+
+  @spec safe_remove_file(String.t(), Actor.t()) :: {:ok, Actor.t()}
+  defp safe_remove_file(url, %Actor{} = actor) do
+    case Upload.remove(url) do
+      {:ok, _value} ->
+        {:ok, actor}
+
+      {:error, error} ->
+        Logger.error("Error while removing an upload file")
+        Logger.debug(inspect(error))
+
+        {:ok, actor}
+    end
+  end
+
+  @spec send_suspension_notification(Actor.t()) :: :ok
+  defp send_suspension_notification(%Actor{type: :Group} = group) do
+    group
+    |> Actors.list_all_local_members_for_group()
+    |> Enum.each(&Group.send_group_suspension_notification/1)
+  end
+
+  defp send_suspension_notification(%Actor{} = _actor), do: :ok
+end
diff --git a/lib/service/address/address.ex b/lib/service/address/address.ex
index c4edc502c..59cc8682c 100644
--- a/lib/service/address/address.ex
+++ b/lib/service/address/address.ex
@@ -7,6 +7,7 @@ defmodule Mobilizon.Service.Address do
 
   @type address :: %{name: String.t(), alternative_name: String.t()}
 
+  @spec render_address(AddressModel.t()) :: String.t() | no_return
   def render_address(%AddressModel{} = address) do
     %{name: name, alternative_name: alternative_name} = render_names(address)
 
diff --git a/lib/service/clean_old_activity.ex b/lib/service/clean_old_activity.ex
index 8801eee5f..7c294a09a 100644
--- a/lib/service/clean_old_activity.ex
+++ b/lib/service/clean_old_activity.ex
@@ -31,7 +31,7 @@ defmodule Mobilizon.Service.CleanOldActivity do
     end
   end
 
-  @spec find_activities(Keyword.t()) :: {Ecto.Query.t(), list()}
+  @spec find_activities(Keyword.t()) :: {Ecto.Query.t(), integer()}
   defp find_activities(opts) do
     grace_period =
       Keyword.get(opts, :grace_period, Config.get([:instance, :activity_expire_days], 365))
diff --git a/lib/service/clean_unconfirmed_users.ex b/lib/service/clean_unconfirmed_users.ex
index d9e6e9ea5..28c77d39e 100644
--- a/lib/service/clean_unconfirmed_users.ex
+++ b/lib/service/clean_unconfirmed_users.ex
@@ -3,9 +3,10 @@ defmodule Mobilizon.Service.CleanUnconfirmedUsers do
   Service to clean unconfirmed users
   """
 
-  alias Mobilizon.{Actors, Users}
   alias Mobilizon.Federation.ActivityPub.Relay
+  alias Mobilizon.Service.ActorSuspension
   alias Mobilizon.Storage.Repo
+  alias Mobilizon.Users
   alias Mobilizon.Users.User
   import Ecto.Query
 
@@ -27,21 +28,21 @@ defmodule Mobilizon.Service.CleanUnconfirmedUsers do
     end
   end
 
-  @spec delete_user(User.t()) :: {:ok, User.t()}
+  @spec delete_user(User.t()) :: User.t() | {:error, Ecto.Changeset.t()} | no_return
   defp delete_user(%User{} = user) do
-    with actors <- Users.get_actors_for_user(user),
-         :ok <-
-           Enum.each(actors, fn actor ->
-             actor_performing = Relay.get_actor()
+    actors = Users.get_actors_for_user(user)
+    %{id: actor_performing_id} = Relay.get_actor()
 
-             Actors.perform(:delete_actor, actor,
-               author_id: actor_performing.id,
-               reserve_username: false
-             )
-           end),
-         {:ok, %User{} = user} <- Users.delete_user(user, reserve_email: false),
-         %User{} = user <- %User{user | actors: actors} do
-      user
+    Enum.each(actors, fn actor ->
+      ActorSuspension.suspend_actor(actor,
+        author_id: actor_performing_id,
+        reserve_username: false
+      )
+    end)
+
+    case Users.delete_user(user, reserve_email: false) do
+      {:ok, %User{} = user} ->
+        %User{user | actors: actors}
     end
   end
 
diff --git a/lib/service/date_time/date_time.ex b/lib/service/date_time/date_time.ex
index ed58b6892..039da30c2 100644
--- a/lib/service/date_time/date_time.ex
+++ b/lib/service/date_time/date_time.ex
@@ -4,10 +4,14 @@ defmodule Mobilizon.Service.DateTime do
   """
   alias Cldr.DateTime.Relative
 
+  @typep to_string_format :: :short | :medium | :long | :full
+
+  @spec datetime_to_string(DateTime.t(), String.t(), to_string_format()) :: String.t()
   def datetime_to_string(%DateTime{} = datetime, locale \\ "en", format \\ :medium) do
     Mobilizon.Cldr.DateTime.to_string!(datetime, format: format, locale: locale_or_default(locale))
   end
 
+  @spec datetime_to_time_string(DateTime.t(), String.t(), to_string_format()) :: String.t()
   def datetime_to_time_string(%DateTime{} = datetime, locale \\ "en", format \\ :short) do
     Mobilizon.Cldr.Time.to_string!(datetime, format: format, locale: locale_or_default(locale))
   end
@@ -39,7 +43,8 @@ defmodule Mobilizon.Service.DateTime do
     end
   end
 
-  def is_first_day_of_week(%Date{} = date, locale \\ "en") do
+  @spec is_first_day_of_week(Date.t(), String.t()) :: boolean()
+  defp is_first_day_of_week(%Date{} = date, locale) do
     Date.day_of_week(date) == Cldr.Calendar.first_day_for_locale(locale)
   end
 
@@ -119,17 +124,18 @@ defmodule Mobilizon.Service.DateTime do
       compare_to
       |> DateTime.to_date()
       |> calculate_first_day_of_week(locale)
-      |> Timex.add(Timex.Duration.from_weeks(1))
+      |> Date.add(7)
       |> build_notification_datetime(options)
 
-    if Date.compare(datetime, next_first_day_of_week) == :gt do
+    if next_first_day_of_week != nil && DateTime.compare(datetime, next_first_day_of_week) == :gt do
       next_first_day_of_week
     else
       nil
     end
   end
 
-  def appropriate_first_day_of_week(%DateTime{} = datetime, options) do
+  @spec appropriate_first_day_of_week(DateTime.t(), keyword) :: DateTime.t() | nil
+  defp appropriate_first_day_of_week(%DateTime{} = datetime, options) do
     locale = Keyword.get(options, :locale, "en")
     timezone = Keyword.get(options, :timezone, "Etc/UTC")
 
@@ -141,15 +147,20 @@ defmodule Mobilizon.Service.DateTime do
     if DateTime.compare(local_datetime, first_datetime) == :gt do
       first_datetime
     else
-      next_first_day_of_week(local_datetime, options)
+      local_datetime
+      |> next_first_day_of_week(options)
+      |> build_notification_datetime(options)
     end
   end
 
   @spec build_notification_datetime(Date.t(), Keyword.t()) :: DateTime.t()
-  def build_notification_datetime(
-        %Date{} = date,
-        options
-      ) do
+  @spec build_notification_datetime(nil, Keyword.t()) :: nil
+  defp build_notification_datetime(nil, _options), do: nil
+
+  defp build_notification_datetime(
+         %Date{} = date,
+         options
+       ) do
     notification_time = Keyword.get(options, :notification_time, ~T[08:00:00])
     timezone = Keyword.get(options, :timezone, "Etc/UTC")
     DateTime.new!(date, notification_time, timezone)
@@ -158,8 +169,8 @@ defmodule Mobilizon.Service.DateTime do
   @start_time ~T[08:00:00]
   @end_time ~T[09:00:00]
 
-  @spec is_between_hours(Keyword.t()) :: boolean()
-  def is_between_hours(options \\ []) when is_list(options) do
+  @spec is_between_hours?(Keyword.t()) :: boolean()
+  def is_between_hours?(options \\ []) when is_list(options) do
     compare_to_day = Keyword.get(options, :compare_to_day, Date.utc_today())
     compare_to = Keyword.get(options, :compare_to_datetime, DateTime.utc_now())
     start_time = Keyword.get(options, :start_time, @start_time)
@@ -176,17 +187,16 @@ defmodule Mobilizon.Service.DateTime do
       ) == :lt
   end
 
-  @spec is_between_hours_on_first_day(Keyword.t()) :: boolean()
-  def is_between_hours_on_first_day(options) when is_list(options) do
+  @spec is_between_hours_on_first_day?(Keyword.t()) :: boolean()
+  def is_between_hours_on_first_day?(options) when is_list(options) do
     compare_to_day = Keyword.get(options, :compare_to_day, Date.utc_today())
     locale = Keyword.get(options, :locale, "en")
 
-    Mobilizon.Service.DateTime.is_first_day_of_week(compare_to_day, locale) &&
-      is_between_hours(options)
+    is_first_day_of_week(compare_to_day, locale) && is_between_hours?(options)
   end
 
-  @spec is_delay_ok_since_last_notification_sent(DateTime.t()) :: boolean()
-  def is_delay_ok_since_last_notification_sent(%DateTime{} = last_notification_sent) do
+  @spec is_delay_ok_since_last_notification_sent?(DateTime.t()) :: boolean()
+  def is_delay_ok_since_last_notification_sent?(%DateTime{} = last_notification_sent) do
     DateTime.compare(DateTime.add(last_notification_sent, 3_600), DateTime.utc_now()) ==
       :lt
   end
diff --git a/lib/service/error_page.ex b/lib/service/error_page.ex
index bca368c99..de8b224a1 100644
--- a/lib/service/error_page.ex
+++ b/lib/service/error_page.ex
@@ -3,10 +3,12 @@ defmodule Mobilizon.Service.ErrorPage do
   Render an error page
   """
 
+  @spec init :: :ok | {:error, File.posix()}
   def init do
     render_error_page()
   end
 
+  @spec render_error_page :: :ok | {:error, File.posix()}
   defp render_error_page do
     content =
       Phoenix.View.render_to_string(Mobilizon.Web.ErrorView, "500.html", conn: %Plug.Conn{})
diff --git a/lib/service/error_reporting/sentry.ex b/lib/service/error_reporting/sentry.ex
index d9f234640..333b8e570 100644
--- a/lib/service/error_reporting/sentry.ex
+++ b/lib/service/error_reporting/sentry.ex
@@ -29,6 +29,7 @@ defmodule Mobilizon.Service.ErrorReporting.Sentry do
   end
 
   @impl ErrorReporting
+  @spec attach :: :ok | {:error, :already_exists}
   def attach do
     :telemetry.attach(
       "oban-errors",
diff --git a/lib/service/export/common.ex b/lib/service/export/common.ex
index c414fd9de..8b11870b3 100644
--- a/lib/service/export/common.ex
+++ b/lib/service/export/common.ex
@@ -6,56 +6,99 @@ defmodule Mobilizon.Service.Export.Common do
   alias Mobilizon.{Actors, Events, Posts, Users}
   alias Mobilizon.Actors.Actor
   alias Mobilizon.Events.{Event, FeedToken}
+  alias Mobilizon.Posts.Post
   alias Mobilizon.Storage.Page
   alias Mobilizon.Users.User
 
-  @spec fetch_actor_event_feed(String.t(), integer()) :: String.t()
+  @spec fetch_actor_event_feed(String.t(), integer()) ::
+          {:ok, Actor.t(), [Event.t()], [Post.t()]}
+          | {:error, :actor_not_public | :actor_not_found}
   def fetch_actor_event_feed(name, limit) do
-    with %Actor{} = actor <- Actors.get_actor_by_name(name),
-         {:visibility, true} <- {:visibility, Actor.is_public_visibility?(actor)},
-         %Page{elements: events} <- Events.list_public_events_for_actor(actor, 1, limit),
-         %Page{elements: posts} <- Posts.get_public_posts_for_group(actor, 1, limit) do
-      {:ok, actor, events, posts}
-    else
-      err ->
-        {:error, err}
+    case Actors.get_actor_by_name(name) do
+      %Actor{} = actor ->
+        if Actor.is_public_visibility?(actor) do
+          %Page{elements: events} = Events.list_public_events_for_actor(actor, 1, limit)
+          %Page{elements: posts} = Posts.get_public_posts_for_group(actor, 1, limit)
+          {:ok, actor, events, posts}
+        else
+          {:error, :actor_not_public}
+        end
+
+      nil ->
+        {:error, :actor_not_found}
     end
   end
 
-  # Only events, not posts
-  @spec fetch_events_from_token(String.t(), integer()) :: String.t()
-  def fetch_events_from_token(token, limit) do
-    with {:ok, uuid} <- ShortUUID.decode(token),
-         {:ok, _uuid} <- Ecto.UUID.cast(uuid),
-         %FeedToken{actor: actor, user: %User{} = user} <- Events.get_feed_token(uuid) do
-      case actor do
-        %Actor{} = actor ->
-          %{
-            type: :actor,
-            actor: actor,
-            events: fetch_actor_private_events(actor, limit),
-            user: user,
-            token: token
-          }
+  @typep token_feed_data :: %{
+           type: :actor | :user,
+           actor: Actor.t() | nil,
+           user: User.t(),
+           events: [Event.t()],
+           token: String.t()
+         }
 
-        nil ->
-          with actors <- Users.get_actors_for_user(user),
-               events <-
-                 actors
-                 |> Enum.map(&fetch_actor_private_events(&1, limit))
-                 |> Enum.concat() do
-            %{type: :user, events: events, user: user, token: token, actor: nil}
-          end
-      end
+  # Only events, not posts
+  @spec fetch_events_from_token(String.t(), integer()) ::
+          token_feed_data | {:error, :bad_token | :token_not_found}
+  def fetch_events_from_token(token, limit) do
+    case uuid_from_token(token) do
+      {:ok, uuid} ->
+        case Events.get_feed_token(uuid) do
+          nil ->
+            {:error, :token_not_found}
+
+          %FeedToken{actor: actor, user: %User{} = user} ->
+            produce_actor_feed(actor, user, token, limit)
+        end
+
+      {:error, :bad_token} ->
+        {:error, :bad_token}
+    end
+  end
+
+  @spec uuid_from_token(String.t()) :: {:ok, String.t()} | {:error, :bad_token}
+  defp uuid_from_token(token) do
+    case ShortUUID.decode(token) do
+      {:ok, uuid} ->
+        case Ecto.UUID.cast(uuid) do
+          {:ok, _uuid} ->
+            {:ok, uuid}
+
+          :error ->
+            {:error, :bad_token}
+        end
+
+      {:error, _err} ->
+        {:error, :bad_token}
+    end
+  end
+
+  @spec produce_actor_feed(Actor.t() | nil, User.t(), String.t(), integer()) :: token_feed_data
+  defp produce_actor_feed(%Actor{} = actor, %User{} = user, token, limit) do
+    %{
+      type: :actor,
+      actor: actor,
+      events: fetch_actor_private_events(actor, limit),
+      user: user,
+      token: token
+    }
+  end
+
+  defp produce_actor_feed(nil, %User{} = user, token, limit) do
+    with actors <- Users.get_actors_for_user(user),
+         events <-
+           actors
+           |> Enum.map(&fetch_actor_private_events(&1, limit))
+           |> Enum.concat() do
+      %{type: :user, events: events, user: user, token: token, actor: nil}
     end
   end
 
   @spec fetch_instance_public_content(integer()) :: {:ok, list(Event.t()), list(Post.t())}
   def fetch_instance_public_content(limit) do
-    with %Page{elements: events} <- Events.list_public_local_events(1, limit),
-         %Page{elements: posts} <- Posts.list_public_local_posts(1, limit) do
-      {:ok, events, posts}
-    end
+    %Page{elements: events} = Events.list_public_local_events(1, limit)
+    %Page{elements: posts} = Posts.list_public_local_posts(1, limit)
+    {:ok, events, posts}
   end
 
   @spec fetch_actor_private_events(Actor.t(), integer()) :: list(Event.t())
diff --git a/lib/service/export/feed.ex b/lib/service/export/feed.ex
index 7d764f01e..6af40bada 100644
--- a/lib/service/export/feed.ex
+++ b/lib/service/export/feed.ex
@@ -96,13 +96,13 @@ defmodule Mobilizon.Service.Export.Feed do
       {:ok, actor, events, posts} ->
         {:ok, build_actor_feed(actor, events, posts)}
 
-      err ->
+      {:error, err} ->
         {:error, err}
     end
   end
 
   # Build an atom feed from actor and its public events and posts
-  @spec build_actor_feed(Actor.t(), list(), list(), boolean()) :: String.t()
+  @spec build_actor_feed(Actor.t(), list(Event.t()), list(Post.t()), boolean()) :: String.t()
   defp build_actor_feed(%Actor{} = actor, events, posts, public \\ true) do
     display_name = Actor.display_name(actor)
 
@@ -199,19 +199,22 @@ defmodule Mobilizon.Service.Export.Feed do
   end
 
   # Only events, not posts
-  @spec fetch_events_from_token(String.t()) :: String.t()
+  @spec fetch_events_from_token(String.t(), integer()) :: {:ok, String.t()} | {:error, atom()}
   defp fetch_events_from_token(token, limit \\ @item_limit) do
-    with %{events: events, token: token, user: user, actor: actor, type: type} <-
-           Common.fetch_events_from_token(token, limit) do
-      case type do
-        :user -> {:ok, build_user_feed(events, user, token)}
-        :actor -> {:ok, build_actor_feed(actor, events, [], false)}
-      end
+    case Common.fetch_events_from_token(token, limit) do
+      %{events: events, token: token, user: user, actor: actor, type: type} ->
+        case type do
+          :user -> {:ok, build_user_feed(events, user, token)}
+          :actor -> {:ok, build_actor_feed(actor, events, [], false)}
+        end
+
+      {:error, err} ->
+        {:error, err}
     end
   end
 
   # Build an atom feed from actor and its public events
-  @spec build_user_feed(list(), User.t(), String.t()) :: String.t()
+  @spec build_user_feed(list(Event.t()), User.t(), String.t()) :: String.t()
   defp build_user_feed(events, %User{email: email}, token) do
     self_url = Endpoint |> Routes.feed_url(:going, token, "atom") |> URI.decode()
 
diff --git a/lib/service/export/icalendar.ex b/lib/service/export/icalendar.ex
index c3ba2dde7..74e2ee3d7 100644
--- a/lib/service/export/icalendar.ex
+++ b/lib/service/export/icalendar.ex
@@ -15,12 +15,13 @@ defmodule Mobilizon.Service.Export.ICalendar do
   @doc """
   Create cache for an actor, an event or an user token
   """
+  @spec create_cache(String.t()) :: {:commit, String.t()} | {:ignore, atom()}
   def create_cache("actor_" <> name) do
     case export_public_actor(name) do
       {:ok, res} ->
         {:commit, res}
 
-      err ->
+      {:error, err} ->
         {:ignore, err}
     end
   end
@@ -30,8 +31,11 @@ defmodule Mobilizon.Service.Export.ICalendar do
          {:ok, res} <- export_public_event(event) do
       {:commit, res}
     else
-      err ->
+      {:error, err} ->
         {:ignore, err}
+
+      nil ->
+        {:ignore, :event_not_found}
     end
   end
 
@@ -40,30 +44,20 @@ defmodule Mobilizon.Service.Export.ICalendar do
       {:ok, res} ->
         {:commit, res}
 
-      err ->
+      {:error, err} ->
         {:ignore, err}
     end
   end
 
   def create_cache("instance") do
-    case fetch_instance_feed() do
-      {:ok, res} ->
-        {:commit, res}
-
-      err ->
-        {:ignore, err}
-    end
+    {:ok, res} = fetch_instance_feed()
+    {:commit, res}
   end
 
   @spec fetch_instance_feed :: {:ok, String.t()}
   defp fetch_instance_feed do
-    case Common.fetch_instance_public_content(@item_limit) do
-      {:ok, events, _posts} ->
-        {:ok, %ICalendar{events: events |> Enum.map(&do_export_event/1)} |> ICalendar.to_ics()}
-
-      err ->
-        {:error, err}
-    end
+    {:ok, events, _posts} = Common.fetch_instance_public_content(@item_limit)
+    {:ok, %ICalendar{events: events |> Enum.map(&do_export_event/1)} |> ICalendar.to_ics()}
   end
 
   @doc """
@@ -77,13 +71,12 @@ defmodule Mobilizon.Service.Export.ICalendar do
 
   The event must have a visibility of `:public` or `:unlisted`
   """
-  @spec export_public_event(Event.t()) :: {:ok, String.t()}
+  @spec export_public_event(Event.t()) :: {:ok, String.t()} | {:error, :event_not_public}
   def export_public_event(%Event{visibility: visibility} = event)
       when visibility in [:public, :unlisted] do
     {:ok, events_to_ics([event])}
   end
 
-  @spec export_public_event(Event.t()) :: {:error, :event_not_public}
   def export_public_event(%Event{}), do: {:error, :event_not_public}
 
   @doc """
@@ -91,28 +84,33 @@ defmodule Mobilizon.Service.Export.ICalendar do
 
   The actor must have a visibility of `:public` or `:unlisted`, as well as the events
   """
-  @spec export_public_actor(String.t()) :: String.t()
+  @spec export_public_actor(String.t()) ::
+          {:ok, String.t()} | {:error, :actor_not_public | :actor_not_found}
   def export_public_actor(name, limit \\ @item_limit) do
     case Common.fetch_actor_event_feed(name, limit) do
       {:ok, _actor, events, _posts} ->
         {:ok, events_to_ics(events)}
 
-      err ->
+      {:error, err} ->
         {:error, err}
     end
   end
 
-  @spec export_private_actor(Actor.t()) :: String.t()
+  @spec export_private_actor(Actor.t(), integer()) :: {:ok, String.t()}
   def export_private_actor(%Actor{} = actor, limit \\ @item_limit) do
-    with events <- Common.fetch_actor_private_events(actor, limit) do
-      {:ok, events_to_ics(events)}
-    end
+    events = Common.fetch_actor_private_events(actor, limit)
+    {:ok, events_to_ics(events)}
   end
 
-  @spec fetch_events_from_token(String.t()) :: String.t()
+  @spec fetch_events_from_token(String.t(), integer()) ::
+          {:ok, String.t()} | {:error, :actor_not_public | :actor_not_found}
   defp fetch_events_from_token(token, limit \\ @item_limit) do
-    with %{events: events} <- Common.fetch_events_from_token(token, limit) do
-      {:ok, events_to_ics(events)}
+    case Common.fetch_events_from_token(token, limit) do
+      %{events: events} ->
+        {:ok, events_to_ics(events)}
+
+      {:error, err} ->
+        {:error, err}
     end
   end
 
@@ -138,6 +136,7 @@ defmodule Mobilizon.Service.Export.ICalendar do
     }
   end
 
+  @spec vendor :: String.t()
   defp vendor do
     "Mobilizon #{Config.instance_version()}"
   end
diff --git a/lib/service/formatter/formatter.ex b/lib/service/formatter/formatter.ex
index bba56b741..e30b1a996 100644
--- a/lib/service/formatter/formatter.ex
+++ b/lib/service/formatter/formatter.ex
@@ -18,18 +18,20 @@ defmodule Mobilizon.Service.Formatter do
   @link_regex ~r"((?:http(s)?:\/\/)?[\w.-]+(?:\.[\w\.-]+)+[\w\-\._~%:/?#[\]@!\$&'\(\)\*\+,;=.]+)|[0-9a-z+\-\.]+:[0-9a-z$-_.+!*'(),]+"ui
   @markdown_characters_regex ~r/(`|\*|_|{|}|[|]|\(|\)|#|\+|-|\.|!)/
 
-  def escape_mention_handler("@" <> nickname = mention, buffer, _, _) do
+  @spec escape_mention_handler(String.t(), String.t(), any(), any()) :: String.t()
+  defp escape_mention_handler("@" <> nickname = mention, buffer, _, _) do
     case Actors.get_actor_by_name(nickname) do
       %Actor{} ->
         # escape markdown characters with `\\`
         # (we don't want something like @user__name to be parsed by markdown)
         String.replace(mention, @markdown_characters_regex, "\\\\\\1")
 
-      _ ->
+      nil ->
         buffer
     end
   end
 
+  @spec mention_handler(String.t(), String.t(), any(), map()) :: {String.t(), map()}
   def mention_handler("@" <> nickname, buffer, _opts, acc) do
     case Actors.get_actor_by_name(nickname) do
       #      %Actor{preferred_username: preferred_username} = actor ->
@@ -58,11 +60,12 @@ defmodule Mobilizon.Service.Formatter do
 
         {link, %{acc | mentions: MapSet.put(acc.mentions, {"@" <> nickname, actor})}}
 
-      _ ->
+      nil ->
         {buffer, acc}
     end
   end
 
+  @spec hashtag_handler(String.t(), String.t(), any(), map()) :: {String.t(), map()}
   def hashtag_handler("#" <> tag = tag_text, _buffer, _opts, acc) do
     tag = String.downcase(tag)
     url = "#{Endpoint.url()}/tag/#{tag}"
@@ -98,6 +101,7 @@ defmodule Mobilizon.Service.Formatter do
   @doc """
   Escapes a special characters in mention names.
   """
+  @spec mentions_escape(String.t(), Keyword.t()) :: String.t()
   def mentions_escape(text, options \\ []) do
     options =
       Keyword.merge(options,
@@ -109,6 +113,11 @@ defmodule Mobilizon.Service.Formatter do
     Linkify.link(text, options)
   end
 
+  @spec html_escape(
+          {text :: String.t(), mentions :: list(), hashtags :: list()},
+          type :: String.t()
+        ) :: {String.t(), list(), list()}
+  @spec html_escape(text :: String.t(), type :: String.t()) :: String.t()
   def html_escape({text, mentions, hashtags}, type) do
     {html_escape(text, type), mentions, hashtags}
   end
@@ -129,6 +138,7 @@ defmodule Mobilizon.Service.Formatter do
     |> Enum.join("")
   end
 
+  @spec truncate(String.t(), non_neg_integer(), String.t()) :: String.t()
   def truncate(text, max_length \\ 200, omission \\ "...") do
     # Remove trailing whitespace
     text = Regex.replace(~r/([^ \t\r\n])([ \t]+$)/u, text, "\\g{1}")
@@ -141,6 +151,7 @@ defmodule Mobilizon.Service.Formatter do
     end
   end
 
+  @spec linkify_opts :: Keyword.t()
   defp linkify_opts do
     Mobilizon.Config.get(__MODULE__) ++
       [
@@ -184,5 +195,6 @@ defmodule Mobilizon.Service.Formatter do
     |> (&" #{&1}").()
   end
 
+  @spec tag_text_strip(String.t()) :: String.t()
   defp tag_text_strip(tag), do: tag |> String.trim("#") |> String.downcase()
 end
diff --git a/lib/service/formatter/html.ex b/lib/service/formatter/html.ex
index 2e8bd5ee5..5544eeded 100644
--- a/lib/service/formatter/html.ex
+++ b/lib/service/formatter/html.ex
@@ -14,6 +14,7 @@ defmodule Mobilizon.Service.Formatter.HTML do
 
   def filter_tags(html), do: Sanitizer.scrub(html, DefaultScrubbler)
 
+  @spec strip_tags(String.t()) :: String.t() | no_return()
   def strip_tags(html) do
     case FastSanitize.strip_tags(html) do
       {:ok, html} ->
diff --git a/lib/service/geospatial/addok.ex b/lib/service/geospatial/addok.ex
index e289925ae..bf3d1f253 100644
--- a/lib/service/geospatial/addok.ex
+++ b/lib/service/geospatial/addok.ex
@@ -93,7 +93,8 @@ defmodule Mobilizon.Service.Geospatial.Addok do
     if is_nil(value), do: url, else: do_add_parameter(url, key, value)
   end
 
-  @spec do_add_parameter(String.t(), atom(), any()) :: String.t()
+  @spec do_add_parameter(String.t(), :coords | :type, %{lat: float, lon: float} | :administrative) ::
+          String.t()
   defp do_add_parameter(url, :coords, coords),
     do: "#{url}&lat=#{coords.lat}&lon=#{coords.lon}"
 
diff --git a/lib/service/geospatial/google_maps.ex b/lib/service/geospatial/google_maps.ex
index 3e145e6a7..0b50c5991 100644
--- a/lib/service/geospatial/google_maps.ex
+++ b/lib/service/geospatial/google_maps.ex
@@ -31,7 +31,7 @@ defmodule Mobilizon.Service.Geospatial.GoogleMaps do
   @doc """
   Google Maps implementation for `c:Mobilizon.Service.Geospatial.Provider.geocode/3`.
   """
-  @spec geocode(String.t(), keyword()) :: list(Address.t())
+  @spec geocode(String.t(), keyword()) :: list(Address.t()) | no_return
   def geocode(lon, lat, options \\ []) do
     url = build_url(:geocode, %{lon: lon, lat: lat}, options)
 
@@ -50,7 +50,7 @@ defmodule Mobilizon.Service.Geospatial.GoogleMaps do
   @doc """
   Google Maps implementation for `c:Mobilizon.Service.Geospatial.Provider.search/2`.
   """
-  @spec search(String.t(), keyword()) :: list(Address.t())
+  @spec search(String.t(), keyword()) :: list(Address.t()) | no_return
   def search(q, options \\ []) do
     url = build_url(:search, %{q: q}, options)
 
@@ -68,7 +68,7 @@ defmodule Mobilizon.Service.Geospatial.GoogleMaps do
     end
   end
 
-  @spec build_url(atom(), map(), list()) :: String.t()
+  @spec build_url(atom(), map(), list()) :: String.t() | no_return
   defp build_url(method, args, options) do
     limit = Keyword.get(options, :limit, 10)
     lang = Keyword.get(options, :lang, "en")
@@ -148,6 +148,7 @@ defmodule Mobilizon.Service.Geospatial.GoogleMaps do
     end
   end
 
+  @spec do_fetch_place_details(String.t() | nil, Keyword.t()) :: String.t() | no_return
   defp do_fetch_place_details(place_id, options) do
     url = build_url(:place_details, %{place_id: place_id}, options)
 
diff --git a/lib/service/geospatial/nominatim.ex b/lib/service/geospatial/nominatim.ex
index 9b8754d58..c32e7ebcd 100644
--- a/lib/service/geospatial/nominatim.ex
+++ b/lib/service/geospatial/nominatim.ex
@@ -143,15 +143,13 @@ defmodule Mobilizon.Service.Geospatial.Nominatim do
     if is_nil(value), do: url, else: do_add_parameter(url, key, value)
   end
 
-  @spec do_add_parameter(String.t(), atom(), any()) :: String.t()
+  @spec do_add_parameter(String.t(), :zoom | :country_code | :api_key, any()) :: String.t()
   defp do_add_parameter(url, :zoom, zoom),
     do: "#{url}&zoom=#{zoom}"
 
-  @spec do_add_parameter(String.t(), atom(), any()) :: String.t()
   defp do_add_parameter(url, :country_code, country_code),
     do: "#{url}&countrycodes=#{country_code}"
 
-  @spec do_add_parameter(String.t(), atom(), any()) :: String.t()
   defp do_add_parameter(url, :api_key, api_key),
     do: "#{url}&key=#{api_key}"
 
diff --git a/lib/service/geospatial/provider.ex b/lib/service/geospatial/provider.ex
index 4d9fadd11..47d92f7ba 100644
--- a/lib/service/geospatial/provider.ex
+++ b/lib/service/geospatial/provider.ex
@@ -42,7 +42,8 @@ defmodule Mobilizon.Service.Geospatial.Provider do
       iex> geocode(48.11, -1.77)
       %Address{}
   """
-  @callback geocode(longitude :: number, latitude :: number, options :: keyword) :: [Address.t()]
+  @callback geocode(longitude :: number, latitude :: number, options :: keyword) ::
+              [Address.t()] | {:error, atom()}
 
   @doc """
   Search for an address
@@ -62,12 +63,12 @@ defmodule Mobilizon.Service.Geospatial.Provider do
       iex> search("10 rue Jangot")
       %Address{}
   """
-  @callback search(address :: String.t(), options :: keyword) :: [Address.t()]
+  @callback search(address :: String.t(), options :: keyword) :: [Address.t()] | {:error, atom()}
 
   @doc """
   Returns a `Geo.Point` for given coordinates
   """
-  @spec coordinates([number], number) :: Geo.Point.t()
+  @spec coordinates([number | String.t()], number) :: Geo.Point.t() | nil
   def coordinates(coords, srid \\ 4326)
 
   def coordinates([x, y], srid) when is_number(x) and is_number(y) do
@@ -78,7 +79,6 @@ defmodule Mobilizon.Service.Geospatial.Provider do
     %Geo.Point{coordinates: {String.to_float(x), String.to_float(y)}, srid: srid}
   end
 
-  @spec coordinates(any) :: nil
   def coordinates(_, _), do: nil
 
   @spec endpoint(atom()) :: String.t()
diff --git a/lib/service/guards.ex b/lib/service/guards.ex
index e48e65076..0db60d099 100644
--- a/lib/service/guards.ex
+++ b/lib/service/guards.ex
@@ -3,7 +3,31 @@ defmodule Mobilizon.Service.Guards do
   Various guards
   """
 
-  defguard is_valid_string?(value) when is_binary(value) and value != ""
+  @doc """
+  Returns `true` if `term` is a valid string and not empty.
 
-  defguard is_valid_list?(value) when is_list(value) and length(value) > 0
+  ## Examples
+
+      iex> is_valid_string("one")
+      true
+      iex> is_valid_string("")
+      false
+      iex> is_valid_string(2)
+      false
+  """
+  defguard is_valid_string(term) when is_binary(term) and term != ""
+
+  @doc """
+  Returns `true` if `term` is a valid list and not empty.
+
+  ## Examples
+
+      iex> is_valid_list(["one"])
+      true
+      iex> is_valid_list([])
+      false
+      iex> is_valid_list("foo")
+      false
+  """
+  defguard is_valid_list(term) when is_list(term) and length(term) > 0
 end
diff --git a/lib/service/http/activity_pub.ex b/lib/service/http/activity_pub.ex
index db9683d9b..57e4ea832 100644
--- a/lib/service/http/activity_pub.ex
+++ b/lib/service/http/activity_pub.ex
@@ -9,6 +9,7 @@ defmodule Mobilizon.Service.HTTP.ActivityPub do
     recv_timeout: 20_000
   ]
 
+  @spec client(Keyword.t()) :: Tesla.Client.t()
   def client(options \\ []) do
     headers = Keyword.get(options, :headers, [])
     adapter = Application.get_env(:tesla, __MODULE__, [])[:adapter] || Tesla.Adapter.Hackney
@@ -27,10 +28,12 @@ defmodule Mobilizon.Service.HTTP.ActivityPub do
     Tesla.client(middleware, {adapter, opts})
   end
 
+  @spec get(Tesla.Client.t(), String.t()) :: Tesla.Env.t()
   def get(client, url) do
     Tesla.get(client, url)
   end
 
+  @spec post(Tesla.Client.t(), String.t(), map() | String.t()) :: Tesla.Env.t()
   def post(client, url, data) do
     Tesla.post(client, url, data)
   end
diff --git a/lib/service/language_detection/language_detection.ex b/lib/service/language_detection/language_detection.ex
index 96d50d498..87b8af0cb 100644
--- a/lib/service/language_detection/language_detection.ex
+++ b/lib/service/language_detection/language_detection.ex
@@ -64,7 +64,7 @@ defmodule Mobilizon.Service.LanguageDetection do
 
   def normalize(language) do
     case Cldr.AcceptLanguage.parse(language, Mobilizon.Cldr) do
-      {:ok, [{_, tag}]} ->
+      {:ok, [{_, %Cldr.LanguageTag{} = tag}]} ->
         tag.language
 
       _ ->
diff --git a/lib/service/metadata/comment.ex b/lib/service/metadata/comment.ex
index 99c893642..d36aebc07 100644
--- a/lib/service/metadata/comment.ex
+++ b/lib/service/metadata/comment.ex
@@ -2,7 +2,8 @@ defimpl Mobilizon.Service.Metadata, for: Mobilizon.Discussions.Comment do
   alias Phoenix.HTML.Tag
   alias Mobilizon.Discussions.Comment
 
-  def build_tags(%Comment{} = comment, _locale \\ "en") do
+  @spec build_tags(Comment.t(), String.t()) :: list(Phoenix.HTML.safe())
+  def build_tags(%Comment{deleted_at: nil} = comment, _locale) do
     [
       Tag.tag(:meta, property: "og:title", content: comment.actor.preferred_username),
       Tag.tag(:meta, property: "og:url", content: comment.url),
@@ -11,4 +12,6 @@ defimpl Mobilizon.Service.Metadata, for: Mobilizon.Discussions.Comment do
       Tag.tag(:meta, property: "twitter:card", content: "summary")
     ]
   end
+
+  def build_tags(%Comment{} = _comment, _locale), do: []
 end
diff --git a/lib/service/notifications/scheduler.ex b/lib/service/notifications/scheduler.ex
index f063a5969..5f942ff12 100644
--- a/lib/service/notifications/scheduler.ex
+++ b/lib/service/notifications/scheduler.ex
@@ -19,7 +19,7 @@ defmodule Mobilizon.Service.Notifications.Scheduler do
 
   require Logger
 
-  @spec trigger_notifications_for_participant(Participant.t()) :: {:ok, nil}
+  @spec trigger_notifications_for_participant(Participant.t()) :: {:ok, Oban.Job.t() | nil}
   def trigger_notifications_for_participant(%Participant{} = participant) do
     before_event_notification(participant)
     on_day_notification(participant)
@@ -27,6 +27,7 @@ defmodule Mobilizon.Service.Notifications.Scheduler do
     {:ok, nil}
   end
 
+  @spec before_event_notification(Participant.t()) :: {:ok, nil}
   def before_event_notification(%Participant{
         id: participant_id,
         event: %Event{begins_on: begins_on},
@@ -46,6 +47,7 @@ defmodule Mobilizon.Service.Notifications.Scheduler do
 
   def before_event_notification(_), do: {:ok, nil}
 
+  @spec on_day_notification(Participant.t()) :: {:ok, Oban.Job.t() | nil | String.t()}
   def on_day_notification(%Participant{
         event: %Event{begins_on: begins_on},
         actor: %Actor{user_id: user_id}
@@ -90,6 +92,7 @@ defmodule Mobilizon.Service.Notifications.Scheduler do
 
   def on_day_notification(_), do: {:ok, nil}
 
+  @spec weekly_notification(Participant.t()) :: {:ok, Oban.Job.t() | nil | String.t()}
   def weekly_notification(%Participant{
         event: %Event{begins_on: begins_on},
         actor: %Actor{user_id: user_id}
@@ -144,6 +147,7 @@ defmodule Mobilizon.Service.Notifications.Scheduler do
 
   def weekly_notification(_), do: {:ok, nil}
 
+  @spec pending_participation_notification(Event.t(), Keyword.t()) :: {:ok, Oban.Job.t() | nil}
   def pending_participation_notification(event, options \\ [])
 
   def pending_participation_notification(
diff --git a/lib/service/notifier/email.ex b/lib/service/notifier/email.ex
index c12f6106d..58388dd9d 100644
--- a/lib/service/notifier/email.ex
+++ b/lib/service/notifier/email.ex
@@ -12,7 +12,7 @@ defmodule Mobilizon.Service.Notifier.Email do
 
   import Mobilizon.Service.DateTime,
     only: [
-      is_delay_ok_since_last_notification_sent: 1
+      is_delay_ok_since_last_notification_sent?: 1
     ]
 
   require Logger
@@ -116,7 +116,7 @@ defmodule Mobilizon.Service.Notifier.Email do
 
   # Delay ok since last notification
   defp match_group_notifications_setting(:one_hour, _, %DateTime{} = last_notification_sent, _) do
-    is_delay_ok_since_last_notification_sent(last_notification_sent)
+    is_delay_ok_since_last_notification_sent?(last_notification_sent)
   end
 
   # This is a recap
diff --git a/lib/service/notifier/notifier.ex b/lib/service/notifier/notifier.ex
index 9c9140ae3..a4d9fd9ac 100644
--- a/lib/service/notifier/notifier.ex
+++ b/lib/service/notifier/notifier.ex
@@ -18,6 +18,7 @@ defmodule Mobilizon.Service.Notifier do
 
   @callback send(User.t(), list(Activity.t()), Keyword.t()) :: {:ok, any()} | {:error, String.t()}
 
+  @spec notify(User.t(), Activity.t(), Keyword.t()) :: :ok
   def notify(%User{} = user, %Activity{} = activity, opts \\ []) do
     Enum.each(providers(opts), & &1.send(user, activity, opts))
   end
diff --git a/lib/service/notifier/push.ex b/lib/service/notifier/push.ex
index 36a0cfc9d..4fc7caac3 100644
--- a/lib/service/notifier/push.ex
+++ b/lib/service/notifier/push.ex
@@ -66,12 +66,14 @@ defmodule Mobilizon.Service.Notifier.Push do
     Map.get(@default_behavior, activity_setting, false)
   end
 
+  @spec send_subscription(Activity.t(), any, Keyword.t()) :: no_return
   defp send_subscription(activity, subscription, options) do
     activity
     |> payload(options)
     |> WebPushEncryption.send_web_push(subscription)
   end
 
+  @spec payload(Activity.t(), Keyword.t()) :: String.t()
   defp payload(%Activity{} = activity, options) do
     activity
     |> Utils.add_activity_object()
diff --git a/lib/service/rich_media/parser.ex b/lib/service/rich_media/parser.ex
index 4556d8299..0a6e3691c 100644
--- a/lib/service/rich_media/parser.ex
+++ b/lib/service/rich_media/parser.ex
@@ -192,7 +192,7 @@ defmodule Mobilizon.Service.RichMedia.Parser do
     end
   end
 
-  @spec maybe_parse(String.t()) :: {:halt, map()} | {:cont, map()}
+  @spec maybe_parse(String.t()) :: map()
   defp maybe_parse(html) do
     Enum.reduce_while(parsers(), %{}, fn parser, acc ->
       case parser.parse(html, acc) do
@@ -286,7 +286,7 @@ defmodule Mobilizon.Service.RichMedia.Parser do
     end
   end
 
-  @spec check_remote_picture_path(map()) :: map()
+  @spec check_remote_picture_path(map()) :: {:ok, map()}
   defp check_remote_picture_path(%{image_remote_url: image_remote_url, url: url} = data)
        when is_binary(image_remote_url) and is_binary(url) do
     Logger.debug("Checking image_remote_url #{image_remote_url}")
diff --git a/lib/service/rich_media/parsers/meta_tags_parser.ex b/lib/service/rich_media/parsers/meta_tags_parser.ex
index 768baffa2..e552ddd9f 100644
--- a/lib/service/rich_media/parsers/meta_tags_parser.ex
+++ b/lib/service/rich_media/parsers/meta_tags_parser.ex
@@ -8,6 +8,8 @@ defmodule Mobilizon.Service.RichMedia.Parsers.MetaTagsParser do
   Module to parse meta tags data in HTML pages
   """
 
+  @spec parse(String.t(), map(), String.t(), String.t(), atom(), atom(), list(atom())) ::
+          {:ok, map()} | {:error, String.t()}
   def parse(
         html,
         data,
@@ -35,10 +37,12 @@ defmodule Mobilizon.Service.RichMedia.Parsers.MetaTagsParser do
     end
   end
 
+  @spec get_elements(String.t(), atom(), String.t()) :: Floki.html_tree()
   defp get_elements(html, key_name, prefix) do
     html |> Floki.parse_document!() |> Floki.find("meta[#{to_string(key_name)}^='#{prefix}:']")
   end
 
+  @spec normalize_attributes(Floki.html_node(), String.t(), atom(), atom(), list(atom())) :: map()
   defp normalize_attributes(html_node, prefix, key_name, value_name, allowed_attributes) do
     {_tag, attributes, _children} = html_node
 
@@ -55,6 +59,7 @@ defmodule Mobilizon.Service.RichMedia.Parsers.MetaTagsParser do
     end
   end
 
+  @spec maybe_put_title(map(), String.t()) :: map()
   defp maybe_put_title(%{title: _} = meta, _), do: meta
 
   defp maybe_put_title(meta, html) when meta != %{} do
@@ -66,6 +71,7 @@ defmodule Mobilizon.Service.RichMedia.Parsers.MetaTagsParser do
 
   defp maybe_put_title(meta, _), do: meta
 
+  @spec maybe_put_description(map(), String.t()) :: map()
   defp maybe_put_description(%{description: _} = meta, _), do: meta
 
   defp maybe_put_description(meta, html) when meta != %{} do
@@ -73,9 +79,6 @@ defmodule Mobilizon.Service.RichMedia.Parsers.MetaTagsParser do
       "" ->
         meta
 
-      descriptions when is_list(descriptions) and length(descriptions) > 0 ->
-        Map.put_new(meta, :description, hd(descriptions))
-
       description ->
         Map.put_new(meta, :description, description)
     end
@@ -99,8 +102,8 @@ defmodule Mobilizon.Service.RichMedia.Parsers.MetaTagsParser do
     with {:ok, document} <- Floki.parse_document(html),
          elem when not is_nil(elem) <-
            document |> Floki.find("html head meta[name='description']") |> List.first(),
-         description when is_binary(description) <- Floki.attribute(elem, "content") do
-      description
+         [_ | _] = descriptions <- Floki.attribute(elem, "content") do
+      hd(descriptions)
     else
       _ -> ""
     end
diff --git a/lib/service/rich_media/parsers/oembed_parser.ex b/lib/service/rich_media/parsers/oembed_parser.ex
index 567277472..bebfdec52 100644
--- a/lib/service/rich_media/parsers/oembed_parser.ex
+++ b/lib/service/rich_media/parsers/oembed_parser.ex
@@ -15,6 +15,7 @@ defmodule Mobilizon.Service.RichMedia.Parsers.OEmbed do
     ssl: [{:versions, [:"tlsv1.2"]}]
   ]
 
+  @spec parse(String.t(), map()) :: {:ok, map()} | {:error, String.t()}
   def parse(html, _data) do
     Logger.debug("Using OEmbed parser")
 
diff --git a/lib/service/rich_media/parsers/ogp.ex b/lib/service/rich_media/parsers/ogp.ex
index 531f79bf4..07c89619c 100644
--- a/lib/service/rich_media/parsers/ogp.ex
+++ b/lib/service/rich_media/parsers/ogp.ex
@@ -30,6 +30,7 @@ defmodule Mobilizon.Service.RichMedia.Parsers.OGP do
     :"image:alt"
   ]
 
+  @spec parse(String.t(), map()) :: {:ok, map()}
   def parse(html, data) do
     Logger.debug("Using OpenGraph card parser")
 
@@ -49,6 +50,7 @@ defmodule Mobilizon.Service.RichMedia.Parsers.OGP do
     end
   end
 
+  @spec transform_tags(map()) :: map()
   defp transform_tags(data) do
     data
     |> Enum.reject(fn {_, v} -> is_nil(v) end)
diff --git a/lib/service/site_map.ex b/lib/service/site_map.ex
index b17ccc75d..d25820f0c 100644
--- a/lib/service/site_map.ex
+++ b/lib/service/site_map.ex
@@ -10,6 +10,7 @@ defmodule Mobilizon.Service.SiteMap do
 
   @default_static_frequency :monthly
 
+  @spec generate_sitemap :: {:ok, :ok}
   def generate_sitemap do
     static_routes = [
       {Routes.page_url(Endpoint, :index, []), :daily},
@@ -60,6 +61,7 @@ defmodule Mobilizon.Service.SiteMap do
   end
 
   # Sometimes we use naive datetimes
+  @spec check_date_time(any()) :: DateTime.t() | nil
   defp check_date_time(%NaiveDateTime{} = datetime), do: DateTime.from_naive!(datetime, "Etc/UTC")
   defp check_date_time(%DateTime{} = datetime), do: datetime
   defp check_date_time(_), do: nil
diff --git a/lib/service/statistics/statistics.ex b/lib/service/statistics/statistics.ex
index 99494726d..6d3e21363 100644
--- a/lib/service/statistics/statistics.ex
+++ b/lib/service/statistics/statistics.ex
@@ -6,6 +6,7 @@ defmodule Mobilizon.Service.Statistics do
   alias Mobilizon.{Actors, Discussions, Events, Users}
   alias Mobilizon.Federation.ActivityPub.Relay
 
+  @spec get_cached_value(String.t()) :: any() | nil
   def get_cached_value(key) do
     case Cachex.fetch(:statistics, key, fn key ->
            case create_cache(key) do
diff --git a/lib/service/workers/activity_builder.ex b/lib/service/workers/activity_builder.ex
index 2d9a49c32..0dcc2a238 100644
--- a/lib/service/workers/activity_builder.ex
+++ b/lib/service/workers/activity_builder.ex
@@ -12,15 +12,22 @@ defmodule Mobilizon.Service.Workers.ActivityBuilder do
   use Mobilizon.Service.Workers.Helper, queue: "activity"
 
   @impl Oban.Worker
+  @spec perform(Job.t()) :: {:ok, Activity.t()} | {:error, Ecto.Changeset.t()}
   def perform(%Job{args: args}) do
-    with {"build_activity", args} <- Map.pop(args, "op"),
-         {:ok, %Activity{} = activity} <- build_activity(args),
-         preloaded_activity <- Activities.preload_activity(activity) do
-      notify_activity(preloaded_activity)
+    {"build_activity", args} = Map.pop(args, "op")
+
+    case build_activity(args) do
+      {:ok, %Activity{} = activity} ->
+        activity
+        |> Activities.preload_activity()
+        |> notify_activity()
+
+      {:error, %Ecto.Changeset{} = err} ->
+        {:error, err}
     end
   end
 
-  @spec build_activity(map()) :: {:ok, Activity.t()}
+  @spec build_activity(map()) :: {:ok, Activity.t()} | {:error, Ecto.Changeset.t()}
   def build_activity(args) do
     Activities.create_activity(args)
   end
diff --git a/lib/service/workers/background.ex b/lib/service/workers/background.ex
index a9e93504e..6f5175b9d 100644
--- a/lib/service/workers/background.ex
+++ b/lib/service/workers/background.ex
@@ -6,15 +6,28 @@ defmodule Mobilizon.Service.Workers.Background do
   alias Mobilizon.Actors
   alias Mobilizon.Actors.Actor
   alias Mobilizon.Federation.ActivityPub.Refresher
+  alias Mobilizon.Service.ActorSuspension
 
   use Mobilizon.Service.Workers.Helper, queue: "background"
 
   @impl Oban.Worker
+  @spec perform(Job.t()) ::
+          {:ok, Actor.t()}
+          | {:error,
+             :actor_not_found | :bad_option_value_for_reserve_username | Ecto.Changeset.t()}
   def perform(%Job{args: %{"op" => "delete_actor", "actor_id" => actor_id} = args}) do
-    with reserve_username when is_boolean(reserve_username) <-
-           Map.get(args, "reserve_username", true),
-         %Actor{} = actor <- Actors.get_actor(actor_id) do
-      Actors.perform(:delete_actor, actor, reserve_username: reserve_username)
+    case Map.get(args, "reserve_username", true) do
+      reserve_username when is_boolean(reserve_username) ->
+        case Actors.get_actor(actor_id) do
+          %Actor{} = actor ->
+            ActorSuspension.suspend_actor(actor, reserve_username: reserve_username)
+
+          nil ->
+            {:error, :actor_not_found}
+        end
+
+      _ ->
+        {:error, :bad_option_value_for_reserve_username}
     end
   end
 
diff --git a/lib/service/workers/clean_orphan_media_worker.ex b/lib/service/workers/clean_orphan_media_worker.ex
index 566120b24..c56c4a1ff 100644
--- a/lib/service/workers/clean_orphan_media_worker.ex
+++ b/lib/service/workers/clean_orphan_media_worker.ex
@@ -4,11 +4,12 @@ defmodule Mobilizon.Service.Workers.CleanOrphanMediaWorker do
   """
 
   use Oban.Worker, queue: "background"
+  alias Mobilizon.Config
   alias Mobilizon.Service.CleanOrphanMedia
 
   @impl Oban.Worker
   def perform(%Job{}) do
-    if Mobilizon.Config.get!([:instance, :remove_orphan_uploads]) and should_perform?() do
+    if Keyword.get(Config.instance_config(), :remove_orphan_uploads, false) and should_perform?() do
       CleanOrphanMedia.clean()
     end
   end
@@ -17,8 +18,7 @@ defmodule Mobilizon.Service.Workers.CleanOrphanMediaWorker do
   defp should_perform? do
     case Cachex.get(:key_value, "last_media_cleanup") do
       {:ok, %DateTime{} = last_media_cleanup} ->
-        default_grace_period =
-          Mobilizon.Config.get([:instance, :orphan_upload_grace_period_hours], 48)
+        default_grace_period = Config.get([:instance, :orphan_upload_grace_period_hours], 48)
 
         DateTime.compare(
           last_media_cleanup,
diff --git a/lib/service/workers/clean_suspended_actors.ex b/lib/service/workers/clean_suspended_actors.ex
new file mode 100644
index 000000000..44b74a4db
--- /dev/null
+++ b/lib/service/workers/clean_suspended_actors.ex
@@ -0,0 +1,18 @@
+defmodule Mobilizon.Service.Workers.CleanSuspendedActors do
+  @moduledoc """
+  Worker to clean unattached media
+  """
+
+  use Oban.Worker, queue: "background"
+  alias Mobilizon.Actors
+  alias Mobilizon.Service.ActorSuspension
+
+  @suspention_days 30
+
+  @impl Oban.Worker
+  def perform(%Job{}) do
+    [suspension: @suspention_days]
+    |> Actors.list_suspended_actors_to_purge()
+    |> Enum.each(&ActorSuspension.suspend_actor(&1, reserve_username: true, suspension: true))
+  end
+end
diff --git a/lib/service/workers/helper.ex b/lib/service/workers/helper.ex
index 53232563e..28bb0d7b8 100644
--- a/lib/service/workers/helper.ex
+++ b/lib/service/workers/helper.ex
@@ -11,6 +11,7 @@ defmodule Mobilizon.Service.Workers.Helper do
   alias Mobilizon.Config
   alias Mobilizon.Service.Workers.Helper
 
+  @spec worker_args(atom()) :: Keyword.t()
   def worker_args(queue) do
     case Config.get([:workers, :retries, queue]) do
       nil -> []
@@ -18,6 +19,7 @@ defmodule Mobilizon.Service.Workers.Helper do
     end
   end
 
+  @spec sidekiq_backoff(integer, integer, integer) :: integer
   def sidekiq_backoff(attempt, pow \\ 4, base_backoff \\ 15) do
     backoff =
       :math.pow(attempt, pow) +
@@ -39,6 +41,8 @@ defmodule Mobilizon.Service.Workers.Helper do
 
       alias Oban.Job
 
+      @spec enqueue(String.t(), map(), Keyword.t()) ::
+              {:ok, Job.t()} | {:error, Ecto.Changeset.t()}
       def enqueue(operation, params, worker_args \\ []) do
         params = Map.merge(%{"op" => operation}, params)
         queue_atom = String.to_existing_atom(unquote(queue))
diff --git a/lib/service/workers/legacy_notifier_builder.ex b/lib/service/workers/legacy_notifier_builder.ex
index 9a6ef1391..86b8bafc4 100644
--- a/lib/service/workers/legacy_notifier_builder.ex
+++ b/lib/service/workers/legacy_notifier_builder.ex
@@ -13,17 +13,16 @@ defmodule Mobilizon.Service.Workers.LegacyNotifierBuilder do
 
   @impl Oban.Worker
   def perform(%Job{args: args}) do
-    with {"legacy_notify", args} <- Map.pop(args, "op") do
-      activity = build_activity(args)
+    {"legacy_notify", args} = Map.pop(args, "op")
+    activity = build_activity(args)
 
-      if args["subject"] == "participation_event_comment" do
-        notify_anonymous_participants(get_in(args, ["subject_params", "event_id"]), activity)
-      end
-
-      args
-      |> users_to_notify(author_id: args["author_id"], group_id: Map.get(args, "group_id"))
-      |> Enum.each(&Notifier.notify(&1, activity, single_activity: true))
+    if args["subject"] == "participation_event_comment" do
+      notify_anonymous_participants(get_in(args, ["subject_params", "event_id"]), activity)
     end
+
+    args
+    |> users_to_notify(author_id: args["author_id"], group_id: Map.get(args, "group_id"))
+    |> Enum.each(&Notifier.notify(&1, activity, single_activity: true))
   end
 
   defp build_activity(args) do
@@ -105,8 +104,8 @@ defmodule Mobilizon.Service.Workers.LegacyNotifierBuilder do
       is_map(metadata) && is_binary(metadata.email)
     end)
     |> Enum.map(fn %Participant{metadata: metadata} -> metadata end)
-    |> Enum.map(fn metadata ->
-      Notifier.Email.send_anonymous_activity(metadata.email, activity,
+    |> Enum.map(fn %{email: email} = metadata ->
+      Notifier.Email.send_anonymous_activity(email, activity,
         locale: Map.get(metadata, :locale, "en")
       )
     end)
diff --git a/lib/service/workers/send_activity_recap_worker.ex b/lib/service/workers/send_activity_recap_worker.ex
index c1a52a262..8b87cbb95 100644
--- a/lib/service/workers/send_activity_recap_worker.ex
+++ b/lib/service/workers/send_activity_recap_worker.ex
@@ -13,9 +13,9 @@ defmodule Mobilizon.Service.Workers.SendActivityRecapWorker do
 
   import Mobilizon.Service.DateTime,
     only: [
-      is_between_hours: 1,
-      is_between_hours_on_first_day: 1,
-      is_delay_ok_since_last_notification_sent: 1
+      is_between_hours?: 1,
+      is_between_hours_on_first_day?: 1,
+      is_delay_ok_since_last_notification_sent?: 1
     ]
 
   @impl Oban.Worker
@@ -86,7 +86,7 @@ defmodule Mobilizon.Service.Workers.SendActivityRecapWorker do
            group_notifications: :one_hour
          }
        }) do
-    is_delay_ok_since_last_notification_sent(last_notification_sent)
+    is_delay_ok_since_last_notification_sent?(last_notification_sent)
   end
 
   # If we're between notification hours
@@ -96,7 +96,7 @@ defmodule Mobilizon.Service.Workers.SendActivityRecapWorker do
            timezone: timezone
          }
        }) do
-    is_between_hours(timezone: timezone || "Etc/UTC")
+    is_between_hours?(timezone: timezone || "Etc/UTC")
   end
 
   # If we're on the first day of the week between notification hours
@@ -107,6 +107,6 @@ defmodule Mobilizon.Service.Workers.SendActivityRecapWorker do
            timezone: timezone
          }
        }) do
-    is_between_hours_on_first_day(timezone: timezone || "Etc/UTC", locale: locale)
+    is_between_hours_on_first_day?(timezone: timezone || "Etc/UTC", locale: locale)
   end
 end
diff --git a/lib/web/auth/context.ex b/lib/web/auth/context.ex
index 68a1c4ffe..dbf216c9f 100644
--- a/lib/web/auth/context.ex
+++ b/lib/web/auth/context.ex
@@ -9,24 +9,42 @@ defmodule Mobilizon.Web.Auth.Context do
   alias Mobilizon.Service.ErrorReporting.Sentry, as: SentryAdapter
   alias Mobilizon.Users.User
 
+  @spec init(Plug.opts()) :: Plug.opts()
   def init(opts) do
     opts
   end
 
+  @spec call(Plug.Conn.t(), Plug.opts()) :: Plug.Conn.t()
   def call(%{assigns: %{ip: _}} = conn, _opts), do: conn
 
   def call(conn, _opts) do
     set_user_information_in_context(conn)
   end
 
-  def set_user_information_in_context(conn) do
+  @spec set_user_information_in_context(Plug.Conn.t()) :: Plug.Conn.t()
+  defp set_user_information_in_context(conn) do
     context = %{ip: conn.remote_ip |> :inet.ntoa() |> to_string()}
 
+    user_agent = conn |> Plug.Conn.get_req_header("user-agent") |> List.first()
+
     {conn, context} =
       case Guardian.Plug.current_resource(conn) do
         %User{id: user_id, email: user_email} = user ->
           if SentryAdapter.enabled?() do
             Sentry.Context.set_user_context(%{id: user_id, name: user_email})
+
+            Sentry.Context.set_request_context(%{
+              url: Plug.Conn.request_url(conn),
+              method: conn.method,
+              headers: %{
+                "User-Agent": user_agent
+              },
+              query_string: conn.query_string,
+              env: %{
+                REQUEST_ID: conn |> Plug.Conn.get_resp_header("x-request-id") |> List.first(),
+                SERVER_NAME: conn.host
+              }
+            })
           end
 
           context = Map.put(context, :current_user, user)
@@ -37,14 +55,7 @@ defmodule Mobilizon.Web.Auth.Context do
           {conn, context}
       end
 
-    context =
-      case get_req_header(conn, "user-agent") do
-        [user_agent | _] ->
-          Map.put(context, :user_agent, user_agent)
-
-        _ ->
-          context
-      end
+    context = if is_nil(user_agent), do: context, else: Map.put(context, :user_agent, user_agent)
 
     put_private(conn, :absinthe, %{context: context})
   end
diff --git a/lib/web/auth/error_handler.ex b/lib/web/auth/error_handler.ex
index edf760bb8..8a27a6e5c 100644
--- a/lib/web/auth/error_handler.ex
+++ b/lib/web/auth/error_handler.ex
@@ -5,6 +5,7 @@ defmodule Mobilizon.Web.Auth.ErrorHandler do
   import Plug.Conn
 
   # sobelow_skip ["XSS.SendResp"]
+  @spec auth_error(Plug.Conn.t(), any(), any()) :: Plug.Conn.t()
   def auth_error(conn, {type, _reason}, _opts) do
     body = Jason.encode!(%{message: to_string(type)})
     send_resp(conn, 401, body)
diff --git a/lib/web/auth/guardian.ex b/lib/web/auth/guardian.ex
index 8797dd06c..9dd50ee65 100644
--- a/lib/web/auth/guardian.ex
+++ b/lib/web/auth/guardian.ex
@@ -15,6 +15,7 @@ defmodule Mobilizon.Web.Auth.Guardian do
 
   require Logger
 
+  @spec subject_for_token(any(), any()) :: {:ok, String.t()} | {:error, :unknown_resource}
   def subject_for_token(%User{} = user, _claims) do
     {:ok, "User:" <> to_string(user.id)}
   end
@@ -23,6 +24,8 @@ defmodule Mobilizon.Web.Auth.Guardian do
     {:error, :unknown_resource}
   end
 
+  @spec resource_from_claims(any) ::
+          {:error, :invalid_id | :no_result | :no_claims} | {:ok, Mobilizon.Users.User.t()}
   def resource_from_claims(%{"sub" => "User:" <> uid_str}) do
     Logger.debug(fn -> "Receiving claim for user #{uid_str}" end)
 
@@ -40,33 +43,38 @@ defmodule Mobilizon.Web.Auth.Guardian do
   end
 
   def resource_from_claims(_) do
-    {:error, :reason_for_error}
+    {:error, :no_claims}
   end
 
+  @spec after_encode_and_sign(any(), any(), any(), any()) :: {:ok, String.t()}
   def after_encode_and_sign(resource, claims, token, _options) do
     with {:ok, _} <- Guardian.DB.after_encode_and_sign(resource, claims["typ"], claims, token) do
       {:ok, token}
     end
   end
 
+  @spec on_verify(any(), any(), any()) :: {:ok, any()}
   def on_verify(claims, token, _options) do
     with {:ok, _} <- Guardian.DB.on_verify(claims, token) do
       {:ok, claims}
     end
   end
 
+  @spec on_revoke(any(), any(), any()) :: {:ok, any()}
   def on_revoke(claims, token, _options) do
     with {:ok, _} <- Guardian.DB.on_revoke(claims, token) do
       {:ok, claims}
     end
   end
 
+  @spec on_refresh({any(), any()}, {any(), any()}, any()) :: {:ok, {any(), any()}, {any(), any()}}
   def on_refresh({old_token, old_claims}, {new_token, new_claims}, _options) do
     with {:ok, _, _} <- Guardian.DB.on_refresh({old_token, old_claims}, {new_token, new_claims}) do
       {:ok, {old_token, old_claims}, {new_token, new_claims}}
     end
   end
 
+  @spec on_exchange(any(), any(), any()) :: {:ok, {any(), any()}, {any(), any()}}
   def on_exchange(old_stuff, new_stuff, options), do: on_refresh(old_stuff, new_stuff, options)
 
   #  def build_claims(claims, _resource, opts) do
diff --git a/lib/web/cache/activity_pub.ex b/lib/web/cache/activity_pub.ex
index d31b8cc2e..d19b70a0a 100644
--- a/lib/web/cache/activity_pub.ex
+++ b/lib/web/cache/activity_pub.ex
@@ -21,24 +21,27 @@ defmodule Mobilizon.Web.Cache.ActivityPub do
   Gets a actor by username and eventually domain.
   """
   @spec get_actor_by_name(String.t()) ::
-          {:commit, Actor.t()} | {:ignore, nil}
+          {:commit, ActorModel.t()} | {:ignore, nil}
   def get_actor_by_name(name) do
-    Cachex.fetch(@cache, "actor_" <> name, fn "actor_" <> name ->
-      case Actor.find_or_make_actor_from_nickname(name) do
-        {:ok, %ActorModel{} = actor} ->
-          {:commit, actor}
+    Cachex.fetch(@cache, "actor_" <> name, &do_get_actor/1)
+  end
 
-        nil ->
-          {:ignore, nil}
-      end
-    end)
+  @spec do_get_actor(String.t()) :: {:commit, Actor.t()} | {:ignore, nil}
+  defp do_get_actor("actor_" <> name) do
+    case Actor.find_or_make_actor_from_nickname(name) do
+      {:ok, %ActorModel{} = actor} ->
+        {:commit, actor}
+
+      {:error, _err} ->
+        {:ignore, nil}
+    end
   end
 
   @doc """
   Gets a local actor by username.
   """
   @spec get_local_actor_by_name(String.t()) ::
-          {:commit, Actor.t()} | {:ignore, nil}
+          {:commit, ActorModel.t()} | {:ignore, nil}
   def get_local_actor_by_name(name) do
     Cachex.fetch(@cache, "local_actor_" <> name, fn "local_actor_" <> name ->
       case Actors.get_local_actor_by_name(name) do
@@ -179,7 +182,7 @@ defmodule Mobilizon.Web.Cache.ActivityPub do
   Gets a member by its UUID, with all associations loaded.
   """
   @spec get_member_by_uuid_with_preload(String.t()) ::
-          {:commit, Todo.t()} | {:ignore, nil}
+          {:commit, Member.t()} | {:ignore, nil}
   def get_member_by_uuid_with_preload(uuid) do
     Cachex.fetch(@cache, "member_" <> uuid, fn "member_" <> uuid ->
       case Actors.get_member(uuid) do
@@ -195,7 +198,7 @@ defmodule Mobilizon.Web.Cache.ActivityPub do
   @doc """
   Gets a relay.
   """
-  @spec get_relay :: {:commit, Actor.t()} | {:ignore, nil}
+  @spec get_relay :: {:commit, ActorModel.t()} | {:ignore, nil}
   def get_relay do
     Cachex.fetch(@cache, "relay_actor", &Relay.get_actor/0)
   end
diff --git a/lib/web/cache/cache.ex b/lib/web/cache/cache.ex
index 5afcd4690..d90007a05 100644
--- a/lib/web/cache/cache.ex
+++ b/lib/web/cache/cache.ex
@@ -3,29 +3,48 @@ defmodule Mobilizon.Web.Cache do
   Facade module which provides access to all cached data.
   """
 
-  alias Mobilizon.Actors.Actor
-
+  alias Mobilizon.Actors.{Actor, Member}
+  alias Mobilizon.Discussions.{Comment, Discussion}
+  alias Mobilizon.Events.Event
+  alias Mobilizon.Posts.Post
+  alias Mobilizon.Resources.Resource
+  alias Mobilizon.Todos.{Todo, TodoList}
   alias Mobilizon.Web.Cache.ActivityPub
+  import Mobilizon.Service.Guards, only: [is_valid_string: 1]
 
   @caches [:activity_pub, :feed, :ics]
 
+  @type local_actor :: %Actor{domain: nil}
+
   @doc """
-  Clears all caches for an actor.
+  Clears all caches for a local actor.
   """
-  @spec clear_cache(Actor.t()) :: {:ok, true}
-  def clear_cache(%Actor{preferred_username: preferred_username, domain: nil}) do
+  @spec clear_cache(%Actor{domain: nil, preferred_username: String.t()}) :: :ok
+  def clear_cache(%Actor{preferred_username: preferred_username, domain: nil})
+      when is_valid_string(preferred_username) do
     Enum.each(@caches, &Cachex.del(&1, "actor_" <> preferred_username))
   end
 
+  @spec get_actor_by_name(binary) :: {:commit, Actor.t()} | {:ignore, nil}
   defdelegate get_actor_by_name(name), to: ActivityPub
+  @spec get_local_actor_by_name(binary) :: {:commit, Actor.t()} | {:ignore, nil}
   defdelegate get_local_actor_by_name(name), to: ActivityPub
+  @spec get_public_event_by_uuid_with_preload(binary) :: {:commit, Event.t()} | {:ignore, nil}
   defdelegate get_public_event_by_uuid_with_preload(uuid), to: ActivityPub
+  @spec get_comment_by_uuid_with_preload(binary) :: {:commit, Comment.t()} | {:ignore, nil}
   defdelegate get_comment_by_uuid_with_preload(uuid), to: ActivityPub
+  @spec get_resource_by_uuid_with_preload(binary) :: {:commit, Resource.t()} | {:ignore, nil}
   defdelegate get_resource_by_uuid_with_preload(uuid), to: ActivityPub
+  @spec get_todo_list_by_uuid_with_preload(binary) :: {:commit, TodoList.t()} | {:ignore, nil}
   defdelegate get_todo_list_by_uuid_with_preload(uuid), to: ActivityPub
+  @spec get_todo_by_uuid_with_preload(binary) :: {:commit, Todo.t()} | {:ignore, nil}
   defdelegate get_todo_by_uuid_with_preload(uuid), to: ActivityPub
+  @spec get_member_by_uuid_with_preload(binary) :: {:commit, Member.t()} | {:ignore, nil}
   defdelegate get_member_by_uuid_with_preload(uuid), to: ActivityPub
+  @spec get_post_by_slug_with_preload(binary) :: {:commit, Post.t()} | {:ignore, nil}
   defdelegate get_post_by_slug_with_preload(slug), to: ActivityPub
+  @spec get_discussion_by_slug_with_preload(binary) :: {:commit, Discussion.t()} | {:ignore, nil}
   defdelegate get_discussion_by_slug_with_preload(slug), to: ActivityPub
+  @spec get_relay :: {:commit, Actor.t()} | {:ignore, nil}
   defdelegate get_relay, to: ActivityPub
 end
diff --git a/lib/web/channels/graphql_socket.ex b/lib/web/channels/graphql_socket.ex
index b694416a1..0bf0e7244 100644
--- a/lib/web/channels/graphql_socket.ex
+++ b/lib/web/channels/graphql_socket.ex
@@ -6,6 +6,7 @@ defmodule Mobilizon.Web.GraphQLSocket do
 
   alias Mobilizon.Users.User
 
+  @spec connect(map, Phoenix.Socket.t()) :: {:ok, Phoenix.Socket.t()} | :error
   def connect(%{"token" => token}, socket) do
     with {:ok, authed_socket} <-
            Guardian.Phoenix.Socket.authenticate(socket, Mobilizon.Web.Auth.Guardian, token),
@@ -26,5 +27,6 @@ defmodule Mobilizon.Web.GraphQLSocket do
 
   def connect(_args, _socket), do: :error
 
+  @spec id(any) :: nil
   def id(_socket), do: nil
 end
diff --git a/lib/web/controllers/activity_pub_controller.ex b/lib/web/controllers/activity_pub_controller.ex
index d8609359a..296d774db 100644
--- a/lib/web/controllers/activity_pub_controller.ex
+++ b/lib/web/controllers/activity_pub_controller.ex
@@ -24,6 +24,7 @@ defmodule Mobilizon.Web.ActivityPubController do
   plug(Mobilizon.Web.Plugs.Federating when action in [:inbox, :relay])
   plug(:relay_active? when action in [:relay])
 
+  @spec relay_active?(Plug.Conn.t(), any()) :: Plug.Conn.t()
   def relay_active?(conn, _) do
     if Config.get([:instance, :allow_relay]) do
       conn
@@ -35,34 +36,42 @@ defmodule Mobilizon.Web.ActivityPubController do
     end
   end
 
+  @spec following(Plug.Conn.t(), map()) :: Plug.Conn.t()
   def following(conn, args) do
     actor_collection(conn, "following", args)
   end
 
+  @spec followers(Plug.Conn.t(), map()) :: Plug.Conn.t()
   def followers(conn, args) do
     actor_collection(conn, "followers", args)
   end
 
+  @spec members(Plug.Conn.t(), map()) :: Plug.Conn.t()
   def members(conn, args) do
     actor_collection(conn, "members", args)
   end
 
+  @spec resources(Plug.Conn.t(), map()) :: Plug.Conn.t()
   def resources(conn, args) do
     actor_collection(conn, "resources", args)
   end
 
+  @spec posts(Plug.Conn.t(), map()) :: Plug.Conn.t()
   def posts(conn, args) do
     actor_collection(conn, "posts", args)
   end
 
+  @spec todos(Plug.Conn.t(), map()) :: Plug.Conn.t()
   def todos(conn, args) do
     actor_collection(conn, "todos", args)
   end
 
+  @spec events(Plug.Conn.t(), map()) :: Plug.Conn.t()
   def events(conn, args) do
     actor_collection(conn, "events", args)
   end
 
+  @spec discussions(Plug.Conn.t(), map()) :: Plug.Conn.t()
   def discussions(conn, args) do
     actor_collection(conn, "discussions", args)
   end
@@ -70,38 +79,45 @@ defmodule Mobilizon.Web.ActivityPubController do
   @ok_statuses [:ok, :commit]
   @spec member(Plug.Conn.t(), map) :: {:error, :not_found} | Plug.Conn.t()
   def member(conn, %{"uuid" => uuid}) do
-    with {status, %Member{parent: %Actor{} = group, actor: %Actor{domain: nil} = _actor} = member}
-         when status in @ok_statuses <-
-           Cache.get_member_by_uuid_with_preload(uuid),
-         actor <- Map.get(conn.assigns, :actor),
-         true <- actor_applicant_group_member?(group, actor) do
-      json(
-        conn,
-        ActorView.render("member.json", %{
-          member: member,
-          actor_applicant: actor
-        })
-      )
-    else
+    case Cache.get_member_by_uuid_with_preload(uuid) do
+      {status, %Member{parent: %Actor{} = group, actor: %Actor{domain: nil} = _actor} = member}
+      when status in @ok_statuses ->
+        actor = Map.get(conn.assigns, :actor)
+
+        if actor_applicant_group_member?(group, actor) do
+          json(
+            conn,
+            ActorView.render("member.json", %{
+              member: member,
+              actor_applicant: actor
+            })
+          )
+        else
+          not_found(conn)
+        end
+
       {status, %Member{actor: %Actor{url: domain}, parent: %Actor{} = group, url: url}}
       when status in @ok_statuses and not is_nil(domain) ->
-        with actor <- Map.get(conn.assigns, :actor),
-             true <- actor_applicant_group_member?(group, actor) do
+        actor = Map.get(conn.assigns, :actor)
+
+        if actor_applicant_group_member?(group, actor) do
           redirect(conn, external: url)
         else
-          _ ->
-            conn
-            |> put_status(404)
-            |> json("Not found")
+          not_found(conn)
         end
 
       _ ->
-        conn
-        |> put_status(404)
-        |> json("Not found")
+        not_found(conn)
     end
   end
 
+  @spec not_found(Plug.Conn.t()) :: Plug.Conn.t()
+  defp not_found(conn) do
+    conn
+    |> put_status(404)
+    |> json("Not found")
+  end
+
   def outbox(conn, args) do
     actor_collection(conn, "outbox", args)
   end
@@ -201,6 +217,7 @@ defmodule Mobilizon.Web.ActivityPubController do
     end
   end
 
+  @spec actor_applicant_group_member?(Actor.t(), Actor.t() | nil) :: boolean()
   defp actor_applicant_group_member?(%Actor{}, nil), do: false
 
   defp actor_applicant_group_member?(%Actor{id: group_id}, %Actor{id: actor_applicant_id}),
diff --git a/lib/web/controllers/auth_controller.ex b/lib/web/controllers/auth_controller.ex
index e841ae7ed..49a12b5a9 100644
--- a/lib/web/controllers/auth_controller.ex
+++ b/lib/web/controllers/auth_controller.ex
@@ -9,6 +9,7 @@ defmodule Mobilizon.Web.AuthController do
 
   plug(Ueberauth)
 
+  @spec request(Plug.Conn.t(), map()) :: Plug.Conn.t()
   def request(conn, %{"provider" => provider_name} = _params) do
     case provider_config(provider_name) do
       {:ok, provider_config} ->
@@ -20,6 +21,7 @@ defmodule Mobilizon.Web.AuthController do
     end
   end
 
+  @spec callback(Plug.Conn.t(), map()) :: Plug.Conn.t() | {:error, any()}
   def callback(
         %{assigns: %{ueberauth_failure: fails}} = conn,
         %{"provider" => provider} = _params
@@ -85,6 +87,7 @@ defmodule Mobilizon.Web.AuthController do
 
   # Github only give public emails as part of the user profile,
   # so we explicitely request all user emails and filter on the primary one
+  @spec email_from_ueberauth(Ueberauth.Auth.t()) :: String.t() | nil
   defp email_from_ueberauth(%Ueberauth.Auth{
          strategy: Ueberauth.Strategy.Github,
          extra: %Ueberauth.Auth.Extra{raw_info: %{user: %{"emails" => emails}}}
@@ -100,6 +103,7 @@ defmodule Mobilizon.Web.AuthController do
 
   defp email_from_ueberauth(_), do: nil
 
+  @spec provider_config(String.t()) :: {:ok, any()} | {:error, :not_supported | :unknown_error}
   defp provider_config(provider_name) do
     with ueberauth when is_list(ueberauth) <- Application.get_env(:ueberauth, Ueberauth),
          providers when is_list(providers) <- Keyword.get(ueberauth, :providers),
diff --git a/lib/web/controllers/fallback_controller.ex b/lib/web/controllers/fallback_controller.ex
index f92fb2312..879d25a8f 100644
--- a/lib/web/controllers/fallback_controller.ex
+++ b/lib/web/controllers/fallback_controller.ex
@@ -6,6 +6,7 @@ defmodule Mobilizon.Web.FallbackController do
   """
   use Mobilizon.Web, :controller
 
+  @spec call(Plug.Conn.t(), {:error, :not_found}) :: Plug.Conn.t()
   def call(conn, {:error, :not_found}) do
     conn
     |> put_status(:not_found)
diff --git a/lib/web/controllers/feed_controller.ex b/lib/web/controllers/feed_controller.ex
index 4db698fea..cf4646263 100644
--- a/lib/web/controllers/feed_controller.ex
+++ b/lib/web/controllers/feed_controller.ex
@@ -7,6 +7,7 @@ defmodule Mobilizon.Web.FeedController do
   action_fallback(Mobilizon.Web.FallbackController)
   alias Mobilizon.Config
 
+  @spec instance(Plug.Conn.t(), map()) :: Plug.Conn.t()
   def instance(conn, %{"format" => format}) do
     if Config.get([:instance, :enable_instance_feeds], false) do
       return_data(conn, format, "instance", Config.instance_name())
@@ -15,6 +16,7 @@ defmodule Mobilizon.Web.FeedController do
     end
   end
 
+  @spec actor(Plug.Conn.t(), map()) :: Plug.Conn.t() | {:error, :not_found}
   def actor(conn, %{"format" => format, "name" => name}) do
     return_data(conn, format, "actor_" <> name, name)
   end
@@ -23,14 +25,17 @@ defmodule Mobilizon.Web.FeedController do
     {:error, :not_found}
   end
 
+  @spec event(Plug.Conn.t(), map()) :: Plug.Conn.t() | {:error, :not_found}
   def event(conn, %{"uuid" => uuid, "format" => "ics"}) do
     return_data(conn, "ics", "event_" <> uuid, "event")
   end
 
+  @spec instance(Plug.Conn.t(), map()) :: Plug.Conn.t()
   def event(_conn, _) do
     {:error, :not_found}
   end
 
+  @spec going(Plug.Conn.t(), map()) :: Plug.Conn.t() | {:error, :not_found}
   def going(conn, %{"token" => token, "format" => format}) do
     return_data(conn, format, "token_" <> token, "events")
   end
@@ -39,6 +44,8 @@ defmodule Mobilizon.Web.FeedController do
     {:error, :not_found}
   end
 
+  @spec return_data(Plug.Conn.t(), String.t(), String.t(), String.t()) ::
+          Plug.Conn.t() | {:error, :not_found}
   defp return_data(conn, "atom", type, filename) do
     case Cachex.fetch(:feed, type) do
       {status, data} when status in [:commit, :ok] ->
diff --git a/lib/web/controllers/media_proxy_controller.ex b/lib/web/controllers/media_proxy_controller.ex
index b60affacc..71f95c421 100644
--- a/lib/web/controllers/media_proxy_controller.ex
+++ b/lib/web/controllers/media_proxy_controller.ex
@@ -10,6 +10,7 @@ defmodule Mobilizon.Web.MediaProxyController do
   alias Plug.Conn
 
   # sobelow_skip ["XSS.SendResp"]
+  @spec remote(Plug.Conn.t(), map()) :: Plug.Conn.t()
   def remote(conn, %{"sig" => sig64, "url" => url64}) do
     with {_, true} <- {:enabled, MediaProxy.enabled?()},
          {:ok, url} <- MediaProxy.decode_url(sig64, url64),
@@ -27,6 +28,7 @@ defmodule Mobilizon.Web.MediaProxyController do
     end
   end
 
+  @spec media_proxy_opts :: Keyword.t()
   defp media_proxy_opts do
     Config.get([:media_proxy, :proxy_opts], [])
   end
diff --git a/lib/web/controllers/node_info_controller.ex b/lib/web/controllers/node_info_controller.ex
index 67cd636cb..e5165e336 100644
--- a/lib/web/controllers/node_info_controller.ex
+++ b/lib/web/controllers/node_info_controller.ex
@@ -15,6 +15,7 @@ defmodule Mobilizon.Web.NodeInfoController do
   @node_info_supported_versions ["2.0", "2.1"]
   @node_info_schema_uri "http://nodeinfo.diaspora.software/ns/schema/"
 
+  @spec schemas(Plug.Conn.t(), any) :: Plug.Conn.t()
   def schemas(conn, _params) do
     links =
       @node_info_supported_versions
@@ -31,6 +32,7 @@ defmodule Mobilizon.Web.NodeInfoController do
   end
 
   # Schema definition: https://github.com/jhass/nodeinfo/blob/master/schemas/2.1/schema.json
+  @spec nodeinfo(Plug.Conn.t(), any()) :: Plug.Conn.t()
   def nodeinfo(conn, %{"version" => version}) when version in @node_info_supported_versions do
     response = %{
       version: version,
diff --git a/lib/web/controllers/page_controller.ex b/lib/web/controllers/page_controller.ex
index eaab4b592..cc00560a5 100644
--- a/lib/web/controllers/page_controller.ex
+++ b/lib/web/controllers/page_controller.ex
@@ -14,15 +14,26 @@ defmodule Mobilizon.Web.PageController do
   plug(:put_layout, false)
   action_fallback(Mobilizon.Web.FallbackController)
 
+  @spec my_events(Plug.Conn.t(), any) :: Plug.Conn.t()
   defdelegate my_events(conn, params), to: PageController, as: :index
+  @spec create_event(Plug.Conn.t(), any) :: Plug.Conn.t()
   defdelegate create_event(conn, params), to: PageController, as: :index
+  @spec list_events(Plug.Conn.t(), any) :: Plug.Conn.t()
   defdelegate list_events(conn, params), to: PageController, as: :index
+  @spec edit_event(Plug.Conn.t(), any) :: Plug.Conn.t()
   defdelegate edit_event(conn, params), to: PageController, as: :index
+  @spec moderation_report(Plug.Conn.t(), any) :: Plug.Conn.t()
   defdelegate moderation_report(conn, params), to: PageController, as: :index
+  @spec participation_email_confirmation(Plug.Conn.t(), any) :: Plug.Conn.t()
   defdelegate participation_email_confirmation(conn, params), to: PageController, as: :index
+  @spec user_email_validation(Plug.Conn.t(), any) :: Plug.Conn.t()
   defdelegate user_email_validation(conn, params), to: PageController, as: :index
+  @spec my_groups(Plug.Conn.t(), any) :: Plug.Conn.t()
   defdelegate my_groups(conn, params), to: PageController, as: :index
 
+  @typep object_type ::
+           :actor | :event | :comment | :resource | :post | :discussion | :todo_list | :todo
+
   @spec index(Plug.Conn.t(), any) :: Plug.Conn.t()
   def index(conn, _params), do: render(conn, :index)
 
@@ -62,38 +73,45 @@ defmodule Mobilizon.Web.PageController do
     render_or_error(conn, &checks?/3, status, :discussion, discussion)
   end
 
-  def resources(conn, %{"name" => _name}) do
-    handle_collection_route(conn, :resources)
-  end
-
-  def posts(conn, %{"name" => _name}) do
-    handle_collection_route(conn, :posts)
-  end
-
-  def discussions(conn, %{"name" => _name}) do
-    handle_collection_route(conn, :discussions)
-  end
-
-  def events(conn, %{"name" => _name}) do
-    handle_collection_route(conn, :events)
-  end
-
-  def todos(conn, %{"name" => _name}) do
-    handle_collection_route(conn, :todos)
-  end
-
-  @spec todo_list(Plug.Conn.t(), map) :: {:error, :not_found} | Plug.Conn.t()
+  @spec todo_list(Plug.Conn.t(), map) :: Plug.Conn.t() | {:error, :not_found}
   def todo_list(conn, %{"uuid" => uuid}) do
     {status, todo_list} = Cache.get_todo_list_by_uuid_with_preload(uuid)
     render_or_error(conn, &checks?/3, status, :todo_list, todo_list)
   end
 
-  @spec todo(Plug.Conn.t(), map) :: {:error, :not_found} | Plug.Conn.t()
+  @spec todo(Plug.Conn.t(), map) :: Plug.Conn.t() | {:error, :not_found}
   def todo(conn, %{"uuid" => uuid}) do
     {status, todo} = Cache.get_todo_by_uuid_with_preload(uuid)
     render_or_error(conn, &checks?/3, status, :todo, todo)
   end
 
+  @typep collections :: :resources | :posts | :discussions | :events | :todos
+
+  @spec resources(Plug.Conn.t(), map()) :: Plug.Conn.t()
+  def resources(conn, %{"name" => _name}) do
+    handle_collection_route(conn, :resources)
+  end
+
+  @spec posts(Plug.Conn.t(), map()) :: Plug.Conn.t()
+  def posts(conn, %{"name" => _name}) do
+    handle_collection_route(conn, :posts)
+  end
+
+  @spec discussions(Plug.Conn.t(), map()) :: Plug.Conn.t()
+  def discussions(conn, %{"name" => _name}) do
+    handle_collection_route(conn, :discussions)
+  end
+
+  @spec events(Plug.Conn.t(), map()) :: Plug.Conn.t()
+  def events(conn, %{"name" => _name}) do
+    handle_collection_route(conn, :events)
+  end
+
+  @spec todos(Plug.Conn.t(), map()) :: Plug.Conn.t()
+  def todos(conn, %{"name" => _name}) do
+    handle_collection_route(conn, :todos)
+  end
+
   @spec interact(Plug.Conn.t(), map()) :: Plug.Conn.t() | {:error, :not_found}
   def interact(conn, %{"uri" => uri}) do
     case ActivityPub.fetch_object_from_url(uri) do
@@ -103,6 +121,7 @@ defmodule Mobilizon.Web.PageController do
     end
   end
 
+  @spec handle_collection_route(Plug.Conn.t(), collections()) :: Plug.Conn.t()
   defp handle_collection_route(conn, collection) do
     case get_format(conn) do
       "html" ->
@@ -113,6 +132,8 @@ defmodule Mobilizon.Web.PageController do
     end
   end
 
+  @spec render_or_error(Plug.Conn.t(), function(), cache_status(), object_type(), any()) ::
+          Plug.Conn.t() | {:error, :not_found}
   defp render_or_error(conn, check_fn, status, object_type, object) do
     case check_fn.(conn, status, object) do
       true ->
@@ -136,12 +157,17 @@ defmodule Mobilizon.Web.PageController do
     end
   end
 
+  @spec is_visible?(map) :: boolean()
   defp is_visible?(%{visibility: v}), do: v in [:public, :unlisted]
   defp is_visible?(%Tombstone{}), do: true
   defp is_visible?(_), do: true
 
+  @spec ok_status?(cache_status) :: boolean()
   defp ok_status?(status), do: status in [:ok, :commit]
 
+  @typep cache_status :: :ok | :commit | :ignore
+
+  @spec ok_status_and_is_visible?(Plug.Conn.t(), cache_status, map()) :: boolean()
   defp ok_status_and_is_visible?(_conn, status, o),
     do: ok_status?(status) and is_visible?(o)
 
@@ -158,9 +184,11 @@ defmodule Mobilizon.Web.PageController do
     end
   end
 
+  @spec is_local?(map()) :: boolean | :remote
   defp is_local?(%{local: local}), do: if(local, do: true, else: :remote)
   defp is_local?(_), do: false
 
+  @spec maybe_add_noindex_header(Plug.Conn.t(), map()) :: Plug.Conn.t()
   defp maybe_add_noindex_header(conn, %{visibility: visibility})
        when visibility != :public do
     put_resp_header(conn, "x-robots-tag", "noindex")
@@ -168,6 +196,7 @@ defmodule Mobilizon.Web.PageController do
 
   defp maybe_add_noindex_header(conn, _), do: conn
 
+  @spec is_person?(Actor.t()) :: boolean()
   defp is_person?(%Actor{type: :Person}), do: true
   defp is_person?(_), do: false
 end
diff --git a/lib/web/controllers/web_finger_controller.ex b/lib/web/controllers/web_finger_controller.ex
index b0aec2524..ecc2e878d 100644
--- a/lib/web/controllers/web_finger_controller.ex
+++ b/lib/web/controllers/web_finger_controller.ex
@@ -17,6 +17,7 @@ defmodule Mobilizon.Web.WebFingerController do
   @doc """
   Provides /.well-known/host-meta
   """
+  @spec host_meta(Plug.Conn.t(), any()) :: Plug.Conn.t() | no_return
   def host_meta(conn, _params) do
     xml = WebFinger.host_meta()
 
@@ -28,6 +29,7 @@ defmodule Mobilizon.Web.WebFingerController do
   @doc """
   Provides /.well-known/webfinger
   """
+  @spec webfinger(Plug.Conn.t(), any()) :: Plug.Conn.t() | no_return
   def webfinger(conn, %{"resource" => resource}) do
     case WebFinger.webfinger(resource, "JSON") do
       {:ok, response} -> json(conn, response)
diff --git a/lib/web/email/activity.ex b/lib/web/email/activity.ex
index 17268424c..15570e5c3 100644
--- a/lib/web/email/activity.ex
+++ b/lib/web/email/activity.ex
@@ -12,7 +12,7 @@ defmodule Mobilizon.Web.Email.Activity do
   alias Mobilizon.Config
   alias Mobilizon.Web.Email
 
-  @spec direct_activity(String.t(), list(), String.t()) ::
+  @spec direct_activity(String.t(), list(), Keyword.t()) ::
           Bamboo.Email.t()
   def direct_activity(
         email,
diff --git a/lib/web/email/actor.ex b/lib/web/email/actor.ex
new file mode 100644
index 000000000..8e81621c5
--- /dev/null
+++ b/lib/web/email/actor.ex
@@ -0,0 +1,60 @@
+defmodule Mobilizon.Web.Email.Actor do
+  @moduledoc """
+  Handles emails sent about actors status.
+  """
+  use Bamboo.Phoenix, view: Mobilizon.Web.EmailView
+
+  import Bamboo.Phoenix
+  import Mobilizon.Web.Gettext
+
+  alias Mobilizon.Actors.Actor
+  alias Mobilizon.{Config, Users}
+  alias Mobilizon.Events.{Event, Participant}
+  alias Mobilizon.Users.User
+  alias Mobilizon.Web.Email
+
+  @doc """
+  Send a notification to participants from events organized by an actor that is going to be suspended
+  """
+  @spec send_notification_event_participants_from_suspension(Participant.t(), Actor.t()) ::
+          :ok
+  def send_notification_event_participants_from_suspension(
+        %Participant{
+          actor: %Actor{user_id: nil}
+        },
+        _suspended
+      ),
+      do: :ok
+
+  def send_notification_event_participants_from_suspension(%Participant{role: role}, _suspended)
+      when role not in [:participant, :moderator, :administrator],
+      do: :ok
+
+  def send_notification_event_participants_from_suspension(
+        %Participant{
+          actor: %Actor{user_id: user_id},
+          event: %Event{} = event,
+          role: member_role
+        },
+        %Actor{} = suspended
+      ) do
+    with %User{email: email, locale: locale} <- Users.get_user!(user_id) do
+      Gettext.put_locale(locale)
+      instance = Config.instance_name()
+
+      subject = gettext("Your participation to %{event} has been cancelled!", event: event.title)
+
+      Email.base_email(to: email, subject: subject)
+      |> assign(:locale, locale)
+      |> assign(:actor, suspended)
+      |> assign(:event, event)
+      |> assign(:role, member_role)
+      |> assign(:subject, subject)
+      |> assign(:instance, instance)
+      |> render(:actor_suspension_participants)
+      |> Email.Mailer.send_email_later()
+
+      :ok
+    end
+  end
+end
diff --git a/lib/web/email/event.ex b/lib/web/email/event.ex
index b49a3baae..120f1d577 100644
--- a/lib/web/email/event.ex
+++ b/lib/web/email/event.ex
@@ -49,6 +49,7 @@ defmodule Mobilizon.Web.Email.Event do
     |> render(:event_updated)
   end
 
+  @spec calculate_event_diff_and_send_notifications(Event.t(), Event.t(), map()) :: {:ok, :ok}
   def calculate_event_diff_and_send_notifications(
         %Event{} = old_event,
         %Event{id: event_id} = event,
@@ -75,6 +76,12 @@ defmodule Mobilizon.Web.Email.Event do
     end
   end
 
+  @spec send_notification_for_event_update_to_participant(
+          {Participant.t(), Actor.t(), User.t() | nil, Setting.t() | nil},
+          Event.t(),
+          Event.t(),
+          MapSet.t()
+        ) :: Bamboo.Email.t()
   defp send_notification_for_event_update_to_participant(
          {%Participant{} = _participant, %Actor{} = actor,
           %User{locale: locale, email: email} = _user, %Setting{timezone: timezone}},
@@ -131,6 +138,15 @@ defmodule Mobilizon.Web.Email.Event do
     )
   end
 
+  @spec do_send_notification_for_event_update_to_participant(
+          String.t(),
+          Actor.t(),
+          Event.t(),
+          Event.t(),
+          MapSet.t(),
+          String.t(),
+          String.t()
+        ) :: Bamboo.Email.t()
   defp do_send_notification_for_event_update_to_participant(
          email,
          actor,
diff --git a/lib/web/email/group.ex b/lib/web/email/group.ex
index 8e1e938ec..bf1ecdc18 100644
--- a/lib/web/email/group.ex
+++ b/lib/web/email/group.ex
@@ -79,6 +79,7 @@ defmodule Mobilizon.Web.Email.Group do
   # TODO : def send_confirmation_to_inviter()
 
   @member_roles [:administrator, :moderator, :member]
+  @spec send_group_suspension_notification(Member.t()) :: :ok
   def send_group_suspension_notification(%Member{actor: %Actor{user_id: nil}}), do: :ok
 
   def send_group_suspension_notification(%Member{role: role}) when role not in @member_roles,
@@ -112,48 +113,4 @@ defmodule Mobilizon.Web.Email.Group do
       :ok
     end
   end
-
-  def send_group_deletion_notification(%Member{actor: %Actor{user_id: nil}}, _author), do: :ok
-
-  def send_group_deletion_notification(%Member{role: role}, _author)
-      when role not in @member_roles,
-      do: :ok
-
-  def send_group_deletion_notification(
-        %Member{
-          actor: %Actor{user_id: user_id, id: actor_id},
-          parent: %Actor{domain: nil} = group,
-          role: member_role
-        },
-        %Actor{id: author_id} = author
-      ) do
-    with %User{email: email, locale: locale} <- Users.get_user!(user_id),
-         {:member_not_author, true} <- {:member_not_author, author_id !== actor_id} do
-      Gettext.put_locale(locale)
-      instance = Config.instance_name()
-
-      subject =
-        gettext(
-          "The group %{group} has been deleted on %{instance}",
-          group: group.name,
-          instance: instance
-        )
-
-      Email.base_email(to: email, subject: subject)
-      |> assign(:locale, locale)
-      |> assign(:group, group)
-      |> assign(:role, member_role)
-      |> assign(:subject, subject)
-      |> assign(:instance, instance)
-      |> assign(:author, author)
-      |> render(:group_deletion)
-      |> Email.Mailer.send_email_later()
-
-      :ok
-    else
-      # Skip if it's the author itself
-      {:member_not_author, _} ->
-        :ok
-    end
-  end
 end
diff --git a/lib/web/email/mailer.ex b/lib/web/email/mailer.ex
index 6f4693746..68f9d905a 100644
--- a/lib/web/email/mailer.ex
+++ b/lib/web/email/mailer.ex
@@ -5,6 +5,7 @@ defmodule Mobilizon.Web.Email.Mailer do
   use Bamboo.Mailer, otp_app: :mobilizon
   alias Mobilizon.Service.ErrorReporting.Sentry
 
+  @spec send_email_later(Bamboo.Email.t()) :: Bamboo.Email.t()
   def send_email_later(email) do
     Mobilizon.Web.Email.Mailer.deliver_later!(email)
   rescue
@@ -17,6 +18,7 @@ defmodule Mobilizon.Web.Email.Mailer do
       reraise error, __STACKTRACE__
   end
 
+  @spec send_email(Bamboo.Email.t()) :: Bamboo.Email.t() | {Bamboo.Email.t(), any()}
   def send_email(email) do
     Mobilizon.Web.Email.Mailer.deliver_now!(email)
   rescue
diff --git a/lib/web/email/notification.ex b/lib/web/email/notification.ex
index 5800bf0f4..c2e83f7fa 100644
--- a/lib/web/email/notification.ex
+++ b/lib/web/email/notification.ex
@@ -34,6 +34,8 @@ defmodule Mobilizon.Web.Email.Notification do
     |> render(:before_event_notification)
   end
 
+  @spec on_day_notification(User.t(), list(Participant.t()), pos_integer(), String.t()) ::
+          Bamboo.Email.t()
   def on_day_notification(
         %User{email: email, settings: %Setting{timezone: timezone}},
         participations,
@@ -58,6 +60,8 @@ defmodule Mobilizon.Web.Email.Notification do
     |> render(:on_day_notification)
   end
 
+  @spec weekly_notification(User.t(), list(Participant.t()), pos_integer(), String.t()) ::
+          Bamboo.Email.t()
   def weekly_notification(
         %User{email: email, settings: %Setting{timezone: timezone}},
         participations,
@@ -82,6 +86,7 @@ defmodule Mobilizon.Web.Email.Notification do
     |> render(:notification_each_week)
   end
 
+  @spec pending_participation_notification(User.t(), Event.t(), pos_integer()) :: Bamboo.Email.t()
   def pending_participation_notification(
         %User{locale: locale, email: email},
         %Event{} = event,
diff --git a/lib/web/email/participation.ex b/lib/web/email/participation.ex
index edf319906..7fea008fb 100644
--- a/lib/web/email/participation.ex
+++ b/lib/web/email/participation.ex
@@ -50,7 +50,6 @@ defmodule Mobilizon.Web.Email.Participation do
           Bamboo.Email.t()
   def participation_updated(user, participant, locale \\ "en")
 
-  @spec participation_updated(User.t(), Participant.t(), String.t()) :: Bamboo.Email.t()
   def participation_updated(
         %User{email: email},
         %Participant{} = participant,
@@ -58,7 +57,6 @@ defmodule Mobilizon.Web.Email.Participation do
       ),
       do: participation_updated(email, participant, locale)
 
-  @spec participation_updated(String.t(), Participant.t(), String.t()) :: Bamboo.Email.t()
   def participation_updated(
         email,
         %Participant{event: event, role: :rejected},
@@ -79,7 +77,6 @@ defmodule Mobilizon.Web.Email.Participation do
     |> render(:event_participation_rejected)
   end
 
-  @spec participation_updated(String.t(), Participant.t(), String.t()) :: Bamboo.Email.t()
   def participation_updated(
         email,
         %Participant{event: %Event{join_options: :free} = event, role: :participant},
@@ -100,7 +97,6 @@ defmodule Mobilizon.Web.Email.Participation do
     |> render(:event_participation_confirmed)
   end
 
-  @spec participation_updated(String.t(), Participant.t(), String.t()) :: Bamboo.Email.t()
   def participation_updated(
         email,
         %Participant{event: event, role: :participant},
diff --git a/lib/web/email/user.ex b/lib/web/email/user.ex
index 54cf253ee..66ccb2137 100644
--- a/lib/web/email/user.ex
+++ b/lib/web/email/user.ex
@@ -7,7 +7,7 @@ defmodule Mobilizon.Web.Email.User do
 
   import Bamboo.Phoenix
 
-  import Mobilizon.Web.Gettext, only: [gettext: 1, gettext: 2]
+  import Mobilizon.Web.Gettext, only: [gettext: 2]
 
   alias Mobilizon.{Config, Crypto, Users}
   alias Mobilizon.Storage.Repo
@@ -57,19 +57,26 @@ defmodule Mobilizon.Web.Email.User do
     |> render(:password_reset)
   end
 
+  @spec check_confirmation_token(String.t()) ::
+          {:ok, User.t()} | {:error, :invalid_token | Ecto.Changeset.t()}
   def check_confirmation_token(token) when is_binary(token) do
-    with %User{} = user <- Users.get_user_by_activation_token(token),
-         {:ok, %User{} = user} <-
-           Users.update_user(user, %{
-             confirmed_at: DateTime.utc_now() |> DateTime.truncate(:second),
-             confirmation_sent_at: nil,
-             confirmation_token: nil,
-             email: user.unconfirmed_email || user.email
-           }) do
-      Logger.info("User #{user.email} has been confirmed")
-      {:ok, user}
-    else
-      _err ->
+    case Users.get_user_by_activation_token(token) do
+      %User{} = user ->
+        case Users.update_user(user, %{
+               confirmed_at: DateTime.utc_now() |> DateTime.truncate(:second),
+               confirmation_sent_at: nil,
+               confirmation_token: nil,
+               email: user.unconfirmed_email || user.email
+             }) do
+          {:ok, %User{} = user} ->
+            Logger.info("User #{user.email} has been confirmed")
+            {:ok, user}
+
+          {:error, %Ecto.Changeset{} = err} ->
+            {:error, err}
+        end
+
+      nil ->
         {:error, :invalid_token}
     end
   end
@@ -86,7 +93,7 @@ defmodule Mobilizon.Web.Email.User do
     end
   end
 
-  @spec send_confirmation_email(User.t(), String.t()) :: {:ok, Bamboo.Email.t()} | {:error, any()}
+  @spec send_confirmation_email(User.t(), String.t()) :: Bamboo.Email.t()
   def send_confirmation_email(%User{} = user, locale \\ "en") do
     user
     |> Email.User.confirmation_email(locale)
@@ -96,30 +103,21 @@ defmodule Mobilizon.Web.Email.User do
   @doc """
   Check that the provided token is correct and update provided password
   """
-  @spec check_reset_password_token(String.t(), String.t()) :: tuple
+  @spec check_reset_password_token(String.t(), String.t()) ::
+          {:ok, User.t()} | {:error, :user_not_found | Ecto.Changeset.t()}
   def check_reset_password_token(password, token) do
-    with %User{} = user <- Users.get_user_by_reset_password_token(token),
-         {:ok, %User{} = user} <-
-           Repo.update(
-             User.password_reset_changeset(user, %{
-               "password" => password,
-               "reset_password_sent_at" => nil,
-               "reset_password_token" => nil
-             })
-           ) do
-      {:ok, user}
-    else
-      {:error, %Ecto.Changeset{errors: [password: {"registration.error.password_too_short", _}]}} ->
-        {:error,
-         gettext(
-           "The password you have choosen is too short. Please make sure your password contains at least 6 charaters."
-         )}
+    case Users.get_user_by_reset_password_token(token) do
+      %User{} = user ->
+        user
+        |> User.password_reset_changeset(%{
+          "password" => password,
+          "reset_password_sent_at" => nil,
+          "reset_password_token" => nil
+        })
+        |> Repo.update()
 
-      _err ->
-        {:error,
-         gettext(
-           "The token you provided is invalid. Make sure that the URL is exactly the one provided inside the email you got."
-         )}
+      nil ->
+        {:error, :user_not_found}
     end
   end
 
@@ -197,14 +195,14 @@ defmodule Mobilizon.Web.Email.User do
         :ok
 
       _ ->
-        case Timex.before?(
-               Timex.shift(Map.get(user, key), hours: 1),
+        case DateTime.compare(
+               DateTime.add(Map.get(user, key), 3600),
                DateTime.utc_now() |> DateTime.truncate(:second)
              ) do
-          true ->
+          :lt ->
             :ok
 
-          false ->
+          _ ->
             {:error, :email_too_soon}
         end
     end
diff --git a/lib/web/endpoint.ex b/lib/web/endpoint.ex
index 2b1455551..6e1c585e5 100644
--- a/lib/web/endpoint.ex
+++ b/lib/web/endpoint.ex
@@ -19,13 +19,13 @@ defmodule Mobilizon.Web.Endpoint do
   end
 
   # For e2e tests
-  if Application.get_env(:mobilizon, :sql_sandbox) do
-    plug(Phoenix.Ecto.SQL.Sandbox,
-      at: "/sandbox",
-      header: "x-session-id",
-      repo: Mobilizon.Storage.Repo
-    )
-  end
+  # if Application.get_env(:mobilizon, :sql_sandbox) do
+  #   plug(Phoenix.Ecto.SQL.Sandbox,
+  #     at: "/sandbox",
+  #     header: "x-session-id",
+  #     repo: Mobilizon.Storage.Repo
+  #   )
+  # end
 
   socket("/graphql_socket", Mobilizon.Web.GraphQLSocket,
     websocket: true,
diff --git a/lib/web/media_proxy.ex b/lib/web/media_proxy.ex
index a7c9fe4fb..9ac3ebe00 100644
--- a/lib/web/media_proxy.ex
+++ b/lib/web/media_proxy.ex
@@ -11,6 +11,7 @@ defmodule Mobilizon.Web.MediaProxy do
 
   @base64_opts [padding: false]
 
+  @spec url(String.t() | nil) :: String.t() | nil
   def url(url) when is_nil(url) or url == "", do: nil
   def url("/" <> _ = url), do: url
 
@@ -27,10 +28,12 @@ defmodule Mobilizon.Web.MediaProxy do
     not local?(url)
   end
 
+  @spec enabled? :: boolean()
   def enabled?, do: Config.get([:media_proxy, :enabled], false)
 
   def local?(url), do: String.starts_with?(url, Web.Endpoint.url())
 
+  @spec base64_sig64(String.t()) :: {String.t(), String.t()}
   defp base64_sig64(url) do
     base64 = Base.url_encode64(url, @base64_opts)
 
@@ -42,12 +45,14 @@ defmodule Mobilizon.Web.MediaProxy do
     {base64, sig64}
   end
 
+  @spec encode_url(String.t()) :: String.t()
   def encode_url(url) do
     {base64, sig64} = base64_sig64(url)
 
     build_url(sig64, base64, filename(url))
   end
 
+  @spec decode_url(String.t(), String.t()) :: {:ok, String.t()} | {:error, :invalid_signature}
   def decode_url(sig, url) do
     with {:ok, sig} <- Base.url_decode64(sig, @base64_opts),
          signature when signature == sig <- signed_url(url) do
@@ -57,10 +62,12 @@ defmodule Mobilizon.Web.MediaProxy do
     end
   end
 
+  @spec signed_url(String.t()) :: String.t()
   defp signed_url(url) do
     sha_hmac(Config.get([Web.Endpoint, :secret_key_base]), url)
   end
 
+  @spec sha_hmac(String.t(), String.t()) :: String.t()
   @compile {:no_warn_undefined, {:crypto, :mac, 4}}
   @compile {:no_warn_undefined, {:crypto, :hmac, 3}}
   defp sha_hmac(key, url) do
@@ -73,14 +80,17 @@ defmodule Mobilizon.Web.MediaProxy do
     end
   end
 
+  @spec filename(String.t()) :: String.t() | nil
   def filename(url_or_path) do
     if path = URI.parse(url_or_path).path, do: Path.basename(path)
   end
 
+  @spec base_url :: String.t()
   def base_url do
     Web.Endpoint.url()
   end
 
+  @spec proxy_url(String.t(), String.t(), String.t(), String.t() | nil) :: String.t()
   defp proxy_url(path, sig_base64, url_base64, filename) do
     [
       base_url(),
@@ -93,10 +103,13 @@ defmodule Mobilizon.Web.MediaProxy do
     |> Path.join()
   end
 
+  @spec build_url(String.t(), String.t(), String.t() | nil) :: String.t()
   def build_url(sig_base64, url_base64, filename \\ nil) do
     proxy_url("proxy", sig_base64, url_base64, filename)
   end
 
+  @spec verify_request_path_and_url(Plug.Conn.t() | String.t(), String.t()) ::
+          :ok | {:wrong_filename, String.t()}
   def verify_request_path_and_url(
         %Plug.Conn{params: %{"filename" => _}, request_path: request_path},
         url
@@ -116,6 +129,7 @@ defmodule Mobilizon.Web.MediaProxy do
 
   def verify_request_path_and_url(_, _), do: :ok
 
+  @spec basename_matches?(String.t(), String.t()) :: boolean()
   defp basename_matches?(path, filename) do
     basename = Path.basename(path)
     basename == filename or URI.decode(basename) == filename or URI.encode(basename) == filename
diff --git a/lib/web/mobilizon_web.ex b/lib/web/mobilizon_web.ex
index 76f5b5fe1..059b9eb92 100644
--- a/lib/web/mobilizon_web.ex
+++ b/lib/web/mobilizon_web.ex
@@ -21,8 +21,8 @@ defmodule Mobilizon.Web do
     quote do
       use Phoenix.Controller, namespace: Mobilizon.Web
       import Plug.Conn
-      import Mobilizon.Web.Router.Helpers
       import Mobilizon.Web.Gettext
+      alias Mobilizon.Web.Router.Helpers, as: Routes
     end
   end
 
@@ -33,14 +33,13 @@ defmodule Mobilizon.Web do
         pattern: "**/*",
         namespace: Mobilizon.Web
 
-      # Import convenience functions from controllers
-      import Phoenix.Controller, only: [get_flash: 2, view_module: 1]
-
       # Use all HTML functionality (forms, tags, etc)
       use Phoenix.HTML
 
-      import Mobilizon.Web.Router.Helpers
+      import Phoenix.View
+      import Mobilizon.Web.ErrorHelpers
       import Mobilizon.Web.Gettext
+      alias Mobilizon.Web.Router.Helpers, as: Routes
     end
   end
 
diff --git a/lib/web/plugs/detect_locale_plug.ex b/lib/web/plugs/detect_locale_plug.ex
index 66c339aca..0c68c9e8f 100644
--- a/lib/web/plugs/detect_locale_plug.ex
+++ b/lib/web/plugs/detect_locale_plug.ex
@@ -11,19 +11,23 @@ defmodule Mobilizon.Web.Plugs.DetectLocalePlug do
   import Plug.Conn, only: [get_req_header: 2, assign: 3]
   alias Mobilizon.Web.Gettext, as: GettextBackend
 
+  @spec init(any()) :: any()
   def init(_), do: nil
 
+  @spec call(Plug.Conn.t(), Keyword.t()) :: Plug.Conn.t()
   def call(conn, _) do
     locale = get_locale_from_header(conn)
     assign(conn, :detected_locale, locale)
   end
 
+  @spec get_locale_from_header(Plug.Conn.t()) :: String.t()
   defp get_locale_from_header(conn) do
     conn
     |> extract_accept_language()
     |> Enum.find(&supported_locale?/1)
   end
 
+  @spec extract_accept_language(Plug.Conn.t()) :: list(String.t())
   defp extract_accept_language(conn) do
     case get_req_header(conn, "accept-language") do
       [value | _] ->
@@ -40,12 +44,14 @@ defmodule Mobilizon.Web.Plugs.DetectLocalePlug do
     end
   end
 
+  @spec supported_locale?(String.t()) :: boolean()
   defp supported_locale?(locale) do
     GettextBackend
     |> Gettext.known_locales()
     |> Enum.member?(locale)
   end
 
+  @spec parse_language_option(String.t()) :: %{tag: String.t(), quality: float()}
   defp parse_language_option(string) do
     captures = Regex.named_captures(~r/^\s?(?<tag>[\w\-]+)(?:;q=(?<quality>[\d\.]+))?$/i, string)
 
@@ -58,6 +64,7 @@ defmodule Mobilizon.Web.Plugs.DetectLocalePlug do
     %{tag: captures["tag"], quality: quality}
   end
 
+  @spec ensure_language_fallbacks(list(String.t())) :: list(String.t())
   defp ensure_language_fallbacks(tags) do
     Enum.flat_map(tags, fn tag ->
       [language | _] = String.split(tag, "-")
diff --git a/lib/web/plugs/federating.ex b/lib/web/plugs/federating.ex
index d63b69cea..99911e3cd 100644
--- a/lib/web/plugs/federating.ex
+++ b/lib/web/plugs/federating.ex
@@ -10,10 +10,12 @@ defmodule Mobilizon.Web.Plugs.Federating do
 
   import Plug.Conn
 
+  @spec init(any()) :: any()
   def init(options) do
     options
   end
 
+  @spec call(Plug.Conn.t(), Keyword.t()) :: Plug.Conn.t()
   def call(conn, _opts) do
     if Mobilizon.Config.get([:instance, :federating]) do
       conn
diff --git a/lib/web/plugs/http_security_plug.ex b/lib/web/plugs/http_security_plug.ex
index 00f0eede8..468dd89e3 100644
--- a/lib/web/plugs/http_security_plug.ex
+++ b/lib/web/plugs/http_security_plug.ex
@@ -13,18 +13,21 @@ defmodule Mobilizon.Web.Plugs.HTTPSecurityPlug do
 
   require Logger
 
+  @spec init(any()) :: any()
   def init(opts), do: opts
 
+  @spec call(Plug.Conn.t(), Keyword.t()) :: Plug.Conn.t()
   def call(conn, options \\ []) do
     if Config.get([:http_security, :enabled]) do
       conn
       |> merge_resp_headers(headers(options))
-      |> maybe_send_sts_header(Config.get([:http_security, :sts]))
+      |> maybe_send_sts_header(Config.get([:http_security, :sts], false))
     else
       conn
     end
   end
 
+  @spec headers(Keyword.t()) :: list({String.t(), String.t()})
   defp headers(options) do
     referrer_policy =
       Keyword.get(options, :referrer_policy, Config.get([:http_security, :referrer_policy]))
@@ -55,14 +58,15 @@ defmodule Mobilizon.Web.Plugs.HTTPSecurityPlug do
   @style_src "style-src 'self' "
   @font_src "font-src 'self' "
 
+  @spec csp_string(Keyword.t()) :: String.t()
   defp csp_string(options) do
     scheme = Keyword.get(options, :scheme, Config.get([Pleroma.Web.Endpoint, :url])[:scheme])
     static_url = Mobilizon.Web.Endpoint.static_url()
     websocket_url = Mobilizon.Web.Endpoint.websocket_url()
 
-    img_src = [@img_src | get_csp_config(:img_src, options)]
+    img_src = [@img_src] ++ [get_csp_config(:img_src, options)]
 
-    media_src = [@media_src | get_csp_config(:media_src, options)]
+    media_src = [@media_src] ++ [get_csp_config(:media_src, options)]
 
     connect_src = [
       @connect_src,
@@ -83,22 +87,22 @@ defmodule Mobilizon.Web.Plugs.HTTPSecurityPlug do
         ]
       end
 
-    script_src = [script_src | get_csp_config(:script_src, options)]
+    script_src = [script_src] ++ [get_csp_config(:script_src, options)]
 
     style_src =
       if Config.get(:env) == :dev, do: [@style_src | "'unsafe-inline' "], else: @style_src
 
-    style_src = [style_src | get_csp_config(:style_src, options)]
+    style_src = [style_src] ++ [get_csp_config(:style_src, options)]
 
-    font_src = [@font_src | get_csp_config(:font_src, options)]
+    font_src = [@font_src] ++ [get_csp_config(:font_src, options)]
 
     frame_src = if Config.get(:env) == :dev, do: "frame-src 'self' ", else: "frame-src 'none' "
-    frame_src = [frame_src | get_csp_config(:frame_src, options)]
+    frame_src = [frame_src] ++ [get_csp_config(:frame_src, options)]
 
     frame_ancestors =
       if Config.get(:env) == :dev, do: "frame-ancestors 'self' ", else: "frame-ancestors 'none' "
 
-    frame_ancestors = [frame_ancestors | get_csp_config(:frame_ancestors, options)]
+    frame_ancestors = [frame_ancestors] ++ [get_csp_config(:frame_ancestors, options)]
 
     insecure = if scheme == "https", do: "upgrade-insecure-requests"
 
@@ -115,10 +119,11 @@ defmodule Mobilizon.Web.Plugs.HTTPSecurityPlug do
     |> to_string()
   end
 
+  @spec add_csp_param(iodata(), iodata() | nil) :: list()
   defp add_csp_param(csp_iodata, nil), do: csp_iodata
-
   defp add_csp_param(csp_iodata, param), do: [[param, ?;] | csp_iodata]
 
+  @spec maybe_send_sts_header(Plug.Conn.t(), boolean()) :: Plug.Conn.t()
   defp maybe_send_sts_header(conn, true) do
     max_age_sts = Config.get([:http_security, :sts_max_age])
 
@@ -127,8 +132,9 @@ defmodule Mobilizon.Web.Plugs.HTTPSecurityPlug do
     ])
   end
 
-  defp maybe_send_sts_header(conn, _), do: conn
+  defp maybe_send_sts_header(conn, false), do: conn
 
+  @spec get_csp_config(atom(), Keyword.t()) :: iodata()
   defp get_csp_config(type, options) do
     options
     |> Keyword.get(type, Config.get([:http_security, :csp_policy, type]))
diff --git a/lib/web/plugs/http_signatures.ex b/lib/web/plugs/http_signatures.ex
index 80333a782..595b3b47a 100644
--- a/lib/web/plugs/http_signatures.ex
+++ b/lib/web/plugs/http_signatures.ex
@@ -8,7 +8,7 @@ defmodule Mobilizon.Web.Plugs.HTTPSignatures do
   Plug to check HTTP Signatures on every incoming request
   """
 
-  import Plug.Conn
+  import Plug.Conn, only: [get_req_header: 2, put_req_header: 3, assign: 3]
 
   require Logger
 
@@ -16,53 +16,67 @@ defmodule Mobilizon.Web.Plugs.HTTPSignatures do
     options
   end
 
+  @spec call(Plug.Conn.t(), any) :: Plug.Conn.t()
   def call(%{assigns: %{valid_signature: true}} = conn, _opts) do
     conn
   end
 
   def call(conn, _opts) do
-    case get_req_header(conn, "signature") do
-      [signature | _] ->
-        if signature do
-          # set (request-target) header to the appropriate value
-          # we also replace the digest header with the one we computed
-          conn =
-            conn
-            |> put_req_header(
-              "(request-target)",
-              String.downcase("#{conn.method}") <> " #{conn.request_path}"
-            )
+    signature = conn |> get_req_header("signature") |> List.first()
 
-          conn =
-            if conn.assigns[:digest] do
-              conn
-              |> put_req_header("digest", conn.assigns[:digest])
-            else
-              conn
-            end
+    if is_nil(signature) do
+      Logger.debug("No signature header!")
+      conn
+    else
+      # set (request-target) header to the appropriate value
+      # we also replace the digest header with the one we computed
+      conn =
+        conn
+        |> put_req_header(
+          "(request-target)",
+          String.downcase("#{conn.method}") <> " #{conn.request_path}"
+        )
 
-          signature_valid = HTTPSignatures.validate_conn(conn)
-          Logger.debug("Is signature valid ? #{inspect(signature_valid)}")
-          date_valid = date_valid?(conn)
-          assign(conn, :valid_signature, signature_valid && date_valid)
+      conn =
+        if conn.assigns[:digest] do
+          conn
+          |> put_req_header("digest", conn.assigns[:digest])
         else
-          Logger.debug("No signature header!")
           conn
         end
 
-      _ ->
-        conn
+      signature_valid = HTTPSignatures.validate_conn(conn)
+      Logger.debug("Is signature valid ? #{inspect(signature_valid)}")
+      date_valid = date_valid?(conn)
+      assign(conn, :valid_signature, signature_valid && date_valid)
     end
   end
 
   @spec date_valid?(Plug.Conn.t()) :: boolean()
   defp date_valid?(conn) do
-    with [date | _] <- get_req_header(conn, "date") || [""],
-         {:ok, date} <- Timex.parse(date, "{WDshort}, {0D} {Mshort} {YYYY} {h24}:{m}:{s} GMT") do
-      Timex.diff(date, DateTime.utc_now(), :hours) <= 12 &&
-        Timex.diff(date, DateTime.utc_now(), :hours) >= -12
+    date = conn |> get_req_header("date") |> List.first()
+
+    if is_nil(date) do
+      false
     else
-      _ -> false
+      case Timex.parse(date, "{WDshort}, {0D} {Mshort} {YYYY} {h24}:{m}:{s} GMT") do
+        {:ok, %NaiveDateTime{} = date} ->
+          date
+          |> DateTime.from_naive!("Etc/UTC")
+          |> date_diff_ok?()
+
+        {:ok, %DateTime{} = date} ->
+          date_diff_ok?(date)
+
+        {:error, _err} ->
+          false
+      end
     end
   end
+
+  @spec date_diff_ok?(DateTime.t()) :: boolean()
+  defp date_diff_ok?(%DateTime{} = date) do
+    DateTime.diff(date, DateTime.utc_now()) <= 12 * 3600 &&
+      DateTime.diff(date, DateTime.utc_now()) >= -12 * 3600
+  end
 end
diff --git a/lib/web/plugs/mapped_signature_to_identity.ex b/lib/web/plugs/mapped_signature_to_identity.ex
index 548f3ac0c..0ae8d252b 100644
--- a/lib/web/plugs/mapped_signature_to_identity.ex
+++ b/lib/web/plugs/mapped_signature_to_identity.ex
@@ -18,6 +18,7 @@ defmodule Mobilizon.Web.Plugs.MappedSignatureToIdentity do
 
   require Logger
 
+  @spec init(any()) :: any()
   def init(options), do: options
 
   @spec key_id_from_conn(Plug.Conn.t()) :: String.t() | nil
@@ -42,6 +43,7 @@ defmodule Mobilizon.Web.Plugs.MappedSignatureToIdentity do
     end
   end
 
+  @spec call(Plug.Conn.t(), any()) :: Plug.Conn.t()
   def call(%{assigns: %{actor: _}} = conn, _opts), do: conn
 
   # if this has payload make sure it is signed by the same actor that made it
diff --git a/lib/web/plugs/set_locale_plug.ex b/lib/web/plugs/set_locale_plug.ex
index 0af554e13..fbfc371ea 100644
--- a/lib/web/plugs/set_locale_plug.ex
+++ b/lib/web/plugs/set_locale_plug.ex
@@ -11,8 +11,10 @@ defmodule Mobilizon.Web.Plugs.SetLocalePlug do
   import Plug.Conn, only: [assign: 3]
   alias Mobilizon.Web.Gettext, as: GettextBackend
 
+  @spec init(any()) :: nil
   def init(_), do: nil
 
+  @spec call(Plug.Conn.t(), any()) :: Plug.Conn.t()
   def call(conn, _) do
     locale =
       [
@@ -29,17 +31,22 @@ defmodule Mobilizon.Web.Plugs.SetLocalePlug do
     assign(conn, :locale, locale)
   end
 
+  @spec supported_locale?(String.t()) :: boolean()
   defp supported_locale?(locale) do
     GettextBackend
     |> Gettext.known_locales()
     |> Enum.member?(locale)
   end
 
+  @spec default_locale :: String.t()
   defp default_locale do
     Keyword.get(Mobilizon.Config.instance_config(), :default_language, "en")
   end
 
-  @spec determine_best_locale(String.t()) :: String.t()
+  @doc """
+  Determine the best available locale for a given locale ID
+  """
+  @spec determine_best_locale(String.t()) :: String.t() | nil
   def determine_best_locale(locale) when is_binary(locale) do
     locale = String.trim(locale)
     locales = Gettext.known_locales(GettextBackend)
@@ -58,5 +65,6 @@ defmodule Mobilizon.Web.Plugs.SetLocalePlug do
   def determine_best_locale(_), do: nil
 
   # Keep only the first part of the locale
+  @spec split_locale(String.t()) :: String.t()
   defp split_locale(locale), do: locale |> String.split("_", trim: true, parts: 2) |> hd
 end
diff --git a/lib/web/plugs/uploaded_media.ex b/lib/web/plugs/uploaded_media.ex
index 14538249f..192890cf0 100644
--- a/lib/web/plugs/uploaded_media.ex
+++ b/lib/web/plugs/uploaded_media.ex
@@ -21,6 +21,7 @@ defmodule Mobilizon.Web.Plugs.UploadedMedia do
   # no slashes
   @path "media"
 
+  @spec init(any()) :: map()
   def init(_opts) do
     static_plug_opts =
       []
@@ -31,6 +32,7 @@ defmodule Mobilizon.Web.Plugs.UploadedMedia do
     %{static_plug_opts: static_plug_opts}
   end
 
+  @spec call(Plug.Conn.t(), map()) :: Plug.Conn.t()
   def call(%{request_path: <<"/", @path, "/", file::binary>>} = conn, opts) do
     conn =
       case fetch_query_params(conn) do
@@ -45,11 +47,13 @@ defmodule Mobilizon.Web.Plugs.UploadedMedia do
 
     config = Config.get([Upload])
 
-    with uploader <- Keyword.fetch!(config, :uploader),
-         proxy_remote = Keyword.get(config, :proxy_remote, false),
-         {:ok, get_method} <- uploader.get_file(file) do
-      get_media(conn, get_method, proxy_remote, opts)
-    else
+    uploader = Keyword.fetch!(config, :uploader)
+    proxy_remote = Keyword.get(config, :proxy_remote, false)
+
+    case uploader.get_file(file) do
+      {:ok, get_method} ->
+        get_media(conn, get_method, proxy_remote, opts)
+
       _ ->
         conn
         |> send_resp(500, "Failed")
@@ -59,6 +63,12 @@ defmodule Mobilizon.Web.Plugs.UploadedMedia do
 
   def call(conn, _opts), do: conn
 
+  @spec get_media(
+          Plug.Conn.t(),
+          {:static_dir, String.t()} | {:url, String.t()} | any(),
+          boolean,
+          any()
+        ) :: Plug.Conn.t()
   defp get_media(conn, {:static_dir, directory}, _, opts) do
     static_opts =
       opts
diff --git a/lib/web/proxy/reverse_proxy.ex b/lib/web/proxy/reverse_proxy.ex
index f09d751a0..9bb83b5a7 100644
--- a/lib/web/proxy/reverse_proxy.ex
+++ b/lib/web/proxy/reverse_proxy.ex
@@ -165,6 +165,11 @@ defmodule Mobilizon.Web.ReverseProxy do
     |> halt()
   end
 
+  @spec request(String.t(), String.t(), list(tuple()), Keyword.t()) ::
+          {:ok, 200 | 206 | 304, list(tuple()), any()}
+          | {:ok, 200 | 206 | 304, list(tuple())}
+          | {:error, {:invalid_http_response, pos_integer()}}
+          | {:error, any()}
   defp request(method, url, headers, hackney_opts) do
     Logger.debug("#{__MODULE__} #{method} #{url} #{inspect(headers)}")
     method = method |> String.downcase() |> String.to_existing_atom()
@@ -184,6 +189,8 @@ defmodule Mobilizon.Web.ReverseProxy do
     end
   end
 
+  @spec response(Plug.Conn.t(), any(), String.t(), pos_integer(), list(tuple()), Keyword.t()) ::
+          Plug.Conn.t()
   defp response(conn, client, url, status, headers, opts) do
     result =
       conn
@@ -209,18 +216,26 @@ defmodule Mobilizon.Web.ReverseProxy do
     end
   end
 
+  @spec chunk_reply(
+          Plug.Conn.t(),
+          any(),
+          Keyword.t(),
+          non_neg_integer(),
+          non_neg_integer() | :no_duration_limit
+        ) ::
+          {:ok, Plug.Conn.t()} | {:error, any(), Plug.Conn.t()}
   defp chunk_reply(conn, client, opts) do
     chunk_reply(conn, client, opts, 0, 0)
   end
 
   defp chunk_reply(conn, client, opts, sent_so_far, duration) do
-    with {:ok, duration} <-
+    with {:ok, {duration, now}} <-
            check_read_duration(
              duration,
              Keyword.get(opts, :max_read_duration, @max_read_duration)
            ),
          {:ok, data} <- @hackney.stream_body(client),
-         {:ok, duration} <- increase_read_duration(duration),
+         {:ok, duration} <- increase_read_duration({duration, now}),
          sent_so_far = sent_so_far + byte_size(data),
          :ok <- body_size_constraint(sent_so_far, Keyword.get(opts, :max_body_size)),
          {:ok, conn} <- chunk(conn, data) do
@@ -231,6 +246,8 @@ defmodule Mobilizon.Web.ReverseProxy do
     end
   end
 
+  @spec head_response(Plug.Conn.t(), any(), pos_integer(), list(tuple()), Keyword.t()) ::
+          Plug.Conn.t() | no_return()
   defp head_response(conn, _url, code, headers, opts) do
     conn
     |> put_resp_headers(build_resp_headers(headers, opts))
@@ -238,6 +255,8 @@ defmodule Mobilizon.Web.ReverseProxy do
   end
 
   # sobelow_skip ["XSS.SendResp"]
+  @spec error_or_redirect(Plug.Conn.t(), String.t(), pos_integer(), String.t(), Keyword.t()) ::
+          Plug.Conn.t()
   defp error_or_redirect(conn, url, code, body, opts) do
     if Keyword.get(opts, :redirect_on_failure, false) do
       conn
@@ -250,12 +269,14 @@ defmodule Mobilizon.Web.ReverseProxy do
     end
   end
 
+  @spec downcase_headers(list(tuple())) :: list(tuple())
   defp downcase_headers(headers) do
     Enum.map(headers, fn {k, v} ->
       {String.downcase(k), v}
     end)
   end
 
+  @spec get_content_type(list(tuple())) :: String.t()
   defp get_content_type(headers) do
     {_, content_type} =
       List.keyfind(headers, "content-type", 0, {"content-type", "application/octet-stream"})
@@ -264,12 +285,14 @@ defmodule Mobilizon.Web.ReverseProxy do
     content_type
   end
 
+  @spec put_resp_headers(Plug.Conn.t(), list(tuple())) :: Plug.Conn.t()
   defp put_resp_headers(conn, headers) do
     Enum.reduce(headers, conn, fn {k, v}, conn ->
       put_resp_header(conn, k, v)
     end)
   end
 
+  @spec build_req_headers(list(tuple()), Keyword.t()) :: list(tuple())
   defp build_req_headers(headers, opts) do
     headers
     |> downcase_headers()
@@ -290,6 +313,7 @@ defmodule Mobilizon.Web.ReverseProxy do
         end).()
   end
 
+  @spec build_resp_headers(list(tuple()), Keyword.t()) :: list(tuple())
   defp build_resp_headers(headers, opts) do
     headers
     |> Enum.filter(fn {k, _} -> k in @keep_resp_headers end)
@@ -298,6 +322,7 @@ defmodule Mobilizon.Web.ReverseProxy do
     |> (fn headers -> headers ++ Keyword.get(opts, :resp_headers, []) end).()
   end
 
+  @spec build_resp_cache_headers(list(tuple()), Keyword.t()) :: list(tuple())
   defp build_resp_cache_headers(headers, _opts) do
     has_cache? = Enum.any?(headers, fn {k, _} -> k in @resp_cache_headers end)
     has_cache_control? = List.keymember?(headers, "cache-control", 0)
@@ -321,6 +346,7 @@ defmodule Mobilizon.Web.ReverseProxy do
     end
   end
 
+  @spec build_resp_content_disposition_header(list(tuple()), Keyword.t()) :: list(tuple())
   defp build_resp_content_disposition_header(headers, opts) do
     opt = Keyword.get(opts, :inline_content_types, @inline_content_types)
 
@@ -359,6 +385,8 @@ defmodule Mobilizon.Web.ReverseProxy do
     end
   end
 
+  @spec header_length_constraint(list(tuple()), non_neg_integer()) ::
+          :ok | {:error, :body_too_large}
   defp header_length_constraint(headers, limit) when is_integer(limit) and limit > 0 do
     with {_, size} <- List.keyfind(headers, "content-length", 0),
          {size, _} <- Integer.parse(size),
@@ -375,12 +403,17 @@ defmodule Mobilizon.Web.ReverseProxy do
 
   defp header_length_constraint(_, _), do: :ok
 
+  @spec body_size_constraint(integer(), integer()) :: :ok | {:error, :body_too_large}
   defp body_size_constraint(size, limit) when is_integer(limit) and limit > 0 and size >= limit do
     {:error, :body_too_large}
   end
 
   defp body_size_constraint(_, _), do: :ok
 
+  @spec check_read_duration(any(), integer() | :no_duration_limit) ::
+          {:ok, {integer(), integer()}}
+          | {:ok, {:no_duration_limit, :no_duration_limit}}
+          | {:error, :read_duration_exceeded}
   defp check_read_duration(duration, max)
        when is_integer(duration) and is_integer(max) and max > 0 do
     if duration > max do
@@ -390,8 +423,12 @@ defmodule Mobilizon.Web.ReverseProxy do
     end
   end
 
-  defp check_read_duration(_, _), do: {:ok, :no_duration_limit, :no_duration_limit}
+  defp check_read_duration(_, _), do: {:ok, {:no_duration_limit, :no_duration_limit}}
 
+  @spec increase_read_duration(
+          {previous_duration :: pos_integer | :no_duration_limit,
+           started :: pos_integer | :no_duration_limit}
+        ) :: {:ok, pos_integer()} | {:ok, :no_duration_limit}
   defp increase_read_duration({previous_duration, started})
        when is_integer(previous_duration) and is_integer(started) do
     duration = :erlang.system_time(:millisecond) - started
@@ -399,9 +436,10 @@ defmodule Mobilizon.Web.ReverseProxy do
   end
 
   defp increase_read_duration(_) do
-    {:ok, :no_duration_limit, :no_duration_limit}
+    {:ok, :no_duration_limit}
   end
 
+  @spec filename(String.t()) :: String.t() | nil
   def filename(url_or_path) do
     if path = URI.parse(url_or_path).path, do: Path.basename(path)
   end
diff --git a/lib/web/templates/email/activity/_comment_activity_item.html.eex b/lib/web/templates/email/activity/_comment_activity_item.html.eex
index 4a9abd54b..7b648bb46 100644
--- a/lib/web/templates/email/activity/_comment_activity_item.html.eex
+++ b/lib/web/templates/email/activity/_comment_activity_item.html.eex
@@ -5,7 +5,7 @@
                 %{
                     profile: "<b>#{Mobilizon.Actors.Actor.display_name_and_username(@activity.author)}</b>",
                     event: "<a href=\"#{
-                        page_url(
+                        Routes.page_url(
                             Mobilizon.Web.Endpoint,
                             :event,
                             @activity.subject_params["event_uuid"]
@@ -20,7 +20,7 @@
                 %{
                     profile: "<b>#{Mobilizon.Actors.Actor.display_name_and_username(@activity.author)}</b>",
                     event: "<a href=\"#{
-                        page_url(
+                        Routes.page_url(
                             Mobilizon.Web.Endpoint,
                             :event,
                             @activity.subject_params["event_uuid"]
@@ -37,7 +37,7 @@
                     %{
                         profile: "<b>#{Mobilizon.Actors.Actor.display_name_and_username(@activity.author)}</b>",
                         event: "<a href=\"#{
-                            page_url(
+                            Routes.page_url(
                                 Mobilizon.Web.Endpoint,
                                 :event,
                                 @activity.subject_params["event_uuid"]
@@ -52,7 +52,7 @@
                     %{
                         profile: "<b>#{Mobilizon.Actors.Actor.display_name_and_username(@activity.author)}</b>",
                         event: "<a href=\"#{
-                            page_url(
+                            Routes.page_url(
                                 Mobilizon.Web.Endpoint,
                                 :event,
                                 @activity.subject_params["event_uuid"]
diff --git a/lib/web/templates/email/activity/_comment_activity_item.text.eex b/lib/web/templates/email/activity/_comment_activity_item.text.eex
index 145a3d7c1..f097b2732 100644
--- a/lib/web/templates/email/activity/_comment_activity_item.text.eex
+++ b/lib/web/templates/email/activity/_comment_activity_item.text.eex
@@ -4,22 +4,22 @@
         event: @activity.subject_params["event_title"]
     }
 ) %>
-<%= page_url(Mobilizon.Web.Endpoint, :event, @activity.subject_params["event_uuid"]) |> URI.decode() %><% :participation_event_comment -> %><%= dgettext("activity", "%{profile} has posted an announcement under event %{event}.",
+<%= Routes.page_url(Mobilizon.Web.Endpoint, :event, @activity.subject_params["event_uuid"]) |> URI.decode() %><% :participation_event_comment -> %><%= dgettext("activity", "%{profile} has posted an announcement under event %{event}.",
     %{
         profile: Mobilizon.Actors.Actor.display_name_and_username(@activity.author),
         event: @activity.subject_params["event_title"]
     }
 ) %>
-<%= page_url(Mobilizon.Web.Endpoint, :event, @activity.subject_params["event_uuid"]) |> URI.decode() %><% :event_new_comment -> %><%= if @activity.subject_params["comment_reply_to"] do %><%=dgettext("activity", "%{profile} has posted a new reply under your event %{event}.",
+<%= Routes.page_url(Mobilizon.Web.Endpoint, :event, @activity.subject_params["event_uuid"]) |> URI.decode() %><% :event_new_comment -> %><%= if @activity.subject_params["comment_reply_to"] do %><%=dgettext("activity", "%{profile} has posted a new reply under your event %{event}.",
     %{
         profile: Mobilizon.Actors.Actor.display_name_and_username(@activity.author),
         event: @activity.subject_params["event_title"]
     }
 ) %>
-<%= "#{page_url(Mobilizon.Web.Endpoint, :event, @activity.subject_params["event_uuid"]) |> URI.decode()}#comment-#{@activity.subject_params["comment_reply_to_uuid"]}-#{@activity.subject_params["comment_uuid"]}" %><% else %><%= dgettext("activity", "%{profile} has posted a new comment under your event %{event}.", 
+<%= "#{Routes.page_url(Mobilizon.Web.Endpoint, :event, @activity.subject_params["event_uuid"]) |> URI.decode()}#comment-#{@activity.subject_params["comment_reply_to_uuid"]}-#{@activity.subject_params["comment_uuid"]}" %><% else %><%= dgettext("activity", "%{profile} has posted a new comment under your event %{event}.", 
 %{
     profile: Mobilizon.Actors.Actor.display_name_and_username(@activity.author),
     event: @activity.subject_params["event_title"]
 }
 ) %>
-<%= "#{page_url(Mobilizon.Web.Endpoint, :event, @activity.subject_params["event_uuid"]) |> URI.decode()}#comment-#{@activity.subject_params["comment_uuid"]}"%><% end %><% end %>
\ No newline at end of file
+<%= "#{Routes.page_url(Mobilizon.Web.Endpoint, :event, @activity.subject_params["event_uuid"]) |> URI.decode()}#comment-#{@activity.subject_params["comment_uuid"]}"%><% end %><% end %>
\ No newline at end of file
diff --git a/lib/web/templates/email/activity/_discussion_activity_item.html.eex b/lib/web/templates/email/activity/_discussion_activity_item.html.eex
index b678ae5ab..3a74f1168 100644
--- a/lib/web/templates/email/activity/_discussion_activity_item.html.eex
+++ b/lib/web/templates/email/activity/_discussion_activity_item.html.eex
@@ -5,7 +5,7 @@
                 %{
                     profile: "<b>#{Mobilizon.Actors.Actor.display_name_and_username(@activity.author)}</b>",
                     discussion: "<a href=\"#{
-                        page_url(
+                        Routes.page_url(
                             Mobilizon.Web.Endpoint,
                             :discussion,
                             Mobilizon.Actors.Actor.preferred_username_and_domain(@activity.group), @activity.subject_params["discussion_slug"]
@@ -19,7 +19,7 @@
                 %{
                     profile: "<b>#{Mobilizon.Actors.Actor.display_name_and_username(@activity.author)}</b>",
                     discussion: "<a href=\"#{
-                        page_url(
+                        Routes.page_url(
                             Mobilizon.Web.Endpoint,
                             :discussion,
                             Mobilizon.Actors.Actor.preferred_username_and_domain(@activity.group), @activity.subject_params["discussion_slug"]
@@ -33,7 +33,7 @@
                 %{
                     profile: "<b>#{Mobilizon.Actors.Actor.display_name_and_username(@activity.author)}</b>",
                     discussion: "<a href=\"#{
-                        page_url(
+                        Routes.page_url(
                             Mobilizon.Web.Endpoint,
                             :discussion,
                             Mobilizon.Actors.Actor.preferred_username_and_domain(@activity.group), @activity.subject_params["discussion_slug"]
@@ -47,7 +47,7 @@
                 %{
                     profile: "<b>#{Mobilizon.Actors.Actor.display_name_and_username(@activity.author)}</b>",
                     discussion: "<a href=\"#{
-                        page_url(
+                        Routes.page_url(
                             Mobilizon.Web.Endpoint,
                             :discussion,
                             Mobilizon.Actors.Actor.preferred_username_and_domain(@activity.group), @activity.subject_params["discussion_slug"]
diff --git a/lib/web/templates/email/activity/_discussion_activity_item.text.eex b/lib/web/templates/email/activity/_discussion_activity_item.text.eex
index 463fbde46..97e676649 100644
--- a/lib/web/templates/email/activity/_discussion_activity_item.text.eex
+++ b/lib/web/templates/email/activity/_discussion_activity_item.text.eex
@@ -4,25 +4,25 @@
         discussion: @activity.subject_params["discussion_title"]
     }
 ) %>
-<%= page_url(Mobilizon.Web.Endpoint, :discussion, Mobilizon.Actors.Actor.preferred_username_and_domain(@activity.group), @activity.subject_params["discussion_slug"]) |> URI.decode() %><% :discussion_replied -> %><%= dgettext("activity", "%{profile} replied to the discussion %{discussion}.", 
+<%= Routes.page_url(Mobilizon.Web.Endpoint, :discussion, Mobilizon.Actors.Actor.preferred_username_and_domain(@activity.group), @activity.subject_params["discussion_slug"]) |> URI.decode() %><% :discussion_replied -> %><%= dgettext("activity", "%{profile} replied to the discussion %{discussion}.", 
     %{
         profile: Mobilizon.Actors.Actor.display_name_and_username(@activity.author),
         discussion: @activity.subject_params["discussion_title"]
     }
 ) %>
-<%= page_url(Mobilizon.Web.Endpoint, :discussion, Mobilizon.Actors.Actor.preferred_username_and_domain(@activity.group), @activity.subject_params["discussion_slug"]) |> URI.decode() %><% :discussion_renamed -> %><%= dgettext("activity", "%{profile} renamed the discussion %{discussion}.", 
+<%= Routes.page_url(Mobilizon.Web.Endpoint, :discussion, Mobilizon.Actors.Actor.preferred_username_and_domain(@activity.group), @activity.subject_params["discussion_slug"]) |> URI.decode() %><% :discussion_renamed -> %><%= dgettext("activity", "%{profile} renamed the discussion %{discussion}.", 
     %{
         profile: Mobilizon.Actors.Actor.display_name_and_username(@activity.author),
         discussion: @activity.subject_params["discussion_title"]
     }
 ) %>
-<%= page_url(Mobilizon.Web.Endpoint, :discussion, Mobilizon.Actors.Actor.preferred_username_and_domain(@activity.group), @activity.subject_params["discussion_slug"]) |> URI.decode() %><% :discussion_archived -> %><%= dgettext("activity", "%{profile} archived the discussion %{discussion}.", 
+<%= Routes.page_url(Mobilizon.Web.Endpoint, :discussion, Mobilizon.Actors.Actor.preferred_username_and_domain(@activity.group), @activity.subject_params["discussion_slug"]) |> URI.decode() %><% :discussion_archived -> %><%= dgettext("activity", "%{profile} archived the discussion %{discussion}.", 
     %{
         profile: Mobilizon.Actors.Actor.display_name_and_username(@activity.author),
         discussion: @activity.subject_params["discussion_title"]
     }
 ) %>
-<%= page_url(Mobilizon.Web.Endpoint, :discussion, Mobilizon.Actors.Actor.preferred_username_and_domain(@activity.group), @activity.subject_params["discussion_slug"]) |> URI.decode() %><% :discussion_deleted -> %><%= dgettext("activity", "%{profile} deleted the discussion %{discussion}.", 
+<%= Routes.page_url(Mobilizon.Web.Endpoint, :discussion, Mobilizon.Actors.Actor.preferred_username_and_domain(@activity.group), @activity.subject_params["discussion_slug"]) |> URI.decode() %><% :discussion_deleted -> %><%= dgettext("activity", "%{profile} deleted the discussion %{discussion}.", 
     %{
         profile: Mobilizon.Actors.Actor.display_name_and_username(@activity.author),
         discussion: @activity.subject_params["discussion_title"]
diff --git a/lib/web/templates/email/activity/_event_activity_item.html.eex b/lib/web/templates/email/activity/_event_activity_item.html.eex
index 074e9c4a6..5f32ab87b 100644
--- a/lib/web/templates/email/activity/_event_activity_item.html.eex
+++ b/lib/web/templates/email/activity/_event_activity_item.html.eex
@@ -5,7 +5,7 @@
                 %{
                     profile: "<b>#{Mobilizon.Actors.Actor.display_name_and_username(@activity.author)}</b>",
                     event: "<a href=\"#{
-                        page_url(
+                        Routes.page_url(
                             Mobilizon.Web.Endpoint,
                             :event,
                             @activity.subject_params["event_uuid"]
@@ -20,7 +20,7 @@
                 %{
                     profile: "<b>#{Mobilizon.Actors.Actor.display_name_and_username(@activity.author)}</b>",
                     event: "<a href=\"#{
-                        page_url(
+                        Routes.page_url(
                             Mobilizon.Web.Endpoint,
                             :event,
                             @activity.subject_params["event_uuid"]
@@ -44,7 +44,7 @@
                 %{
                     profile: "<b>#{Mobilizon.Actors.Actor.display_name_and_username(@activity.author)}</b>",
                     event: "<a href=\"#{
-                        page_url(
+                        Routes.page_url(
                             Mobilizon.Web.Endpoint,
                             :event,
                             @activity.subject_params["event_uuid"]
@@ -59,7 +59,7 @@
                 %{
                     profile: "<b>#{Mobilizon.Actors.Actor.display_name_and_username(@activity.author)}</b>",
                     event: "<a href=\"#{
-                        page_url(
+                        Routes.page_url(
                             Mobilizon.Web.Endpoint,
                             :event,
                             @activity.subject_params["event_uuid"]
diff --git a/lib/web/templates/email/activity/_event_activity_item.text.eex b/lib/web/templates/email/activity/_event_activity_item.text.eex
index 80e1b1e51..390bd2611 100644
--- a/lib/web/templates/email/activity/_event_activity_item.text.eex
+++ b/lib/web/templates/email/activity/_event_activity_item.text.eex
@@ -4,13 +4,13 @@
         event: @activity.subject_params["event_title"]
     }
 ) %>
-<%= page_url(Mobilizon.Web.Endpoint, :event, @activity.subject_params["event_uuid"]) |> URI.decode() %><% :event_updated -> %><%= dgettext("activity", "The event %{event} was updated by %{profile}.", 
+<%= Routes.page_url(Mobilizon.Web.Endpoint, :event, @activity.subject_params["event_uuid"]) |> URI.decode() %><% :event_updated -> %><%= dgettext("activity", "The event %{event} was updated by %{profile}.", 
     %{
         profile: Mobilizon.Actors.Actor.display_name_and_username(@activity.author),
         event: @activity.subject_params["event_title"]
     }
 ) %>
-<%= page_url(Mobilizon.Web.Endpoint, :event, @activity.subject_params["event_uuid"]) |> URI.decode() %><% :event_deleted -> %><%= dgettext("activity", "The event %{event} was deleted by %{profile}.", 
+<%= Routes.page_url(Mobilizon.Web.Endpoint, :event, @activity.subject_params["event_uuid"]) |> URI.decode() %><% :event_deleted -> %><%= dgettext("activity", "The event %{event} was deleted by %{profile}.", 
     %{
         profile: Mobilizon.Actors.Actor.display_name_and_username(@activity.author),
         event: @activity.subject_params["event_title"]
@@ -22,10 +22,10 @@
         event: @activity.subject_params["event_title"]
     }
 ) %>
-<%= page_url(Mobilizon.Web.Endpoint, :event, @activity.subject_params["event_uuid"]) |> URI.decode() %><% else %><%= dgettext("activity", "%{profile} posted a comment on the event %{event}.", 
+<%= Routes.page_url(Mobilizon.Web.Endpoint, :event, @activity.subject_params["event_uuid"]) |> URI.decode() %><% else %><%= dgettext("activity", "%{profile} posted a comment on the event %{event}.", 
     %{
         profile: Mobilizon.Actors.Actor.display_name_and_username(@activity.author),
         event: @activity.subject_params["event_title"]
     }
 ) %>
-<%= page_url(Mobilizon.Web.Endpoint, :event, @activity.subject_params["event_uuid"]) |> URI.decode() %><% end %><% end %>
\ No newline at end of file
+<%= Routes.page_url(Mobilizon.Web.Endpoint, :event, @activity.subject_params["event_uuid"]) |> URI.decode() %><% end %><% end %>
\ No newline at end of file
diff --git a/lib/web/templates/email/activity/_group_activity_item.html.eex b/lib/web/templates/email/activity/_group_activity_item.html.eex
index a17c7956f..bf4be4e8e 100644
--- a/lib/web/templates/email/activity/_group_activity_item.html.eex
+++ b/lib/web/templates/email/activity/_group_activity_item.html.eex
@@ -5,7 +5,7 @@
                 %{
                     profile: "<b>#{Mobilizon.Actors.Actor.display_name_and_username(@activity.author)}</b>",
                     group: "<a href=\"#{
-                        page_url(
+                        Routes.page_url(
                             Mobilizon.Web.Endpoint,
                             :actor,
                             @activity.subject_params["group_federated_username"]
@@ -20,7 +20,7 @@
                 %{
                     profile: "<b>#{Mobilizon.Actors.Actor.display_name_and_username(@activity.author)}</b>",
                     group: "<a href=\"#{
-                        page_url(
+                        Routes.page_url(
                             Mobilizon.Web.Endpoint,
                             :actor,
                             @activity.subject_params["group_federated_username"]
diff --git a/lib/web/templates/email/activity/_group_activity_item.text.eex b/lib/web/templates/email/activity/_group_activity_item.text.eex
index 8dd2d8845..48308f74b 100644
--- a/lib/web/templates/email/activity/_group_activity_item.text.eex
+++ b/lib/web/templates/email/activity/_group_activity_item.text.eex
@@ -4,10 +4,10 @@
         group: @activity.subject_params["group_name"]
     }
 ) %>
-<%= page_url(Mobilizon.Web.Endpoint, :actor, @activity.subject_params["group_federated_username"]) |> URI.decode() %><% :group_updated -> %><%= dgettext("activity", "%{profile} updated the group %{group}.", 
+<%= Routes.page_url(Mobilizon.Web.Endpoint, :actor, @activity.subject_params["group_federated_username"]) |> URI.decode() %><% :group_updated -> %><%= dgettext("activity", "%{profile} updated the group %{group}.", 
     %{
         profile: Mobilizon.Actors.Actor.display_name_and_username(@activity.author),
         group: @activity.subject_params["group_name"]
     }
 ) %>
-<%= page_url(Mobilizon.Web.Endpoint, :actor, @activity.subject_params["group_federated_username"]) |> URI.decode() %><% end %>
\ No newline at end of file
+<%= Routes.page_url(Mobilizon.Web.Endpoint, :actor, @activity.subject_params["group_federated_username"]) |> URI.decode() %><% end %>
\ No newline at end of file
diff --git a/lib/web/templates/email/activity/_post_activity_item.html.eex b/lib/web/templates/email/activity/_post_activity_item.html.eex
index 856056be9..81733b4ab 100644
--- a/lib/web/templates/email/activity/_post_activity_item.html.eex
+++ b/lib/web/templates/email/activity/_post_activity_item.html.eex
@@ -5,7 +5,7 @@
                 %{
                     profile: "<b>#{Mobilizon.Actors.Actor.display_name_and_username(@activity.author)}</b>",
                     post: "<a href=\"#{
-                        page_url(
+                        Routes.page_url(
                             Mobilizon.Web.Endpoint,
                             :post,
                             @activity.subject_params["post_slug"]
@@ -20,7 +20,7 @@
                 %{
                     profile: "<b>#{Mobilizon.Actors.Actor.display_name_and_username(@activity.author)}</b>",
                     post: "<a href=\"#{
-                        page_url(
+                        Routes.page_url(
                             Mobilizon.Web.Endpoint,
                             :post,
                             @activity.subject_params["post_slug"]
diff --git a/lib/web/templates/email/activity/_post_activity_item.text.eex b/lib/web/templates/email/activity/_post_activity_item.text.eex
index 2fc6143c4..ee9c37c9b 100644
--- a/lib/web/templates/email/activity/_post_activity_item.text.eex
+++ b/lib/web/templates/email/activity/_post_activity_item.text.eex
@@ -4,13 +4,13 @@
         post: @activity.subject_params["post_title"]
     }
 ) %>
-<%= page_url(Mobilizon.Web.Endpoint, :post, @activity.subject_params["post_slug"]) |> URI.decode() %><% :post_updated -> %><%= dgettext("activity", "The post %{post} was updated by %{profile}.", 
+<%= Routes.page_url(Mobilizon.Web.Endpoint, :post, @activity.subject_params["post_slug"]) |> URI.decode() %><% :post_updated -> %><%= dgettext("activity", "The post %{post} was updated by %{profile}.", 
     %{
         profile: Mobilizon.Actors.Actor.display_name_and_username(@activity.author),
         post: @activity.subject_params["post_title"]
     }
 ) %>
-<%= page_url(Mobilizon.Web.Endpoint, :post, @activity.subject_params["post_slug"]) |> URI.decode() %><% :post_deleted -> %><%= dgettext("activity", "The post %{post} was deleted by %{profile}.", 
+<%= Routes.page_url(Mobilizon.Web.Endpoint, :post, @activity.subject_params["post_slug"]) |> URI.decode() %><% :post_deleted -> %><%= dgettext("activity", "The post %{post} was deleted by %{profile}.", 
     %{
         profile: Mobilizon.Actors.Actor.display_name_and_username(@activity.author),
         post: @activity.subject_params["post_title"]
diff --git a/lib/web/templates/email/activity/_resource_activity_item.html.eex b/lib/web/templates/email/activity/_resource_activity_item.html.eex
index ad5b42d5e..6a894c83a 100644
--- a/lib/web/templates/email/activity/_resource_activity_item.html.eex
+++ b/lib/web/templates/email/activity/_resource_activity_item.html.eex
@@ -6,7 +6,7 @@
                     %{
                         profile: "<b>#{Mobilizon.Actors.Actor.display_name_and_username(@activity.author)}</b>",
                         resource: "<a href=\"#{
-                            page_url(
+                            Routes.page_url(
                                 Mobilizon.Web.Endpoint,
                                 :resource,
                                 @activity.subject_params["resource_uuid"]
@@ -21,7 +21,7 @@
                     %{
                         profile: "<b>#{Mobilizon.Actors.Actor.display_name_and_username(@activity.author)}</b>",
                         resource: "<a href=\"#{
-                            page_url(
+                            Routes.page_url(
                                 Mobilizon.Web.Endpoint,
                                 :resource,
                                 @activity.subject_params["resource_uuid"]
@@ -38,7 +38,7 @@
                     %{
                         profile: "<b>#{Mobilizon.Actors.Actor.display_name_and_username(@activity.author)}</b>",
                         resource: "<a href=\"#{
-                            page_url(
+                            Routes.page_url(
                                 Mobilizon.Web.Endpoint,
                                 :resource,
                                 @activity.subject_params["resource_uuid"]
@@ -54,7 +54,7 @@
                     %{
                         profile: "<b>#{Mobilizon.Actors.Actor.display_name_and_username(@activity.author)}</b>",
                         resource: "<a href=\"#{
-                            page_url(
+                            Routes.page_url(
                                 Mobilizon.Web.Endpoint,
                                 :resource,
                                 @activity.subject_params["resource_uuid"]
@@ -72,7 +72,7 @@
                     %{
                         profile: "<b>#{Mobilizon.Actors.Actor.display_name_and_username(@activity.author)}</b>",
                         resource: "<a href=\"#{
-                            page_url(
+                            Routes.page_url(
                                 Mobilizon.Web.Endpoint,
                                 :resource,
                                 @activity.subject_params["resource_uuid"]
@@ -87,7 +87,7 @@
                     %{
                         profile: "<b>#{Mobilizon.Actors.Actor.display_name_and_username(@activity.author)}</b>",
                         resource: "<a href=\"#{
-                            page_url(
+                            Routes.page_url(
                                 Mobilizon.Web.Endpoint,
                                 :resource,
                                 @activity.subject_params["resource_uuid"]
diff --git a/lib/web/templates/email/activity/_resource_activity_item.text.eex b/lib/web/templates/email/activity/_resource_activity_item.text.eex
index f54268ba9..bd9ded7ab 100644
--- a/lib/web/templates/email/activity/_resource_activity_item.text.eex
+++ b/lib/web/templates/email/activity/_resource_activity_item.text.eex
@@ -5,39 +5,39 @@
         resource: @activity.subject_params["resource_title"]
     }
 ) %>
-<%= page_url(Mobilizon.Web.Endpoint, :resource, @activity.subject_params["resource_uuid"]) |> URI.decode() %><% else %><%= dgettext("activity", "%{profile} created the resource %{resource}.", 
+<%= Routes.page_url(Mobilizon.Web.Endpoint, :resource, @activity.subject_params["resource_uuid"]) |> URI.decode() %><% else %><%= dgettext("activity", "%{profile} created the resource %{resource}.", 
     %{
         profile: Mobilizon.Actors.Actor.display_name_and_username(@activity.author),
         resource: @activity.subject_params["resource_title"]
     }
 ) %>
-<%= page_url(Mobilizon.Web.Endpoint, :resource, @activity.subject_params["resource_uuid"]) |> URI.decode() %><% end %><% :resource_renamed -> %><%= if @activity.subject_params["is_folder"] do %><%= dgettext("activity", "%{profile} renamed the folder from %{old_resource_title} to %{resource}.", 
+<%= Routes.page_url(Mobilizon.Web.Endpoint, :resource, @activity.subject_params["resource_uuid"]) |> URI.decode() %><% end %><% :resource_renamed -> %><%= if @activity.subject_params["is_folder"] do %><%= dgettext("activity", "%{profile} renamed the folder from %{old_resource_title} to %{resource}.", 
     %{
         profile: Mobilizon.Actors.Actor.display_name_and_username(@activity.author),
         resource: @activity.subject_params["resource_title"],
         old_resource_title: @activity.subject_params["old_resource_title"]
     }
 ) %>
-<%= page_url(Mobilizon.Web.Endpoint, :resource, @activity.subject_params["resource_uuid"]) |> URI.decode() %><% else %><%= dgettext("activity", "%{profile} renamed the resource from %{old_resource_title} to %{resource}.", 
+<%= Routes.page_url(Mobilizon.Web.Endpoint, :resource, @activity.subject_params["resource_uuid"]) |> URI.decode() %><% else %><%= dgettext("activity", "%{profile} renamed the resource from %{old_resource_title} to %{resource}.", 
     %{
         profile: Mobilizon.Actors.Actor.display_name_and_username(@activity.author),
         resource: @activity.subject_params["resource_title"],
         old_resource_title: @activity.subject_params["old_resource_title"]
     }
 ) %>
-<%= page_url(Mobilizon.Web.Endpoint, :resource, @activity.subject_params["resource_uuid"]) |> URI.decode() %><% end %><% :resource_moved -> %><%= if @activity.subject_params["is_folder"] do %><%= dgettext("activity", "%{profile} moved the folder %{resource}.", 
+<%= Routes.page_url(Mobilizon.Web.Endpoint, :resource, @activity.subject_params["resource_uuid"]) |> URI.decode() %><% end %><% :resource_moved -> %><%= if @activity.subject_params["is_folder"] do %><%= dgettext("activity", "%{profile} moved the folder %{resource}.", 
     %{
         profile: Mobilizon.Actors.Actor.display_name_and_username(@activity.author),
         resource: @activity.subject_params["resource_title"]
     }
 ) %>
-<%= page_url(Mobilizon.Web.Endpoint, :resource, @activity.subject_params["resource_uuid"]) |> URI.decode() %><% else %><%= dgettext("activity", "%{profile} moved the resource %{resource}.", 
+<%= Routes.page_url(Mobilizon.Web.Endpoint, :resource, @activity.subject_params["resource_uuid"]) |> URI.decode() %><% else %><%= dgettext("activity", "%{profile} moved the resource %{resource}.", 
     %{
         profile: Mobilizon.Actors.Actor.display_name_and_username(@activity.author),
         resource: @activity.subject_params["resource_title"]
     }
 ) %>
-<%= page_url(Mobilizon.Web.Endpoint, :resource, @activity.subject_params["resource_uuid"]) |> URI.decode() %><% end %><% :resource_deleted -> %><%= if @activity.subject_params["is_folder"] do %><%= dgettext("activity", "%{profile} deleted the folder %{resource}.", 
+<%= Routes.page_url(Mobilizon.Web.Endpoint, :resource, @activity.subject_params["resource_uuid"]) |> URI.decode() %><% end %><% :resource_deleted -> %><%= if @activity.subject_params["is_folder"] do %><%= dgettext("activity", "%{profile} deleted the folder %{resource}.", 
     %{
         profile: Mobilizon.Actors.Actor.display_name_and_username(@activity.author),
         resource: @activity.subject_params["resource_title"]
diff --git a/lib/web/templates/email/group_deletion.html.eex b/lib/web/templates/email/actor_suspension_participants.html.eex
similarity index 77%
rename from lib/web/templates/email/group_deletion.html.eex
rename to lib/web/templates/email/actor_suspension_participants.html.eex
index da88eff37..10c150ae9 100644
--- a/lib/web/templates/email/group_deletion.html.eex
+++ b/lib/web/templates/email/actor_suspension_participants.html.eex
@@ -10,7 +10,7 @@
       <tr>
         <td bgcolor="#ffffff" align="center" valign="top" style="padding: 40px 20px 20px 20px; border-radius: 4px 4px 0px 0px; color: #3A384C; font-family: 'Roboto', Helvetica, Arial, sans-serif; font-size: 48px; font-weight: 400; line-height: 48px;">
           <h1 style="font-size: 48px; font-weight: 400; margin: 0;">
-            <%= gettext "The group %{group} was deleted on %{instance}!", group: (@group.name || @group.preferred_username), instance: @instance %>
+            <%= gettext "Your participation to %{event} has been cancelled!", event: (@event.title), instance: @instance %>
           </h1>
         </td>
       </tr>
@@ -35,9 +35,7 @@
       <tr>
         <td bgcolor="#ffffff" align="left" style="padding: 20px 30px 0px 30px; color: #474467; font-family: 'Roboto', Helvetica, Arial, sans-serif; font-size: 18px; font-weight: 400; line-height: 25px;" >
           <p style="margin: 0;">
-            <%= gettext "The administrator %{author} deleted group %{group}. All of the group's events, discussions, posts and todos have been deleted.",
-  author: Mobilizon.Actors.Actor.display_name_and_username(@author),
-  group: Mobilizon.Actors.Actor.display_name_and_username(@group) %>
+            <%= gettext "Your instance's moderation team has decided to suspend %{actor_name} (%{actor_address}). All of their events have been removed and your participation cancelled.", group_name: @actor.name || @actor.preferred_username, actor_address: if @actor.domain, do: "@#{@actor.preferred_username}@#{@actor.domain}", else: "@#{@actor.preferred_username}" %>
           </p>
         </td>
       </tr>
diff --git a/lib/web/templates/email/actor_suspension_participants.text.eex b/lib/web/templates/email/actor_suspension_participants.text.eex
new file mode 100644
index 000000000..cb05eb2e4
--- /dev/null
+++ b/lib/web/templates/email/actor_suspension_participants.text.eex
@@ -0,0 +1,3 @@
+<%= gettext "Your participation to %{event} has been cancelled!", event: (@event.title), instance: @instance %>
+==
+<%= gettext "Your instance's moderation team has decided to suspend %{actor_name} (%{actor_address}). All of their events have been removed and your participation cancelled.", group_name: @actor.name || @actor.preferred_username, actor_address: if @actor.domain, do: "@#{@actor.preferred_username}@#{@actor.domain}", else: "@#{@actor.preferred_username}" %>
diff --git a/lib/web/templates/email/anonymous_participation_confirmation.html.eex b/lib/web/templates/email/anonymous_participation_confirmation.html.eex
index cbb6ce477..8cbb1a8b7 100644
--- a/lib/web/templates/email/anonymous_participation_confirmation.html.eex
+++ b/lib/web/templates/email/anonymous_participation_confirmation.html.eex
@@ -47,7 +47,7 @@
               <td bgcolor="#ffffff" align="center" style="padding: 20px 30px 60px 30px;">
                 <table border="0" cellspacing="0" cellpadding="0">
                   <tr>
-                    <td align="center" style="border-radius: 3px;" bgcolor="#3C376E"><a href="<%= page_url(Mobilizon.Web.Endpoint, :participation_email_confirmation, @participant.metadata.confirmation_token) %>" target="_blank" style="font-size: 20px; font-family: 'Roboto', Helvetica, Arial, sans-serif; color: #ffffff; text-decoration: none; padding: 15px 25px; border-radius: 2px; border: 1px solid #3C376E; display: inline-block;">
+                    <td align="center" style="border-radius: 3px;" bgcolor="#3C376E"><a href="<%= Routes.page_url(Mobilizon.Web.Endpoint, :participation_email_confirmation, @participant.metadata.confirmation_token) %>" target="_blank" style="font-size: 20px; font-family: 'Roboto', Helvetica, Arial, sans-serif; color: #ffffff; text-decoration: none; padding: 15px 25px; border-radius: 2px; border: 1px solid #3C376E; display: inline-block;">
                         <%= gettext "Confirm my e-mail address" %>
                       </a></td>
                   </tr>
diff --git a/lib/web/templates/email/anonymous_participation_confirmation.text.eex b/lib/web/templates/email/anonymous_participation_confirmation.text.eex
index b5e46e1da..ae4943c15 100644
--- a/lib/web/templates/email/anonymous_participation_confirmation.text.eex
+++ b/lib/web/templates/email/anonymous_participation_confirmation.text.eex
@@ -2,5 +2,5 @@
 ==
 <%= gettext "Hi there! You just registered to join this event: « %{title} ». Please confirm the e-mail address you provided:", title: @participant.event.title %>
 <%= gettext "If you didn't trigger this email, you may safely ignore it." %>
-<%= page_url(Mobilizon.Web.Endpoint, :participation_email_confirmation, @participant.metadata.confirmation_token) %>
+<%= Routes.page_url(Mobilizon.Web.Endpoint, :participation_email_confirmation, @participant.metadata.confirmation_token) %>
 <%= ngettext "Would you wish to cancel your attendance, visit the event page through the link above and click the « Attending » button.", "Would you wish to cancel your attendance to one or several events, visit the event pages through the links above and click the « Attending » button.", 1 %>
diff --git a/lib/web/templates/email/before_event_notification.html.eex b/lib/web/templates/email/before_event_notification.html.eex
index 213b038c2..ab4f54c83 100644
--- a/lib/web/templates/email/before_event_notification.html.eex
+++ b/lib/web/templates/email/before_event_notification.html.eex
@@ -47,7 +47,7 @@
               <td bgcolor="#ffffff" align="center" style="padding: 20px 30px 60px 30px;">
                 <table border="0" cellspacing="0" cellpadding="0">
                   <tr>
-                    <td align="center" style="border-radius: 3px;" bgcolor="#3C376E"><a href="<%= page_url(Mobilizon.Web.Endpoint, :event, @participant.event.uuid) %>" target="_blank" style="font-size: 20px; font-family: Helvetica, Arial, sans-serif; color: #ffffff; text-decoration: none; padding: 15px 25px; border-radius: 2px; border: 1px solid #3C376E; display: inline-block;">
+                    <td align="center" style="border-radius: 3px;" bgcolor="#3C376E"><a href="<%= Routes.page_url(Mobilizon.Web.Endpoint, :event, @participant.event.uuid) %>" target="_blank" style="font-size: 20px; font-family: Helvetica, Arial, sans-serif; color: #ffffff; text-decoration: none; padding: 15px 25px; border-radius: 2px; border: 1px solid #3C376E; display: inline-block;">
                         <%= gettext "Go to event page" %>
                       </a></td>
                   </tr>
diff --git a/lib/web/templates/email/before_event_notification.text.eex b/lib/web/templates/email/before_event_notification.text.eex
index f1f561c32..cb72a7cce 100644
--- a/lib/web/templates/email/before_event_notification.text.eex
+++ b/lib/web/templates/email/before_event_notification.text.eex
@@ -2,5 +2,5 @@
 ==
 <%= gettext "Get ready for %{title}", title: @participant.event.title %>
 <%= gettext "Go to event page" %>
-<%= gettext "View the event on: %{link}", link: page_url(Mobilizon.Web.Endpoint, :event, @participant.event.uuid) %>
+<%= gettext "View the event on: %{link}", link: Routes.page_url(Mobilizon.Web.Endpoint, :event, @participant.event.uuid) %>
 <%= gettext "If you wish to cancel your attendance, visit the event page through the link above and click the « Attending » button." %>
diff --git a/lib/web/templates/email/email_anonymous_activity.html.eex b/lib/web/templates/email/email_anonymous_activity.html.eex
index 66b95852a..52f624712 100644
--- a/lib/web/templates/email/email_anonymous_activity.html.eex
+++ b/lib/web/templates/email/email_anonymous_activity.html.eex
@@ -42,7 +42,7 @@
                     %{
                         profile: "<b>#{Mobilizon.Actors.Actor.display_name_and_username(@activity.author)}</b>",
                         event: "<a href=\"#{
-                            page_url(
+                            Routes.page_url(
                                 Mobilizon.Web.Endpoint,
                                 :event,
                                 @activity.subject_params["event_uuid"]
@@ -63,7 +63,7 @@
               <td bgcolor="#ffffff" align="center" style="padding: 20px 30px 60px 30px;">
                 <table border="0" cellspacing="0" cellpadding="0">
                   <tr>
-                    <td align="center" style="border-radius: 3px;" bgcolor="#3C376E"><a href="<%= page_url(Mobilizon.Web.Endpoint, :event, @activity.subject_params["event_uuid"]) %>" target="_blank" style="font-size: 20px; font-family: Helvetica, Arial, sans-serif; color: #ffffff; text-decoration: none; padding: 15px 25px; border-radius: 2px; border: 1px solid #3C376E; display: inline-block;">
+                    <td align="center" style="border-radius: 3px;" bgcolor="#3C376E"><a href="<%= Routes.page_url(Mobilizon.Web.Endpoint, :event, @activity.subject_params["event_uuid"]) %>" target="_blank" style="font-size: 20px; font-family: Helvetica, Arial, sans-serif; color: #ffffff; text-decoration: none; padding: 15px 25px; border-radius: 2px; border: 1px solid #3C376E; display: inline-block;">
                         <%= gettext "Visit event page" %>
                       </a></td>
                   </tr>
diff --git a/lib/web/templates/email/email_anonymous_activity.text.eex b/lib/web/templates/email/email_anonymous_activity.text.eex
index 0df709a1c..c19b43834 100644
--- a/lib/web/templates/email/email_anonymous_activity.text.eex
+++ b/lib/web/templates/email/email_anonymous_activity.text.eex
@@ -8,4 +8,4 @@
         event: @activity.subject_params["event_title"]
     }
 ) %>
-<%= page_url(Mobilizon.Web.Endpoint, :event, @activity.subject_params["event_uuid"]) |> URI.decode() %>
\ No newline at end of file
+<%= Routes.page_url(Mobilizon.Web.Endpoint, :event, @activity.subject_params["event_uuid"]) |> URI.decode() %>
\ No newline at end of file
diff --git a/lib/web/templates/email/email_changed_new.html.eex b/lib/web/templates/email/email_changed_new.html.eex
index f3eb0267b..75fd87b81 100644
--- a/lib/web/templates/email/email_changed_new.html.eex
+++ b/lib/web/templates/email/email_changed_new.html.eex
@@ -47,7 +47,7 @@
                 <table border="0" cellspacing="0" cellpadding="0">
                   <tr>
                     <td align="center" style="border-radius: 3px;" bgcolor="#3C376E">
-                      <a href="<%= page_url(Mobilizon.Web.Endpoint, :user_email_validation, @token) %>" target="_blank" style="font-size: 20px; font-family: Helvetica, Arial, sans-serif; color: #ffffff; text-decoration: none; padding: 15px 25px; border-radius: 2px; border: 1px solid #3C376E; display: inline-block;">
+                      <a href="<%= Routes.page_url(Mobilizon.Web.Endpoint, :user_email_validation, @token) %>" target="_blank" style="font-size: 20px; font-family: Helvetica, Arial, sans-serif; color: #ffffff; text-decoration: none; padding: 15px 25px; border-radius: 2px; border: 1px solid #3C376E; display: inline-block;">
                         <%= gettext "Verify your email address" %>
                       </a>
                     </td>
diff --git a/lib/web/templates/email/email_changed_new.text.eex b/lib/web/templates/email/email_changed_new.text.eex
index 65d5c4fd6..5ae1b016e 100644
--- a/lib/web/templates/email/email_changed_new.text.eex
+++ b/lib/web/templates/email/email_changed_new.text.eex
@@ -1,5 +1,5 @@
 <%= gettext "Confirm new email" %>
 ==
 <%= gettext "Hi there! It seems like you wanted to change the email address linked to your account on <b>%{instance}</b>. If you still wish to do so, please click the button below to confirm the change. You will then be able to log in to %{instance} with this new email address.", %{instance: @instance_name} %>
-<%= page_url(Mobilizon.Web.Endpoint, :user_email_validation, @token) %>
+<%= Routes.page_url(Mobilizon.Web.Endpoint, :user_email_validation, @token) %>
 <%= gettext "If you didn't trigger the change yourself, please ignore this message." %>
diff --git a/lib/web/templates/email/email_direct_activity.html.eex b/lib/web/templates/email/email_direct_activity.html.eex
index be3d997b5..23115ea33 100644
--- a/lib/web/templates/email/email_direct_activity.html.eex
+++ b/lib/web/templates/email/email_direct_activity.html.eex
@@ -64,7 +64,7 @@
                               <tr>
                                 <%= if hd(group_activities).group.avatar do %>
                                   <td width="85">
-                                    <a href="<%= page_url(Mobilizon.Web.Endpoint, :actor, Mobilizon.Actors.Actor.preferred_username_and_domain(hd(group_activities).group)) |> URI.decode() %>" target="_blank" style="text-decoration: none;">
+                                    <a href="<%= Routes.page_url(Mobilizon.Web.Endpoint, :actor, Mobilizon.Actors.Actor.preferred_username_and_domain(hd(group_activities).group)) |> URI.decode() %>" target="_blank" style="text-decoration: none;">
                                       <img width="80" src="<%= hd(group_activities).group.avatar.url %>" style="width: 80px;max-height: 100px;" style="margin:0; padding:0; border:none; display:block;" border="0" alt="" />
                                     </a>
                                   </td>
@@ -73,7 +73,7 @@
                                   <table width="" cellpadding="0" cellspacing="0" border="0" style="max-width: 400px;width: 100%;" align="left">
                                     <tr>
                                       <td align="left">
-                                        <a href="<%= page_url(Mobilizon.Web.Endpoint, :actor, Mobilizon.Actors.Actor.preferred_username_and_domain(hd(group_activities).group)) |> URI.decode() %>" target="_blank" style="text-decoration: none;color: #474467;font-family: 'Roboto', Helvetica, Arial, sans-serif;font-size: 18px;font-weight: bold;line-height: 25px;">
+                                        <a href="<%= Routes.page_url(Mobilizon.Web.Endpoint, :actor, Mobilizon.Actors.Actor.preferred_username_and_domain(hd(group_activities).group)) |> URI.decode() %>" target="_blank" style="text-decoration: none;color: #474467;font-family: 'Roboto', Helvetica, Arial, sans-serif;font-size: 18px;font-weight: bold;line-height: 25px;">
                                           <%= hd(group_activities).group.name || "@#{Mobilizon.Actors.Actor.preferred_username_and_domain(hd(group_activities).group)}" %>
                                         </a>
                                       </td>
@@ -81,7 +81,7 @@
                                     <%= if hd(group_activities).group.name do %>
                                       <tr>
                                         <td align="left">
-                                          <a href="<%= page_url(Mobilizon.Web.Endpoint, :actor, Mobilizon.Actors.Actor.preferred_username_and_domain(hd(group_activities).group)) |> URI.decode() %>" target="_blank" style="text-decoration: none;display: block;color: #7a7a7a;font-family: 'Roboto', Helvetica, Arial, sans-serif;font-size: 16px;font-weight: 400;line-height: 25px;">
+                                          <a href="<%= Routes.page_url(Mobilizon.Web.Endpoint, :actor, Mobilizon.Actors.Actor.preferred_username_and_domain(hd(group_activities).group)) |> URI.decode() %>" target="_blank" style="text-decoration: none;display: block;color: #7a7a7a;font-family: 'Roboto', Helvetica, Arial, sans-serif;font-size: 16px;font-weight: 400;line-height: 25px;">
                                             @<%= Mobilizon.Actors.Actor.preferred_username_and_domain(hd(group_activities).group) %>
                                           </a>
                                         </td>
@@ -131,7 +131,7 @@
                             <table border="0" cellspacing="0" cellpadding="0">
                               <tr>
                                 <td align="center" style="border-radius: 3px;" bgcolor="#3C376E">
-                                  <a href="<%= page_url(Mobilizon.Web.Endpoint, :actor, Mobilizon.Actors.Actor.preferred_username_and_domain(hd(group_activities).group)) |> URI.decode() %>/timeline" target="_blank" style="font-size: 20px; font-family: Helvetica, Arial, sans-serif; color: #ffffff; text-decoration: none; padding: 15px 25px; border-radius: 2px; border: 1px solid #3C376E; display: inline-block;">
+                                  <a href="<%= Routes.page_url(Mobilizon.Web.Endpoint, :actor, Mobilizon.Actors.Actor.preferred_username_and_domain(hd(group_activities).group)) |> URI.decode() %>/timeline" target="_blank" style="font-size: 20px; font-family: Helvetica, Arial, sans-serif; color: #ffffff; text-decoration: none; padding: 15px 25px; border-radius: 2px; border: 1px solid #3C376E; display: inline-block;">
                                     <%= dngettext "activity", "View one more activity", "View %{count} more activities", length(group_activities) - 5, %{count: length(group_activities) - 5} %>
                                   </a>
                                 </td>
diff --git a/lib/web/templates/email/email_direct_activity.text.eex b/lib/web/templates/email/email_direct_activity.text.eex
index 44572d5a2..e795ec0ab 100644
--- a/lib/web/templates/email/email_direct_activity.text.eex
+++ b/lib/web/templates/email/email_direct_activity.text.eex
@@ -21,7 +21,7 @@
 <% end %>
 <%= if length(group_activities) > 5 do %>
 <%= dngettext "activity", "View one more activity", "View %{count} more activities", length(group_activities) - 5, %{count: length(group_activities) - 5} %>
-<%= page_url(Mobilizon.Web.Endpoint, :actor, Mobilizon.Actors.Actor.preferred_username_and_domain(hd(group_activities).group)) |> URI.decode() %>/timeline
+<%= Routes.page_url(Mobilizon.Web.Endpoint, :actor, Mobilizon.Actors.Actor.preferred_username_and_domain(hd(group_activities).group)) |> URI.decode() %>/timeline
 <% end %>
 <% end %>
 <%= dgettext("activity", "Don't want to receive activity notifications? You may change frequency or disable them in your settings.") %>
diff --git a/lib/web/templates/email/event_participation_approved.html.eex b/lib/web/templates/email/event_participation_approved.html.eex
index 7ec2ed034..1a1f2f80a 100644
--- a/lib/web/templates/email/event_participation_approved.html.eex
+++ b/lib/web/templates/email/event_participation_approved.html.eex
@@ -54,7 +54,7 @@
               <td bgcolor="#ffffff" align="center" style="padding: 20px 30px 60px 30px;">
                 <table border="0" cellspacing="0" cellpadding="0">
                   <tr>
-                    <td align="center" style="border-radius: 3px;" bgcolor="#3C376E"><a href="<%= page_url(Mobilizon.Web.Endpoint, :event, @event.uuid) %>" target="_blank" style="font-size: 20px; font-family: Helvetica, Arial, sans-serif; color: #ffffff; text-decoration: none; padding: 15px 25px; border-radius: 2px; border: 1px solid #3C376E; display: inline-block;">
+                    <td align="center" style="border-radius: 3px;" bgcolor="#3C376E"><a href="<%= Routes.page_url(Mobilizon.Web.Endpoint, :event, @event.uuid) %>" target="_blank" style="font-size: 20px; font-family: Helvetica, Arial, sans-serif; color: #ffffff; text-decoration: none; padding: 15px 25px; border-radius: 2px; border: 1px solid #3C376E; display: inline-block;">
                         <%= gettext "Visit event page" %>
                       </a></td>
                   </tr>
diff --git a/lib/web/templates/email/event_participation_approved.text.eex b/lib/web/templates/email/event_participation_approved.text.eex
index 906cfbfa2..5b71ca3f1 100644
--- a/lib/web/templates/email/event_participation_approved.text.eex
+++ b/lib/web/templates/email/event_participation_approved.text.eex
@@ -6,6 +6,6 @@
 
 <%= gettext "Good news: one of the event organizers just approved your request. Update your calendar, because you're on the guest list now!" %>
 
-<%= page_url(Mobilizon.Web.Endpoint, :event, @event.uuid) %>
+<%= Routes.page_url(Mobilizon.Web.Endpoint, :event, @event.uuid) %>
 
 <%= gettext "Would you wish to update or cancel your attendance, simply access the event page through the link above and click on the Attending button." %>
diff --git a/lib/web/templates/email/event_participation_confirmed.html.eex b/lib/web/templates/email/event_participation_confirmed.html.eex
index 3dbbab91c..d38056a4d 100644
--- a/lib/web/templates/email/event_participation_confirmed.html.eex
+++ b/lib/web/templates/email/event_participation_confirmed.html.eex
@@ -54,7 +54,7 @@
               <td bgcolor="#ffffff" align="center" style="padding: 20px 30px 60px 30px;">
                 <table border="0" cellspacing="0" cellpadding="0">
                   <tr>
-                    <td align="center" style="border-radius: 3px;" bgcolor="#3C376E"><a href="<%= page_url(Mobilizon.Web.Endpoint, :event, @event.uuid) %>" target="_blank" style="font-size: 20px; font-family: Helvetica, Arial, sans-serif; color: #ffffff; text-decoration: none; padding: 15px 25px; border-radius: 2px; border: 1px solid #3C376E; display: inline-block;">
+                    <td align="center" style="border-radius: 3px;" bgcolor="#3C376E"><a href="<%= Routes.page_url(Mobilizon.Web.Endpoint, :event, @event.uuid) %>" target="_blank" style="font-size: 20px; font-family: Helvetica, Arial, sans-serif; color: #ffffff; text-decoration: none; padding: 15px 25px; border-radius: 2px; border: 1px solid #3C376E; display: inline-block;">
                         <%= gettext "Visit event page" %>
                       </a></td>
                   </tr>
diff --git a/lib/web/templates/email/event_participation_confirmed.text.eex b/lib/web/templates/email/event_participation_confirmed.text.eex
index 869df0b4d..56f9edad8 100644
--- a/lib/web/templates/email/event_participation_confirmed.text.eex
+++ b/lib/web/templates/email/event_participation_confirmed.text.eex
@@ -2,5 +2,5 @@
 ==
 <%= gettext "You recently requested to attend %{title}.", title: @event.title %>
 <%= gettext "You have confirmed your participation. Update your calendar, because you're on the guest list now!" %>
-<%= page_url(Mobilizon.Web.Endpoint, :event, @event.uuid) %>
+<%= Routes.page_url(Mobilizon.Web.Endpoint, :event, @event.uuid) %>
 <%= gettext "Would you wish to update or cancel your attendance, simply access the event page through the link above and click on the Attending button." %>
diff --git a/lib/web/templates/email/event_updated.html.eex b/lib/web/templates/email/event_updated.html.eex
index f6539b2e8..61b1318fd 100644
--- a/lib/web/templates/email/event_updated.html.eex
+++ b/lib/web/templates/email/event_updated.html.eex
@@ -117,7 +117,7 @@
               <td bgcolor="#ffffff" align="center" style="padding: 20px 30px 60px 30px;">
                 <table border="0" cellspacing="0" cellpadding="0">
                   <tr>
-                    <td align="center" style="border-radius: 3px;" bgcolor="#3C376E"><a href="<%= page_url(Mobilizon.Web.Endpoint, :event, @event.uuid) %>" target="_blank" style="font-size: 20px; font-family: Helvetica, Arial, sans-serif; color: #ffffff; text-decoration: none; padding: 15px 25px; border-radius: 2px; border: 1px solid #3C376E; display: inline-block;">
+                    <td align="center" style="border-radius: 3px;" bgcolor="#3C376E"><a href="<%= Routes.page_url(Mobilizon.Web.Endpoint, :event, @event.uuid) %>" target="_blank" style="font-size: 20px; font-family: Helvetica, Arial, sans-serif; color: #ffffff; text-decoration: none; padding: 15px 25px; border-radius: 2px; border: 1px solid #3C376E; display: inline-block;">
                         <%= gettext "Visit the updated event page" %>
                       </a></td>
                   </tr>
diff --git a/lib/web/templates/email/event_updated.text.eex b/lib/web/templates/email/event_updated.text.eex
index d65225f13..676cbae61 100644
--- a/lib/web/templates/email/event_updated.text.eex
+++ b/lib/web/templates/email/event_updated.text.eex
@@ -20,5 +20,5 @@
 <%= if MapSet.member?(@changes, :ends_on) && !is_nil(@event.ends_on) do %>
   <%= gettext "End %{ends_on}", ends_on: @event.ends_on |> datetime_tz_convert(@timezone) |> datetime_to_string(@locale) %>
 <% end %>
-<%= gettext "Visit the updated event page: %{link}", link: page_url(Mobilizon.Web.Endpoint, :event, @event.uuid) %>
+<%= gettext "Visit the updated event page: %{link}", link: Routes.page_url(Mobilizon.Web.Endpoint, :event, @event.uuid) %>
 <%= ngettext "Would you wish to cancel your attendance, visit the event page through the link above and click the « Attending » button.", "Would you wish to cancel your attendance to one or several events, visit the event pages through the links above and click the « Attending » button.", 1 %>
diff --git a/lib/web/templates/email/group_deletion.text.eex b/lib/web/templates/email/group_deletion.text.eex
deleted file mode 100644
index 511cd64b9..000000000
--- a/lib/web/templates/email/group_deletion.text.eex
+++ /dev/null
@@ -1,5 +0,0 @@
-<%= gettext "The group %{group} was deleted on %{instance}!", group: (@group.name || @group.preferred_username), instance: @instance %>
-==
-<%= gettext "The administrator %{author} deleted group %{group}. All of the group's events, discussions, posts and todos have been deleted.",
-  author: Mobilizon.Actors.Actor.display_name_and_username(@author),
-  group: Mobilizon.Actors.Actor.display_name_and_username(@group) %>
diff --git a/lib/web/templates/email/group_invite.html.eex b/lib/web/templates/email/group_invite.html.eex
index 6c134ba02..129478107 100644
--- a/lib/web/templates/email/group_invite.html.eex
+++ b/lib/web/templates/email/group_invite.html.eex
@@ -55,7 +55,7 @@
                 <table border="0" cellspacing="0" cellpadding="0">
                   <tr>
                     <td align="center" style="border-radius: 3px;" bgcolor="#3C376E">
-                      <a href="<%= page_url(Mobilizon.Web.Endpoint, :my_groups) %>" target="_blank" style="font-size: 20px; font-family: Helvetica, Arial, sans-serif; color: #ffffff; text-decoration: none; padding: 15px 25px; border-radius: 2px; border: 1px solid #3C376E; display: inline-block;">
+                      <a href="<%= Routes.page_url(Mobilizon.Web.Endpoint, :my_groups) %>" target="_blank" style="font-size: 20px; font-family: Helvetica, Arial, sans-serif; color: #ffffff; text-decoration: none; padding: 15px 25px; border-radius: 2px; border: 1px solid #3C376E; display: inline-block;">
                         <%= gettext "See my groups" %>
                       </a>
                     </td>
diff --git a/lib/web/templates/email/group_invite.text.eex b/lib/web/templates/email/group_invite.text.eex
index 70d1c983f..72b03aeb5 100644
--- a/lib/web/templates/email/group_invite.text.eex
+++ b/lib/web/templates/email/group_invite.text.eex
@@ -3,4 +3,4 @@
 <%= gettext "%{inviter} just invited you to join their group %{group}", group: @group.name, inviter: @inviter.name %>
 <%= @group.url %>
 <%= gettext "To accept this invitation, head over to your groups." %>
-<%= page_url(Mobilizon.Web.Endpoint, :my_groups) %>
+<%= Routes.page_url(Mobilizon.Web.Endpoint, :my_groups) %>
diff --git a/lib/web/templates/email/notification_each_week.html.eex b/lib/web/templates/email/notification_each_week.html.eex
index c27c23018..270785fa9 100644
--- a/lib/web/templates/email/notification_each_week.html.eex
+++ b/lib/web/templates/email/notification_each_week.html.eex
@@ -48,7 +48,7 @@
                   <strong>
                     <%= participation.event.begins_on |> datetime_tz_convert(@timezone) |> datetime_to_string(@locale) %>
                   </strong>
-                  <a href="<%= page_url(Mobilizon.Web.Endpoint, :event, participation.event.uuid) %>" target="_blank">
+                  <a href="<%= Routes.page_url(Mobilizon.Web.Endpoint, :event, participation.event.uuid) %>" target="_blank">
                     <%= participation.event.title %>
                   </a>
                 </li>
@@ -58,7 +58,7 @@
             <strong>
               <%= @participation.event.begins_on |> datetime_tz_convert(@timezone) |> datetime_to_string(@locale) %>
             </strong>
-            <a href="<%= page_url(Mobilizon.Web.Endpoint, :event, @participation.event.uuid) %>" target="_blank">
+            <a href="<%= Routes.page_url(Mobilizon.Web.Endpoint, :event, @participation.event.uuid) %>" target="_blank">
               <%= @participation.event.title %>
             </a>
           <% end %>
diff --git a/lib/web/templates/email/notification_each_week.text.eex b/lib/web/templates/email/notification_each_week.text.eex
index e0c2c3cbe..f0f2fc303 100644
--- a/lib/web/templates/email/notification_each_week.text.eex
+++ b/lib/web/templates/email/notification_each_week.text.eex
@@ -3,9 +3,9 @@
 <%= ngettext "You have one event this week:", "You have %{total} events this week:", @total, total: @total %>
 <%= if @total > 1 do %>
   <%= for participation <- @participations do %>
-    - <%= participation.event.begins_on |> datetime_tz_convert(@timezone) |> datetime_to_string(@locale) %> - <%= participation.event.title %> <%= page_url(Mobilizon.Web.Endpoint, :event, participation.event.uuid) %>
+    - <%= participation.event.begins_on |> datetime_tz_convert(@timezone) |> datetime_to_string(@locale) %> - <%= participation.event.title %> <%= Routes.page_url(Mobilizon.Web.Endpoint, :event, participation.event.uuid) %>
   <% end %>
 <% else %>
-  <%= @participation.event.begins_on |> datetime_tz_convert(@timezone) |> datetime_to_string(@locale) %> - <%= @participation.event.title %> <%= page_url(Mobilizon.Web.Endpoint, :event, @participation.event.uuid) %>
+  <%= @participation.event.begins_on |> datetime_tz_convert(@timezone) |> datetime_to_string(@locale) %> - <%= @participation.event.title %> <%= Routes.page_url(Mobilizon.Web.Endpoint, :event, @participation.event.uuid) %>
 <% end %>
 <%= ngettext "Would you wish to cancel your attendance, visit the event page through the link above and click the « Attending » button.", "Would you wish to cancel your attendance to one or several events, visit the event pages through the links above and click the « Attending » button.", @total %>
diff --git a/lib/web/templates/email/on_day_notification.html.eex b/lib/web/templates/email/on_day_notification.html.eex
index dd31dce02..7e6b9441d 100644
--- a/lib/web/templates/email/on_day_notification.html.eex
+++ b/lib/web/templates/email/on_day_notification.html.eex
@@ -48,7 +48,7 @@
                   <strong>
                     <%= participation.event.begins_on |> DateTime.shift_zone!(@timezone) |> datetime_to_time_string(@locale) %>
                   </strong>
-                  <a href="<%= page_url(Mobilizon.Web.Endpoint, :event, participation.event.uuid) %>" target="_blank">
+                  <a href="<%= Routes.page_url(Mobilizon.Web.Endpoint, :event, participation.event.uuid) %>" target="_blank">
                     <%= participation.event.title %>
                   </a>
                 </li>
@@ -58,7 +58,7 @@
             <strong>
               <%= @participation.event.begins_on |> DateTime.shift_zone!(@timezone) |> datetime_to_time_string(@locale) %>
             </strong>
-            <a href="<%= page_url(Mobilizon.Web.Endpoint, :event, @participation.event.uuid) %>" target="_blank">
+            <a href="<%= Routes.page_url(Mobilizon.Web.Endpoint, :event, @participation.event.uuid) %>" target="_blank">
               <%= @participation.event.title %>
             </a>
           <% end %>
diff --git a/lib/web/templates/email/on_day_notification.text.eex b/lib/web/templates/email/on_day_notification.text.eex
index 6d1b0f3e0..b902f2646 100644
--- a/lib/web/templates/email/on_day_notification.text.eex
+++ b/lib/web/templates/email/on_day_notification.text.eex
@@ -5,10 +5,10 @@
 
 <%= if @total > 1 do %>
   <%= for participation <- @participations do %>
-  - <%= participation.event.begins_on |> DateTime.shift_zone!(@timezone) |> datetime_to_time_string(@locale) %> - <%= participation.event.title %> <%= page_url(Mobilizon.Web.Endpoint, :event, participation.event.uuid) %>
+  - <%= participation.event.begins_on |> DateTime.shift_zone!(@timezone) |> datetime_to_time_string(@locale) %> - <%= participation.event.title %> <%= Routes.page_url(Mobilizon.Web.Endpoint, :event, participation.event.uuid) %>
   <% end %>
 <% else %>
-  <%= DateTime.shift_zone!(@participation.event.begins_on, @timezone) |> datetime_to_time_string(@locale) %> - <%= @participation.event.title %> <%= page_url(Mobilizon.Web.Endpoint, :event, @participation.event.uuid) %>
+  <%= DateTime.shift_zone!(@participation.event.begins_on, @timezone) |> datetime_to_time_string(@locale) %> - <%= @participation.event.title %> <%= Routes.page_url(Mobilizon.Web.Endpoint, :event, @participation.event.uuid) %>
 <% end %>
 
 <%= ngettext "Would you wish to cancel your attendance, visit the event page through the link above and click the « Attending » button.", "Would you wish to cancel your attendance to one or several events, visit the event pages through the links above and click the « Attending » button.", @total %>
diff --git a/lib/web/templates/email/pending_participation_notification.html.eex b/lib/web/templates/email/pending_participation_notification.html.eex
index 56c4c5ea7..79aeb85ab 100644
--- a/lib/web/templates/email/pending_participation_notification.html.eex
+++ b/lib/web/templates/email/pending_participation_notification.html.eex
@@ -47,7 +47,7 @@
                 <table border="0" cellspacing="0" cellpadding="0">
                   <tr>
                     <td align="center" style="border-radius: 3px;" bgcolor="#3C376E">
-                      <a href="<%= page_url(Mobilizon.Web.Endpoint, :event, @event.uuid) <> "/participations" %>" target="_blank" style="font-size: 20px; font-family: Helvetica, Arial, sans-serif; color: #ffffff; text-decoration: none; color: #ffffff; text-decoration: none; padding: 15px 25px; border-radius: 2px; border: 1px solid #3C376E; display: inline-block;">
+                      <a href="<%= Routes.page_url(Mobilizon.Web.Endpoint, :event, @event.uuid) <> "/participations" %>" target="_blank" style="font-size: 20px; font-family: Helvetica, Arial, sans-serif; color: #ffffff; text-decoration: none; color: #ffffff; text-decoration: none; padding: 15px 25px; border-radius: 2px; border: 1px solid #3C376E; display: inline-block;">
                         <%= gettext "Manage pending requests" %>
                       </a>
                     </td>
diff --git a/lib/web/templates/email/pending_participation_notification.text.eex b/lib/web/templates/email/pending_participation_notification.text.eex
index a1de9a579..6a0f31c77 100644
--- a/lib/web/templates/email/pending_participation_notification.text.eex
+++ b/lib/web/templates/email/pending_participation_notification.text.eex
@@ -3,6 +3,6 @@
 
 <%= ngettext "You have one pending attendance request to process:", "You have %{number_participation_requests} attendance requests to process:", @total, number_participation_requests: @total %>
 
-<%= gettext "Manage pending requests" %> <%= page_url(Mobilizon.Web.Endpoint, :event, @event.uuid) <> "/participations" %>
+<%= gettext "Manage pending requests" %> <%= Routes.page_url(Mobilizon.Web.Endpoint, :event, @event.uuid) <> "/participations" %>
 
 <%= gettext "You are receiving this email because you chose to get notifications for pending attendance requests to your events. You can disable or change your notification settings in your user account settings under « Notifications »." %>s
diff --git a/lib/web/templates/email/report.html.eex b/lib/web/templates/email/report.html.eex
index 1d1775ef5..b25939438 100644
--- a/lib/web/templates/email/report.html.eex
+++ b/lib/web/templates/email/report.html.eex
@@ -122,7 +122,7 @@
               <td bgcolor="#ffffff" align="center" style="padding: 20px 30px 60px 30px;">
                 <table border="0" cellspacing="0" cellpadding="0">
                   <tr>
-                    <td align="center" style="border-radius: 3px;" bgcolor="#3C376E"><a href="<%= page_url(Mobilizon.Web.Endpoint, :moderation_report, @report.id) %>" target="_blank" style="font-size: 20px; font-family: Helvetica, Arial, sans-serif; color: #ffffff; text-decoration: none; padding: 15px 25px; border-radius: 2px; border: 1px solid #3C376E; display: inline-block;">
+                    <td align="center" style="border-radius: 3px;" bgcolor="#3C376E"><a href="<%= Routes.page_url(Mobilizon.Web.Endpoint, :moderation_report, @report.id) %>" target="_blank" style="font-size: 20px; font-family: Helvetica, Arial, sans-serif; color: #ffffff; text-decoration: none; padding: 15px 25px; border-radius: 2px; border: 1px solid #3C376E; display: inline-block;">
                         <%= gettext "View report" %>
                       </a></td>
                   </tr>
diff --git a/lib/web/templates/email/report.text.eex b/lib/web/templates/email/report.text.eex
index b5521c4db..7cd119b57 100644
--- a/lib/web/templates/email/report.text.eex
+++ b/lib/web/templates/email/report.text.eex
@@ -21,4 +21,4 @@
   <%= gettext "Reason" %>
   <%= @report.content %>
 <% end %>
-<%= gettext "View report:" %> <%= page_url(Mobilizon.Web.Endpoint, :moderation_report, @report.id) %>
+<%= gettext "View report:" %> <%= Routes.page_url(Mobilizon.Web.Endpoint, :moderation_report, @report.id) %>
diff --git a/lib/web/upload/filter/analyze_metadata.ex b/lib/web/upload/filter/analyze_metadata.ex
index ea12fb487..72fb44203 100644
--- a/lib/web/upload/filter/analyze_metadata.ex
+++ b/lib/web/upload/filter/analyze_metadata.ex
@@ -13,7 +13,7 @@ defmodule Mobilizon.Web.Upload.Filter.AnalyzeMetadata do
   @behaviour Mobilizon.Web.Upload.Filter
 
   @spec filter(Upload.t()) ::
-          {:ok, :filtered, Upload.t()} | {:ok, :noop} | {:error, String.t()}
+          {:ok, :filtered, Upload.t()} | {:ok, :noop}
   def filter(%Upload{tempfile: file, content_type: "image" <> _} = upload) do
     image =
       file
diff --git a/lib/web/upload/filter/anonymize_filename.ex b/lib/web/upload/filter/anonymize_filename.ex
index 093479448..108635995 100644
--- a/lib/web/upload/filter/anonymize_filename.ex
+++ b/lib/web/upload/filter/anonymize_filename.ex
@@ -14,19 +14,27 @@ defmodule Mobilizon.Web.Upload.Filter.AnonymizeFilename do
 
   alias Mobilizon.Config
   alias Mobilizon.Web.Upload
+  alias Mobilizon.Web.Upload.Filter
+  import Mobilizon.Service.Guards, only: [is_valid_string: 1]
 
+  @impl Filter
+  @spec filter(any) :: {:ok, :filtered, Upload.t()} | {:ok, :noop}
   def filter(%Upload{name: name} = upload) do
     extension = List.last(String.split(name, "."))
-    name = predefined_name(extension) || random(extension)
+    name = predefined_name(extension)
+    name = if is_nil(name), do: random(extension), else: name
     {:ok, :filtered, %Upload{upload | name: name}}
   end
 
+  @impl Filter
   def filter(_), do: {:ok, :noop}
 
   @spec predefined_name(String.t()) :: String.t() | nil
   defp predefined_name(extension) do
-    with name when not is_nil(name) <- Config.get([__MODULE__, :text]),
-         do: String.replace(name, "{extension}", extension)
+    case Config.get([__MODULE__, :text]) do
+      name when is_valid_string(name) -> String.replace(name, "{extension}", extension)
+      _ -> nil
+    end
   end
 
   defp random(extension) do
diff --git a/lib/web/upload/filter/blurhash.ex b/lib/web/upload/filter/blurhash.ex
index b2454dea6..a05c790a9 100644
--- a/lib/web/upload/filter/blurhash.ex
+++ b/lib/web/upload/filter/blurhash.ex
@@ -8,7 +8,7 @@ defmodule Mobilizon.Web.Upload.Filter.BlurHash do
   @behaviour Mobilizon.Web.Upload.Filter
 
   @spec filter(Upload.t()) ::
-          {:ok, :filtered, Upload.t()} | {:ok, :noop} | {:error, String.t()}
+          {:ok, :filtered, Upload.t()} | {:ok, :noop}
   def filter(%Upload{tempfile: file, content_type: "image" <> _} = upload) do
     {:ok, :filtered, %Upload{upload | blurhash: generate_blurhash(file)}}
   rescue
diff --git a/lib/web/upload/filter/dedupe.ex b/lib/web/upload/filter/dedupe.ex
index 1e7731a5d..d6ca08860 100644
--- a/lib/web/upload/filter/dedupe.ex
+++ b/lib/web/upload/filter/dedupe.ex
@@ -10,6 +10,7 @@ defmodule Mobilizon.Web.Upload.Filter.Dedupe do
   @behaviour Mobilizon.Web.Upload.Filter
   alias Mobilizon.Web.Upload
 
+  @spec filter(Upload.t()) :: {:ok, :filtered, Upload.t()} | {:ok, :noop}
   def filter(%Upload{name: name, tempfile: tempfile} = upload) do
     extension = name |> String.split(".") |> List.last()
     shasum = :crypto.hash(:sha256, File.read!(tempfile)) |> Base.encode16(case: :lower)
diff --git a/lib/web/upload/filter/exiftool.ex b/lib/web/upload/filter/exiftool.ex
index fd7391f27..4f5a1773c 100644
--- a/lib/web/upload/filter/exiftool.ex
+++ b/lib/web/upload/filter/exiftool.ex
@@ -11,7 +11,7 @@ defmodule Mobilizon.Web.Upload.Filter.Exiftool do
 
   @behaviour Mobilizon.Web.Upload.Filter
 
-  @spec filter(Upload.t()) :: {:ok, any()} | {:error, String.t()}
+  @spec filter(Upload.t()) :: {:ok, :filtered | :noop} | {:error, String.t()}
 
   # webp is not compatible with exiftool at this time
   def filter(%Upload{content_type: "image/webp"}), do: {:ok, :noop}
diff --git a/lib/web/upload/filter/filter.ex b/lib/web/upload/filter/filter.ex
index be85909a8..a2f63a9df 100644
--- a/lib/web/upload/filter/filter.ex
+++ b/lib/web/upload/filter/filter.ex
@@ -20,11 +20,10 @@ defmodule Mobilizon.Web.Upload.Filter do
               {:ok, :filtered}
               | {:ok, :noop}
               | {:ok, :filtered, Mobilizon.Web.Upload.t()}
-              | {:error, any()}
+              | {:error, String.t() | atom}
 
   @spec filter([module()], Mobilizon.Web.Upload.t()) ::
-          {:ok, Mobilizon.Web.Upload.t()} | {:error, any()}
-
+          {:ok, Mobilizon.Web.Upload.t()} | {:error, String.t() | atom}
   def filter([], upload) do
     {:ok, upload}
   end
diff --git a/lib/web/upload/filter/mogrify.ex b/lib/web/upload/filter/mogrify.ex
index f10c49728..587fb5bdd 100644
--- a/lib/web/upload/filter/mogrify.ex
+++ b/lib/web/upload/filter/mogrify.ex
@@ -15,7 +15,7 @@ defmodule Mobilizon.Web.Upload.Filter.Mogrify do
   @type conversion :: action :: String.t() | {action :: String.t(), opts :: String.t()}
   @type conversions :: conversion() | [conversion()]
 
-  @spec filter(Mobilizon.Web.Upload.t()) :: {:ok, :atom} | {:error, String.t()}
+  @spec filter(Mobilizon.Web.Upload.t()) :: {:ok, :filtered | :noop} | {:error, String.t()}
   def filter(%Mobilizon.Web.Upload{tempfile: file, content_type: "image" <> _}) do
     do_filter(file, Config.get!([__MODULE__, :args]))
     {:ok, :filtered}
diff --git a/lib/web/upload/filter/optimize.ex b/lib/web/upload/filter/optimize.ex
index c19c9fa04..fc1f73f9e 100644
--- a/lib/web/upload/filter/optimize.ex
+++ b/lib/web/upload/filter/optimize.ex
@@ -6,6 +6,8 @@ defmodule Mobilizon.Web.Upload.Filter.Optimize do
   @behaviour Mobilizon.Web.Upload.Filter
 
   alias Mobilizon.Config
+  alias Mobilizon.Web.Upload
+  require Logger
 
   @default_optimizers [
     JpegOptim,
@@ -16,24 +18,24 @@ defmodule Mobilizon.Web.Upload.Filter.Optimize do
     Cwebp
   ]
 
-  def filter(%Mobilizon.Web.Upload{tempfile: file, content_type: "image" <> _}) do
+  @spec filter(Upload.t()) :: {:ok, :filtered | :noop} | {:error, :file_not_found}
+  def filter(%Upload{tempfile: file, content_type: "image" <> _}) do
     optimizers = Config.get([__MODULE__, :optimizers], @default_optimizers)
 
     case ExOptimizer.optimize(file, deps: optimizers) do
       {:ok, _res} ->
         {:ok, :filtered}
 
-      {:error, err} ->
-        require Logger
+      {:error, :file_not_found} ->
+        Logger.warn("Unable to optimize file #{file}. File was not found")
+        {:error, :file_not_found}
 
+      {:error, err} ->
         Logger.warn(
           "Unable to optimize file #{file}. The return from the process was #{inspect(err)}"
         )
 
         {:ok, :noop}
-
-      err ->
-        {:error, err}
     end
   end
 
diff --git a/lib/web/upload/filter/resize.ex b/lib/web/upload/filter/resize.ex
index 12c34ea7a..be6e9e6c7 100644
--- a/lib/web/upload/filter/resize.ex
+++ b/lib/web/upload/filter/resize.ex
@@ -11,6 +11,7 @@ defmodule Mobilizon.Web.Upload.Filter.Resize do
   @maximum_width 1_920
   @maximum_height 1_080
 
+  @spec filter(Upload.t()) :: {:ok, :filtered, Upload.t()} | {:ok, :noop}
   def filter(
         %Upload{
           tempfile: file,
@@ -31,6 +32,7 @@ defmodule Mobilizon.Web.Upload.Filter.Resize do
 
   def filter(_), do: {:ok, :noop}
 
+  @spec limit_sizes({non_neg_integer, non_neg_integer}) :: {non_neg_integer, non_neg_integer}
   def limit_sizes({width, height}) when width > @maximum_width do
     new_height = round(@maximum_width * height / width)
     limit_sizes({@maximum_width, new_height})
@@ -43,5 +45,6 @@ defmodule Mobilizon.Web.Upload.Filter.Resize do
 
   def limit_sizes({width, height}), do: {width, height}
 
+  @spec string({non_neg_integer, non_neg_integer}) :: String.t()
   defp string({width, height}), do: "#{width}x#{height}"
 end
diff --git a/lib/web/upload/mime.ex b/lib/web/upload/mime.ex
index 8a570c12f..2f5478035 100644
--- a/lib/web/upload/mime.ex
+++ b/lib/web/upload/mime.ex
@@ -10,16 +10,26 @@ defmodule Mobilizon.Web.Upload.MIME do
   @default "application/octet-stream"
   @read_bytes 35
 
-  @spec file_mime_type(String.t()) ::
-          {:ok, content_type :: String.t(), filename :: String.t()} | {:error, any()} | :error
+  @spec file_mime_type(String.t(), String.t()) ::
+          {:ok, content_type :: String.t(), filename :: String.t()}
+          | {:error, :unknown_mime | :failed_to_fix_extension}
+  @spec file_mime_type(String.t()) :: {:ok, String.t()} | {:error, :unknown_mime}
   def file_mime_type(path, filename) do
-    with {:ok, content_type} <- file_mime_type(path),
-         filename when is_binary(filename) <- fix_extension(filename, content_type) do
-      {:ok, content_type, filename}
+    case file_mime_type(path) do
+      {:ok, content_type} ->
+        case fix_extension(filename, content_type) do
+          {:error, :failed_to_fix_extension} ->
+            {:error, :failed_to_fix_extension}
+
+          filename when is_binary(filename) ->
+            {:ok, content_type, filename}
+        end
+
+      {:error, :unknown_mime} ->
+        {:error, :unknown_mime}
     end
   end
 
-  @spec file_mime_type(String.t()) :: {:ok, String.t()} | {:error, any()} | :error
   def file_mime_type(filename) do
     File.open(filename, [:read], fn f ->
       check_mime_type(IO.binread(f, @read_bytes))
@@ -33,12 +43,12 @@ defmodule Mobilizon.Web.Upload.MIME do
     end
   end
 
-  @spec bin_mime_type(binary()) :: {:ok, String.t()} | :error
+  @spec bin_mime_type(binary()) :: {:ok, String.t()} | {:error, :unknown_mime}
   def bin_mime_type(<<head::binary-size(@read_bytes), _::binary>>) do
     {:ok, check_mime_type(head)}
   end
 
-  def bin_mime_type(_), do: :error
+  def bin_mime_type(_), do: {:error, :unknown_mime}
 
   def mime_type(<<_::binary>>), do: {:ok, @default}
 
@@ -67,8 +77,9 @@ defmodule Mobilizon.Web.Upload.MIME do
     end
   end
 
-  defp fix_extension(_, _), do: :error
+  defp fix_extension(_, _), do: {:error, :failed_to_fix_extension}
 
+  @spec check_mime_type(binary) :: String.t()
   defp check_mime_type(<<0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A, _::binary>>) do
     "image/png"
   end
diff --git a/lib/web/upload/upload.ex b/lib/web/upload/upload.ex
index 16b2f389b..5a4ec274c 100644
--- a/lib/web/upload/upload.ex
+++ b/lib/web/upload/upload.ex
@@ -53,6 +53,7 @@ defmodule Mobilizon.Web.Upload do
           | {:size_limit, nil | non_neg_integer()}
           | {:uploader, module()}
           | {:filters, [module()]}
+          | {:allow_list_mime_types, boolean()}
 
   @type t :: %__MODULE__{
           id: String.t(),
@@ -65,33 +66,36 @@ defmodule Mobilizon.Web.Upload do
           height: integer(),
           blurhash: String.t()
         }
-  defstruct [:id, :name, :tempfile, :content_type, :path, :size, :width, :height, :blurhash]
+  defstruct [:id, :name, :url, :tempfile, :content_type, :path, :size, :width, :height, :blurhash]
 
-  @spec store(source, options :: [option()]) :: {:ok, map()} | {:error, any()}
+  @typep internal_options :: %{
+           activity_type: String.t() | nil,
+           size_limit: integer(),
+           uploader: module(),
+           filters: [module()],
+           description: String.t(),
+           allow_list_mime_types: list(String.t()),
+           base_url: String.t()
+         }
+
+  @spec store(source, options :: [option()]) ::
+          {:ok, t()} | {:error, String.t()} | {:error, atom()}
   def store(upload, opts \\ []) do
     opts = get_opts(opts)
 
-    with {:ok, upload} <- prepare_upload(upload, opts),
-         %__MODULE__{} = upload <- %__MODULE__{
-           upload
-           | path: upload.path || "#{upload.id}/#{upload.name}"
-         },
-         {:ok, upload} <- Filter.filter(opts.filters, upload),
-         {:ok, url_spec} <- Uploader.put_file(opts.uploader, upload) do
-      {:ok,
-       upload
-       |> Map.put(:name, Map.get(opts, :description) || upload.name)
-       |> Map.put(:url, url_from_spec(upload, opts.base_url, url_spec))}
-    else
-      {:error, error} ->
-        Logger.error(
-          "#{__MODULE__} store (using #{inspect(opts.uploader)}) failed: #{inspect(error)}"
-        )
+    case prepare_upload(upload, opts) do
+      {:ok, upload} ->
+        upload
+        |> set_default_upload_path()
+        |> perform_filter_and_put_file(opts)
 
+      {:error, error} ->
         {:error, error}
     end
   end
 
+  @spec remove(String.t(), Keyword.t()) ::
+          {:ok, String.t()} | {:error, atom} | {:error, String.t()}
   def remove(url, opts \\ []) do
     with opts <- get_opts(opts),
          %URI{path: "/media/" <> path, host: host} <- URI.parse(url),
@@ -106,10 +110,52 @@ defmodule Mobilizon.Web.Upload do
     end
   end
 
-  def char_unescaped?(char) do
+  @spec char_unescaped?(byte()) :: boolean()
+  defp char_unescaped?(char) do
     URI.char_unreserved?(char) or char == ?/
   end
 
+  @spec set_default_upload_path(t) :: t
+  defp set_default_upload_path(%__MODULE__{} = upload) do
+    %__MODULE__{
+      upload
+      | path: upload.path || "#{upload.id}/#{upload.name}"
+    }
+  end
+
+  @spec perform_filter_and_put_file(t, map) ::
+          {:ok, t} | {:error, String.t()} | {:error, atom()}
+  defp perform_filter_and_put_file(%__MODULE__{} = upload, opts) do
+    case Filter.filter(opts.filters, upload) do
+      {:ok, upload} ->
+        perform_put_file(upload, opts)
+
+      {:error, error} ->
+        {:error, error}
+    end
+  end
+
+  @spec perform_put_file(t, map) :: {:ok, t} | {:error, atom()}
+  defp perform_put_file(%__MODULE__{} = upload, opts) do
+    case Uploader.put_file(opts.uploader, upload) do
+      {:ok, url_spec} ->
+        {:ok,
+         %__MODULE__{
+           upload
+           | name: Map.get(opts, :description) || upload.name,
+             url: url_from_spec(upload, opts.base_url, url_spec)
+         }}
+
+      {:error, error} ->
+        Logger.error(
+          "#{__MODULE__} store (using #{inspect(opts.uploader)}) failed: #{inspect(error)}"
+        )
+
+        {:error, error}
+    end
+  end
+
+  @spec get_opts(Keyword.t()) :: internal_options()
   defp get_opts(opts) do
     {size_limit, activity_type} =
       case Keyword.get(opts, :type) do
@@ -123,27 +169,38 @@ defmodule Mobilizon.Web.Upload do
           {Config.get!([:instance, :upload_limit]), nil}
       end
 
+    activity_type = Keyword.get(opts, :activity_type, activity_type)
+    size_limit = Keyword.get(opts, :size_limit, size_limit)
+    uploader = Keyword.get(opts, :uploader, Config.get([__MODULE__, :uploader]))
+    filters = Keyword.get(opts, :filters, Config.get([__MODULE__, :filters]))
+    description = Keyword.get(opts, :description)
+
+    allow_list_mime_types =
+      Keyword.get(
+        opts,
+        :allow_list_mime_types,
+        Config.get([__MODULE__, :allow_list_mime_types])
+      )
+
+    base_url =
+      Keyword.get(
+        opts,
+        :base_url,
+        Config.get([__MODULE__, :base_url], Endpoint.url())
+      )
+
     %{
-      activity_type: Keyword.get(opts, :activity_type, activity_type),
-      size_limit: Keyword.get(opts, :size_limit, size_limit),
-      uploader: Keyword.get(opts, :uploader, Config.get([__MODULE__, :uploader])),
-      filters: Keyword.get(opts, :filters, Config.get([__MODULE__, :filters])),
-      description: Keyword.get(opts, :description),
-      allow_list_mime_types:
-        Keyword.get(
-          opts,
-          :allow_list_mime_types,
-          Config.get([__MODULE__, :allow_list_mime_types])
-        ),
-      base_url:
-        Keyword.get(
-          opts,
-          :base_url,
-          Config.get([__MODULE__, :base_url], Endpoint.url())
-        )
+      activity_type: activity_type,
+      size_limit: size_limit,
+      uploader: uploader,
+      filters: filters,
+      description: description,
+      allow_list_mime_types: allow_list_mime_types,
+      base_url: base_url
     }
   end
 
+  @spec prepare_upload(t(), internal_options()) :: {:ok, t()} | {:error, atom()}
   defp prepare_upload(%Plug.Upload{} = file, opts) do
     with {:ok, size} <- check_file_size(file.path, opts.size_limit),
          {:ok, content_type, name} <- MIME.file_mime_type(file.path, file.filename),
@@ -156,9 +213,14 @@ defmodule Mobilizon.Web.Upload do
          content_type: content_type,
          size: size
        }}
+    else
+      {:error, err} ->
+        {:error, err}
     end
   end
 
+  @spec prepare_upload(%{body: String.t(), name: String.t()}, internal_options()) ::
+          {:ok, t()} | {:error, :mime_type_not_allowed}
   defp prepare_upload(%{body: body, name: name} = _file, opts) do
     with :ok <- check_binary_size(body, opts.size_limit),
          tmp_path <- tempfile_for_image(body),
@@ -175,8 +237,10 @@ defmodule Mobilizon.Web.Upload do
     end
   end
 
+  @spec check_file_size(String.t(), non_neg_integer()) ::
+          {:ok, non_neg_integer()} | {:error, :file_too_large} | {:error, :file.posix()}
   defp check_file_size(path, size_limit) when is_integer(size_limit) and size_limit > 0 do
-    with {:ok, %{size: size}} <- File.stat(path),
+    with {:ok, %File.Stat{size: size}} <- File.stat(path),
          true <- size <= size_limit do
       {:ok, size}
     else
@@ -185,8 +249,7 @@ defmodule Mobilizon.Web.Upload do
     end
   end
 
-  defp check_file_size(_, _), do: :ok
-
+  @spec check_binary_size(String.t(), non_neg_integer()) :: :ok | {:error, :file_too_large}
   defp check_binary_size(binary, size_limit)
        when is_integer(size_limit) and size_limit > 0 and byte_size(binary) >= size_limit do
     {:error, :file_too_large}
@@ -196,6 +259,7 @@ defmodule Mobilizon.Web.Upload do
 
   # Creates a tempfile using the Plug.Upload Genserver which cleans them up
   # automatically.
+  @spec tempfile_for_image(iodata) :: String.t()
   defp tempfile_for_image(data) do
     {:ok, tmp_path} = Plug.Upload.random_file("temp_files")
     {:ok, tmp_file} = File.open(tmp_path, [:write, :raw, :binary])
@@ -204,6 +268,7 @@ defmodule Mobilizon.Web.Upload do
     tmp_path
   end
 
+  @spec url_from_spec(t, String.t(), {:file | :url, String.t()}) :: String.t()
   defp url_from_spec(%__MODULE__{name: name}, base_url, {:file, path}) do
     path =
       URI.encode(path, &char_unescaped?/1) <>
@@ -219,7 +284,7 @@ defmodule Mobilizon.Web.Upload do
 
   defp url_from_spec(_upload, _base_url, {:url, url}), do: url
 
-  @spec check_allowed_mime_type(String.t(), List.t()) :: :ok | {:error, :atom}
+  @spec check_allowed_mime_type(String.t(), List.t()) :: :ok | {:error, :mime_type_not_allowed}
   defp check_allowed_mime_type(content_type, allow_list_mime_types) do
     if Enum.any?(allow_list_mime_types, &(&1 == content_type)),
       do: :ok,
diff --git a/lib/web/upload/uploader/local.ex b/lib/web/upload/uploader/local.ex
index 97ff58fa6..89aa0f9a3 100644
--- a/lib/web/upload/uploader/local.ex
+++ b/lib/web/upload/uploader/local.ex
@@ -19,46 +19,74 @@ defmodule Mobilizon.Web.Upload.Uploader.Local do
   end
 
   @impl true
-  def put_file(%Upload{path: path, tempfile: tempfile}) do
-    {path, file} = local_path(path)
+  @spec put_file(Upload.t()) ::
+          :ok | {:ok, {:file, String.t()}} | {:error, :tempfile_no_longer_exists}
+  def put_file(%Upload{path: initial_path, tempfile: tempfile}) do
+    {path, file} = local_path(initial_path)
     result_file = Path.join(path, file)
 
-    with {:result_exists, false} <- {:result_exists, File.exists?(result_file)},
-         {:temp_file_exists, true} <- {:temp_file_exists, File.exists?(tempfile)} do
-      File.cp!(tempfile, result_file)
+    if File.exists?(result_file) do
+      # If the resulting file already exists, it's because of the Dedupe filter
+      :ok
     else
-      {:result_exists, _} ->
-        # If the resulting file already exists, it's because of the Dedupe filter
-        :ok
-
-      {:temp_file_exists, _} ->
-        {:error, "Temporary file no longer exists"}
+      if File.exists?(tempfile) do
+        File.cp!(tempfile, result_file)
+        {:ok, {:file, initial_path}}
+      else
+        {:error, :tempfile_no_longer_exists}
+      end
     end
   end
 
   @impl true
+  @spec remove_file(String.t()) ::
+          {:ok, {:file, String.t()}}
+          | {:error, :folder_not_empty}
+          | {:error, :enofile}
+          | {:error, File.posix()}
   def remove_file(path) do
-    with {path, file} <- local_path(path),
-         full_path <- Path.join(path, file),
-         true <- File.exists?(full_path),
-         :ok <- File.rm(full_path),
-         :ok <- remove_folder(path) do
-      {:ok, path}
+    {path, file} = local_path(path)
+    full_path = Path.join(path, file)
+
+    if File.exists?(full_path) do
+      do_remove_file(path, full_path)
     else
-      false -> {:error, "File #{path} doesn't exist"}
+      {:error, :enofile}
     end
   end
 
+  @spec do_remove_file(String.t(), String.t()) ::
+          {:ok, {:file, String.t()}}
+          | {:error, :folder_not_empty}
+          | {:error, File.posix()}
+  defp do_remove_file(path, full_path) do
+    case File.rm(full_path) do
+      :ok ->
+        case remove_folder(path) do
+          :ok ->
+            {:ok, {:file, path}}
+
+          {:error, err} ->
+            {:error, err}
+        end
+
+      {:error, err} ->
+        {:error, err}
+    end
+  end
+
+  @spec remove_folder(String.t()) :: :ok | {:error, :folder_not_empty} | {:error, File.posix()}
   defp remove_folder(path) do
     with {:subfolder, true} <- {:subfolder, path != upload_path()},
          {:empty_folder, {:ok, [] = _files}} <- {:empty_folder, File.ls(path)} do
       File.rmdir(path)
     else
       {:subfolder, _} -> :ok
-      {:empty_folder, _} -> {:error, "Error: Folder is not empty"}
+      {:empty_folder, _} -> {:error, :folder_not_empty}
     end
   end
 
+  @spec local_path(String.t()) :: {String.t(), String.t()}
   defp local_path(path) do
     case Enum.reverse(String.split(path, "/", trim: true)) do
       [file] ->
@@ -71,6 +99,7 @@ defmodule Mobilizon.Web.Upload.Uploader.Local do
     end
   end
 
+  @spec upload_path :: String.t()
   def upload_path do
     Config.get!([__MODULE__, :uploads])
   end
diff --git a/lib/web/upload/uploader/uploader.ex b/lib/web/upload/uploader/uploader.ex
index 57c9de994..f5372a36c 100644
--- a/lib/web/upload/uploader/uploader.ex
+++ b/lib/web/upload/uploader/uploader.ex
@@ -33,9 +33,9 @@ defmodule Mobilizon.Web.Upload.Uploader do
   """
   @type file_spec :: {:file | :url, String.t()}
   @callback put_file(Mobilizon.Web.Upload.t()) ::
-              :ok | {:ok, file_spec()} | {:error, String.t()} | :wait_callback
+              :ok | {:ok, file_spec()} | {:error, atom()} | :wait_callback
 
-  @callback remove_file(file_spec()) :: :ok | {:ok, file_spec()} | {:error, String.t()}
+  @callback remove_file(file_spec()) :: :ok | {:ok, file_spec()} | {:error, atom()}
 
   @callback http_callback(Plug.Conn.t(), map()) ::
               {:ok, Plug.Conn.t()}
@@ -43,7 +43,7 @@ defmodule Mobilizon.Web.Upload.Uploader do
               | {:error, Plug.Conn.t(), String.t()}
   @optional_callbacks http_callback: 2
 
-  @spec put_file(module(), Mobilizon.Web.Upload.t()) :: {:ok, file_spec()} | {:error, String.t()}
+  @spec put_file(module(), Mobilizon.Web.Upload.t()) :: {:ok, file_spec()} | {:error, atom()}
   def put_file(uploader, upload) do
     case uploader.put_file(upload) do
       :ok -> {:ok, {:file, upload.path}}
@@ -53,6 +53,7 @@ defmodule Mobilizon.Web.Upload.Uploader do
     end
   end
 
+  @spec remove_file(module(), String.t()) :: {:ok, String.t()} | {:error, atom()}
   def remove_file(uploader, path) do
     uploader.remove_file(path)
   end
diff --git a/lib/web/views/activity_pub/actor_view.ex b/lib/web/views/activity_pub/actor_view.ex
index 0e61e75a6..3e0f61930 100644
--- a/lib/web/views/activity_pub/actor_view.ex
+++ b/lib/web/views/activity_pub/actor_view.ex
@@ -17,6 +17,7 @@ defmodule Mobilizon.Web.ActivityPub.ActorView do
   @json_ld_header Utils.make_json_ld_header()
   @selected_member_roles ~w(creator administrator moderator member)a
 
+  @spec render(String.t(), map()) :: map()
   def render("actor.json", %{actor: actor}) do
     actor
     |> Convertible.model_to_as()
@@ -70,7 +71,18 @@ defmodule Mobilizon.Web.ActivityPub.ActorView do
     }
   end
 
-  @spec fetch_collection(atom(), Actor.t(), integer()) :: Page.t()
+  @type collection ::
+          :following
+          | :followers
+          | :members
+          | :resources
+          | :discussions
+          | :posts
+          | :events
+          | :todos
+          | :outbox
+
+  @spec fetch_collection(collection(), Actor.t(), integer()) :: Page.t()
   defp fetch_collection(:following, actor, page) do
     Actors.build_followings_for_actor(actor, page)
   end
@@ -103,7 +115,6 @@ defmodule Mobilizon.Web.ActivityPub.ActorView do
     Todos.get_todo_lists_for_group(actor, page)
   end
 
-  @spec fetch_collection(atom(), Actor.t(), integer()) :: %{total: integer(), elements: Enum.t()}
   defp fetch_collection(:outbox, actor, page) do
     ActivityPub.fetch_public_activities_for_actor(actor, page)
   end
@@ -179,8 +190,7 @@ defmodule Mobilizon.Web.ActivityPub.ActorView do
   def item(%Event{} = event), do: Convertible.model_to_as(event)
   def item(%TodoList{} = todo_list), do: Convertible.model_to_as(todo_list)
 
-  defp actor_applicant_group_member?(%Actor{}, nil), do: false
-
+  @spec actor_applicant_group_member?(Actor.t(), Actor.t()) :: boolean()
   defp actor_applicant_group_member?(%Actor{id: group_id}, %Actor{id: actor_applicant_id}),
     do:
       Actors.get_member(actor_applicant_id, group_id, [
diff --git a/lib/web/views/activity_pub/object_view.ex b/lib/web/views/activity_pub/object_view.ex
index 9ababb1c3..a3ee04ec8 100644
--- a/lib/web/views/activity_pub/object_view.ex
+++ b/lib/web/views/activity_pub/object_view.ex
@@ -3,6 +3,7 @@ defmodule Mobilizon.Web.ActivityPub.ObjectView do
 
   alias Mobilizon.Federation.ActivityPub.{Activity, Utils}
 
+  @spec render(String.t(), map()) :: map()
   def render("activity.json", %{activity: %Activity{local: local, data: data} = activity}) do
     %{
       "id" => data["id"],
diff --git a/lib/web/views/auth_view.ex b/lib/web/views/auth_view.ex
index 67079bd8e..9ec29ff29 100644
--- a/lib/web/views/auth_view.ex
+++ b/lib/web/views/auth_view.ex
@@ -8,6 +8,7 @@ defmodule Mobilizon.Web.AuthView do
   alias Phoenix.HTML.Tag
   import Mobilizon.Web.Views.Utils
 
+  @spec render(String.t(), map()) :: String.t() | Plug.Conn.t()
   def render("callback.html", %{
         conn: conn,
         access_token: access_token,
diff --git a/lib/web/views/error_helpers.ex b/lib/web/views/error_helpers.ex
index 5a42c31c2..eb63a4d26 100644
--- a/lib/web/views/error_helpers.ex
+++ b/lib/web/views/error_helpers.ex
@@ -8,6 +8,7 @@ defmodule Mobilizon.Web.ErrorHelpers do
   @doc """
   Translates an error message using gettext.
   """
+  @spec translate_error({msg :: String.t(), opts :: map()}) :: String.t()
   def translate_error({msg, opts}) do
     # Because error messages were defined within Ecto, we must
     # call the Gettext module passing our Gettext backend. We
diff --git a/lib/web/views/error_view.ex b/lib/web/views/error_view.ex
index de8e7a704..28e8096e3 100644
--- a/lib/web/views/error_view.ex
+++ b/lib/web/views/error_view.ex
@@ -6,6 +6,7 @@ defmodule Mobilizon.Web.ErrorView do
   alias Mobilizon.Service.Metadata.Instance
   import Mobilizon.Web.Views.Utils
 
+  @spec render(String.t(), map()) :: map() | String.t() | Plug.Conn.t()
   def render("404.html", %{conn: conn}) do
     with tags <- Instance.build_tags(),
          {:ok, html} <- inject_tags(tags, get_locale(conn)) do
diff --git a/lib/web/views/json_ld/object_view.ex b/lib/web/views/json_ld/object_view.ex
index 333193a06..cc41e511b 100644
--- a/lib/web/views/json_ld/object_view.ex
+++ b/lib/web/views/json_ld/object_view.ex
@@ -8,6 +8,7 @@ defmodule Mobilizon.Web.JsonLD.ObjectView do
   alias Mobilizon.Web.Endpoint
   alias Mobilizon.Web.JsonLD.ObjectView
 
+  @spec render(String.t(), map()) :: map()
   def render("group.json", %{group: %Actor{} = group}) do
     %{
       "@context" => "http://schema.org",
@@ -93,6 +94,7 @@ defmodule Mobilizon.Web.JsonLD.ObjectView do
     }
   end
 
+  @spec render_location(map()) :: map() | nil
   defp render_location(%{physical_address: %Address{} = address}),
     do: render_one(address, ObjectView, "place.json", as: :address)
 
diff --git a/lib/web/views/page_view.ex b/lib/web/views/page_view.ex
index 3ce02182b..7c040bd9a 100644
--- a/lib/web/views/page_view.ex
+++ b/lib/web/views/page_view.ex
@@ -19,6 +19,8 @@ defmodule Mobilizon.Web.PageView do
   alias Mobilizon.Federation.ActivityStream.Convertible
   import Mobilizon.Web.Views.Utils
 
+  @doc false
+  @spec render(String.t(), %{conn: Plug.Conn.t()}) :: map() | String.t() | Plug.Conn.t()
   def render("actor.activity-json", %{conn: %{assigns: %{object: %Actor{} = actor}}}) do
     actor
     |> Convertible.model_to_as()
diff --git a/lib/web/views/utils.ex b/lib/web/views/utils.ex
index ecc1018c4..93336f44f 100644
--- a/lib/web/views/utils.ex
+++ b/lib/web/views/utils.ex
@@ -8,7 +8,7 @@ defmodule Mobilizon.Web.Views.Utils do
   import Plug.Conn, only: [put_status: 2, halt: 1]
 
   # sobelow_skip ["Traversal.FileModule"]
-  @spec inject_tags(Enum.t(), String.t()) :: {:ok, {:safe, String.t()}}
+  @spec inject_tags(Enum.t(), String.t()) :: {:ok, {:safe, String.t()}} | {:error, atom()}
   def inject_tags(tags, locale \\ "en") do
     with path <- Path.join(Application.app_dir(:mobilizon, "priv/static"), "index.html"),
          {:exists, true} <- {:exists, File.exists?(path)},
@@ -17,6 +17,7 @@ defmodule Mobilizon.Web.Views.Utils do
       {:ok, {:safe, safe}}
     else
       {:exists, false} -> {:error, :index_not_found}
+      {:error, error} when is_atom(error) -> {:error, error}
     end
   end
 
diff --git a/mix.exs b/mix.exs
index 01805dd1e..db86fd195 100644
--- a/mix.exs
+++ b/mix.exs
@@ -9,12 +9,13 @@ defmodule Mobilizon.Mixfile do
       version: @version,
       elixir: "~> 1.11",
       elixirc_paths: elixirc_paths(Mix.env()),
-      compilers: [:phoenix, :gettext] ++ Mix.compilers(),
+      compilers: [:gettext] ++ Mix.compilers(),
       xref: [exclude: [:eldap]],
       start_permanent: Mix.env() == :prod,
       aliases: aliases(),
       deps: deps(),
       test_coverage: [tool: ExCoveralls],
+      dialyzer: [plt_add_apps: [:mix]],
       preferred_cli_env: [
         coveralls: :test,
         "coveralls.detail": :test,
@@ -94,7 +95,7 @@ defmodule Mobilizon.Mixfile do
   # Type `mix help deps` for examples and options.
   defp deps do
     [
-      {:phoenix, "~> 1.5.0"},
+      {:phoenix, "~> 1.6.0"},
       {:phoenix_pubsub, "~> 2.0"},
       {:phoenix_ecto, "~> 4.0"},
       {:postgrex, ">= 0.15.3"},
@@ -106,7 +107,7 @@ defmodule Mobilizon.Mixfile do
       {:guardian_phoenix, "~> 2.0"},
       {:argon2_elixir, "~> 2.0"},
       {:cors_plug, "~> 2.0"},
-      {:ecto_autoslug_field, "~> 2.0"},
+      {:ecto_autoslug_field, "~> 3.0"},
       {:geo, "~> 3.0"},
       {:geo_postgis, "~> 3.1"},
       {:timex, "~> 3.0"},
@@ -160,9 +161,7 @@ defmodule Mobilizon.Mixfile do
       {:sentry, "~> 8.0"},
       {:html_entities, "~> 0.5"},
       {:sweet_xml, "~> 0.7"},
-      {:web_push_encryption,
-       git: "https://github.com/tcitworld/elixir-web-push-encryption",
-       ref: "4361bd02b0b7f2cb5f8ac302bcd1210b57964a51"},
+      {:web_push_encryption, "~> 0.3"},
       {:eblurhash, "~> 1.2"},
       {:struct_access, "~> 1.1.2"},
       {:paasaa, "~> 0.5.0"},
@@ -180,7 +179,8 @@ defmodule Mobilizon.Mixfile do
       {:elixir_feed_parser, "~> 2.1.0", only: :test},
       {:mox, "~> 1.0", only: :test},
       {:junit_formatter, "~> 3.1", only: [:test]},
-      {:sobelow, "~> 0.8", only: [:dev, :test]}
+      {:sobelow, "~> 0.8", only: [:dev, :test]},
+      {:doctor, "~> 0.18.0", only: :dev}
     ] ++ oauth_deps()
   end
 
diff --git a/mix.lock b/mix.lock
index ab5fb59ba..a6350ac69 100644
--- a/mix.lock
+++ b/mix.lock
@@ -23,26 +23,26 @@
   "db_connection": {:hex, :db_connection, "2.4.0", "d04b1b73795dae60cead94189f1b8a51cc9e1f911c234cc23074017c43c031e5", [:mix], [{:connection, "~> 1.0", [hex: :connection, repo: "hexpm", optional: false]}, {:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "ad416c21ad9f61b3103d254a71b63696ecadb6a917b36f563921e0de00d7d7c8"},
   "decimal": {:hex, :decimal, "2.0.0", "a78296e617b0f5dd4c6caf57c714431347912ffb1d0842e998e9792b5642d697", [:mix], [], "hexpm", "34666e9c55dea81013e77d9d87370fe6cb6291d1ef32f46a1600230b1d44f577"},
   "dialyxir": {:hex, :dialyxir, "1.1.0", "c5aab0d6e71e5522e77beff7ba9e08f8e02bad90dfbeffae60eaf0cb47e29488", [:mix], [{:erlex, ">= 0.2.6", [hex: :erlex, repo: "hexpm", optional: false]}], "hexpm", "07ea8e49c45f15264ebe6d5b93799d4dd56a44036cf42d0ad9c960bc266c0b9a"},
+  "doctor": {:hex, :doctor, "0.18.0", "114934c1740239953208a39db617699b7e2660770e81129d7f95cdf7837ab766", [:mix], [{:decimal, "~> 2.0", [hex: :decimal, repo: "hexpm", optional: false]}], "hexpm", "829c88c365f72c0666e443ea670ffb6f180de7b90c23d536edabdd8c722b88f4"},
   "earmark": {:hex, :earmark, "1.4.15", "2c7f924bf495ec1f65bd144b355d0949a05a254d0ec561740308a54946a67888", [:mix], [{:earmark_parser, ">= 1.4.13", [hex: :earmark_parser, repo: "hexpm", optional: false]}], "hexpm", "3b1209b85bc9f3586f370f7c363f6533788fb4e51db23aa79565875e7f9999ee"},
   "earmark_parser": {:hex, :earmark_parser, "1.4.15", "b29e8e729f4aa4a00436580dcc2c9c5c51890613457c193cc8525c388ccb2f06", [:mix], [], "hexpm", "044523d6438ea19c1b8ec877ec221b008661d3c27e3b848f4c879f500421ca5c"},
-  "eblurhash": {:hex, :eblurhash, "1.2.0", "ff461979542fcb1bfd428aaba6ee56e544975f6d657aa3dfcf3e314b1d1c2517", [:rebar3], [], "hexpm", "8fa6b740f1630adc0a3e425dbbb4ff92d036e62eb973e7a06676226137a10aa7"},
+  "eblurhash": {:hex, :eblurhash, "1.2.1", "36b187459244f5374bb7f47fd0b3001ee3f74d72b18bb04b00cdb7080cdf70f2", [:rebar3], [], "hexpm", "c0b168e734562f8edf1f0abf145b95f93e7657187e1bfaacc32a5714921e920b"},
   "ecto": {:hex, :ecto, "3.7.1", "a20598862351b29f80f285b21ec5297da1181c0442687f9b8329f0445d228892", [:mix], [{:decimal, "~> 1.6 or ~> 2.0", [hex: :decimal, repo: "hexpm", optional: false]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}, {:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "d36e5b39fc479e654cffd4dbe1865d9716e4a9b6311faff799b6f90ab81b8638"},
-  "ecto_autoslug_field": {:hex, :ecto_autoslug_field, "2.0.1", "2177c1c253f6dd3efd4b56d1cb76104d0a6ef044c6b9a7a0ad6d32665c4111e5", [:mix], [{:ecto, ">= 2.1.0", [hex: :ecto, repo: "hexpm", optional: false]}, {:slugger, ">= 0.2.0", [hex: :slugger, repo: "hexpm", optional: false]}], "hexpm", "a3cc73211f2e75b89a03332183812ebe1ac08be2e25a1df5aa3d1422f92c45c3"},
+  "ecto_autoslug_field": {:hex, :ecto_autoslug_field, "3.0.0", "37fbc2f07e6691136afff246f2cf5b159ad395b665a55d06db918975fd2397db", [:mix], [{:ecto, ">= 3.7.0", [hex: :ecto, repo: "hexpm", optional: false]}, {:slugger, ">= 0.3.0", [hex: :slugger, repo: "hexpm", optional: false]}], "hexpm", "8ec252c7cf85f13132062f56a484d6a0ef1f981f7be9ce4ad7e9546dd8c0cc0f"},
   "ecto_enum": {:hex, :ecto_enum, "1.4.0", "d14b00e04b974afc69c251632d1e49594d899067ee2b376277efd8233027aec8", [:mix], [{:ecto, ">= 3.0.0", [hex: :ecto, repo: "hexpm", optional: false]}, {:ecto_sql, "> 3.0.0", [hex: :ecto_sql, repo: "hexpm", optional: false]}, {:mariaex, ">= 0.0.0", [hex: :mariaex, repo: "hexpm", optional: true]}, {:postgrex, ">= 0.0.0", [hex: :postgrex, repo: "hexpm", optional: true]}], "hexpm", "8fb55c087181c2b15eee406519dc22578fa60dd82c088be376d0010172764ee4"},
   "ecto_shortuuid": {:hex, :ecto_shortuuid, "0.1.3", "d36aede64edf256e4b769be2ad15a8ad5d9d1ff8ad46befe39e8cb4489abcd05", [:mix], [{:ecto, "~> 2.2 or ~> 3.0", [hex: :ecto, repo: "hexpm", optional: false]}, {:shortuuid, "~> 2.1.1", [hex: :shortuuid, repo: "hexpm", optional: false]}], "hexpm", "d215c8ced7125265de94d55abc696125942caef33439cf281fafded9744a4294"},
   "ecto_sql": {:hex, :ecto_sql, "3.7.0", "2fcaad4ab0c8d76a5afbef078162806adbe709c04160aca58400d5cbbe8eeac6", [:mix], [{:db_connection, "~> 2.2", [hex: :db_connection, repo: "hexpm", optional: false]}, {:ecto, "~> 3.7.0", [hex: :ecto, repo: "hexpm", optional: false]}, {:myxql, "~> 0.4.0 or ~> 0.5.0", [hex: :myxql, repo: "hexpm", optional: true]}, {:postgrex, "~> 0.15.0 or ~> 1.0", [hex: :postgrex, repo: "hexpm", optional: true]}, {:tds, "~> 2.1.1", [hex: :tds, repo: "hexpm", optional: true]}, {:telemetry, "~> 0.4.0 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "a26135dfa1d99bf87a928c464cfa25bba6535a4fe761eefa56077a4febc60f70"},
   "elixir_feed_parser": {:hex, :elixir_feed_parser, "2.1.0", "bb96fb6422158dc7ad59de62ef211cc69d264acbbe63941a64a5dce97bbbc2e6", [:mix], [{:timex, "~> 3.4", [hex: :timex, repo: "hexpm", optional: false]}], "hexpm", "2d3c62fe7b396ee3b73d7160bc8fadbd78bfe9597c98c7d79b3f1038d9cba28f"},
   "elixir_make": {:hex, :elixir_make, "0.6.2", "7dffacd77dec4c37b39af867cedaabb0b59f6a871f89722c25b28fcd4bd70530", [:mix], [], "hexpm", "03e49eadda22526a7e5279d53321d1cced6552f344ba4e03e619063de75348d9"},
   "erlex": {:hex, :erlex, "0.2.6", "c7987d15e899c7a2f34f5420d2a2ea0d659682c06ac607572df55a43753aa12e", [:mix], [], "hexpm", "2ed2e25711feb44d52b17d2780eabf998452f6efda104877a3881c2f8c0c0c75"},
-  "erlsom": {:hex, :erlsom, "1.5.0", "c5a5cdd0ee0e8dca62bcc4b13ff08da24fdefc16ccd8b25282a2fda2ba1be24a", [:rebar3], [], "hexpm", "55a9dbf9cfa77fcfc108bd8e2c4f9f784dea228a8f4b06ea10b684944946955a"},
   "eternal": {:hex, :eternal, "1.2.2", "d1641c86368de99375b98d183042dd6c2b234262b8d08dfd72b9eeaafc2a1abd", [:mix], [], "hexpm", "2c9fe32b9c3726703ba5e1d43a1d255a4f3f2d8f8f9bc19f094c7cb1a7a9e782"},
-  "ex_cldr": {:hex, :ex_cldr, "2.23.1", "a449fb44d00131b096f0e203da563827f731ceceafce50cf5e756379bf29e32a", [:mix], [{:castore, "~> 0.1", [hex: :castore, repo: "hexpm", optional: true]}, {:certifi, "~> 2.5", [hex: :certifi, repo: "hexpm", optional: true]}, {:cldr_utils, "~> 2.15", [hex: :cldr_utils, repo: "hexpm", optional: false]}, {:decimal, "~> 1.6 or ~> 2.0", [hex: :decimal, repo: "hexpm", optional: false]}, {:gettext, "~> 0.13", [hex: :gettext, repo: "hexpm", optional: true]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}, {:nimble_parsec, "~> 0.5 or ~> 1.0", [hex: :nimble_parsec, repo: "hexpm", optional: true]}, {:plug, "~> 1.9", [hex: :plug, repo: "hexpm", optional: true]}, {:telemetry, "~> 0.4.0", [hex: :telemetry, repo: "hexpm", optional: true]}], "hexpm", "f7b42cf2d72bd48feda95890447ff7ef3a07d94c572bf9607db0f7d5c5effaf0"},
+  "ex_cldr": {:hex, :ex_cldr, "2.23.2", "76c51b722cefdcd1a13eb5e7c7f4da5b9acfd64ff054424a977ff6e2d6a78981", [:mix], [{:castore, "~> 0.1", [hex: :castore, repo: "hexpm", optional: true]}, {:certifi, "~> 2.5", [hex: :certifi, repo: "hexpm", optional: true]}, {:cldr_utils, "~> 2.15", [hex: :cldr_utils, repo: "hexpm", optional: false]}, {:decimal, "~> 1.6 or ~> 2.0", [hex: :decimal, repo: "hexpm", optional: false]}, {:gettext, "~> 0.13", [hex: :gettext, repo: "hexpm", optional: true]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}, {:nimble_parsec, "~> 0.5 or ~> 1.0", [hex: :nimble_parsec, repo: "hexpm", optional: true]}, {:plug, "~> 1.9", [hex: :plug, repo: "hexpm", optional: true]}], "hexpm", "d9ce03c8d3fdc7ab751bdb2be742b6972f94adc856d51dfe5bb06a51ac96b8f4"},
   "ex_cldr_calendars": {:hex, :ex_cldr_calendars, "1.16.0", "7f076c85b63b03cf2c5719b75a9c1ca1b177d6d164a94a1eaf4bfb1a5dca152a", [:mix], [{:calendar_interval, "~> 0.2", [hex: :calendar_interval, repo: "hexpm", optional: true]}, {:earmark, "~> 1.0", [hex: :earmark, repo: "hexpm", optional: false]}, {:ex_cldr, "~> 2.23", [hex: :ex_cldr, repo: "hexpm", optional: false]}, {:ex_cldr_units, "~> 3.7", [hex: :ex_cldr_units, repo: "hexpm", optional: true]}, {:ex_doc, "~> 0.21", [hex: :ex_doc, repo: "hexpm", optional: true]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: false]}], "hexpm", "483d91a0fb4909efe211ae59a3620a28bf1a72d64dbf922ae940115e64f6138a"},
   "ex_cldr_currencies": {:hex, :ex_cldr_currencies, "2.11.1", "a6e56209d6f98082cd197aa424333e7a0e38e79253fce9589117719728de4fef", [:mix], [{:ex_cldr, "~> 2.23", [hex: :ex_cldr, repo: "hexpm", optional: false]}, {:ex_doc, "~> 0.18", [hex: :ex_doc, repo: "hexpm", optional: true]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}], "hexpm", "99e8eb3f48a30127bb11ab70f484c124c9fe5b11bce710c94c53939032b0c58c"},
-  "ex_cldr_dates_times": {:hex, :ex_cldr_dates_times, "2.9.2", "39820b1b11ba621ea2832137beb726180bb59936db2eda1df2ad9753d3539b2f", [:mix], [{:calendar_interval, "~> 0.2", [hex: :calendar_interval, repo: "hexpm", optional: true]}, {:ex_cldr_calendars, "~> 1.15", [hex: :ex_cldr_calendars, repo: "hexpm", optional: false]}, {:ex_cldr_numbers, "~> 2.19", [hex: :ex_cldr_numbers, repo: "hexpm", optional: false]}, {:ex_doc, "~> 0.18", [hex: :ex_doc, repo: "hexpm", optional: true]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}], "hexpm", "dabd8e6f444c178b63dea8ace09477f503489027c3708785d5f0e58957104d12"},
+  "ex_cldr_dates_times": {:hex, :ex_cldr_dates_times, "2.9.4", "9ee780d2226f695fc80e45f61118c3feccc9ec47ef1685300b4c1a22a039111f", [:mix], [{:calendar_interval, "~> 0.2", [hex: :calendar_interval, repo: "hexpm", optional: true]}, {:ex_cldr_calendars, "~> 1.15", [hex: :ex_cldr_calendars, repo: "hexpm", optional: false]}, {:ex_cldr_numbers, "~> 2.19", [hex: :ex_cldr_numbers, repo: "hexpm", optional: false]}, {:ex_doc, "~> 0.18", [hex: :ex_doc, repo: "hexpm", optional: true]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}], "hexpm", "0597172df5e7bcc7d79b5405adb1ee2b06c607a0879c66c768fba055b5c81434"},
   "ex_cldr_languages": {:hex, :ex_cldr_languages, "0.2.2", "d7dab93272443b70e18e6aef0f62974418baaca3a3b31a66d51921ec1547113c", [:mix], [{:ex_cldr, "~> 2.2 and >= 2.2.1", [hex: :ex_cldr, repo: "hexpm", optional: false]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}], "hexpm", "d9cbf4bf643365b0042e774520ddfcbc31618efd5a5383fac98f75149961622c"},
-  "ex_cldr_numbers": {:hex, :ex_cldr_numbers, "2.22.0", "fd1bedc4275dd294316ea64faee61abac3bf5ccf78c8d2e4667eb4010790ddde", [:mix], [{:decimal, "~> 1.6 or ~> 2.0", [hex: :decimal, repo: "hexpm", optional: false]}, {:ex_cldr, "~> 2.23", [hex: :ex_cldr, repo: "hexpm", optional: false]}, {:ex_cldr_currencies, "~> 2.11", [hex: :ex_cldr_currencies, repo: "hexpm", optional: false]}, {:ex_doc, "~> 0.18", [hex: :ex_doc, repo: "hexpm", optional: true]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}], "hexpm", "af8e726712744efe08bc3d5af795e29118269b46f64bc8950f57d7d8420baf7c"},
-  "ex_doc": {:hex, :ex_doc, "0.25.2", "4f1cae793c4d132e06674b282f1d9ea3bf409bcca027ddb2fe177c4eed6a253f", [:mix], [{:earmark_parser, "~> 1.4.0", [hex: :earmark_parser, repo: "hexpm", optional: false]}, {:makeup_elixir, "~> 0.14", [hex: :makeup_elixir, repo: "hexpm", optional: false]}, {:makeup_erlang, "~> 0.1", [hex: :makeup_erlang, repo: "hexpm", optional: false]}], "hexpm", "5b0c172e87ac27f14dfd152d52a145238ec71a95efbf29849550278c58a393d6"},
+  "ex_cldr_numbers": {:hex, :ex_cldr_numbers, "2.22.1", "c710abb30a89875a5e2aff5f8a5e073ffad8689c6e84034729f10c51d39c4dcf", [:mix], [{:decimal, "~> 1.6 or ~> 2.0", [hex: :decimal, repo: "hexpm", optional: false]}, {:ex_cldr, "~> 2.23", [hex: :ex_cldr, repo: "hexpm", optional: false]}, {:ex_cldr_currencies, "~> 2.11", [hex: :ex_cldr_currencies, repo: "hexpm", optional: false]}, {:ex_doc, "~> 0.18", [hex: :ex_doc, repo: "hexpm", optional: true]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}], "hexpm", "2015161a54f583eede00f18cdf43ec2b27aecf53e22486f6158d787da1f02bb9"},
+  "ex_doc": {:hex, :ex_doc, "0.25.3", "3edf6a0d70a39d2eafde030b8895501b1c93692effcbd21347296c18e47618ce", [:mix], [{:earmark_parser, "~> 1.4.0", [hex: :earmark_parser, repo: "hexpm", optional: false]}, {:makeup_elixir, "~> 0.14", [hex: :makeup_elixir, repo: "hexpm", optional: false]}, {:makeup_erlang, "~> 0.1", [hex: :makeup_erlang, repo: "hexpm", optional: false]}], "hexpm", "9ebebc2169ec732a38e9e779fd0418c9189b3ca93f4a676c961be6c1527913f5"},
   "ex_ical": {:hex, :ex_ical, "0.2.0", "4b928b554614704016cc0c9ee226eb854da9327a1cc460457621ceacb1ac29a6", [:mix], [{:timex, "~> 3.1", [hex: :timex, repo: "hexpm", optional: false]}], "hexpm", "db76473b2ae0259e6633c6c479a5a4d8603f09497f55c88f9ef4d53d2b75befb"},
   "ex_machina": {:hex, :ex_machina, "2.7.0", "b792cc3127fd0680fecdb6299235b4727a4944a09ff0fa904cc639272cd92dc7", [:mix], [{:ecto, "~> 2.2 or ~> 3.0", [hex: :ecto, repo: "hexpm", optional: true]}, {:ecto_sql, "~> 3.0", [hex: :ecto_sql, repo: "hexpm", optional: true]}], "hexpm", "419aa7a39bde11894c87a615c4ecaa52d8f107bbdd81d810465186f783245bf8"},
   "ex_optimizer": {:hex, :ex_optimizer, "0.1.1", "62da37e206fc2233ff7a4e54e40eae365c40f96c81992fcd15b782eb25169b80", [:mix], [{:file_info, "~> 0.0.4", [hex: :file_info, repo: "hexpm", optional: false]}], "hexpm", "e6f5c059bcd58b66be2f6f257fdc4f69b74b0fa5c9ddd669486af012e4b52286"},
@@ -75,7 +75,7 @@
   "icalendar": {:git, "https://github.com/tcitworld/icalendar.git", "e16a3a0b74e07ba79044361fbf5014bed344f2da", []},
   "idna": {:hex, :idna, "6.1.1", "8a63070e9f7d0c62eb9d9fcb360a7de382448200fbbd1b106cc96d3d8099df8d", [:rebar3], [{:unicode_util_compat, "~>0.7.0", [hex: :unicode_util_compat, repo: "hexpm", optional: false]}], "hexpm", "92376eb7894412ed19ac475e4a86f7b413c1b9fbb5bd16dccd57934157944cea"},
   "inet_cidr": {:hex, :inet_cidr, "1.0.4", "a05744ab7c221ca8e395c926c3919a821eb512e8f36547c062f62c4ca0cf3d6e", [:mix], [], "hexpm", "64a2d30189704ae41ca7dbdd587f5291db5d1dda1414e0774c29ffc81088c1bc"},
-  "ip_reserved": {:hex, :ip_reserved, "0.1.0", "5c3b6df25eb875618e489db47e00fb8dac53bc2b0dc2d546b713e6141210fe9f", [:mix], [{:inet_cidr, "~> 1.0.0", [hex: :inet_cidr, repo: "hexpm", optional: false]}], "hexpm", "88b0e96f40048f214b9e90e64eaebbf18acfec066008d7ef993b08282b2fe484"},
+  "ip_reserved": {:hex, :ip_reserved, "0.1.1", "e5112d71f1abf05207f82fd9597d369a5fde1e0b6d1bbe77c02a99bb26ecdc33", [:mix], [{:inet_cidr, "~> 1.0.0", [hex: :inet_cidr, repo: "hexpm", optional: false]}], "hexpm", "55fcd2b6e211caef09ea3f54ef37d43030bec486325d12fe865ab5ed8140a4fe"},
   "jason": {:hex, :jason, "1.2.2", "ba43e3f2709fd1aa1dce90aaabfd039d000469c05c56f0b8e31978e03fa39052", [:mix], [{:decimal, "~> 1.0 or ~> 2.0", [hex: :decimal, repo: "hexpm", optional: true]}], "hexpm", "18a228f5f0058ee183f29f9eae0805c6e59d61c3b006760668d8d18ff0d12179"},
   "jose": {:hex, :jose, "1.11.2", "f4c018ccf4fdce22c71e44d471f15f723cb3efab5d909ab2ba202b5bf35557b3", [:mix, :rebar3], [], "hexpm", "98143fbc48d55f3a18daba82d34fe48959d44538e9697c08f34200fa5f0947d2"},
   "jsx": {:hex, :jsx, "2.8.3", "a05252d381885240744d955fbe3cf810504eb2567164824e19303ea59eef62cf", [:mix, :rebar3], [], "hexpm", "fc3499fed7a726995aa659143a248534adc754ebd16ccd437cd93b649a95091f"},
@@ -98,19 +98,19 @@
   "nimble_parsec": {:hex, :nimble_parsec, "1.1.0", "3a6fca1550363552e54c216debb6a9e95bd8d32348938e13de5eda962c0d7f89", [:mix], [], "hexpm", "08eb32d66b706e913ff748f11694b17981c0b04a33ef470e33e11b3d3ac8f54b"},
   "nimble_pool": {:hex, :nimble_pool, "0.1.0", "ffa9d5be27eee2b00b0c634eb649aa27f97b39186fec3c493716c2a33e784ec6", [:mix], [], "hexpm", "343a1eaa620ddcf3430a83f39f2af499fe2370390d4f785cd475b4df5acaf3f9"},
   "oauth2": {:hex, :oauth2, "2.0.0", "338382079fe16c514420fa218b0903f8ad2d4bfc0ad0c9f988867dfa246731b0", [:mix], [{:hackney, "~> 1.13", [hex: :hackney, repo: "hexpm", optional: false]}], "hexpm", "881b8364ac7385f9fddc7949379cbe3f7081da37233a1aa7aab844670a91e7e7"},
-  "oauther": {:hex, :oauther, "1.1.1", "7d8b16167bb587ecbcddd3f8792beb9ec3e7b65c1f8ebd86b8dd25318d535752", [:mix], [], "hexpm", "9374f4302045321874cccdc57eb975893643bd69c3b22bf1312dab5f06e5788e"},
+  "oauther": {:hex, :oauther, "1.2.0", "394f097845393370009924456fa073389896701c62198ad15110f647f12e43d7", [:mix], [], "hexpm", "ca7b1097980e85e1d54bcdc200b4e4157e436bac17bc1801394d23f677650fec"},
   "oban": {:hex, :oban, "2.8.0", "e44b19a30e30bb983099f55d59749316ff0eaf5dfef4214e1190738176653e50", [:mix], [{:ecto_sql, ">= 3.4.3", [hex: :ecto_sql, repo: "hexpm", optional: false]}, {:jason, "~> 1.1", [hex: :jason, repo: "hexpm", optional: false]}, {:postgrex, "~> 0.14", [hex: :postgrex, repo: "hexpm", optional: false]}, {:telemetry, "~> 0.4", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "2954a2ac418f7cc4217c0772a3dd3a70e2966240583b97f4126a489e1300a573"},
   "paasaa": {:hex, :paasaa, "0.5.1", "58d8bf61902adfd1d04815a115f0eb3b996845c0360f1831854e21073411e822", [:mix], [], "hexpm", "571f1a33b8e184396a93fc18ee5331f2655c96ba9a6fc383dc675e4bc8fc7596"},
   "parse_trans": {:hex, :parse_trans, "3.3.1", "16328ab840cc09919bd10dab29e431da3af9e9e7e7e6f0089dd5a2d2820011d8", [:rebar3], [], "hexpm", "07cd9577885f56362d414e8c4c4e6bdf10d43a8767abb92d24cbe8b24c54888b"},
-  "phoenix": {:hex, :phoenix, "1.5.12", "75fddb14c720388eea93d33886166a690416a7ff8633fbd93f364355b6fe1166", [:mix], [{:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}, {:phoenix_html, "~> 2.13 or ~> 3.0", [hex: :phoenix_html, repo: "hexpm", optional: true]}, {:phoenix_pubsub, "~> 2.0", [hex: :phoenix_pubsub, repo: "hexpm", optional: false]}, {:plug, "~> 1.10", [hex: :plug, repo: "hexpm", optional: false]}, {:plug_cowboy, "~> 1.0 or ~> 2.2", [hex: :plug_cowboy, repo: "hexpm", optional: true]}, {:plug_crypto, "~> 1.1.2 or ~> 1.2", [hex: :plug_crypto, repo: "hexpm", optional: false]}, {:telemetry, "~> 0.4", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "8f0ae6734fcc18bbaa646c161e2febc46fb899eae43f82679b92530983324113"},
+  "phoenix": {:hex, :phoenix, "1.6.0", "7b85023f7ddef9a5c70909a51cc37c8b868b474d853f90f4280efd26b0e7cce5", [:mix], [{:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}, {:phoenix_pubsub, "~> 2.0", [hex: :phoenix_pubsub, repo: "hexpm", optional: false]}, {:phoenix_view, "~> 1.0", [hex: :phoenix_view, repo: "hexpm", optional: false]}, {:plug, "~> 1.10", [hex: :plug, repo: "hexpm", optional: false]}, {:plug_cowboy, "~> 2.2", [hex: :plug_cowboy, repo: "hexpm", optional: true]}, {:plug_crypto, "~> 1.2", [hex: :plug_crypto, repo: "hexpm", optional: false]}, {:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "52ffdd31f2daeb399b2e1eb57d468f99a1ad6eee5d8ea19d2353492f06c9fc96"},
   "phoenix_ecto": {:hex, :phoenix_ecto, "4.4.0", "0672ed4e4808b3fbed494dded89958e22fb882de47a97634c0b13e7b0b5f7720", [:mix], [{:ecto, "~> 3.3", [hex: :ecto, repo: "hexpm", optional: false]}, {:phoenix_html, "~> 2.14.2 or ~> 3.0", [hex: :phoenix_html, repo: "hexpm", optional: true]}, {:plug, "~> 1.9", [hex: :plug, repo: "hexpm", optional: false]}], "hexpm", "09864e558ed31ee00bd48fcc1d4fc58ae9678c9e81649075431e69dbabb43cc1"},
-  "phoenix_html": {:hex, :phoenix_html, "3.0.3", "32812d70841c7e975e01edb591989b2b002b69797db1005b8d0adc1fe717be30", [:mix], [{:plug, "~> 1.5", [hex: :plug, repo: "hexpm", optional: true]}], "hexpm", "e8152ae9e8c60705659761edb8d8c4bb7e29130a9b0803ec1854fe137ec62dde"},
+  "phoenix_html": {:hex, :phoenix_html, "3.0.4", "232d41884fe6a9c42d09f48397c175cd6f0d443aaa34c7424da47604201df2e1", [:mix], [{:plug, "~> 1.5", [hex: :plug, repo: "hexpm", optional: true]}], "hexpm", "ce17fd3cf815b2ed874114073e743507704b1f5288bb03c304a77458485efc8b"},
   "phoenix_live_reload": {:hex, :phoenix_live_reload, "1.3.3", "3a53772a6118d5679bf50fc1670505a290e32a1d195df9e069d8c53ab040c054", [:mix], [{:file_system, "~> 0.2.1 or ~> 0.3", [hex: :file_system, repo: "hexpm", optional: false]}, {:phoenix, "~> 1.4", [hex: :phoenix, repo: "hexpm", optional: false]}], "hexpm", "766796676e5f558dbae5d1bdb066849673e956005e3730dfd5affd7a6da4abac"},
   "phoenix_pubsub": {:hex, :phoenix_pubsub, "2.0.0", "a1ae76717bb168cdeb10ec9d92d1480fec99e3080f011402c0a2d68d47395ffb", [:mix], [], "hexpm", "c52d948c4f261577b9c6fa804be91884b381a7f8f18450c5045975435350f771"},
+  "phoenix_view": {:hex, :phoenix_view, "1.0.0", "fea71ecaaed71178b26dd65c401607de5ec22e2e9ef141389c721b3f3d4d8011", [:mix], [{:phoenix_html, "~> 2.14.2 or ~> 3.0", [hex: :phoenix_html, repo: "hexpm", optional: true]}], "hexpm", "82be3e2516f5633220246e2e58181282c71640dab7afc04f70ad94253025db0c"},
   "plug": {:hex, :plug, "1.12.1", "645678c800601d8d9f27ad1aebba1fdb9ce5b2623ddb961a074da0b96c35187d", [:mix], [{:mime, "~> 1.0 or ~> 2.0", [hex: :mime, repo: "hexpm", optional: false]}, {:plug_crypto, "~> 1.1.1 or ~> 1.2", [hex: :plug_crypto, repo: "hexpm", optional: false]}, {:telemetry, "~> 0.4.3 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "d57e799a777bc20494b784966dc5fbda91eb4a09f571f76545b72a634ce0d30b"},
-  "plug_cowboy": {:hex, :plug_cowboy, "2.5.1", "7cc96ff645158a94cf3ec9744464414f02287f832d6847079adfe0b58761cbd0", [:mix], [{:cowboy, "~> 2.7", [hex: :cowboy, repo: "hexpm", optional: false]}, {:cowboy_telemetry, "~> 0.3", [hex: :cowboy_telemetry, repo: "hexpm", optional: false]}, {:plug, "~> 1.7", [hex: :plug, repo: "hexpm", optional: false]}, {:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "107d0a5865fa92bcb48e631cc0729ae9ccfa0a9f9a1bd8f01acb513abf1c2d64"},
+  "plug_cowboy": {:hex, :plug_cowboy, "2.5.2", "62894ccd601cf9597e2c23911ff12798a8a18d237e9739f58a6b04e4988899fe", [:mix], [{:cowboy, "~> 2.7", [hex: :cowboy, repo: "hexpm", optional: false]}, {:cowboy_telemetry, "~> 0.3", [hex: :cowboy_telemetry, repo: "hexpm", optional: false]}, {:plug, "~> 1.7", [hex: :plug, repo: "hexpm", optional: false]}], "hexpm", "ea6e87f774c8608d60c8d34022a7d073bd7680a0a013f049fc62bf35efea1044"},
   "plug_crypto": {:hex, :plug_crypto, "1.2.2", "05654514ac717ff3a1843204b424477d9e60c143406aa94daf2274fdd280794d", [:mix], [], "hexpm", "87631c7ad914a5a445f0a3809f99b079113ae4ed4b867348dd9eec288cecb6db"},
-  "poison": {:hex, :poison, "4.0.1", "bcb755a16fac91cad79bfe9fc3585bb07b9331e50cfe3420a24bcc2d735709ae", [:mix], [], "hexpm", "ba8836feea4b394bb718a161fc59a288fe0109b5006d6bdf97b6badfcf6f0f25"},
   "postgrex": {:hex, :postgrex, "0.15.10", "2809dee1b1d76f7cbabe570b2a9285c2e7b41be60cf792f5f2804a54b838a067", [:mix], [{:connection, "~> 1.0", [hex: :connection, repo: "hexpm", optional: false]}, {:db_connection, "~> 2.1", [hex: :db_connection, repo: "hexpm", optional: false]}, {:decimal, "~> 1.5 or ~> 2.0", [hex: :decimal, repo: "hexpm", optional: false]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}], "hexpm", "1560ca427542f6b213f8e281633ae1a3b31cdbcd84ebd7f50628765b8f6132be"},
   "progress_bar": {:hex, :progress_bar, "2.0.1", "7b40200112ae533d5adceb80ff75fbe66dc753bca5f6c55c073bfc122d71896d", [:mix], [{:decimal, "~> 2.0", [hex: :decimal, repo: "hexpm", optional: false]}], "hexpm", "2519eb58a2f149a3a094e729378256d8cb6d96a259ec94841bd69fdc71f18f87"},
   "ranch": {:hex, :ranch, "1.8.0", "8c7a100a139fd57f17327b6413e4167ac559fbc04ca7448e9be9057311597a1d", [:make, :rebar3], [], "hexpm", "49fbcfd3682fab1f5d109351b61257676da1a2fdbe295904176d5e521a2ddfe5"},
@@ -138,6 +138,6 @@
   "ueberauth_twitter": {:hex, :ueberauth_twitter, "0.4.0", "4b98620341bc91bac90459093bba093c650823b6e2df35b70255c493c17e9227", [:mix], [{:httpoison, "~> 1.0", [hex: :httpoison, repo: "hexpm", optional: false]}, {:oauther, "~> 1.1", [hex: :oauther, repo: "hexpm", optional: false]}, {:ueberauth, "~> 0.6", [hex: :ueberauth, repo: "hexpm", optional: false]}], "hexpm", "fb29c9047ca263038c0c61f5a0ec8597e8564aba3f2b4cb02704b60205fd4468"},
   "unicode_util_compat": {:hex, :unicode_util_compat, "0.7.0", "bc84380c9ab48177092f43ac89e4dfa2c6d62b40b8bd132b1059ecc7232f9a78", [:rebar3], [], "hexpm", "25eee6d67df61960cf6a794239566599b09e17e668d3700247bc498638152521"},
   "unsafe": {:hex, :unsafe, "1.0.1", "a27e1874f72ee49312e0a9ec2e0b27924214a05e3ddac90e91727bc76f8613d8", [:mix], [], "hexpm", "6c7729a2d214806450d29766abc2afaa7a2cbecf415be64f36a6691afebb50e5"},
-  "web_push_encryption": {:git, "https://github.com/tcitworld/elixir-web-push-encryption", "4361bd02b0b7f2cb5f8ac302bcd1210b57964a51", [ref: "4361bd02b0b7f2cb5f8ac302bcd1210b57964a51"]},
+  "web_push_encryption": {:hex, :web_push_encryption, "0.3.1", "76d0e7375142dfee67391e7690e89f92578889cbcf2879377900b5620ee4708d", [:mix], [{:httpoison, "~> 1.0", [hex: :httpoison, repo: "hexpm", optional: false]}, {:jose, "~> 1.11.1", [hex: :jose, repo: "hexpm", optional: false]}], "hexpm", "4f82b2e57622fb9337559058e8797cb0df7e7c9790793bdc4e40bc895f70e2a2"},
   "xml_builder": {:hex, :xml_builder, "2.2.0", "cc5f1eeefcfcde6e90a9b77fb6c490a20bc1b856a7010ce6396f6da9719cbbab", [:mix], [], "hexpm", "9d66d52fb917565d358166a4314078d39ef04d552904de96f8e73f68f64a62c9"},
 }
diff --git a/test/federation/activity_pub/activity_pub_test.exs b/test/federation/activity_pub/activity_pub_test.exs
index aa72aae8f..59e6986d5 100644
--- a/test/federation/activity_pub/activity_pub_test.exs
+++ b/test/federation/activity_pub/activity_pub_test.exs
@@ -16,7 +16,7 @@ defmodule Mobilizon.Federation.ActivityPubTest do
   alias Mobilizon.Todos.{Todo, TodoList}
 
   alias Mobilizon.Federation.ActivityPub
-  alias Mobilizon.Federation.ActivityPub.Utils
+  alias Mobilizon.Federation.ActivityPub.{Actions, Utils}
   alias Mobilizon.Federation.HTTPSignatures.Signature
   alias Mobilizon.Service.HTTP.ActivityPub.Mock
 
@@ -117,7 +117,7 @@ defmodule Mobilizon.Federation.ActivityPubTest do
     test "it creates a delete activity and deletes the original event" do
       event = insert(:event)
       event = Events.get_public_event_by_url_with_preload!(event.url)
-      {:ok, delete, _} = ActivityPub.delete(event, event.organizer_actor)
+      {:ok, delete, _} = Actions.Delete.delete(event, event.organizer_actor)
 
       assert delete.data["type"] == "Delete"
       assert delete.data["actor"] == event.organizer_actor.url
@@ -133,7 +133,7 @@ defmodule Mobilizon.Federation.ActivityPubTest do
         lazy_put_activity_defaults: fn args -> args end do
         event = insert(:event)
         event = Events.get_public_event_by_url_with_preload!(event.url)
-        {:ok, delete, _} = ActivityPub.delete(event, event.organizer_actor, false)
+        {:ok, delete, _} = Actions.Delete.delete(event, event.organizer_actor, false)
 
         assert delete.data["type"] == "Delete"
         assert delete.data["actor"] == event.organizer_actor.url
@@ -151,7 +151,7 @@ defmodule Mobilizon.Federation.ActivityPubTest do
       comment = insert(:comment)
       comment = Discussions.get_comment_from_url_with_preload!(comment.url)
       assert is_nil(Discussions.get_comment_from_url(comment.url).deleted_at)
-      {:ok, delete, _} = ActivityPub.delete(comment, comment.actor)
+      {:ok, delete, _} = Actions.Delete.delete(comment, comment.actor)
 
       assert delete.data["type"] == "Delete"
       assert delete.data["actor"] == comment.actor.url
@@ -169,7 +169,7 @@ defmodule Mobilizon.Federation.ActivityPubTest do
       actor = insert(:actor)
       actor_data = %{summary: @updated_actor_summary}
 
-      {:ok, update, _} = ActivityPub.update(actor, actor_data, false)
+      {:ok, update, _} = Actions.Update.update(actor, actor_data, false)
 
       assert update.data["actor"] == actor.url
       assert update.data["to"] == [@activity_pub_public_audience]
@@ -185,7 +185,7 @@ defmodule Mobilizon.Federation.ActivityPubTest do
       event = insert(:event, organizer_actor: actor)
       event_data = %{begins_on: @updated_start_time}
 
-      {:ok, update, _} = ActivityPub.update(event, event_data)
+      {:ok, update, _} = Actions.Update.update(event, event_data)
 
       assert update.data["actor"] == actor.url
       assert update.data["to"] == [@activity_pub_public_audience]
@@ -200,7 +200,7 @@ defmodule Mobilizon.Federation.ActivityPubTest do
       group = insert(:group)
       member = insert(:member, parent: group)
       moderator = insert(:actor)
-      {:ok, activity, _member} = ActivityPub.remove(member, group, moderator, true)
+      {:ok, activity, _member} = Actions.Remove.remove(member, group, moderator, true)
       assert activity.data["type"] == "Remove"
       assert activity.data["actor"] == moderator.url
       assert activity.data["to"] == [group.members_url]
@@ -217,9 +217,14 @@ defmodule Mobilizon.Federation.ActivityPubTest do
         group = insert(:group)
 
         {:ok, create_data, %TodoList{url: todo_list_url}} =
-          ActivityPub.create(:todo_list, %{title: @todo_list_title, actor_id: group.id}, true, %{
-            "actor" => actor.url
-          })
+          Actions.Create.create(
+            :todo_list,
+            %{title: @todo_list_title, actor_id: group.id},
+            true,
+            %{
+              "actor" => actor.url
+            }
+          )
 
         assert create_data.local
         assert create_data.data["object"]["id"] == todo_list_url
@@ -242,7 +247,7 @@ defmodule Mobilizon.Federation.ActivityPubTest do
         todo_list = insert(:todo_list)
 
         {:ok, create_data, %Todo{url: todo_url}} =
-          ActivityPub.create(
+          Actions.Create.create(
             :todo,
             %{title: @todo_title, todo_list_id: todo_list.id, creator_id: actor.id},
             true,
@@ -272,7 +277,7 @@ defmodule Mobilizon.Federation.ActivityPubTest do
         group = insert(:group)
 
         {:ok, create_data, %Resource{url: url}} =
-          ActivityPub.create(
+          Actions.Create.create(
             :resource,
             %{
               title: @resource_title,
@@ -307,7 +312,7 @@ defmodule Mobilizon.Federation.ActivityPubTest do
         group = insert(:group)
 
         {:ok, create_data, %Resource{url: url}} =
-          ActivityPub.create(
+          Actions.Create.create(
             :resource,
             %{
               title: @folder_title,
@@ -341,7 +346,7 @@ defmodule Mobilizon.Federation.ActivityPubTest do
           insert(:resource, type: :folder, resource_url: nil, actor: group)
 
         {:ok, create_data, %Resource{url: url}} =
-          ActivityPub.create(
+          Actions.Create.create(
             :resource,
             %{
               title: @resource_title,
@@ -388,7 +393,7 @@ defmodule Mobilizon.Federation.ActivityPubTest do
           )
 
         {:ok, update_data, %Resource{url: url}} =
-          ActivityPub.update(
+          Actions.Update.update(
             resource,
             %{
               title: @updated_resource_title
@@ -430,7 +435,7 @@ defmodule Mobilizon.Federation.ActivityPubTest do
           insert(:resource, type: :folder, resource_url: nil, actor: group)
 
         {:ok, update_data, %Resource{url: url}} =
-          ActivityPub.move(
+          Actions.Move.move(
             :resource,
             resource,
             %{
@@ -473,7 +478,7 @@ defmodule Mobilizon.Federation.ActivityPubTest do
           )
 
         {:ok, update_data, %Resource{url: url}} =
-          ActivityPub.delete(
+          Actions.Delete.delete(
             resource,
             actor,
             true
diff --git a/test/federation/activity_pub/audience_test.exs b/test/federation/activity_pub/audience_test.exs
index 4549698c9..331a0bb66 100644
--- a/test/federation/activity_pub/audience_test.exs
+++ b/test/federation/activity_pub/audience_test.exs
@@ -249,11 +249,11 @@ defmodule Mobilizon.Federation.ActivityPub.AudienceTest do
     end
 
     test "reply to a remote comment" do
-      %Actor{id: remote_actor_id, url: remote_actor_url} =
+      %Actor{} =
         remote_actor =
         insert(:actor, domain: "somewhere.else", url: "https://somewhere.else/@someone")
 
-      %Actor{id: remote_group_id, url: remote_group_url} =
+      %Actor{} =
         remote_group =
         insert(:group, domain: "somewhere.else", url: "https://somewhere.else/@somegroup")
 
diff --git a/test/federation/activity_pub/transmogrifier/delete_test.exs b/test/federation/activity_pub/transmogrifier/delete_test.exs
index cefd4d64f..e6847646e 100644
--- a/test/federation/activity_pub/transmogrifier/delete_test.exs
+++ b/test/federation/activity_pub/transmogrifier/delete_test.exs
@@ -88,10 +88,10 @@ defmodule Mobilizon.Federation.ActivityPub.Transmogrifier.DeleteTest do
       %Actor{url: url} =
         actor = insert(:actor, url: "https://framapiaf.org/users/admin", domain: "framapiaf.org")
 
-      %Event{url: event1_url} = event1 = insert(:event, organizer_actor: actor)
+      %Event{} = event1 = insert(:event, organizer_actor: actor)
       insert(:event, organizer_actor: actor)
 
-      %Comment{url: comment1_url} = comment1 = insert(:comment, actor: actor)
+      %Comment{} = comment1 = insert(:comment, actor: actor)
       insert(:comment, actor: actor)
 
       data =
diff --git a/test/federation/activity_pub/transmogrifier/follow_test.exs b/test/federation/activity_pub/transmogrifier/follow_test.exs
index 10a2666cd..6d7f75452 100644
--- a/test/federation/activity_pub/transmogrifier/follow_test.exs
+++ b/test/federation/activity_pub/transmogrifier/follow_test.exs
@@ -6,7 +6,7 @@ defmodule Mobilizon.Federation.ActivityPub.Transmogrifier.FollowTest do
   alias Mobilizon.Actors
   alias Mobilizon.Actors.Follower
   alias Mobilizon.Federation.ActivityPub
-  alias Mobilizon.Federation.ActivityPub.{Activity, Transmogrifier}
+  alias Mobilizon.Federation.ActivityPub.{Actions, Activity, Transmogrifier}
 
   describe "handle incoming follow requests" do
     test "it works only for groups" do
@@ -80,7 +80,7 @@ defmodule Mobilizon.Federation.ActivityPub.Transmogrifier.FollowTest do
 
       refute Actors.is_following(follower, followed)
 
-      {:ok, follow_activity, _} = ActivityPub.follow(follower, followed)
+      {:ok, follow_activity, _} = Actions.Follow.follow(follower, followed)
       assert Actors.is_following(follower, followed)
 
       follow_object_id = follow_activity.data["id"]
@@ -112,7 +112,7 @@ defmodule Mobilizon.Federation.ActivityPub.Transmogrifier.FollowTest do
 
       refute Actors.is_following(follower, followed)
 
-      {:ok, follow_activity, _} = ActivityPub.follow(follower, followed)
+      {:ok, follow_activity, _} = Actions.Follow.follow(follower, followed)
       assert Actors.is_following(follower, followed)
 
       follow_object_id = follow_activity.data["id"]
@@ -145,7 +145,7 @@ defmodule Mobilizon.Federation.ActivityPub.Transmogrifier.FollowTest do
       follower = insert(:actor)
       followed = insert(:group, manually_approves_followers: true)
 
-      {:ok, follow_activity, _} = ActivityPub.follow(follower, followed)
+      {:ok, follow_activity, _} = Actions.Follow.follow(follower, followed)
 
       accept_data =
         File.read!("test/fixtures/mastodon-accept-activity.json")
@@ -207,7 +207,7 @@ defmodule Mobilizon.Federation.ActivityPub.Transmogrifier.FollowTest do
       follower = insert(:actor)
       followed = insert(:group)
 
-      {:ok, follow_activity, _} = ActivityPub.follow(follower, followed)
+      {:ok, follow_activity, _} = Actions.Follow.follow(follower, followed)
 
       assert Actors.is_following(follower, followed)
 
diff --git a/test/federation/activity_pub/transmogrifier/invite_test.exs b/test/federation/activity_pub/transmogrifier/invite_test.exs
index 9f64a5351..869538454 100644
--- a/test/federation/activity_pub/transmogrifier/invite_test.exs
+++ b/test/federation/activity_pub/transmogrifier/invite_test.exs
@@ -24,7 +24,7 @@ defmodule Mobilizon.Federation.ActivityPub.Transmogrifier.InviteTest do
         |> Map.put("object", group_url)
         |> Map.put("target", invitee_url)
 
-      assert {:ok, activity, %Member{}} = Transmogrifier.handle_incoming(invite_data)
+      assert {:ok, _activity, %Member{}} = Transmogrifier.handle_incoming(invite_data)
       assert %Member{} = member = Actors.get_member_by_url(invite_data["id"])
       assert member.actor.id == invitee_id
       assert member.parent.id == group_id
@@ -49,7 +49,7 @@ defmodule Mobilizon.Federation.ActivityPub.Transmogrifier.InviteTest do
         |> Map.put("object", group_url)
         |> Map.put("target", invitee_url)
 
-      assert {:ok, activity, %Member{}} = Transmogrifier.handle_incoming(invite_data)
+      assert {:ok, _activity, %Member{}} = Transmogrifier.handle_incoming(invite_data)
       assert %Member{} = member = Actors.get_member_by_url(invite_data["id"])
       assert member.actor.id == invitee_id
       assert member.parent.id == group_id
diff --git a/test/federation/activity_pub/transmogrifier/join_test.exs b/test/federation/activity_pub/transmogrifier/join_test.exs
index 3948bf40e..a65ce7c1d 100644
--- a/test/federation/activity_pub/transmogrifier/join_test.exs
+++ b/test/federation/activity_pub/transmogrifier/join_test.exs
@@ -7,7 +7,7 @@ defmodule Mobilizon.Federation.ActivityPub.Transmogrifier.JoinTest do
   alias Mobilizon.Events
   alias Mobilizon.Events.{Event, Participant}
   alias Mobilizon.Federation.ActivityPub
-  alias Mobilizon.Federation.ActivityPub.Transmogrifier
+  alias Mobilizon.Federation.ActivityPub.{Actions, Transmogrifier}
 
   describe "handle incoming join activities" do
     @join_message "I want to get in!"
@@ -48,7 +48,9 @@ defmodule Mobilizon.Federation.ActivityPub.Transmogrifier.JoinTest do
       %Event{} = event = insert(:event, organizer_actor: organizer, join_options: :restricted)
 
       {:ok, join_activity, participation} =
-        ActivityPub.join(event, participant_actor, false, %{metadata: %{role: :not_approved}})
+        Actions.Join.join(event, participant_actor, false, %{
+          metadata: %{role: :not_approved}
+        })
 
       accept_data =
         File.read!("test/fixtures/mastodon-accept-activity.json")
@@ -113,7 +115,7 @@ defmodule Mobilizon.Federation.ActivityPub.Transmogrifier.JoinTest do
 
       %Event{} = event = insert(:event, organizer_actor: organizer, join_options: :restricted)
 
-      {:ok, join_activity, participation} = ActivityPub.join(event, participant_actor)
+      {:ok, join_activity, participation} = Actions.Join.join(event, participant_actor)
 
       reject_data =
         File.read!("test/fixtures/mastodon-reject-activity.json")
diff --git a/test/federation/activity_pub/transmogrifier/leave_test.exs b/test/federation/activity_pub/transmogrifier/leave_test.exs
index c72f54715..484526531 100644
--- a/test/federation/activity_pub/transmogrifier/leave_test.exs
+++ b/test/federation/activity_pub/transmogrifier/leave_test.exs
@@ -5,8 +5,7 @@ defmodule Mobilizon.Federation.ActivityPub.Transmogrifier.LeaveTest do
   alias Mobilizon.Actors.Actor
   alias Mobilizon.Events
   alias Mobilizon.Events.{Event, Participant}
-  alias Mobilizon.Federation.ActivityPub
-  alias Mobilizon.Federation.ActivityPub.Transmogrifier
+  alias Mobilizon.Federation.ActivityPub.{Actions, Transmogrifier}
 
   describe "handle incoming leave activities on events" do
     test "it accepts Leave activities" do
@@ -19,7 +18,7 @@ defmodule Mobilizon.Federation.ActivityPub.Transmogrifier.LeaveTest do
       organizer_participation =
         %Participant{} = insert(:participant, event: event, actor: organizer, role: :creator)
 
-      {:ok, _join_activity, _participation} = ActivityPub.join(event, participant_actor)
+      {:ok, _join_activity, _participation} = Actions.Join.join(event, participant_actor)
 
       join_data =
         File.read!("test/fixtures/mobilizon-leave-activity.json")
diff --git a/test/federation/activity_pub/transmogrifier/update_test.exs b/test/federation/activity_pub/transmogrifier/update_test.exs
index 7936887ce..b67f10631 100644
--- a/test/federation/activity_pub/transmogrifier/update_test.exs
+++ b/test/federation/activity_pub/transmogrifier/update_test.exs
@@ -120,7 +120,7 @@ defmodule Mobilizon.Federation.ActivityPub.Transmogrifier.UpdateTest do
         )
 
       group = insert(:group)
-      %Member{} = member = insert(:member, actor: remote_actor, parent: group, role: :moderator)
+      %Member{} = _member = insert(:member, actor: remote_actor, parent: group, role: :moderator)
       %Post{} = post = insert(:post, attributed_to: group)
 
       data = Convertible.model_to_as(post)
@@ -157,7 +157,7 @@ defmodule Mobilizon.Federation.ActivityPub.Transmogrifier.UpdateTest do
         )
 
       group = insert(:group)
-      %Member{} = member = insert(:member, actor: remote_actor, parent: group)
+      %Member{} = _member = insert(:member, actor: remote_actor, parent: group)
       %Post{} = post = insert(:post, attributed_to: group)
 
       data = Convertible.model_to_as(post)
diff --git a/test/federation/activity_pub/transmogrifier_test.exs b/test/federation/activity_pub/transmogrifier_test.exs
index d344b5633..841b54f97 100644
--- a/test/federation/activity_pub/transmogrifier_test.exs
+++ b/test/federation/activity_pub/transmogrifier_test.exs
@@ -173,7 +173,7 @@ defmodule Mobilizon.Federation.ActivityPub.TransmogrifierTest do
         get_or_fetch_actor_by_url: fn url ->
           case url do
             @mobilizon_group_url -> {:ok, group}
-            actor_url -> {:ok, actor}
+            ^actor_url -> {:ok, actor}
           end
         end do
         activity = %{
@@ -202,7 +202,7 @@ defmodule Mobilizon.Federation.ActivityPub.TransmogrifierTest do
       with_mock ActivityPubActor, [:passthrough],
         get_or_fetch_actor_by_url: fn url ->
           case url do
-            @mobilizon_group_url -> {:error, "Not found"}
+            @mobilizon_group_url -> {:error, :http_not_found}
             ^actor_url -> {:ok, actor}
           end
         end do
@@ -279,7 +279,7 @@ defmodule Mobilizon.Federation.ActivityPub.TransmogrifierTest do
         get_or_fetch_actor_by_url: fn url ->
           case url do
             @mobilizon_group_url -> {:ok, group}
-            actor_url -> {:ok, actor}
+            ^actor_url -> {:ok, actor}
           end
         end do
         activity = %{
@@ -308,7 +308,7 @@ defmodule Mobilizon.Federation.ActivityPub.TransmogrifierTest do
       with_mock ActivityPubActor, [:passthrough],
         get_or_fetch_actor_by_url: fn url ->
           case url do
-            @mobilizon_group_url -> {:error, "Not found"}
+            @mobilizon_group_url -> {:error, :http_not_found}
             ^actor_url -> {:ok, actor}
           end
         end do
@@ -379,7 +379,7 @@ defmodule Mobilizon.Federation.ActivityPub.TransmogrifierTest do
         }
       }
 
-      assert {:ok, %Activity{data: data, local: false}, %Resource{} = resource} =
+      assert {:ok, %Activity{data: _data, local: false}, %Resource{} = resource} =
                Transmogrifier.handle_incoming(activity)
 
       assert resource.actor_id == group.id
@@ -420,7 +420,7 @@ defmodule Mobilizon.Federation.ActivityPub.TransmogrifierTest do
         }
       }
 
-      assert {:ok, %Activity{data: data, local: false}, %Resource{} = resource} =
+      assert {:ok, %Activity{data: _data, local: false}, %Resource{} = resource} =
                Transmogrifier.handle_incoming(activity)
 
       assert resource.actor_id == group.id
@@ -475,7 +475,7 @@ defmodule Mobilizon.Federation.ActivityPub.TransmogrifierTest do
         }
       }
 
-      assert {:ok, %Activity{data: data, local: false}, %Resource{} = resource} =
+      assert {:ok, %Activity{data: _data, local: false}, %Resource{} = resource} =
                Transmogrifier.handle_incoming(activity)
 
       assert resource.actor_id == group.id
@@ -643,7 +643,7 @@ defmodule Mobilizon.Federation.ActivityPub.TransmogrifierTest do
 
       Mock
       |> expect(:call, fn
-        %{method: :get, url: actor_url}, _opts ->
+        %{method: :get, url: ^actor_url}, _opts ->
           {:ok, %Tesla.Env{status: 200, body: actor_data}}
       end)
 
diff --git a/test/federation/activity_pub/types/events_test.exs b/test/federation/activity_pub/types/events_test.exs
index 2da5def62..dad623337 100644
--- a/test/federation/activity_pub/types/events_test.exs
+++ b/test/federation/activity_pub/types/events_test.exs
@@ -406,7 +406,7 @@ defmodule Mobilizon.Federation.ActivityPub.Types.EventsTest do
       %Actor{url: organizer_group_url, members_url: members_url, followers_url: followers_url} =
         organizer_group = insert(:group, domain: nil)
 
-      %Actor{url: organizer_actor_url} =
+      %Actor{url: _organizer_actor_url} =
         organizer_actor =
         insert(:actor, domain: "somewhere.else", url: "https://somewhere.else/@someone")
 
diff --git a/test/graphql/api/report_test.exs b/test/graphql/api/report_test.exs
index fbf4e377b..ea5369f0b 100644
--- a/test/graphql/api/report_test.exs
+++ b/test/graphql/api/report_test.exs
@@ -126,7 +126,7 @@ defmodule Mobilizon.GraphQL.API.ReportTest do
 
       %Comment{id: comment_1_id} = _comment_1 = insert(:comment, actor: reported)
 
-      assert {:ok, %Activity{} = flag_activity, %Report{id: report_id} = _report} =
+      assert {:ok, %Activity{}, %Report{id: report_id} = _report} =
                Reports.report(%{
                  reporter_id: reporter_id,
                  reported_id: reported_id,
@@ -152,7 +152,7 @@ defmodule Mobilizon.GraphQL.API.ReportTest do
 
       %Comment{id: comment_1_id} = _comment_1 = insert(:comment, actor: reported)
 
-      assert {:ok, %Activity{} = flag_activity, %Report{id: report_id} = _report} =
+      assert {:ok, %Activity{}, %Report{id: report_id} = _report} =
                Reports.report(%{
                  reporter_id: reporter_id,
                  reported_id: reported_id,
diff --git a/test/graphql/resolvers/comment_test.exs b/test/graphql/resolvers/comment_test.exs
index 4ded1f48e..9a26d766c 100644
--- a/test/graphql/resolvers/comment_test.exs
+++ b/test/graphql/resolvers/comment_test.exs
@@ -34,7 +34,6 @@ defmodule Mobilizon.GraphQL.Resolvers.CommentTest do
 
     test "create_comment/3 creates a comment", %{
       conn: conn,
-      actor: actor,
       user: user,
       event: event
     } do
@@ -51,7 +50,6 @@ defmodule Mobilizon.GraphQL.Resolvers.CommentTest do
 
     test "create_comment/3 doesn't allow creating events if it's disabled", %{
       conn: conn,
-      actor: actor,
       user: user,
       event: event
     } do
@@ -93,8 +91,6 @@ defmodule Mobilizon.GraphQL.Resolvers.CommentTest do
       conn: conn,
       event: event
     } do
-      actor = insert(:actor)
-
       res =
         conn
         |> AbsintheHelpers.graphql_query(
@@ -108,7 +104,6 @@ defmodule Mobilizon.GraphQL.Resolvers.CommentTest do
 
     test "create_comment/3 creates a reply to a comment", %{
       conn: conn,
-      actor: actor,
       user: user,
       event: event
     } do
@@ -175,7 +170,7 @@ defmodule Mobilizon.GraphQL.Resolvers.CommentTest do
 
       # Change the current actor for user
       actor2 = insert(:actor, user: user)
-      Mobilizon.Users.update_user_default_actor(user.id, actor2.id)
+      Mobilizon.Users.update_user_default_actor(user.id, actor2)
 
       res =
         conn
@@ -188,7 +183,7 @@ defmodule Mobilizon.GraphQL.Resolvers.CommentTest do
       assert hd(res["errors"])["message"] ==
                "You cannot delete this comment"
 
-      Mobilizon.Users.update_user_default_actor(user.id, actor.id)
+      Mobilizon.Users.update_user_default_actor(user.id, actor)
 
       res =
         conn
diff --git a/test/graphql/resolvers/discussion_test.exs b/test/graphql/resolvers/discussion_test.exs
index e0adc56ec..5b5b2cece 100644
--- a/test/graphql/resolvers/discussion_test.exs
+++ b/test/graphql/resolvers/discussion_test.exs
@@ -448,7 +448,7 @@ defmodule Mobilizon.GraphQL.Resolvers.DiscussionTest do
 
     #   # Change the current actor for user
     #   actor2 = insert(:actor, user: user)
-    #   Mobilizon.Users.update_user_default_actor(user.id, actor2.id)
+    #   Mobilizon.Users.update_user_default_actor(user.id, actor2)
 
     #   res =
     #     conn
@@ -461,7 +461,7 @@ defmodule Mobilizon.GraphQL.Resolvers.DiscussionTest do
     #   assert hd(res["errors"])["message"] ==
     #            "You cannot delete this comment"
 
-    #   Mobilizon.Users.update_user_default_actor(user.id, actor.id)
+    #   Mobilizon.Users.update_user_default_actor(user.id, actor)
 
     #   res =
     #     conn
diff --git a/test/graphql/resolvers/event_test.exs b/test/graphql/resolvers/event_test.exs
index 1d8423c62..b426ea8ea 100644
--- a/test/graphql/resolvers/event_test.exs
+++ b/test/graphql/resolvers/event_test.exs
@@ -1225,7 +1225,7 @@ defmodule Mobilizon.Web.Resolvers.EventTest do
       %Actor{} = administrator_actor = insert(:actor, user: user)
       insert(:member, parent: group, actor: administrator_actor, role: :administrator)
 
-      %Actor{id: not_member_actor_id} = insert(:actor, user: user)
+      %Actor{id: not_member_actor_id} = not_member_actor = insert(:actor, user: user)
 
       %Event{} =
         event = insert(:event, attributed_to: group, organizer_actor: administrator_actor)
@@ -1235,7 +1235,7 @@ defmodule Mobilizon.Web.Resolvers.EventTest do
         |> Map.put(:attributed_to_id, "#{group_id}")
         |> Map.put(:eventId, to_string(event.id))
 
-      Users.update_user_default_actor(user.id, member_not_approved_actor_id)
+      Users.update_user_default_actor(user.id, member_not_approved_actor)
 
       res =
         conn
@@ -1250,7 +1250,7 @@ defmodule Mobilizon.Web.Resolvers.EventTest do
       assert hd(res["errors"])["message"] ==
                "This profile doesn't have permission to update an event on behalf of this group"
 
-      Users.update_user_default_actor(user.id, not_member_actor_id)
+      Users.update_user_default_actor(user.id, not_member_actor)
 
       res =
         conn
@@ -1265,7 +1265,7 @@ defmodule Mobilizon.Web.Resolvers.EventTest do
       assert hd(res["errors"])["message"] ==
                "This profile doesn't have permission to update an event on behalf of this group"
 
-      Users.update_user_default_actor(user.id, member_actor_id)
+      Users.update_user_default_actor(user.id, member_actor)
 
       res =
         conn
@@ -1280,7 +1280,7 @@ defmodule Mobilizon.Web.Resolvers.EventTest do
       assert hd(res["errors"])["message"] ==
                "This profile doesn't have permission to update an event on behalf of this group"
 
-      Users.update_user_default_actor(user.id, moderator_actor_id)
+      Users.update_user_default_actor(user.id, moderator_actor)
 
       res =
         conn
diff --git a/test/graphql/resolvers/group_test.exs b/test/graphql/resolvers/group_test.exs
index e99d7bef8..f8fc10894 100644
--- a/test/graphql/resolvers/group_test.exs
+++ b/test/graphql/resolvers/group_test.exs
@@ -57,7 +57,7 @@ defmodule Mobilizon.Web.Resolvers.GroupTest do
         |> post("/api", AbsintheHelpers.mutation_skeleton(mutation))
 
       assert hd(json_response(res, 200)["errors"])["message"] ==
-               "A group with this name already exists"
+               "A profile or group with that name already exists"
     end
   end
 
diff --git a/test/graphql/resolvers/media_test.exs b/test/graphql/resolvers/media_test.exs
index 36fbc0ec9..9b5fa1d56 100644
--- a/test/graphql/resolvers/media_test.exs
+++ b/test/graphql/resolvers/media_test.exs
@@ -150,7 +150,7 @@ defmodule Mobilizon.GraphQL.Resolvers.MediaTest do
           variables: %{id: media_id}
         )
 
-      assert is_nil(res["errors"])
+      assert res["errors"] == nil
       assert res["data"]["removeMedia"]["id"] == to_string(media_id)
 
       res =
diff --git a/test/graphql/resolvers/member_test.exs b/test/graphql/resolvers/member_test.exs
index 3ea20452a..db2a42f08 100644
--- a/test/graphql/resolvers/member_test.exs
+++ b/test/graphql/resolvers/member_test.exs
@@ -423,7 +423,7 @@ defmodule Mobilizon.GraphQL.Resolvers.MemberTest do
     } do
       user = insert(:user)
       actor = insert(:actor, user: user)
-      Mobilizon.Users.update_user_default_actor(user.id, actor.id)
+      Mobilizon.Users.update_user_default_actor(user.id, actor)
 
       %Member{id: member_id} =
         insert(:member, %{actor: target_actor, parent: group, role: :member})
@@ -449,7 +449,7 @@ defmodule Mobilizon.GraphQL.Resolvers.MemberTest do
       group: group,
       target_actor: target_actor
     } do
-      Mobilizon.Users.update_user_default_actor(user.id, actor.id)
+      Mobilizon.Users.update_user_default_actor(user.id, actor)
       insert(:member, actor: actor, parent: group, role: :administrator)
 
       %Member{id: member_id} =
@@ -504,7 +504,7 @@ defmodule Mobilizon.GraphQL.Resolvers.MemberTest do
       actor: actor,
       group: group
     } do
-      Mobilizon.Users.update_user_default_actor(user.id, actor.id)
+      Mobilizon.Users.update_user_default_actor(user.id, actor)
       %Member{id: member_id} = insert(:member, actor: actor, parent: group, role: :administrator)
 
       res =
diff --git a/test/graphql/resolvers/resource_test.exs b/test/graphql/resolvers/resource_test.exs
index 65dc4b734..b561f87bb 100644
--- a/test/graphql/resolvers/resource_test.exs
+++ b/test/graphql/resolvers/resource_test.exs
@@ -598,7 +598,7 @@ defmodule Mobilizon.GraphQL.Resolvers.ResourceTest do
           }
         )
 
-      assert is_nil(res["errors"])
+      assert res["errors"] == nil
 
       assert res["data"]["updateResource"]["path"] ==
                "#{root_folder.path}/#{@updated_resource_title}"
diff --git a/test/graphql/resolvers/tag_test.exs b/test/graphql/resolvers/tag_test.exs
index 271ecbd4c..b8f78970d 100644
--- a/test/graphql/resolvers/tag_test.exs
+++ b/test/graphql/resolvers/tag_test.exs
@@ -6,33 +6,33 @@ defmodule Mobilizon.GraphQL.Resolvers.TagTest do
   alias Mobilizon.GraphQL.AbsintheHelpers
 
   describe "Tag Resolver" do
-    test "list_tags/3 returns the list of tags", context do
+    @tags_query """
+    query Tags($filter: String) {
+      tags(filter: $filter) {
+        id
+        related {
+          id
+          slug
+          title
+        }
+        slug
+        title
+      }
+    }
+    """
+
+    test "list_tags/3 returns the list of tags", %{conn: conn} do
       tag1 = insert(:tag)
       tag2 = insert(:tag)
       tag3 = insert(:tag)
       insert(:tag_relation, tag: tag1, link: tag2)
       insert(:tag_relation, tag: tag3, link: tag1)
 
-      query = """
-      {
-        tags {
-          id,
-          slug,
-          title,
-          related {
-            id,
-            title,
-            slug
-          }
-        }
-      }
-      """
-
       res =
-        context.conn
-        |> get("/api", AbsintheHelpers.query_skeleton(query, "tags"))
+        conn
+        |> AbsintheHelpers.graphql_query(query: @tags_query)
 
-      tags = json_response(res, 200)["data"]["tags"]
+      tags = res["data"]["tags"]
       assert tags |> length == 3
 
       assert tags
@@ -45,5 +45,19 @@ defmodule Mobilizon.GraphQL.Resolvers.TagTest do
                |> Enum.map(fn tag -> tag.slug end)
                |> MapSet.new()
     end
+
+    test "list_tags/3 returns tags for a filter", %{conn: conn} do
+      tag1 = insert(:tag, title: "PineApple", slug: "pineapple")
+      tag2 = insert(:tag, title: "sexy pineapple", slug: "sexy-pineapple")
+      _tag3 = insert(:tag)
+
+      res =
+        conn
+        |> AbsintheHelpers.graphql_query(query: @tags_query, variables: %{filter: "apple"})
+
+      tags = res["data"]["tags"]
+      assert tags |> length == 2
+      assert [tag1.id, tag2.id] == tags |> Enum.map(&String.to_integer(&1["id"]))
+    end
   end
 end
diff --git a/test/graphql/resolvers/user_test.exs b/test/graphql/resolvers/user_test.exs
index c418dbeb1..906cfa03e 100644
--- a/test/graphql/resolvers/user_test.exs
+++ b/test/graphql/resolvers/user_test.exs
@@ -873,6 +873,7 @@ defmodule Mobilizon.GraphQL.Resolvers.UserTest do
 
     test "test refresh_token/3 with an appropriate token", context do
       user = insert(:user)
+      insert(:actor, user: user)
       {:ok, refresh_token} = Authenticator.generate_refresh_token(user)
 
       mutation = """
diff --git a/test/mobilizon/actors/actors_test.exs b/test/mobilizon/actors/actors_test.exs
index 94abd067e..e5bf81f7e 100644
--- a/test/mobilizon/actors/actors_test.exs
+++ b/test/mobilizon/actors/actors_test.exs
@@ -5,7 +5,7 @@ defmodule Mobilizon.ActorsTest do
 
   import Mobilizon.Factory
 
-  alias Mobilizon.{Actors, Config, Discussions, Events, Tombstone, Users}
+  alias Mobilizon.{Actors, Config, Discussions, Events, Users}
   alias Mobilizon.Actors.{Actor, Bot, Follower, Member}
   alias Mobilizon.Discussions.Comment
   alias Mobilizon.Events.Event
@@ -292,66 +292,16 @@ defmodule Mobilizon.ActorsTest do
     test "update_actor/2 with invalid data returns error changeset", %{actor: actor} do
       assert {:error, %Ecto.Changeset{}} = Actors.update_actor(actor, @invalid_attrs)
       actor_fetched = Actors.get_actor!(actor.id)
-      assert actor = actor_fetched
-    end
-
-    test "perform delete the actor actually deletes the actor", %{
-      actor: %Actor{avatar: %{url: avatar_url}, banner: %{url: banner_url}, id: actor_id} = actor
-    } do
-      %Event{url: event1_url} = event1 = insert(:event, organizer_actor: actor)
-      insert(:event, organizer_actor: actor)
-
-      %Comment{url: comment1_url} = comment1 = insert(:comment, actor: actor)
-      insert(:comment, actor: actor)
-
-      %URI{path: "/media/" <> avatar_path} = URI.parse(avatar_url)
-      %URI{path: "/media/" <> banner_path} = URI.parse(banner_url)
-
-      assert File.exists?(
-               Config.get!([Uploader.Local, :uploads]) <>
-                 "/" <> avatar_path
-             )
-
-      assert File.exists?(
-               Config.get!([Uploader.Local, :uploads]) <>
-                 "/" <> banner_path
-             )
-
-      assert {:ok, %Actor{}} = Actors.perform(:delete_actor, actor)
-
-      assert %Actor{
-               name: nil,
-               summary: nil,
-               suspended: true,
-               avatar: nil,
-               banner: nil,
-               user_id: nil
-             } = Actors.get_actor(actor_id)
-
-      assert {:error, :event_not_found} = Events.get_event(event1.id)
-      assert %Tombstone{} = Tombstone.find_tombstone(event1_url)
-      assert %Comment{deleted_at: deleted_at} = Discussions.get_comment(comment1.id)
-      refute is_nil(deleted_at)
-      assert %Tombstone{} = Tombstone.find_tombstone(comment1_url)
-
-      refute File.exists?(
-               Config.get!([Uploader.Local, :uploads]) <>
-                 "/" <> avatar_path
-             )
-
-      refute File.exists?(
-               Config.get!([Uploader.Local, :uploads]) <>
-                 "/" <> banner_path
-             )
+      assert actor.id == actor_fetched.id
     end
 
     test "delete_actor/1 deletes the actor", %{
       actor: %Actor{avatar: %{url: avatar_url}, banner: %{url: banner_url}, id: actor_id} = actor
     } do
-      %Event{url: event1_url} = event1 = insert(:event, organizer_actor: actor)
+      %Event{} = event1 = insert(:event, organizer_actor: actor)
       insert(:event, organizer_actor: actor)
 
-      %Comment{url: comment1_url} = comment1 = insert(:comment, actor: actor)
+      %Comment{} = comment1 = insert(:comment, actor: actor)
       insert(:comment, actor: actor)
 
       %URI{path: "/media/" <> avatar_path} = URI.parse(avatar_url)
@@ -392,10 +342,8 @@ defmodule Mobilizon.ActorsTest do
              } = Actors.get_actor(actor_id)
 
       assert {:error, :event_not_found} = Events.get_event(event1.id)
-      assert %Tombstone{} = Tombstone.find_tombstone(event1_url)
       assert %Comment{deleted_at: deleted_at} = Discussions.get_comment(comment1.id)
       refute is_nil(deleted_at)
-      assert %Tombstone{} = Tombstone.find_tombstone(comment1_url)
 
       refute File.exists?(
                Config.get!([Uploader.Local, :uploads]) <>
@@ -438,25 +386,25 @@ defmodule Mobilizon.ActorsTest do
     test "create_group/1 with an existing profile username fails" do
       _actor = insert(:actor, preferred_username: @valid_attrs.preferred_username)
 
-      assert {:error, :insert_group,
+      assert {:error,
               %Ecto.Changeset{
                 errors: [preferred_username: {"This username is already taken.", []}]
-              }, %{}} = Actors.create_group(@valid_attrs)
+              }} = Actors.create_group(@valid_attrs)
     end
 
     test "create_group/1 with an existing group username fails" do
       %Actor{id: actor_id} = insert(:actor)
       attrs = Map.put(@valid_attrs, :creator_actor_id, actor_id)
-      assert {:ok, %Actor{} = group} = Actors.create_group(attrs)
+      assert {:ok, %Actor{}} = Actors.create_group(attrs)
 
-      assert {:error, :insert_group,
+      assert {:error,
               %Ecto.Changeset{
                 errors: [preferred_username: {"This username is already taken.", []}]
-              }, %{}} = Actors.create_group(attrs)
+              }} = Actors.create_group(attrs)
     end
 
     test "create_group/1 with invalid data returns error changeset" do
-      assert {:error, :insert_group, %Ecto.Changeset{}, %{}} = Actors.create_group(@invalid_attrs)
+      assert {:error, %Ecto.Changeset{}} = Actors.create_group(@invalid_attrs)
     end
   end
 
@@ -508,7 +456,7 @@ defmodule Mobilizon.ActorsTest do
     test "update_bot/2 with invalid data returns error changeset" do
       bot = insert(:bot)
       assert {:error, %Ecto.Changeset{}} = Actors.update_bot(bot, @invalid_attrs)
-      assert bot = Actors.get_bot!(bot.id)
+      assert bot.id == Actors.get_bot!(bot.id).id
     end
 
     test "delete_bot/1 deletes the bot" do
@@ -535,7 +483,7 @@ defmodule Mobilizon.ActorsTest do
 
     test "get_follower!/1 returns the follower with given id", context do
       follower = create_test_follower(context)
-      assert follower = Actors.get_follower!(follower.id)
+      assert follower.id == Actors.get_follower!(follower.id).id
     end
 
     test "create_follower/1 with valid data creates a follower", %{
@@ -550,8 +498,12 @@ defmodule Mobilizon.ActorsTest do
       assert {:ok, %Follower{} = follower} = Actors.create_follower(valid_attrs)
       assert follower.approved == true
 
-      assert %{total: 1, elements: [target_actor]} = Actors.build_followings_for_actor(actor)
-      assert %{total: 1, elements: [actor]} = Actors.build_followers_for_actor(target_actor)
+      assert %{total: 1, elements: followings} = Actors.build_followings_for_actor(actor)
+      followings_ids = Enum.map(followings, & &1.id)
+      assert followings_ids == [target_actor.id]
+      assert %{total: 1, elements: followers} = Actors.build_followers_for_actor(target_actor)
+      followers_ids = Enum.map(followers, & &1.id)
+      assert followers_ids == [actor.id]
     end
 
     test "create_follower/1 with valid data but same actors fails to create a follower", %{
@@ -590,7 +542,7 @@ defmodule Mobilizon.ActorsTest do
     test "update_follower/2 with invalid data returns error changeset", context do
       follower = create_test_follower(context)
       assert {:error, %Ecto.Changeset{}} = Actors.update_follower(follower, @invalid_attrs)
-      assert follower = Actors.get_follower!(follower.id)
+      assert follower.id == Actors.get_follower!(follower.id).id
     end
 
     test "delete_follower/1 deletes the follower", context do
@@ -615,13 +567,11 @@ defmodule Mobilizon.ActorsTest do
       assert actor.followings |> Enum.map(& &1.target_actor_id) == [target_actor.id]
 
       # Test if actor is already following target actor
-      assert {:error, :already_following, msg} = Actors.follow(target_actor, actor)
-      assert msg =~ "already following"
+      assert {:error, :already_following} = Actors.follow(target_actor, actor)
 
       # Test if target actor is suspended
       target_actor = %{target_actor | suspended: true}
-      assert {:error, :suspended, msg} = Actors.follow(target_actor, actor)
-      assert msg =~ "suspended"
+      assert {:error, :followed_suspended} = Actors.follow(target_actor, actor)
     end
   end
 
@@ -642,7 +592,7 @@ defmodule Mobilizon.ActorsTest do
 
     test "get_member!/1 returns the member with given id", context do
       member = create_test_member(context)
-      assert member = Actors.get_member!(member.id)
+      assert member.id == Actors.get_member!(member.id).id
     end
 
     test "create_member/1 with valid data creates a member", %{
@@ -658,7 +608,9 @@ defmodule Mobilizon.ActorsTest do
       assert member.role == :member
 
       assert [group] = Actors.list_groups_member_of(actor)
-      assert %Page{elements: [actor], total: 1} = Actors.list_members_for_group(group)
+      assert %Page{elements: members, total: 1} = Actors.list_members_for_group(group)
+      members_ids = Enum.map(members, & &1.id)
+      assert members_ids == [member.id]
     end
 
     test "create_member/1 with valid data but same actors just updates the member", %{
diff --git a/test/mobilizon/admin/action_log_test.exs b/test/mobilizon/admin/action_log_test.exs
index 200c54fc1..cc36b9b79 100644
--- a/test/mobilizon/admin/action_log_test.exs
+++ b/test/mobilizon/admin/action_log_test.exs
@@ -19,28 +19,32 @@ defmodule Mobilizon.Service.Admin.ActionLogTest do
 
   describe "action_log_creation" do
     test "log a report update", %{moderator: moderator} do
-      %Report{id: _report_id} = report = insert(:report)
+      %Report{id: report_id} = report = insert(:report)
 
       assert {:ok,
               %ActionLog{
                 target_type: "Elixir.Mobilizon.Reports.Report",
-                target_id: report_id,
+                target_id: found_report_id,
                 action: :update,
-                actor: moderator
+                actor: _moderator
               }} = Admin.log_action(moderator, "update", report)
+
+      assert found_report_id == report_id
     end
 
     test "log the creation of a report note", %{moderator: moderator} do
       %Report{} = report = insert(:report)
-      %Note{id: _note_id} = report = insert(:report_note, report: report)
+      %Note{id: note_id} = report = insert(:report_note, report: report)
 
       assert {:ok,
               %ActionLog{
                 target_type: "Elixir.Mobilizon.Reports.Note",
-                target_id: note_id,
+                target_id: found_note_id,
                 action: :create,
-                actor: moderator
+                actor: _moderator
               }} = Admin.log_action(moderator, "create", report)
+
+      assert found_note_id == note_id
     end
   end
 end
diff --git a/test/mobilizon/events/events_test.exs b/test/mobilizon/events/events_test.exs
index fbda5b00a..c9b6e9b55 100644
--- a/test/mobilizon/events/events_test.exs
+++ b/test/mobilizon/events/events_test.exs
@@ -242,6 +242,12 @@ defmodule Mobilizon.EventsTest do
       assert [tag.id] == Events.list_tags() |> Enum.map(& &1.id)
     end
 
+    test "list_tags/1 filters tags by title or slug" do
+      tag1 = insert(:tag, title: "PineApple", slug: "pineapple")
+      tag2 = insert(:tag, title: "sexy pineapple", slug: "sexy-pineapple")
+      assert [tag1.id, tag2.id] == Events.list_tags("apple") |> Enum.map(& &1.id)
+    end
+
     test "get_tag!/1 returns the tag with given id" do
       tag = insert(:tag)
       assert Events.get_tag!(tag.id).id == tag.id
@@ -418,7 +424,7 @@ defmodule Mobilizon.EventsTest do
     end
 
     test "delete_participant/1 deletes the participant", %{participant: participant} do
-      assert {:ok, %Participant{}} = Events.delete_participant(participant)
+      assert {:ok, %{participant: %Participant{}}} = Events.delete_participant(participant)
     end
   end
 
diff --git a/test/mobilizon/users/users_test.exs b/test/mobilizon/users/users_test.exs
index c49dfdf0a..0a1ba31f6 100644
--- a/test/mobilizon/users/users_test.exs
+++ b/test/mobilizon/users/users_test.exs
@@ -19,13 +19,13 @@ defmodule Mobilizon.UsersTest do
     end
 
     test "get_user!/1 returns the user with given id" do
-      user = insert(:user)
-      assert user = Users.get_user!(user.id)
+      %User{id: user_id} = user = insert(:user)
+      assert user == Users.get_user!(user_id)
     end
 
     # There's no create_user/1, just register/1
     test "register/1 with valid data creates a user" do
-      assert {:ok, %User{email: email} = user} = Users.register(@valid_attrs)
+      assert {:ok, %User{email: email}} = Users.register(@valid_attrs)
 
       assert email == @valid_attrs.email
     end
@@ -48,9 +48,9 @@ defmodule Mobilizon.UsersTest do
     end
 
     test "update_user/2 with invalid data returns error changeset" do
-      user = insert(:user)
+      %User{id: user_id} = user = insert(:user)
       assert {:error, %Ecto.Changeset{}} = Users.update_user(user, @invalid_attrs)
-      assert user = Users.get_user!(user.id)
+      assert user == Users.get_user!(user_id)
     end
 
     test "delete_user/1 empties the user" do
@@ -65,11 +65,6 @@ defmodule Mobilizon.UsersTest do
       assert_raise Ecto.NoResultsError, fn -> Users.get_user!(user.id) end
     end
 
-    # test "change_user/1 returns a user changeset" do
-    #   user = insert(:user)
-    #   assert %Ecto.Changeset{} = Users.change_user(user)
-    # end
-
     @email "email@domain.tld"
     @password "password"
 
diff --git a/test/service/actor_suspension_test.exs b/test/service/actor_suspension_test.exs
new file mode 100644
index 000000000..5932e83c2
--- /dev/null
+++ b/test/service/actor_suspension_test.exs
@@ -0,0 +1,105 @@
+defmodule Mobilizon.Service.ActorSuspensionTest do
+  use Mobilizon.DataCase
+
+  import Mobilizon.Factory
+
+  alias Mobilizon.{Actors, Config, Discussions, Events}
+  alias Mobilizon.Actors.Actor
+  alias Mobilizon.Discussions.Comment
+  alias Mobilizon.Events.{Event, Participant}
+  alias Mobilizon.Service.ActorSuspension
+  alias Mobilizon.Web.Upload.Uploader
+
+  describe "suspend a person" do
+    setup do
+      user = insert(:user)
+      %Actor{} = actor = insert(:actor, user: user)
+      insert(:actor, user: user)
+
+      %Comment{} = comment = insert(:comment, actor: actor)
+      %Event{} = event = insert(:event, organizer_actor: actor)
+      %Event{} = insert(:event)
+      insert(:participant, event: event)
+
+      %Participant{} =
+        participant = insert(:participant, actor: actor, event: event, role: :participant)
+
+      {:ok, actor: actor, comment: comment, event: event, participant: participant}
+    end
+
+    test "local", %{actor: actor, comment: comment, event: event, participant: participant} do
+      assert actor
+             |> media_paths()
+             |> media_exists?()
+
+      assert {:ok, %Actor{}} = ActorSuspension.suspend_actor(actor)
+      assert %Actor{suspended: true} = Actors.get_actor(actor.id)
+      assert %Comment{deleted_at: %DateTime{}} = Discussions.get_comment(comment.id)
+      assert {:error, :event_not_found} = Events.get_event(event.id)
+      assert nil == Events.get_participant(participant.id)
+
+      refute actor
+             |> media_paths()
+             |> media_exists?()
+    end
+  end
+
+  describe "delete a person" do
+    setup do
+      %Actor{} = actor = insert(:actor)
+
+      %Comment{} = comment = insert(:comment, actor: actor)
+      %Event{} = event = insert(:event, organizer_actor: actor)
+
+      {:ok, actor: actor, comment: comment, event: event}
+    end
+
+    test "local", %{actor: actor, comment: comment, event: event} do
+      assert actor
+             |> media_paths()
+             |> media_exists?()
+
+      assert {:ok, %Actor{}} = ActorSuspension.suspend_actor(actor, reserve_username: false)
+      assert nil == Actors.get_actor(actor.id)
+      assert %Comment{deleted_at: %DateTime{}} = Discussions.get_comment(comment.id)
+      assert {:error, :event_not_found} = Events.get_event(event.id)
+
+      refute actor
+             |> media_paths()
+             |> media_exists?()
+    end
+  end
+
+  describe "suspend a group" do
+    setup do
+      %Actor{} = group = insert(:group)
+
+      %Event{} = event = insert(:event, attributed_to: group)
+
+      {:ok, group: group, event: event}
+    end
+
+    test "local", %{group: group, event: event} do
+      assert {:ok, %Actor{}} = ActorSuspension.suspend_actor(group)
+      assert %Actor{suspended: true} = Actors.get_actor(group.id)
+      assert {:error, :event_not_found} = Events.get_event(event.id)
+    end
+  end
+
+  defp media_paths(%Actor{avatar: %{url: avatar_url}, banner: %{url: banner_url}}) do
+    %URI{path: "/media/" <> avatar_path} = URI.parse(avatar_url)
+    %URI{path: "/media/" <> banner_path} = URI.parse(banner_url)
+    %{avatar: avatar_path, banner: banner_path}
+  end
+
+  defp media_exists?(%{avatar: avatar_path, banner: banner_path}) do
+    File.exists?(
+      Config.get!([Uploader.Local, :uploads]) <>
+        "/" <> avatar_path
+    ) &&
+      File.exists?(
+        Config.get!([Uploader.Local, :uploads]) <>
+          "/" <> banner_path
+      )
+  end
+end
diff --git a/test/service/date_time/date_time_test.exs b/test/service/date_time/date_time_test.exs
index 1471386a2..9a82e829b 100644
--- a/test/service/date_time/date_time_test.exs
+++ b/test/service/date_time/date_time_test.exs
@@ -156,30 +156,30 @@ defmodule Mobilizon.Service.DateTimeTest do
 
   describe "check if we're between hours" do
     test "basic" do
-      refute DateTimeTools.is_between_hours(
+      refute DateTimeTools.is_between_hours?(
                compare_to_datetime: ~U[2021-06-22 15:00:00Z],
                compare_to_day: ~D[2021-06-22]
              )
 
-      assert DateTimeTools.is_between_hours(
+      assert DateTimeTools.is_between_hours?(
                compare_to_datetime: ~U[2021-06-22 08:00:00Z],
                compare_to_day: ~D[2021-06-22]
              )
 
-      assert DateTimeTools.is_between_hours(
+      assert DateTimeTools.is_between_hours?(
                compare_to_datetime: ~U[2021-06-22 08:01:00Z],
                compare_to_day: ~D[2021-06-22]
              )
     end
 
     test "with special timezone" do
-      refute DateTimeTools.is_between_hours(
+      refute DateTimeTools.is_between_hours?(
                compare_to_datetime: ~U[2021-06-22 08:01:00Z],
                compare_to_day: ~D[2021-06-22],
                timezone: "Asia/Brunei"
              )
 
-      assert DateTimeTools.is_between_hours(
+      assert DateTimeTools.is_between_hours?(
                compare_to_datetime: ~U[2021-06-22 00:01:00Z],
                compare_to_day: ~D[2021-06-22],
                timezone: "Asia/Brunei"
@@ -189,12 +189,12 @@ defmodule Mobilizon.Service.DateTimeTest do
 
   describe "check if we're between hours on right day" do
     test "basic" do
-      assert DateTimeTools.is_between_hours_on_first_day(
+      assert DateTimeTools.is_between_hours_on_first_day?(
                compare_to_datetime: ~U[2021-06-20 08:00:00Z],
                compare_to_day: ~D[2021-06-20]
              )
 
-      assert DateTimeTools.is_between_hours_on_first_day(
+      assert DateTimeTools.is_between_hours_on_first_day?(
                compare_to_datetime: ~U[2021-06-21 08:00:00Z],
                compare_to_day: ~D[2021-06-21],
                locale: "fr"
@@ -202,14 +202,14 @@ defmodule Mobilizon.Service.DateTimeTest do
     end
 
     test "with special timezone" do
-      refute DateTimeTools.is_between_hours_on_first_day(
+      refute DateTimeTools.is_between_hours_on_first_day?(
                compare_to_datetime: ~U[2021-06-21 08:00:00Z],
                compare_to_day: ~D[2021-06-21],
                locale: "fr",
                timezone: "Asia/Srednekolymsk"
              )
 
-      assert DateTimeTools.is_between_hours_on_first_day(
+      assert DateTimeTools.is_between_hours_on_first_day?(
                compare_to_datetime: ~U[2021-06-20 21:00:00Z],
                compare_to_day: ~D[2021-06-21],
                locale: "fr",
diff --git a/test/service/workers/notification_test.exs b/test/service/workers/notification_test.exs
index de0a23952..3503faa3c 100644
--- a/test/service/workers/notification_test.exs
+++ b/test/service/workers/notification_test.exs
@@ -56,7 +56,7 @@ defmodule Mobilizon.Service.Workers.NotificationTest do
       actor = Map.put(participant.actor, :user, user)
       participant = Map.put(participant, :actor, actor)
 
-      assert {:ok, %Participant{}} = Events.delete_participant(participant)
+      assert {:ok, %{participant: %Participant{}}} = Events.delete_participant(participant)
 
       Notification.perform(%Oban.Job{
         args: %{"op" => "before_event_notification", "participant_id" => participant_id}
@@ -131,7 +131,7 @@ defmodule Mobilizon.Service.Workers.NotificationTest do
       actor = Map.put(participant.actor, :user, user)
       participant = Map.put(participant, :actor, actor)
 
-      assert {:ok, %Participant{}} = Events.delete_participant(participant)
+      assert {:ok, %{participant: %Participant{}}} = Events.delete_participant(participant)
 
       Notification.perform(%Oban.Job{
         args: %{"op" => "on_day_notification", "user_id" => user_id}
@@ -243,7 +243,7 @@ defmodule Mobilizon.Service.Workers.NotificationTest do
       actor = Map.put(participant.actor, :user, user)
       participant = Map.put(participant, :actor, actor)
 
-      assert {:ok, %Participant{}} = Events.delete_participant(participant)
+      assert {:ok, %{participant: %Participant{}}} = Events.delete_participant(participant)
 
       Notification.perform(%Oban.Job{
         args: %{"op" => "weekly_notification", "user_id" => user_id}
diff --git a/test/support/factory.ex b/test/support/factory.ex
index 953ac8c0b..4294ffcd7 100644
--- a/test/support/factory.ex
+++ b/test/support/factory.ex
@@ -11,6 +11,7 @@ defmodule Mobilizon.Factory do
   alias Mobilizon.Web.{Endpoint, Upload}
   alias Mobilizon.Web.Router.Helpers, as: Routes
 
+  @spec user_factory :: Mobilizon.Users.User.t()
   def user_factory do
     %Mobilizon.Users.User{
       password_hash: "Jane Smith",
@@ -23,6 +24,7 @@ defmodule Mobilizon.Factory do
     }
   end
 
+  @spec settings_factory :: Mobilizon.Users.Setting.t()
   def settings_factory do
     %Mobilizon.Users.Setting{
       timezone: nil,
@@ -37,6 +39,7 @@ defmodule Mobilizon.Factory do
     }
   end
 
+  @spec actor_factory :: Mobilizon.Actors.Actor.t()
   def actor_factory do
     preferred_username = sequence("thomas")
 
@@ -62,6 +65,7 @@ defmodule Mobilizon.Factory do
     }
   end
 
+  @spec group_factory :: Mobilizon.Actors.Actor.t()
   def group_factory do
     preferred_username = sequence("myGroup")
 
@@ -82,6 +86,7 @@ defmodule Mobilizon.Factory do
     )
   end
 
+  @spec instance_actor_factory :: Mobilizon.Actors.Actor.t()
   def instance_actor_factory do
     preferred_username = "relay"
     domain = "#{sequence("mydomain")}.com"
@@ -104,6 +109,7 @@ defmodule Mobilizon.Factory do
     )
   end
 
+  @spec follower_factory :: Mobilizon.Actors.Follower.t()
   def follower_factory do
     uuid = Ecto.UUID.generate()
 
@@ -116,6 +122,7 @@ defmodule Mobilizon.Factory do
     }
   end
 
+  @spec tag_factory :: Mobilizon.Events.Tag.t()
   def tag_factory do
     %Mobilizon.Events.Tag{
       title: sequence("MyTag"),
@@ -123,6 +130,7 @@ defmodule Mobilizon.Factory do
     }
   end
 
+  @spec tag_relation_factory :: Mobilizon.Events.TagRelation.t()
   def tag_relation_factory do
     %Mobilizon.Events.TagRelation{
       tag: build(:tag),
@@ -130,6 +138,7 @@ defmodule Mobilizon.Factory do
     }
   end
 
+  @spec address_factory :: Mobilizon.Addresses.Address.t()
   def address_factory do
     %Mobilizon.Addresses.Address{
       description: sequence("MyAddress"),
@@ -143,6 +152,7 @@ defmodule Mobilizon.Factory do
     }
   end
 
+  @spec comment_factory :: Mobilizon.Discussions.Comment.t()
   def comment_factory do
     uuid = Ecto.UUID.generate()
 
@@ -165,6 +175,7 @@ defmodule Mobilizon.Factory do
     }
   end
 
+  @spec event_factory :: Mobilizon.Events.Event.t()
   def event_factory do
     actor = build(:actor)
     start = Timex.shift(DateTime.utc_now(), hours: 2)
@@ -198,6 +209,7 @@ defmodule Mobilizon.Factory do
     }
   end
 
+  @spec participant_factory :: Mobilizon.Events.Participant.t()
   def participant_factory do
     uuid = Ecto.UUID.generate()
 
@@ -214,6 +226,7 @@ defmodule Mobilizon.Factory do
     }
   end
 
+  @spec session_factory :: Mobilizon.Events.Session.t()
   def session_factory do
     %Mobilizon.Events.Session{
       title: sequence("MySession"),
@@ -222,6 +235,7 @@ defmodule Mobilizon.Factory do
     }
   end
 
+  @spec track_factory :: Mobilizon.Events.Track.t()
   def track_factory do
     %Mobilizon.Events.Track{
       name: sequence("MyTrack"),
@@ -229,6 +243,7 @@ defmodule Mobilizon.Factory do
     }
   end
 
+  @spec bot_factory :: Mobilizon.Actors.Bot.t()
   def bot_factory do
     %Mobilizon.Actors.Bot{
       source: "https://mysource.tld/feed.ics",
@@ -238,6 +253,7 @@ defmodule Mobilizon.Factory do
     }
   end
 
+  @spec member_factory :: Mobilizon.Actors.Member.t()
   def member_factory do
     uuid = Ecto.UUID.generate()
 
@@ -250,6 +266,7 @@ defmodule Mobilizon.Factory do
     }
   end
 
+  @spec feed_token_factory :: Mobilizon.Events.FeedToken.t()
   def feed_token_factory do
     user = build(:user)
 
@@ -260,6 +277,7 @@ defmodule Mobilizon.Factory do
     }
   end
 
+  @spec file_factory :: Mobilizon.Medias.File.t()
   def file_factory do
     File.cp!("test/fixtures/image.jpg", "test/fixtures/image_tmp.jpg")
 
@@ -285,6 +303,7 @@ defmodule Mobilizon.Factory do
     }
   end
 
+  @spec media_factory :: Mobilizon.Medias.Media.t()
   def media_factory do
     %Mobilizon.Medias.Media{
       file: build(:file),
@@ -292,6 +311,7 @@ defmodule Mobilizon.Factory do
     }
   end
 
+  @spec report_factory :: Mobilizon.Reports.Report.t()
   def report_factory do
     %Mobilizon.Reports.Report{
       content: "This is problematic",
@@ -304,6 +324,7 @@ defmodule Mobilizon.Factory do
     }
   end
 
+  @spec report_note_factory :: Mobilizon.Reports.Note.t()
   def report_note_factory do
     %Mobilizon.Reports.Note{
       content: "My opinion",
@@ -312,6 +333,7 @@ defmodule Mobilizon.Factory do
     }
   end
 
+  @spec todo_list_factory :: Mobilizon.Todos.TodoList.t()
   def todo_list_factory do
     uuid = Ecto.UUID.generate()
 
@@ -324,6 +346,7 @@ defmodule Mobilizon.Factory do
     }
   end
 
+  @spec todo_factory :: Mobilizon.Todos.Todo.t()
   def todo_factory do
     uuid = Ecto.UUID.generate()
 
@@ -340,6 +363,7 @@ defmodule Mobilizon.Factory do
     }
   end
 
+  @spec resource_factory :: Mobilizon.Resources.Resource.t()
   def resource_factory do
     uuid = Ecto.UUID.generate()
     title = sequence("my resource")
@@ -358,6 +382,7 @@ defmodule Mobilizon.Factory do
     }
   end
 
+  @spec admin_setting_factory :: Mobilizon.Admin.Setting.t()
   def admin_setting_factory do
     %Mobilizon.Admin.Setting{
       group: sequence("group"),
@@ -366,6 +391,7 @@ defmodule Mobilizon.Factory do
     }
   end
 
+  @spec post_factory :: Mobilizon.Posts.Post.t()
   def post_factory do
     uuid = Ecto.UUID.generate()
 
@@ -386,6 +412,7 @@ defmodule Mobilizon.Factory do
     }
   end
 
+  @spec tombstone_factory :: Mobilizon.Tombstone.t()
   def tombstone_factory do
     uuid = Ecto.UUID.generate()
 
@@ -395,6 +422,7 @@ defmodule Mobilizon.Factory do
     }
   end
 
+  @spec discussion_factory :: Mobilizon.Discussions.Discussion.t()
   def discussion_factory do
     uuid = Ecto.UUID.generate()
     actor = build(:actor)
@@ -413,6 +441,7 @@ defmodule Mobilizon.Factory do
     }
   end
 
+  @spec mobilizon_activity_factory :: Mobilizon.Activities.Activity.t()
   def mobilizon_activity_factory do
     group = build(:group)
     actor = build(:actor)
@@ -433,6 +462,7 @@ defmodule Mobilizon.Factory do
     }
   end
 
+  @spec mobilizon_activity_setting_factory :: Mobilizon.Users.ActivitySetting.t()
   def mobilizon_activity_setting_factory do
     %Mobilizon.Users.ActivitySetting{
       key: "event_created",
@@ -442,6 +472,7 @@ defmodule Mobilizon.Factory do
     }
   end
 
+  @spec push_subscription_factory :: Mobilizon.Users.PushSubscription.t()
   def push_subscription_factory do
     %Mobilizon.Users.PushSubscription{
       digest: "",
@@ -452,6 +483,7 @@ defmodule Mobilizon.Factory do
     }
   end
 
+  @spec share_factory :: Mobilizon.Share.t()
   def share_factory do
     %Mobilizon.Share{
       actor: build(:actor),
@@ -460,6 +492,7 @@ defmodule Mobilizon.Factory do
     }
   end
 
+  @spec event_metadata_factory :: Mobilizon.Events.EventMetadata.t()
   def event_metadata_factory do
     %Mobilizon.Events.EventMetadata{
       key: sequence("mz:custom:something"),
diff --git a/test/tasks/users_test.exs b/test/tasks/users_test.exs
index 89575e030..bff6acce2 100644
--- a/test/tasks/users_test.exs
+++ b/test/tasks/users_test.exs
@@ -277,7 +277,7 @@ defmodule Mix.Tasks.Mobilizon.UsersTest do
       assert {:ok, %User{confirmed_at: confirmed_at}} = Users.get_user_by_email(@email)
 
       assert output_received ==
-               "An user has been modified with the following information:\n  - email: #{user.email}\n  - Role: #{user.role}\n  - account status: activated on #{confirmed_at} (UTC)\n"
+               "An user has been modified with the following information:\n  - email: #{user.email}\n  - Role: #{user.role}\n  - account status: Activated on #{confirmed_at} (UTC)\n"
 
       refute is_nil(confirmed_at)
 
@@ -308,7 +308,7 @@ defmodule Mix.Tasks.Mobilizon.UsersTest do
                Users.get_user_by_email(@modified_email)
 
       assert output_received ==
-               "An user has been modified with the following information:\n  - email: #{@modified_email}\n  - Role: #{user.role}\n  - account status: activated on #{confirmed_at} (UTC)\n"
+               "An user has been modified with the following information:\n  - email: #{@modified_email}\n  - Role: #{user.role}\n  - account status: Activated on #{confirmed_at} (UTC)\n"
     end
   end
 end
diff --git a/test/web/controllers/activity_pub_controller_test.exs b/test/web/controllers/activity_pub_controller_test.exs
index ca962f661..123c00bf2 100644
--- a/test/web/controllers/activity_pub_controller_test.exs
+++ b/test/web/controllers/activity_pub_controller_test.exs
@@ -5,6 +5,7 @@
 
 defmodule Mobilizon.Web.ActivityPubControllerTest do
   use ExVCR.Mock, adapter: ExVCR.Adapter.Hackney
+  import Mox
 
   use Mobilizon.Web.ConnCase
 
@@ -14,7 +15,7 @@ defmodule Mobilizon.Web.ActivityPubControllerTest do
   alias Mobilizon.Actors.Actor
 
   alias Mobilizon.Federation.ActivityPub
-
+  alias Mobilizon.Service.HTTP.ActivityPub.Mock
   alias Mobilizon.Web.ActivityPub.ActorView
   alias Mobilizon.Web.{Endpoint, PageView}
   alias Mobilizon.Web.Router.Helpers, as: Routes
@@ -119,18 +120,55 @@ defmodule Mobilizon.Web.ActivityPubControllerTest do
 
   describe "/@:preferred_username/inbox" do
     test "it inserts an incoming event into the database", %{conn: conn} do
-      use_cassette "activity_pub_controller/mastodon-post-activity_actor_call" do
-        data = File.read!("test/fixtures/mastodon-post-activity.json") |> Jason.decode!()
+      # use_cassette "activity_pub_controller/mastodon-post-activity_actor_call" do
+      data = File.read!("test/fixtures/mastodon-post-activity.json") |> Jason.decode!()
 
-        conn =
-          conn
-          |> assign(:valid_signature, true)
-          |> post("#{Endpoint.url()}/inbox", data)
+      %Actor{url: remote_actor_url} =
+        remote_actor =
+        insert(:actor,
+          domain: "framapiaf.org",
+          url: "https://framapiaf.org/users/admin",
+          preferred_username: "admin"
+        )
 
-        assert "ok" == json_response(conn, 200)
-        :timer.sleep(500)
-        assert ActivityPub.fetch_object_from_url(data["object"]["id"])
-      end
+      remote_actor_data =
+        Mobilizon.Federation.ActivityStream.Converter.Actor.model_to_as(remote_actor)
+
+      %Actor{url: local_actor_url} =
+        local_actor =
+        insert(:actor, domain: nil, url: "http://mobilizon.com/@tcit", preferred_username: "tcit")
+
+      local_actor_data =
+        Mobilizon.Federation.ActivityStream.Converter.Actor.model_to_as(local_actor)
+
+      Mock
+      |> expect(:call, fn
+        %{method: :get, url: url}, _opts ->
+          case url do
+            ^remote_actor_url ->
+              {:ok, %Tesla.Env{status: 200, body: remote_actor_data}}
+
+            ^local_actor_url ->
+              {:ok, %Tesla.Env{status: 200, body: local_actor_data}}
+
+            "https://framapiaf.org/users/admin/statuses/99512778738411822" ->
+              {:ok, %Tesla.Env{status: 404, body: ""}}
+          end
+      end)
+
+      conn =
+        conn
+        |> assign(:valid_signature, true)
+        |> post("#{Endpoint.url()}/inbox", data)
+
+      assert "ok" == json_response(conn, 200)
+      :timer.sleep(500)
+
+      assert {:ok, %Mobilizon.Discussions.Comment{} = comment} =
+               ActivityPub.fetch_object_from_url(data["object"]["id"])
+
+      assert comment.actor.id == remote_actor.id
+      # end
     end
   end
 
diff --git a/test/web/upload/upload_test.exs b/test/web/upload/upload_test.exs
index b9aeadbeb..871a6e10e 100644
--- a/test/web/upload/upload_test.exs
+++ b/test/web/upload/upload_test.exs
@@ -127,7 +127,8 @@ defmodule Mobilizon.UploadTest do
         filename: "test.txt"
       }
 
-      assert {:error, :mime_type_not_allowed} == Upload.store(file)
+      res = Upload.store(file)
+      assert match?({:error, :mime_type_not_allowed}, res)
     end
 
     test "copies the file to the configured folder with anonymizing filename" do
@@ -189,7 +190,7 @@ defmodule Mobilizon.UploadTest do
 
       refute File.exists?(file)
 
-      assert {:error, "File not_existing/definitely.jpg doesn't exist"} =
+      assert {:error, :enofile} =
                Upload.remove("https://mobilizon.test/media/not_existing/definitely.jpg")
     end
   end
diff --git a/test/web/upload/uploader/local_test.exs b/test/web/upload/uploader/local_test.exs
index 5ac4243f6..53b60fe1f 100644
--- a/test/web/upload/uploader/local_test.exs
+++ b/test/web/upload/uploader/local_test.exs
@@ -8,6 +8,15 @@ defmodule Mobilizon.Web.Upload.Uploader.LocalTest do
   alias Mobilizon.Web.Upload
   alias Mobilizon.Web.Upload.Uploader.Local
 
+  @file_path "local_upload/files/image.jpg"
+  @local_path Path.join([Local.upload_path(), @file_path])
+
+  setup do
+    File.rm(@local_path)
+
+    :ok
+  end
+
   describe "get_file/1" do
     test "it returns path to local folder for files" do
       assert Local.get_file("") == {:ok, {:static_dir, "test/uploads"}}
@@ -17,42 +26,44 @@ defmodule Mobilizon.Web.Upload.Uploader.LocalTest do
   describe "put_file/1" do
     test "put file to local folder" do
       File.cp!("test/fixtures/image.jpg", "test/fixtures/image_tmp.jpg")
-      file_path = "local_upload/files/image.jpg"
 
       file = %Upload{
         name: "image.jpg",
         content_type: "image/jpeg",
-        path: file_path,
+        path: @file_path,
         tempfile: Path.absname("test/fixtures/image_tmp.jpg")
       }
 
-      assert Local.put_file(file) == :ok
+      assert {:ok, {:file, @file_path}} == Local.put_file(file)
 
-      assert [Local.upload_path(), file_path]
-             |> Path.join()
-             |> File.exists?()
+      assert File.exists?(@local_path)
+
+      assert :ok == Local.put_file(file)
+
+      assert File.exists?(@local_path)
     end
   end
 
   describe "remove_file/1" do
     test "removes local file" do
       File.cp!("test/fixtures/image.jpg", "test/fixtures/image_tmp.jpg")
-      file_path = "local_upload/files/image.jpg"
 
       file = %Upload{
         name: "image.jpg",
         content_type: "image/jpeg",
-        path: file_path,
+        path: @file_path,
         tempfile: Path.absname("test/fixtures/image_tmp.jpg")
       }
 
-      :ok = Local.put_file(file)
-      local_path = Path.join([Local.upload_path(), file_path])
-      assert File.exists?(local_path)
+      refute File.exists?(@local_path)
 
-      Local.remove_file(file_path)
+      assert {:ok, {:file, @file_path}} = Local.put_file(file)
 
-      refute File.exists?(local_path)
+      assert File.exists?(@local_path)
+
+      Local.remove_file(@file_path)
+
+      refute File.exists?(@local_path)
     end
   end
 end