improve init UX (#2424)

Author: pPrecel

internal/cmd/alpha/function/init.go

@@ -6,15 +6,21 @@ import (
 	"os"
 	"path"
 	"path/filepath"
+	"sort"
 	"strings"
 
 	"github.com/kyma-project/cli.v3/internal/clierror"
 	"github.com/kyma-project/cli.v3/internal/cmdcommon"
-	"github.com/kyma-project/cli.v3/internal/cmdcommon/flags"
+	"github.com/pkg/errors"
 	"github.com/spf13/cobra"
 	"gopkg.in/yaml.v3"
 )
 
+type extensionConfig struct {
+	DefaultRuntime string                   `yaml:"defaultRuntime"`
+	Runtimes       map[string]runtimeConfig `yaml:"runtimes"`
+}
+
 type runtimeConfig struct {
 	DepsFilename    string `yaml:"depsFilename"`
 	DepsData        string `yaml:"depsData"`
@@ -25,77 +31,78 @@ type runtimeConfig struct {
 type initConfig struct {
 	*cmdcommon.KymaConfig
 
-	runtimesConfig map[string]runtimeConfig
+	extensionConfig *extensionConfig
 
 	runtime string
 	dir     string
 }
 
-func NewInitCmd(kymaConfig *cmdcommon.KymaConfig, cmdConfig interface{}) *cobra.Command {
+func NewInitCmd(kymaConfig *cmdcommon.KymaConfig, cmdConfig interface{}) (*cobra.Command, error) {
+	extensionConfig, err := parseExtensionConfig(cmdConfig)
+	if err != nil {
+		return nil, err
+	}
+
 	cfg := &initConfig{
-		KymaConfig: kymaConfig,
+		KymaConfig:      kymaConfig,
+		extensionConfig: extensionConfig,
 	}
 
 	cmd := &cobra.Command{
 		Use:   "init",
 		Short: "Init source and dependencies files locally",
 		Long:  "Use this command to initialize source and dependencies files for a Function.",
 		PreRun: func(cmd *cobra.Command, _ []string) {
-			clierror.Check(flags.Validate(cmd.Flags(), flags.MarkRequired("runtime")))
-			clierror.Check(cfg.complete(cmdConfig))
 			clierror.Check(cfg.validate())
 		},
 		Run: func(cmd *cobra.Command, _ []string) {
 			clierror.Check(runInit(cfg, cmd.OutOrStdout()))
 		},
 	}
 
-	cmd.Flags().StringVar(&cfg.runtime, "runtime", "", "Runtime for which the files are generated")
+	cmd.Flags().StringVar(&cfg.runtime, "runtime", cfg.extensionConfig.DefaultRuntime, fmt.Sprintf("Runtime for which the files are generated [ %s ]", sortedRuntimesString(cfg.extensionConfig.Runtimes)))
 	cmd.Flags().StringVar(&cfg.dir, "dir", ".", "Path to the directory where files must be created")
 
-	return cmd
+	return cmd, nil
 }
 
-func (c *initConfig) complete(cmdConfig interface{}) clierror.Error {
+func parseExtensionConfig(cmdConfig interface{}) (*extensionConfig, error) {
 	if cmdConfig == nil {
-		return clierror.New("unexpected extension error, empty config")
+		return nil, errors.New("unexpected extension error, empty config object")
 	}
 
 	configBytes, err := yaml.Marshal(cmdConfig)
 	if err != nil {
-		return clierror.Wrap(err, clierror.New("failed to marshal config"))
+		return nil, errors.Wrap(err, "failed to marshal config")
 	}
 
-	err = yaml.Unmarshal(configBytes, &c.runtimesConfig)
+	extCfg := extensionConfig{}
+	err = yaml.Unmarshal(configBytes, &extCfg)
 	if err != nil {
-		return clierror.Wrap(err, clierror.New("failed to unmarshal config"))
+		return nil, errors.Wrap(err, "failed to unmarshal config")
 	}
 
-	return nil
+	if extCfg.DefaultRuntime == "" || len(extCfg.Runtimes) == 0 {
+		// simple validation
+		return nil, errors.New("unexpected extension error, empty config data")
+	}
+
+	return &extCfg, nil
 }
 
 func (c *initConfig) validate() clierror.Error {
-	if _, ok := c.runtimesConfig[c.runtime]; !ok {
+	if _, ok := c.extensionConfig.Runtimes[c.runtime]; !ok {
 		return clierror.New(
 			fmt.Sprintf("unsupported runtime %s", c.runtime),
-			fmt.Sprintf("use on the allowed runtimes on this cluster [ %s ]", strings.Join(mapKeys(c.runtimesConfig), " / ")),
+			fmt.Sprintf("use on the allowed runtimes on this cluster [ %s ]", sortedRuntimesString(c.extensionConfig.Runtimes)),
 		)
 	}
 
 	return nil
 }
 
-func mapKeys(m map[string]runtimeConfig) []string {
-	keys := []string{}
-	for key := range m {
-		keys = append(keys, key)
-	}
-
-	return keys
-}
-
 func runInit(cfg *initConfig, out io.Writer) clierror.Error {
-	runtimeCfg := cfg.runtimesConfig[cfg.runtime]
+	runtimeCfg := cfg.extensionConfig.Runtimes[cfg.runtime]
 
 	handlerPath := path.Join(cfg.dir, runtimeCfg.HandlerFilename)
 	err := os.WriteFile(handlerPath, []byte(runtimeCfg.HandlerData), os.ModePerm)
@@ -115,8 +122,20 @@ func runInit(cfg *initConfig, out io.Writer) clierror.Error {
 		outDir = cfg.dir
 	}
 
-	fmt.Fprintf(out, "Functions files initialized to dir %s\n", outDir)
-	fmt.Fprint(out, "\nExample usage:\n")
-	fmt.Fprintf(out, "kyma alpha function create %s --runtime %s --source %s --dependencies %s\n", cfg.runtime, cfg.runtime, handlerPath, depsPath)
+	fmt.Fprintf(out, "Functions files of runtime %s initialized to dir %s\n", cfg.runtime, outDir)
+	fmt.Fprint(out, "\nNext steps:\n")
+	fmt.Fprint(out, "* update output files in your favorite IDE\n")
+	fmt.Fprintf(out, "* create Function, for example:\n")
+	fmt.Fprintf(out, "  kyma alpha function create %s --runtime %s --source %s --dependencies %s\n", cfg.runtime, cfg.runtime, handlerPath, depsPath)
 	return nil
 }
+
+func sortedRuntimesString(m map[string]runtimeConfig) string {
+	keys := []string{}
+	for key := range m {
+		keys = append(keys, key)
+	}
+
+	sort.Strings(sort.StringSlice(keys))
+	return strings.Join(keys, ", ")
+}

internal/cmd/alpha/registry/config/config.go

@@ -17,7 +17,7 @@ type cfgConfig struct {
 	output      string
 }
 
-func NewConfigCMD(kymaConfig *cmdcommon.KymaConfig, _ interface{}) *cobra.Command {
+func NewConfigCMD(kymaConfig *cmdcommon.KymaConfig, _ interface{}) (*cobra.Command, error) {
 	cfg := cfgConfig{
 		KymaConfig: kymaConfig,
 	}
@@ -34,7 +34,7 @@ func NewConfigCMD(kymaConfig *cmdcommon.KymaConfig, _ interface{}) *cobra.Comman
 	cmd.Flags().BoolVar(&cfg.externalurl, "externalurl", false, "External URL for the Kyma registry")
 	cmd.Flags().StringVar(&cfg.output, "output", "", "Path where the output file should be saved to. NOTE: docker expects the file to be named `config.json`")
 
-	return cmd
+	return cmd, nil
 }
 
 func runConfig(cfg *cfgConfig) clierror.Error {

internal/cmd/alpha/registry/imageimport/imageimport.go

@@ -16,7 +16,7 @@ type provisionConfig struct {
 	image string
 }
 
-func NewImportCMD(kymaConfig *cmdcommon.KymaConfig, _ interface{}) *cobra.Command {
+func NewImportCMD(kymaConfig *cmdcommon.KymaConfig, _ interface{}) (*cobra.Command, error) {
 	config := provisionConfig{
 		KymaConfig: kymaConfig,
 	}
@@ -36,7 +36,7 @@ func NewImportCMD(kymaConfig *cmdcommon.KymaConfig, _ interface{}) *cobra.Comman
 		},
 	}
 
-	return cmd
+	return cmd, nil
 }
 
 func (pc *provisionConfig) validate() clierror.Error {

internal/cmdcommon/extension.go

@@ -77,7 +77,17 @@ func (kec *KymaExtensionsConfig) BuildExtensions(availableTemplateCommands *Temp
 			continue
 		}
 
-		cmds = append(cmds, buildCommandFromExtension(kec.kymaConfig, extension, availableTemplateCommands, availableCoreCommands))
+		extensionCommands, err := buildCommandFromExtension(kec.kymaConfig, extension, availableTemplateCommands, availableCoreCommands)
+		if err != nil {
+			kec.parseErrors = errors.Join(
+				kec.parseErrors,
+				fmt.Errorf("failed to build extensions from configmap '%s/%s': %s",
+					cm.GetNamespace(), cm.GetName(), err.Error()),
+			)
+			continue
+		}
+
+		cmds = append(cmds, extensionCommands)
 	}
 
 	return cmds
@@ -203,7 +213,7 @@ func parseOptionalField[T any](cmData map[string]string, cmKey string) (T, error
 	return data, err
 }
 
-func buildCommandFromExtension(config *KymaConfig, extension *Extension, availableTemplateCommands *TemplateCommandsList, availableCoreCommands CoreCommandsMap) *cobra.Command {
+func buildCommandFromExtension(config *KymaConfig, extension *Extension, availableTemplateCommands *TemplateCommandsList, availableCoreCommands CoreCommandsMap) (*cobra.Command, error) {
 	cmd := &cobra.Command{
 		Use:   fmt.Sprintf("%s <command> [flags]", extension.RootCommand.Name),
 		Short: extension.RootCommand.Description,
@@ -214,9 +224,8 @@ func buildCommandFromExtension(config *KymaConfig, extension *Extension, availab
 		addGenericCommands(cmd, config, extension, availableTemplateCommands)
 	}
 
-	addCoreCommands(cmd, config, extension.CoreCommands, availableCoreCommands)
-
-	return cmd
+	err := addCoreCommands(cmd, config, extension.CoreCommands, availableCoreCommands)
+	return cmd, err
 }
 
 func addGenericCommands(cmd *cobra.Command, config *KymaConfig, extension *Extension, availableTemplateCommands *TemplateCommandsList) {
@@ -257,16 +266,26 @@ func addGenericCommands(cmd *cobra.Command, config *KymaConfig, extension *Exten
 	}
 }
 
-func addCoreCommands(cmd *cobra.Command, config *KymaConfig, extensionCoreCommands []CoreCommandInfo, availableCoreCommands CoreCommandsMap) {
+func addCoreCommands(cmd *cobra.Command, config *KymaConfig, extensionCoreCommands []CoreCommandInfo, availableCoreCommands CoreCommandsMap) error {
+	var cmdErr error
 	for _, expectedCoreCommand := range extensionCoreCommands {
 		command, ok := availableCoreCommands[expectedCoreCommand.ActionID]
 		if !ok {
 			// commands doesn't exist in this version of cli and we will not process it
 			continue
 		}
 
-		cmd.AddCommand(command(config, expectedCoreCommand.Config))
+		coreCmd, err := command(config, expectedCoreCommand.Config)
+		if err != nil {
+			// add error and continue to check next commands
+			cmdErr = errors.Join(cmdErr, err)
+			continue
+		}
+
+		cmd.AddCommand(coreCmd)
 	}
+
+	return cmdErr
 }
 
 // search os.Args manually to find if user pass given flag and return its value

internal/cmdcommon/extension_types.go

@@ -17,7 +17,7 @@ const (
 )
 
 // map of allowed core commands in format ID: FUNC
-type CoreCommandsMap map[string]func(*KymaConfig, interface{}) *cobra.Command
+type CoreCommandsMap map[string]func(*KymaConfig, interface{}) (*cobra.Command, error)
 
 // allowed template commands
 type TemplateCommandsList struct {