refactor(hive-forge): port CLI verbs to forgejo-api

hive-forge/src/verbs/labels.rs

@@ -3,9 +3,10 @@
 
 use anyhow::{Result, bail};
 use clap::{Args as ClapArgs, Subcommand};
-use serde_json::{Value, json};
+use forgejo_api::structs::{DeleteLabelsOption, IssueLabelsOption, IssueListLabelsQuery, Label};
+use serde_json::json;
 
-use crate::client::Client;
+use crate::client::{Client, index};
 use crate::verbs::print_json;
 
 #[derive(ClapArgs)]
@@ -33,85 +34,84 @@ enum Action {
 }
 
 pub fn run(client: &Client, args: Args) -> Result<()> {
-    let repo = client.repo();
+    let (owner, name) = client.owner_repo()?;
+    let idx = index(args.number)?;
     match args.action.unwrap_or(Action::List) {
         Action::List => {
-            let labels =
-                client.get_json(&format!("/repos/{repo}/issues/{}/labels", args.number))?;
+            let labels = client.api().issue_get_labels(owner, name, idx).send()?;
             print_label_names(&labels);
         }
         Action::Add { labels } => {
             if labels.is_empty() {
                 bail!("hive-forge labels add: pass at least one label name");
             }
-            let all = client.get_json(&format!("/repos/{repo}/labels?limit=100"))?;
-            let ids = resolve_ids(&all, &labels);
-            let resp = client.post_json(
-                &format!("/repos/{repo}/issues/{}/labels", args.number),
-                &json!({ "labels": ids }),
-            )?;
+            let all = repo_labels(client)?;
+            let ids: Vec<serde_json::Value> = resolve_ids(&all, &labels)
+                .into_iter()
+                .map(|id| json!(id))
+                .collect();
+            let resp = client
+                .api()
+                .issue_add_label(
+                    owner,
+                    name,
+                    idx,
+                    IssueLabelsOption {
+                        labels: Some(ids),
+                        updated_at: None,
+                    },
+                )
+                .send()?;
             print_label_names(&resp);
         }
         Action::Remove { labels } => {
             if labels.is_empty() {
                 bail!("hive-forge labels remove: pass at least one label name");
             }
-            let all = client.get_json(&format!("/repos/{repo}/labels?limit=100"))?;
-            for name in &labels {
-                if let Some(id) = lookup_id(&all, name) {
-                    let _ = client.delete(
-                        &format!("/repos/{repo}/issues/{}/labels/{id}", args.number),
-                        None,
-                    );
+            let all = repo_labels(client)?;
+            for label in &labels {
+                if let Some(id) = lookup_id(&all, label) {
+                    let _ = client
+                        .api()
+                        .issue_remove_label(
+                            owner,
+                            name,
+                            idx,
+                            &id.to_string(),
+                            DeleteLabelsOption { updated_at: None },
+                        )
+                        .send();
                 }
             }
-            let labels =
-                client.get_json(&format!("/repos/{repo}/issues/{}/labels", args.number))?;
+            let labels = client.api().issue_get_labels(owner, name, idx).send()?;
             print_label_names(&labels);
         }
     }
     Ok(())
 }
 
-fn resolve_ids(all: &Value, names: &[String]) -> Vec<u64> {
-    let Some(arr) = all.as_array() else {
-        return Vec::new();
-    };
-    names
-        .iter()
-        .filter_map(|n| {
-            arr.iter().find_map(|l| {
-                let lname = l.get("name").and_then(Value::as_str)?;
-                if lname == n {
-                    l.get("id").and_then(Value::as_u64)
-                } else {
-                    None
-                }
-            })
-        })
-        .collect()
+/// First page (100) of the repo's label set, for name → id resolution.
+fn repo_labels(client: &Client) -> Result<Vec<Label>> {
+    let (owner, name) = client.owner_repo()?;
+    let (_, labels) = client
+        .api()
+        .issue_list_labels(owner, name, IssueListLabelsQuery::default())
+        .page_size(100)
+        .send()?;
+    Ok(labels)
 }
 
-fn lookup_id(all: &Value, name: &str) -> Option<u64> {
-    let arr = all.as_array()?;
-    arr.iter().find_map(|l| {
-        let lname = l.get("name").and_then(Value::as_str)?;
-        if lname == name {
-            l.get("id").and_then(Value::as_u64)
-        } else {
-            None
-        }
-    })
+fn resolve_ids(all: &[Label], names: &[String]) -> Vec<i64> {
+    names.iter().filter_map(|n| lookup_id(all, n)).collect()
 }
 
-fn print_label_names(v: &Value) {
-    let names: Vec<&str> = v
-        .as_array()
-        .map(|a| {
-            a.iter()
-                .filter_map(|l| l.get("name").and_then(Value::as_str))
-                .collect()
-        })
-        .unwrap_or_default();
+fn lookup_id(all: &[Label], name: &str) -> Option<i64> {
+    all.iter()
+        .find(|l| l.name.as_deref() == Some(name))
+        .and_then(|l| l.id)
+}
+
+fn print_label_names(labels: &[Label]) {
+    let names: Vec<&str> = labels.iter().filter_map(|l| l.name.as_deref()).collect();
     let _ = print_json(&json!(names));
 }