feat(orm): postgres support (#70)

In addition to that, this also adds tests that use Postgres, and a way
to run raw SQL queries.

There's some opportunity to do some deduplication between Sqlite and
Postgres code, but let's wait for it until MySQL support lands.

Author: m4tx

.github/workflows/rust.yml

@@ -81,6 +81,42 @@ jobs:
       - name: Run clippy
         run: cargo clippy --no-deps -- -Dclippy::all -Wclippy::pedantic
 
+  external-deps:
+    if: github.event_name == 'push' || github.event_name == 'schedule' ||
+      github.event.pull_request.head.repo.full_name != github.repository
+
+    name: Test with external dependencies
+    runs-on: ubuntu-latest
+    needs: ["build"]
+    steps:
+      - name: Checkout source
+        uses: actions/checkout@v4
+
+      - name: Install Rust toolchain
+        uses: dtolnay/rust-toolchain@master
+        with:
+          toolchain: nightly
+
+      - name: Cache Cargo registry
+        uses: Swatinem/rust-cache@v2
+
+      - name: Install cargo-nextest
+        uses: taiki-e/install-action@v2
+        with:
+          tool: nextest
+
+      - name: Build
+        run: cargo build
+
+      - name: Run the external dependencies
+        run: docker compose up -d
+
+      - name: Test
+        run: cargo nextest run --all-features -- --include-ignored
+
+      - name: Test docs
+        run: cargo test --doc
+
   coverage:
     if: github.event_name == 'push' || github.event_name == 'schedule' ||
       github.event.pull_request.head.repo.full_name != github.repository
@@ -101,8 +137,11 @@ jobs:
       - name: Cache Cargo registry
         uses: Swatinem/rust-cache@v2
 
+      - name: Run the external dependencies
+        run: docker compose up -d
+
       - name: Test
-        run: cargo test --all-features --no-fail-fast
+        run: cargo test --all-features --no-fail-fast -- --include-ignored
         env:
           RUSTFLAGS: "-Cinstrument-coverage"
 

Cargo.toml

@@ -63,11 +63,11 @@ rand = "0.8"
 regex = "1.11"
 rustversion = "1"
 sea-query = "0.32.0-rc.2"
-sea-query-binder = { version = "0.7.0-rc.2", features = ["sqlx-sqlite", "with-chrono", "runtime-tokio"] }
+sea-query-binder = { version = "0.7.0-rc.2", features = ["sqlx-sqlite", "sqlx-postgres", "with-chrono", "runtime-tokio"] }
 serde = "1"
 sha2 = "0.11.0-pre.4"
 slug = "0.1"
-sqlx = { version = "0.8", default-features = false, features = ["macros", "json", "runtime-tokio", "sqlite", "chrono"] }
+sqlx = { version = "0.8", default-features = false, features = ["macros", "json", "runtime-tokio", "sqlite", "postgres", "chrono"] }
 subtle = "2"
 syn = { version = "2", features = ["full", "extra-traits"] }
 sync_wrapper = "1"

README.md

@@ -28,6 +28,24 @@ built on top of [axum](https://github.com/tokio-rs/axum).
 * **Secure by default** — security should be opt-out, not opt-in. Flareon takes care of making your web apps secure by
   default, defending it against common modern web vulnerabilities. You can focus on building your app, not securing it.
 
+## Development
+
+### Testing
+
+Tests that require using external databases are ignored by default. In order to run them, execute the following in the
+root of the repository:
+
+```shell
+docker compose up -d
+cargo test --all-features -- --include-ignored
+```
+
+You can them execute the following command to stop the database:
+
+```shell
+docker compose down
+```
+
 ## License
 
 Flareon is licensed under either of the following, at your option:

compose.yml

@@ -0,0 +1,10 @@
+services:
+  postgres:
+    image: postgres:16-alpine
+    container_name: flareon-postgres
+    restart: always
+    environment:
+      POSTGRES_USER: flareon
+      POSTGRES_PASSWORD: flareon
+    ports:
+      - "5432:5432"

flareon-cli/src/migration_generator.rs

@@ -540,13 +540,14 @@ impl AppState {
 ///
 /// For instance, for `use std::collections::HashMap;` the `VisibleSymbol `
 /// would be:
-///
 /// ```ignore
+/// # /*
 /// VisibleSymbol {
 ///     alias: "HashMap",
 ///     full_path: "std::collections::HashMap",
 ///     kind: VisibleSymbolKind::Use,
 /// }
+/// # */
 /// ```
 #[derive(Debug, Clone, PartialEq, Eq)]
 struct VisibleSymbol {

flareon-macros/src/dbtest.rs

@@ -0,0 +1,44 @@
+use proc_macro2::TokenStream;
+use quote::{format_ident, quote};
+use syn::ItemFn;
+
+pub(super) fn fn_to_dbtest(test_function_decl: ItemFn) -> syn::Result<TokenStream> {
+    let test_fn = &test_function_decl.sig.ident;
+    let sqlite_ident = format_ident!("{}_sqlite", test_fn);
+    let postgres_ident = format_ident!("{}_postgres", test_fn);
+
+    if test_function_decl.sig.inputs.len() != 1 {
+        return Err(syn::Error::new_spanned(
+            test_function_decl.sig.inputs,
+            "Database test function must have exactly one argument",
+        ));
+    }
+
+    let result = quote! {
+        #[::tokio::test]
+        async fn #sqlite_ident() {
+            let mut database = flareon::test::TestDatabase::new_sqlite().await.unwrap();
+
+            #test_fn(&mut database).await;
+
+            database.cleanup().await.unwrap();
+
+            #test_function_decl
+        }
+
+        #[ignore]
+        #[::tokio::test]
+        async fn #postgres_ident() {
+            let mut database = flareon::test::TestDatabase::new_postgres(stringify!(#test_fn))
+                .await
+                .unwrap();
+
+            #test_fn(&mut database).await;
+
+            database.cleanup().await.unwrap();
+
+            #test_function_decl
+        }
+    };
+    Ok(result)
+}

flareon-macros/src/lib.rs

@@ -1,3 +1,4 @@
+mod dbtest;
 mod form;
 mod model;
 mod query;
@@ -7,8 +8,9 @@ use darling::Error;
 use proc_macro::TokenStream;
 use proc_macro_crate::crate_name;
 use quote::quote;
-use syn::parse_macro_input;
+use syn::{parse_macro_input, ItemFn};
 
+use crate::dbtest::fn_to_dbtest;
 use crate::form::impl_form_for_struct;
 use crate::model::impl_model_for_struct;
 use crate::query::{query_to_tokens, Query};
@@ -112,6 +114,14 @@ pub fn query(input: TokenStream) -> TokenStream {
     query_to_tokens(query_input).into()
 }
 
+#[proc_macro_attribute]
+pub fn dbtest(_args: TokenStream, input: TokenStream) -> TokenStream {
+    let fn_input = parse_macro_input!(input as ItemFn);
+    fn_to_dbtest(fn_input)
+        .unwrap_or_else(syn::Error::into_compile_error)
+        .into()
+}
+
 pub(crate) fn flareon_ident() -> proc_macro2::TokenStream {
     let flareon_crate = crate_name("flareon").expect("flareon is not present in `Cargo.toml`");
     match flareon_crate {

flareon/src/auth.rs

@@ -15,6 +15,7 @@ use std::sync::Arc;
 use async_trait::async_trait;
 use chrono::{DateTime, FixedOffset};
 use flareon::config::SecretKey;
+use flareon::db::impl_postgres::PostgresValueRef;
 #[cfg(test)]
 use mockall::automock;
 use password_auth::VerifyError;
@@ -410,6 +411,10 @@ impl FromDbValue for PasswordHash {
     fn from_sqlite(value: SqliteValueRef) -> flareon::db::Result<Self> {
         PasswordHash::new(value.get::<String>()?).map_err(flareon::db::DatabaseError::value_decode)
     }
+
+    fn from_postgres(value: PostgresValueRef) -> flareon::db::Result<Self> {
+        PasswordHash::new(value.get::<String>()?).map_err(flareon::db::DatabaseError::value_decode)
+    }
 }
 
 impl ToDbValue for PasswordHash {

flareon/src/auth/db.rs

@@ -84,13 +84,14 @@ impl DatabaseUser {
     ///
     /// # #[tokio::main]
     /// # async fn main() -> flareon::Result<()> {
-    /// #     use flareon::test::{TestDatabaseBuilder, TestRequestBuilder};
+    /// #     use flareon::test::{TestDatabase, TestRequestBuilder};
+    /// #     let mut test_database = TestDatabase::new_sqlite().await?;
+    /// #     test_database.with_auth().run_migrations().await;
     /// #     let request = TestRequestBuilder::get("/")
-    /// #         .with_db_auth(std::sync::Arc::new(
-    /// #             TestDatabaseBuilder::new().with_auth().build().await,
-    /// #         ))
+    /// #         .with_db_auth(test_database.database())
     /// #         .build();
     /// #     view(&request).await?;
+    /// #     test_database.cleanup().await?;
     /// #     Ok(())
     /// # }
     /// ```