Merge branch 'main' into konrad/group_operations

applogic/src/api/conversation_details_cubit.rs

@@ -10,7 +10,6 @@ use phnxcoreclient::{
     store::{Store, StoreEntityId, StoreOperation},
 };
 use phnxcoreclient::{store::StoreNotification, ConversationId};
-use phnxtypes::identifiers::SafeTryInto;
 use tokio::sync::watch;
 use tokio_stream::{Stream, StreamExt};
 use tokio_util::sync::CancellationToken;
@@ -91,10 +90,10 @@ impl ConversationDetailsCubitBase {
             .map(|c| c.conversation_type.clone());
         match conversation_type {
             Some(
-                UiConversationType::UnconfirmedConnection(username)
-                | UiConversationType::Connection(username),
+                UiConversationType::UnconfirmedConnection(user_name)
+                | UiConversationType::Connection(user_name),
             ) => {
-                let qualified_username = SafeTryInto::try_into(username)?;
+                let qualified_username = user_name.parse()?;
                 let profile = self.store.user_profile(&qualified_username).await?;
                 Ok(profile.map(|profile| UiUserProfile::from_profile(&profile)))
             }

applogic/src/api/conversation_list_cubit.rs

@@ -72,7 +72,7 @@ impl ConversationListCubitBase {
     // Cubit methods
 
     pub async fn create_connection(&self, user_name: String) -> anyhow::Result<ConversationId> {
-        let id = self.context.store.add_contact(user_name).await?;
+        let id = self.context.store.add_contact(user_name.parse()?).await?;
         self.context.load_and_emit_state().await;
         Ok(id)
     }

applogic/src/api/conversations.rs

@@ -6,7 +6,7 @@ use std::future::Future;
 
 use anyhow::{anyhow, Result};
 use phnxcoreclient::{store::Store, Conversation, ConversationId};
-use phnxtypes::identifiers::{QualifiedUserName, SafeTryInto};
+use phnxtypes::identifiers::QualifiedUserName;
 
 use crate::notifier::dispatch_message_notifications;
 
@@ -62,7 +62,7 @@ impl User {
                 conversation_id,
                 &user_names
                     .into_iter()
-                    .map(<String as SafeTryInto<QualifiedUserName>>::try_into)
+                    .map(|s| s.parse())
                     .collect::<Result<Vec<QualifiedUserName>, _>>()?,
             )
             .await?;
@@ -81,7 +81,7 @@ impl User {
                 conversation_id,
                 &user_names
                     .into_iter()
-                    .map(<String as SafeTryInto<QualifiedUserName>>::try_into)
+                    .map(|s| s.parse())
                     .collect::<Result<Vec<QualifiedUserName>, _>>()?,
             )
             .await?;

applogic/src/api/user/connections.rs

@@ -3,7 +3,6 @@
 // SPDX-License-Identifier: AGPL-3.0-or-later
 
 use anyhow::Result;
-use phnxtypes::identifiers::{QualifiedUserName, SafeTryInto};
 
 use crate::api::types::{UiContact, UiUserProfile};
 
@@ -21,13 +20,13 @@ impl User {
     }
 
     pub async fn contact(&self, user_name: String) -> Option<UiContact> {
-        let user_name = <String as SafeTryInto<QualifiedUserName>>::try_into(user_name).unwrap();
+        let user_name = user_name.parse().unwrap();
         self.user.contact(&user_name).await.map(|c| c.into())
     }
 
     /// Get the user profile of the user with the given [`QualifiedUserName`].
     pub async fn user_profile(&self, user_name: String) -> Result<Option<UiUserProfile>> {
-        let user_name = SafeTryInto::try_into(user_name)?;
+        let user_name = user_name.parse()?;
         let user_profile = self
             .user
             .user_profile(&user_name)

applogic/src/api/user/mod.rs

@@ -9,7 +9,7 @@ use phnxcoreclient::{
     Asset, UserProfile,
 };
 use phnxtypes::{
-    identifiers::{QualifiedUserName, SafeTryInto},
+    identifiers::QualifiedUserName,
     messages::{client_ds::QsWsMessage, push_token::PushTokenOperator},
 };
 use tracing::error;
@@ -89,7 +89,7 @@ impl User {
         display_name: Option<String>,
         profile_picture: Option<Vec<u8>>,
     ) -> Result<User> {
-        let user_name: QualifiedUserName = SafeTryInto::try_into(user_name)?;
+        let user_name: QualifiedUserName = user_name.parse()?;
         let user_profile = UserProfile::new(
             user_name.clone(),
             display_name.map(TryFrom::try_from).transpose()?,

backend/src/ds/group_state/persistence.rs

@@ -16,10 +16,10 @@ use super::StorableDsGroupData;
 impl StorableDsGroupData {
     pub(super) async fn store(&self, connection: impl PgExecutor<'_>) -> Result<(), StorageError> {
         sqlx::query!(
-            "INSERT INTO 
-                encrypted_groups 
+            "INSERT INTO
+                encrypted_groups
                 (group_id, ciphertext, last_used, deleted_queues)
-            VALUES 
+            VALUES
                 ($1, $2, $3, $4)
             ON CONFLICT (group_id) DO NOTHING",
             self.group_id,
@@ -37,11 +37,11 @@ impl StorableDsGroupData {
         qgid: &QualifiedGroupId,
     ) -> Result<Option<StorableDsGroupData>, StorageError> {
         let Some(group_data_record) = sqlx::query!(
-            "SELECT 
+            "SELECT
                 group_id, ciphertext, last_used, deleted_queues
-            FROM 
+            FROM
                 encrypted_groups
-            WHERE 
+            WHERE
                 group_id = $1",
             qgid.group_uuid()
         )
@@ -61,11 +61,11 @@ impl StorableDsGroupData {
 
     pub(crate) async fn update(&self, connection: impl PgExecutor<'_>) -> Result<(), StorageError> {
         sqlx::query!(
-            "UPDATE 
+            "UPDATE
                 encrypted_groups
-            SET 
+            SET
                 ciphertext = $2, last_used = $3, deleted_queues = $4
-            WHERE 
+            WHERE
                 group_id = $1",
             self.group_id,
             PhnxCodec::to_vec(&self.encrypted_group_state)?,
@@ -82,9 +82,9 @@ impl StorableDsGroupData {
         qgid: &QualifiedGroupId,
     ) -> Result<(), StorageError> {
         sqlx::query!(
-            "DELETE FROM 
+            "DELETE FROM
                 encrypted_groups
-            WHERE 
+            WHERE
                 group_id = $1",
             qgid.group_uuid()
         )
@@ -96,10 +96,7 @@ impl StorableDsGroupData {
 
 #[cfg(test)]
 mod test {
-    use phnxtypes::{
-        crypto::ear::Ciphertext,
-        identifiers::{Fqdn, QualifiedGroupId},
-    };
+    use phnxtypes::{crypto::ear::Ciphertext, identifiers::QualifiedGroupId};
     use sqlx::PgPool;
     use uuid::Uuid;
 
@@ -113,7 +110,7 @@ mod test {
 
     #[sqlx::test]
     async fn reserve_group_id(pool: PgPool) {
-        let ds = Ds::new_from_pool(pool, Fqdn::try_from("example.com").unwrap())
+        let ds = Ds::new_from_pool(pool, "example.com".parse().unwrap())
             .await
             .expect("Error creating ephemeral Ds instance.");
 
@@ -132,7 +129,7 @@ mod test {
 
     #[sqlx::test]
     async fn group_state_lifecycle(pool: PgPool) {
-        let ds = Ds::new_from_pool(pool, Fqdn::try_from("example.com").unwrap())
+        let ds = Ds::new_from_pool(pool, "example.com".parse().unwrap())
             .await
             .expect("Error creating ephemeral Ds instance.");
 

coreclient/src/clients/mod.rs

@@ -38,7 +38,6 @@ use phnxtypes::{
     },
     identifiers::{
         AsClientId, ClientConfig, QsClientId, QsClientReference, QsUserId, QualifiedUserName,
-        SafeTryInto,
     },
     messages::{
         client_as::{ConnectionPackageTbs, UserConnectionPackagesParams},
@@ -118,13 +117,12 @@ impl CoreUser {
     /// Create a new user with the given `user_name`. If a user with this name
     /// already exists, this will overwrite that user.
     pub async fn new(
-        user_name: impl SafeTryInto<QualifiedUserName>,
+        user_name: QualifiedUserName,
         password: &str,
         server_url: impl ToString,
         db_path: &str,
         push_token: Option<PushToken>,
     ) -> Result<Self> {
-        let user_name = user_name.try_into()?;
         let as_client_id = AsClientId::random(user_name)?;
         // Open the phnx db to store the client record
         let phnx_db_connection = open_phnx_db(db_path)?;
@@ -619,11 +617,7 @@ impl CoreUser {
     ///
     /// Returns the [`ConversationId`] of the newly created connection
     /// conversation.
-    pub async fn add_contact(
-        &self,
-        user_name: impl SafeTryInto<QualifiedUserName>,
-    ) -> Result<ConversationId> {
-        let user_name = user_name.try_into()?;
+    pub async fn add_contact(&self, user_name: QualifiedUserName) -> Result<ConversationId> {
         let params = UserConnectionPackagesParams {
             user_name: user_name.clone(),
         };

coreclient/src/clients/tests/mod.rs

@@ -11,10 +11,7 @@ use crate::{
     },
 };
 use phnxserver_test_harness::utils::setup::TestBackend;
-use phnxtypes::{
-    codec::PhnxCodec,
-    identifiers::{AsClientId, SafeTryInto},
-};
+use phnxtypes::{codec::PhnxCodec, identifiers::AsClientId};
 use rusqlite::Connection;
 
 #[actix_rt::test]
@@ -23,7 +20,7 @@ async fn user_stages() {
     let setup = TestBackend::single().await;
 
     let user_name = "[email protected]";
-    let as_client_id = AsClientId::random(SafeTryInto::try_into(user_name).unwrap()).unwrap();
+    let as_client_id = AsClientId::random(user_name.parse().unwrap()).unwrap();
 
     let phnx_db_connection = Connection::open_in_memory().unwrap();
     let mut client_db_connection = Connection::open_in_memory().unwrap();