Try unify error response parsing and handling

Author: Askir

internal/tiger/api/client.go

@@ -6,6 +6,7 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
+	"io"
 	"net/http"
 	"sync"
 	"time"
@@ -134,3 +135,72 @@ func FormatAPIErrorFromBody(body []byte, fallback string) error {
 	}
 	return errors.New(fallback)
 }
+
+// Error implements the error interface for the Error type.
+// This allows Error values to be used directly as Go errors.
+func (e *Error) Error() string {
+	if e == nil {
+		return "unknown error"
+	}
+	if e.Message != nil && *e.Message != "" {
+		return *e.Message
+	}
+	return "unknown error"
+}
+
+// ResponseError wraps an API response with an error, preserving the status code
+// for proper exit code mapping in CLI commands
+type ResponseError struct {
+	statusCode int
+	response   *http.Response
+	err        error
+}
+
+func (r *ResponseError) Error() string {
+	return r.err.Error()
+}
+
+func (r *ResponseError) StatusCode() int {
+	return r.statusCode
+}
+
+func (r *ResponseError) HTTPResponse() *http.Response {
+	return r.response
+}
+
+func (r *ResponseError) Unwrap() error {
+	return r.err
+}
+
+// NewResponseError creates an error from an API response
+// It attempts to extract the error message from the response body
+func NewResponseError(response *http.Response) error {
+	if response == nil {
+		return errors.New("unknown error")
+	}
+
+	var err error
+	bodyBytes, readErr := io.ReadAll(response.Body)
+	err = errors.New(string(bodyBytes))
+	return &ResponseError{
+		statusCode: response.StatusCode,
+		response:   response,
+		err:        err,
+	}
+	if readErr == nil && len(bodyBytes) > 0 {
+		var apiErr Error
+		if unmarshalErr := json.Unmarshal(bodyBytes, &apiErr); unmarshalErr == nil {
+			err = &apiErr
+		} else {
+			err = fmt.Errorf("API error: status %d", unmarshalErr.Error())
+		}
+	} else {
+		err = fmt.Errorf("API error: status %d", response.StatusCode)
+	}
+
+	return &ResponseError{
+		statusCode: response.StatusCode,
+		response:   response,
+		err:        err,
+	}
+}

internal/tiger/api/client_util.go

@@ -321,27 +321,11 @@ func getServiceDetails(cmd *cobra.Command, args []string) (api.Service, error) {
 	}
 
 	// Handle API response
-	switch resp.StatusCode() {
-	case 200:
-		if resp.JSON200 == nil {
-			return api.Service{}, fmt.Errorf("empty response from API")
-		}
-
-		return *resp.JSON200, nil
-
-	case 401:
-		return api.Service{}, exitWithCode(ExitAuthenticationError, api.FormatAPIErrorFromBody(resp.Body, "authentication failed: invalid API key"))
-	case 403:
-		return api.Service{}, exitWithCode(ExitPermissionDenied, api.FormatAPIErrorFromBody(resp.Body, "permission denied: insufficient access to service"))
-	case 404:
-		return api.Service{}, exitWithCode(ExitServiceNotFound, api.FormatAPIError(resp.JSON404, fmt.Sprintf("service '%s' not found in project '%s'", serviceID, projectID)))
-	default:
-		statusCode := resp.StatusCode()
-		if statusCode >= 400 && statusCode < 500 {
-			return api.Service{}, api.FormatAPIErrorFromBody(resp.Body, fmt.Sprintf("API request failed with status %d", statusCode))
-		}
-		return api.Service{}, fmt.Errorf("API request failed with status %d", statusCode)
+	if resp.StatusCode() != 200 {
+		return api.Service{}, exitWithErrorFromStatusCode(resp.StatusCode(), resp.JSON4XX)
 	}
+
+	return *resp.JSON200, nil
 }
 
 // ArgsLenAtDashProvider defines the interface for getting ArgsLenAtDash

internal/tiger/api/types.go

@@ -1,5 +1,7 @@
 package cmd
 
+import "errors"
+
 // Exit codes as defined in the CLI specification
 const (
 	ExitSuccess             = 0 // Success
@@ -32,3 +34,34 @@ func (e exitCodeError) ExitCode() int {
 func exitWithCode(code int, err error) error {
 	return exitCodeError{code: code, err: err}
 }
+
+// exitWithErrorFromStatusCode maps HTTP status codes to CLI exit codes
+func exitWithErrorFromStatusCode(statusCode int, err error) error {
+	if err == nil {
+		err = errors.New("unknown error")
+	}
+	switch statusCode {
+	case 400:
+		// Bad request - invalid parameters
+		return exitWithCode(ExitInvalidParameters, err)
+	case 401:
+		// Unauthorized - authentication error
+		return exitWithCode(ExitAuthenticationError, err)
+	case 403:
+		// Forbidden - permission denied
+		return exitWithCode(ExitPermissionDenied, err)
+	case 404:
+		// Not found - service/resource not found
+		return exitWithCode(ExitServiceNotFound, err)
+	case 408, 504:
+		// Request timeout or gateway timeout
+		return exitWithCode(ExitTimeout, err)
+	default:
+		// For other 4xx errors, use general error
+		if statusCode >= 400 && statusCode < 500 {
+			return exitWithCode(ExitGeneralError, err)
+		}
+		// For 5xx and other errors, use general error
+		return exitWithCode(ExitGeneralError, err)
+	}
+}