Merge pull request #13 from major-technology/3

Refactor the hiearchy of commands

Author: jasonzbao

clients/api/client.go

@@ -0,0 +1,221 @@
+package api
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"time"
+
+	mjrToken "github.com/major-technology/cli/clients/token"
+	"github.com/pkg/errors"
+)
+
+// Client represents an API client for making authenticated requests
+type Client struct {
+	baseURL    string
+	httpClient *http.Client
+}
+
+// NewClient creates a new API client with the provided base URL and optional token
+func NewClient(baseURL string) *Client {
+	return &Client{
+		baseURL: baseURL,
+		httpClient: &http.Client{
+			Timeout: 30 * time.Second,
+		},
+	}
+}
+
+// doRequestWithoutAuth is a helper method to make unauthenticated HTTP requests
+func (c *Client) doRequestWithoutAuth(method, path string, body interface{}, response interface{}) error {
+	return c.doRequestInternal(method, path, body, response, false)
+}
+
+// doRequest is a helper method to make HTTP requests with common error handling
+// It automatically gets the token from the keyring for each request
+func (c *Client) doRequest(method, path string, body interface{}, response interface{}) error {
+	return c.doRequestInternal(method, path, body, response, true)
+}
+
+// doRequestInternal is the internal implementation for making HTTP requests
+func (c *Client) doRequestInternal(method, path string, body interface{}, response interface{}, requireAuth bool) error {
+	var token string
+	if requireAuth {
+		// Get token from keyring for this request
+		t, err := mjrToken.GetToken()
+		if err != nil {
+			return &NoTokenError{OriginalError: err}
+		}
+		token = t
+	}
+
+	var reqBody io.Reader
+	if body != nil {
+		jsonBody, err := json.Marshal(body)
+		if err != nil {
+			return errors.Wrap(err, "failed to marshal request body")
+		}
+		reqBody = bytes.NewBuffer(jsonBody)
+	}
+
+	url := c.baseURL + path
+	req, err := http.NewRequest(method, url, reqBody)
+	if err != nil {
+		return errors.Wrap(err, "failed to create request")
+	}
+
+	req.Header.Set("Content-Type", "application/json")
+	if token != "" {
+		req.Header.Set("Authorization", "Bearer "+token)
+	}
+
+	resp, err := c.httpClient.Do(req)
+	if err != nil {
+		return errors.Wrap(err, "failed to make request")
+	}
+	defer resp.Body.Close()
+
+	respBody, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return errors.Wrap(err, "failed to read response")
+	}
+
+	// Handle error responses
+	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
+		var errResp ErrorResponse
+		if err := json.Unmarshal(respBody, &errResp); err == nil && errResp.Message != "" {
+			return &APIError{
+				StatusCode: resp.StatusCode,
+				Message:    errResp.Message,
+				ErrorType:  errResp.Error,
+			}
+		}
+		return &APIError{
+			StatusCode: resp.StatusCode,
+			Message:    string(respBody),
+		}
+	}
+
+	// Parse successful response if a response struct is provided
+	if response != nil {
+		if err := json.Unmarshal(respBody, response); err != nil {
+			return errors.Wrap(err, "failed to parse response")
+		}
+	}
+
+	return nil
+}
+
+// --- Authentication / User endpoints ---
+
+// StartLogin initiates the device flow login process
+func (c *Client) StartLogin() (*LoginStartResponse, error) {
+	var resp LoginStartResponse
+	err := c.doRequestWithoutAuth("POST", "/login/start", map[string]interface{}{}, &resp)
+	if err != nil {
+		return nil, err
+	}
+	return &resp, nil
+}
+
+// PollLogin polls the login endpoint to check if the user has authorized the device
+func (c *Client) PollLogin(deviceCode string) (*LoginPollResponse, error) {
+	req := LoginPollRequest{DeviceCode: deviceCode}
+
+	var resp LoginPollResponse
+	err := c.doRequestWithoutAuth("POST", "/login/poll", req, &resp)
+	if err != nil {
+		// Check if it's a bad request (expired/invalid codes)
+		if IsBadRequest(err) {
+			return nil, fmt.Errorf("invalid or expired device code")
+		}
+		return nil, err
+	}
+
+	return &resp, nil
+}
+
+// VerifyToken verifies the current token and returns user information
+func (c *Client) VerifyToken() (*VerifyTokenResponse, error) {
+	var resp VerifyTokenResponse
+	err := c.doRequest("GET", "/verify", nil, &resp)
+	if err != nil {
+		if IsUnauthorized(err) {
+			return nil, fmt.Errorf("invalid or expired token - please login again")
+		}
+		return nil, err
+	}
+
+	if !resp.Active {
+		return nil, fmt.Errorf("token is not active - please login again")
+	}
+
+	return &resp, nil
+}
+
+// Logout revokes the current token
+func (c *Client) Logout() error {
+	return c.doRequest("POST", "/logout", map[string]interface{}{}, nil)
+}
+
+// --- Organization endpoints ---
+
+// GetOrganizations retrieves the list of organizations for the authenticated user
+func (c *Client) GetOrganizations() (*OrganizationsResponse, error) {
+	var resp OrganizationsResponse
+	err := c.doRequest("GET", "/organizations", nil, &resp)
+	if err != nil {
+		return nil, err
+	}
+	return &resp, nil
+}
+
+// --- Application endpoints ---
+
+// CreateApplication creates a new application with a GitHub repository
+func (c *Client) CreateApplication(name, description, organizationID string) (*CreateApplicationResponse, error) {
+	req := CreateApplicationRequest{
+		Name:           name,
+		Description:    description,
+		OrganizationID: organizationID,
+	}
+
+	var resp CreateApplicationResponse
+	err := c.doRequest("POST", "/applications", req, &resp)
+	if err != nil {
+		return nil, err
+	}
+	return &resp, nil
+}
+
+// GetApplicationByRepo retrieves an application by its repository owner and name
+func (c *Client) GetApplicationByRepo(owner, repo string) (*GetApplicationByRepoResponse, error) {
+	req := GetApplicationByRepoRequest{
+		Owner: owner,
+		Repo:  repo,
+	}
+
+	var resp GetApplicationByRepoResponse
+	err := c.doRequest("POST", "/application/from-repo", req, &resp)
+	if err != nil {
+		return nil, err
+	}
+	return &resp, nil
+}
+
+// GetApplicationEnv retrieves environment variables for an application
+func (c *Client) GetApplicationEnv(organizationID, applicationID string) (map[string]string, error) {
+	req := GetApplicationEnvRequest{
+		OrganizationID: organizationID,
+		ApplicationID:  applicationID,
+	}
+
+	var resp GetApplicationEnvResponse
+	err := c.doRequest("POST", "/application/env", req, &resp)
+	if err != nil {
+		return nil, err
+	}
+	return resp.EnvVars, nil
+}

