add a macro to generate enums from pg integers

Author: pietroalbini

src/lib.rs

@@ -52,6 +52,7 @@ pub mod sql;
 pub mod ssh;
 pub mod swirl;
 mod test_util;
+#[macro_use]
 pub mod util;
 pub mod worker;
 

src/models/action.rs

@@ -1,22 +1,14 @@
-use chrono::NaiveDateTime;
-use diesel::prelude::*;
-use diesel::{
-    deserialize::{self, FromSql},
-    pg::Pg,
-    serialize::{self, Output, ToSql},
-    sql_types::Integer,
-};
-
 use crate::models::{ApiToken, User, Version};
 use crate::schema::*;
+use chrono::NaiveDateTime;
+use diesel::prelude::*;
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq, FromSqlRow, AsExpression)]
-#[repr(i32)]
-#[diesel(sql_type = Integer)]
-pub enum VersionAction {
-    Publish = 0,
-    Yank = 1,
-    Unyank = 2,
+pg_enum! {
+    pub enum VersionAction {
+        Publish = 0,
+        Yank = 1,
+        Unyank = 2,
+    }
 }
 
 impl From<VersionAction> for &'static str {
@@ -37,23 +29,6 @@ impl From<VersionAction> for String {
     }
 }
 
-impl FromSql<Integer, Pg> for VersionAction {
-    fn from_sql(bytes: diesel::pg::PgValue<'_>) -> deserialize::Result<Self> {
-        match <i32 as FromSql<Integer, Pg>>::from_sql(bytes)? {
-            0 => Ok(VersionAction::Publish),
-            1 => Ok(VersionAction::Yank),
-            2 => Ok(VersionAction::Unyank),
-            n => Err(format!("unknown version action: {n}").into()),
-        }
-    }
-}
-
-impl ToSql<Integer, Pg> for VersionAction {
-    fn to_sql(&self, out: &mut Output<'_, '_, Pg>) -> serialize::Result {
-        ToSql::<Integer, Pg>::to_sql(&(*self as i32), &mut out.reborrow())
-    }
-}
-
 #[derive(Debug, Clone, Copy, Queryable, Identifiable, Associations)]
 #[diesel(
     table_name = version_owner_actions,

src/models/dependency.rs

@@ -1,5 +1,3 @@
-use diesel::deserialize::{self, FromSql};
-use diesel::pg::Pg;
 use diesel::sql_types::{Integer, Text};
 
 use crate::models::{Crate, Version};
@@ -36,14 +34,12 @@ pub struct ReverseDependency {
     pub name: String,
 }
 
-#[derive(Copy, Clone, Serialize, Deserialize, Debug, FromSqlRow)]
-#[serde(rename_all = "lowercase")]
-#[repr(u32)]
-pub enum DependencyKind {
-    Normal = 0,
-    Build = 1,
-    Dev = 2,
-    // if you add a kind here, be sure to update `from_row` below.
+pg_enum! {
+    pub enum DependencyKind {
+        Normal = 0,
+        Build = 1,
+        Dev = 2,
+    }
 }
 
 impl From<IndexDependencyKind> for DependencyKind {
@@ -65,14 +61,3 @@ impl From<DependencyKind> for IndexDependencyKind {
         }
     }
 }
-
-impl FromSql<Integer, Pg> for DependencyKind {
-    fn from_sql(bytes: diesel::pg::PgValue<'_>) -> deserialize::Result<Self> {
-        match <i32 as FromSql<Integer, Pg>>::from_sql(bytes)? {
-            0 => Ok(DependencyKind::Normal),
-            1 => Ok(DependencyKind::Build),
-            2 => Ok(DependencyKind::Dev),
-            n => Err(format!("unknown kind: {n}").into()),
-        }
-    }
-}

src/util.rs

@@ -32,3 +32,38 @@ impl Maximums {
         }
     }
 }
+
+#[macro_export]
+macro_rules! pg_enum {
+    (
+        $vis:vis enum $name:ident {
+            $($item:ident = $int:expr,)*
+        }
+    ) => {
+        #[derive(Debug, Copy, Clone, PartialEq, Eq, Serialize, Deserialize, FromSqlRow, AsExpression)]
+        #[diesel(sql_type = diesel::sql_types::Integer)]
+        #[serde(rename_all = "snake_case")]
+        #[repr(i32)]
+        $vis enum $name {
+            $($item = $int,)*
+        }
+
+        impl diesel::deserialize::FromSql<diesel::sql_types::Integer, diesel::pg::Pg> for $name {
+            fn from_sql(bytes: diesel::pg::PgValue<'_>) -> diesel::deserialize::Result<Self> {
+                match <i32 as diesel::deserialize::FromSql<diesel::sql_types::Integer, diesel::pg::Pg>>::from_sql(bytes)? {
+                    $($int => Ok(Self::$item),)*
+                    n => Err(format!("unknown value: {}", n).into()),
+                }
+            }
+        }
+
+        impl diesel::serialize::ToSql<diesel::sql_types::Integer, diesel::pg::Pg> for $name {
+            fn to_sql(
+                &self,
+                out: &mut diesel::serialize::Output<'_, '_, diesel::pg::Pg>,
+            ) -> diesel::serialize::Result {
+                diesel::serialize::ToSql::<diesel::sql_types::Integer, diesel::pg::Pg>::to_sql(&(*self as i32), &mut out.reborrow())
+            }
+        }
+    }
+}