Use new MaxMind env vars on Labrinth (#4573)

* Bring in modrinth-maxmind

* integrate modrinth-maxmind into labrinth

* Fix CI

packages/modrinth-util/src/error.rs

@@ -0,0 +1,326 @@
+use std::{
+    convert::Infallible,
+    fmt::{Debug, Display},
+};
+
+use actix_web::{HttpResponse, ResponseError, http::StatusCode};
+use derive_more::{Display, Error};
+use serde::{Deserialize, Serialize};
+
+/// Error when calling an HTTP endpoint.
+#[derive(Debug, Display, Error)]
+pub enum ApiError {
+    /// Error occurred on the server side, which the caller has no fault in.
+    Internal(eyre::Report),
+    /// Caller made an invalid or malformed request.
+    Request(eyre::Report),
+    /// Caller attempted a request which they are not allowed to make.
+    Auth(eyre::Report),
+}
+
+impl ResponseError for ApiError {
+    fn status_code(&self) -> StatusCode {
+        match self {
+            Self::Internal(_) => StatusCode::INTERNAL_SERVER_ERROR,
+            Self::Request(_) => StatusCode::BAD_REQUEST,
+            Self::Auth(_) => StatusCode::UNAUTHORIZED,
+        }
+    }
+
+    fn error_response(&self) -> HttpResponse {
+        HttpResponse::build(self.status_code()).json(ErrorResponse {
+            // internal error details are not leaked to the caller
+            description: match self {
+                Self::Internal(_) => None,
+                _ => Some(self.to_string()),
+            },
+        })
+    }
+}
+
+/// How an [`ApiError`] is represented when sending over an HTTP request.
+#[derive(Debug, Serialize, Deserialize)]
+pub struct ErrorResponse {
+    /// Text description of the error that occurred.
+    ///
+    /// [`ApiError::Internal`] errors have their description filtered out, and
+    /// will hold [`None`].
+    pub description: Option<String>,
+}
+
+/// Allows wrapping [`Result`]s and [`Option`]s into [`Result<T, ApiError>`]s.
+#[allow(
+    clippy::missing_errors_doc,
+    reason = "this trait's purpose is improving error handling"
+)]
+pub trait Context<T, E>: Sized {
+    /// Maps the error variant into an [`eyre::Report`], creating the message
+    /// using `f`.
+    fn wrap_err_with<D>(self, f: impl FnOnce() -> D) -> Result<T, eyre::Report>
+    where
+        D: Send + Sync + Debug + Display + 'static;
+
+    /// Maps the error variant into an [`eyre::Report`] with the given message.
+    /// Maps the error variant into an [`eyre::Report`] with the given message.
+    #[inline]
+    fn wrap_err<D>(self, msg: D) -> Result<T, eyre::Report>
+    where
+        D: Send + Sync + Debug + Display + 'static,
+    {
+        self.wrap_err_with(|| msg)
+    }
+
+    /// Maps the error variant into an [`ApiError::Internal`] using the closure to create the message.
+    #[inline]
+    fn wrap_internal_err_with<D>(
+        self,
+        f: impl FnOnce() -> D,
+    ) -> Result<T, ApiError>
+    where
+        D: Send + Sync + Debug + Display + 'static,
+    {
+        self.wrap_err_with(f).map_err(ApiError::Internal)
+    }
+
+    /// Maps the error variant into an [`ApiError::Internal`] with the given message.
+    #[inline]
+    fn wrap_internal_err<D>(self, msg: D) -> Result<T, ApiError>
+    where
+        D: Send + Sync + Debug + Display + 'static,
+    {
+        self.wrap_internal_err_with(|| msg)
+    }
+
+    /// Maps the error variant into an [`ApiError::Request`] using the closure to create the message.
+    #[inline]
+    fn wrap_request_err_with<D>(
+        self,
+        f: impl FnOnce() -> D,
+    ) -> Result<T, ApiError>
+    where
+        D: Send + Sync + Debug + Display + 'static,
+    {
+        self.wrap_err_with(f).map_err(ApiError::Request)
+    }
+
+    /// Maps the error variant into an [`ApiError::Request`] with the given message.
+    #[inline]
+    fn wrap_request_err<D>(self, msg: D) -> Result<T, ApiError>
+    where
+        D: Send + Sync + Debug + Display + 'static,
+    {
+        self.wrap_request_err_with(|| msg)
+    }
+
+    /// Maps the error variant into an [`ApiError::Auth`] using the closure to create the message.
+    #[inline]
+    fn wrap_auth_err_with<D>(self, f: impl FnOnce() -> D) -> Result<T, ApiError>
+    where
+        D: Send + Sync + Debug + Display + 'static,
+    {
+        self.wrap_err_with(f).map_err(ApiError::Auth)
+    }
+
+    /// Maps the error variant into an [`ApiError::Auth`] with the given message.
+    #[inline]
+    fn wrap_auth_err<D>(self, msg: D) -> Result<T, ApiError>
+    where
+        D: Send + Sync + Debug + Display + 'static,
+    {
+        self.wrap_auth_err_with(|| msg)
+    }
+}
+
+impl<T, E> Context<T, E> for Result<T, E>
+where
+    Self: eyre::WrapErr<T, E>,
+{
+    fn wrap_err_with<D>(self, f: impl FnOnce() -> D) -> Result<T, eyre::Report>
+    where
+        D: Send + Sync + Debug + Display + 'static,
+    {
+        eyre::WrapErr::wrap_err_with(self, f)
+    }
+}
+
+impl<T> Context<T, Infallible> for Option<T> {
+    fn wrap_err_with<D>(self, f: impl FnOnce() -> D) -> Result<T, eyre::Report>
+    where
+        D: Send + Sync + Debug + Display + 'static,
+    {
+        self.ok_or_else(|| eyre::Report::msg(f()))
+    }
+}
+
+// impl<T, E, Ty> Context<T, E> for Ty where Ty: eyre::WrapErr<T, E> {}
+
+// impl<T, Ty> Context<T, Infallible> for Ty where Ty: eyre::OptionExt<T> {}
+
+// impl<T, E> Context<T, E> for Result<T, E>
+// where
+//     Self: eyre::WrapErr<T, E>,
+// {
+//     fn wrap_err_with<D>(self, f: impl FnOnce() -> D) -> Result<T, eyre::Report>
+//     where
+//         D: Send + Sync + Debug + Display + 'static,
+//     {
+//         self.map_err(|err| eyre::Report::new(err).wrap_err(f()))
+//     }
+// }
+
+// impl<T> Context<T, Infallible> for Option<T> {
+//     fn wrap_err_with<D>(self, f: impl FnOnce() -> D) -> Result<T, eyre::Report>
+//     where
+//         D: Send + Sync + Debug + Display + 'static,
+//     {
+//         self.ok_or_else(|| eyre::Report::msg(f()))
+//     }
+// }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use actix_web::http::StatusCode;
+
+    #[test]
+    fn test_api_error_display() {
+        let error = ApiError::Internal(eyre::eyre!("test internal error"));
+        assert!(error.to_string().contains("test internal error"));
+
+        let error = ApiError::Request(eyre::eyre!("test request error"));
+        assert!(error.to_string().contains("test request error"));
+
+        let error = ApiError::Auth(eyre::eyre!("test auth error"));
+        assert!(error.to_string().contains("test auth error"));
+    }
+
+    #[test]
+    fn test_api_error_debug() {
+        let error = ApiError::Internal(eyre::eyre!("test error"));
+        let debug_str = format!("{error:?}");
+        assert!(debug_str.contains("Internal"));
+        assert!(debug_str.contains("test error"));
+    }
+
+    #[test]
+    fn test_response_error_status_codes() {
+        let internal_error = ApiError::Internal(eyre::eyre!("internal error"));
+        assert_eq!(
+            internal_error.status_code(),
+            StatusCode::INTERNAL_SERVER_ERROR
+        );
+
+        let request_error = ApiError::Request(eyre::eyre!("request error"));
+        assert_eq!(request_error.status_code(), StatusCode::BAD_REQUEST);
+
+        let auth_error = ApiError::Auth(eyre::eyre!("auth error"));
+        assert_eq!(auth_error.status_code(), StatusCode::UNAUTHORIZED);
+    }
+
+    #[test]
+    fn test_response_error_response() {
+        let error = ApiError::Request(eyre::eyre!("test request error"));
+        let response = error.error_response();
+
+        assert_eq!(response.status(), StatusCode::BAD_REQUEST);
+
+        // Skip the body parsing test as it requires async and is more complex
+        // The important thing is that the error response is created correctly
+    }
+
+    #[test]
+    fn test_context_trait_result() {
+        let result: Result<i32, std::io::Error> = Ok(42);
+        let wrapped = result.wrap_err("context message");
+        assert_eq!(wrapped.unwrap(), 42);
+
+        let result: Result<i32, std::io::Error> = Err(std::io::Error::new(
+            std::io::ErrorKind::NotFound,
+            "not found",
+        ));
+        let wrapped = result.wrap_err("context message");
+        assert!(wrapped.is_err());
+        assert!(wrapped.unwrap_err().to_string().contains("context message"));
+    }
+
+    #[test]
+    fn test_context_trait_option() {
+        let option: Option<i32> = Some(42);
+        let wrapped = option.wrap_err("context message");
+        assert_eq!(wrapped.unwrap(), 42);
+
+        let option: Option<i32> = None;
+        let wrapped = option.wrap_err("context message");
+        assert!(wrapped.is_err());
+        assert_eq!(wrapped.unwrap_err().to_string(), "context message");
+    }
+
+    #[test]
+    fn test_context_trait_internal_error() {
+        let result: Result<i32, std::io::Error> = Err(std::io::Error::new(
+            std::io::ErrorKind::NotFound,
+            "not found",
+        ));
+        let wrapped = result.wrap_internal_err("internal error context");
+
+        assert!(wrapped.is_err());
+        match wrapped.unwrap_err() {
+            ApiError::Internal(report) => {
+                assert!(report.to_string().contains("internal error context"));
+            }
+            _ => panic!("Expected Internal error"),
+        }
+    }
+
+    #[test]
+    fn test_context_trait_request_error() {
+        let result: Result<i32, std::io::Error> = Err(std::io::Error::new(
+            std::io::ErrorKind::NotFound,
+            "not found",
+        ));
+        let wrapped = result.wrap_request_err("request error context");
+
+        assert!(wrapped.is_err());
+        match wrapped.unwrap_err() {
+            ApiError::Request(report) => {
+                assert!(report.to_string().contains("request error context"));
+            }
+            _ => panic!("Expected Request error"),
+        }
+    }
+
+    #[test]
+    fn test_context_trait_auth_error() {
+        let result: Result<i32, std::io::Error> = Err(std::io::Error::new(
+            std::io::ErrorKind::NotFound,
+            "not found",
+        ));
+        let wrapped = result.wrap_auth_err("auth error context");
+
+        assert!(wrapped.is_err());
+        match wrapped.unwrap_err() {
+            ApiError::Auth(report) => {
+                assert!(report.to_string().contains("auth error context"));
+            }
+            _ => panic!("Expected Auth error"),
+        }
+    }
+
+    #[test]
+    fn test_context_trait_with_closure() {
+        let result: Result<i32, std::io::Error> = Err(std::io::Error::new(
+            std::io::ErrorKind::NotFound,
+            "not found",
+        ));
+        let wrapped =
+            result.wrap_err_with(|| format!("context with {}", "dynamic"));
+
+        assert!(wrapped.is_err());
+        assert!(
+            wrapped
+                .unwrap_err()
+                .to_string()
+                .contains("context with dynamic")
+        );
+    }
+}

packages/modrinth-util/src/lib.rs

@@ -0,0 +1,23 @@
+#![doc = include_str!("../README.md")]
+
+mod error;
+pub use error::*;
+
+use eyre::{Result, eyre};
+
+/// Fetches an environment variable, possibly loading it using [`dotenvy`].
+///
+/// # Errors
+///
+/// Errors if the environment variable is missing or empty, providing a
+/// pretty-printed error including the environment variable name.
+#[track_caller]
+pub fn env_var(key: &str) -> Result<String> {
+    let value = dotenvy::var(key)
+        .wrap_err_with(|| eyre!("missing environment variable `{key}`"))?;
+    if value.is_empty() {
+        Err(eyre!("environment variable `{key}` is empty"))
+    } else {
+        Ok(value)
+    }
+}