implement account_manager

Cargo.lock

···
  "regex",
  "reqwest 0.12.15",
  "reqwest-middleware",
- "rocket_sync_db_pools",
  "rsky-common",
  "rsky-lexicon",
  "rsky-pds",

Cargo.toml

···
 
 [dependencies]
 multihash = "0.19.3"
-diesel = { version = "2.1.5", features = ["chrono", "sqlite", "r2d2"] }
+diesel = { version = "2.1.5", features = [
+    "chrono",
+    "sqlite",
+    "r2d2",
+    "returning_clauses_for_sqlite_3_35",
+] }
 diesel_migrations = { version = "2.1.0" }
 r2d2 = "0.8.10"
 
···
 lazy_static = "1.5.0"
 secp256k1 = "0.28.2"
 dotenvy = "0.15.7"
-deadpool-diesel = { version = "0.6.1", features = ["serde", "sqlite", "tracing"] }
-[dependencies.rocket_sync_db_pools]
-version = "=0.1.0"
-features = ["diesel_sqlite_pool"]
+deadpool-diesel = { version = "0.6.1", features = [
+    "serde",
+    "sqlite",
+    "tracing",
+] }

src/account_manager/helpers/account.rs

···
 use rsky_lexicon::com::atproto::admin::StatusAttr;
 #[expect(unused_imports)]
 pub(crate) use rsky_pds::account_manager::helpers::account::{
-    AccountStatus, ActorAccount, ActorJoinAccount, AvailabilityFlags, BoxedQuery,
-    FormattedAccountStatus, GetAccountAdminStatusOutput, format_account_status, select_account_qb,
+    AccountStatus, ActorAccount, ActorJoinAccount, AvailabilityFlags, FormattedAccountStatus,
+    GetAccountAdminStatusOutput, format_account_status,
 };
 use rsky_pds::schema::pds::account::dsl as AccountSchema;
 use rsky_pds::schema::pds::actor::dsl as ActorSchema;
···
     UserAlreadyExistsError,
     #[error("DatabaseError: `{0}`")]
     DieselError(String),
+}
+
+pub type BoxedQuery<'life> = dsl::IntoBoxed<'life, ActorJoinAccount, sqlite::Sqlite>;
+pub fn select_account_qb(flags: Option<AvailabilityFlags>) -> BoxedQuery<'static> {
+    let AvailabilityFlags {
+        include_taken_down,
+        include_deactivated,
+    } = flags.unwrap_or_else(|| AvailabilityFlags {
+        include_taken_down: Some(false),
+        include_deactivated: Some(false),
+    });
+    let include_taken_down = include_taken_down.unwrap_or(false);
+    let include_deactivated = include_deactivated.unwrap_or(false);
+
+    let mut builder = ActorSchema::actor
+        .left_join(AccountSchema::account.on(ActorSchema::did.eq(AccountSchema::did)))
+        .into_boxed();
+    if !include_taken_down {
+        builder = builder.filter(ActorSchema::takedownRef.is_null());
+    }
+    if !include_deactivated {
+        builder = builder.filter(ActorSchema::deactivatedAt.is_null());
+    }
+    builder
 }
 
 pub async fn get_account(
···
                 ))
                 .execute(conn)
         })
