Add Jira project list command

Author: NeoHsu

README.md

@@ -48,3 +48,11 @@ atla auth status
 atla config set default-project PROJ
 atla config list --output json
 ```
+
+First Jira command:
+
+```bash
+atla jira project list
+atla jira project list --query platform --limit 25 --output json
+atla jira project list --output keys
+```

crates/atla-cli/src/cli.rs

@@ -89,12 +89,31 @@ pub struct JiraCommand {
 #[derive(Debug, Subcommand)]
 pub enum JiraResource {
     Issue,
-    Project,
+    Project(ProjectCommand),
     Sprint,
     Board,
     Search { jql: String },
 }
 
+#[derive(Debug, Args)]
+pub struct ProjectCommand {
+    #[command(subcommand)]
+    pub action: ProjectAction,
+}
+
+#[derive(Debug, Subcommand)]
+pub enum ProjectAction {
+    List {
+        #[arg(long)]
+        query: Option<String>,
+        #[arg(long, default_value_t = 50)]
+        limit: u32,
+    },
+    View {
+        key: String,
+    },
+}
+
 #[derive(Debug, Args)]
 pub struct ConfluenceCommand {
     #[command(subcommand)]

crates/atla-cli/src/commands/jira/mod.rs

@@ -1,13 +1,147 @@
-use crate::cli::{GlobalArgs, JiraCommand, JiraResource};
+use anyhow::Context;
+use atla_core::auth::{CredentialStore, KeyringCredentialStore};
+use atla_core::{
+    AtlaConfig, AtlassianClient, ConfigStore, JiraClient, JiraProject, JiraProjectSearch, Profile,
+};
 
-pub async fn run(command: JiraCommand, _global: &GlobalArgs) -> anyhow::Result<()> {
+use crate::cli::{
+    GlobalArgs, JiraCommand, JiraResource, OutputFormat, ProjectAction, ProjectCommand,
+};
+use crate::config;
+use crate::output;
+
+pub async fn run(command: JiraCommand, global: &GlobalArgs) -> anyhow::Result<()> {
     match command.resource {
         JiraResource::Issue => println!("jira issue commands are planned"),
-        JiraResource::Project => println!("jira project commands are planned"),
+        JiraResource::Project(command) => run_project(command, global).await?,
         JiraResource::Sprint => println!("jira sprint commands are planned"),
         JiraResource::Board => println!("jira board commands are planned"),
         JiraResource::Search { jql } => println!("jira search is planned: {jql}"),
     }
 
     Ok(())
 }
+
+async fn run_project(command: ProjectCommand, global: &GlobalArgs) -> anyhow::Result<()> {
+    match command.action {
+        ProjectAction::List { query, limit } => {
+            let store = ConfigStore::default_store().context("failed to find config location")?;
+            let atla_config = store.load().context("failed to load config")?;
+            let (profile_name, profile) = active_profile(&atla_config, global)?;
+            let search = JiraProjectSearch {
+                start_at: 0,
+                max_results: limit.clamp(1, 100),
+                query,
+            };
+
+            if global.dry_run {
+                let url = format!(
+                    "{}/rest/api/3/project/search?startAt={}&maxResults={}",
+                    profile.instance.trim_end_matches('/'),
+                    search.start_at,
+                    search.max_results
+                );
+                if let Some(query) = &search.query {
+                    println!("Would GET {url} with query `{query}` using profile `{profile_name}`");
+                } else {
+                    println!("Would GET {url} using profile `{profile_name}`");
+                }
+                return Ok(());
+            }
+
+            let token = token_for_profile(profile_name, profile)?;
+            let client = JiraClient::new(AtlassianClient::from_profile(profile, token));
+            let page = client.search_projects(&search).await.with_context(|| {
+                format!(
+                    "failed to list Jira projects from {}",
+                    client.instance_url()
+                )
+            })?;
+
+            print_projects(&page.values, page.total, global)?;
+        }
+        ProjectAction::View { key } => {
+            println!("jira project view is planned: {key}");
+        }
+    }
+
+    Ok(())
+}
+
+fn active_profile<'a>(
+    atla_config: &'a AtlaConfig,
+    global: &GlobalArgs,
+) -> anyhow::Result<(&'a str, &'a Profile)> {
+    atla_config
+        .active_profile(config::active_profile(global))
+        .ok_or_else(|| anyhow::anyhow!("no active profile; run `atla auth login` first"))
+}
+
+fn token_for_profile(profile_name: &str, profile: &Profile) -> anyhow::Result<String> {
+    let credential = profile.credential_ref(profile_name);
+    let token = KeyringCredentialStore::default()
+        .get_token(&credential)
+        .context("failed to read API token from keyring")?;
+
+    token.ok_or_else(|| {
+        anyhow::anyhow!("missing API token; run `atla auth login --profile {profile_name}`")
+    })
+}
+
+fn print_projects(
+    projects: &[JiraProject],
+    total: Option<u64>,
+    global: &GlobalArgs,
+) -> anyhow::Result<()> {
+    match global.output.unwrap_or(OutputFormat::Table) {
+        OutputFormat::Json => output::print_json(projects),
+        OutputFormat::Keys => {
+            for project in projects {
+                if let Some(key) = &project.key {
+                    println!("{key}");
+                }
+            }
+            Ok(())
+        }
+        OutputFormat::Csv => {
+            println!("key,name,type,style,archived");
+            for project in projects {
+                println!(
+                    "{},{},{},{},{}",
+                    csv_cell(project.key.as_deref().unwrap_or_default()),
+                    csv_cell(project.name.as_deref().unwrap_or_default()),
+                    csv_cell(project.project_type_key.as_deref().unwrap_or_default()),
+                    csv_cell(project.style.as_deref().unwrap_or_default()),
+                    csv_cell(&project.archived.unwrap_or(false).to_string())
+                );
+            }
+            Ok(())
+        }
+        OutputFormat::Table => {
+            println!("{:<12} {:<16} {:<12} NAME", "KEY", "TYPE", "STYLE");
+            for project in projects {
+                println!(
+                    "{:<12} {:<16} {:<12} {}",
+                    project.key.as_deref().unwrap_or("-"),
+                    project.project_type_key.as_deref().unwrap_or("-"),
+                    project.style.as_deref().unwrap_or("-"),
+                    project.name.as_deref().unwrap_or("-")
+                );
+            }
+
+            if let Some(total) = total {
+                println!();
+                println!("Showing {} of {total} projects.", projects.len());
+            }
+            Ok(())
+        }
+    }
+}
+
+fn csv_cell(value: &str) -> String {
+    if value.contains(',') || value.contains('"') || value.contains('\n') {
+        format!("\"{}\"", value.replace('"', "\"\""))
+    } else {
+        value.to_owned()
+    }
+}

crates/atla-cli/src/output.rs

@@ -1,6 +1,6 @@
 use serde::Serialize;
 
-pub fn print_json<T: Serialize>(value: &T) -> anyhow::Result<()> {
+pub fn print_json<T: Serialize + ?Sized>(value: &T) -> anyhow::Result<()> {
     println!("{}", serde_json::to_string_pretty(value)?);
     Ok(())
 }

crates/atla-core/Cargo.toml

@@ -13,12 +13,7 @@ serde.workspace = true
 serde_json.workspace = true
 thiserror.workspace = true
 toml.workspace = true
-
-reqwest = { workspace = true, optional = true }
+reqwest.workspace = true
 
 [dev-dependencies]
 tempfile.workspace = true
-
-[features]
-default = []
-http-client = ["dep:reqwest"]

crates/atla-core/src/auth.rs

@@ -23,6 +23,7 @@ pub enum AuthState {
 
 pub trait CredentialStore {
     fn save_token(&self, credential: &CredentialRef, token: &str) -> Result<(), AuthError>;
+    fn get_token(&self, credential: &CredentialRef) -> Result<Option<String>, AuthError>;
     fn delete_token(&self, credential: &CredentialRef) -> Result<(), AuthError>;
     fn has_token(&self, credential: &CredentialRef) -> Result<bool, AuthError>;
 }
@@ -58,6 +59,14 @@ impl CredentialStore for KeyringCredentialStore {
             .map_err(|error| AuthError::Backend(error.to_string()))
     }
 
+    fn get_token(&self, credential: &CredentialRef) -> Result<Option<String>, AuthError> {
+        match self.entry(credential)?.get_password() {
+            Ok(token) => Ok(Some(token)),
+            Err(keyring::Error::NoEntry) => Ok(None),
+            Err(error) => Err(AuthError::Backend(error.to_string())),
+        }
+    }
+
     fn delete_token(&self, credential: &CredentialRef) -> Result<(), AuthError> {
         match self.entry(credential)?.delete_credential() {
             Ok(()) | Err(keyring::Error::NoEntry) => Ok(()),
@@ -66,11 +75,7 @@ impl CredentialStore for KeyringCredentialStore {
     }
 
     fn has_token(&self, credential: &CredentialRef) -> Result<bool, AuthError> {
-        match self.entry(credential)?.get_password() {
-            Ok(_) => Ok(true),
-            Err(keyring::Error::NoEntry) => Ok(false),
-            Err(error) => Err(AuthError::Backend(error.to_string())),
-        }
+        self.get_token(credential).map(|token| token.is_some())
     }
 }
 

crates/atla-core/src/client.rs

@@ -1,5 +1,7 @@
 use serde::{Deserialize, Serialize};
 
+use crate::Profile;
+
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 pub struct AtlassianInstance {
     pub base_url: String,
@@ -12,3 +14,97 @@ impl AtlassianInstance {
         }
     }
 }
+
+#[derive(Debug, Clone)]
+pub struct AtlassianClient {
+    http: reqwest::Client,
+    instance: AtlassianInstance,
+    email: String,
+    token: String,
+}
+
+impl AtlassianClient {
+    pub fn new(
+        instance: AtlassianInstance,
+        email: impl Into<String>,
+        token: impl Into<String>,
+    ) -> Self {
+        Self {
+            http: reqwest::Client::new(),
+            instance,
+            email: email.into(),
+            token: token.into(),
+        }
+    }
+
+    pub fn from_profile(profile: &Profile, token: impl Into<String>) -> Self {
+        Self::new(
+            AtlassianInstance::new(&profile.instance),
+            profile.email.clone(),
+            token,
+        )
+    }
+
+    pub fn instance(&self) -> &AtlassianInstance {
+        &self.instance
+    }
+
+    pub fn get(&self, path: &str) -> reqwest::RequestBuilder {
+        self.http
+            .get(self.url(path))
+            .basic_auth(&self.email, Some(&self.token))
+            .header(reqwest::header::ACCEPT, "application/json")
+    }
+
+    pub fn url(&self, path: &str) -> String {
+        format!(
+            "{}/{}",
+            self.instance.base_url,
+            path.trim_start_matches('/')
+        )
+    }
+}
+
+#[derive(Debug, thiserror::Error)]
+pub enum ApiError {
+    #[error("request failed: {0}")]
+    Request(#[from] reqwest::Error),
+    #[error("Atlassian API returned {status}: {body}")]
+    Http {
+        status: reqwest::StatusCode,
+        body: String,
+    },
+}
+
+pub async fn read_json<T: serde::de::DeserializeOwned>(
+    request: reqwest::RequestBuilder,
+) -> Result<T, ApiError> {
+    let response = request.send().await?;
+    let status = response.status();
+
+    if !status.is_success() {
+        let body = response.text().await.unwrap_or_default();
+        return Err(ApiError::Http { status, body });
+    }
+
+    response.json::<T>().await.map_err(ApiError::Request)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn joins_base_url_and_paths() {
+        let client = AtlassianClient::new(
+            AtlassianInstance::new("https://example.atlassian.net/"),
+            "neo@example.com",
+            "token",
+        );
+
+        assert_eq!(
+            client.url("/rest/api/3/project/search"),
+            "https://example.atlassian.net/rest/api/3/project/search"
+        );
+    }
+}