refactor: split off db with migration

The entity module requires common, common requires migration due to the
DB setup functions.

However, if we want to use the entities in the migration as well, then
that would lead to a circular dependency situation.

Moving the setup methods into a special "db" modules solves this issue.

Author: ctron

Cargo.lock

@@ -3,6 +3,7 @@ resolver = "3"
 members = [
     "common",
     "common/auth",
+    "common/db",
     "common/infrastructure",
     "cvss",
     "entity",
@@ -154,6 +155,7 @@ zip = "4"
 trustify-auth = { path = "common/auth", features = ["actix", "swagger"] }
 trustify-common = { path = "common" }
 trustify-cvss = { path = "cvss" }
+trustify-db = { path = "common/db" }
 trustify-entity = { path = "entity" }
 trustify-infrastructure = { path = "common/infrastructure" }
 trustify-migration = { path = "migration" }

Cargo.toml

@@ -6,8 +6,6 @@ publish.workspace = true
 license.workspace = true
 
 [dependencies]
-trustify-migration = { workspace = true }
-
 actix-web = { workspace = true }
 anyhow = { workspace = true }
 bytes = { workspace = true }
@@ -25,13 +23,13 @@ log = { workspace = true }
 native-tls = { workspace = true }
 packageurl = { workspace = true }
 pem = { workspace = true }
-postgresql_embedded = { workspace = true, features = ["blocking", "tokio"] }
 regex = { workspace = true }
 reqwest = { workspace = true, features = ["native-tls"] }
 ring = { workspace = true }
 sbom-walker = { workspace = true }
 schemars = { workspace = true }
 sea-orm = { workspace = true, features = ["sea-query-binder", "sqlx-postgres", "runtime-tokio-rustls", "macros"] }
+sea-orm-migration = { workspace = true }
 sea-query = { workspace = true }
 serde = { workspace = true, features = ["derive"] }
 serde_json = { workspace = true }
@@ -46,15 +44,14 @@ tracing = { workspace = true }
 urlencoding = { workspace = true }
 utoipa = { workspace = true, features = ["url"] }
 uuid = { workspace = true, features = ["v5", "serde"] }
-walker-common = { workspace = true, features = ["bzip2", "liblzma", "flate2"]}
+walker-common = { workspace = true, features = ["bzip2", "liblzma", "flate2"] }
 humantime = { workspace = true }
 
 [dev-dependencies]
 chrono = { workspace = true }
 rand = { workspace = true }
 rstest = { workspace = true }
 serde_json = { workspace = true }
-test-context = { workspace = true }
 test-log = { workspace = true, features = ["log", "trace"] }
 time = { workspace = true, features = ["macros"] }
 tokio = { workspace = true, features = ["full"] }

common/Cargo.toml

@@ -0,0 +1,17 @@
+[package]
+name = "trustify-db"
+version.workspace = true
+edition.workspace = true
+publish.workspace = true
+license.workspace = true
+
+[dependencies]
+trustify-migration = { workspace = true }
+trustify-common = { workspace = true }
+
+anyhow = { workspace = true }
+log = { workspace = true }
+postgresql_embedded = { workspace = true, features = ["blocking", "tokio"] }
+sea-orm = { workspace = true }
+sea-orm-migration = { workspace = true }
+tracing = { workspace = true }

common/db/Cargo.toml

@@ -1,8 +1,8 @@
-use crate::db::Database;
 use anyhow::Context;
 use postgresql_embedded::{PostgreSQL, Settings, VersionReq};
 use std::path::Path;
 use tracing::{Instrument, info_span};
+use trustify_common::db::Database;
 
 /// Create common default settings for the embedded database
 fn default_settings() -> anyhow::Result<Settings> {
@@ -62,7 +62,7 @@ async fn create_for(settings: Settings) -> anyhow::Result<(Database, PostgreSQL)
         port: postgresql.settings().port,
         ..crate::config::Database::from_env()?
     };
-    let db = Database::bootstrap(&config)
+    let db = super::Database::bootstrap(&config)
         .await
         .context("Bootstrapping the test database")?;
 

common/src/db/embedded.rs renamed to common/db/src/embedded.rs

@@ -0,0 +1,67 @@
+pub mod embedded;
+
+use anyhow::ensure;
+use migration::Migrator;
+use sea_orm::{ConnectionTrait, Statement};
+use sea_orm_migration::prelude::MigratorTrait;
+use tracing::instrument;
+use trustify_common::{config, db};
+
+pub struct Database<'a>(pub &'a db::Database);
+
+impl<'a> Database<'a> {
+    #[instrument(skip(self), err)]
+    pub async fn migrate(&self) -> Result<(), anyhow::Error> {
+        log::debug!("applying migrations");
+        Migrator::up(self.0, None).await?;
+        log::debug!("applied migrations");
+
+        Ok(())
+    }
+
+    #[instrument(skip(self), err)]
+    pub async fn refresh(&self) -> Result<(), anyhow::Error> {
+        log::warn!("refreshing database schema...");
+        Migrator::refresh(self.0).await?;
+        log::warn!("refreshing database schema... done!");
+
+        Ok(())
+    }
+
+    #[instrument(err)]
+    pub async fn bootstrap(database: &config::Database) -> Result<db::Database, anyhow::Error> {
+        ensure!(
+            database.url.is_none(),
+            "Unable to bootstrap database with '--db-url'"
+        );
+
+        let url = crate::config::Database {
+            name: "postgres".into(),
+            ..database.clone()
+        }
+        .to_url();
+
+        log::debug!("bootstrap to {}", url);
+        let db = sea_orm::Database::connect(url).await?;
+
+        db.execute(Statement::from_string(
+            db.get_database_backend(),
+            format!("DROP DATABASE IF EXISTS \"{}\";", database.name),
+        ))
+        .await?;
+
+        db.execute(Statement::from_string(
+            db.get_database_backend(),
+            format!("CREATE DATABASE \"{}\";", database.name),
+        ))
+        .await?;
+        db.close().await?;
+
+        let db = db::Database::new(database).await?;
+        db.execute_unprepared("CREATE EXTENSION IF NOT EXISTS \"pg_stat_statements\";")
+            .await?;
+        Database(&db).migrate().await?;
+
+        Ok(db)
+    }
+}

