feat(knot): set cache-control headers for immutable responses

Signed-off-by: tjh <did:plc:65gha4t3avpfpzmvpbwovss7>

crates/knot/src/model/repository.rs

···
     public::xrpc::XrpcError,
     types::sh::tangled::repo::{blob, branches, diff, log, tags},
 };
+use axum::{
+    http::{HeaderMap, HeaderValue},
+    response::IntoResponse,
+};
 use gix::{ThreadSafeRepository, bstr::ByteSlice as _};
 use lexicon::sh::tangled::repo::{get_default_branch, refs, tree};
+use serde::Serialize;
 use std::cmp::Reverse;
 use tokio_rayon::AsyncThreadPool as _;
 
···
     fn blob(
         &self,
         params: blob::Input,
-    ) -> impl Future<Output = Result<blob::Output, XrpcError>> + Send;
+    ) -> impl Future<Output = Result<DirectResponse<blob::Output>, XrpcError>> + Send;
 
     fn branches(
         &self,
···
     fn diff(
         &self,
         params: diff::Input,
-    ) -> impl Future<Output = Result<diff::Output, XrpcError>> + Send;
+    ) -> impl Future<Output = Result<XrpcResponse<diff::Output>, XrpcError>> + Send;
 
     fn log(
         &self,
···
     fn tree(
         &self,
         params: tree::Input,
-    ) -> impl Future<Output = Result<tree::Output, XrpcError>> + Send;
+    ) -> impl Future<Output = Result<XrpcResponse<tree::Output>, XrpcError>> + Send;
+}
+
+pub struct XrpcResponse<T> {
+    pub value: T,
+    pub immutable: bool,
+}
+
+impl<T> IntoResponse for XrpcResponse<T>
+where
+    T: Serialize,
+{
+    fn into_response(self) -> axum::response::Response {
+        use axum::{http::header::CACHE_CONTROL, response::Json};
+
+        let mut headers = HeaderMap::new();
+        if self.immutable {
+            headers.insert(
+                CACHE_CONTROL,
+                HeaderValue::from_static("public, immutable, s-maxage=604800"),
+            );
+        }
+
+        (headers, Json(self.value)).into_response()
+    }
+}
+
+pub struct DirectResponse<T> {
+    pub value: T,
+    pub immutable: bool,
+}
+
+impl<T> IntoResponse for DirectResponse<T>
+where
+    T: IntoResponse,
+{
+    fn into_response(self) -> axum::response::Response {
+        use axum::http::header::CACHE_CONTROL;
+
+        let mut headers = HeaderMap::new();
+        if self.immutable {
+            headers.insert(
+                CACHE_CONTROL,
+                HeaderValue::from_static("public, immutable, s-maxage=604800"),
+            );
+        }
+
+        (headers, self.value).into_response()
+    }
 }
 
 pub struct GitOxideRepository<'a> {
···
 }
 
 impl TangledRepository for GitOxideRepository<'_> {
-    async fn blob(&self, params: blob::Input) -> Result<blob::Output, XrpcError> {
+    async fn blob(&self, params: blob::Input) -> Result<DirectResponse<blob::Output>, XrpcError> {
         let repo = self.repo.to_thread_local();
         self.state
             .pool()
             .spawn_fifo_async(move || {
-                let tip = resolve_rev(&repo, params.rev.as_deref())?;
+                let (tip, immutable) = resolve_rev(&repo, params.rev.as_deref())?;
                 let entry = tip
                     .tree()?
                     .lookup_entry_by_path(&params.path)?
···
                 let mut blob = entry.object()?.into_blob();
                 let data = blob.take_data();
                 if params.raw {
-                    return Ok(blob::Output::Raw(data));
+                    return Ok(DirectResponse {
+                        value: blob::Output::Raw(data),
+                        immutable,
+                    });
                 }
 
                 let size = data.len();
···
                     ),
                 };
 
-                Ok(blob::Output::Json(Box::new(
-                    lexicon::sh::tangled::repo::blob::Output {
+                Ok(DirectResponse {
+                    value: blob::Output::Json(Box::new(lexicon::sh::tangled::repo::blob::Output {
                         rev: params.rev.as_deref().unwrap_or_default().to_owned(),
                         path: params.path.to_owned(),
                         content,
···
                         is_binary,
                         mime_type: "".to_string(),
                         last_commit: None,
-                    },
-                )))
+                    })),
+                    immutable,
+                })
             })
             .await
     }
···
             .await
     }
 
