Wrap the database pool in an App struct.

This is a jumping-off point for adding logic that needs more than just the DB for state, such as chat message handling.

The name sucks, but it's the best I've got.

2 files changed, 11 insertions, 15 deletions

diff --git a/src/login/extract/login.rs b/src/login/extract/login.rs
index da0a90e..4155ec2 100644
--- a/src/login/extract/login.rs
+++ b/src/login/extract/login.rs
@@ -3,9 +3,9 @@ use axum::{
     http::{request::Parts, StatusCode},
     response::{IntoResponse, Response},
 };
-use sqlx::sqlite::SqlitePool;
 
 use crate::{
+    app::App,
     clock::RequestedAt,
     error::InternalError,
     login::{
@@ -15,13 +15,10 @@ use crate::{
 };
 
 #[async_trait::async_trait]
-impl FromRequestParts<SqlitePool> for Login {
+impl FromRequestParts<App> for Login {
     type Rejection = LoginError<InternalError>;
 
-    async fn from_request_parts(
-        parts: &mut Parts,
-        state: &SqlitePool,
-    ) -> Result<Self, Self::Rejection> {
+    async fn from_request_parts(parts: &mut Parts, state: &App) -> Result<Self, Self::Rejection> {
         // After Rust 1.82 (and #[feature(min_exhaustive_patterns)] lands on
         // stable), the following can be replaced:
         //
@@ -31,8 +28,8 @@ impl FromRequestParts<SqlitePool> for Login {
 
         let secret = identity_token.secret().ok_or(LoginError::Forbidden)?;
 
-        let db = State::<SqlitePool>::from_request_parts(parts, state).await?;
-        let mut tx = db.begin().await?;
+        let app = State::<App>::from_request_parts(parts, state).await?;
+        let mut tx = app.db.begin().await?;
         tx.tokens().expire(requested_at).await?;
         let login = tx.tokens().validate(secret, requested_at).await?;
         tx.commit().await?;
diff --git a/src/login/routes.rs b/src/login/routes.rs
index c30bcb1..9cefe38 100644
--- a/src/login/routes.rs
+++ b/src/login/routes.rs
@@ -5,16 +5,15 @@ use axum::{
     routing::post,
     Router,
 };
-use sqlx::sqlite::SqlitePool;
 
-use crate::{clock::RequestedAt, error::InternalError};
+use crate::{app::App, clock::RequestedAt, error::InternalError};
 
 use super::{
     extract::IdentityToken,
     repo::{logins::Provider as _, tokens::Provider as _},
 };
 
-pub fn router() -> Router<SqlitePool> {
+pub fn router() -> Router<App> {
     Router::new()
         .route("/login", post(on_login))
         .route("/logout", post(on_logout))
@@ -27,12 +26,12 @@ struct LoginRequest {
 }
 
 async fn on_login(
-    State(db): State<SqlitePool>,
+    State(app): State<App>,
     RequestedAt(now): RequestedAt,
     identity: IdentityToken,
     Form(form): Form<LoginRequest>,
 ) -> Result<impl IntoResponse, InternalError> {
-    let mut tx = db.begin().await?;
+    let mut tx = app.db.begin().await?;
 
     // Spelling the following in the more conventional form,
     //     if let Some(…) = create().await? {}
@@ -88,11 +87,11 @@ impl IntoResponse for LoginResponse {
 }
 
 async fn on_logout(
-    State(db): State<SqlitePool>,
+    State(app): State<App>,
     identity: IdentityToken,
 ) -> Result<impl IntoResponse, InternalError> {
     if let Some(secret) = identity.secret() {
-        let mut tx = db.begin().await?;
+        let mut tx = app.db.begin().await?;
         tx.tokens().revoke(secret).await?;
         tx.commit().await?;
     }