Support async DB listing & job retrieval

Add higher-level client helpers and refactor callers: implement Client.GetJob to handle both wrapped and flat job responses, and Client.ListDatabases to handle synchronous (200) and asynchronous (202 -> job) /api/dbs responses. Introduce databasesFromJobResult to extract database rows from job results and update WaitForJob to use GetJob. Update cmd/db.go and cmd/jobs.go to call the new client methods and simplify response handling and output. These changes centralize API parsing and enable polling for async database listings.

Author: andreapollastri

cmd/db.go

@@ -24,35 +24,36 @@ var dbListCmd = &cobra.Command{
 			return err
 		}
 
-		var result struct {
-			Data []map[string]interface{} `json:"data"`
-		}
-
-		if err := client.Get("/api/dbs", &result); err != nil {
+		dbs, err := client.ListDatabases()
+		if err != nil {
 			output.Error("Failed to list databases: %s", err)
 			return err
 		}
 
+		result := struct {
+			Data []map[string]interface{} `json:"data"`
+		}{Data: dbs}
+
 		if jsonFlag {
 			output.PrintJSON(result)
 			return nil
 		}
 
-		if len(result.Data) == 0 {
+		if len(dbs) == 0 {
 			output.Warn("No databases found")
 			return nil
 		}
 
 		output.Header("Databases")
 		t := output.NewTable("NAME", "SIZE")
-		for _, db := range result.Data {
+		for _, db := range dbs {
 			t.Row(
 				str(db, "name"),
 				str(db, "size"),
 			)
 		}
 		t.Flush()
-		output.Dim.Printf("  Total: %d database(s)\n\n", len(result.Data))
+		output.Dim.Printf("  Total: %d database(s)\n\n", len(dbs))
 		return nil
 	},
 }

cmd/jobs.go

@@ -25,8 +25,8 @@ var jobsShowCmd = &cobra.Command{
 			return err
 		}
 
-		var job api.JobStatus
-		if err := client.Get(fmt.Sprintf("/api/jobs/%s", args[0]), &job); err != nil {
+		job, err := client.GetJob(args[0])
+		if err != nil {
 			output.Error("Failed to get job: %s", err)
 			return err
 		}

internal/api/client.go

@@ -140,6 +140,119 @@ func (c *Client) Get(path string, result interface{}) error {
 	return c.parseResponse(resp, result)
 }
 
+// GetJob fetches GET /api/jobs/{id}. The API returns either { "data": { job } } or a flat job object.
+func (c *Client) GetJob(jobID string) (*JobStatus, error) {
+	resp, err := c.request("GET", fmt.Sprintf("/api/jobs/%s", jobID), nil)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+	data, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return nil, err
+	}
+	if resp.StatusCode >= 400 {
+		var apiErr APIError
+		if json.Unmarshal(data, &apiErr) == nil && apiErr.Message != "" {
+			return nil, &apiErr
+		}
+		return nil, fmt.Errorf("API error (HTTP %d): %s", resp.StatusCode, string(data))
+	}
+	var outer map[string]json.RawMessage
+	if err := json.Unmarshal(data, &outer); err != nil {
+		return nil, fmt.Errorf("parsing job response: %w", err)
+	}
+	if raw, ok := outer["data"]; ok {
+		var job JobStatus
+		if err := json.Unmarshal(raw, &job); err != nil {
+			return nil, fmt.Errorf("parsing job data: %w", err)
+		}
+		return &job, nil
+	}
+	var job JobStatus
+	if err := json.Unmarshal(data, &job); err != nil {
+		return nil, fmt.Errorf("parsing job response: %w", err)
+	}
+	return &job, nil
+}
+
+// ListDatabases returns GET /api/dbs. The server may answer synchronously (200 + data) or
+// asynchronously (202 + job_id); in the latter case the job is polled until completion.
+func (c *Client) ListDatabases() ([]map[string]interface{}, error) {
+	resp, err := c.request("GET", "/api/dbs", nil)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return nil, err
+	}
+	if resp.StatusCode >= 400 {
+		var apiErr APIError
+		if json.Unmarshal(body, &apiErr) == nil && apiErr.Message != "" {
+			return nil, &apiErr
+		}
+		return nil, fmt.Errorf("API error (HTTP %d): %s", resp.StatusCode, string(body))
+	}
+
+	switch resp.StatusCode {
+	case http.StatusOK:
+		var v struct {
+			Data []map[string]interface{} `json:"data"`
+		}
+		if err := json.Unmarshal(body, &v); err != nil {
+			return nil, fmt.Errorf("parsing database list: %w", err)
+		}
+		if v.Data == nil {
+			return []map[string]interface{}{}, nil
+		}
+		return v.Data, nil
+	case http.StatusAccepted:
+		var async AsyncResponse
+		if err := json.Unmarshal(body, &async); err != nil {
+			return nil, fmt.Errorf("parsing async response: %w", err)
+		}
+		if async.JobID == nil || async.JobIDString() == "" {
+			return nil, fmt.Errorf("no job_id in database list response")
+		}
+		job, err := c.WaitForJob(async.JobIDString())
+		if err != nil {
+			return nil, err
+		}
+		return databasesFromJobResult(job.Result)
+	default:
+		return nil, fmt.Errorf("unexpected HTTP %d listing databases: %s", resp.StatusCode, string(body))
+	}
+}
+
+func databasesFromJobResult(result interface{}) ([]map[string]interface{}, error) {
+	if result == nil {
+		return []map[string]interface{}{}, nil
+	}
+	m, ok := result.(map[string]interface{})
+	if !ok {
+		return nil, fmt.Errorf("unexpected job result format for database list")
+	}
+	raw, ok := m["databases"]
+	if !ok || raw == nil {
+		return []map[string]interface{}{}, nil
+	}
+	arr, ok := raw.([]interface{})
+	if !ok {
+		return nil, fmt.Errorf("job result \"databases\" is not an array")
+	}
+	out := make([]map[string]interface{}, 0, len(arr))
+	for _, item := range arr {
+		row, ok := item.(map[string]interface{})
+		if !ok {
+			continue
+		}
+		out = append(out, row)
+	}
+	return out, nil
+}
+
 func (c *Client) Post(path string, body interface{}, result interface{}) error {
 	resp, err := c.request("POST", path, body)
 	if err != nil {
@@ -191,23 +304,23 @@ func (c *Client) WaitForJob(jobID string) (*JobStatus, error) {
 
 	maxAttempts := 120
 	for i := 0; i < maxAttempts; i++ {
-		var job JobStatus
-		if err := c.Get(fmt.Sprintf("/api/jobs/%s", jobID), &job); err != nil {
+		job, err := c.GetJob(jobID)
+		if err != nil {
 			time.Sleep(2 * time.Second)
 			continue
 		}
 
 		switch job.Status {
 		case "completed", "success", "finished":
 			s.Stop()
-			return &job, nil
+			return job, nil
 		case "failed", "error":
 			s.Stop()
 			errMsg := job.Error
 			if errMsg == "" {
 				errMsg = "job failed"
 			}
-			return &job, fmt.Errorf("%s", errMsg)
+			return job, fmt.Errorf("%s", errMsg)
 		}
 
 		interval := 2 * time.Second