1. Corrected the output format for all requests

2. Switched flags to args and vice versa to keep the clean format all the way

Author: Jan Sternagel

internal/cmd/beta/kms/key/create/create.go

@@ -24,13 +24,14 @@ import (
 )
 
 const (
-	keyRingIdFlag = "key-ring"
+	keyRingIdFlag = "key-ring-id"
 
 	algorithmFlag   = "algorithm"
 	descriptionFlag = "description"
 	displayNameFlag = "name"
 	importOnlyFlag  = "import-only"
 	purposeFlag     = "purpose"
+	protectionFlag  = "protection"
 )
 
 type inputModel struct {
@@ -42,6 +43,7 @@ type inputModel struct {
 	Name        *string
 	ImportOnly  bool // Default false
 	Purpose     *string
+	Protection  *string
 }
 
 func NewCmd(params *params.CmdParams) *cobra.Command {
@@ -53,10 +55,10 @@ func NewCmd(params *params.CmdParams) *cobra.Command {
 		Example: examples.Build(
 			examples.NewExample(
 				`Create a Symmetric KMS key`,
-				`$ stackit beta kms key create --key-ring "my-keyring-id" --algorithm "rsa_2048_oaep_sha256" --name "my-key-name" --purpose "symmetric_encrypt_decrypt"`),
+				`$ stackit beta kms key create --key-ring "my-keyring-id" --algorithm "rsa_2048_oaep_sha256" --name "my-key-name" --purpose "asymmetric_encrypt_decrypt" --protection "software"`),
 			examples.NewExample(
 				`Create a Message Authentication KMS key`,
-				`$ stackit beta kms key create --key-ring "my-keyring-id" --algorithm "hmac_sha512" --name "my-key-name" --purpose "message_authentication_code"`),
+				`$ stackit beta kms key create --key-ring "my-keyring-id" --algorithm "hmac_sha512" --name "my-key-name" --purpose "message_authentication_code" --protection "software"`),
 		),
 		RunE: func(cmd *cobra.Command, _ []string) error {
 			ctx := context.Background()
@@ -87,10 +89,6 @@ func NewCmd(params *params.CmdParams) *cobra.Command {
 
 			// Call API
 			req, _ := buildRequest(ctx, model, apiClient)
-			if err != nil {
-				return err
-			}
-
 			key, err := req.Execute()
 			if err != nil {
 				return fmt.Errorf("create KMS key: %w", err)
@@ -128,6 +126,7 @@ func parseInput(p *print.Printer, cmd *cobra.Command) (*inputModel, error) {
 		Description:     flags.FlagToStringPointer(p, cmd, descriptionFlag),
 		ImportOnly:      flags.FlagToBoolValue(p, cmd, importOnlyFlag),
 		Purpose:         flags.FlagToStringPointer(p, cmd, purposeFlag),
+		Protection:      flags.FlagToStringPointer(p, cmd, protectionFlag),
 	}
 
 	if p.IsVerbosityDebug() {
@@ -155,6 +154,7 @@ func buildRequest(ctx context.Context, model *inputModel, apiClient kmsKeyClient
 		Algorithm:   kms.CreateKeyPayloadGetAlgorithmAttributeType(model.Algorithm),
 		Purpose:     kms.CreateKeyPayloadGetPurposeAttributeType(model.Purpose),
 		ImportOnly:  &model.ImportOnly,
+		Protection:  kms.CreateKeyPayloadGetProtectionAttributeType(model.Protection),
 	})
 	return req, nil
 }
@@ -171,20 +171,18 @@ func outputResult(p *print.Printer, outputFormat, projectLabel string, resp *kms
 			return fmt.Errorf("marshal KMS key: %w", err)
 		}
 		p.Outputln(string(details))
-		return nil
 
 	case print.YAMLOutputFormat:
 		details, err := yaml.MarshalWithOptions(resp, yaml.IndentSequence(true), yaml.UseJSONMarshaler())
 		if err != nil {
 			return fmt.Errorf("marshal KMS key: %w", err)
 		}
 		p.Outputln(string(details))
-		return nil
 
 	default:
-		p.Outputf("Created key for project %q. key ID: %s\n", projectLabel, utils.PtrString(resp.Id))
-		return nil
+		p.Outputf("Created the key '%s' for project %q. Key ID: %s\n", utils.PtrString(resp.DisplayName), projectLabel, utils.PtrString(resp.Id))
 	}
+	return nil
 }
 
 func configureFlags(cmd *cobra.Command) {
@@ -194,7 +192,8 @@ func configureFlags(cmd *cobra.Command) {
 	cmd.Flags().String(descriptionFlag, "", "Optional description of the key")
 	cmd.Flags().Bool(importOnlyFlag, false, "States whether versions can be created or only imported")
 	cmd.Flags().String(purposeFlag, "", "Purpose of the key. Enum: 'symmetric_encrypt_decrypt', 'asymmetric_encrypt_decrypt', 'message_authentication_code', 'asymmetric_sign_verify' ")
+	cmd.Flags().String(protectionFlag, "", "The underlying system that is responsible for protecting the key material. Value: 'software'")
 
-	err := flags.MarkFlagsRequired(cmd, keyRingIdFlag, algorithmFlag, purposeFlag, displayNameFlag)
+	err := flags.MarkFlagsRequired(cmd, keyRingIdFlag, algorithmFlag, purposeFlag, displayNameFlag, protectionFlag)
 	cobra.CheckErr(err)
 }

internal/cmd/beta/kms/key/create/create_test.go

@@ -22,6 +22,7 @@ const (
 	testPurpose     = "asymmetric_encrypt_decrypt"
 	testDescription = "my key description"
 	testImportOnly  = "true"
+	testProtection  = "software"
 )
 
 type testCtxKey struct{}
@@ -44,6 +45,7 @@ func fixtureFlagValues(mods ...func(flagValues map[string]string)) map[string]st
 		purposeFlag:               testPurpose,
 		descriptionFlag:           testDescription,
 		importOnlyFlag:            testImportOnly,
+		protectionFlag:            testProtection,
 	}
 	for _, mod := range mods {
 		mod(flagValues)
@@ -65,6 +67,7 @@ func fixtureInputModel(mods ...func(model *inputModel)) *inputModel {
 		Purpose:     utils.Ptr(testPurpose),
 		Description: utils.Ptr(testDescription),
 		ImportOnly:  true, // Watch out: ImportOnly is not testImportOnly!
+		Protection:  utils.Ptr(testProtection),
 	}
 	for _, mod := range mods {
 		mod(model)
@@ -81,6 +84,7 @@ func fixtureRequest(mods ...func(request *kms.ApiCreateKeyRequest)) kms.ApiCreat
 		Purpose:     kms.CreateKeyPayloadGetPurposeAttributeType(utils.Ptr(testPurpose)),
 		Description: utils.Ptr(testDescription),
 		ImportOnly:  utils.Ptr(true),
+		Protection:  kms.CreateKeyPayloadGetProtectionAttributeType(utils.Ptr(testProtection)),
 	})
 
 	for _, mod := range mods {
@@ -161,6 +165,13 @@ func TestParseInput(t *testing.T) {
 			}),
 			isValid: false,
 		},
