handlers: extract the PgRepository from the request

Also fix a bunch of clippy errors & doctests

crates/handlers/src/oauth2/authorization/complete.rs

@@ -32,7 +32,6 @@ use mas_storage::{
 use mas_storage_pg::PgRepository;
 use mas_templates::Templates;
 use oauth2_types::requests::{AccessTokenResponse, AuthorizationResponse};
-use sqlx::PgPool;
 use thiserror::Error;
 use ulid::Ulid;
 
@@ -82,12 +81,10 @@ pub(crate) async fn get(
     clock: BoxClock,
     State(policy_factory): State<Arc<PolicyFactory>>,
     State(templates): State<Templates>,
-    State(pool): State<PgPool>,
+    mut repo: PgRepository,
     cookie_jar: PrivateCookieJar<Encrypter>,
     Path(grant_id): Path<Ulid>,
 ) -> Result<Response, RouteError> {
-    let mut repo = PgRepository::from_pool(&pool).await?;
-
     let (session_info, cookie_jar) = cookie_jar.session_info();
 
     let maybe_session = session_info.load_session(&mut repo).await?;

crates/handlers/src/oauth2/authorization/mod.rs

@@ -39,7 +39,6 @@ use oauth2_types::{
 };
 use rand::{distributions::Alphanumeric, Rng};
 use serde::Deserialize;
-use sqlx::PgPool;
 use thiserror::Error;
 
 use self::{callback::CallbackDestination, complete::GrantCompletionError};
@@ -136,12 +135,10 @@ pub(crate) async fn get(
     clock: BoxClock,
     State(policy_factory): State<Arc<PolicyFactory>>,
     State(templates): State<Templates>,
-    State(pool): State<PgPool>,
+    mut repo: PgRepository,
     cookie_jar: PrivateCookieJar<Encrypter>,
     Form(params): Form<Params>,
 ) -> Result<Response, RouteError> {
-    let mut repo = PgRepository::from_pool(&pool).await?;
-
     // First, figure out what client it is
     let client = repo
         .oauth2_client()

crates/handlers/src/oauth2/consent.rs

@@ -34,7 +34,6 @@ use mas_storage::{
 };
 use mas_storage_pg::PgRepository;
 use mas_templates::{ConsentContext, PolicyViolationContext, TemplateContext, Templates};
-use sqlx::PgPool;
 use thiserror::Error;
 use ulid::Ulid;
 
@@ -78,12 +77,10 @@ pub(crate) async fn get(
     clock: BoxClock,
     State(policy_factory): State<Arc<PolicyFactory>>,
     State(templates): State<Templates>,
-    State(pool): State<PgPool>,
+    mut repo: PgRepository,
     cookie_jar: PrivateCookieJar<Encrypter>,
     Path(grant_id): Path<Ulid>,
 ) -> Result<Response, RouteError> {
-    let mut repo = PgRepository::from_pool(&pool).await?;
-
     let (session_info, cookie_jar) = cookie_jar.session_info();
 
     let maybe_session = session_info.load_session(&mut repo).await?;
@@ -133,13 +130,11 @@ pub(crate) async fn post(
     mut rng: BoxRng,
     clock: BoxClock,
     State(policy_factory): State<Arc<PolicyFactory>>,
-    State(pool): State<PgPool>,
+    mut repo: PgRepository,
     cookie_jar: PrivateCookieJar<Encrypter>,
     Path(grant_id): Path<Ulid>,
     Form(form): Form<ProtectedForm<()>>,
 ) -> Result<Response, RouteError> {
-    let mut repo = PgRepository::from_pool(&pool).await?;
-
     cookie_jar.verify_form(&clock, form)?;
 
     let (session_info, cookie_jar) = cookie_jar.session_info();

crates/handlers/src/oauth2/introspection.rs

@@ -33,7 +33,6 @@ use oauth2_types::{
     requests::{IntrospectionRequest, IntrospectionResponse},
     scope::ScopeToken,
 };
-use sqlx::PgPool;
 use thiserror::Error;
 
 use crate::impl_from_error_for_route;
@@ -126,12 +125,10 @@ const API_SCOPE: ScopeToken = ScopeToken::from_static("urn:matrix:org.matrix.msc
 pub(crate) async fn post(
     clock: BoxClock,
     State(http_client_factory): State<HttpClientFactory>,
-    State(pool): State<PgPool>,
+    mut repo: PgRepository,
     State(encrypter): State<Encrypter>,
     client_authorization: ClientAuthorization<IntrospectionRequest>,
 ) -> Result<impl IntoResponse, RouteError> {
-    let mut repo = PgRepository::from_pool(&pool).await?;
-
     let client = client_authorization
         .credentials
         .fetch(&mut repo)

crates/handlers/src/oauth2/registration.rs

@@ -28,7 +28,6 @@ use oauth2_types::{
     },
 };
 use rand::distributions::{Alphanumeric, DistString};
-use sqlx::PgPool;
 use thiserror::Error;
 use tracing::info;
 
@@ -109,7 +108,7 @@ impl IntoResponse for RouteError {
 pub(crate) async fn post(
     mut rng: BoxRng,
     clock: BoxClock,
-    State(pool): State<PgPool>,
+    mut repo: PgRepository,
     State(policy_factory): State<Arc<PolicyFactory>>,
     State(encrypter): State<Encrypter>,
     Json(body): Json<ClientMetadata>,
@@ -125,8 +124,6 @@ pub(crate) async fn post(
         return Err(RouteError::PolicyDenied(res.violations));
     }
 
-    let mut repo = PgRepository::from_pool(&pool).await?;
-
     let (client_secret, encrypted_client_secret) = match metadata.token_endpoint_auth_method {
         Some(
             OAuthClientAuthenticationMethod::ClientSecretJwt

crates/handlers/src/oauth2/token.rs

@@ -50,7 +50,6 @@ use oauth2_types::{
 };
 use serde::Serialize;
 use serde_with::{serde_as, skip_serializing_none};
-use sqlx::PgPool;
 use thiserror::Error;
 use tracing::debug;
 use url::Url;
@@ -164,12 +163,10 @@ pub(crate) async fn post(
     State(http_client_factory): State<HttpClientFactory>,
     State(key_store): State<Keystore>,
     State(url_builder): State<UrlBuilder>,
-    State(pool): State<PgPool>,
+    mut repo: PgRepository,
     State(encrypter): State<Encrypter>,
     client_authorization: ClientAuthorization<AccessTokenRequest>,
 ) -> Result<impl IntoResponse, RouteError> {
-    let mut repo = PgRepository::from_pool(&pool).await?;
-
     let client = client_authorization
         .credentials
         .fetch(&mut repo)

crates/handlers/src/oauth2/userinfo.rs

@@ -37,7 +37,6 @@ use mas_storage_pg::PgRepository;
 use oauth2_types::scope;
 use serde::Serialize;
 use serde_with::skip_serializing_none;
-use sqlx::PgPool;
 use thiserror::Error;
 
 use crate::impl_from_error_for_route;
@@ -101,12 +100,10 @@ pub async fn get(
     mut rng: BoxRng,
     clock: BoxClock,
     State(url_builder): State<UrlBuilder>,
-    State(pool): State<PgPool>,
+    mut repo: PgRepository,
     State(key_store): State<Keystore>,
     user_authorization: UserAuthorization,
 ) -> Result<Response, RouteError> {
-    let mut repo = PgRepository::from_pool(&pool).await?;
-
     let session = user_authorization.protected(&mut repo, &clock).await?;
 
     let browser_session = repo