app

commit cf2fdf0f1c3f51e23593a56381c638eb47dff4d9
parent 3b0a6d4ad3416807942bf3e544c5793214b32b40
Author: triesap <triesap@radroots.dev>
Date:   Tue, 20 Jan 2026 18:24:06 +0000

app: rename keystore types

- rename AppKeystoreError to RadrootsAppKeystoreError
- rename AppKeystoreResult to RadrootsAppKeystoreResult
- update init and logging references
- refresh public exports for keystore types

Diffstat:
M
app/src/init.rs
 | 
4
++--
M
app/src/keystore.rs
 | 
32
++++++++++++++++----------------
M
app/src/lib.rs
 | 
4
++--
M
app/src/logging.rs
 | 
6
+++---

4 files changed, 23 insertions(+), 23 deletions(-)
diff --git a/app/src/init.rs b/app/src/init.rs
@@ -34,7 +34,7 @@ use crate::{
     RadrootsAppConfig,
     RadrootsAppSettings,
     RadrootsAppConfigError,
-    AppKeystoreError,
+    RadrootsAppKeystoreError,
     RadrootsAppKeyMapConfig,
 };
 
@@ -404,7 +404,7 @@ pub async fn app_init_backends(config: RadrootsAppConfig) -> RadrootsAppInitResu
     let nostr_public_key = app_keystore_nostr_ensure_key(&nostr_keystore)
         .await
         .map_err(|err| match err {
-            AppKeystoreError::Keystore(inner) => RadrootsAppInitError::Keystore(inner),
+            RadrootsAppKeystoreError::Keystore(inner) => RadrootsAppInitError::Keystore(inner),
         })?;
     let key_ms = app_init_elapsed_ms(key_start);
     let _ = app_log_debug_emit(
diff --git a/app/src/keystore.rs b/app/src/keystore.rs
@@ -5,38 +5,38 @@ use radroots_app_core::keystore::{RadrootsClientKeystoreError, RadrootsClientKey
 use crate::app_log_debug_emit;
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum AppKeystoreError {
+pub enum RadrootsAppKeystoreError {
     Keystore(RadrootsClientKeystoreError),
 }
 
-pub type AppKeystoreResult<T> = Result<T, AppKeystoreError>;
+pub type RadrootsAppKeystoreResult<T> = Result<T, RadrootsAppKeystoreError>;
 
-impl AppKeystoreError {
+impl RadrootsAppKeystoreError {
     pub const fn message(&self) -> &'static str {
         match self {
-            AppKeystoreError::Keystore(err) => err.message(),
+            RadrootsAppKeystoreError::Keystore(err) => err.message(),
         }
     }
 }
 
-impl std::fmt::Display for AppKeystoreError {
+impl std::fmt::Display for RadrootsAppKeystoreError {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         f.write_str(self.message())
     }
 }
 
-impl std::error::Error for AppKeystoreError {}
+impl std::error::Error for RadrootsAppKeystoreError {}
 
-impl From<RadrootsClientKeystoreError> for AppKeystoreError {
+impl From<RadrootsClientKeystoreError> for RadrootsAppKeystoreError {
     fn from(err: RadrootsClientKeystoreError) -> Self {
-        AppKeystoreError::Keystore(err)
+        RadrootsAppKeystoreError::Keystore(err)
     }
 }
 
 pub async fn app_keystore_nostr_keys<T: RadrootsClientKeystoreNostr>(
     keystore: &T,
-) -> AppKeystoreResult<Vec<String>> {
-    let result = keystore.keys().await.map_err(AppKeystoreError::from);
+) -> RadrootsAppKeystoreResult<Vec<String>> {
+    let result = keystore.keys().await.map_err(RadrootsAppKeystoreError::from);
     let context = match &result {
         Ok(keys) => Some(format!("count={}", keys.len())),
         Err(err) => Some(err.to_string()),
@@ -47,7 +47,7 @@ pub async fn app_keystore_nostr_keys<T: RadrootsClientKeystoreNostr>(
 
 pub async fn app_keystore_nostr_public_key<T: RadrootsClientKeystoreNostr>(
     keystore: &T,
-) -> AppKeystoreResult<Option<String>> {
+) -> RadrootsAppKeystoreResult<Option<String>> {
     let _ = app_log_debug_emit("log.app.keystore.public_key", "start", None);
     match keystore.keys().await {
         Ok(mut keys) => {
@@ -57,20 +57,20 @@ pub async fn app_keystore_nostr_public_key<T: RadrootsClientKeystoreNostr>(
             Ok(key)
         }
         Err(RadrootsClientKeystoreError::NostrNoResults) => Ok(None),
-        Err(err) => Err(AppKeystoreError::from(err)),
+        Err(err) => Err(RadrootsAppKeystoreError::from(err)),
     }
 }
 
 pub async fn app_keystore_nostr_ensure_key<T: RadrootsClientKeystoreNostr>(
     keystore: &T,
-) -> AppKeystoreResult<String> {
+) -> RadrootsAppKeystoreResult<String> {
     match app_keystore_nostr_public_key(keystore).await? {
         Some(key) => {
             let _ = app_log_debug_emit("log.app.keystore.ensure", "existing", None);
             Ok(key)
         }
         None => {
-            let generated = keystore.generate().await.map_err(AppKeystoreError::from)?;
+            let generated = keystore.generate().await.map_err(RadrootsAppKeystoreError::from)?;
             let _ = app_log_debug_emit("log.app.keystore.ensure", "generated", None);
             Ok(generated)
         }
@@ -83,7 +83,7 @@ mod tests {
         app_keystore_nostr_ensure_key,
         app_keystore_nostr_public_key,
         app_keystore_nostr_keys,
-        AppKeystoreError,
+        RadrootsAppKeystoreError,
     };
     use async_trait::async_trait;
     use radroots_app_core::keystore::{
@@ -156,7 +156,7 @@ mod tests {
             .expect_err("nostr key");
         assert_eq!(
             err,
-            AppKeystoreError::Keystore(RadrootsClientKeystoreError::IdbUndefined)
+            RadrootsAppKeystoreError::Keystore(RadrootsClientKeystoreError::IdbUndefined)
         );
     }
 
diff --git a/app/src/lib.rs b/app/src/lib.rs
@@ -45,8 +45,8 @@ pub use keystore::{
     app_keystore_nostr_ensure_key,
     app_keystore_nostr_keys,
     app_keystore_nostr_public_key,
-    AppKeystoreError,
-    AppKeystoreResult,
+    RadrootsAppKeystoreError,
+    RadrootsAppKeystoreResult,
 };
 pub use logs::LogsPage;
 pub use logging::{
diff --git a/app/src/logging.rs b/app/src/logging.rs
@@ -25,7 +25,7 @@ use crate::{
     RadrootsAppConfigError,
     RadrootsAppInitAssetError,
     RadrootsAppInitError,
-    AppKeystoreError,
+    RadrootsAppKeystoreError,
     RadrootsAppKeyMapConfig,
     AppNotificationsError,
     AppTangleError,
@@ -145,14 +145,14 @@ impl AppLoggableError for RadrootsAppInitError {
     }
 }
 
-impl AppLoggableError for AppKeystoreError {
+impl AppLoggableError for RadrootsAppKeystoreError {
     fn log_code(&self) -> &'static str {
         self.message()
     }
 
     fn log_context(&self) -> Option<String> {
         match self {
-            AppKeystoreError::Keystore(err) => Some(err.to_string()),
+            RadrootsAppKeystoreError::Keystore(err) => Some(err.to_string()),
         }
     }
 }