feat: interval query param

Author: EvolveArt

pragma-node/src/handlers/entries/get_entry.rs

@@ -1,4 +1,4 @@
-use axum::extract::State;
+use axum::extract::{Query, State};
 use axum::Json;
 use bigdecimal::num_bigint::ToBigInt;
 
@@ -9,6 +9,7 @@ use crate::AppState;
 use pragma_entities::{error::InfraError, EntryError};
 
 use super::utils::currency_pair_to_pair_id;
+use super::GetEntryParams;
 
 #[utoipa::path(
         get,
@@ -24,11 +25,17 @@ use super::utils::currency_pair_to_pair_id;
 pub async fn get_entry(
     State(state): State<AppState>,
     PathExtractor(pair): PathExtractor<(String, String)>,
+    Query(params): Query<GetEntryParams>,
 ) -> Result<Json<GetEntryResponse>, EntryError> {
     tracing::info!("Received get entry request for pair {:?}", pair);
     // Construct pair id
     let pair_id = currency_pair_to_pair_id(&pair.1, &pair.0);
 
+    // Validate given timestamp
+    if params.timestamp > chrono::Utc::now().naive_utc() {
+        return Err(EntryError::InvalidTimestamp);
+    }
+
     // Mock strk/eth pair
     if pair_id == "STRK/ETH" {
         return Ok(Json(GetEntryResponse {
@@ -41,13 +48,9 @@ pub async fn get_entry(
     }
 
     // Get entries from database with given pair id (only the latest one grouped by publisher)
-    let entry = entry_repository::get_median_price(&state.pool, pair_id.clone())
+    let entry = entry_repository::get_median_price(&state.pool, pair_id.clone(), params.interval)
         .await
-        .map_err(|db_error| match db_error {
-            InfraError::InternalServerError => EntryError::InternalServerError,
-            InfraError::NotFound => EntryError::NotFound(pair_id.clone()),
-            InfraError::InvalidTimeStamp => EntryError::InvalidTimestamp,
-        })?;
+        .map_err(|db_error| to_entry_error(db_error, pair_id.clone()))?;
 
     let decimals = entry_repository::get_decimals(&state.pool, &pair_id)
         .await
@@ -82,3 +85,11 @@ fn adapt_entry_to_entry_response(
         decimals,
     }
 }
+
+fn to_entry_error(error: InfraError, pair_id: String) -> EntryError {
+    match error {
+        InfraError::InternalServerError => EntryError::InternalServerError,
+        InfraError::NotFound => EntryError::NotFound(pair_id.to_string()),
+        InfraError::InvalidTimeStamp => EntryError::InvalidTimestamp,
+    }
+}

pragma-node/src/handlers/entries/mod.rs

@@ -1,3 +1,4 @@
+use chrono::NaiveDateTime;
 use serde::{Deserialize, Serialize};
 
 use starknet::core::types::FieldElement;
@@ -54,3 +55,32 @@ pub struct GetVolatilityResponse {
     volatility: f64,
     decimals: u32,
 }
+
+/// Query parameters structs
+
+// Define an enum for the allowed intervals
+#[derive(Default, Debug, Deserialize)]
+pub enum Interval {
+    #[serde(rename = "1min")]
+    #[default]
+    OneMinute,
+    #[serde(rename = "15min")]
+    FifteenMinutes,
+    #[serde(rename = "1h")]
+    OneHour,
+}
+
+#[derive(Debug, Deserialize)]
+pub struct GetEntryParams {
+    pub timestamp: NaiveDateTime,
+    pub interval: Interval,
+}
+
+impl Default for GetEntryParams {
+    fn default() -> Self {
+        Self {
+            timestamp: chrono::Utc::now().naive_utc(),
+            interval: Interval::default(),
+        }
+    }
+}

pragma-node/src/infra/repositories/entry_repository.rs

@@ -11,6 +11,8 @@ use pragma_entities::{
     Entry, NewEntry,
 };
 
+use crate::handlers::entries::Interval;
+
 #[derive(Deserialize)]
 #[allow(unused)]
 pub struct EntriesFilter {
@@ -82,10 +84,13 @@ pub struct MedianEntryRaw {
 pub async fn get_median_price(
     pool: &deadpool_diesel::postgres::Pool,
     pair_id: String,
+    interval: Interval,
 ) -> Result<MedianEntry, InfraError> {
     let conn = pool.get().await.map_err(adapt_infra_error)?;
 
-    let raw_sql = r#"
+    let raw_sql = match interval {
+        Interval::OneMinute => {
+            r#"
         -- query the materialized realtime view
         SELECT
             bucket AS time,
@@ -98,7 +103,41 @@ pub async fn get_median_price(
         ORDER BY
             time DESC
         LIMIT 1;
-    "#;
+    "#
+        }
+        Interval::FifteenMinutes => {
+            r#"
+        -- query the materialized realtime view
+        SELECT
+            bucket AS time,
+            median_price,
+            num_sources
+        FROM
+            price_15_min_agg
+        WHERE
+            pair_id = $1
+        ORDER BY
+            time DESC
+        LIMIT 1;
+    "#
+        }
+        Interval::OneHour => {
+            r#"
+        -- query the materialized realtime view
+        SELECT
+            bucket AS time,
+            median_price,
+            num_sources
+        FROM
+            price_1_hour_agg
+        WHERE
+            pair_id = $1
+        ORDER BY
+            time DESC
+        LIMIT 1;
+    "#
+        }
+    };
 
     let raw_entry = conn
         .interact(move |conn| {