prototype auth

src/actor_endpoints.rs

···
 use constcat::concat;
 use diesel::prelude::*;
 
+use crate::actor_store::ActorStore;
+
 use super::*;
 
 async fn put_preferences(
···
     let json_string =
         serde_json::to_string(&input.preferences).context("failed to serialize preferences")?;
 
-    let conn = &mut actor_pools
-        .get(&did)
-        .context("failed to get actor pool")?
-        .repo
-        .get()
-        .await
-        .expect("failed to get database connection");
-    conn.interact(move |conn| {
-        diesel::update(accounts::table)
-            .filter(accounts::did.eq(did))
-            .set(accounts::private_prefs.eq(json_string))
-            .execute(conn)
-            .context("failed to update user preferences")
-    });
-
+    // let conn = &mut actor_pools
+    //     .get(&did)
+    //     .context("failed to get actor pool")?
+    //     .repo
+    //     .get()
+    //     .await
+    //     .expect("failed to get database connection");
+    // conn.interact(move |conn| {
+    //     diesel::update(accounts::table)
+    //         .filter(accounts::did.eq(did))
+    //         .set(accounts::private_prefs.eq(json_string))
+    //         .execute(conn)
+    //         .context("failed to update user preferences")
+    // });
+    todo!("Use actor_store's preferences writer instead");
     Ok(())
 }
 
···
     State(actor_pools): State<std::collections::HashMap<String, ActorPools>>,
 ) -> Result<Json<actor::get_preferences::Output>> {
     let did = user.did();
-    let conn = &mut actor_pools
-        .get(&did)
-        .context("failed to get actor pool")?
-        .repo
-        .get()
-        .await
-        .expect("failed to get database connection");
+    // let conn = &mut actor_pools
+    //     .get(&did)
+    //     .context("failed to get actor pool")?
+    //     .repo
+    //     .get()
+    //     .await
+    //     .expect("failed to get database connection");
 
-    #[derive(QueryableByName)]
-    struct Prefs {
-        #[diesel(sql_type = diesel::sql_types::Text)]
-        private_prefs: Option<String>,
-    }
+    // #[derive(QueryableByName)]
+    // struct Prefs {
+    //     #[diesel(sql_type = diesel::sql_types::Text)]
+    //     private_prefs: Option<String>,
+    // }
 
-    let result = conn
-        .interact(move |conn| {
-            diesel::sql_query("SELECT private_prefs FROM accounts WHERE did = ?")
-                .bind::<diesel::sql_types::Text, _>(did)
-                .get_result::<Prefs>(conn)
-        })
-        .await
-        .expect("failed to fetch preferences");
+    // let result = conn
+    //     .interact(move |conn| {
+    //         diesel::sql_query("SELECT private_prefs FROM accounts WHERE did = ?")
+    //             .bind::<diesel::sql_types::Text, _>(did)
+    //             .get_result::<Prefs>(conn)
+    //     })
+    //     .await
+    //     .expect("failed to fetch preferences");
 
-    if let Some(prefs_json) = result.private_prefs {
-        let prefs: actor::defs::Preferences =
-            serde_json::from_str(&prefs_json).context("failed to deserialize preferences")?;
+    // if let Some(prefs_json) = result.private_prefs {
+    //     let prefs: actor::defs::Preferences =
+    //         serde_json::from_str(&prefs_json).context("failed to deserialize preferences")?;
 
-        Ok(Json(
-            actor::get_preferences::OutputData { preferences: prefs }.into(),
-        ))
-    } else {
-        Ok(Json(
-            actor::get_preferences::OutputData {
-                preferences: Vec::new(),
-            }
-            .into(),
-        ))
-    }
+    //     Ok(Json(
+    //         actor::get_preferences::OutputData { preferences: prefs }.into(),
+    //     ))
+    // } else {
+    //     Ok(Json(
+    //         actor::get_preferences::OutputData {
+    //             preferences: Vec::new(),
+    //         }
+    //         .into(),
+    //     ))
+    // }
+    todo!("Use actor_store's preferences writer instead");
 }
 
 /// Register all actor endpoints.

src/auth.rs

