remote date time wrappers

Signed-off-by: Michelle Dhanani <[email protected]>
Co-authored-by: Brian Hardock <[email protected]>

Author: michelleN

Cargo.lock

@@ -13,4 +13,5 @@ anyhow = "1"
 http = "1.0.0"
 # The Spin SDK.
 spin-sdk = { path = "../.." }
-
+# For handling date/time types
+chrono = "0.4.38"

examples/postgres-v3/Cargo.toml

@@ -1,10 +1,7 @@
 #![allow(dead_code)]
 use anyhow::Result;
 use http::{Request, Response};
-use spin_sdk::{
-    http_component, pg3,
-    pg3::{Date, Decode},
-};
+use spin_sdk::{http_component, pg3, pg3::Decode};
 
 // The environment variable set in `spin.toml` that points to the
 // address of the Pg server that the component will write to
@@ -16,7 +13,7 @@ struct Article {
     title: String,
     content: String,
     authorname: String,
-    published: Date,
+    published: chrono::NaiveDate,
     coauthor: Option<String>,
 }
 
@@ -28,7 +25,7 @@ impl TryFrom<&pg3::Row> for Article {
         let title = String::decode(&row[1])?;
         let content = String::decode(&row[2])?;
         let authorname = String::decode(&row[3])?;
-        let published = Date::decode(&row[4])?;
+        let published = chrono::NaiveDate::decode(&row[4])?;
         let coauthor = Option::<String>::decode(&row[5])?;
 
         Ok(Self {

examples/postgres-v3/src/lib.rs

@@ -124,11 +124,7 @@ impl Decode for String {
     }
 }
 
-/// Native representation of the WIT postgres Date value.
-#[derive(Clone, Debug, PartialEq)]
-pub struct Date(pub chrono::NaiveDate);
-
-impl Decode for Date {
+impl Decode for chrono::NaiveDate {
     fn decode(value: &DbValue) -> Result<Self, Error> {
         match value {
             DbValue::Date((year, month, day)) => {
@@ -140,18 +136,14 @@ impl Decode for Date {
                                 year, month, day
                             ))
                         })?;
-                Ok(Date(naive_date))
+                Ok(naive_date)
             }
             _ => Err(Error::Decode(format_decode_err("DATE", value))),
         }
     }
 }
 
-/// Native representation of the WIT postgres Time value.
-#[derive(Clone, Debug, PartialEq)]
-pub struct Time(pub chrono::NaiveTime);
-
-impl Decode for Time {
+impl Decode for chrono::NaiveTime {
     fn decode(value: &DbValue) -> Result<Self, Error> {
         match value {
             DbValue::Time((hour, minute, second, nanosecond)) => {
@@ -167,18 +159,14 @@ impl Decode for Time {
                         hour, minute, second, nanosecond
                     ))
                 })?;
-                Ok(Time(naive_time))
+                Ok(naive_time)
             }
             _ => Err(Error::Decode(format_decode_err("TIME", value))),
         }
     }
 }
 
-/// Native representation of the WIT postgres DateTime value.
-#[derive(Clone, Debug, PartialEq)]
-pub struct DateTime(pub chrono::NaiveDateTime);
-
-impl Decode for DateTime {
+impl Decode for chrono::NaiveDateTime {
     fn decode(value: &DbValue) -> Result<Self, Error> {
         match value {
             DbValue::Datetime((year, month, day, hour, minute, second, nanosecond)) => {
@@ -203,7 +191,7 @@ impl Decode for DateTime {
                     ))
                 })?;
                 let dt = chrono::NaiveDateTime::new(naive_date, naive_time);
-                Ok(DateTime(dt))
+                Ok(dt)
             }
             _ => Err(Error::Decode(format_decode_err("DATETIME", value))),
         }
@@ -216,6 +204,8 @@ fn format_decode_err(types: &str, value: &DbValue) -> String {
 
 #[cfg(test)]
 mod tests {
+    use chrono::NaiveDateTime;
+
     use super::*;
 
     #[test]
@@ -285,44 +275,48 @@ mod tests {
     #[test]
     fn date() {
         assert_eq!(
-            Date::decode(&DbValue::Date((1, 2, 4))).unwrap(),
-            Date(chrono::NaiveDate::from_ymd_opt(1, 2, 4).unwrap())
+            chrono::NaiveDate::decode(&DbValue::Date((1, 2, 4))).unwrap(),
+            chrono::NaiveDate::from_ymd_opt(1, 2, 4).unwrap()
         );
         assert_ne!(
-            Date::decode(&DbValue::Date((1, 2, 4))).unwrap(),
-            Date(chrono::NaiveDate::from_ymd_opt(1, 2, 5).unwrap())
+            chrono::NaiveDate::decode(&DbValue::Date((1, 2, 4))).unwrap(),
+            chrono::NaiveDate::from_ymd_opt(1, 2, 5).unwrap()
         );
-        assert!(Option::<Date>::decode(&DbValue::DbNull).unwrap().is_none());
+        assert!(Option::<chrono::NaiveDate>::decode(&DbValue::DbNull)
+            .unwrap()
+            .is_none());
     }
 
     #[test]
     fn time() {
         assert_eq!(
-            Time::decode(&DbValue::Time((1, 2, 3, 4))).unwrap(),
-            Time(chrono::NaiveTime::from_hms_nano_opt(1, 2, 3, 4).unwrap())
+            chrono::NaiveTime::decode(&DbValue::Time((1, 2, 3, 4))).unwrap(),
+            chrono::NaiveTime::from_hms_nano_opt(1, 2, 3, 4).unwrap()
         );
         assert_ne!(
-            Time::decode(&DbValue::Time((1, 2, 3, 4))).unwrap(),
-            Time(chrono::NaiveTime::from_hms_nano_opt(1, 2, 4, 5).unwrap())
+            chrono::NaiveTime::decode(&DbValue::Time((1, 2, 3, 4))).unwrap(),
+            chrono::NaiveTime::from_hms_nano_opt(1, 2, 4, 5).unwrap()
         );
-        assert!(Option::<Time>::decode(&DbValue::DbNull).unwrap().is_none());
+        assert!(Option::<chrono::NaiveTime>::decode(&DbValue::DbNull)
+            .unwrap()
+            .is_none());
     }
 
     #[test]
     fn datetime() {
         let date = chrono::NaiveDate::from_ymd_opt(1, 2, 3).unwrap();
         let mut time = chrono::NaiveTime::from_hms_nano_opt(4, 5, 6, 7).unwrap();
         assert_eq!(
-            DateTime::decode(&DbValue::Datetime((1, 2, 3, 4, 5, 6, 7))).unwrap(),
-            DateTime(chrono::NaiveDateTime::new(date, time))
+            chrono::NaiveDateTime::decode(&DbValue::Datetime((1, 2, 3, 4, 5, 6, 7))).unwrap(),
+            chrono::NaiveDateTime::new(date, time)
         );
 
         time = chrono::NaiveTime::from_hms_nano_opt(4, 5, 6, 8).unwrap();
         assert_ne!(
-            DateTime::decode(&DbValue::Datetime((1, 2, 3, 4, 5, 6, 7))).unwrap(),
-            DateTime(chrono::NaiveDateTime::new(date, time))
+            NaiveDateTime::decode(&DbValue::Datetime((1, 2, 3, 4, 5, 6, 7))).unwrap(),
+            chrono::NaiveDateTime::new(date, time)
         );
-        assert!(Option::<DateTime>::decode(&DbValue::DbNull)
+        assert!(Option::<chrono::NaiveDateTime>::decode(&DbValue::DbNull)
             .unwrap()
             .is_none());
     }