refactor: simplify things a bit

Author: ctron

migration/src/data/mod.rs

@@ -21,6 +21,7 @@ use std::{
 };
 use trustify_module_storage::service::dispatch::DispatchBackend;
 
+/// A handler for processing a [`Document`] data migration.
 #[allow(async_fn_in_trait)]
 pub trait Handler<D>: Send
 where
@@ -34,6 +35,21 @@ where
     ) -> anyhow::Result<()>;
 }
 
+impl<F, D> Handler<D> for F
+where
+    D: Document,
+    for<'x> F: AsyncFn(D, D::Model, &'x DatabaseTransaction) -> anyhow::Result<()> + Send,
+{
+    async fn call(
+        &self,
+        document: D,
+        model: D::Model,
+        tx: &DatabaseTransaction,
+    ) -> anyhow::Result<()> {
+        (self)(document, model, tx).await
+    }
+}
+
 #[derive(Clone, Debug, PartialEq, Eq, clap::Parser)]
 pub struct Options {
     /// Number of concurrent documents being processes
@@ -108,7 +124,7 @@ impl From<&Options> for Partition {
     }
 }
 
-/// A trait for processing documents
+/// A trait for processing documents using a [`Handler`].
 pub trait DocumentProcessor {
     fn process<D>(
         &self,
@@ -228,50 +244,6 @@ impl<'c> DocumentProcessor for SchemaManager<'c> {
     }
 }
 
-/// A handler for data migration of documents.
-///
-/// Handlers have to be written in a way that they can be re-run multiple times on the same
-/// document without failing and creating the exact same output state.
-#[macro_export]
-macro_rules! handler {
-    (async | $doc:ident: $doc_ty:ty, $model:ident, $tx:ident | $body:block) => {{
-        struct H;
-
-        impl $crate::data::Handler<$doc_ty> for H {
-            async fn call(
-                &self,
-                $doc: $doc_ty,
-                $model: <$doc_ty as $crate::data::Document>::Model,
-                $tx: &sea_orm::DatabaseTransaction,
-            ) -> anyhow::Result<()> {
-                $body
-            }
-        }
-
-        H
-    }};
-}
-
-/// A handler for SBOMs.
-///
-/// See: [`handler!`].
-#[macro_export]
-macro_rules! sbom {
-    (async | $doc:ident, $model:ident, $tx:ident | $body:block) => {
-        $crate::handler!(async |$doc: $crate::data::Sbom, $model, $tx| $body)
-    };
-}
-
-/// A handler for advisories.
-///
-/// See: [`handler!`].
-#[macro_export]
-macro_rules! advisory {
-    (async | $doc:ident, $model:ident, $tx:ident | $body:block) => {
-        $crate::handler!(async |$doc: $crate::data::Advisory, $model, $tx| $body)
-    };
-}
-
 pub trait MigratorWithData {
     fn data_migrations() -> Vec<Box<dyn MigrationTraitWithData>>;
 }

migration/src/m0002000_add_sbom_properties.rs

@@ -1,10 +1,8 @@
-use crate::{
-    data::{MigrationTraitWithData, Sbom as SbomDoc, SchemaDataManager},
-    sbom,
-};
-use sea_orm::{ActiveModelTrait, IntoActiveModel, Set};
+use crate::data::{MigrationTraitWithData, Sbom as SbomDoc, SchemaDataManager};
+use sea_orm::{ActiveModelTrait, DatabaseTransaction, IntoActiveModel, Set};
 use sea_orm_migration::prelude::*;
 use trustify_common::advisory::cyclonedx::extract_properties_json;
+use trustify_entity::sbom;
 
 #[derive(DeriveMigrationName)]
 pub struct Migration;
@@ -38,7 +36,7 @@ impl MigrationTraitWithData for Migration {
         manager
             .process(
                 self,
-                sbom!(async |sbom, model, tx| {
+                async |sbom: SbomDoc, model: sbom::Model, tx: &DatabaseTransaction| {
                     let mut model = model.into_active_model();
                     match sbom {
                         SbomDoc::CycloneDx(sbom) => {
@@ -55,7 +53,7 @@ impl MigrationTraitWithData for Migration {
                     model.save(tx).await?;
 
                     Ok(())
-                }),
+                },
             )
             .await?;
 

migration/src/m0002010_add_advisory_scores.rs

@@ -1,11 +1,9 @@
-use crate::{
-    advisory,
-    data::{Advisory as AdvisoryDoc, MigrationTraitWithData, SchemaDataManager},
-};
-use sea_orm::sea_query::extension::postgres::*;
+use crate::data::{Advisory, MigrationTraitWithData, SchemaDataManager};
+use sea_orm::{DatabaseTransaction, sea_query::extension::postgres::*};
 use sea_orm_migration::prelude::*;
 use strum::VariantNames;
 use trustify_common::db::create_enum_if_not_exists;
+use trustify_entity::advisory;
 use trustify_module_ingestor::{
     graph::cvss::ScoreCreator,
     service::advisory::{csaf, cve, osv},
@@ -99,16 +97,16 @@ impl MigrationTraitWithData for Migration {
         manager
             .process(
                 self,
-                advisory!(async |advisory, model, tx| {
+                async |advisory: Advisory, model: advisory::Model, tx: &DatabaseTransaction| {
                     let mut creator = ScoreCreator::new(model.id);
                     match advisory {
-                        AdvisoryDoc::Cve(advisory) => {
+                        Advisory::Cve(advisory) => {
                             cve::extract_scores(&advisory, &mut creator);
                         }
-                        AdvisoryDoc::Csaf(advisory) => {
+                        Advisory::Csaf(advisory) => {
                             csaf::extract_scores(&advisory, &mut creator);
                         }
-                        AdvisoryDoc::Osv(advisory) => {
+                        Advisory::Osv(advisory) => {
                             osv::extract_scores(&advisory, &mut creator);
                         }
                         _ => {
@@ -119,7 +117,7 @@ impl MigrationTraitWithData for Migration {
                     creator.create(tx).await?;
 
                     Ok(())
-                }),
+                },
             )
             .await?;
 

migration/tests/data/main.rs

@@ -17,9 +17,9 @@ mod sbom {
     use migration::{
         ColumnDef, DeriveIden, DeriveMigrationName, Table, async_trait,
         data::{MigrationTraitWithData, Sbom as SbomDoc, SchemaDataManager},
-        sbom,
     };
-    use sea_orm::{ConnectionTrait, DbErr, Statement};
+    use sea_orm::{ConnectionTrait, DatabaseTransaction, DbErr, Statement};
+    use trustify_entity::sbom;
 
     #[derive(DeriveMigrationName)]
     pub struct Migration;
@@ -50,7 +50,7 @@ mod sbom {
             manager
                 .process(
                     self,
-                    sbom!(async |sbom, model, tx| {
+                    async |sbom: SbomDoc, model: sbom::Model, tx: &DatabaseTransaction| {
                         // we just pick a random value
                         let value = match sbom {
                             SbomDoc::CycloneDx(sbom) => sbom.serial_number,
@@ -70,7 +70,7 @@ mod sbom {
                         }
 
                         Ok(())
-                    }),
+                    },
                 )
                 .await?;