Do not add register endpoint if there is no SMTP server

Author: joepio

lib/src/db.rs

@@ -20,18 +20,20 @@ use tracing::instrument;
 
 use crate::{
     agents::ForAgent,
-    atomic_url::AtomicUrl,
+    atomic_url::{AtomicUrl, Routes},
     atoms::IndexAtom,
     commit::CommitResponse,
     db::{query_index::NO_VALUE, val_prop_sub_index::find_in_val_prop_sub_index},
     email::{self, MailMessage},
-    endpoints::{default_endpoints, Endpoint, HandleGetContext},
+    endpoints::{build_default_endpoints, Endpoint, HandleGetContext},
     errors::{AtomicError, AtomicResult},
+    plugins,
     query::QueryResult,
     resources::PropVals,
     storelike::Storelike,
+    urls,
     values::SortableValue,
-    Atom, Query, Resource,
+    Atom, Query, Resource, Value,
 };
 
 use self::{
@@ -112,7 +114,7 @@ impl Db {
             prop_val_sub_index,
             server_url: AtomicUrl::try_from(server_url)?,
             watched_queries,
-            endpoints: default_endpoints(),
+            endpoints: Vec::new(),
             handle_commit: None,
             smtp_client: None,
         };
@@ -220,9 +222,40 @@ impl Db {
         Some(Resource::from_propvals(propvals, subject))
     }
 
+    pub fn register_default_endpoints(&mut self) -> AtomicResult<()> {
+        // First we delete all existing endpoint resources, as they might not be there in this new run
+        let found_endpoints = self.query(&Query::new_class(urls::ENDPOINT))?.resources;
+
+        for mut found in found_endpoints {
+            found.destroy(self)?;
+        }
+
+        let mut endpoints = build_default_endpoints();
+
+        if self.smtp_client.is_some() {
+            endpoints.push(plugins::register::register_endpoint());
+            endpoints.push(plugins::register::confirm_email_endpoint());
+        }
+
+        for endpoint in endpoints {
+            self.register_endpoint(endpoint)?;
+        }
+
+        Ok(())
+    }
+
     /// Adds an [Endpoint] to the store. This means adding a route with custom behavior.
-    pub fn register_endpoint(&mut self, endpoint: Endpoint) {
+    pub fn register_endpoint(&mut self, endpoint: Endpoint) -> AtomicResult<()> {
+        let mut resource = endpoint.to_resource(self)?;
+        let endpoints_collection = self.get_server_url().set_route(Routes::Endpoints);
+        resource.set_propval(
+            urls::PARENT.into(),
+            Value::AtomicUrl(endpoints_collection.to_string()),
+            self,
+        )?;
+        resource.save_locally(self)?;
         self.endpoints.push(endpoint);
+        Ok(())
     }
 
     /// Registers an SMTP client to the store, allowing the store to send emails.

lib/src/endpoints.rs

@@ -87,15 +87,13 @@ impl std::fmt::Debug for Endpoint {
     }
 }
 
-pub fn default_endpoints() -> Vec<Endpoint> {
+pub fn build_default_endpoints() -> Vec<Endpoint> {
     vec![
         plugins::versioning::version_endpoint(),
         plugins::versioning::all_versions_endpoint(),
         plugins::path::path_endpoint(),
         plugins::search::search_endpoint(),
         plugins::files::upload_endpoint(),
-        plugins::register::register_endpoint(),
-        plugins::register::confirm_email_endpoint(),
         #[cfg(feature = "html")]
         plugins::bookmark::bookmark_endpoint(),
         plugins::importer::import_endpoint(),

lib/src/plugins/mod.rs

@@ -34,8 +34,6 @@ They are used for performing custom queries, or calculating dynamic attributes.
 Add these by registering the handler at [crate::db::Db::get_resource_extended].
 */
 
-use crate::endpoints::Endpoint;
-
 // Class Extenders
 pub mod chatroom;
 pub mod importer;
@@ -53,19 +51,3 @@ pub mod versioning;
 
 // Utilities / helpers
 mod utils;
-
-pub fn default_endpoints() -> Vec<Endpoint> {
-    vec![
-        versioning::version_endpoint(),
-        versioning::all_versions_endpoint(),
-        path::path_endpoint(),
-        search::search_endpoint(),
-        files::upload_endpoint(),
-        register::register_endpoint(),
-        register::confirm_email_endpoint(),
-        add_pubkey::request_email_add_pubkey(),
-        add_pubkey::confirm_add_pubkey(),
-        #[cfg(feature = "html")]
-        bookmark::bookmark_endpoint(),
-    ]
-}

lib/src/populate.rs

@@ -247,26 +247,6 @@ pub fn populate_collections(store: &impl Storelike) -> AtomicResult<()> {
     Ok(())
 }
 
-#[cfg(feature = "db")]
-/// Adds default Endpoints (versioning) to the Db.
-/// Makes sure they are fetchable
-pub fn populate_endpoints(store: &crate::Db) -> AtomicResult<()> {
-    use crate::atomic_url::Routes;
-
-    let endpoints = crate::plugins::default_endpoints();
-    let endpoints_collection = store.get_server_url().set_route(Routes::Endpoints);
-    for endpoint in endpoints {
-        let mut resource = endpoint.to_resource(store)?;
-        resource.set_propval(
-            urls::PARENT.into(),
-            Value::AtomicUrl(endpoints_collection.to_string()),
-            store,
-        )?;
-        resource.save_locally(store)?;
-    }
-    Ok(())
-}
-
 #[cfg(feature = "db")]
 /// Adds items to the SideBar as subresources.
 /// Useful for helping a new user get started.
@@ -294,7 +274,6 @@ pub fn populate_all(store: &crate::Db) -> AtomicResult<()> {
     create_drive(store, None, &store.get_default_agent()?.subject, true)
         .map_err(|e| format!("Failed to create drive. {}", e))?;
     populate_collections(store).map_err(|e| format!("Failed to populate collections. {}", e))?;
-    populate_endpoints(store).map_err(|e| format!("Failed to populate endpoints. {}", e))?;
     populate_sidebar_items(store)
         .map_err(|e| format!("Failed to populate sidebar items. {}", e))?;
     Ok(())

server/src/appstate.rs

@@ -29,10 +29,12 @@ pub struct AppState {
 
 /// Initializes the Store and sets the default agent.
 pub fn init_store(config: &Config) -> AtomicServerResult<Db> {
-    let store = atomic_lib::Db::init(&config.store_path, &config.server_url)?;
+    let mut store = atomic_lib::Db::init(&config.store_path, &config.server_url)?;
 
     tracing::info!("Setting default agent");
     set_default_agent(config, &store)?;
+    store.register_default_endpoints()?;
+
     Ok(store)
 }