feat(endpoint_onchain_checkpoints): Error handling

pragma-entities/src/lib.rs

@@ -8,6 +8,7 @@ pub mod schema;
 // exporting for idiomatic use
 pub use error::{adapt_infra_error, InfraError};
 pub use models::{
+    checkpoint_error::CheckpointError,
     currency::Currency,
     currency_error::CurrencyError,
     entry::{Entry, NewEntry},

pragma-entities/src/models/checkpoint_error.rs

@@ -0,0 +1,52 @@
+use axum::http::StatusCode;
+use axum::response::IntoResponse;
+use axum::Json;
+use serde_json::json;
+
+use crate::error::InfraError;
+
+#[derive(Debug, thiserror::Error)]
+pub enum CheckpointError {
+    #[error("internal server error")]
+    InternalServerError,
+    #[error("invalid limit : {0}")]
+    InvalidLimit(u64),
+    #[error("no checkpoints found for requested pair")]
+    NotFound(),
+}
+
+impl From<InfraError> for CheckpointError {
+    fn from(error: InfraError) -> Self {
+        match error {
+            InfraError::InternalServerError => Self::InternalServerError,
+            InfraError::NotFound => Self::NotFound(),
+            InfraError::InvalidTimeStamp => Self::InternalServerError,
+        }
+    }
+}
+
+impl IntoResponse for CheckpointError {
+    fn into_response(self) -> axum::response::Response {
+        let (status, err_msg) = match self {
+            Self::InvalidLimit(limit) => (
+                StatusCode::INTERNAL_SERVER_ERROR,
+                format!("Invalid Limit {}", limit),
+            ),
+            Self::NotFound() => (
+                StatusCode::NOT_FOUND,
+                String::from("No checkpoints found for requested pair"),
+            ),
+            _ => (
+                StatusCode::INTERNAL_SERVER_ERROR,
+                String::from("Internal server error"),
+            ),
+        };
+        (
+            status,
+            Json(
+                json!({"resource":"Checkpoint", "message": err_msg, "happened_at" : chrono::Utc::now() }),
+            ),
+        )
+            .into_response()
+    }
+}

pragma-entities/src/models/entry_error.rs

@@ -37,8 +37,6 @@ pub enum EntryError {
     PublishData(String),
     #[error("can't build publish message: {0}")]
     BuildPublish(String),
-    #[error("limit maximum is 1000, current is: {0}")]
-    InvalidLimit(u64),
 }
 
 impl IntoResponse for EntryError {

pragma-entities/src/models/mod.rs

@@ -1,3 +1,4 @@
+pub mod checkpoint_error;
 pub mod currency;
 pub mod currency_error;
 pub mod entry;

pragma-node/src/handlers/entries/get_onchain/checkpoints.rs

@@ -1,6 +1,6 @@
 use axum::extract::{Query, State};
 use axum::Json;
-use pragma_entities::EntryError;
+use pragma_entities::CheckpointError;
 
 use crate::handlers::entries::utils::currency_pair_to_pair_id;
 use crate::handlers::entries::{GetOnchainCheckpointsParams, GetOnchainCheckpointsResponse};
@@ -29,23 +29,19 @@ pub async fn get_onchain_checkpoints(
     State(state): State<AppState>,
     PathExtractor(pair): PathExtractor<(String, String)>,
     Query(params): Query<GetOnchainCheckpointsParams>,
-) -> Result<Json<GetOnchainCheckpointsResponse>, EntryError> {
+) -> Result<Json<GetOnchainCheckpointsResponse>, CheckpointError> {
     tracing::info!("Received get onchain entry request for pair {:?}", pair);
 
     let pair_id: String = currency_pair_to_pair_id(&pair.0, &pair.1);
-    let limit = if let Some(limit) = params.limit {
-        if (limit == 0) || (limit > MAX_LIMIT) {
-            // TODO(akhercha): not so great error kind
-            return Err(EntryError::InvalidLimit(limit));
-        }
-        limit
-    } else {
-        DEFAULT_LIMIT
-    };
+
+    let limit = params.limit.unwrap_or(DEFAULT_LIMIT);
+    if !(1..=MAX_LIMIT).contains(&limit) {
+        return Err(CheckpointError::InvalidLimit(limit));
+    }
 
     let decimals = get_decimals(&state.timescale_pool, &pair_id)
         .await
-        .map_err(|db_error| db_error.to_entry_error(&pair_id))?;
+        .map_err(CheckpointError::from)?;
 
     let checkpoints = get_checkpoints(
         &state.postgres_pool,
@@ -55,8 +51,10 @@ pub async fn get_onchain_checkpoints(
         limit,
     )
     .await
-    .map_err(|db_error| db_error.to_entry_error(&pair_id))?;
+    .map_err(CheckpointError::from)?;
 
-    // TODO(akhercha): Return error if checkpoints length == 0
+    if checkpoints.is_empty() {
+        return Err(CheckpointError::NotFound());
+    }
     Ok(Json(GetOnchainCheckpointsResponse(checkpoints)))
 }

pragma-node/src/main.rs

@@ -39,26 +39,28 @@ async fn main() {
         components(
             schemas(pragma_entities::dto::Entry, pragma_entities::EntryError),
             schemas(pragma_entities::dto::Publisher, pragma_entities::PublisherError),
+            schemas(pragma_entities::error::InfraError),
             schemas(
                 handlers::entries::CreateEntryRequest,
                 handlers::entries::CreateEntryResponse,
+                handlers::entries::GetEntryParams,
                 handlers::entries::GetEntryResponse,
                 handlers::entries::GetVolatilityResponse,
                 handlers::entries::GetOHLCResponse,
+                handlers::entries::GetOnchainParams,
                 handlers::entries::GetOnchainResponse,
+                handlers::entries::GetOnchainCheckpointsParams,
                 handlers::entries::GetOnchainCheckpointsResponse,
             ),
             schemas(
+                handlers::entries::Entry,
+                handlers::entries::BaseEntry,
                 handlers::entries::OnchainEntry,
-                handlers::entries::Checkpoint,
-                handlers::entries::GetOnchainParams,
-                handlers::entries::GetOnchainCheckpointsParams
             ),
+            schemas(handlers::entries::Checkpoint),
             schemas(handlers::entries::Network),
             schemas(handlers::entries::AggregationMode),
-            schemas(handlers::entries::GetEntryParams, handlers::entries::Interval),
-            schemas(handlers::entries::Entry, handlers::entries::BaseEntry),
-            schemas(pragma_entities::error::InfraError),
+            schemas(handlers::entries::Interval),
         ),
         modifiers(&SecurityAddon),
         tags(