-    async fn diff(&self, params: diff::Input) -> Result<diff::Output, XrpcError> {
+    async fn diff(&self, params: diff::Input) -> Result<XrpcResponse<diff::Output>, XrpcError> {
         let repo = self.repo.to_thread_local();
         self.state
             .pool()
             .spawn_fifo_async(move || {
-                let this_commit = resolve_rev(&repo, Some(&params.rev))?;
+                let (this_commit, immutable) = resolve_rev(&repo, Some(&params.rev))?;
                 let diff = super::nicediff::unified_diff_from_parent(this_commit).unwrap();
                 let response = diff::Output {
                     rev: params.rev,
                     diff,
                 };
-                Ok(response)
+                Ok(XrpcResponse {
+                    value: response,
+                    immutable,
+                })
             })
             .await
     }
···
                     }
                 };
 
-                let tip = resolve_rev(&repo, params.rev.as_deref())?;
+                let (tip, _) = resolve_rev(&repo, params.rev.as_deref())?;
 
                 let mut commits = Vec::new();
                 for commit in repo
···
             .await
     }
 
-    async fn tree(&self, params: tree::Input) -> Result<tree::Output, XrpcError> {
+    async fn tree(&self, params: tree::Input) -> Result<XrpcResponse<tree::Output>, XrpcError> {
         let repo = self.repo.to_thread_local();
         self.state
             .pool()
             .spawn_fifo_async(move || {
-                let tip = resolve_rev(&repo, params.rev.as_deref())?;
+                let (tip, immutable) = resolve_rev(&repo, params.rev.as_deref())?;
                 let dotdot = params.path.clone().and_then(|mut path| {
                     path.pop();
                     match path.as_os_str().is_empty() {
···
                         .ok_or(PathNotFound(subpath.to_string_lossy()))?;
 
                     if !entry.mode().is_tree() {
-                        return Ok(tree::Output {
-                            files: vec![],
-                            dotdot,
-                            parent: params.path.clone(),
-                            rev: params.rev.as_deref().unwrap_or_default().to_string(),
-                            readme: None,
+                        return Ok(XrpcResponse {
+                            value: tree::Output {
+                                files: vec![],
+                                dotdot,
+                                parent: params.path.clone(),
+                                rev: params.rev.as_deref().unwrap_or_default().to_string(),
+                                readme: None,
+                            },
+                            immutable,
                         });
                     }
 
···
                     })
                     .collect();
 
-                Ok(tree::Output {
-                    files,
-                    dotdot,
-                    parent,
-                    rev: params.rev.as_deref().unwrap_or_default().to_string(),
-                    readme,
+                Ok(XrpcResponse {
+                    value: tree::Output {
+                        files,
+                        dotdot,
+                        parent,
+                        rev: params.rev.as_deref().unwrap_or_default().to_string(),
+                        readme,
+                    },
+                    immutable,
                 })
             })
             .await
     }
 }
 
+/// Resolve a revspec into a [`gix::Commit`] and an immutable flag.
+///
+/// A revspec is considered immutable if, and only if, it is an object ID.
 fn resolve_rev<'repo>(
     repo: &'repo gix::Repository,
     rev: Option<&str>,
-) -> Result<gix::Commit<'repo>, XrpcError> {
+) -> Result<(gix::Commit<'repo>, bool), XrpcError> {
     use std::str::FromStr as _;
 
-    let revision = if let Some(refspec) = rev {
+    Ok(if let Some(refspec) = rev {
         match gix::ObjectId::from_str(refspec) {
-            Ok(id) => repo.find_commit(id).map_err(RefNotFound)?,
+            Ok(id) => (repo.find_commit(id).map_err(RefNotFound)?, true),
             Err(_) => {
                 // Assume the revspec is a branch or tag.
                 let mut reference = repo.find_reference(refspec).map_err(RefNotFound)?;
-                reference.peel_to_commit().map_err(RefNotFound)?
+                (reference.peel_to_commit().map_err(RefNotFound)?, false)
             }
         }
     } else {
-        repo.head_commit().map_err(RefNotFound)?
-    };
-
-    Ok(revision)
+        (repo.head_commit().map_err(RefNotFound)?, false)
+    })
 }

crates/knot/src/public/xrpc/sh/tangled/repo.rs

···
 xrpc_query!("sh.tangled.repo.blob", direct blob);
 xrpc_query!("sh.tangled.repo.branches", branches);
 xrpc_query!("sh.tangled.repo.getDefaultBranch", get_default_branch);
-xrpc_query!("sh.tangled.repo.diff", diff);
+xrpc_query!("sh.tangled.repo.diff", direct diff);
 xrpc_query!("sh.tangled.repo.log", log);
 xrpc_query!("sh.tangled.repo.tags", tags);
-xrpc_query!("sh.tangled.repo.tree", tree);
+xrpc_query!("sh.tangled.repo.tree", direct tree);
 
 #[xrpc::query("sh.tangled.repo.languages")]
 #[tracing::instrument(skip(_knot))]