-        .await;
+        .await
+        .expect("Failed to update email");
 
     match res {
         Ok(_) => Ok(()),

src/account_manager/helpers/email_token.rs

···
 use rsky_common::time::{MINUTE, from_str_to_utc, less_than_ago_s};
 use rsky_pds::apis::com::atproto::server::get_random_token;
 use rsky_pds::models::EmailToken;
-use rsky_pds::models::models::EmailTokenPurpose;
 
 pub async fn create_email_token(
     did: &str,
···
         Ok(res.did)
     } else {
         bail!("Token is invalid")
+    }
+}
+
+#[derive(
+    Clone,
+    Copy,
+    Debug,
+    PartialEq,
+    Eq,
+    Hash,
+    Default,
+    serde::Serialize,
+    serde::Deserialize,
+    AsExpression,
+)]
+#[diesel(sql_type = sql_types::Text)]
+pub enum EmailTokenPurpose {
+    #[default]
+    ConfirmEmail,
+    UpdateEmail,
+    ResetPassword,
+    DeleteAccount,
+    PlcOperation,
+}
+
+impl EmailTokenPurpose {
+    pub fn as_str(&self) -> &'static str {
+        match self {
+            EmailTokenPurpose::ConfirmEmail => "confirm_email",
+            EmailTokenPurpose::UpdateEmail => "update_email",
+            EmailTokenPurpose::ResetPassword => "reset_password",
+            EmailTokenPurpose::DeleteAccount => "delete_account",
+            EmailTokenPurpose::PlcOperation => "plc_operation",
+        }
+    }
+
+    pub fn from_str(s: &str) -> Result<Self> {
+        match s {
+            "confirm_email" => Ok(EmailTokenPurpose::ConfirmEmail),
+            "update_email" => Ok(EmailTokenPurpose::UpdateEmail),
+            "reset_password" => Ok(EmailTokenPurpose::ResetPassword),
+            "delete_account" => Ok(EmailTokenPurpose::DeleteAccount),
+            "plc_operation" => Ok(EmailTokenPurpose::PlcOperation),
+            _ => bail!("Unable to parse as EmailTokenPurpose: `{s:?}`"),
+        }
+    }
+}
+
+impl<DB> Queryable<sql_types::Text, DB> for EmailTokenPurpose
+where
+    DB: backend::Backend,
+    String: deserialize::FromSql<sql_types::Text, DB>,
+{
+    type Row = String;
+
+    fn build(s: String) -> deserialize::Result<Self> {
+        Ok(EmailTokenPurpose::from_str(&s)?)
+    }
+}
+
+impl serialize::ToSql<sql_types::Text, sqlite::Sqlite> for EmailTokenPurpose
+where
+    String: serialize::ToSql<sql_types::Text, sqlite::Sqlite>,
+{
+    fn to_sql<'lifetime>(
+        &'lifetime self,
+        out: &mut serialize::Output<'lifetime, '_, sqlite::Sqlite>,
+    ) -> serialize::Result {
+        serialize::ToSql::<sql_types::Text, sqlite::Sqlite>::to_sql(
+            match self {
+                EmailTokenPurpose::ConfirmEmail => "confirm_email",
+                EmailTokenPurpose::UpdateEmail => "update_email",
+                EmailTokenPurpose::ResetPassword => "reset_password",
+                EmailTokenPurpose::DeleteAccount => "delete_account",
+                EmailTokenPurpose::PlcOperation => "plc_operation",
+            },
+            out,
+        )
     }
 }
 

src/account_manager/helpers/password.rs

···
 //! blacksky-algorithms/rsky is licensed under the Apache License 2.0
 //!
 //! Modified for SQLite backend
-use anyhow::{Result, anyhow, bail};
-use argon2::{
-    Argon2,
-    password_hash::{PasswordHash, PasswordHasher, PasswordVerifier, SaltString, rand_core::OsRng},
-};
-// use base64ct::{Base64, Encoding};
+use anyhow::{Result, bail};
 use diesel::*;
 use rsky_common::{get_random_str, now};
 use rsky_lexicon::com::atproto::server::CreateAppPasswordOutput;

src/account_manager/mod.rs

···
 use cidv10::Cid;
 use diesel::*;
 use futures::try_join;
+use helpers::email_token::EmailTokenPurpose;
 use helpers::{account, auth, email_token, invite, password, repo};
 use rsky_common::RFC3339_VARIANT;
 use rsky_common::time::{HOUR, from_micros_to_str, from_str_to_micros};
···
     UpdateAccountPasswordOpts, UpdateEmailOpts,
 };
 use rsky_pds::auth_verifier::AuthScope;
-use rsky_pds::models::models::EmailTokenPurpose;
 use secp256k1::{Keypair, Secp256k1, SecretKey};
 use std::collections::BTreeMap;
 use std::env;