Skip to content

Modern Docker Management, Designed for Everyone

8.7 KB
Raw Blame
package variables

import (
	"cmp"
	"errors"
	"fmt"
	"net/http"
	"slices"
	"strconv"
	"strings"
	"time"

	"github.com/getarcaneapp/arcane/types/v2/env"
	"github.com/spf13/cobra"
	"go.getarcane.app/kit/pkg"

	"github.com/getarcaneapp/arcane/cli/v2/internal/cmdutil"
	"github.com/getarcaneapp/arcane/cli/v2/internal/output"
	"github.com/getarcaneapp/arcane/cli/v2/internal/types"
)

// Command is the parent command for global variable operations.
func Command() *cobra.Command {
	command := &cobra.Command{
		Use:     "variables",
		Aliases: []string{"variable", "vars"},
		Short:   "Manage global variables",
	}
	command.AddCommand(newListCmd())
	command.AddCommand(newCreateCmd())
	command.AddCommand(newUpdateCmd())
	command.AddCommand(newDeleteCmd())
	command.AddCommand(newSyncCmd())
	return command
}

const secretMask = "********"

func printMutationResult(result env.GlobalVariableMutationResponse, message string) error {
	output.Success("%s", message)
	if result.Variable != nil {
		output.KeyValue("ID", result.Variable.ID)
		output.KeyValue("Key", result.Variable.Key)
		output.KeyValue("Secret", strconv.FormatBool(result.Variable.IsSecret))
		scope := "-"
		switch {
		case result.Variable.AllEnvironments:
			scope = "all environments"
		case len(result.Variable.EnvironmentIDs) > 0:
			scope = strings.Join(result.Variable.EnvironmentIDs, ",")
		}
		output.KeyValue("Scope", scope)
	}
	return nil
}

func newListCmd() *cobra.Command {
	return &cobra.Command{
		Use:          "list",
		Aliases:      []string{"ls"},
		Short:        "List global variables",
		Args:         cobra.NoArgs,
		SilenceUsage: true,
		RunE: func(cmd *cobra.Command, args []string) error {
			c, err := cmdutil.ClientFromCommand(cmd)
			if err != nil {
				return err
			}

			return cmdutil.Run(cmd, c, cmdutil.Spec[[]env.GlobalVariable]{
				Method:         http.MethodGet,
				Path:           types.Variables(),
				FailureMessage: "failed to list variables",
				Render: func(data []env.GlobalVariable) error {
					headers := []string{"ID", "KEY", "SCOPE", "SECRET", "VALUE"}
					rows := make([][]string, len(data))
					for i, variable := range data {
						value := variable.Value
						if variable.IsSecret {
							value = secretMask
						}
						scope := "-"
						switch {
						case variable.AllEnvironments:
							scope = "all environments"
						case len(variable.EnvironmentIDs) > 0:
							scope = strings.Join(variable.EnvironmentIDs, ",")
						}
						rows[i] = []string{
							variable.ID,
							variable.Key,
							scope,
							strconv.FormatBool(variable.IsSecret),
							value,
						}
					}

					if tableErr := output.Table(headers, rows); tableErr != nil {
						return tableErr
					}
					_, _ = fmt.Fprintf(output.Stdout(), "\nTotal: %d variables\n", len(data))
					return nil
				},
			})
		},
	}
}

func newCreateCmd() *cobra.Command {
	var opts struct {
		key     string
		value   string
		secret  bool
		allEnvs bool
		envIDs  []string
	}
	command := &cobra.Command{
		Use:          "create",
		Short:        "Create a global variable",
		Args:         cobra.NoArgs,
		SilenceUsage: true,
		RunE: func(cmd *cobra.Command, args []string) error {
			c, err := cmdutil.ClientFromCommand(cmd)
			if err != nil {
				return err
			}

			req := env.CreateGlobalVariableRequest{
				Key:             opts.key,
				Value:           opts.value,
				IsSecret:        opts.secret,
				AllEnvironments: opts.allEnvs,
				EnvironmentIDs:  opts.envIDs,
			}

			return cmdutil.Run(cmd, c, cmdutil.Spec[env.GlobalVariableMutationResponse]{
				Method:         http.MethodPost,
				Path:           types.Variables(),
				FailureMessage: "failed to create variable",
				Body:           req,
				Render: func(data env.GlobalVariableMutationResponse) error {
					return printMutationResult(data, fmt.Sprintf("Variable %s created successfully", opts.key))
				},
			})
		},
	}
	command.Flags().StringVar(&opts.key, "key", "", "Variable key")
	command.Flags().StringVar(&opts.value, "value", "", "Variable value")
	command.Flags().BoolVar(&opts.secret, "secret", false, "Store the value as a secret")
	command.Flags().BoolVar(&opts.allEnvs, "all-environments", false, "Scope the variable to all environments")
	command.Flags().StringArrayVar(&opts.envIDs, "environment", nil, "Environment ID to scope the variable to (repeatable)")
	_ = command.MarkFlagRequired("key")
	return command
}

