authorization_codes: crate, database, insert one

Cargo.lock

@@ -164,6 +164,16 @@ dependencies = [
  "winapi 0.3.9",
 ]
 
+[[package]]
+name = "authorization_codes"
+version = "0.0.0"
+dependencies = [
+ "chrono",
+ "database",
+ "id",
+ "thiserror",
+]
+
 [[package]]
 name = "autocfg"
 version = "1.1.0"

crates/authorization_codes/Cargo.toml

@@ -0,0 +1,12 @@
+[package]
+name = "authorization_codes"
+version = "0.0.0"
+edition = "2021"
+
+[dependencies]
+thiserror = { workspace = true }
+chrono = { workspace = true }
+
+# local crates
+database = { path = "../database" }
+id = { path = "../id" }

crates/authorization_codes/src/database.rs

@@ -0,0 +1,42 @@
+use crate::error::Error;
+use crate::AuthorizationCodes;
+use chrono::{Duration, Utc};
+use database::sqlx::SqliteExecutor;
+use database::AuthorizationCodes as DatabaseAuthorizationCodes;
+use id::{AppID, UserID};
+
+impl From<DatabaseAuthorizationCodes> for AuthorizationCodes {
+    fn from(db: DatabaseAuthorizationCodes) -> Self {
+        Self {
+            // Info
+            code: db.code,
+            app: AppID(db.app),
+            user: UserID(db.user),
+
+            // Timings
+            created_at: db.created_at,
+            expires_at: db.expires_at,
+            used_at: db.used_at,
+        }
+    }
+}
+
+impl AuthorizationCodes {
+    pub async fn insert(
+        conn: impl SqliteExecutor<'_>,
+        code: &str,
+        app: &AppID,
+        user: &UserID,
+    ) -> Result<Option<()>, Error> {
+        let expires_at = Utc::now() + Duration::minutes(10);
+
+        Ok(DatabaseAuthorizationCodes::insert(
+            conn,
+            code,
+            app.as_ref(),
+            user.as_ref(),
+            expires_at.timestamp(),
+        )
+        .await?)
+    }
+}

crates/authorization_codes/src/error.rs

@@ -0,0 +1,8 @@
+// error
+#[derive(thiserror::Error)]
+// the rest
+#[derive(Debug)]
+pub enum Error {
+    #[error("Database: {0}")]
+    Database(#[from] database::Error),
+}

crates/authorization_codes/src/lib.rs

@@ -0,0 +1,20 @@
+mod database;
+mod error;
+
+use chrono::{DateTime, Utc};
+use id::{AppID, UserID};
+
+pub use crate::error::Error;
+
+#[derive(Debug)]
+pub struct AuthorizationCodes {
+    // Info
+    code: String,
+    app: AppID,
+    user: UserID,
+
+    // Timings
+    created_at: DateTime<Utc>,
+    expires_at: DateTime<Utc>,
+    used_at: Option<DateTime<Utc>>,
+}

crates/database/migrations/20230316213207_authorization_codes.down.sql

@@ -0,0 +1 @@
+drop table if exists authorization_codes;

crates/database/migrations/20230316213207_authorization_codes.up.sql

@@ -0,0 +1,12 @@
+create table if not exists authorization_codes
+(
+    -- info
+    code       TEXT not null primary key,
+    app        TEXT not null references apps (id),
+    user       TEXT not null references users (id),
+
+    -- timings
+    created_at TEXT not null default CURRENT_TIMESTAMP,
+    expires_at TEXT not null,
+    used_at    TEXT
+);

crates/database/queries/authorization_codes/insert.sql

@@ -0,0 +1,2 @@
+insert into authorization_codes (code, app, user, expires_at)
+values (?, ?, ?, datetime(?, 'unixepoch'))

crates/database/sqlx-data.json

@@ -302,6 +302,16 @@
     },
     "query": "update settings\n\nset url = ?\n\nwhere id is 0\n"
   },
+  "a55b17a3a70e6445517f19536220f0dafc78a0e8b69221dee4715f84841839da": {
+    "describe": {
+      "columns": [],
+      "nullable": [],
+      "parameters": {
+        "Right": 4
+      }
+    },
+    "query": "insert into authorization_codes (code, app, user, expires_at)\nvalues (?, ?, ?, datetime(?, 'unixepoch'))\n"
+  },
   "aae93a39c5a9f46235b5ef871b45ba76d7efa1677bfe8291a62b8cbf9cd9e0d5": {
     "describe": {
       "columns": [],

crates/database/src/tables.rs

@@ -1,9 +1,11 @@
 mod apps;
+mod authorization_codes;
 mod keys;
 mod settings;
 mod users;
 
 pub use apps::Apps;
+pub use authorization_codes::AuthorizationCodes;
 pub use keys::Keys;
 pub use settings::Settings;
 pub use users::Users;

crates/database/src/tables/authorization_codes.rs

@@ -0,0 +1,40 @@
+use crate::error::{handle_error, Error};
+use sqlx::sqlite::SqliteQueryResult;
+use sqlx::types::chrono::{DateTime, Utc};
+use sqlx::{FromRow, SqliteExecutor};
+
+#[derive(FromRow)]
+pub struct AuthorizationCodes {
+    // Info
+    pub code: String,
+    pub app: String,
+    pub user: String,
+
+    // Timings
+    pub created_at: DateTime<Utc>,
+    pub expires_at: DateTime<Utc>,
+    pub used_at: Option<DateTime<Utc>>,
+}
+
+impl AuthorizationCodes {
+    pub async fn insert(
+        conn: impl SqliteExecutor<'_>,
+        code: &str,
+        app: &str,
+        user: &str,
+        expires_at: i64,
+    ) -> Result<Option<()>, Error> {
+        let query: SqliteQueryResult = sqlx::query_file!(
+            "queries/authorization_codes/insert.sql",
+            code,
+            app,
+            user,
+            expires_at
+        )
+        .execute(conn)
+        .await
+        .map_err(handle_error)?;
+
+        Ok((query.rows_affected() == 1).then_some(()))
+    }
+}