feat: db migrations tool and db client

.env_sample

@@ -0,0 +1,2 @@
+export POSTGRES_DATABASE_URL="postgres://postgres:password@localhost:5432/postgres"
+export MARIA_DATABASE_URL="mysql://maria:password@localhost:3306/maria"

build.rs

@@ -0,0 +1,26 @@
+/*
+ * Copyright (C) 2021  Aravinth Manivannan <realaravinth@batsense.net>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+use std::process::Command;
+
+fn main() {
+    let output = Command::new("git")
+        .args(["rev-parse", "HEAD"])
+        .output()
+        .expect("error in git command, is git installed?");
+    let git_hash = String::from_utf8(output.stdout).unwrap();
+    println!("cargo:rustc-env=GIT_HASH={}", git_hash);
+}

db/migrations/.gitignore

@@ -0,0 +1,2 @@
+/target
+target/

db/migrations/Cargo.toml

@@ -0,0 +1,13 @@
+[package]
+name = "db-migrations"
+version = "0.1.0"
+edition = "2021"
+homepage = "https://mcaptcha.org"
+repository = "https://github.com/mCaptcha/mCaptcha"
+documentation = "https://mcaptcha.org/docs/"
+license = "AGPLv3 or later version"
+authors = ["realaravinth <realaravinth@batsense.net>"]
+
+[dependencies]
+actix-rt = "2"
+sqlx = { version = "0.6.1", features = [ "runtime-actix-rustls", "postgres", "time", "offline"] }

db/migrations/src/main.rs

@@ -0,0 +1,29 @@
+// Copyright (C) 2022  Aravinth Manivannan <realaravinth@batsense.net>
+// SPDX-FileCopyrightText: 2023 Aravinth Manivannan <realaravinth@batsense.net>
+//
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+use std::env;
+
+use sqlx::postgres::PgPoolOptions;
+
+#[cfg(not(tarpaulin_include))]
+#[actix_rt::main]
+async fn main() {
+    //TODO featuregate sqlite and postgres
+    postgres_migrate().await;
+}
+
+async fn postgres_migrate() {
+    let db_url = env::var("DATABASE_URL").expect("set POSTGRES_DATABASE_URL env var");
+    let db = PgPoolOptions::new()
+        .max_connections(2)
+        .connect(&db_url)
+        .await
+        .expect("Unable to form database pool");
+
+//    sqlx::migrate!("../../migrations/")
+//        .run(&db)
+//        .await
+//        .unwrap();
+}

src/db.rs

@@ -0,0 +1,167 @@
+/*
+ * Copyright (C) 2022  Aravinth Manivannan <realaravinth@batsense.net>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+use std::str::FromStr;
+
+use sqlx::postgres::PgPoolOptions;
+use sqlx::types::time::OffsetDateTime;
+use sqlx::ConnectOptions;
+use sqlx::PgPool;
+
+use crate::errors::*;
+
+/// Connect to databse
+pub enum ConnectionOptions {
+    /// fresh connection
+    Fresh(Fresh),
+    /// existing connection
+    Existing(Conn),
+}
+
+/// Use an existing database pool
+pub struct Conn(pub PgPool);
+
+pub struct Fresh {
+    pub pool_options: PgPoolOptions,
+    pub disable_logging: bool,
+    pub url: String,
+}
+
+impl ConnectionOptions {
+    async fn connect(self) -> ServiceResult<Database> {
+        let pool = match self {
+            Self::Fresh(fresh) => {
+                let mut connect_options =
+                    sqlx::postgres::PgConnectOptions::from_str(&fresh.url).unwrap();
+                if fresh.disable_logging {
+                    connect_options.disable_statement_logging();
+                }
+                sqlx::postgres::PgConnectOptions::from_str(&fresh.url)
+                    .unwrap()
+                    .disable_statement_logging();
+                fresh
+                    .pool_options
+                    .connect_with(connect_options)
+                    .await
+                    .unwrap()
+            }
+
+            Self::Existing(conn) => conn.0,
+        };
+        Ok(Database { pool })
+    }
+}
+
+#[derive(Clone)]
+pub struct Database {
+    pub pool: PgPool,
+}
+
+impl Database {
+    pub async fn migrate(&self) -> ServiceResult<()> {
+        sqlx::migrate!("./migrations/")
+            .run(&self.pool)
+            .await
+            .unwrap();
+        Ok(())
+    }
+
+    pub async fn ping(&self) -> bool {
+        use sqlx::Connection;
+
+        if let Ok(mut con) = self.pool.acquire().await {
+            con.ping().await.is_ok()
+        } else {
+            false
+        }
+    }
+}
+
+fn now_unix_time_stamp() -> OffsetDateTime {
+    OffsetDateTime::now_utc()
+}
+
+pub async fn get_db(settings: &crate::settings::Settings) -> Database {
+    let pool_options = PgPoolOptions::new().max_connections(settings.database.pool);
+    ConnectionOptions::Fresh(Fresh {
+        pool_options,
+        url: settings.database.url.clone(),
+        disable_logging: !settings.debug,
+    })
+    .connect()
+    .await
+    .unwrap()
+}
+
+/// map custom row not found error to DB error
+pub fn map_row_not_found_err(e: sqlx::Error, row_not_found: ServiceError) -> ServiceError {
+    if let sqlx::Error::RowNotFound = e {
+        row_not_found
+    } else {
+        map_register_err(e)
+    }
+}
+
+/// map postgres errors to [ServiceError](ServiceError) types
+fn map_register_err(e: sqlx::Error) -> ServiceError {
+    use sqlx::Error;
+    use std::borrow::Cow;
+
+    if let Error::Database(err) = e {
+        if err.code() == Some(Cow::from("23505")) {
+            let msg = err.message();
+            unimplemented!("{}", msg);
+        //            if msg.contains("librepages_users_name_key") {
+        //                ServiceError::UsernameTaken
+        //            } else {
+        //                error!("{}", msg);
+        //                ServiceError::InternalServerError
+        //            }
+        } else {
+            ServiceError::InternalServerError
+        }
+    } else {
+        ServiceError::InternalServerError
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::settings::Settings;
+
+    #[actix_rt::test]
+    async fn db_works() {
+        let settings = Settings::new().unwrap();
+        let pool_options = PgPoolOptions::new().max_connections(1);
+        let db = ConnectionOptions::Fresh(Fresh {
+            pool_options,
+            url: settings.database.url.clone(),
+            disable_logging: !settings.debug,
+        })
+        .connect()
+        .await
+        .unwrap();
+        assert!(db.ping().await);
+
+        const EMAIL: &str = "postgresuser@foo.com";
+        const EMAIL2: &str = "postgresuser2@foo.com";
+        const NAME: &str = "postgresuser";
+        const PASSWORD: &str = "pasdfasdfasdfadf";
+
+        db.migrate().await.unwrap();
+    }
+}