refactor(knot): move branches impl to handler

Signed-off-by: tjh <[e-mail]>

crates/gordian-knot/src/model/knot_state.rs

···
     pub async fn open_repository(
         &self,
         repo_key: &RepositoryKey,
-    ) -> Result<gix::ThreadSafeRepository, Arc<gix::open::Error>> {
+    ) -> Result<gix::ThreadSafeRepository, RepositoryOpenError> {
         use gix::open::Options;
 
         let repository = self
···
     fn from(value: DataStoreError) -> Self {
         Self::Lookup(Arc::new(value))
     }
+}
+
+#[derive(Debug, thiserror::Error)]
+pub enum RepositoryOpenError {
+    #[error(transparent)]
+    Gix(#[from] Arc<gix::open::Error>),
 }
 
 impl AuthorizationClaimsStore<service_auth::Claims> for KnotState {

crates/gordian-knot/src/model/repository.rs

···
 use gordian_lexicon::sh_tangled::repo::branch;
 use gordian_lexicon::sh_tangled::repo::get_default_branch;
 use gordian_lexicon::sh_tangled::repo::languages;
-use gordian_lexicon::sh_tangled::repo::refs;
 use gordian_lexicon::sh_tangled::repo::tree;
 use rustc_hash::FxHashSet;
 use serde::Deserialize;
···
 use crate::public::xrpc::XrpcResult;
 use crate::types::repository_spec::RepositoryKey;
 use crate::types::repository_spec::RepositoryPath;
-use crate::types::sh_tangled::repo::branches;
 use crate::types::sh_tangled::repo::compare;
 use crate::types::sh_tangled::repo::diff;
 use crate::types::sh_tangled::repo::log;
···
             is_default,
         })
         .into())
-    }
-
-    pub fn branches(&self, _params: branches::Input) -> XrpcResult<Json<branches::Output>> {
-        // Assume HEAD points to the intended default branch. This *should* be
-        // true for a bare repository.
-        let head = self.repository.head()?;
-        let default_name = head
-            .referent_name()
-            .ok_or(errors::HeadDetached)?
-            .shorten()
-            .to_string();
-
-        let mut branches = Vec::new();
-        for branch in self.repository.references()?.local_branches()?
-        // .skip(params.cursor)
-        // .take(_params.limit.into())
-        {
-            let Ok(branch) = branch.inspect_err(|error| tracing::error!(?error)) else {
-                continue;
-            };
-
-            let name = branch.name().shorten().to_string();
-            let Some(id) = branch.try_id() else {
-                tracing::warn!(?name, "branch unborn, skipping");
-                continue;
-            };
-
-            let Ok(commit) = self.repository.find_commit(id) else {
-                tracing::error!(?name, ?id, "failed to find commit for branch");
-                continue;
-            };
-
-            let is_default = name == default_name;
-            branches.push(branches::Branch {
-                reference: refs::Reference {
-                    name,
-                    hash: commit.id.into(),
-                },
-                commit: convert::try_convert_commit(commit)?,
-                is_default,
-            });
-        }
-
-        Ok(Json(branches::Output { branches }).into())
     }
 
     pub fn compare(&self, params: compare::Input) -> XrpcResult<Json<compare::Output>> {

crates/gordian-knot/src/public/xrpc.rs

···
         }
     }
 }
+
+impl From<crate::types::repository_spec::Error> for XrpcError {
+    fn from(value: crate::types::repository_spec::Error) -> Self {
+        Self::new(StatusCode::BAD_REQUEST, "InvalidRequest", value.to_string())
+    }
+}
+
+impl From<crate::model::knot_state::RepositoryResolveError> for XrpcError {
+    fn from(value: crate::model::knot_state::RepositoryResolveError) -> Self {
+        use crate::model::knot_state::RepositoryResolveError as Error;
+        match value {
+            Error::Resolve(error) => {
+                Self::new(StatusCode::BAD_REQUEST, "RepoNotFound", error.to_string())
+            }
+            Error::Lookup(error) => {
+                Self::new(StatusCode::NOT_FOUND, "RepoNotFound", error.to_string())
+            }
+            Error::NotFound => Self::from_static(
+                StatusCode::NOT_FOUND,
+                "RepoNotFound",
+                "Repository not found",
+            ),
+        }
+    }
+}
+
+impl From<crate::model::knot_state::RepositoryOpenError> for XrpcError {
+    fn from(value: crate::model::knot_state::RepositoryOpenError) -> Self {
+        use crate::model::knot_state::RepositoryOpenError as Error;
+        match value {
+            Error::Gix(error) => match error.as_ref() {
+                gix::open::Error::Io(error) if error.kind() == std::io::ErrorKind::NotFound => {
+                    Self::new(StatusCode::NOT_FOUND, "RepoNotFound", error.to_string())
+                }
+                _ => Self::new(
+                    StatusCode::INTERNAL_SERVER_ERROR,
+                    "RepoNotFound",
+                    error.to_string(),
+                ),
+            },
+        }
+    }
+}

crates/gordian-knot/src/public/xrpc/sh_tangled/repo/impl_branches.rs

