Public key reset endpoint WIP

Author: joepio

lib/src/agents.rs

@@ -2,7 +2,7 @@
 //! Agents are actors (such as users) that can edit content.
 //! https://docs.atomicdata.dev/commits/concepts.html
 
-use crate::{errors::AtomicResult, urls, Resource, Storelike, Value};
+use crate::{errors::AtomicResult, urls, Query, Resource, Storelike, Value};
 
 #[derive(Clone, Debug)]
 pub struct Agent {
@@ -39,6 +39,41 @@ impl Agent {
         Ok(resource)
     }
 
+    pub fn from_email(email: &str, store: &impl Storelike) -> AtomicResult<Self> {
+        let mut query = Query::new();
+        query.property = Some(urls::EMAIL.into());
+        query.value = Some(Value::String(email.to_string()));
+        let response = store.query(&query)?;
+        if response.resources.is_empty() {
+            return Err(format!("Agent with Email {} not found", email).into());
+        }
+        if response.resources.len() > 1 {
+            return Err(format!(
+                "Email {} is not unique, {} agents have this email",
+                email, response.count
+            )
+            .into());
+        }
+        let resource = response.resources.first().unwrap();
+        Agent::from_resource(resource.clone())
+    }
+
+    pub fn from_resource(resource: Resource) -> AtomicResult<Self> {
+        let name = if let Ok(name) = resource.get(urls::NAME) {
+            Some(name.to_string())
+        } else {
+            None
+        };
+
+        return Ok(Self {
+            created_at: resource.get(urls::CREATED_AT)?.to_int()?,
+            name,
+            public_key: resource.get(urls::PUBLIC_KEY)?.to_string(),
+            private_key: None,
+            subject: resource.get_subject().into(),
+        });
+    }
+
     /// Creates a new Agent, generates a new Keypair.
     pub fn new(name: Option<&str>, store: &impl Storelike) -> AtomicResult<Agent> {
         let keypair = generate_keypair()?;

lib/src/collections.rs

@@ -1,9 +1,7 @@
 //! Collections are dynamic resources that refer to multiple resources.
 //! They are constructed using a TPF query
 use crate::{
-    errors::AtomicResult,
-    storelike::{Query, ResourceCollection},
-    urls, Resource, Storelike, Value,
+    errors::AtomicResult, storelike::ResourceCollection, urls, Query, Resource, Storelike, Value,
 };
 
 #[derive(Debug)]

lib/src/db.rs

@@ -26,10 +26,11 @@ use crate::{
     email::{self, MailMessage},
     endpoints::{default_endpoints, Endpoint},
     errors::{AtomicError, AtomicResult},
+    query::QueryResult,
     resources::PropVals,
-    storelike::{Query, QueryResult, Storelike},
+    storelike::Storelike,
     values::SortableValue,
-    Atom, Resource,
+    Atom, Query, Resource,
 };
 
 use self::{

lib/src/db/query_index.rs

@@ -2,11 +2,8 @@
 //! It relies on lexicographic ordering of keys, which Sled utilizes using `scan_prefix` queries.
 
 use crate::{
-    atoms::IndexAtom,
-    errors::AtomicResult,
-    storelike::{Query, QueryResult},
-    values::SortableValue,
-    Atom, Db, Resource, Storelike, Value,
+    atoms::IndexAtom, errors::AtomicResult, query::QueryResult, values::SortableValue, Atom, Db,
+    Query, Resource, Storelike, Value,
 };
 use serde::{Deserialize, Serialize};
 

lib/src/email.rs

@@ -1,6 +1,6 @@
 //! [EmailAddress] with validation, [MailMessage] with sending, and [get_smtp_client] for setting up mail.
 
-use crate::{errors::AtomicResult, storelike::Query, urls, Storelike};
+use crate::{errors::AtomicResult, urls, Query, Storelike};
 use mail_send::{mail_builder::MessageBuilder, Connected, Transport};
 use serde::{Deserialize, Serialize};
 use tracing::info;

lib/src/hierarchy.rs

@@ -4,7 +4,7 @@
 
 use core::fmt;
 
-use crate::{errors::AtomicResult, storelike::Query, urls, AtomicError, Resource, Storelike};
+use crate::{errors::AtomicResult, urls, AtomicError, Query, Resource, Storelike};
 
 #[derive(Debug)]
 pub enum Right {

lib/src/lib.rs

@@ -87,6 +87,7 @@ pub mod parse;
 #[cfg(feature = "db")]
 pub mod plugins;
 pub mod populate;
+pub mod query;
 pub mod resources;
 pub mod schema;
 pub mod serialize;
@@ -108,6 +109,7 @@ pub use commit::Commit;
 pub use db::Db;
 pub use errors::AtomicError;
 pub use errors::AtomicErrorType;
+pub use query::Query;
 pub use resources::Resource;
 pub use store::Store;
 pub use storelike::Storelike;

lib/src/plugins/chatroom.rs

@@ -7,9 +7,8 @@ They list a bunch of Messages.
 use crate::{
     commit::{CommitBuilder, CommitResponse},
     errors::AtomicResult,
-    storelike::Query,
     urls::{self, PARENT},
-    utils, Resource, Storelike, Value,
+    utils, Query, Resource, Storelike, Value,
 };
 
 // Find the messages for the ChatRoom

lib/src/plugins/importer.rs

@@ -2,7 +2,7 @@
 Importers allow users to (periodically) import JSON-AD files from a remote source.
 */
 
-use crate::{errors::AtomicResult, storelike::Query, urls, Resource, Storelike};
+use crate::{errors::AtomicResult, urls, Query, Resource, Storelike};
 
 /// When an importer is shown, we list a bunch of Paramaters and a list of previously imported items.
 #[tracing::instrument(skip(store, query_params))]

lib/src/plugins/mod.rs

@@ -47,3 +47,6 @@ pub mod register;
 pub mod reset_pubkey;
 pub mod search;
 pub mod versioning;
+
+// Utilities / helpers
+mod utils;

lib/src/plugins/register.rs

@@ -12,6 +12,8 @@ use crate::{
     Db, Resource, Storelike, Value,
 };
 
+use super::utils::return_success;
+
 pub fn register_endpoint() -> Endpoint {
     Endpoint {
       path: urls::PATH_REGISTER.to_string(),
@@ -21,7 +23,7 @@ pub fn register_endpoint() -> Endpoint {
       ].into(),
       description: "Allows new users to easily, in one request, make both an Agent and a Drive. This drive will be created at the subdomain of `name`.".to_string(),
       shortname: "register".to_string(),
-      handle: Some(construct_register_redirect),
+      handle: Some(handle_register_name_and_email),
   }
 }
 
@@ -42,7 +44,7 @@ struct MailConfirmation {
 }
 
 #[tracing::instrument(skip(store))]
-pub fn construct_register_redirect(
+pub fn handle_register_name_and_email(
     url: url::Url,
     store: &Db,
     for_agent: Option<&str>,
@@ -94,14 +96,7 @@ pub fn construct_register_redirect(
             .unwrap_or_else(|e| tracing::error!("Error sending email: {}", e));
     });
 
-    // Here we probably want to return some sort of SuccesMessage page.
-    // Not sure what that should be.
-    let mut resource = Resource::new_generate_subject(store);
-    resource.set_propval_string(urls::DESCRIPTION.into(), "success", store)?;
-
-    // resource.set_propval(urls::, value, store)
-
-    Ok(resource)
+    return_success()
 }
 
 #[tracing::instrument(skip(store))]

lib/src/plugins/reset_pubkey.rs

@@ -1,70 +1,125 @@
 /*!
-Reset email
+Sends users a link to add a new public key to their account.
+Useful when a users loses their private key.
 */
 
-use crate::{endpoints::Endpoint, errors::AtomicResult, urls, Db, Resource};
+use serde::{Deserialize, Serialize};
 
-pub fn request_email_pubkey_reset() -> Endpoint {
+use crate::{
+    agents::Agent,
+    email::{EmailAddress, MailAction, MailMessage},
+    endpoints::Endpoint,
+    errors::AtomicResult,
+    plugins::utils::return_success,
+    urls, Db, Resource, Storelike,
+};
+
+pub fn request_email_add_pubkey() -> Endpoint {
     Endpoint {
-        path: urls::PATH_RESET_PUBKEY.to_string(),
+        path: urls::PATH_ADD_PUBKEY.to_string(),
         params: [urls::TOKEN.to_string(), urls::INVITE_PUBKEY.to_string()].into(),
-        description: "Requests an email to set a new PublicKey to an Agent.".to_string(),
+        description: "Requests an email to add a new PublicKey to an Agent.".to_string(),
         shortname: "request-pubkey-reset".to_string(),
-        handle: Some(construct_reset_pubkey),
+        handle: Some(handle_request_email_pubkey),
     }
 }
 
-pub fn confirm_pubkey_reset() -> Endpoint {
+pub fn confirm_add_pubkey() -> Endpoint {
     Endpoint {
-        path: urls::PATH_CONFIRM_RESET.to_string(),
+        path: urls::PATH_CONFIRM_PUBKEY.to_string(),
         params: [urls::TOKEN.to_string(), urls::INVITE_PUBKEY.to_string()].into(),
-        description: "Requests an email to set a new PublicKey to an Agent.".to_string(),
+        description: "Confirms a token to add a new Public Key.".to_string(),
         shortname: "request-pubkey-reset".to_string(),
-        handle: Some(construct_confirm_reset_pubkey),
+        handle: Some(handle_confirm_add_pubkey),
+    }
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+struct AddPubkeyToken {
+    agent: String,
+}
+
+pub fn handle_request_email_pubkey(
+    url: url::Url,
+    store: &Db,
+    _for_agent: Option<&str>,
+) -> AtomicResult<Resource> {
+    let mut email_option: Option<EmailAddress> = None;
+    for (k, v) in url.query_pairs() {
+        match k.as_ref() {
+            "email" => email_option = Some(EmailAddress::new(v.to_string())?),
+            _ => {}
+        }
     }
+    // by default just return the Endpoint
+    let Some(email) = email_option else {
+        return request_email_add_pubkey().to_resource(store);
+    };
+
+    // Find the agent by their email
+    let agent = Agent::from_email(&email.to_string(), store)?;
+
+    // send the user an e-mail to confirm sign up
+    let store_clone = store.clone();
+    let confirmation_token_struct = AddPubkeyToken {
+        agent: agent.subject.clone(),
+    };
+    let token = crate::token::sign_claim(store, confirmation_token_struct)?;
+    let mut confirm_url = store
+        .get_server_url()
+        .clone()
+        .set_path(urls::PATH_CONFIRM_PUBKEY)
+        .url();
+    confirm_url.set_query(Some(&format!("token={}", token)));
+    let message = MailMessage {
+        to: email,
+        subject: "Add a new Passphrase to your account".to_string(),
+        body: format!("You've requested adding a new Passphrase. Click the link below to do so!"),
+        action: Some(MailAction {
+            name: "Add new Passphrase to account".to_string(),
+            url: confirm_url.into(),
+        }),
+    };
+    // async, because mails are slow
+    tokio::spawn(async move {
+        store_clone
+            .send_email(message)
+            .await
+            .unwrap_or_else(|e| tracing::error!("Error sending email: {}", e));
+    });
+
+    return_success()
 }
 
 #[tracing::instrument(skip(store))]
-pub fn construct_confirm_reset_pubkey(
+pub fn handle_confirm_add_pubkey(
     url: url::Url,
     store: &Db,
     for_agent: Option<&str>,
 ) -> AtomicResult<Resource> {
     let mut token_opt: Option<String> = None;
     let mut pubkey_option = None;
 
-    println!("url: {:?}", url);
     for (k, v) in url.query_pairs() {
         match k.as_ref() {
             "token" | urls::TOKEN => token_opt = Some(v.to_string()),
             "public-key" | urls::INVITE_PUBKEY => pubkey_option = Some(v.to_string()),
             _ => {}
         }
     }
+    let pubkey = pubkey_option.ok_or("No public-key provided")?;
+
     let Some(token) = token_opt else {
-        return confirm_pubkey_reset().to_resource(store);
+        return confirm_add_pubkey().to_resource(store);
     };
-    let pubkey = pubkey_option.ok_or("No public-key provided")?;
 
     // Parse and verify the JWT token
-    let confirmation = crate::token::verify_claim::<MailConfirmation>(store, &token)?.custom;
+    let confirmation = crate::token::verify_claim::<AddPubkeyToken>(store, &token)?.custom;
 
-    // Add the drive to the Agent's list of drives
-    let mut agent = store.get_resource(&drive_creator_agent)?;
-    agent.push_propval(
-        urls::USED_PUBKEYS.into(),
-        SubResource::Subject(drive.get_subject().into()),
-        true,
-    )?;
-    agent.save_locally(store)?;
+    // Add the key to the agent
+    let mut agent = store.get_resource(&confirmation.agent)?;
+    agent.push_propval(urls::ACTIVE_KEYS, pubkey.into(), true)?;
+    agent.save(store)?;
 
-    // Construct the Redirect Resource, which might provide the Client with a Subject for his Agent.
-    let mut redirect = Resource::new_instance(urls::REDIRECT, store)?;
-    redirect.set_propval_string(urls::DESTINATION.into(), drive.get_subject(), store)?;
-    redirect.set_propval(
-        urls::REDIRECT_AGENT.into(),
-        crate::Value::AtomicUrl(drive_creator_agent),
-        store,
-    )?;
-    Ok(redirect)
+    return_success()
 }

lib/src/plugins/utils.rs

@@ -0,0 +1,10 @@
+//! Functions that can be valuable in multiple plugins
+
+use crate::{errors::AtomicResult, urls, Resource, Value};
+
+/// Returns a Resource with a description of "success"
+pub fn return_success() -> AtomicResult<Resource> {
+    let mut resource = Resource::new("unknown".into());
+    resource.set_propval_unsafe(urls::DESCRIPTION.into(), Value::String("success".into()));
+    Ok(resource)
+}

lib/src/plugins/versioning.rs

@@ -1,8 +1,8 @@
 use tracing::warn;
 
 use crate::{
-    collections::CollectionBuilder, endpoints::Endpoint, errors::AtomicResult, storelike::Query,
-    urls, AtomicError, Commit, Resource, Storelike,
+    collections::CollectionBuilder, endpoints::Endpoint, errors::AtomicResult, urls, AtomicError,
+    Commit, Query, Resource, Storelike,
 };
 
 pub fn version_endpoint() -> Endpoint {

lib/src/populate.rs

@@ -8,8 +8,7 @@ use crate::{
     errors::AtomicResult,
     parse::ParseOpts,
     schema::{Class, Property},
-    storelike::Query,
-    urls, Resource, Storelike, Value,
+    urls, Query, Resource, Storelike, Value,
 };
 
 /// Populates a store with some of the most fundamental Properties and Classes needed to bootstrap the whole.