func newUpdateCmd() *cobra.Command {
	var opts struct {
		key     string
		value   string
		secret  bool
		allEnvs bool
		envIDs  []string
	}
	command := &cobra.Command{
		Use:          "update <id>",
		Short:        "Update a global variable",
		Args:         cobra.ExactArgs(1),
		SilenceUsage: true,
		RunE: func(cmd *cobra.Command, args []string) error {
			if !slices.ContainsFunc([]string{"key", "value", "secret", "all-environments", "environment"}, cmd.Flags().Changed) {
				return errors.New("no updates provided (set at least one flag)")
			}
			c, err := cmdutil.ClientFromCommand(cmd)
			if err != nil {
				return err
			}

			req := env.UpdateGlobalVariableRequest{
				Key:             kit.Ternary(cmd.Flags().Changed("key"), &opts.key, nil),
				Value:           kit.Ternary(cmd.Flags().Changed("value"), &opts.value, nil),
				IsSecret:        kit.Ternary(cmd.Flags().Changed("secret"), &opts.secret, nil),
				AllEnvironments: kit.Ternary(cmd.Flags().Changed("all-environments"), &opts.allEnvs, nil),
				EnvironmentIDs:  kit.Ternary(cmd.Flags().Changed("environment"), &opts.envIDs, nil),
			}

			return cmdutil.Run(cmd, c, cmdutil.Spec[env.GlobalVariableMutationResponse]{
				Method:         http.MethodPut,
				Path:           types.Variable(args[0]),
				FailureMessage: "failed to update variable",
				Body:           req,
				Render: func(data env.GlobalVariableMutationResponse) error {
					return printMutationResult(data, "Variable updated successfully")
				},
			})
		},
	}
	command.Flags().StringVar(&opts.key, "key", "", "Variable key")
	command.Flags().StringVar(&opts.value, "value", "", "Variable value")
	command.Flags().BoolVar(&opts.secret, "secret", false, "Store the value as a secret")
	command.Flags().BoolVar(&opts.allEnvs, "all-environments", false, "Scope the variable to all environments")
	command.Flags().StringArrayVar(&opts.envIDs, "environment", nil, "Environment ID to scope the variable to (repeatable)")
	return command
}

func newDeleteCmd() *cobra.Command {
	var opts struct {
		force bool
	}
	command := &cobra.Command{
		Use:          "delete <id>",
		Aliases:      []string{"rm", "remove"},
		Short:        "Delete a global variable",
		Args:         cobra.ExactArgs(1),
		SilenceUsage: true,
		RunE: func(cmd *cobra.Command, args []string) error {
			c, err := cmdutil.ClientFromCommand(cmd)
			if err != nil {
				return err
			}
			return cmdutil.RunDelete(cmd, c, cmdutil.DeleteSpec{
				Force:          opts.force,
				Prompt:         fmt.Sprintf("Are you sure you want to delete variable %s?", args[0]),
				Path:           types.Variable(args[0]),
				FailureMessage: "failed to delete variable",
				SuccessMessage: "Variable deleted successfully",
			})
		},
	}
	command.Flags().BoolVarP(&opts.force, "force", "f", false, "Skip the confirmation prompt")
	return command
}

func newSyncCmd() *cobra.Command {
	var opts struct {
		syncStatus bool
	}
	command := &cobra.Command{
		Use:          "sync",
		Short:        "Sync global variables to every environment (--status shows the last sync result per environment)",
		Args:         cobra.NoArgs,
		SilenceUsage: true,
		RunE: func(cmd *cobra.Command, args []string) error {
			c, err := cmdutil.ClientFromCommand(cmd)
			if err != nil {
				return err
			}

			method, path, failureMessage := http.MethodPost, types.VariablesSync(), "failed to sync variables"
			if opts.syncStatus {
				method, path, failureMessage = http.MethodGet, types.VariablesSyncStatus(), "failed to get variable sync status"
			}
			return cmdutil.Run(cmd, c, cmdutil.Spec[[]env.EnvironmentSyncStatus]{
				Method:         method,
				Path:           path,
				FailureMessage: failureMessage,
				Render: func(data []env.EnvironmentSyncStatus) error {
					headers := []string{"ENVIRONMENT ID", "NAME", "STATUS", "LAST SYNCED", "ERROR"}
					rows := make([][]string, len(data))
					for i, status := range data {
						lastSynced := "-"
						if status.LastSyncedAt != nil {
							lastSynced = status.LastSyncedAt.Format(time.RFC3339)
						}
						syncError := cmp.Or(status.Error, "-")
						rows[i] = []string{
							status.EnvironmentID,
							status.EnvironmentName,
							status.Status,
							lastSynced,
							syncError,
						}
					}
					return output.Table(headers, rows)
				},
			})
		},
	}
	command.Flags().BoolVar(&opts.syncStatus, "status", false, "Show the last sync result per environment instead of triggering a sync")
	return command
}