clients/api/errors.go

@@ -0,0 +1,100 @@
+package api
+
+import (
+	"errors"
+	"fmt"
+	"net/http"
+
+	"github.com/spf13/cobra"
+)
+
+// ErrorResponse represents an error response from the API
+type ErrorResponse struct {
+	Error   string `json:"error"`
+	Message string `json:"message"`
+}
+
+// APIError represents an API error with status code and message
+type APIError struct {
+	StatusCode int
+	Message    string
+	ErrorType  string
+}
+
+func (e *APIError) Error() string {
+	if e.ErrorType != "" {
+		return fmt.Sprintf("API error (status %d): %s - %s", e.StatusCode, e.ErrorType, e.Message)
+	}
+	return fmt.Sprintf("API error (status %d): %s", e.StatusCode, e.Message)
+}
+
+// NoTokenError represents an error when no token is available
+type NoTokenError struct {
+	OriginalError error
+}
+
+func (e *NoTokenError) Error() string {
+	return fmt.Sprintf("not logged in: %v", e.OriginalError)
+}
+
+// IsUnauthorized checks if the error is an unauthorized error
+func IsUnauthorized(err error) bool {
+	var apiErr *APIError
+	if errors.As(err, &apiErr) {
+		return apiErr.StatusCode == http.StatusUnauthorized
+	}
+	return false
+}
+
+// IsNotFound checks if the error is a not found error
+func IsNotFound(err error) bool {
+	var apiErr *APIError
+	if errors.As(err, &apiErr) {
+		return apiErr.StatusCode == http.StatusNotFound
+	}
+	return false
+}
+
+// IsBadRequest checks if the error is a bad request error
+func IsBadRequest(err error) bool {
+	var apiErr *APIError
+	if errors.As(err, &apiErr) {
+		return apiErr.StatusCode == http.StatusBadRequest
+	}
+	return false
+}
+
+// IsNoToken checks if the error is a no token error
+func IsNoToken(err error) bool {
+	var noTokenErr *NoTokenError
+	return errors.As(err, &noTokenErr)
+}
+
+// CheckErr checks for errors and prints appropriate messages using the command's output
+// Returns true if no error (ok to continue), false if there was an error
+func CheckErr(cmd *cobra.Command, err error) bool {
+	if err == nil {
+		return true
+	}
+
+	// Check if it's a no token error
+	if IsNoToken(err) {
+		cmd.Println("Error: Not logged in. Please run 'major user login' first.")
+		return false
+	}
+
+	// Check if it's an API error
+	var apiErr *APIError
+	if errors.As(err, &apiErr) {
+		cmd.Printf("Error: Failed to make request (status %d)\n", apiErr.StatusCode)
+		if apiErr.ErrorType != "" {
+			cmd.Printf("  Type: %s\n", apiErr.ErrorType)
+		}
+		cmd.Printf("  Message: %s\n", apiErr.Message)
+		return false
+	}
+
+	// Generic error
+	cmd.Printf("Error: %v\n", err)
+	return false
+}