wrap civil Date and Time

Signed-off-by: tison <[email protected]>

jiff-sqlx/src/postgres/mod.rs

@@ -1,2 +1,5 @@
+mod date;
+mod datetime;
 mod interval;
+mod time;
 mod timestamp;

jiff-sqlx/src/wrap_types.rs

@@ -1,61 +1,40 @@
-pub trait ToTimestamp {
-    fn to_sqlx(self) -> Timestamp;
-}
-
-#[derive(Debug, Clone, Copy)]
-pub struct Timestamp(jiff::Timestamp);
-
-impl Timestamp {
-    pub fn to_jiff(self) -> jiff::Timestamp {
-        self.0
-    }
-}
-
-impl ToTimestamp for jiff::Timestamp {
-    fn to_sqlx(self) -> Timestamp {
-        Timestamp(self)
-    }
-}
-
-impl From<Timestamp> for jiff::Timestamp {
-    fn from(ts: Timestamp) -> Self {
-        ts.0
-    }
-}
-
-impl From<jiff::Timestamp> for Timestamp {
-    fn from(ts: jiff::Timestamp) -> Self {
-        Self(ts)
-    }
-}
-
-pub trait ToSignedDuration {
-    fn to_sqlx(self) -> SignedDuration;
-}
-
-#[derive(Debug, Clone, Copy)]
-pub struct SignedDuration(jiff::SignedDuration);
-
-impl SignedDuration {
-    pub fn to_jiff(self) -> jiff::SignedDuration {
-        self.0
-    }
-}
-
-impl ToSignedDuration for jiff::SignedDuration {
-    fn to_sqlx(self) -> SignedDuration {
-        SignedDuration(self)
-    }
-}
-
-impl From<SignedDuration> for jiff::SignedDuration {
-    fn from(sd: SignedDuration) -> Self {
-        sd.0
-    }
-}
-
-impl From<jiff::SignedDuration> for SignedDuration {
-    fn from(sd: jiff::SignedDuration) -> Self {
-        Self(sd)
-    }
-}
+macro_rules! define_wrap_type {
+    ($wrapper:ident, $wrapper_trait:ident, $origin:ty) => {
+        pub trait $wrapper_trait {
+            fn to_sqlx(self) -> $wrapper;
+        }
+
+        #[derive(Debug, Clone, Copy)]
+        pub struct $wrapper($origin);
+
+        impl $wrapper {
+            pub fn to_jiff(self) -> $origin {
+                self.0
+            }
+        }
+
+        impl $wrapper_trait for $origin {
+            fn to_sqlx(self) -> $wrapper {
+                $wrapper(self)
+            }
+        }
+
+        impl From<$wrapper> for $origin {
+            fn from(value: $wrapper) -> Self {
+                value.0
+            }
+        }
+
+        impl From<$origin> for $wrapper {
+            fn from(value: $origin) -> Self {
+                Self(value)
+            }
+        }
+    };
+}
+
+define_wrap_type!(Timestamp, ToTimestamp, jiff::Timestamp);
+define_wrap_type!(SignedDuration, ToSignedDuration, jiff::SignedDuration);
+define_wrap_type!(Date, ToDate, jiff::civil::Date);
+define_wrap_type!(Time, ToTime, jiff::civil::Time);
+define_wrap_type!(DateTime, ToDateTime, jiff::civil::DateTime);