feat(indexes): workspace-wide list with filters and parallel fetch

Indexes list no longer requires connection, schema, and table. Defaults
to all tables in the workspace; optional flags narrow the catalog scan.

Resolve information_schema connection labels to connection IDs via
GET /connections. Skip missing tables when the indexes endpoint
returns 404 so stale catalog rows do not abort the run.

Fetch per-table indexes in parallel with rayon to reduce wall-clock
latency. Add ApiClient::Clone and get_none_if_not_found for the scan.

Author: eddietejeda

Cargo.lock

@@ -16,6 +16,7 @@ anstyle = "1.0.13"
 clap = { version = "4", features = ["derive"] }
 directories = "6"
 reqwest = { version = "0.12", features = ["blocking", "json"] }
+rayon = "1.10"
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
 serde_yaml = "0.9"

Cargo.toml

@@ -4,6 +4,7 @@ use crate::util;
 use crossterm::style::Stylize;
 use serde::de::DeserializeOwned;
 
+#[derive(Clone)]
 pub struct ApiClient {
     client: reqwest::blocking::Client,
     api_key: String,
@@ -156,6 +157,37 @@ impl ApiClient {
         }
     }
 
+    /// GET request; returns `None` on HTTP 404. Other status codes use the same handling as
+    /// [`Self::get`]. Used when probing many paths where a missing resource is normal.
+    pub fn get_none_if_not_found<T: DeserializeOwned>(&self, path: &str) -> Option<T> {
+        let url = format!("{}{path}", self.api_url);
+        self.log_request("GET", &url, None);
+
+        let resp = match self.build_request(reqwest::Method::GET, &url).send() {
+            Ok(r) => r,
+            Err(e) => {
+                eprintln!("error connecting to API: {e}");
+                std::process::exit(1);
+            }
+        };
+
+        let (status, body) = util::debug_response(resp);
+        if status == reqwest::StatusCode::NOT_FOUND {
+            return None;
+        }
+        if !status.is_success() {
+            self.fail_response(status, body);
+        }
+
+        match serde_json::from_str(&body) {
+            Ok(v) => Some(v),
+            Err(e) => {
+                eprintln!("error parsing response: {e}");
+                std::process::exit(1);
+            }
+        }
+    }
+
     /// POST request with JSON body, returns parsed response.
     pub fn post<T: DeserializeOwned>(&self, path: &str, body: &serde_json::Value) -> T {
         let url = format!("{}{path}", self.api_url);

src/api.rs

@@ -248,19 +248,19 @@ pub enum AuthCommands {
 
 #[derive(Subcommand)]
 pub enum IndexesCommands {
-    /// List indexes on a table
+    /// List indexes (defaults to the whole workspace; narrow with filters)
     List {
-        /// Connection ID
+        /// Filter by connection ID
         #[arg(long, short = 'c')]
-        connection_id: String,
+        connection_id: Option<String>,
 
-        /// Schema name
+        /// Filter by schema name
         #[arg(long)]
-        schema: String,
+        schema: Option<String>,
 
-        /// Table name
+        /// Filter by table name
         #[arg(long)]
-        table: String,
+        table: Option<String>,
 
         /// Output format
         #[arg(long = "output", short = 'o', default_value = "table", value_parser = ["table", "json", "yaml"])]