commit 840ad351adf75d78dbf4a63649f7d308bfb206ad
parent 5b87bfabc89a573da22950dfbb2875479ceb78b8
Author: triesap <triesap@radroots.dev>
Date: Tue, 20 Jan 2026 18:20:30 +0000
app: rename app config types
- rename AppConfig to RadrootsAppConfig
- rename App*Config helpers and key map types
- update config error/result naming across modules
- adjust exports and tests for config renames
Diffstat:
7 files changed, 161 insertions(+), 161 deletions(-)
diff --git a/app/src/app.rs b/app/src/app.rs
@@ -24,7 +24,7 @@ use crate::{
app_datastore_set_notifications_permission,
app_health_check_all_logged,
AppBackends,
- AppConfig,
+ RadrootsAppConfig,
AppHealthCheckResult,
AppHealthCheckStatus,
AppHealthReport,
@@ -67,7 +67,7 @@ fn log_init_stage(stage: AppInitStage) {
}
fn spawn_health_checks(
- config: AppConfig,
+ config: RadrootsAppConfig,
health_report: RwSignal<AppHealthReport, LocalStorage>,
health_running: RwSignal<bool, LocalStorage>,
active_key: RwSignal<Option<String>, LocalStorage>,
diff --git a/app/src/bootstrap.rs b/app/src/bootstrap.rs
@@ -10,12 +10,12 @@ use crate::{
RadrootsAppSettings,
AppInitError,
AppInitResult,
- AppKeyMapConfig,
+ RadrootsAppKeyMapConfig,
};
pub async fn app_datastore_write_config<T: RadrootsClientDatastore>(
datastore: &T,
- key_maps: &AppKeyMapConfig,
+ key_maps: &RadrootsAppKeyMapConfig,
data: &RadrootsAppSettings,
) -> AppInitResult<RadrootsAppSettings> {
let key = app_datastore_obj_key_cfg_data(key_maps).map_err(AppInitError::Config)?;
@@ -29,7 +29,7 @@ pub async fn app_datastore_write_config<T: RadrootsClientDatastore>(
pub async fn app_datastore_has_config<T: RadrootsClientDatastore>(
datastore: &T,
- key_maps: &AppKeyMapConfig,
+ key_maps: &RadrootsAppKeyMapConfig,
) -> AppInitResult<bool> {
let key = app_datastore_obj_key_cfg_data(key_maps).map_err(AppInitError::Config)?;
match datastore.get_obj::<RadrootsAppSettings>(key).await {
@@ -41,7 +41,7 @@ pub async fn app_datastore_has_config<T: RadrootsClientDatastore>(
pub async fn app_datastore_write_app_data<T: RadrootsClientDatastore>(
datastore: &T,
- key_maps: &AppKeyMapConfig,
+ key_maps: &RadrootsAppKeyMapConfig,
data: &RadrootsAppState,
) -> AppInitResult<RadrootsAppState> {
let key = app_datastore_obj_key_app_data(key_maps).map_err(AppInitError::Config)?;
@@ -55,7 +55,7 @@ pub async fn app_datastore_write_app_data<T: RadrootsClientDatastore>(
pub async fn app_datastore_read_app_data<T: RadrootsClientDatastore>(
datastore: &T,
- key_maps: &AppKeyMapConfig,
+ key_maps: &RadrootsAppKeyMapConfig,
) -> AppInitResult<RadrootsAppState> {
let key = app_datastore_obj_key_app_data(key_maps).map_err(AppInitError::Config)?;
let value = datastore
@@ -68,7 +68,7 @@ pub async fn app_datastore_read_app_data<T: RadrootsClientDatastore>(
pub async fn app_datastore_has_app_data<T: RadrootsClientDatastore>(
datastore: &T,
- key_maps: &AppKeyMapConfig,
+ key_maps: &RadrootsAppKeyMapConfig,
) -> AppInitResult<bool> {
let key = app_datastore_obj_key_app_data(key_maps).map_err(AppInitError::Config)?;
match datastore.get_obj::<RadrootsAppState>(key).await {
@@ -80,7 +80,7 @@ pub async fn app_datastore_has_app_data<T: RadrootsClientDatastore>(
pub async fn app_datastore_clear_bootstrap<T: RadrootsClientDatastore>(
datastore: &T,
- key_maps: &AppKeyMapConfig,
+ key_maps: &RadrootsAppKeyMapConfig,
) -> AppInitResult<()> {
let cfg_key = app_datastore_obj_key_cfg_data(key_maps).map_err(AppInitError::Config)?;
datastore
@@ -98,7 +98,7 @@ pub async fn app_datastore_clear_bootstrap<T: RadrootsClientDatastore>(
pub async fn app_datastore_set_notifications_permission<T: RadrootsClientDatastore>(
datastore: &T,
- key_maps: &AppKeyMapConfig,
+ key_maps: &RadrootsAppKeyMapConfig,
permission: &str,
) -> AppInitResult<RadrootsAppState> {
let mut data = match app_datastore_has_app_data(datastore, key_maps).await? {
diff --git a/app/src/config.rs b/app/src/config.rs
@@ -8,11 +8,11 @@ use radroots_app_core::idb::{
IDB_CONFIG_KEYSTORE_NOSTR,
};
-pub type AppDatastoreKeyParam = fn(&str) -> String;
-pub type AppDatastoreKeyMap = BTreeMap<&'static str, &'static str>;
-pub type AppDatastoreKeyParamMap = BTreeMap<&'static str, AppDatastoreKeyParam>;
-pub type AppDatastoreKeyObjMap = BTreeMap<&'static str, &'static str>;
-pub type AppKeystoreKeyMap = BTreeMap<&'static str, &'static str>;
+pub type RadrootsAppDatastoreKeyParam = fn(&str) -> String;
+pub type RadrootsAppDatastoreKeyMap = BTreeMap<&'static str, &'static str>;
+pub type RadrootsAppDatastoreKeyParamMap = BTreeMap<&'static str, RadrootsAppDatastoreKeyParam>;
+pub type RadrootsAppDatastoreKeyObjMap = BTreeMap<&'static str, &'static str>;
+pub type RadrootsAppKeystoreKeyMap = BTreeMap<&'static str, &'static str>;
pub const APP_DATASTORE_KEY_NOSTR_KEY: &str = "nostr:key";
pub const APP_DATASTORE_KEY_EULA_DATE: &str = "app:eula:date";
@@ -34,13 +34,13 @@ pub fn app_datastore_param_log_entry(entry_id: &str) -> String {
}
#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct AppKeyMapConfig {
- pub key_map: AppDatastoreKeyMap,
- pub param_map: AppDatastoreKeyParamMap,
- pub obj_map: AppDatastoreKeyObjMap,
+pub struct RadrootsAppKeyMapConfig {
+ pub key_map: RadrootsAppDatastoreKeyMap,
+ pub param_map: RadrootsAppDatastoreKeyParamMap,
+ pub obj_map: RadrootsAppDatastoreKeyObjMap,
}
-impl AppKeyMapConfig {
+impl RadrootsAppKeyMapConfig {
pub fn empty() -> Self {
Self {
key_map: BTreeMap::new(),
@@ -50,21 +50,21 @@ impl AppKeyMapConfig {
}
}
-pub fn app_key_maps_default() -> AppKeyMapConfig {
+pub fn app_key_maps_default() -> RadrootsAppKeyMapConfig {
let mut key_map = BTreeMap::new();
key_map.insert("nostr_key", APP_DATASTORE_KEY_NOSTR_KEY);
key_map.insert("eula_date", APP_DATASTORE_KEY_EULA_DATE);
let mut param_map = BTreeMap::new();
- param_map.insert("nostr_profile", app_datastore_param_nostr_profile as AppDatastoreKeyParam);
+ param_map.insert("nostr_profile", app_datastore_param_nostr_profile as RadrootsAppDatastoreKeyParam);
param_map.insert(
"radroots_profile",
- app_datastore_param_radroots_profile as AppDatastoreKeyParam,
+ app_datastore_param_radroots_profile as RadrootsAppDatastoreKeyParam,
);
- param_map.insert("log_entry", app_datastore_param_log_entry as AppDatastoreKeyParam);
+ param_map.insert("log_entry", app_datastore_param_log_entry as RadrootsAppDatastoreKeyParam);
let mut obj_map = BTreeMap::new();
obj_map.insert("cfg_data", APP_DATASTORE_KEY_OBJ_CFG_DATA);
obj_map.insert("app_data", APP_DATASTORE_KEY_OBJ_APP_DATA);
- AppKeyMapConfig {
+ RadrootsAppKeyMapConfig {
key_map,
param_map,
obj_map,
@@ -72,133 +72,133 @@ pub fn app_key_maps_default() -> AppKeyMapConfig {
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum AppConfigError {
+pub enum RadrootsAppConfigError {
MissingKeyMap(&'static str),
MissingParamMap(&'static str),
MissingObjMap(&'static str),
MissingKeystoreKeyMap(&'static str),
}
-pub type AppConfigResult<T> = Result<T, AppConfigError>;
+pub type RadrootsAppConfigResult<T> = Result<T, RadrootsAppConfigError>;
-impl AppConfigError {
+impl RadrootsAppConfigError {
pub const fn message(&self) -> &'static str {
match self {
- AppConfigError::MissingKeyMap(_) => "error.app.config.key_map_missing",
- AppConfigError::MissingParamMap(_) => "error.app.config.param_map_missing",
- AppConfigError::MissingObjMap(_) => "error.app.config.obj_map_missing",
- AppConfigError::MissingKeystoreKeyMap(_) => "error.app.config.keystore_map_missing",
+ RadrootsAppConfigError::MissingKeyMap(_) => "error.app.config.key_map_missing",
+ RadrootsAppConfigError::MissingParamMap(_) => "error.app.config.param_map_missing",
+ RadrootsAppConfigError::MissingObjMap(_) => "error.app.config.obj_map_missing",
+ RadrootsAppConfigError::MissingKeystoreKeyMap(_) => "error.app.config.keystore_map_missing",
}
}
}
-impl std::fmt::Display for AppConfigError {
+impl std::fmt::Display for RadrootsAppConfigError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str(self.message())
}
}
-impl std::error::Error for AppConfigError {}
+impl std::error::Error for RadrootsAppConfigError {}
-pub fn app_key_maps_validate(config: &AppKeyMapConfig) -> AppConfigResult<()> {
+pub fn app_key_maps_validate(config: &RadrootsAppKeyMapConfig) -> RadrootsAppConfigResult<()> {
if !config.key_map.contains_key("nostr_key") {
- return Err(AppConfigError::MissingKeyMap("nostr_key"));
+ return Err(RadrootsAppConfigError::MissingKeyMap("nostr_key"));
}
if !config.key_map.contains_key("eula_date") {
- return Err(AppConfigError::MissingKeyMap("eula_date"));
+ return Err(RadrootsAppConfigError::MissingKeyMap("eula_date"));
}
if !config.param_map.contains_key("nostr_profile") {
- return Err(AppConfigError::MissingParamMap("nostr_profile"));
+ return Err(RadrootsAppConfigError::MissingParamMap("nostr_profile"));
}
if !config.param_map.contains_key("radroots_profile") {
- return Err(AppConfigError::MissingParamMap("radroots_profile"));
+ return Err(RadrootsAppConfigError::MissingParamMap("radroots_profile"));
}
if !config.param_map.contains_key("log_entry") {
- return Err(AppConfigError::MissingParamMap("log_entry"));
+ return Err(RadrootsAppConfigError::MissingParamMap("log_entry"));
}
if !config.obj_map.contains_key("cfg_data") {
- return Err(AppConfigError::MissingObjMap("cfg_data"));
+ return Err(RadrootsAppConfigError::MissingObjMap("cfg_data"));
}
if !config.obj_map.contains_key("app_data") {
- return Err(AppConfigError::MissingObjMap("app_data"));
+ return Err(RadrootsAppConfigError::MissingObjMap("app_data"));
}
Ok(())
}
-pub fn app_keystore_key_maps_validate(config: &AppKeystoreKeyMap) -> AppConfigResult<()> {
+pub fn app_keystore_key_maps_validate(config: &RadrootsAppKeystoreKeyMap) -> RadrootsAppConfigResult<()> {
if !config.contains_key("nostr_default") {
- return Err(AppConfigError::MissingKeystoreKeyMap("nostr_default"));
+ return Err(RadrootsAppConfigError::MissingKeystoreKeyMap("nostr_default"));
}
Ok(())
}
-pub fn app_datastore_key(config: &AppKeyMapConfig, key: &'static str) -> AppConfigResult<&'static str> {
+pub fn app_datastore_key(config: &RadrootsAppKeyMapConfig, key: &'static str) -> RadrootsAppConfigResult<&'static str> {
config
.key_map
.get(key)
.copied()
- .ok_or(AppConfigError::MissingKeyMap(key))
+ .ok_or(RadrootsAppConfigError::MissingKeyMap(key))
}
pub fn app_datastore_obj_key(
- config: &AppKeyMapConfig,
+ config: &RadrootsAppKeyMapConfig,
key: &'static str,
-) -> AppConfigResult<&'static str> {
+) -> RadrootsAppConfigResult<&'static str> {
config
.obj_map
.get(key)
.copied()
- .ok_or(AppConfigError::MissingObjMap(key))
+ .ok_or(RadrootsAppConfigError::MissingObjMap(key))
}
pub fn app_datastore_param_key(
- config: &AppKeyMapConfig,
+ config: &RadrootsAppKeyMapConfig,
key: &'static str,
-) -> AppConfigResult<AppDatastoreKeyParam> {
+) -> RadrootsAppConfigResult<RadrootsAppDatastoreKeyParam> {
config
.param_map
.get(key)
.copied()
- .ok_or(AppConfigError::MissingParamMap(key))
+ .ok_or(RadrootsAppConfigError::MissingParamMap(key))
}
-pub fn app_datastore_key_nostr_key(config: &AppKeyMapConfig) -> AppConfigResult<&'static str> {
+pub fn app_datastore_key_nostr_key(config: &RadrootsAppKeyMapConfig) -> RadrootsAppConfigResult<&'static str> {
app_datastore_key(config, "nostr_key")
}
-pub fn app_datastore_key_eula_date(config: &AppKeyMapConfig) -> AppConfigResult<&'static str> {
+pub fn app_datastore_key_eula_date(config: &RadrootsAppKeyMapConfig) -> RadrootsAppConfigResult<&'static str> {
app_datastore_key(config, "eula_date")
}
-pub fn app_datastore_obj_key_cfg_data(config: &AppKeyMapConfig) -> AppConfigResult<&'static str> {
+pub fn app_datastore_obj_key_cfg_data(config: &RadrootsAppKeyMapConfig) -> RadrootsAppConfigResult<&'static str> {
app_datastore_obj_key(config, "cfg_data")
}
-pub fn app_datastore_obj_key_app_data(config: &AppKeyMapConfig) -> AppConfigResult<&'static str> {
+pub fn app_datastore_obj_key_app_data(config: &RadrootsAppKeyMapConfig) -> RadrootsAppConfigResult<&'static str> {
app_datastore_obj_key(config, "app_data")
}
pub fn app_keystore_key(
- config: &AppKeystoreKeyMap,
+ config: &RadrootsAppKeystoreKeyMap,
key: &'static str,
-) -> AppConfigResult<&'static str> {
+) -> RadrootsAppConfigResult<&'static str> {
config
.get(key)
.copied()
- .ok_or(AppConfigError::MissingKeystoreKeyMap(key))
+ .ok_or(RadrootsAppConfigError::MissingKeystoreKeyMap(key))
}
-pub fn app_keystore_key_nostr_default(config: &AppKeystoreKeyMap) -> AppConfigResult<&'static str> {
+pub fn app_keystore_key_nostr_default(config: &RadrootsAppKeystoreKeyMap) -> RadrootsAppConfigResult<&'static str> {
app_keystore_key(config, "nostr_default")
}
#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct AppKeystoreConfig {
+pub struct RadrootsAppKeystoreConfig {
pub nostr_store: RadrootsClientIdbConfig,
- pub key_map: AppKeystoreKeyMap,
+ pub key_map: RadrootsAppKeystoreKeyMap,
}
-impl AppKeystoreConfig {
+impl RadrootsAppKeystoreConfig {
pub fn default_config() -> Self {
Self {
nostr_store: IDB_CONFIG_KEYSTORE_NOSTR,
@@ -207,20 +207,20 @@ impl AppKeystoreConfig {
}
}
-pub fn app_keystore_key_maps_default() -> AppKeystoreKeyMap {
+pub fn app_keystore_key_maps_default() -> RadrootsAppKeystoreKeyMap {
let mut map = BTreeMap::new();
map.insert("nostr_default", APP_KEYSTORE_KEY_NOSTR_DEFAULT);
map
}
#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct AppDatastoreConfig {
+pub struct RadrootsAppDatastoreConfig {
pub idb_config: RadrootsClientIdbConfig,
- pub key_maps: AppKeyMapConfig,
+ pub key_maps: RadrootsAppKeyMapConfig,
}
-impl AppDatastoreConfig {
- pub fn default_config(key_maps: AppKeyMapConfig) -> Self {
+impl RadrootsAppDatastoreConfig {
+ pub fn default_config(key_maps: RadrootsAppKeyMapConfig) -> Self {
Self {
idb_config: IDB_CONFIG_DATASTORE,
key_maps,
@@ -229,56 +229,56 @@ impl AppDatastoreConfig {
}
#[derive(Debug, Clone, PartialEq, Eq, Default)]
-pub struct AppAssetConfig {
+pub struct RadrootsAppAssetConfig {
pub sql_wasm_url: Option<String>,
pub geocoder_db_url: Option<String>,
}
-pub fn app_assets_sql_wasm_url(config: &AppConfig) -> Option<&str> {
+pub fn app_assets_sql_wasm_url(config: &RadrootsAppConfig) -> Option<&str> {
config.assets.sql_wasm_url.as_deref()
}
-pub fn app_assets_geocoder_db_url(config: &AppConfig) -> Option<&str> {
+pub fn app_assets_geocoder_db_url(config: &RadrootsAppConfig) -> Option<&str> {
config.assets.geocoder_db_url.as_deref()
}
#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct AppConfig {
- pub datastore: AppDatastoreConfig,
- pub keystore: AppKeystoreConfig,
- pub assets: AppAssetConfig,
+pub struct RadrootsAppConfig {
+ pub datastore: RadrootsAppDatastoreConfig,
+ pub keystore: RadrootsAppKeystoreConfig,
+ pub assets: RadrootsAppAssetConfig,
}
-impl AppConfig {
+impl RadrootsAppConfig {
pub fn empty() -> Self {
- let key_maps = AppKeyMapConfig::empty();
+ let key_maps = RadrootsAppKeyMapConfig::empty();
Self {
- datastore: AppDatastoreConfig::default_config(key_maps),
- keystore: AppKeystoreConfig::default_config(),
- assets: AppAssetConfig::default(),
+ datastore: RadrootsAppDatastoreConfig::default_config(key_maps),
+ keystore: RadrootsAppKeystoreConfig::default_config(),
+ assets: RadrootsAppAssetConfig::default(),
}
}
- pub fn from_key_maps(key_maps: AppKeyMapConfig) -> Self {
+ pub fn from_key_maps(key_maps: RadrootsAppKeyMapConfig) -> Self {
Self {
- datastore: AppDatastoreConfig::default_config(key_maps),
- keystore: AppKeystoreConfig::default_config(),
- assets: AppAssetConfig::default(),
+ datastore: RadrootsAppDatastoreConfig::default_config(key_maps),
+ keystore: RadrootsAppKeystoreConfig::default_config(),
+ assets: RadrootsAppAssetConfig::default(),
}
}
- pub fn validate(&self) -> AppConfigResult<()> {
+ pub fn validate(&self) -> RadrootsAppConfigResult<()> {
app_key_maps_validate(&self.datastore.key_maps)?;
app_keystore_key_maps_validate(&self.keystore.key_map)?;
Ok(())
}
}
-pub fn app_config_default() -> AppConfig {
- AppConfig::from_key_maps(app_key_maps_default())
+pub fn app_config_default() -> RadrootsAppConfig {
+ RadrootsAppConfig::from_key_maps(app_key_maps_default())
}
-pub fn app_config_from_env() -> AppConfig {
+pub fn app_config_from_env() -> RadrootsAppConfig {
app_config_default()
}
@@ -301,13 +301,13 @@ mod tests {
app_datastore_param_key,
app_assets_geocoder_db_url,
app_assets_sql_wasm_url,
- AppAssetConfig,
- AppConfig,
- AppConfigError,
- AppDatastoreConfig,
- AppKeyMapConfig,
- AppKeystoreConfig,
- AppKeystoreKeyMap,
+ RadrootsAppAssetConfig,
+ RadrootsAppConfig,
+ RadrootsAppConfigError,
+ RadrootsAppDatastoreConfig,
+ RadrootsAppKeyMapConfig,
+ RadrootsAppKeystoreConfig,
+ RadrootsAppKeystoreKeyMap,
APP_DATASTORE_KEY_EULA_DATE,
APP_DATASTORE_KEY_NOSTR_KEY,
APP_DATASTORE_KEY_OBJ_APP_DATA,
@@ -320,7 +320,7 @@ mod tests {
#[test]
fn key_map_config_defaults_empty() {
- let config = AppKeyMapConfig::empty();
+ let config = RadrootsAppKeyMapConfig::empty();
assert!(config.key_map.is_empty());
assert!(config.param_map.is_empty());
assert!(config.obj_map.is_empty());
@@ -328,7 +328,7 @@ mod tests {
#[test]
fn app_config_defaults_empty() {
- let config = AppConfig::empty();
+ let config = RadrootsAppConfig::empty();
assert!(config.datastore.key_maps.key_map.is_empty());
}
@@ -347,13 +347,13 @@ mod tests {
fn app_config_validate_uses_key_map_rules() {
let config = app_config_default();
assert!(config.validate().is_ok());
- let empty = AppConfig::empty();
+ let empty = RadrootsAppConfig::empty();
assert!(empty.validate().is_err());
}
#[test]
fn keystore_config_defaults_to_nostr_store() {
- let config = AppKeystoreConfig::default_config();
+ let config = RadrootsAppKeystoreConfig::default_config();
assert_eq!(config.nostr_store, IDB_CONFIG_KEYSTORE_NOSTR);
}
@@ -368,15 +368,15 @@ mod tests {
#[test]
fn asset_config_defaults_empty() {
- let config = AppAssetConfig::default();
+ let config = RadrootsAppAssetConfig::default();
assert!(config.sql_wasm_url.is_none());
assert!(config.geocoder_db_url.is_none());
}
#[test]
fn datastore_config_defaults_to_idb_store() {
- let key_maps = AppKeyMapConfig::empty();
- let config = AppDatastoreConfig::default_config(key_maps);
+ let key_maps = RadrootsAppKeyMapConfig::empty();
+ let config = RadrootsAppDatastoreConfig::default_config(key_maps);
assert_eq!(config.idb_config, IDB_CONFIG_DATASTORE);
assert!(config.key_maps.key_map.is_empty());
}
@@ -411,20 +411,20 @@ mod tests {
fn key_map_validation_requires_expected_keys() {
let config = super::app_key_maps_default();
assert!(app_key_maps_validate(&config).is_ok());
- let mut missing = AppKeyMapConfig::empty();
+ let mut missing = RadrootsAppKeyMapConfig::empty();
missing.key_map.insert("nostr_key", APP_DATASTORE_KEY_NOSTR_KEY);
let err = app_key_maps_validate(&missing).expect_err("missing keys");
- assert_eq!(err, AppConfigError::MissingKeyMap("eula_date"));
+ assert_eq!(err, RadrootsAppConfigError::MissingKeyMap("eula_date"));
}
#[test]
fn keystore_map_validation_requires_expected_keys() {
let map = app_keystore_key_maps_default();
assert!(app_keystore_key_maps_validate(&map).is_ok());
- let empty: AppKeystoreKeyMap = BTreeMap::new();
+ let empty: RadrootsAppKeystoreKeyMap = BTreeMap::new();
let err = app_keystore_key_maps_validate(&empty)
.expect_err("missing keys");
- assert_eq!(err, AppConfigError::MissingKeystoreKeyMap("nostr_default"));
+ assert_eq!(err, RadrootsAppConfigError::MissingKeystoreKeyMap("nostr_default"));
}
#[test]
diff --git a/app/src/health.rs b/app/src/health.rs
@@ -92,7 +92,7 @@ use crate::{
AppNotifications,
AppLogLevel,
AppTangleClient,
- AppKeyMapConfig,
+ RadrootsAppKeyMapConfig,
};
use radroots_app_core::notifications::RadrootsClientNotificationsPermission;
use radroots_app_core::datastore::{RadrootsClientDatastore, RadrootsClientDatastoreError};
@@ -119,7 +119,7 @@ fn log_health_end(name: &str, result: &AppHealthCheckResult) {
}
}
-pub fn app_health_check_key_maps(key_maps: &AppKeyMapConfig) -> AppHealthCheckResult {
+pub fn app_health_check_key_maps(key_maps: &RadrootsAppKeyMapConfig) -> AppHealthCheckResult {
match app_key_maps_validate(key_maps) {
Ok(()) => AppHealthCheckResult::ok(),
Err(err) => AppHealthCheckResult::error(err.to_string()),
@@ -128,7 +128,7 @@ pub fn app_health_check_key_maps(key_maps: &AppKeyMapConfig) -> AppHealthCheckRe
pub async fn app_health_check_bootstrap_config<T: RadrootsClientDatastore>(
datastore: &T,
- key_maps: &AppKeyMapConfig,
+ key_maps: &RadrootsAppKeyMapConfig,
) -> AppHealthCheckResult {
match app_datastore_has_config(datastore, key_maps).await {
Ok(true) => AppHealthCheckResult::ok(),
@@ -139,7 +139,7 @@ pub async fn app_health_check_bootstrap_config<T: RadrootsClientDatastore>(
pub async fn app_health_check_bootstrap_app_data<T: RadrootsClientDatastore>(
datastore: &T,
- key_maps: &AppKeyMapConfig,
+ key_maps: &RadrootsAppKeyMapConfig,
) -> AppHealthCheckResult {
match app_datastore_has_app_data(datastore, key_maps).await {
Ok(true) => AppHealthCheckResult::ok(),
@@ -150,7 +150,7 @@ pub async fn app_health_check_bootstrap_app_data<T: RadrootsClientDatastore>(
pub async fn app_health_check_app_data_active_key<T: RadrootsClientDatastore>(
datastore: &T,
- key_maps: &AppKeyMapConfig,
+ key_maps: &RadrootsAppKeyMapConfig,
) -> AppHealthCheckResult {
let app_data = match app_datastore_read_app_data(datastore, key_maps).await {
Ok(value) => value,
@@ -241,7 +241,7 @@ pub async fn app_health_check_datastore_roundtrip<T: RadrootsClientDatastore>(
pub async fn app_health_check_keystore_access<T: RadrootsClientDatastore, K: RadrootsClientKeystoreNostr>(
datastore: &T,
keystore: &K,
- key_maps: &AppKeyMapConfig,
+ key_maps: &RadrootsAppKeyMapConfig,
) -> AppHealthCheckResult {
let key_name = match app_datastore_key_nostr_key(key_maps) {
Ok(value) => value,
@@ -266,7 +266,7 @@ pub async fn app_health_check_all<T: RadrootsClientDatastore, K: RadrootsClientK
keystore: &K,
notifications: &AppNotifications,
tangle: &G,
- key_maps: &AppKeyMapConfig,
+ key_maps: &RadrootsAppKeyMapConfig,
) -> AppHealthReport {
log_health_start("key_maps");
let key_maps_result = app_health_check_key_maps(key_maps);
@@ -315,7 +315,7 @@ pub async fn app_health_check_all_logged<T: RadrootsClientDatastore, K: Radroots
keystore: &K,
notifications: &AppNotifications,
tangle: &G,
- key_maps: &AppKeyMapConfig,
+ key_maps: &RadrootsAppKeyMapConfig,
) -> AppHealthReport {
let report = app_health_check_all(datastore, keystore, notifications, tangle, key_maps).await;
let _ = app_log_buffer_flush_critical(datastore, key_maps).await;
@@ -343,7 +343,7 @@ mod tests {
AppHealthReport,
};
use crate::app_log_buffer_drain;
- use crate::AppKeyMapConfig;
+ use crate::RadrootsAppKeyMapConfig;
use async_trait::async_trait;
use radroots_app_core::datastore::{
RadrootsClientDatastore,
@@ -405,7 +405,7 @@ mod tests {
#[test]
fn health_check_key_maps_reports_errors() {
- let empty = AppKeyMapConfig::empty();
+ let empty = RadrootsAppKeyMapConfig::empty();
let result = app_health_check_key_maps(&empty);
assert_eq!(result.status, AppHealthCheckStatus::Error);
assert_eq!(
diff --git a/app/src/init.rs b/app/src/init.rs
@@ -31,11 +31,11 @@ use crate::{
app_keystore_nostr_ensure_key,
app_log_debug_emit,
RadrootsAppState,
- AppConfig,
+ RadrootsAppConfig,
RadrootsAppSettings,
- AppConfigError,
+ RadrootsAppConfigError,
AppKeystoreError,
- AppKeyMapConfig,
+ RadrootsAppKeyMapConfig,
};
#[cfg(target_arch = "wasm32")]
@@ -255,7 +255,7 @@ pub enum AppInitError {
Idb(RadrootsClientIdbStoreError),
Datastore(RadrootsClientDatastoreError),
Keystore(RadrootsClientKeystoreError),
- Config(AppConfigError),
+ Config(RadrootsAppConfigError),
Assets(AppInitAssetError),
}
@@ -282,7 +282,7 @@ impl fmt::Display for AppInitError {
impl std::error::Error for AppInitError {}
pub struct AppBackends {
- pub config: AppConfig,
+ pub config: RadrootsAppConfig,
pub datastore: RadrootsClientWebDatastore,
pub nostr_keystore: RadrootsClientWebKeystoreNostr,
}
@@ -290,7 +290,7 @@ pub struct AppBackends {
pub type AppInitResult<T> = Result<T, AppInitError>;
pub async fn app_init_assets<F, G>(
- config: &AppConfig,
+ config: &RadrootsAppConfig,
mut on_stage: F,
mut on_progress: G,
) -> Result<(), AppInitAssetError>
@@ -351,7 +351,7 @@ pub fn app_init_mark_completed() {
pub async fn app_init_reset<T: RadrootsClientDatastore, K: RadrootsClientKeystoreNostr>(
datastore: Option<&T>,
- key_maps: Option<&AppKeyMapConfig>,
+ key_maps: Option<&RadrootsAppKeyMapConfig>,
keystore: Option<&K>,
) -> AppInitResult<()> {
let _ = app_log_debug_emit("log.app.init.reset", "start", None);
@@ -372,7 +372,7 @@ pub async fn app_init_reset<T: RadrootsClientDatastore, K: RadrootsClientKeystor
Ok(())
}
-pub async fn app_init_backends(config: AppConfig) -> AppInitResult<AppBackends> {
+pub async fn app_init_backends(config: RadrootsAppConfig) -> AppInitResult<AppBackends> {
let _ = app_log_debug_emit("log.app.init.backends", "start", None);
config.validate().map_err(AppInitError::Config)?;
let idb_start = app_init_timer_start();
@@ -469,7 +469,7 @@ mod tests {
AppInitStage,
AppInitAssetError,
};
- use crate::{app_config_default, AppConfig};
+ use crate::{app_config_default, RadrootsAppConfig};
use radroots_app_core::datastore::RadrootsClientDatastoreError;
use radroots_app_core::idb::RadrootsClientIdbStoreError;
use radroots_app_core::keystore::{
@@ -478,7 +478,7 @@ mod tests {
RadrootsClientKeystoreResult,
};
use async_trait::async_trait;
- use crate::AppConfigError;
+ use crate::RadrootsAppConfigError;
#[test]
fn app_init_error_messages_match_spec() {
@@ -496,7 +496,7 @@ mod tests {
"error.app.init.keystore",
),
(
- AppInitError::Config(AppConfigError::MissingKeyMap("nostr_key")),
+ AppInitError::Config(RadrootsAppConfigError::MissingKeyMap("nostr_key")),
"error.app.init.config",
),
(
@@ -636,7 +636,7 @@ mod tests {
#[test]
fn app_init_assets_reports_unavailable_on_native() {
- let mut config = AppConfig::empty();
+ let mut config = RadrootsAppConfig::empty();
config.assets.sql_wasm_url = Some("http://example.com/sql.wasm".to_string());
let result = futures::executor::block_on(app_init_assets(
&config,
diff --git a/app/src/lib.rs b/app/src/lib.rs
@@ -107,18 +107,18 @@ pub use config::{
app_keystore_key_nostr_default,
app_key_maps_default,
app_key_maps_validate,
- AppConfig,
- AppConfigError,
- AppConfigResult,
- AppAssetConfig,
- AppDatastoreConfig,
- AppDatastoreKeyMap,
- AppDatastoreKeyObjMap,
- AppDatastoreKeyParam,
- AppDatastoreKeyParamMap,
- AppKeystoreConfig,
- AppKeystoreKeyMap,
- AppKeyMapConfig,
+ RadrootsAppConfig,
+ RadrootsAppConfigError,
+ RadrootsAppConfigResult,
+ RadrootsAppAssetConfig,
+ RadrootsAppDatastoreConfig,
+ RadrootsAppDatastoreKeyMap,
+ RadrootsAppDatastoreKeyObjMap,
+ RadrootsAppDatastoreKeyParam,
+ RadrootsAppDatastoreKeyParamMap,
+ RadrootsAppKeystoreConfig,
+ RadrootsAppKeystoreKeyMap,
+ RadrootsAppKeyMapConfig,
APP_DATASTORE_KEY_EULA_DATE,
APP_DATASTORE_KEY_LOG_ENTRY,
APP_DATASTORE_KEY_NOSTR_KEY,
diff --git a/app/src/logging.rs b/app/src/logging.rs
@@ -22,11 +22,11 @@ use radroots_app_core::datastore::{RadrootsClientDatastore, RadrootsClientDatast
use crate::{
app_datastore_param_key,
- AppConfigError,
+ RadrootsAppConfigError,
AppInitAssetError,
AppInitError,
AppKeystoreError,
- AppKeyMapConfig,
+ RadrootsAppKeyMapConfig,
AppNotificationsError,
AppTangleError,
};
@@ -114,17 +114,17 @@ impl AppLoggableError for AppInitAssetError {
}
}
-impl AppLoggableError for AppConfigError {
+impl AppLoggableError for RadrootsAppConfigError {
fn log_code(&self) -> &'static str {
self.message()
}
fn log_context(&self) -> Option<String> {
match self {
- AppConfigError::MissingKeyMap(key) => Some(format!("key_map={key}")),
- AppConfigError::MissingParamMap(key) => Some(format!("param_map={key}")),
- AppConfigError::MissingObjMap(key) => Some(format!("obj_map={key}")),
- AppConfigError::MissingKeystoreKeyMap(key) => Some(format!("keystore_map={key}")),
+ RadrootsAppConfigError::MissingKeyMap(key) => Some(format!("key_map={key}")),
+ RadrootsAppConfigError::MissingParamMap(key) => Some(format!("param_map={key}")),
+ RadrootsAppConfigError::MissingObjMap(key) => Some(format!("obj_map={key}")),
+ RadrootsAppConfigError::MissingKeystoreKeyMap(key) => Some(format!("keystore_map={key}")),
}
}
}
@@ -177,7 +177,7 @@ impl AppLoggableError for AppTangleError {
#[derive(Debug)]
pub enum AppLogError {
- Config(AppConfigError),
+ Config(RadrootsAppConfigError),
Datastore(RadrootsClientDatastoreError),
}
@@ -194,8 +194,8 @@ impl std::fmt::Display for AppLogError {
impl std::error::Error for AppLogError {}
-impl From<AppConfigError> for AppLogError {
- fn from(err: AppConfigError) -> Self {
+impl From<RadrootsAppConfigError> for AppLogError {
+ fn from(err: RadrootsAppConfigError) -> Self {
AppLogError::Config(err)
}
}
@@ -298,7 +298,7 @@ pub fn app_log_warn_emit(code: &str, message: &str, context: Option<String>) ->
}
pub fn app_log_entry_key(
- key_maps: &AppKeyMapConfig,
+ key_maps: &RadrootsAppKeyMapConfig,
entry_id: &str,
) -> AppLogResult<String> {
let param = app_datastore_param_key(key_maps, "log_entry")?;
@@ -307,7 +307,7 @@ pub fn app_log_entry_key(
pub async fn app_log_entry_store<T: RadrootsClientDatastore>(
datastore: &T,
- key_maps: &AppKeyMapConfig,
+ key_maps: &RadrootsAppKeyMapConfig,
entry: &AppLogEntry,
) -> AppLogResult<AppLogEntry> {
let key = app_log_entry_key(key_maps, &entry.id)?;
@@ -319,7 +319,7 @@ pub async fn app_log_entry_store<T: RadrootsClientDatastore>(
pub async fn app_log_error_store<T: RadrootsClientDatastore, E: AppLoggableError>(
datastore: &T,
- key_maps: &AppKeyMapConfig,
+ key_maps: &RadrootsAppKeyMapConfig,
err: &E,
) -> AppLogResult<AppLogEntry> {
let entry = app_log_error_emit(err);
@@ -369,7 +369,7 @@ fn app_log_entry_should_persist(level: AppLogLevel) -> bool {
pub async fn app_log_buffer_flush<T: RadrootsClientDatastore>(
datastore: &T,
- key_maps: &AppKeyMapConfig,
+ key_maps: &RadrootsAppKeyMapConfig,
) -> AppLogResult<usize> {
let entries = app_log_buffer_drain();
let mut stored = 0;
@@ -390,7 +390,7 @@ pub async fn app_log_buffer_flush<T: RadrootsClientDatastore>(
pub async fn app_log_buffer_flush_critical<T: RadrootsClientDatastore>(
datastore: &T,
- key_maps: &AppKeyMapConfig,
+ key_maps: &RadrootsAppKeyMapConfig,
) -> AppLogResult<usize> {
let entries = app_log_buffer_drain();
let mut keep = Vec::new();
@@ -424,14 +424,14 @@ pub async fn app_log_buffer_flush_critical<T: RadrootsClientDatastore>(
Ok(stored)
}
-pub fn app_log_entry_prefix(key_maps: &AppKeyMapConfig) -> AppLogResult<String> {
+pub fn app_log_entry_prefix(key_maps: &RadrootsAppKeyMapConfig) -> AppLogResult<String> {
let param = app_datastore_param_key(key_maps, "log_entry")?;
Ok(param(""))
}
pub async fn app_log_entries_load<T: RadrootsClientDatastore>(
datastore: &T,
- key_maps: &AppKeyMapConfig,
+ key_maps: &RadrootsAppKeyMapConfig,
) -> AppLogResult<Vec<AppLogEntry>> {
let entries = datastore.entries().await.map_err(AppLogError::Datastore)?;
let prefix = app_log_entry_prefix(key_maps)?;
@@ -452,7 +452,7 @@ pub async fn app_log_entries_load<T: RadrootsClientDatastore>(
pub async fn app_log_entries_clear<T: RadrootsClientDatastore>(
datastore: &T,
- key_maps: &AppKeyMapConfig,
+ key_maps: &RadrootsAppKeyMapConfig,
) -> AppLogResult<usize> {
let prefix = app_log_entry_prefix(key_maps)?;
let removed = datastore
@@ -478,7 +478,7 @@ pub fn app_log_entries_dump(entries: &[AppLogEntry]) -> String {
pub async fn app_log_entries_prune<T: RadrootsClientDatastore>(
datastore: &T,
- key_maps: &AppKeyMapConfig,
+ key_maps: &RadrootsAppKeyMapConfig,
max_entries: usize,
) -> AppLogResult<usize> {
let mut entries = app_log_entries_load(datastore, key_maps).await?;
@@ -569,7 +569,7 @@ mod tests {
};
use crate::{
app_key_maps_default,
- AppConfigError,
+ RadrootsAppConfigError,
APP_DATASTORE_KEY_LOG_ENTRY,
};
use async_trait::async_trait;
@@ -751,7 +751,7 @@ mod tests {
#[test]
fn log_entry_error_includes_context() {
- let err = AppConfigError::MissingKeyMap("nostr_key");
+ let err = RadrootsAppConfigError::MissingKeyMap("nostr_key");
let entry = app_log_entry_error(&err);
assert_eq!(entry.level, AppLogLevel::Error);
assert_eq!(entry.code, err.message());
