Refactor logout to use sentinel error and separate messages

gtsiolis · gtsiolis · commit e5943ab41449 · 2026-02-20T12:52:47.000+02:00
diff --git a/cmd/logout.go b/cmd/logout.go
@@ -1,6 +1,7 @@
 package cmd
 
 import (
+	"errors"
 	"os"
 
 	"github.com/localstack/lstk/internal/api"
@@ -20,28 +21,20 @@ var logoutCmd = &cobra.Command{
 			return err
 		}
 
-		sink := output.NewPlainSink(os.Stdout)
-		a := auth.New(sink, platformClient, tokenStorage, false)
-
 		if ui.IsInteractive() {
+			a := auth.New(nil, platformClient, tokenStorage, false)
 			return ui.RunLogout(cmd.Context(), version, a)
 		}
 
-		// Non-interactive mode
-		output.EmitLog(sink, "Logging out...")
-
-		result, err := a.Logout()
-		if err != nil {
-			return err
-		}
+		// Non-interactive mode: auth emits events through the sink
+		sink := output.NewPlainSink(os.Stdout)
+		a := auth.New(sink, platformClient, tokenStorage, false)
 
-		if result.TokenDeleted {
-			output.EmitSuccess(sink, "Logged out successfully.")
-		} else {
-			output.EmitNote(sink, "Not currently logged in.")
+		err = a.Logout()
+		if errors.Is(err, auth.ErrNotLoggedIn) {
+			return nil
 		}
-
-		return nil
+		return err
 	},
 }
 
diff --git a/internal/auth/auth.go b/internal/auth/auth.go
@@ -56,20 +56,23 @@ func (a *Auth) GetToken(ctx context.Context) (string, error) {
 	return token, nil
 }
 
-// LogoutResult represents the outcome of a logout operation
-type LogoutResult struct {
-	TokenDeleted bool
-}
+var ErrNotLoggedIn = errors.New("not currently logged in")
 
 // Logout removes the stored auth token from the keyring.
-// Returns LogoutResult indicating whether a token was actually deleted.
-func (a *Auth) Logout() (LogoutResult, error) {
+// Returns ErrNotLoggedIn if no token was stored.
+// Emits success/note events through the sink if one is configured.
+func (a *Auth) Logout() error {
+	output.EmitLog(a.sink, "Logging out...")
+
 	err := a.tokenStorage.DeleteAuthToken()
 	if errors.Is(err, keyring.ErrKeyNotFound) {
-		return LogoutResult{TokenDeleted: false}, nil
+		output.EmitNote(a.sink, "Not currently logged in.")
+		return ErrNotLoggedIn
 	}
 	if err != nil {
-		return LogoutResult{}, err
+		return err
 	}
-	return LogoutResult{TokenDeleted: true}, nil
+
+	output.EmitSuccess(a.sink, "Logged out successfully.")
+	return nil
 }
diff --git a/internal/ui/run_logout.go b/internal/ui/run_logout.go
@@ -2,6 +2,7 @@ package ui
 
 import (
 	"context"
+	"errors"
 	"time"
 
 	tea "github.com/charmbracelet/bubbletea"
@@ -12,30 +13,34 @@ import (
 
 const minSpinnerDuration = 400 * time.Millisecond
 
-type logoutDoneMsg struct {
-	result auth.LogoutResult
-}
+type logoutSuccessMsg struct{}
+
+type logoutNotLoggedInMsg struct{}
 
 type logoutErrMsg struct {
 	err error
 }
 
+type logoutState int
+
+const (
+	logoutStateLoading logoutState = iota
+	logoutStateSuccess
+	logoutStateNotLoggedIn
+)
+
 type LogoutApp struct {
 	header  components.Header
 	spinner components.Spinner
-	result  *logoutResultDisplay
+	state   logoutState
 	err     error
 }
 
-type logoutResultDisplay struct {
-	success bool
-	message string
-}
-
 func NewLogoutApp(version string) LogoutApp {
 	return LogoutApp{
 		header:  components.NewHeader(version),
 		spinner: components.NewSpinner().Show("Logging out"),
+		state:   logoutStateLoading,
 	}
 }
 
@@ -50,13 +55,14 @@ func (a LogoutApp) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 			return a, tea.Quit
 		}
 
-	case logoutDoneMsg:
+	case logoutSuccessMsg:
 		a.spinner = a.spinner.Hide()
-		if msg.result.TokenDeleted {
-			a.result = &logoutResultDisplay{success: true, message: "Logged out successfully."}
-		} else {
-			a.result = &logoutResultDisplay{success: false, message: "Not currently logged in."}
-		}
+		a.state = logoutStateSuccess
+		return a, tea.Quit
+
+	case logoutNotLoggedInMsg:
+		a.spinner = a.spinner.Hide()
+		a.state = logoutStateNotLoggedIn
 		return a, tea.Quit
 
 	case logoutErrMsg:
@@ -82,19 +88,24 @@ func (a LogoutApp) View() string {
 		s += a.spinner.View() + "\n"
 	}
 
-	if a.result != nil {
-		s += renderLogoutResult(a.result) + "\n"
+	switch a.state {
+	case logoutStateSuccess:
+		s += renderLogoutSuccess() + "\n"
+	case logoutStateNotLoggedIn:
+		s += renderLogoutNotLoggedIn() + "\n"
 	}
 
 	return s
 }
 
-func renderLogoutResult(r *logoutResultDisplay) string {
+func renderLogoutSuccess() string {
 	prefix := styles.Secondary.Render("> ")
-	if r.success {
-		return prefix + styles.Success.Render("Success:") + " " + styles.Message.Render(r.message)
-	}
-	return prefix + styles.Note.Render("Note:") + " " + styles.Message.Render(r.message)
+	return prefix + styles.Success.Render("Success:") + " " + styles.Message.Render("Logged out successfully.")
+}
+
+func renderLogoutNotLoggedIn() string {
+	prefix := styles.Secondary.Render("> ")
+	return prefix + styles.Note.Render("Note:") + " " + styles.Message.Render("Not currently logged in.")
 }
 
 func (a LogoutApp) Err() error {
@@ -107,19 +118,23 @@ func RunLogout(ctx context.Context, version string, a *auth.Auth) error {
 
 	go func() {
 		start := time.Now()
-		result, err := a.Logout()
+		err := a.Logout()
 
 		// Ensure spinner is visible for minimum duration
 		elapsed := time.Since(start)
 		if elapsed < minSpinnerDuration {
 			time.Sleep(minSpinnerDuration - elapsed)
 		}
 
+		if errors.Is(err, auth.ErrNotLoggedIn) {
+			p.Send(logoutNotLoggedInMsg{})
+			return
+		}
 		if err != nil {
 			p.Send(logoutErrMsg{err: err})
 			return
 		}
-		p.Send(logoutDoneMsg{result: result})
+		p.Send(logoutSuccessMsg{})
 	}()
 
 	model, err := p.Run()
