perf: only get Apple Music environment variables on startup

server/src/am_auth_flow.rs

···
 use askama::Template;
 
-use crate::scrapers::apple_music;
+use crate::scrapers::apple_music::AppleMusicClient;
 
 #[derive(Template, Debug, Clone)]
 #[template(path = "am-auth-flow.html")]
···
 }
 
 impl AuthFlowTemplate {
-    pub fn new() -> anyhow::Result<Self> {
-        let token = apple_music::build_developer_token()?;
+    pub fn new(apple_music_client: &AppleMusicClient) -> anyhow::Result<Self> {
+        let token = apple_music_client.build_developer_token()?;
         Ok(Self { token })
     }
 }

server/src/index.rs

···
 use crate::scrapers::{
-    apple_music::{self, AppleMusic},
+    apple_music::{self, AppleMusic, AppleMusicClient},
     backloggd::{self, Backloggd},
     letterboxd::{self, Letterboxd},
 };
···
 }
 
 impl RootTemplate {
-    pub async fn new() -> RootTemplate {
+    pub async fn new(apple_music_client: &AppleMusicClient) -> RootTemplate {
         let (game, movie, song) = tokio::join!(
             backloggd::cached_fetch(),
             letterboxd::cached_fetch(),
-            apple_music::cached_fetch()
+            apple_music::cached_fetch(apple_music_client)
         );
         RootTemplate { game, movie, song }
     }

server/src/main.rs

···
 mod index;
 mod scrapers;
 
-use std::net::SocketAddr;
+use std::{net::SocketAddr, sync::Arc};
 
 #[cfg(debug_assertions)]
 use crate::am_auth_flow::AuthFlowTemplate;
 use crate::index::RootTemplate;
+use crate::scrapers::apple_music::AppleMusicClient;
 
 use askama::Template;
 use axum::{
     Router,
+    extract::State,
     http::{HeaderName, HeaderValue, StatusCode},
     response::{Html, IntoResponse},
     routing::{get, get_service},
···
     trace::TraceLayer,
 };
 
+#[derive(Clone)]
+struct AppState {
+    apple_music_client: Arc<AppleMusicClient>,
+}
+
 #[tokio::main]
 async fn main() -> anyhow::Result<()> {
     tracing_subscriber::fmt::init();
 
+    let apple_music_client = Arc::new(AppleMusicClient::new()?);
+    let state = AppState { apple_music_client };
+
     let app = Router::new()
         .route("/", get(render_index_handler))
         .route("/dev/am-auth-flow", get(render_apple_music_auth_flow))
         .fallback(get_service(ServeDir::new(".")))
+        .with_state(state)
         .layer(
             ServiceBuilder::new()
                 .layer(TraceLayer::new_for_http())
···
     Ok(())
 }
 
-async fn render_index_handler() -> impl IntoResponse {
-    let template = RootTemplate::new().await;
+async fn render_index_handler(State(state): State<AppState>) -> impl IntoResponse {
+    let template = RootTemplate::new(&state.apple_music_client).await;
     template.render().map(Html).map_err(|err| {
         tracing::error!("failed to render index: {err:?}");
         StatusCode::INTERNAL_SERVER_ERROR
     })
 }
 
-async fn render_apple_music_auth_flow() -> impl IntoResponse {
+async fn render_apple_music_auth_flow(State(state): State<AppState>) -> impl IntoResponse {
     #[cfg(not(debug_assertions))]
     return StatusCode::NOT_FOUND;
 
     #[cfg(debug_assertions)]
     {
-        let template = AuthFlowTemplate::new();
+        let template = AuthFlowTemplate::new(&state.apple_music_client);
         template
             .and_then(|template| Ok(template.render()?))
             .map(Html)

server/src/scrapers/apple_music.rs

···
     url: String,
 }
 
-impl AppleMusic {
-    pub async fn fetch() -> anyhow::Result<Self> {
-        let jwt = build_developer_token()?;
+pub struct AppleMusicClient {
+    http_client: Client,
+    key_id: String,
+    team_id: String,
+    key: EncodingKey,
+    user_token: String,
+}
+
+impl AppleMusicClient {
+    pub fn new() -> anyhow::Result<Self> {
+        let key_id =
+            env::var("APPLE_DEVELOPER_TOKEN_KEY_ID").context("missing apple developer key ID")?;
+        let team_id =
+            env::var("APPLE_DEVELOPER_TOKEN_TEAM_ID").context("missing apple developer team ID")?;
+        let auth_key = env::var("APPLE_DEVELOPER_TOKEN_AUTH_KEY")
+            .context("missing apple developer auth key")?;
+        let key = EncodingKey::from_ec_pem(auth_key.as_bytes())
+            .context("failed to parse appple developer auth key")?;
         let user_token = env::var("APPLE_USER_TOKEN").context("missing apple user token")?;
 
-        let client = Client::new();
-        let response: AppleMusicResponse = client
+        Ok(Self {
+            http_client: Client::new(),
+            key_id,
+            team_id,
+            key,
+            user_token,
+        })
+    }
+
+    pub async fn fetch(&self) -> anyhow::Result<AppleMusic> {
+        let jwt = self.build_developer_token()?;
+
+        let response: AppleMusicResponse = self
+            .http_client
             .get("https://api.music.apple.com/v1/me/recent/played/tracks")
             .bearer_auth(jwt)
-            .header("Music-User-Token", user_token)
+            .header("Music-User-Token", &self.user_token)
             .query(&[("types", "songs"), ("limit", "1")])
             .send()
             .await
···
             .replace("{w}", dimensions)
             .replace("{h}", dimensions);
 
-        Ok(Self {
+        Ok(AppleMusic {
             name: track.attributes.name.clone(),
             art: artwork_url,
         })
     }
+
+    pub fn build_developer_token(&self) -> anyhow::Result<String> {
+        let mut header = Header::new(Algorithm::ES256);
+        header.kid = Some(self.key_id.clone());
+        let claims = Claims::new(self.team_id.clone());
+
+        jsonwebtoken::encode(&header, &claims, &self.key)
+            .context("failed to encode apple developer JWT")
+    }
 }
 
 #[once(time = 30, option = false)]
-pub async fn cached_fetch() -> Option<AppleMusic> {
-    AppleMusic::fetch()
+pub async fn cached_fetch(this: &AppleMusicClient) -> Option<AppleMusic> {
+    this.fetch()
         .await
         .map_err(|error| tracing::warn!(?error, "failed to call Apple Music"))
         .ok()
 }
-
-pub fn build_developer_token() -> anyhow::Result<String> {
-    let mut header = Header::new(Algorithm::ES256);
-    header.kid =
-        Some(env::var("APPLE_DEVELOPER_TOKEN_KEY_ID").context("missing apple developer key ID")?);
-    let team_id =
-        env::var("APPLE_DEVELOPER_TOKEN_TEAM_ID").context("missing apple developer team ID")?;
-    let claims = Claims::new(team_id);
-    let auth_key =
-        env::var("APPLE_DEVELOPER_TOKEN_AUTH_KEY").context("missing apple developer auth key")?;
-    let key = EncodingKey::from_ec_pem(auth_key.as_bytes())
-        .context("failed to parse appple developer auth key")?;
-
-    jsonwebtoken::encode(&header, &claims, &key).context("failed to encode apple developer JWT")
-}