commit 08e94556411a3e2af79956f112f345085359f621
parent 840ad351adf75d78dbf4a63649f7d308bfb206ad
Author: triesap <triesap@radroots.dev>
Date: Tue, 20 Jan 2026 18:22:29 +0000
app: rename init and context types
- rename AppInit* types with RadrootsAppInit prefix
- rename AppBackends to RadrootsAppBackends
- rename AppContext to RadrootsAppContext
- update app/init/context/logging references
Diffstat:
6 files changed, 179 insertions(+), 179 deletions(-)
diff --git a/app/src/app.rs b/app/src/app.rs
@@ -23,13 +23,13 @@ use crate::{
app_datastore_read_app_data,
app_datastore_set_notifications_permission,
app_health_check_all_logged,
- AppBackends,
+ RadrootsAppBackends,
RadrootsAppConfig,
AppHealthCheckResult,
AppHealthCheckStatus,
AppHealthReport,
- AppInitError,
- AppInitStage,
+ RadrootsAppInitError,
+ RadrootsAppInitStage,
AppNotifications,
AppTangleClientStub,
LogsPage,
@@ -62,7 +62,7 @@ fn active_key_label(value: Option<String>) -> String {
format!("{head}...{tail}")
}
-fn log_init_stage(stage: AppInitStage) {
+fn log_init_stage(stage: RadrootsAppInitStage) {
let _ = app_log_debug_emit("log.app.init.stage", stage.as_str(), None);
}
@@ -117,8 +117,8 @@ fn app_health_check_delay_ms() -> u32 {
#[component]
fn HomePage() -> impl IntoView {
- let backends = RwSignal::new_local(None::<AppBackends>);
- let init_error = RwSignal::new_local(None::<AppInitError>);
+ let backends = RwSignal::new_local(None::<RadrootsAppBackends>);
+ let init_error = RwSignal::new_local(None::<RadrootsAppInitError>);
let init_state = RwSignal::new_local(app_init_state_default());
let reset_status = RwSignal::new_local(None::<String>);
let health_report = RwSignal::new_local(AppHealthReport::empty());
@@ -132,7 +132,7 @@ fn HomePage() -> impl IntoView {
provide_context(init_state);
Effect::new(move || {
spawn_local(async move {
- let stage = AppInitStage::Storage;
+ let stage = RadrootsAppInitStage::Storage;
init_state.update(|state| app_init_stage_set(state, stage));
log_init_stage(stage);
let config = app_config_default();
@@ -159,15 +159,15 @@ fn HomePage() -> impl IntoView {
)
.await;
if let Err(err) = assets_result {
- let init_err = AppInitError::Assets(err);
+ let init_err = RadrootsAppInitError::Assets(err);
let _ = app_log_error_emit(&init_err);
init_error.set(Some(init_err));
- let stage = AppInitStage::Error;
+ let stage = RadrootsAppInitStage::Error;
init_state.update(|state| app_init_stage_set(state, stage));
log_init_stage(stage);
return;
}
- let stage = AppInitStage::Storage;
+ let stage = RadrootsAppInitStage::Storage;
init_state.update(|state| app_init_stage_set(state, stage));
log_init_stage(stage);
}
@@ -180,14 +180,14 @@ fn HomePage() -> impl IntoView {
.await;
backends.set(Some(value));
app_init_mark_completed();
- let stage = AppInitStage::Ready;
+ let stage = RadrootsAppInitStage::Ready;
init_state.update(|state| app_init_stage_set(state, stage));
log_init_stage(stage);
}
Err(err) => {
let _ = app_log_error_emit(&err);
init_error.set(Some(err));
- let stage = AppInitStage::Error;
+ let stage = RadrootsAppInitStage::Error;
init_state.update(|state| app_init_stage_set(state, stage));
log_init_stage(stage);
}
@@ -195,7 +195,7 @@ fn HomePage() -> impl IntoView {
})
});
Effect::new(move || {
- if init_state.get().stage != AppInitStage::Ready {
+ if init_state.get().stage != RadrootsAppInitStage::Ready {
return;
}
if health_autorun.get() {
@@ -219,14 +219,14 @@ fn HomePage() -> impl IntoView {
});
});
let status_color = move || match init_state.get().stage {
- AppInitStage::Ready => "green",
- AppInitStage::Error => "red",
- AppInitStage::Storage => "orange",
- AppInitStage::DownloadSql => "orange",
- AppInitStage::DownloadGeo => "orange",
- AppInitStage::Database => "orange",
- AppInitStage::Geocoder => "orange",
- AppInitStage::Idle => "gray",
+ RadrootsAppInitStage::Ready => "green",
+ RadrootsAppInitStage::Error => "red",
+ RadrootsAppInitStage::Storage => "orange",
+ RadrootsAppInitStage::DownloadSql => "orange",
+ RadrootsAppInitStage::DownloadGeo => "orange",
+ RadrootsAppInitStage::Database => "orange",
+ RadrootsAppInitStage::Geocoder => "orange",
+ RadrootsAppInitStage::Idle => "gray",
};
let reset_disabled = move || backends.with(|value| value.is_none());
let reset_label = move || {
diff --git a/app/src/bootstrap.rs b/app/src/bootstrap.rs
@@ -8,8 +8,8 @@ use crate::{
app_log_debug_emit,
RadrootsAppState,
RadrootsAppSettings,
- AppInitError,
- AppInitResult,
+ RadrootsAppInitError,
+ RadrootsAppInitResult,
RadrootsAppKeyMapConfig,
};
@@ -17,12 +17,12 @@ pub async fn app_datastore_write_config<T: RadrootsClientDatastore>(
datastore: &T,
key_maps: &RadrootsAppKeyMapConfig,
data: &RadrootsAppSettings,
-) -> AppInitResult<RadrootsAppSettings> {
- let key = app_datastore_obj_key_cfg_data(key_maps).map_err(AppInitError::Config)?;
+) -> RadrootsAppInitResult<RadrootsAppSettings> {
+ let key = app_datastore_obj_key_cfg_data(key_maps).map_err(RadrootsAppInitError::Config)?;
let value = datastore
.set_obj(key, data)
.await
- .map_err(AppInitError::Datastore)?;
+ .map_err(RadrootsAppInitError::Datastore)?;
let _ = app_log_debug_emit("log.app.bootstrap.config", "write", Some(key.to_string()));
Ok(value)
}
@@ -30,12 +30,12 @@ pub async fn app_datastore_write_config<T: RadrootsClientDatastore>(
pub async fn app_datastore_has_config<T: RadrootsClientDatastore>(
datastore: &T,
key_maps: &RadrootsAppKeyMapConfig,
-) -> AppInitResult<bool> {
- let key = app_datastore_obj_key_cfg_data(key_maps).map_err(AppInitError::Config)?;
+) -> RadrootsAppInitResult<bool> {
+ let key = app_datastore_obj_key_cfg_data(key_maps).map_err(RadrootsAppInitError::Config)?;
match datastore.get_obj::<RadrootsAppSettings>(key).await {
Ok(_) => Ok(true),
Err(RadrootsClientDatastoreError::NoResult) => Ok(false),
- Err(err) => Err(AppInitError::Datastore(err)),
+ Err(err) => Err(RadrootsAppInitError::Datastore(err)),
}
}
@@ -43,12 +43,12 @@ pub async fn app_datastore_write_app_data<T: RadrootsClientDatastore>(
datastore: &T,
key_maps: &RadrootsAppKeyMapConfig,
data: &RadrootsAppState,
-) -> AppInitResult<RadrootsAppState> {
- let key = app_datastore_obj_key_app_data(key_maps).map_err(AppInitError::Config)?;
+) -> RadrootsAppInitResult<RadrootsAppState> {
+ let key = app_datastore_obj_key_app_data(key_maps).map_err(RadrootsAppInitError::Config)?;
let value = datastore
.set_obj(key, data)
.await
- .map_err(AppInitError::Datastore)?;
+ .map_err(RadrootsAppInitError::Datastore)?;
let _ = app_log_debug_emit("log.app.bootstrap.app_data", "write", Some(key.to_string()));
Ok(value)
}
@@ -56,12 +56,12 @@ pub async fn app_datastore_write_app_data<T: RadrootsClientDatastore>(
pub async fn app_datastore_read_app_data<T: RadrootsClientDatastore>(
datastore: &T,
key_maps: &RadrootsAppKeyMapConfig,
-) -> AppInitResult<RadrootsAppState> {
- let key = app_datastore_obj_key_app_data(key_maps).map_err(AppInitError::Config)?;
+) -> RadrootsAppInitResult<RadrootsAppState> {
+ let key = app_datastore_obj_key_app_data(key_maps).map_err(RadrootsAppInitError::Config)?;
let value = datastore
.get_obj::<RadrootsAppState>(key)
.await
- .map_err(AppInitError::Datastore)?;
+ .map_err(RadrootsAppInitError::Datastore)?;
let _ = app_log_debug_emit("log.app.bootstrap.app_data", "read", Some(key.to_string()));
Ok(value)
}
@@ -69,29 +69,29 @@ pub async fn app_datastore_read_app_data<T: RadrootsClientDatastore>(
pub async fn app_datastore_has_app_data<T: RadrootsClientDatastore>(
datastore: &T,
key_maps: &RadrootsAppKeyMapConfig,
-) -> AppInitResult<bool> {
- let key = app_datastore_obj_key_app_data(key_maps).map_err(AppInitError::Config)?;
+) -> RadrootsAppInitResult<bool> {
+ let key = app_datastore_obj_key_app_data(key_maps).map_err(RadrootsAppInitError::Config)?;
match datastore.get_obj::<RadrootsAppState>(key).await {
Ok(_) => Ok(true),
Err(RadrootsClientDatastoreError::NoResult) => Ok(false),
- Err(err) => Err(AppInitError::Datastore(err)),
+ Err(err) => Err(RadrootsAppInitError::Datastore(err)),
}
}
pub async fn app_datastore_clear_bootstrap<T: RadrootsClientDatastore>(
datastore: &T,
key_maps: &RadrootsAppKeyMapConfig,
-) -> AppInitResult<()> {
- let cfg_key = app_datastore_obj_key_cfg_data(key_maps).map_err(AppInitError::Config)?;
+) -> RadrootsAppInitResult<()> {
+ let cfg_key = app_datastore_obj_key_cfg_data(key_maps).map_err(RadrootsAppInitError::Config)?;
datastore
.del_obj(cfg_key)
.await
- .map_err(AppInitError::Datastore)?;
- let app_key = app_datastore_obj_key_app_data(key_maps).map_err(AppInitError::Config)?;
+ .map_err(RadrootsAppInitError::Datastore)?;
+ let app_key = app_datastore_obj_key_app_data(key_maps).map_err(RadrootsAppInitError::Config)?;
datastore
.del_obj(app_key)
.await
- .map_err(AppInitError::Datastore)?;
+ .map_err(RadrootsAppInitError::Datastore)?;
let _ = app_log_debug_emit("log.app.bootstrap.reset", "clear", None);
Ok(())
}
@@ -100,7 +100,7 @@ pub async fn app_datastore_set_notifications_permission<T: RadrootsClientDatasto
datastore: &T,
key_maps: &RadrootsAppKeyMapConfig,
permission: &str,
-) -> AppInitResult<RadrootsAppState> {
+) -> RadrootsAppInitResult<RadrootsAppState> {
let mut data = match app_datastore_has_app_data(datastore, key_maps).await? {
true => app_datastore_read_app_data(datastore, key_maps).await?,
false => RadrootsAppState::default(),
@@ -121,7 +121,7 @@ mod tests {
app_datastore_write_app_data,
app_datastore_write_config,
};
- use crate::{app_key_maps_default, RadrootsAppState, RadrootsAppSettings, AppInitError};
+ use crate::{app_key_maps_default, RadrootsAppState, RadrootsAppSettings, RadrootsAppInitError};
use radroots_app_core::datastore::{RadrootsClientDatastoreError, RadrootsClientWebDatastore};
#[test]
@@ -135,7 +135,7 @@ mod tests {
&data,
))
.expect_err("idb undefined");
- assert_eq!(err, AppInitError::Datastore(RadrootsClientDatastoreError::IdbUndefined));
+ assert_eq!(err, RadrootsAppInitError::Datastore(RadrootsClientDatastoreError::IdbUndefined));
}
#[test]
@@ -149,7 +149,7 @@ mod tests {
&data,
))
.expect_err("idb undefined");
- assert_eq!(err, AppInitError::Datastore(RadrootsClientDatastoreError::IdbUndefined));
+ assert_eq!(err, RadrootsAppInitError::Datastore(RadrootsClientDatastoreError::IdbUndefined));
}
#[test]
@@ -161,7 +161,7 @@ mod tests {
&key_maps,
))
.expect_err("idb undefined");
- assert_eq!(err, AppInitError::Datastore(RadrootsClientDatastoreError::IdbUndefined));
+ assert_eq!(err, RadrootsAppInitError::Datastore(RadrootsClientDatastoreError::IdbUndefined));
}
#[test]
@@ -173,7 +173,7 @@ mod tests {
&key_maps,
))
.expect_err("idb undefined");
- assert_eq!(err, AppInitError::Datastore(RadrootsClientDatastoreError::IdbUndefined));
+ assert_eq!(err, RadrootsAppInitError::Datastore(RadrootsClientDatastoreError::IdbUndefined));
}
#[test]
@@ -182,7 +182,7 @@ mod tests {
let key_maps = app_key_maps_default();
let err = futures::executor::block_on(app_datastore_has_config(&datastore, &key_maps))
.expect_err("idb undefined");
- assert_eq!(err, AppInitError::Datastore(RadrootsClientDatastoreError::IdbUndefined));
+ assert_eq!(err, RadrootsAppInitError::Datastore(RadrootsClientDatastoreError::IdbUndefined));
}
#[test]
@@ -191,7 +191,7 @@ mod tests {
let key_maps = app_key_maps_default();
let err = futures::executor::block_on(app_datastore_has_app_data(&datastore, &key_maps))
.expect_err("idb undefined");
- assert_eq!(err, AppInitError::Datastore(RadrootsClientDatastoreError::IdbUndefined));
+ assert_eq!(err, RadrootsAppInitError::Datastore(RadrootsClientDatastoreError::IdbUndefined));
}
#[test]
@@ -204,6 +204,6 @@ mod tests {
"granted",
))
.expect_err("idb undefined");
- assert_eq!(err, AppInitError::Datastore(RadrootsClientDatastoreError::IdbUndefined));
+ assert_eq!(err, RadrootsAppInitError::Datastore(RadrootsClientDatastoreError::IdbUndefined));
}
}
diff --git a/app/src/context.rs b/app/src/context.rs
@@ -2,27 +2,27 @@
use leptos::prelude::{use_context, LocalStorage, RwSignal};
-use crate::{AppBackends, AppInitError, AppInitState};
+use crate::{RadrootsAppBackends, RadrootsAppInitError, RadrootsAppInitState};
#[derive(Clone)]
-pub struct AppContext {
- pub backends: RwSignal<Option<AppBackends>, LocalStorage>,
- pub init_error: RwSignal<Option<AppInitError>, LocalStorage>,
- pub init_state: RwSignal<AppInitState, LocalStorage>,
+pub struct RadrootsAppContext {
+ pub backends: RwSignal<Option<RadrootsAppBackends>, LocalStorage>,
+ pub init_error: RwSignal<Option<RadrootsAppInitError>, LocalStorage>,
+ pub init_state: RwSignal<RadrootsAppInitState, LocalStorage>,
}
-pub fn app_context() -> Option<AppContext> {
- Some(AppContext {
- backends: use_context::<RwSignal<Option<AppBackends>, LocalStorage>>()?,
- init_error: use_context::<RwSignal<Option<AppInitError>, LocalStorage>>()?,
- init_state: use_context::<RwSignal<AppInitState, LocalStorage>>()?,
+pub fn app_context() -> Option<RadrootsAppContext> {
+ Some(RadrootsAppContext {
+ backends: use_context::<RwSignal<Option<RadrootsAppBackends>, LocalStorage>>()?,
+ init_error: use_context::<RwSignal<Option<RadrootsAppInitError>, LocalStorage>>()?,
+ init_state: use_context::<RwSignal<RadrootsAppInitState, LocalStorage>>()?,
})
}
#[cfg(test)]
mod tests {
use super::app_context;
- use crate::{app_init_state_default, AppBackends, AppInitError, AppInitStage};
+ use crate::{app_init_state_default, RadrootsAppBackends, RadrootsAppInitError, RadrootsAppInitStage};
use leptos::prelude::{provide_context, Owner, RwSignal, WithUntracked};
#[test]
@@ -36,8 +36,8 @@ mod tests {
fn app_context_reads_provided_signals() {
let owner = Owner::new();
owner.set();
- let backends = RwSignal::new_local(None::<AppBackends>);
- let init_error = RwSignal::new_local(None::<AppInitError>);
+ let backends = RwSignal::new_local(None::<RadrootsAppBackends>);
+ let init_error = RwSignal::new_local(None::<RadrootsAppInitError>);
let init_state = RwSignal::new_local(app_init_state_default());
provide_context(backends);
provide_context(init_error);
@@ -47,7 +47,7 @@ mod tests {
assert!(context.init_error.with_untracked(|value| value.is_none()));
assert_eq!(
context.init_state.with_untracked(|state| state.stage),
- AppInitStage::Idle
+ RadrootsAppInitStage::Idle
);
}
}
diff --git a/app/src/init.rs b/app/src/init.rs
@@ -56,7 +56,7 @@ use std::time::Instant;
pub const APP_INIT_STORAGE_KEY: &str = "radroots.app.init.ready";
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum AppInitStage {
+pub enum RadrootsAppInitStage {
Idle,
Storage,
DownloadSql,
@@ -67,62 +67,62 @@ pub enum AppInitStage {
Error,
}
-impl AppInitStage {
+impl RadrootsAppInitStage {
pub const fn as_str(self) -> &'static str {
match self {
- AppInitStage::Idle => "idle",
- AppInitStage::Storage => "storage",
- AppInitStage::DownloadSql => "download_sql",
- AppInitStage::DownloadGeo => "download_geo",
- AppInitStage::Database => "database",
- AppInitStage::Geocoder => "geocoder",
- AppInitStage::Ready => "ready",
- AppInitStage::Error => "error",
+ RadrootsAppInitStage::Idle => "idle",
+ RadrootsAppInitStage::Storage => "storage",
+ RadrootsAppInitStage::DownloadSql => "download_sql",
+ RadrootsAppInitStage::DownloadGeo => "download_geo",
+ RadrootsAppInitStage::Database => "database",
+ RadrootsAppInitStage::Geocoder => "geocoder",
+ RadrootsAppInitStage::Ready => "ready",
+ RadrootsAppInitStage::Error => "error",
}
}
pub fn parse(value: &str) -> Option<Self> {
match value {
- "idle" => Some(AppInitStage::Idle),
- "storage" => Some(AppInitStage::Storage),
- "download_sql" => Some(AppInitStage::DownloadSql),
- "download_geo" => Some(AppInitStage::DownloadGeo),
- "database" => Some(AppInitStage::Database),
- "geocoder" => Some(AppInitStage::Geocoder),
- "ready" => Some(AppInitStage::Ready),
- "error" => Some(AppInitStage::Error),
+ "idle" => Some(RadrootsAppInitStage::Idle),
+ "storage" => Some(RadrootsAppInitStage::Storage),
+ "download_sql" => Some(RadrootsAppInitStage::DownloadSql),
+ "download_geo" => Some(RadrootsAppInitStage::DownloadGeo),
+ "database" => Some(RadrootsAppInitStage::Database),
+ "geocoder" => Some(RadrootsAppInitStage::Geocoder),
+ "ready" => Some(RadrootsAppInitStage::Ready),
+ "error" => Some(RadrootsAppInitStage::Error),
_ => None,
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct AppInitState {
- pub stage: AppInitStage,
+pub struct RadrootsAppInitState {
+ pub stage: RadrootsAppInitStage,
pub loaded_bytes: u64,
pub total_bytes: Option<u64>,
}
-pub const fn app_init_state_default() -> AppInitState {
- AppInitState {
- stage: AppInitStage::Idle,
+pub const fn app_init_state_default() -> RadrootsAppInitState {
+ RadrootsAppInitState {
+ stage: RadrootsAppInitStage::Idle,
loaded_bytes: 0,
total_bytes: Some(0),
}
}
-pub fn app_init_stage_set(state: &mut AppInitState, stage: AppInitStage) {
+pub fn app_init_stage_set(state: &mut RadrootsAppInitState, stage: RadrootsAppInitStage) {
state.stage = stage;
}
-pub fn app_init_progress_add(state: &mut AppInitState, bytes: u64) {
+pub fn app_init_progress_add(state: &mut RadrootsAppInitState, bytes: u64) {
if bytes == 0 {
return;
}
state.loaded_bytes = state.loaded_bytes.saturating_add(bytes);
}
-pub fn app_init_total_add(state: &mut AppInitState, bytes: u64) {
+pub fn app_init_total_add(state: &mut RadrootsAppInitState, bytes: u64) {
if bytes == 0 {
return;
}
@@ -132,7 +132,7 @@ pub fn app_init_total_add(state: &mut AppInitState, bytes: u64) {
state.total_bytes = Some(total.saturating_add(bytes));
}
-pub fn app_init_total_unknown(state: &mut AppInitState) {
+pub fn app_init_total_unknown(state: &mut RadrootsAppInitState) {
state.total_bytes = None;
}
@@ -162,12 +162,12 @@ fn app_init_timing_context(label: &str, elapsed_ms: u64) -> String {
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub struct AppInitAssetProgress {
+pub struct RadrootsAppInitAssetProgress {
pub loaded_bytes: u64,
pub total_bytes: Option<u64>,
}
-impl AppInitAssetProgress {
+impl RadrootsAppInitAssetProgress {
pub const fn empty() -> Self {
Self {
loaded_bytes: 0,
@@ -177,60 +177,60 @@ impl AppInitAssetProgress {
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum AppInitAssetError {
+pub enum RadrootsAppInitAssetError {
MissingUrl,
FetchUnavailable,
FetchFailed,
}
-impl AppInitAssetError {
+impl RadrootsAppInitAssetError {
pub const fn message(self) -> &'static str {
match self {
- AppInitAssetError::MissingUrl => "error.app.init.asset_missing_url",
- AppInitAssetError::FetchUnavailable => "error.app.init.asset_unavailable",
- AppInitAssetError::FetchFailed => "error.app.init.asset_fetch_failed",
+ RadrootsAppInitAssetError::MissingUrl => "error.app.init.asset_missing_url",
+ RadrootsAppInitAssetError::FetchUnavailable => "error.app.init.asset_unavailable",
+ RadrootsAppInitAssetError::FetchFailed => "error.app.init.asset_fetch_failed",
}
}
}
-impl fmt::Display for AppInitAssetError {
+impl fmt::Display for RadrootsAppInitAssetError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str(self.message())
}
}
-impl std::error::Error for AppInitAssetError {}
+impl std::error::Error for RadrootsAppInitAssetError {}
#[cfg(target_arch = "wasm32")]
pub async fn app_init_fetch_asset<F>(
url: &str,
mut on_progress: F,
-) -> Result<AppInitAssetProgress, AppInitAssetError>
+) -> Result<RadrootsAppInitAssetProgress, RadrootsAppInitAssetError>
where
F: FnMut(u64, Option<u64>),
{
if url.is_empty() {
- return Err(AppInitAssetError::MissingUrl);
+ return Err(RadrootsAppInitAssetError::MissingUrl);
}
let response_value = JsFuture::from(window().fetch_with_str(url))
.await
- .map_err(|_| AppInitAssetError::FetchFailed)?;
+ .map_err(|_| RadrootsAppInitAssetError::FetchFailed)?;
let response: Response = response_value
.dyn_into()
- .map_err(|_| AppInitAssetError::FetchFailed)?;
+ .map_err(|_| RadrootsAppInitAssetError::FetchFailed)?;
let total_bytes = response
.headers()
.get("content-length")
.ok()
.flatten()
.and_then(|value| value.parse::<u64>().ok());
- let buffer_value = JsFuture::from(response.array_buffer().map_err(|_| AppInitAssetError::FetchFailed)?)
+ let buffer_value = JsFuture::from(response.array_buffer().map_err(|_| RadrootsAppInitAssetError::FetchFailed)?)
.await
- .map_err(|_| AppInitAssetError::FetchFailed)?;
+ .map_err(|_| RadrootsAppInitAssetError::FetchFailed)?;
let buffer = Uint8Array::new(&buffer_value);
let loaded_bytes = buffer.length() as u64;
on_progress(loaded_bytes, total_bytes);
- Ok(AppInitAssetProgress {
+ Ok(RadrootsAppInitAssetProgress {
loaded_bytes,
total_bytes,
})
@@ -240,68 +240,68 @@ where
pub async fn app_init_fetch_asset<F>(
url: &str,
_on_progress: F,
-) -> Result<AppInitAssetProgress, AppInitAssetError>
+) -> Result<RadrootsAppInitAssetProgress, RadrootsAppInitAssetError>
where
F: FnMut(u64, Option<u64>),
{
if url.is_empty() {
- return Err(AppInitAssetError::MissingUrl);
+ return Err(RadrootsAppInitAssetError::MissingUrl);
}
- Err(AppInitAssetError::FetchUnavailable)
+ Err(RadrootsAppInitAssetError::FetchUnavailable)
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum AppInitError {
+pub enum RadrootsAppInitError {
Idb(RadrootsClientIdbStoreError),
Datastore(RadrootsClientDatastoreError),
Keystore(RadrootsClientKeystoreError),
Config(RadrootsAppConfigError),
- Assets(AppInitAssetError),
+ Assets(RadrootsAppInitAssetError),
}
-pub type AppInitErrorMessage = &'static str;
+pub type RadrootsAppInitErrorMessage = &'static str;
-impl AppInitError {
- pub const fn message(&self) -> AppInitErrorMessage {
+impl RadrootsAppInitError {
+ pub const fn message(&self) -> RadrootsAppInitErrorMessage {
match self {
- AppInitError::Idb(_) => "error.app.init.idb",
- AppInitError::Datastore(_) => "error.app.init.datastore",
- AppInitError::Keystore(_) => "error.app.init.keystore",
- AppInitError::Config(_) => "error.app.init.config",
- AppInitError::Assets(_) => "error.app.init.assets",
+ RadrootsAppInitError::Idb(_) => "error.app.init.idb",
+ RadrootsAppInitError::Datastore(_) => "error.app.init.datastore",
+ RadrootsAppInitError::Keystore(_) => "error.app.init.keystore",
+ RadrootsAppInitError::Config(_) => "error.app.init.config",
+ RadrootsAppInitError::Assets(_) => "error.app.init.assets",
}
}
}
-impl fmt::Display for AppInitError {
+impl fmt::Display for RadrootsAppInitError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str(self.message())
}
}
-impl std::error::Error for AppInitError {}
+impl std::error::Error for RadrootsAppInitError {}
-pub struct AppBackends {
+pub struct RadrootsAppBackends {
pub config: RadrootsAppConfig,
pub datastore: RadrootsClientWebDatastore,
pub nostr_keystore: RadrootsClientWebKeystoreNostr,
}
-pub type AppInitResult<T> = Result<T, AppInitError>;
+pub type RadrootsAppInitResult<T> = Result<T, RadrootsAppInitError>;
pub async fn app_init_assets<F, G>(
config: &RadrootsAppConfig,
mut on_stage: F,
mut on_progress: G,
-) -> Result<(), AppInitAssetError>
+) -> Result<(), RadrootsAppInitAssetError>
where
- F: FnMut(AppInitStage),
+ F: FnMut(RadrootsAppInitStage),
G: FnMut(u64, Option<u64>),
{
let _ = app_log_debug_emit("log.app.init.assets", "start", None);
if let Some(url) = app_assets_sql_wasm_url(config).filter(|value| !value.is_empty()) {
let _ = app_log_debug_emit("log.app.init.assets.sql", "download_start", Some(url.to_string()));
- on_stage(AppInitStage::DownloadSql);
+ on_stage(RadrootsAppInitStage::DownloadSql);
app_init_fetch_asset(url, |loaded, total| {
on_progress(loaded, total);
})
@@ -310,7 +310,7 @@ where
}
if let Some(url) = app_assets_geocoder_db_url(config).filter(|value| !value.is_empty()) {
let _ = app_log_debug_emit("log.app.init.assets.geo", "download_start", Some(url.to_string()));
- on_stage(AppInitStage::DownloadGeo);
+ on_stage(RadrootsAppInitStage::DownloadGeo);
app_init_fetch_asset(url, |loaded, total| {
on_progress(loaded, total);
})
@@ -353,13 +353,13 @@ pub async fn app_init_reset<T: RadrootsClientDatastore, K: RadrootsClientKeystor
datastore: Option<&T>,
key_maps: Option<&RadrootsAppKeyMapConfig>,
keystore: Option<&K>,
-) -> AppInitResult<()> {
+) -> RadrootsAppInitResult<()> {
let _ = app_log_debug_emit("log.app.init.reset", "start", None);
if let (Some(datastore), Some(key_maps)) = (datastore, key_maps) {
app_datastore_clear_bootstrap(datastore, key_maps).await?;
}
if let Some(keystore) = keystore {
- keystore.reset().await.map_err(AppInitError::Keystore)?;
+ keystore.reset().await.map_err(RadrootsAppInitError::Keystore)?;
}
#[cfg(target_arch = "wasm32")]
{
@@ -372,13 +372,13 @@ pub async fn app_init_reset<T: RadrootsClientDatastore, K: RadrootsClientKeystor
Ok(())
}
-pub async fn app_init_backends(config: RadrootsAppConfig) -> AppInitResult<AppBackends> {
+pub async fn app_init_backends(config: RadrootsAppConfig) -> RadrootsAppInitResult<RadrootsAppBackends> {
let _ = app_log_debug_emit("log.app.init.backends", "start", None);
- config.validate().map_err(AppInitError::Config)?;
+ config.validate().map_err(RadrootsAppInitError::Config)?;
let idb_start = app_init_timer_start();
idb_store_bootstrap(RADROOTS_IDB_DATABASE, None)
.await
- .map_err(AppInitError::Idb)?;
+ .map_err(RadrootsAppInitError::Idb)?;
let idb_ms = app_init_elapsed_ms(idb_start);
let _ = app_log_debug_emit(
"log.app.init.backends",
@@ -389,7 +389,7 @@ pub async fn app_init_backends(config: RadrootsAppConfig) -> AppInitResult<AppBa
datastore
.init()
.await
- .map_err(AppInitError::Datastore)?;
+ .map_err(RadrootsAppInitError::Datastore)?;
let _ = app_log_debug_emit("log.app.init.backends", "datastore_ready", None);
let has_config = app_datastore_has_config(&datastore, &config.datastore.key_maps).await?;
if !has_config {
@@ -404,7 +404,7 @@ pub async fn app_init_backends(config: RadrootsAppConfig) -> AppInitResult<AppBa
let nostr_public_key = app_keystore_nostr_ensure_key(&nostr_keystore)
.await
.map_err(|err| match err {
- AppKeystoreError::Keystore(inner) => AppInitError::Keystore(inner),
+ AppKeystoreError::Keystore(inner) => RadrootsAppInitError::Keystore(inner),
})?;
let key_ms = app_init_elapsed_ms(key_start);
let _ = app_log_debug_emit(
@@ -413,23 +413,23 @@ pub async fn app_init_backends(config: RadrootsAppConfig) -> AppInitResult<AppBa
Some(app_init_timing_context("elapsed", key_ms)),
);
let nostr_key =
- app_datastore_key_nostr_key(&config.datastore.key_maps).map_err(AppInitError::Config)?;
+ app_datastore_key_nostr_key(&config.datastore.key_maps).map_err(RadrootsAppInitError::Config)?;
match datastore.get(nostr_key).await {
Ok(existing) => {
if existing != nostr_public_key {
let _ = datastore
.set(nostr_key, &nostr_public_key)
.await
- .map_err(AppInitError::Datastore)?;
+ .map_err(RadrootsAppInitError::Datastore)?;
}
}
Err(RadrootsClientDatastoreError::NoResult) => {
let _ = datastore
.set(nostr_key, &nostr_public_key)
.await
- .map_err(AppInitError::Datastore)?;
+ .map_err(RadrootsAppInitError::Datastore)?;
}
- Err(err) => return Err(AppInitError::Datastore(err)),
+ Err(err) => return Err(RadrootsAppInitError::Datastore(err)),
}
let _ = app_log_debug_emit("log.app.init.backends", "nostr_key_synced", None);
let has_app_data = app_datastore_has_app_data(&datastore, &config.datastore.key_maps).await?;
@@ -446,7 +446,7 @@ pub async fn app_init_backends(config: RadrootsAppConfig) -> AppInitResult<AppBa
.await?;
}
let _ = app_log_debug_emit("log.app.init.backends", "app_data_ready", None);
- Ok(AppBackends {
+ Ok(RadrootsAppBackends {
config,
datastore,
nostr_keystore,
@@ -464,10 +464,10 @@ mod tests {
app_init_stage_set,
app_init_total_add,
app_init_total_unknown,
- AppInitError,
- AppInitErrorMessage,
- AppInitStage,
- AppInitAssetError,
+ RadrootsAppInitError,
+ RadrootsAppInitErrorMessage,
+ RadrootsAppInitStage,
+ RadrootsAppInitAssetError,
};
use crate::{app_config_default, RadrootsAppConfig};
use radroots_app_core::datastore::RadrootsClientDatastoreError;
@@ -482,25 +482,25 @@ mod tests {
#[test]
fn app_init_error_messages_match_spec() {
- let cases: &[(AppInitError, AppInitErrorMessage)] = &[
+ let cases: &[(RadrootsAppInitError, RadrootsAppInitErrorMessage)] = &[
(
- AppInitError::Idb(RadrootsClientIdbStoreError::IdbUndefined),
+ RadrootsAppInitError::Idb(RadrootsClientIdbStoreError::IdbUndefined),
"error.app.init.idb",
),
(
- AppInitError::Datastore(RadrootsClientDatastoreError::IdbUndefined),
+ RadrootsAppInitError::Datastore(RadrootsClientDatastoreError::IdbUndefined),
"error.app.init.datastore",
),
(
- AppInitError::Keystore(RadrootsClientKeystoreError::IdbUndefined),
+ RadrootsAppInitError::Keystore(RadrootsClientKeystoreError::IdbUndefined),
"error.app.init.keystore",
),
(
- AppInitError::Config(RadrootsAppConfigError::MissingKeyMap("nostr_key")),
+ RadrootsAppInitError::Config(RadrootsAppConfigError::MissingKeyMap("nostr_key")),
"error.app.init.config",
),
(
- AppInitError::Assets(AppInitAssetError::FetchUnavailable),
+ RadrootsAppInitError::Assets(RadrootsAppInitAssetError::FetchUnavailable),
"error.app.init.assets",
),
];
@@ -518,7 +518,7 @@ mod tests {
};
assert_eq!(
err,
- AppInitError::Idb(RadrootsClientIdbStoreError::IdbUndefined)
+ RadrootsAppInitError::Idb(RadrootsClientIdbStoreError::IdbUndefined)
);
}
@@ -582,22 +582,22 @@ mod tests {
.expect_err("keystore reset should error on native");
assert_eq!(
err,
- AppInitError::Keystore(RadrootsClientKeystoreError::IdbUndefined)
+ RadrootsAppInitError::Keystore(RadrootsClientKeystoreError::IdbUndefined)
);
}
#[test]
fn app_init_stage_roundtrip() {
- let stage = AppInitStage::Ready;
+ let stage = RadrootsAppInitStage::Ready;
assert_eq!(stage.as_str(), "ready");
- assert_eq!(AppInitStage::parse("ready"), Some(stage));
- assert_eq!(AppInitStage::parse("unknown"), None);
+ assert_eq!(RadrootsAppInitStage::parse("ready"), Some(stage));
+ assert_eq!(RadrootsAppInitStage::parse("unknown"), None);
}
#[test]
fn app_init_state_defaults_match_spec() {
let state = app_init_state_default();
- assert_eq!(state.stage, AppInitStage::Idle);
+ assert_eq!(state.stage, RadrootsAppInitStage::Idle);
assert_eq!(state.loaded_bytes, 0);
assert_eq!(state.total_bytes, Some(0));
}
@@ -605,8 +605,8 @@ mod tests {
#[test]
fn app_init_progress_helpers_update_state() {
let mut state = app_init_state_default();
- app_init_stage_set(&mut state, AppInitStage::Storage);
- assert_eq!(state.stage, AppInitStage::Storage);
+ app_init_stage_set(&mut state, RadrootsAppInitStage::Storage);
+ assert_eq!(state.stage, RadrootsAppInitStage::Storage);
app_init_progress_add(&mut state, 0);
assert_eq!(state.loaded_bytes, 0);
app_init_progress_add(&mut state, 5);
@@ -644,6 +644,6 @@ mod tests {
|_loaded, _total| {},
))
.expect_err("asset fetch should error on native");
- assert_eq!(result, AppInitAssetError::FetchUnavailable);
+ assert_eq!(result, RadrootsAppInitAssetError::FetchUnavailable);
}
}
diff --git a/app/src/lib.rs b/app/src/lib.rs
@@ -24,7 +24,7 @@ pub use bootstrap::{
app_datastore_write_app_data,
app_datastore_write_config,
};
-pub use context::{app_context, AppContext};
+pub use context::{app_context, RadrootsAppContext};
pub use data::{RadrootsAppState, RadrootsAppSettings, RadrootsAppRole};
pub use health::{
app_health_check_all,
@@ -138,13 +138,13 @@ pub use init::{
app_init_stage_set,
app_init_total_add,
app_init_total_unknown,
- AppBackends,
- AppInitAssetError,
- AppInitAssetProgress,
- AppInitError,
- AppInitErrorMessage,
- AppInitResult,
- AppInitStage,
- AppInitState,
+ RadrootsAppBackends,
+ RadrootsAppInitAssetError,
+ RadrootsAppInitAssetProgress,
+ RadrootsAppInitError,
+ RadrootsAppInitErrorMessage,
+ RadrootsAppInitResult,
+ RadrootsAppInitStage,
+ RadrootsAppInitState,
APP_INIT_STORAGE_KEY,
};
diff --git a/app/src/logging.rs b/app/src/logging.rs
@@ -23,8 +23,8 @@ use radroots_app_core::datastore::{RadrootsClientDatastore, RadrootsClientDatast
use crate::{
app_datastore_param_key,
RadrootsAppConfigError,
- AppInitAssetError,
- AppInitError,
+ RadrootsAppInitAssetError,
+ RadrootsAppInitError,
AppKeystoreError,
RadrootsAppKeyMapConfig,
AppNotificationsError,
@@ -108,7 +108,7 @@ pub trait AppLoggableError: std::fmt::Display {
}
}
-impl AppLoggableError for AppInitAssetError {
+impl AppLoggableError for RadrootsAppInitAssetError {
fn log_code(&self) -> &'static str {
self.message()
}
@@ -129,18 +129,18 @@ impl AppLoggableError for RadrootsAppConfigError {
}
}
-impl AppLoggableError for AppInitError {
+impl AppLoggableError for RadrootsAppInitError {
fn log_code(&self) -> &'static str {
self.message()
}
fn log_context(&self) -> Option<String> {
match self {
- AppInitError::Idb(err) => Some(err.to_string()),
- AppInitError::Datastore(err) => Some(err.to_string()),
- AppInitError::Keystore(err) => Some(err.to_string()),
- AppInitError::Config(err) => err.log_context().or_else(|| Some(err.message().to_string())),
- AppInitError::Assets(err) => Some(err.message().to_string()),
+ RadrootsAppInitError::Idb(err) => Some(err.to_string()),
+ RadrootsAppInitError::Datastore(err) => Some(err.to_string()),
+ RadrootsAppInitError::Keystore(err) => Some(err.to_string()),
+ RadrootsAppInitError::Config(err) => err.log_context().or_else(|| Some(err.message().to_string())),
+ RadrootsAppInitError::Assets(err) => Some(err.message().to_string()),
}
}
}