+		{
+			description: "protection missing (required)",
+			flagValues: fixtureFlagValues(func(flagValues map[string]string) {
+				delete(flagValues, protectionFlag)
+			}),
+			isValid: false,
+		},
 		{
 			description: "name missing (required)",
 			flagValues: fixtureFlagValues(func(flagValues map[string]string) {
@@ -248,6 +259,7 @@ func TestBuildRequest(t *testing.T) {
 				Purpose:     kms.CreateKeyPayloadGetPurposeAttributeType(utils.Ptr(testPurpose)),
 				Description: nil,
 				ImportOnly:  utils.Ptr(false),
+				Protection:  kms.CreateKeyPayloadGetProtectionAttributeType(utils.Ptr(testProtection)),
 			}),
 		},
 	}

internal/cmd/beta/kms/key/delete/delete.go

@@ -4,7 +4,6 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
-	"time"
 
 	"github.com/goccy/go-yaml"
 	"github.com/spf13/cobra"
@@ -16,36 +15,38 @@ import (
 	"github.com/stackitcloud/stackit-cli/internal/pkg/globalflags"
 	"github.com/stackitcloud/stackit-cli/internal/pkg/print"
 	kmsUtils "github.com/stackitcloud/stackit-cli/internal/pkg/services/kms/utils"
+	"github.com/stackitcloud/stackit-cli/internal/pkg/utils"
 
 	"github.com/stackitcloud/stackit-cli/internal/pkg/services/kms/client"
 	"github.com/stackitcloud/stackit-sdk-go/services/kms"
 )
 
 const (
-	keyRingIdFlag = "key-ring"
-	keyIdFlag     = "key"
+	keyIdArg = "KEY_ID"
+
+	keyRingIdFlag = "key-ring-id"
 )
 
 type inputModel struct {
 	*globalflags.GlobalFlagModel
-	KeyRingId string
 	KeyId     string
+	KeyRingId string
 }
 
 func NewCmd(params *params.CmdParams) *cobra.Command {
 	cmd := &cobra.Command{
-		Use:   "delete",
+		Use:   fmt.Sprintf("delete %s", keyIdArg),
 		Short: "Deletes a KMS key",
 		Long:  "Deletes a KMS key inside a specific key ring.",
-		Args:  args.NoArgs,
+		Args:  args.SingleArg(keyIdArg, utils.ValidateUUID),
 		Example: examples.Build(
 			examples.NewExample(
 				`Delete a KMS key "my-key-id" inside the key ring "my-key-ring-id"`,
-				`$ stackit beta kms keyring delete --key-ring "my-key-ring-id" --key "my-key-id"`),
+				`$ stackit beta kms keyring delete "my-key-id" --key-ring "my-key-ring-id"`),
 		),
-		RunE: func(cmd *cobra.Command, _ []string) error {
+		RunE: func(cmd *cobra.Command, args []string) error {
 			ctx := context.Background()
-			model, err := parseInput(params.Printer, cmd)
+			model, err := parseInput(params.Printer, cmd, args)
 			if err != nil {
 				return err
 			}
@@ -79,20 +80,22 @@ func NewCmd(params *params.CmdParams) *cobra.Command {
 
 			// Don't wait for a month until the deletion was performed.
 			// Just print the deletion date.
-			deletionDate, err := kmsUtils.GetKeyDeletionDate(ctx, apiClient, model.ProjectId, model.Region, model.KeyRingId, model.KeyId)
+			resp, err := apiClient.GetKeyExecute(ctx, model.ProjectId, model.Region, model.KeyRingId, model.KeyId)
 			if err != nil {
-				return err
+				params.Printer.Debug(print.ErrorLevel, "get key: %v", err)
 			}
 
-			return outputResult(params.Printer, model.OutputFormat, model.KeyId, keyName, deletionDate)
+			return outputResult(params.Printer, model.OutputFormat, resp)
 		},
 	}
 
 	configureFlags(cmd)
 	return cmd
 }
 
-func parseInput(p *print.Printer, cmd *cobra.Command) (*inputModel, error) {
+func parseInput(p *print.Printer, cmd *cobra.Command, inputArgs []string) (*inputModel, error) {
+	keyId := inputArgs[0]
+
 	globalFlags := globalflags.Parse(p, cmd)
 	if globalFlags.ProjectId == "" {
 		return nil, &errors.ProjectIdError{}
@@ -101,7 +104,7 @@ func parseInput(p *print.Printer, cmd *cobra.Command) (*inputModel, error) {
 	model := inputModel{
 		GlobalFlagModel: globalFlags,
 		KeyRingId:       flags.FlagToStringValue(p, cmd, keyRingIdFlag),
-		KeyId:           flags.FlagToStringValue(p, cmd, keyIdFlag),
+		KeyId:           keyId,
 	}
 
 	if p.IsVerbosityDebug() {
@@ -123,53 +126,31 @@ func buildRequest(ctx context.Context, model *inputModel, apiClient *kms.APIClie
 
 func configureFlags(cmd *cobra.Command) {
 	cmd.Flags().Var(flags.UUIDFlag(), keyRingIdFlag, "ID of the KMS Key Ring where the Key is stored")
-	cmd.Flags().Var(flags.UUIDFlag(), keyIdFlag, "ID of the actual Key")
-	err := flags.MarkFlagsRequired(cmd, keyRingIdFlag, keyIdFlag)
+	err := flags.MarkFlagsRequired(cmd, keyRingIdFlag)
 	cobra.CheckErr(err)
 }
 
-func outputResult(p *print.Printer, outputFormat, keyId, keyName string, deletionDate time.Time) error {
+func outputResult(p *print.Printer, outputFormat string, resp *kms.Key) error {
+	if resp == nil {
+		return fmt.Errorf("response from 'GetKeyExecute()' is nil")
+	}
+
 	switch outputFormat {
 	case print.JSONOutputFormat:
-		details := struct {
-			KeyId        string    `json:"keyId"`
-			KeyName      string    `json:"keyName"`
-			Status       string    `json:"status"`
-			DeletionDate time.Time `json:"deletionDate"`
-		}{
-			KeyId:        keyId,
-			KeyName:      keyName,
-			Status:       "Deletion Scheduled",
-			DeletionDate: deletionDate,
-		}
-		b, err := json.MarshalIndent(details, "", "  ")
+		details, err := json.MarshalIndent(resp, "", "  ")
 		if err != nil {
 			return fmt.Errorf("marshal output to JSON: %w", err)
 		}
-		p.Outputln(string(b))
-		return nil
-
+		p.Outputln(string(details))
 	case print.YAMLOutputFormat:
-		details := struct {
-			KeyId        string    `yaml:"keyId"`
-			KeyName      string    `yaml:"keyName"`
-			Status       string    `yaml:"status"`
-			DeletionDate time.Time `yaml:"deletionDate"`
-		}{
-			KeyId:        keyId,
-			KeyName:      keyName,
-			Status:       "Deletion Scheduled",
-			DeletionDate: deletionDate,
-		}
-		b, err := yaml.Marshal(details)
+		details, err := yaml.MarshalWithOptions(resp, yaml.IndentSequence(true), yaml.UseJSONMarshaler())
 		if err != nil {
 			return fmt.Errorf("marshal output to YAML: %w", err)
 		}
-		p.Outputln(string(b))
-		return nil
+		p.Outputln(string(details))
 
 	default:
-		p.Outputf("Deletion of KMS key %q scheduled successfully for the deletion date: %q\n", keyName, deletionDate)
-		return nil
+		p.Outputf("Deletion of KMS key %s scheduled successfully for the deletion date: %s\n", utils.PtrString(resp.DisplayName), utils.PtrString(resp.DeletionDate))
 	}
+	return nil
 }