chore: upgrade to Dioxus 0.7

src/server/database_connection.rs

@@ -1,12 +1,8 @@
 use diesel::pg::PgConnection;
 use diesel::prelude::*;
-use dotenvy::dotenv;
-use std::env;
+
+const DATABASE_URL: &str = "postgres://app:app@db/todo_baggins";
 
 pub(crate) fn establish_database_connection() -> ConnectionResult<PgConnection> {
-    dotenv().expect("Could not load environment variables.");
-
-    let database_url =
-        env::var("DATABASE_URL").expect("The environment variable DATABASE_URL has to be set.");
-    PgConnection::establish(&database_url)
+    PgConnection::establish(DATABASE_URL)
 }

src/server/internationalization.rs

@@ -1,15 +0,0 @@
-use dioxus::prelude::ServerFnError;
-use dioxus::prelude::*;
-#[cfg(feature = "server")]
-use dotenvy::dotenv;
-use std::env;
-use unic_langid_impl::LanguageIdentifier;
-
-#[server]
-pub(crate) async fn get_language_identifier() -> Result<LanguageIdentifier, ServerFnError> {
-    dotenv().expect("Could not load environment variables from the .env file.");
-
-    Ok(env::var("LANGUAGE_CODE")
-        .expect("The environment variable LANGUAGE_CODE must be set.")
-        .parse::<LanguageIdentifier>()?)
-}

src/server/mod.rs

@@ -1,6 +1,6 @@
 #[cfg(feature = "server")]
 pub(crate) mod database_connection;
-pub(crate) mod internationalization;
 pub(crate) mod projects;
 pub(crate) mod subtasks;
 pub(crate) mod tasks;
+pub(crate) mod updates;

src/server/projects.rs

@@ -1,100 +1,75 @@
-use crate::errors::error::Error;
-use crate::errors::error_vec::ErrorVec;
-use crate::errors::project_error::ProjectError;
 use crate::models::project::{NewProject, Project};
 #[cfg(feature = "server")]
 use crate::server::database_connection::establish_database_connection;
 #[cfg(feature = "server")]
+use crate::server::updates::publish_update;
+#[cfg(feature = "server")]
 use diesel::{ExpressionMethods, QueryDsl, RunQueryDsl, SelectableHelper};
 use dioxus::prelude::*;
 #[cfg(feature = "server")]
 use validator::Validate;
 
 #[server]