···
 
     // Extract subject (DID)
     if let Some(did) = claims.get("sub").and_then(serde_json::Value::as_str) {
-        use crate::schema::accounts::dsl as AccountSchema;
+        use rsky_pds::schema::pds::account::dsl as AccountSchema;
+        let did_clone = did.to_owned();
 
-        let _status = state
+        let _did = state
             .db
             .get()
             .await
             .expect("failed to get db connection")
             .interact(move |conn| {
-                AccountSchema::accounts
-                    .filter(AccountSchema::did.eq(did.to_string()))
-                    .select(AccountSchema::status)
+                AccountSchema::account
+                    .filter(AccountSchema::did.eq(did_clone))
+                    .select(AccountSchema::did)
                     .first::<String>(conn)
             })
             .await
-            .with_context(|| format!("failed to query account {did}"))
-            .context("should fetch account status")?;
+            .expect("failed to query account");
 
         Ok(AuthenticatedUser {
             did: did.to_owned(),
···
 
     let timestamp = chrono::Utc::now().timestamp();
 
-    use crate::schema::oauth_used_jtis::dsl as JtiSchema;
+    use crate::schema::pds::oauth_used_jtis::dsl as JtiSchema;
 
     // Check if JTI has been used before
     let jti_string = jti.to_string();
···
                 .get_result::<i64>(conn)
         })
         .await
-        .context("failed to check JTI")?;
+        .expect("failed to query JTI")
+        .expect("failed to get JTI count");
 
     if jti_used > 0 {
         return Err(Error::with_status(
···
                 .execute(conn)
         })
         .await
-        .context("failed to store JTI")?;
+        .expect("failed to insert JTI")
+        .expect("failed to insert JTI");
 
     // Extract subject (DID) from access token
-    if let Some(did) = claims.get("sub").and_then(|v| v.as_str) {
-        use crate::schema::accounts::dsl as AccountSchema;
+    if let Some(did) = claims.get("sub").and_then(|v| v.as_str()) {
+        use rsky_pds::schema::pds::account::dsl as AccountSchema;
 
-        let _status = state
+        let did_clone = did.to_owned();
+
+        let _did = state
             .db
             .get()
             .await
             .expect("failed to get db connection")
             .interact(move |conn| {
-                AccountSchema::accounts
-                    .filter(AccountSchema::did.eq(did.to_string()))
-                    .select(AccountSchema::status)
+                AccountSchema::account
+                    .filter(AccountSchema::did.eq(did_clone))
+                    .select(AccountSchema::did)
                     .first::<String>(conn)
             })
             .await
-            .with_context(|| format!("failed to query account {did}"))
-            .context("should fetch account status")?;
+            .expect("failed to query account")
+            .expect("failed to get account");
 
         Ok(AuthenticatedUser {
             did: did.to_owned(),

src/main.rs

···
 mod mmap;
 mod oauth;
 mod plc;
+mod schema;
 #[cfg(test)]
 mod tests;
 

src/schema.rs

···
+pub mod pds {
+
+    // Legacy tables
+
+    diesel::table! {
+        pds.oauth_par_requests (request_uri) {
+            request_uri -> Varchar,
+            client_id -> Varchar,
+            response_type -> Varchar,
+            code_challenge -> Varchar,
+            code_challenge_method -> Varchar,
+            state -> Nullable<Varchar>,
+            login_hint -> Nullable<Varchar>,
+            scope -> Nullable<Varchar>,
+            redirect_uri -> Nullable<Varchar>,
+            response_mode -> Nullable<Varchar>,
+            display -> Nullable<Varchar>,
+            created_at -> Int8,
+            expires_at -> Int8,
+        }
+    }
+    diesel::table! {
+        pds.oauth_authorization_codes (code) {
+            code -> Varchar,
+            client_id -> Varchar,
+            subject -> Varchar,
+            code_challenge -> Varchar,
+            code_challenge_method -> Varchar,
+            redirect_uri -> Varchar,
+            scope -> Nullable<Varchar>,
+            created_at -> Int8,
+            expires_at -> Int8,
+            used -> Bool,
+        }
+    }
+    diesel::table! {
+        pds.oauth_refresh_tokens (token) {
+            token -> Varchar,
+            client_id -> Varchar,
+            subject -> Varchar,
+            dpop_thumbprint -> Varchar,
+            scope -> Nullable<Varchar>,
+            created_at -> Int8,
+            expires_at -> Int8,
+            revoked -> Bool,
+        }
+    }
+    diesel::table! {
+        pds.oauth_used_jtis (jti) {
+            jti -> Varchar,
+            issuer -> Varchar,
+            created_at -> Int8,
+            expires_at -> Int8,
+        }
+    }
+
+    // Upcoming tables
+
+    diesel::table! {
+        pds.authorization_request (id) {
+            id -> Varchar,
+            did -> Nullable<Varchar>,
+            deviceId -> Nullable<Varchar>,
+            clientId -> Varchar,
+            clientAuth -> Varchar,
+            parameters -> Varchar,
+            expiresAt -> Timestamptz,
+            code -> Nullable<Varchar>,
+        }
+    }
+
+    diesel::table! {
+        pds.device (id) {
+            id -> Varchar,
+            sessionId -> Nullable<Varchar>,
+            userAgent -> Nullable<Varchar>,
+            ipAddress -> Varchar,
+            lastSeenAt -> Timestamptz,
+        }
+    }
+
+    diesel::table! {
+        pds.device_account (deviceId, did) {
+            did -> Varchar,
+            deviceId -> Varchar,
+            authenticatedAt -> Timestamptz,
+            remember -> Bool,
+            authorizedClients -> Varchar,
+        }
+    }
+
+    diesel::table! {
+        pds.token (id) {
+            id -> Varchar,
+            did -> Varchar,
+            tokenId -> Varchar,
+            createdAt -> Timestamptz,
+            updatedAt -> Timestamptz,
+            expiresAt -> Timestamptz,
+            clientId -> Varchar,
+            clientAuth -> Varchar,
+            deviceId -> Nullable<Varchar>,
+            parameters -> Varchar,
+            details -> Nullable<Varchar>,
+            code -> Nullable<Varchar>,
+            currentRefreshToken -> Nullable<Varchar>,
+        }
+    }
+
+    diesel::table! {
+        pds.used_refresh_token (refreshToken) {
+            refreshToken -> Varchar,
+            tokenId -> Varchar,
+        }
+    }
+}