common/db/src/lib.rs

@@ -1,4 +1,4 @@
-use migration::Iden;
+use sea_orm::Iden;
 use sea_orm::{ConnectionTrait, DbErr, ExecResult};
 use sea_query::{Func, SelectStatement};
 use std::fmt::Write;

common/src/db/func.rs

@@ -1,21 +1,19 @@
-mod func;
-
 pub mod chunk;
-pub mod embedded;
 pub mod limiter;
 pub mod multi_model;
 pub mod query;
 
+mod func;
 pub use func::*;
 
-use anyhow::{Context, ensure};
-use migration::{Migrator, MigratorTrait};
+use anyhow::Context;
 use reqwest::Url;
 use sea_orm::{
     AccessMode, ConnectOptions, ConnectionTrait, DatabaseConnection, DatabaseTransaction,
     DbBackend, DbErr, ExecResult, IsolationLevel, QueryResult, RuntimeErr, Statement, StreamTrait,
     TransactionError, TransactionTrait, prelude::async_trait,
 };
+use sea_orm_migration::{IntoSchemaManagerConnection, SchemaManagerConnection};
 use sqlx::error::ErrorKind;
 use std::{
     ops::{Deref, DerefMut},
@@ -24,6 +22,23 @@ use std::{
 };
 use tracing::instrument;
 
+/// A trait to help working with database errors
+pub trait DatabaseErrors {
+    /// return `true` if the error is a duplicate key error
+    fn is_duplicate(&self) -> bool;
+}
+
+impl DatabaseErrors for DbErr {
+    fn is_duplicate(&self) -> bool {
+        match self {
+            DbErr::Query(RuntimeErr::SqlxError(sqlx::error::Error::Database(err))) => {
+                err.kind() == ErrorKind::UniqueViolation
+            }
+            _ => false,
+        }
+    }
+}
+
 #[derive(Clone, Debug)]
 pub struct Database {
     /// the database connection
@@ -57,61 +72,6 @@ impl Database {
         Ok(Self { db, name })
     }
 
-    #[instrument(skip(self), err)]
-    pub async fn migrate(&self) -> Result<(), anyhow::Error> {
-        log::debug!("applying migrations");
-        Migrator::up(&self.db, None).await?;
-        log::debug!("applied migrations");
-
-        Ok(())
-    }
-
-    #[instrument(skip(self), err)]
-    pub async fn refresh(&self) -> Result<(), anyhow::Error> {
-        log::warn!("refreshing database schema...");
-        Migrator::refresh(&self.db).await?;
-        log::warn!("refreshing database schema... done!");
-
-        Ok(())
-    }
-
-    #[instrument(err)]
-    pub async fn bootstrap(database: &crate::config::Database) -> Result<Self, anyhow::Error> {
-        ensure!(
-            database.url.is_none(),
-            "Unable to bootstrap database with '--db-url'"
-        );
-
-        let url = crate::config::Database {
-            name: "postgres".into(),
-            ..database.clone()
-        }
-        .to_url();
-
-        log::debug!("bootstrap to {}", url);
-        let db = sea_orm::Database::connect(url).await?;
-
-        db.execute(Statement::from_string(
-            db.get_database_backend(),
-            format!("DROP DATABASE IF EXISTS \"{}\";", database.name),
-        ))
-        .await?;
-
-        db.execute(Statement::from_string(
-            db.get_database_backend(),
-            format!("CREATE DATABASE \"{}\";", database.name),
-        ))
-        .await?;
-        db.close().await?;
-
-        let db = Self::new(database).await?;
-        db.execute_unprepared("CREATE EXTENSION IF NOT EXISTS \"pg_stat_statements\";")
-            .await?;
-        db.migrate().await?;
-
-        Ok(db)
-    }
-
     #[instrument(skip(self), err)]
     pub async fn close(self) -> anyhow::Result<()> {
         Ok(self.db.close().await?)
@@ -286,20 +246,9 @@ impl<'b> StreamTrait for &'b Database {
     }
 }
 
-/// A trait to help working with database errors
-pub trait DatabaseErrors {
-    /// return `true` if the error is a duplicate key error
-    fn is_duplicate(&self) -> bool;
-}
-
-impl DatabaseErrors for DbErr {
-    fn is_duplicate(&self) -> bool {
-        match self {
-            DbErr::Query(RuntimeErr::SqlxError(sqlx::error::Error::Database(err))) => {
-                err.kind() == ErrorKind::UniqueViolation
-            }
-            _ => false,
-        }
+impl<'a> IntoSchemaManagerConnection<'a> for &'a Database {
+    fn into_schema_manager_connection(self) -> SchemaManagerConnection<'a> {
+        self.db.into_schema_manager_connection()
     }
 }