feat: implement date window for ascents

For now, the date window is a string displayed like ISO 8601 with
intervals. It could make sense to make this a scalar of some kind to
enforce the implementation.

Some notes on implementation..

- the PostgreSQL `DATERANGE` type is queries as `::TEXT` since
  rust-postgres doesn't appear (or that I could find) to allow the user
  to specify the [format per returned column](https://www.postgresql.org/docs/9.3/protocol-overview.html#PROTOCOL-FORMAT-CODES).. and so the `FromSql`
  implementation must accept a `TEXT` type as well.

- the `DATERANGE` is [always of the format `[)`](https://www.postgresql.org/docs/current/rangetypes.html#RANGETYPES-DISCRETE) (or `()` when the bottom
  is unbounded), so this makes parsing quite simple.

Author: lgrosz

Cargo.toml

@@ -8,6 +8,7 @@ async-graphql = "7.0.7"
 async-graphql-axum = "7.0.7"
 axum = "0.7.5"
 bytes = "1.10.1"
+chrono = "0.4.40"
 config = "0.14.1"
 deadpool = "0.12.1"
 deadpool-postgres = { version = "0.14.0", features = ["serde"] }

src/schema/mod.rs

@@ -1,12 +1,13 @@
-use std::fmt::Display;
+use std::{fmt::Display, ops::Bound, error::Error};
 
 use async_graphql::{Context, Object, OneofObject, Result, SimpleObject, Union, ID};
 
 use area::Area;
+use chrono::{Duration, NaiveDate};
 use climb::Climb;
 use formation::{Coordinate, Formation};
 use grade::{Grade, GradeInput};
-use postgres_types::ToSql;
+use postgres_types::{accepts, FromSql, ToSql};
 
 use crate::AppData;
 
@@ -18,6 +19,107 @@ pub mod fontainebleau_grade;
 pub mod vermin_grade;
 pub mod yosemite_decimal_grade;
 
+struct BoundedNaiveDateRange(pub Bound<NaiveDate>, pub Bound<NaiveDate>);
+
+#[derive(Debug)]
+struct PgDateRangeParseError;
+
+impl Display for PgDateRangeParseError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "Failed to parse PostgreSQL DATERANGE")
+    }
+}
+
+impl Error for PgDateRangeParseError { }
+
+impl BoundedNaiveDateRange {
+    fn from_pg_range_text(s: &str) -> std::result::Result<Self, PgDateRangeParseError> {
+        let trimmed = s.trim();
+
+        if trimmed.len() < 3 || (!trimmed.starts_with(['[', '('])) || (!trimmed.ends_with([']', ')'])) {
+            return Err(PgDateRangeParseError);
+        }
+
+        let start_closed = trimmed.starts_with('[');
+        let end_closed = trimmed.ends_with(']');
+
+        let inner = &trimmed[1..trimmed.len() - 1];
+        let parts: Vec<&str> = inner.split(',').map(|s| s.trim()).collect();
+
+        let start_bound = match parts.first() {
+            Some(date_str) if !date_str.is_empty() => {
+                let date = NaiveDate::parse_from_str(date_str, "%Y-%m-%d")
+                    .map_err(|_| PgDateRangeParseError)?;
+                if start_closed {
+                    Bound::Included(date)
+                } else {
+                    Bound::Excluded(date)
+                }
+            }
+            _ => Bound::Unbounded,
+        };
+
+        let end_bound = match parts.get(1).copied() {
+            Some(date_str) if !date_str.is_empty() => {
+                let date = NaiveDate::parse_from_str(date_str, "%Y-%m-%d")
+                    .map_err(|_| PgDateRangeParseError)?;
+                if end_closed {
+                    Bound::Included(date)
+                } else {
+                    Bound::Excluded(date)
+                }
+            }
+            _ => Bound::Unbounded,
+        };
+
+        Ok(BoundedNaiveDateRange(start_bound, end_bound))
+    }
+}
+
+impl Display for BoundedNaiveDateRange {
+    // format the string in a somewhat universal format (ISO 8601 with only needed extensions)
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        // TODO This implementation is naive, I can think of several simplifications off the top of
+        // my head such as..
+        // - [2024-03-01, 2024-03-02) --> 2024-03-02
+        // - [2024-03-01, 2024-04-01) --> 2024-03
+        // - [2024-01-01, 2025-01-01) --> 2024
+
+        // Formatting the start bound
+        let start = match &self.0 {
+            Bound::Included(date) => date.to_string(),
+            Bound::Excluded(date) => (*date + Duration::days(1)).to_string(),
+            Bound::Unbounded => String::from(".."),
+        };
+
+        // Formatting the end bound
+        let end = match &self.1 {
+            Bound::Included(date) => date.to_string(),
+            Bound::Excluded(date) => (*date - Duration::days(1)).to_string(),
+            Bound::Unbounded => String::from(".."),
+        };
+
+        // Combine the formatted start and end bounds, separating with a "/"
+        write!(f, "{}/{}", start, end)
+    }
+}
+
+impl<'a> FromSql<'a> for BoundedNaiveDateRange {
+    fn from_sql(ty: &postgres_types::Type, raw: &'a [u8]) -> std::result::Result<Self, Box<dyn std::error::Error + Sync + Send>> {
+        match *ty {
+            postgres_types::Type::DATE_RANGE => todo!(),
+            postgres_types::Type::TEXT => {
+                let text = std::str::from_utf8(raw)?;
+                let parsed = BoundedNaiveDateRange::from_pg_range_text(text)?;
+                Ok(parsed)
+            },
+            _ => Err(format!("Unsupported type: {:?}", ty).into()),
+        }
+    }
+
+    accepts!(DATE_RANGE, TEXT);
+}
+
 pub struct QueryRoot;
 
 impl Display for GradeInput {
@@ -251,6 +353,38 @@ impl Ascent {
         Ok(Climber(climber_id))
     }
 
+    async fn date_window<'a>(
+        &self,
+        ctx: &Context<'a>,
+    ) -> Result<Option<String>> { // ISO 8601 interval
+        let data = ctx.data::<AppData>()?;
+        let client = match &data.pg_pool {
+            Some(pool) => pool.get().await?,
+            None => {
+                return Err("Database connection is not available".into());
+            }
+        };
+
+        let result = client
+            // TODO sfackler/rust-postgres-range#18
+            .query_one(
+                "
+                SELECT date_window::TEXT
+                FROM ascents
+                WHERE id = $1
+                ",
+                &[&self.0],
+            )
+            .await?;
+
+        let value: Option<BoundedNaiveDateRange> = result.try_get(0)?;
+
+        match value {
+            Some(range) => Ok(Some(format!("{}", range).to_string())),
+            None => Ok(None),
+        }
+    }
+
     async fn grades<'a>(
         &self,
         ctx: &Context<'a>,