1 files changed, 89 insertions, 0 deletions

diff --git a/src/error.rs b/src/error.rs
new file mode 100644
index 0000000..2d0f911
--- /dev/null
+++ b/src/error.rs
@@ -0,0 +1,89 @@
+use axum::extract::rejection::JsonRejection;
+use axum::response::{IntoResponse, Response};
+use axum_extra::typed_header::TypedHeaderRejection;
+
+use crate::response::{ErrorResponse, FailResponse, SuccessResponse};
+
+pub type ApiResult<T> = Result<SuccessResponse<T>, ApiError>;
+
+pub enum ApiError {
+    // 400
+    BadJsonBody(String),
+    BadAuthTokenHeader(String),
+    UserAlreadyExists { username: String },
+    InvalidPassword,
+    NotAuthorized,
+    // 500
+    Database(String),
+    PasswordHash(String),
+    InternalJwt(String),
+}
+
+impl From<JsonRejection> for ApiError {
+    fn from(value: JsonRejection) -> Self {
+        Self::BadJsonBody(value.body_text())
+    }
+}
+
+impl From<TypedHeaderRejection> for ApiError {
+    fn from(value: TypedHeaderRejection) -> Self {
+        Self::BadAuthTokenHeader(value.to_string())
+    }
+}
+
+impl From<sea_orm::DbErr> for ApiError {
+    fn from(value: sea_orm::DbErr) -> Self {
+        Self::Database(value.to_string())
+    }
+}
+
+impl From<argon2::password_hash::Error> for ApiError {
+    fn from(value: argon2::password_hash::Error) -> Self {
+        Self::PasswordHash(value.to_string())
+    }
+}
+
+impl ToString for ApiError {
+    fn to_string(&self) -> String {
+        match self {
+            // 400
+            ApiError::BadJsonBody(..) => "BadJsonBody",
+            ApiError::BadAuthTokenHeader(..) => "BadAuthTokenHeader",
+            ApiError::UserAlreadyExists { .. } => "UserAlreadyExists",
+            ApiError::InvalidPassword => "InvalidPassword",
+            ApiError::NotAuthorized => "NotAuthorized",
+            // 500
+            ApiError::Database(..) => "Database",
+            ApiError::PasswordHash(..) => "PasswordHash",
+            ApiError::InternalJwt(..) => "InternalJwt",
+        }
+        .to_string()
+    }
+}
+
+impl IntoResponse for ApiError {
+    fn into_response(self) -> Response {
+        let kind = self.to_string();
+        match self {
+            // 400
+            ApiError::BadJsonBody(msg) => FailResponse(kind, msg).into_response(),
+            ApiError::BadAuthTokenHeader(msg) => FailResponse(kind, msg).into_response(),
+            ApiError::UserAlreadyExists { username } => FailResponse(
+                kind,
+                format!("user with username `{}` already exists", username),
+            )
+            .into_response(),
+            ApiError::InvalidPassword => {
+                FailResponse(kind, "password is invalid".to_string()).into_response()
+            }
+            ApiError::NotAuthorized => {
+                FailResponse(kind, "user is not authorized".to_string()).into_response()
+            }
+
+            // 500
+            ApiError::Database(msg) => ErrorResponse(kind, msg).into_response(),
+            ApiError::PasswordHash(msg) => ErrorResponse(kind, msg).into_response(),
+            ApiError::InternalJwt(msg) => ErrorResponse(kind, msg).into_response(),
+        }
+    }
+}