-pub(crate) async fn create_project(
-    new_project: NewProject,
-) -> Result<Project, ServerFnError<ErrorVec<ProjectError>>> {
+pub(crate) async fn create_project(new_project: NewProject) -> Result<Project> {
     use crate::schema::projects;
 
     // TODO: replace with model sanitization (https://github.com/matous-volf/todo-baggins/issues/13)
     let mut new_project = new_project;
     new_project.title = new_project.title.trim().to_owned();
 
-    new_project
-        .validate()
-        .map_err::<ErrorVec<ProjectError>, _>(|errors| errors.into())?;
-
-    let mut connection =
-        establish_database_connection().map_err::<ErrorVec<ProjectError>, _>(|_| {
-            vec![ProjectError::Error(Error::ServerInternal)].into()
-        })?;
+    new_project.validate()?;
 
+    let mut connection = establish_database_connection()?;
     let new_project = diesel::insert_into(projects::table)
         .values(&new_project)
         .returning(Project::as_returning())
-        .get_result(&mut connection)
-        .map_err::<ErrorVec<ProjectError>, _>(|error| vec![error.into()].into())?;
+        .get_result(&mut connection)?;
+
+    publish_update().await;
 
     Ok(new_project)
 }
 
 #[server]
-pub(crate) async fn get_projects() -> Result<Vec<Project>, ServerFnError<ErrorVec<Error>>> {
+pub(crate) async fn get_projects() -> Result<Vec<Project>> {
     use crate::schema::projects::dsl::*;
 
-    let mut connection = establish_database_connection()
-        .map_err::<ErrorVec<Error>, _>(|_| vec![Error::ServerInternal].into())?;
-
+    let mut connection = establish_database_connection()?;
     let results = projects
         .select(Project::as_select())
-        .load::<Project>(&mut connection)
-        .map_err::<ErrorVec<Error>, _>(|_| vec![Error::ServerInternal].into())?;
+        .load::<Project>(&mut connection)?;
 
     Ok(results)
 }
 
 #[server]
-pub(crate) async fn edit_project(
-    project_id: i32,
-    new_project: NewProject,
-) -> Result<Project, ServerFnError<ErrorVec<ProjectError>>> {
+pub(crate) async fn edit_project(project_id: i32, new_project: NewProject) -> Result<Project> {
     use crate::schema::projects::dsl::*;
 
     // TODO: replace with model sanitization (https://github.com/matous-volf/todo-baggins/issues/13)
     let mut new_project = new_project;
     new_project.title = new_project.title.trim().to_owned();
 
-    new_project
-        .validate()
-        .map_err::<ErrorVec<ProjectError>, _>(|errors| errors.into())?;
-
-    let mut connection =
-        establish_database_connection().map_err::<ErrorVec<ProjectError>, _>(|_| {
-            vec![ProjectError::Error(Error::ServerInternal)].into()
-        })?;
+    new_project.validate()?;
 
+    let mut connection = establish_database_connection()?;
     let updated_project = diesel::update(projects)
         .filter(id.eq(project_id))
         .set(title.eq(new_project.title))
         .returning(Project::as_returning())
-        .get_result(&mut connection)
-        .map_err::<ErrorVec<ProjectError>, _>(|error| vec![error.into()].into())?;
+        .get_result(&mut connection)?;
 
+    publish_update().await;
     Ok(updated_project)
 }
 
-// TODO: Get rid of this suppression.
-//noinspection DuplicatedCode
 #[server]
-pub(crate) async fn delete_project(project_id: i32) -> Result<(), ServerFnError<ErrorVec<Error>>> {
+pub(crate) async fn delete_project(project_id: i32) -> Result<()> {
     use crate::schema::projects::dsl::*;
 
-    let mut connection = establish_database_connection()
-        .map_err::<ErrorVec<Error>, _>(|_| vec![Error::ServerInternal].into())?;
-
-    diesel::delete(projects.filter(id.eq(project_id)))
-        .execute(&mut connection)
-        .map_err::<ErrorVec<Error>, _>(|error| vec![error.into()].into())?;
+    let mut connection = establish_database_connection()?;
+    diesel::delete(projects.filter(id.eq(project_id))).execute(&mut connection)?;
 
+    publish_update().await;
     Ok(())
 }

src/server/subtasks.rs

@@ -1,86 +1,64 @@
-use crate::errors::error::Error;
-use crate::errors::error_vec::ErrorVec;
-use crate::errors::subtask_error::SubtaskError;
 use crate::models::subtask::{NewSubtask, Subtask};
 #[cfg(feature = "server")]
 use crate::server::database_connection::establish_database_connection;
 #[cfg(feature = "server")]
 use crate::server::tasks::trigger_task_updated_at;
 #[cfg(feature = "server")]
+use crate::server::updates::publish_update;
+#[cfg(feature = "server")]
 use diesel::{ExpressionMethods, QueryDsl, RunQueryDsl, SelectableHelper};
 use dioxus::prelude::*;
 #[cfg(feature = "server")]
 use validator::Validate;
 
 #[server]
-pub(crate) async fn create_subtask(
-    new_subtask: NewSubtask,
-) -> Result<Subtask, ServerFnError<ErrorVec<SubtaskError>>> {
+pub(crate) async fn create_subtask(new_subtask: NewSubtask) -> Result<Subtask> {
     use crate::schema::subtasks;
 
     // TODO: replace with model sanitization (https://github.com/matous-volf/todo-baggins/issues/13)
     let mut new_subtask = new_subtask;
     new_subtask.title = new_subtask.title.trim().to_owned();
 
-    new_subtask
-        .validate()
-        .map_err::<ErrorVec<SubtaskError>, _>(|errors| errors.into())?;
+    new_subtask.validate()?;
 
-    let mut connection =
-        establish_database_connection().map_err::<ErrorVec<SubtaskError>, _>(|_| {
-            vec![SubtaskError::Error(Error::ServerInternal)].into()
-        })?;
+    let mut connection = establish_database_connection()?;
 
     let created_subtask = diesel::insert_into(subtasks::table)
         .values(&new_subtask)
         .returning(Subtask::as_returning())
-        .get_result(&mut connection)
-        .map_err::<ErrorVec<SubtaskError>, _>(|error| vec![error.into()].into())?;
+        .get_result(&mut connection)?;
 
-    trigger_task_updated_at(new_subtask.task_id)
-        .await
-        .map_err::<ErrorVec<SubtaskError>, _>(|error_vec| error_vec.into())?;
+    trigger_task_updated_at(new_subtask.task_id).await?;
 
+    publish_update().await;
     Ok(created_subtask)
 }
 
 #[server]
-pub(crate) async fn get_subtasks_of_task(
-    filtered_task_id: i32,
-) -> Result<Vec<Subtask>, ServerFnError<ErrorVec<Error>>> {
+pub(crate) async fn get_subtasks_of_task(filtered_task_id: i32) -> Result<Vec<Subtask>> {
     use crate::schema::subtasks::dsl::*;
 
-    let mut connection = establish_database_connection()
-        .map_err::<ErrorVec<Error>, _>(|_| vec![Error::ServerInternal].into())?;
+    let mut connection = establish_database_connection()?;
 
     let results = subtasks
         .select(Subtask::as_select())
         .filter(task_id.eq(filtered_task_id))
-        .load::<Subtask>(&mut connection)
-        .map_err::<ErrorVec<Error>, _>(|_| vec![Error::ServerInternal].into())?;
+        .load::<Subtask>(&mut connection)?;
 
     Ok(results)
 }
 
 #[server]
-pub(crate) async fn edit_subtask(
-    subtask_id: i32,
-    new_subtask: NewSubtask,
-) -> Result<Subtask, ServerFnError<ErrorVec<SubtaskError>>> {
+pub(crate) async fn edit_subtask(subtask_id: i32, new_subtask: NewSubtask) -> Result<Subtask> {
     use crate::schema::subtasks::dsl::*;
 
     // TODO: replace with model sanitization (https://github.com/matous-volf/todo-baggins/issues/13)
     let mut new_subtask = new_subtask;
     new_subtask.title = new_subtask.title.trim().to_owned();
 
-    new_subtask
-        .validate()
-        .map_err::<ErrorVec<SubtaskError>, _>(|errors| errors.into())?;
+    new_subtask.validate()?;
 
-    let mut connection =
-        establish_database_connection().map_err::<ErrorVec<SubtaskError>, _>(|_| {
-            vec![SubtaskError::Error(Error::ServerInternal)].into()
-        })?;
+    let mut connection = establish_database_connection()?;
 
     let updated_task = diesel::update(subtasks)
         .filter(id.eq(subtask_id))
@@ -89,50 +67,41 @@ pub(crate) async fn edit_subtask(
             is_completed.eq(new_subtask.is_completed),
         ))
         .returning(Subtask::as_returning())
-        .get_result(&mut connection)
-        .map_err::<ErrorVec<SubtaskError>, _>(|error| vec![error.into()].into())?;
+        .get_result(&mut connection)?;
 
-    trigger_task_updated_at(new_subtask.task_id)
-        .await
-        .map_err::<ErrorVec<SubtaskError>, _>(|error_vec| error_vec.into())?;
+    trigger_task_updated_at(new_subtask.task_id).await?;
 
+    publish_update().await;
     Ok(updated_task)
 }
 
-#[server]
-pub(crate) async fn restore_subtasks_of_task(
-    filtered_task_id: i32,
-) -> Result<Vec<Subtask>, ServerFnError<ErrorVec<Error>>> {
+#[cfg(feature = "server")]
+pub(super) async fn restore_subtasks_of_task(filtered_task_id: i32) -> Result<Vec<Subtask>> {
     use crate::schema::subtasks::dsl::*;
 
-    let mut connection = establish_database_connection()
-        .map_err::<ErrorVec<Error>, _>(|_| vec![Error::ServerInternal].into())?;
+    let mut connection = establish_database_connection()?;
 
     let updated_subtasks = diesel::update(subtasks)
         .filter(task_id.eq(filtered_task_id))
         .set(is_completed.eq(false))
         .returning(Subtask::as_returning())
-        .get_results(&mut connection)
-        .map_err::<ErrorVec<Error>, _>(|error| vec![error.into()].into())?;
+        .get_results(&mut connection)?;
 
     Ok(updated_subtasks)
 }
 
-// TODO: Get rid of this suppression.
-//noinspection DuplicatedCode
 #[server]
-pub(crate) async fn delete_subtask(subtask_id: i32) -> Result<(), ServerFnError<ErrorVec<Error>>> {
+pub(crate) async fn delete_subtask(subtask_id: i32) -> Result<()> {
     use crate::schema::subtasks::dsl::*;
 
-    let mut connection = establish_database_connection()
-        .map_err::<ErrorVec<Error>, _>(|_| vec![Error::ServerInternal].into())?;
+    let mut connection = establish_database_connection()?;
 
     let deleted_subtask = diesel::delete(subtasks.filter(id.eq(subtask_id)))
         .returning(Subtask::as_returning())
-        .get_result(&mut connection)
-        .map_err::<ErrorVec<Error>, _>(|error| vec![error.into()].into())?;
+        .get_result(&mut connection)?;
 
-    trigger_task_updated_at(deleted_subtask.task_id()).await?;
+    trigger_task_updated_at(deleted_subtask.task_id).await?;
 
+    publish_update().await;
     Ok(())
 }

src/server/tasks.rs

@@ -1,6 +1,3 @@
-use crate::errors::error::Error;
-use crate::errors::error_vec::ErrorVec;
-use crate::errors::task_error::TaskError;
 use crate::models::category::Category;
 #[cfg(feature = "server")]
 use crate::models::category::ReoccurrenceInterval;
@@ -12,6 +9,8 @@ use crate::server::database_connection::establish_database_connection;
 #[cfg(feature = "server")]
 use crate::server::subtasks::restore_subtasks_of_task;
 #[cfg(feature = "server")]
+use crate::server::updates::publish_update;
+#[cfg(feature = "server")]
 use chrono::{Datelike, Days, Local, Months, NaiveDate};
 #[cfg(feature = "server")]
 use diesel::prelude::*;
@@ -24,65 +23,52 @@ use time::Month;
 use validator::Validate;
 
 #[server]
-pub(crate) async fn create_task(
-    new_task: NewTask,
-) -> Result<Task, ServerFnError<ErrorVec<TaskError>>> {
+pub(crate) async fn create_task(new_task: NewTask) -> Result<Task> {
     use crate::schema::tasks;
 
     // TODO: replace with model sanitization (https://github.com/matous-volf/todo-baggins/issues/13)
     let mut new_task = new_task;
     new_task.title = new_task.title.trim().to_owned();
 
-    new_task
-        .validate()
-        .map_err::<ErrorVec<TaskError>, _>(|errors| errors.into())?;
+    new_task.validate()?;
 
-    let mut connection =
-        establish_database_connection().map_err::<ErrorVec<TaskError>, _>(|_| {
-            vec![TaskError::Error(Error::ServerInternal)].into()
-        })?;
+    let mut connection = establish_database_connection()?;
 
     let new_task = diesel::insert_into(tasks::table)
         .values(&new_task)
         .returning(Task::as_returning())
-        .get_result(&mut connection)
-        .map_err::<ErrorVec<TaskError>, _>(|error| vec![error.into()].into())?;
+        .get_result(&mut connection)?;
 
+    publish_update().await;
     Ok(new_task)
 }
 
 #[server]
-pub(crate) async fn get_task(task_id: i32) -> Result<Task, ServerFnError<ErrorVec<Error>>> {
+pub(crate) async fn get_task(task_id: i32) -> Result<Task> {
     use crate::schema::tasks::dsl::*;
 
-    let mut connection = establish_database_connection()
-        .map_err::<ErrorVec<Error>, _>(|_| vec![Error::ServerInternal].into())?;
+    let mut connection = establish_database_connection()?;
 
     let task = tasks
         .find(task_id)
         .select(Task::as_select())
         .first(&mut connection)
-        .optional()
-        .map_err::<ErrorVec<Error>, _>(|_| vec![Error::ServerInternal].into())?;
+        .optional()?;
 
     // TODO: Handle not finding the task.
     Ok(task.unwrap())
 }
 
 #[server]
-pub(crate) async fn get_tasks_in_category(
-    filtered_category: Category,
-) -> Result<Vec<Task>, ServerFnError<ErrorVec<Error>>> {
+pub(crate) async fn get_tasks_in_category(filtered_category: Category) -> Result<Vec<Task>> {
     use crate::schema::tasks::dsl::*;
 
-    let mut connection = establish_database_connection()
-        .map_err::<ErrorVec<Error>, _>(|_| vec![Error::ServerInternal].into())?;
+    let mut connection = establish_database_connection()?;
 
     let results = tasks
         .select(Task::as_select())
         .filter(filtered_category.eq_sql_predicate())
-        .load::<Task>(&mut connection)
-        .map_err::<ErrorVec<Error>, _>(|_| vec![Error::ServerInternal].into())?;
+        .load::<Task>(&mut connection)?;
 
     Ok(results)
 }
@@ -90,52 +76,40 @@ pub(crate) async fn get_tasks_in_category(
 #[server]
 pub(crate) async fn get_tasks_with_subtasks_in_category(
     filtered_category: Category,
-) -> Result<Vec<TaskWithSubtasks>, ServerFnError<ErrorVec<Error>>> {
+) -> Result<Vec<TaskWithSubtasks>> {
     use crate::schema::tasks;
 
-    let mut connection = establish_database_connection()
-        .map_err::<ErrorVec<Error>, _>(|_| vec![Error::ServerInternal].into())?;
+    let mut connection = establish_database_connection()?;
 
     let tasks_in_category = tasks::table
         .filter(filtered_category.eq_sql_predicate())
         .select(Task::as_select())
-        .load(&mut connection)
-        .map_err::<ErrorVec<Error>, _>(|_| vec![Error::ServerInternal].into())?;
+        .load(&mut connection)?;
 
     let subtasks = Subtask::belonging_to(&tasks_in_category)
         .select(Subtask::as_select())
-        .load(&mut connection)
-        .map_err::<ErrorVec<Error>, _>(|_| vec![Error::ServerInternal].into())?;
+        .load(&mut connection)?;
 
     let tasks_with_subtasks = subtasks
         .grouped_by(&tasks_in_category)
         .into_iter()
         .zip(tasks_in_category)
-        .map(|(pages, book)| TaskWithSubtasks::new(book, pages))
+        .map(|(subtasks, task)| TaskWithSubtasks { task, subtasks })
         .collect();
 
     Ok(tasks_with_subtasks)
 }
 
 #[server]
-pub(crate) async fn edit_task(
-    task_id: i32,
-    mut new_task: NewTask,
-) -> Result<Task, ServerFnError<ErrorVec<TaskError>>> {
+pub(crate) async fn edit_task(task_id: i32, mut new_task: NewTask) -> Result<Task> {
     use crate::schema::tasks::dsl::*;
 
     // TODO: replace with model sanitization (https://github.com/matous-volf/todo-baggins/issues/13)
-    let mut new_task = new_task;
     new_task.title = new_task.title.trim().to_owned();
 
-    new_task
-        .validate()
-        .map_err::<ErrorVec<TaskError>, _>(|errors| errors.into())?;
+    new_task.validate()?;
 
-    let mut connection =
-        establish_database_connection().map_err::<ErrorVec<TaskError>, _>(|_| {
-            vec![TaskError::Error(Error::ServerInternal)].into()
-        })?;
+    let mut connection = establish_database_connection()?;
 
     let updated_task = diesel::update(tasks)
         .filter(id.eq(task_id))
@@ -146,14 +120,14 @@ pub(crate) async fn edit_task(
             project_id.eq(new_task.project_id),
         ))
         .returning(Task::as_returning())
-        .get_result(&mut connection)
-        .map_err::<ErrorVec<TaskError>, _>(|error| vec![error.into()].into())?;
+        .get_result(&mut connection)?;
 
+    publish_update().await;
     Ok(updated_task)
 }
 
 #[server]
-pub(crate) async fn complete_task(task_id: i32) -> Result<Task, ServerFnError<ErrorVec<Error>>> {
+pub(crate) async fn complete_task(task_id: i32) -> Result<Task> {
     let task = get_task(task_id).await?;
     let mut new_task = NewTask::from(task);
 
@@ -163,13 +137,13 @@ pub(crate) async fn complete_task(task_id: i32) -> Result<Task, ServerFnError<Er
         ..
     } = &mut new_task.category
     {
-        match reoccurrence.interval() {
-            ReoccurrenceInterval::Day => *date = *date + Days::new(reoccurrence.length() as u64),
+        match reoccurrence.interval {
+            ReoccurrenceInterval::Day => *date = *date + Days::new(reoccurrence.length as u64),
             ReoccurrenceInterval::Month | ReoccurrenceInterval::Year => {
                 *date = *date
                     + Months::new(
-                        reoccurrence.length()
-                            * if *(reoccurrence.interval()) == ReoccurrenceInterval::Year {
+                        reoccurrence.length
+                            * if reoccurrence.interval == ReoccurrenceInterval::Year {
                                 12
                             } else {
                                 1
@@ -178,7 +152,7 @@ pub(crate) async fn complete_task(task_id: i32) -> Result<Task, ServerFnError<Er
                 *date = NaiveDate::from_ymd_opt(
                     date.year(),
                     date.month(),
-                    reoccurrence.start_date().day().min(
+                    reoccurrence.start_date.day().min(
                         Month::try_from(date.month() as u8)
                             .unwrap()
                             .length(date.year()) as u32,
@@ -192,42 +166,35 @@ pub(crate) async fn complete_task(task_id: i32) -> Result<Task, ServerFnError<Er
         new_task.category = Category::Done;
     }
 
-    let updated_task = edit_task(task_id, new_task)
-        .await
-        .map_err::<ErrorVec<Error>, _>(|_| vec![Error::ServerInternal].into())?;
+    let updated_task = edit_task(task_id, new_task).await?;
 
+    publish_update().await;
     Ok(updated_task)
 }
 
-// TODO: Get rid of this suppression.
-//noinspection DuplicatedCode
 #[server]
-pub(crate) async fn delete_task(task_id: i32) -> Result<(), ServerFnError<ErrorVec<Error>>> {
+pub(crate) async fn delete_task(task_id: i32) -> Result<()> {
     use crate::schema::tasks::dsl::*;
 
-    let mut connection = establish_database_connection()
-        .map_err::<ErrorVec<Error>, _>(|_| vec![Error::ServerInternal].into())?;
+    let mut connection = establish_database_connection()?;
 
-    diesel::delete(tasks.filter(id.eq(task_id)))
-        .execute(&mut connection)
-        .map_err::<ErrorVec<Error>, _>(|error| vec![error.into()].into())?;
+    diesel::delete(tasks.filter(id.eq(task_id))).execute(&mut connection)?;
 
+    publish_update().await;
     Ok(())
 }
 
 #[cfg(feature = "server")]
-pub(crate) async fn trigger_task_updated_at(task_id: i32) -> Result<Task, ErrorVec<Error>> {
+pub(crate) async fn trigger_task_updated_at(task_id: i32) -> Result<Task> {
     use crate::schema::tasks::dsl::*;
 
-    let mut connection = establish_database_connection()
-        .map_err::<ErrorVec<Error>, _>(|_| vec![Error::ServerInternal].into())?;
+    let mut connection = establish_database_connection()?;
 
     let updated_task = diesel::update(tasks)
         .filter(id.eq(task_id))
         .set(updated_at.eq(Local::now().naive_local()))
         .returning(Task::as_returning())
-        .get_result(&mut connection)
-        .map_err::<ErrorVec<Error>, _>(|error| vec![error.into()].into())?;
+        .get_result(&mut connection)?;
 
     Ok(updated_task)
 }

src/server/updates.rs

@@ -0,0 +1,83 @@
+use dioxus::{
+    fullstack::{WebSocketOptions, Websocket},
+    prelude::*,
+};
+use serde::{Deserialize, Serialize};
+
+#[cfg(feature = "server")]
+use rand::random;
+#[cfg(feature = "server")]
+use tokio::sync::Mutex;
+
+#[derive(Serialize, Deserialize)]
+pub(crate) struct UpdateEvent;
+
+#[cfg(feature = "server")]
+mod server_only {
+    use std::{
+        collections::{HashMap, HashSet},
+        ops::Deref,
+        sync::LazyLock,
+    };
+
+    use dioxus::fullstack::TypedWebsocket;
+    use tokio::sync::{Mutex, RwLock};
+
+    use crate::server::updates::UpdateEvent;
+
+    pub(super) struct SubscribedClient {
+        pub(super) websocket: Mutex<TypedWebsocket<UpdateEvent, UpdateEvent>>,
+    }
+
+    pub(super) struct SubscribedClients(RwLock<HashMap<u64, SubscribedClient>>);
+
+    impl Deref for SubscribedClients {
+        type Target = RwLock<HashMap<u64, SubscribedClient>>;
+
+        fn deref(&self) -> &Self::Target {
+            &self.0
+        }
+    }
+
+    pub(super) static SUBSCRIBED_CLIENTS: LazyLock<SubscribedClients> =
+        LazyLock::new(|| SubscribedClients(RwLock::new(HashMap::new())));
+
+    pub(crate) async fn publish_update() {
+        let mut disconnected_client_ids = HashSet::new();
+        let subscribed_clients = SUBSCRIBED_CLIENTS.read().await;
+        for (id, client) in subscribed_clients.iter() {
+            if client
+                .websocket
+                .lock()
+                .await
+                .send(UpdateEvent)
+                .await
+                .is_err()
+            {
+                disconnected_client_ids.insert(*id);
+            }
+        }
+        drop(subscribed_clients);
+        if !disconnected_client_ids.is_empty() {
+            let mut subscribed_clients = SUBSCRIBED_CLIENTS.write().await;
+            subscribed_clients.retain(|id, _| !disconnected_client_ids.contains(id));
+        }
+    }
+}
+
+#[cfg(feature = "server")]
+pub(super) use server_only::*;
+
+#[get("/api/subscribe_to_updates")]
+pub(crate) async fn subscribe_to_updates(
+    websocket_options: WebSocketOptions,
+) -> Result<Websocket<UpdateEvent, UpdateEvent>> {
+    Ok(websocket_options.on_upgrade(move |socket| async move {
+        SUBSCRIBED_CLIENTS.write().await.insert(
+            random(),
+            SubscribedClient {
+                websocket: Mutex::new(socket),
+            },
+        );
+    }))
+}