···
 use axum::Json;
 use axum::extract::State;
+use gordian_lexicon::sh_tangled::repo::refs::Commit;
+use gordian_lexicon::sh_tangled::repo::refs::Reference;
+use serde::Serialize;
 use tokio_rayon::AsyncThreadPool as _;
 
 use crate::model::Knot;
-use crate::model::repository::TangledRepository;
+use crate::model::convert;
+use crate::model::errors;
 use crate::public::xrpc::XrpcQuery;
 use crate::public::xrpc::XrpcResult;
-use crate::types::sh_tangled::repo::branches::Input;
-use crate::types::sh_tangled::repo::branches::Output;
+
+pub use crate::lexicon::sh_tangled::repo::branches::Input;
 
 pub const LXM: &str = "/sh.tangled.repo.branches";
 
-#[tracing::instrument(target = "sh_tangled::repo::branches", skip(knot, repository), err)]
+/// Output of `sh.tangled.repo.branches` query.
+#[derive(Debug, Default, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Output {
+    #[serde(skip_serializing_if = "Vec::is_empty")]
+    pub branches: Vec<Branch>,
+}
+
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Branch {
+    pub reference: Reference,
+    pub commit: Commit,
+    pub is_default: bool,
+}
+
+pub type Response = XrpcResult<Json<Output>>;
+
+#[tracing::instrument(target = "sh_tangled::repo::branches", skip(knot), err)]
 pub async fn handle(
     State(knot): State<Knot>,
-    XrpcQuery(params): XrpcQuery<Input>,
-    repository: TangledRepository,
-) -> XrpcResult<Json<Output>> {
+    XrpcQuery(Input {
+        repo,
+        limit,
+        cursor,
+    }): XrpcQuery<Input>,
+) -> Response {
+    let repo_path = repo.parse()?;
+    let repo_key = knot.resolve_repo_key(&repo_path).await?;
+    let repository = knot.open_repository(&repo_key).await?;
+
     knot.pool()
-        .spawn_async(move || repository.branches(params))
+        .spawn_async(move || {
+            let repository = repository.to_thread_local();
+
+            // Assume HEAD points to the intended default branch. This *should* be
+            // true for a bare repository.
+            let head = repository.head()?;
+            let default_name = head
+                .referent_name()
+                .ok_or(errors::HeadDetached)?
+                .shorten()
+                .to_string();
+
+            let mut branches = Vec::new();
+            for branch in repository
+                .references()?
+                .local_branches()?
+                .skip(cursor.into())
+                .take(limit.into())
+            {
+                let Ok(branch) = branch.inspect_err(|error| tracing::error!(?error)) else {
+                    continue;
+                };
+
+                let name = branch.name().shorten().to_string();
+                let Some(id) = branch.try_id() else {
+                    tracing::warn!(?name, "branch unborn, skipping");
+                    continue;
+                };
+
+                let Ok(commit) = repository.find_commit(id) else {
+                    tracing::error!(?name, ?id, "failed to find commit for branch");
+                    continue;
+                };
+
+                let is_default = name == default_name;
+                branches.push(Branch {
+                    reference: Reference {
+                        name,
+                        hash: commit.id.into(),
+                    },
+                    commit: convert::try_convert_commit(commit)?,
+                    is_default,
+                });
+            }
+
+            Ok(Json(Output { branches }).into())
+        })
         .await
 }

crates/gordian-knot/src/types/sh_tangled.rs

···
 pub mod repo {
-    pub mod branches {
-        use serde::Serialize;
-
-        pub use crate::lexicon::sh_tangled::repo::branches::Input;
-        use crate::lexicon::sh_tangled::repo::refs;
-
-        /// Output of `sh.tangled.repo.branches` query.
-        #[derive(Debug, Default, Serialize)]
-        #[serde(rename_all = "camelCase")]
-        pub struct Output {
-            #[serde(skip_serializing_if = "Vec::is_empty")]
-            pub branches: Vec<Branch>,
-        }
-
-        #[derive(Debug, Serialize)]
-        #[serde(rename_all = "camelCase")]
-        pub struct Branch {
-            pub reference: refs::Reference,
-            pub commit: refs::Commit,
-            #[serde(rename = "is_deafult")]
-            pub is_default: bool,
-        }
-
-        pub type Response = axum::Json<Output>;
-    }
-
     pub mod compare {
         use serde::Serialize;
 

crates/gordian-lexicon/src/sh_tangled/repo/branches.rs

···
     pub limit: u16,
 
     /// Pagination cursor
-    pub cursor: Option<String>,
+    pub cursor: u16,
 }
 
 #[derive(serde::Deserialize)]
 struct UnvalidatedInput {
     repo: String,
     limit: Option<u16>,
-    cursor: Option<String>,
+    cursor: Option<u16>,
 }
 
 impl TryFrom<UnvalidatedInput> for Input {
···
         if !(LIMIT_MIN..=LIMIT_MAX).contains(&limit) {
             return Err("'limit' field is outside acceptable range");
         }
+
+        let cursor = cursor.unwrap_or_default();
 
         Ok(Self {
             repo,