add: icon resolver

add: config "no_track" file list option
add: rainbeam-shared -> tetratto-shared
add: l10n

crates/core/src/database/drivers/postgres.rs

@@ -0,0 +1,100 @@
+use crate::config::Config;
+use bb8_postgres::{
+    PostgresConnectionManager,
+    bb8::{Pool, PooledConnection},
+};
+use tetratto_l10n::{LangFile, read_langs};
+use tokio_postgres::{Config as PgConfig, NoTls, Row, types::ToSql};
+
+pub type Result<T> = std::result::Result<T, tokio_postgres::Error>;
+pub type Connection<'a> = PooledConnection<'a, PostgresConnectionManager<NoTls>>;
+
+#[derive(Clone)]
+pub struct DataManager(
+    pub Config,
+    pub HashMap<String, LangFile>,
+    pub Pool<PostgresConnectionManager<NoTls>>,
+);
+
+impl DataManager {
+    /// Obtain a connection to the staging database.
+    pub(crate) async fn connect(&self) -> Result<Connection> {
+        Ok(self.2.get().await.unwrap())
+    }
+
+    /// Create a new [`DataManager`] (and init database).
+    pub async fn new(config: Config) -> Result<Self> {
+        let manager = PostgresConnectionManager::new(
+            {
+                let mut c = PgConfig::new();
+                c.user(&config.database.user);
+                c.password(&config.database.password);
+                c.dbname(&config.database.name);
+                c
+            },
+            NoTls,
+        );
+        let pool = Pool::builder().max_size(15).build(manager).await.unwrap();
+
+        let this = Self(config.clone(), read_langs(), pool);
+        let c = this.clone();
+        let conn = c.connect().await?;
+
+        conn.execute(super::common::CREATE_TABLE_USERS, &[])
+            .await
+            .unwrap();
+
+        Ok(this)
+    }
+}
+
+#[cfg(feature = "postgres")]
+#[macro_export]
+macro_rules! get {
+    ($row:ident->$idx:literal($t:tt)) => {
+        $row.get::<usize, Option<$t>>($idx).unwrap()
+    };
+}
+
+pub async fn query_row_helper<T, F>(
+    conn: &Connection<'_>,
+    sql: &str,
+    params: &[&(dyn ToSql + Sync)],
+    f: F,
+) -> Result<T>
+where
+    F: FnOnce(&Row) -> Result<T>,
+{
+    let query = conn.prepare(sql).await.unwrap();
+    let res = conn.query_one(&query, params).await;
+
+    if let Ok(row) = res {
+        Ok(f(&row).unwrap())
+    } else {
+        Err(res.unwrap_err())
+    }
+}
+
+#[macro_export]
+macro_rules! query_row {
+    ($conn:expr, $sql:expr, $params:expr, $f:expr) => {
+        crate::database::query_row_helper($conn, $sql, $params, $f).await
+    };
+}
+
+pub async fn execute_helper(
+    conn: &Connection<'_>,
+    sql: &str,
+    params: &[&(dyn ToSql + Sync)],
+) -> Result<()> {
+    let query = conn.prepare(sql).await.unwrap();
+    conn.execute(&query, params).await?;
+    Ok(())
+}
+
+#[macro_export]
+macro_rules! execute {
+    ($conn:expr, $sql:expr, $params:expr) => {
+        crate::database::execute_helper($conn, $sql, $params).await
+    };
+}