Initial public release

src/error.rs

@@ -0,0 +1,153 @@
+use axum::{
+    response::{IntoResponse, Response},
+    http::StatusCode,
+};
+use std::fmt;
+use std::path::PathBuf;
+
+/// Structured error type for database initialization and migration failures.
+///
+/// Each variant provides actionable context about what went wrong during startup,
+/// making diagnosis possible from logs alone without needing a debugger.
+#[derive(Debug)]
+pub enum DatabaseInitError {
+    /// Data directory could not be created or accessed
+    DataDirCreate { path: PathBuf, source: std::io::Error },
+    /// SQLite connection could not be opened
+    ConnectionOpen { database: String, path: PathBuf, source: rusqlite::Error },
+    /// PRAGMA configuration failed (WAL, foreign_keys, etc.)
+    PragmaConfig { database: String, pragma: String, source: rusqlite::Error },
+    /// Migration execution failed
+    MigrationFailed { database: String, version: u32, name: String, source: Box<dyn std::error::Error + Send + Sync> },
+    /// Database integrity check failed
+    IntegrityCheckFailed { database: String, message: String },
+    /// WAL mode could not be enabled (returned unexpected mode)
+    WalModeFailed { database: String, actual_mode: String },
+}
+
+impl fmt::Display for DatabaseInitError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::DataDirCreate { path, source } => {
+                write!(f, "Failed to create data directory {:?}: {}", path, source)
+            }
+            Self::ConnectionOpen { database, path, source } => {
+                write!(f, "Failed to open {}.db at {:?}: {}", database, path, source)
+            }
+            Self::PragmaConfig { database, pragma, source } => {
+                write!(f, "PRAGMA {} failed on {}.db: {}", pragma, database, source)
+            }
+            Self::MigrationFailed { database, version, name, source } => {
+                write!(f, "Migration v{} ({}) failed on {}.db: {}", version, name, database, source)
+            }
+            Self::IntegrityCheckFailed { database, message } => {
+                write!(f, "Integrity check failed on {}.db: {}", database, message)
+            }
+            Self::WalModeFailed { database, actual_mode } => {
+                write!(f, "WAL mode not enabled on {}.db (got '{}')", database, actual_mode)
+            }
+        }
+    }
+}
+
+impl std::error::Error for DatabaseInitError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        match self {
+            Self::DataDirCreate { source, .. } => Some(source),
+            Self::ConnectionOpen { source, .. } => Some(source),
+            Self::PragmaConfig { source, .. } => Some(source),
+            Self::MigrationFailed { source, .. } => Some(source.as_ref()),
+            _ => None,
+        }
+    }
+}
+
+#[derive(Debug)]
+pub enum AppError {
+    Db(rusqlite::Error),
+    Auth(String),
+    Template(askama::Error),
+    Json(serde_json::Error),
+    Io(std::io::Error),
+    Http(String),
+    NotFound(String),
+    BadRequest(String),
+    Unauthorized(String),
+    Internal(String),
+}
+
+impl fmt::Display for AppError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            AppError::Db(e) => write!(f, "Database error: {}", e),
+            AppError::Auth(e) => write!(f, "Authentication error: {}", e),
+            AppError::Template(e) => write!(f, "Template render error: {}", e),
+            AppError::Json(e) => write!(f, "JSON processing error: {}", e),
+            AppError::Io(e) => write!(f, "IO error: {}", e),
+            AppError::Http(e) => write!(f, "HTTP request error: {}", e),
+            AppError::NotFound(e) => write!(f, "Not found: {}", e),
+            AppError::BadRequest(e) => write!(f, "Bad request: {}", e),
+            AppError::Unauthorized(e) => write!(f, "Unauthorized: {}", e),
+            AppError::Internal(e) => write!(f, "Internal error: {}", e),
+        }
+    }
+}
+
+impl std::error::Error for AppError {}
+
+impl From<rusqlite::Error> for AppError {
+    fn from(err: rusqlite::Error) -> Self {
+        AppError::Db(err)
+    }
+}
+
+impl From<askama::Error> for AppError {
+    fn from(err: askama::Error) -> Self {
+        AppError::Template(err)
+    }
+}
+
+impl From<serde_json::Error> for AppError {
+    fn from(err: serde_json::Error) -> Self {
+        AppError::Json(err)
+    }
+}
+
+impl From<std::io::Error> for AppError {
+    fn from(err: std::io::Error) -> Self {
+        AppError::Io(err)
+    }
+}
+
+impl From<argon2::password_hash::Error> for AppError {
+    fn from(err: argon2::password_hash::Error) -> Self {
+        AppError::Auth(err.to_string())
+    }
+}
+
+impl From<reqwest::Error> for AppError {
+    fn from(err: reqwest::Error) -> Self {
+        AppError::Http(err.to_string())
+    }
+}
+
+impl IntoResponse for AppError {
+    fn into_response(self) -> Response {
+        let status = match &self {
+            AppError::NotFound(_) => StatusCode::NOT_FOUND,
+            AppError::BadRequest(_) => StatusCode::BAD_REQUEST,
+            AppError::Unauthorized(_) => StatusCode::UNAUTHORIZED,
+            AppError::Auth(_) => StatusCode::UNAUTHORIZED,
+            _ => StatusCode::INTERNAL_SERVER_ERROR,
+        };
+
+        let message = self.to_string();
+        if status == StatusCode::INTERNAL_SERVER_ERROR {
+            tracing::error!("AppError encountered: {:?}", self);
+        }
+
+        // Return error details as text. Handlers requiring custom UI/JSON can catch errors
+        // or map them prior to calling into_response.
+        (status, message).into_response()
+    }
+}