feat: added prompts for default values if not defined

Signed-off-by: Jason Salaber <jcsalaber@hotmail.com>

Author: jsalaber

cmd/generate.go

@@ -4,10 +4,10 @@ import (
 	"strings"
 
 	"github.com/open-feature/cli/internal/config"
-	"github.com/open-feature/cli/internal/flagset"
 	"github.com/open-feature/cli/internal/generators"
 	"github.com/open-feature/cli/internal/generators/golang"
 	"github.com/open-feature/cli/internal/generators/react"
+	"github.com/open-feature/cli/internal/manifest"
 	"github.com/spf13/cobra"
 )
 
@@ -53,7 +53,7 @@ func GetGenerateReactCmd() *cobra.Command {
 				OutputPath: outputPath,
 				Custom: react.Params{},
 			}
-			flagset, err := flagset.Load(manifestPath)
+			flagset, err := manifest.LoadFlagSet(manifestPath)
 			if err != nil {
 				return err
 			}
@@ -95,7 +95,7 @@ func GetGenerateGoCmd() *cobra.Command {
 				},
 			}
 
-			flagset, err := flagset.Load(manifestPath)
+			flagset, err := manifest.LoadFlagSet(manifestPath)
 			if err != nil {
 				return err
 			}

cmd/init.go

@@ -21,7 +21,7 @@ func GetInitCmd() *cobra.Command {
 		RunE: func(cmd *cobra.Command, args []string) error {
 			manifestPath := config.GetManifestPath(cmd)
 			override := config.GetOverride(cmd)
-			flagSourceUrl, _ := cmd.Flags().GetString("flagSourceUrl")
+			flagSourceUrl := config.GetFlagSourceUrl(cmd)
 
 			manifestExists, _ := filesystem.Exists(manifestPath)
 			if (manifestExists && !override) {
@@ -63,12 +63,7 @@ func GetInitCmd() *cobra.Command {
 		},
 	}
 
-<<<<<<< HEAD
 	config.AddInitFlags(initCmd)
-=======
-	initCmd.Flags().Bool("override", false, "Override an existing configuration")
-	initCmd.Flags().String("flagSourceUrl", "", "The URL of the flag source")
->>>>>>> ae4ce45 (feat: added functionality to create yaml config file and preliminary pull command)
 
 	return initCmd
 }

cmd/pull.go

@@ -1,12 +1,61 @@
 package cmd
 
 import (
+	"errors"
 	"fmt"
+	"strconv"
 
+	"github.com/open-feature/cli/internal/config"
 	"github.com/open-feature/cli/internal/filesystem"
+	"github.com/open-feature/cli/internal/flagset"
+	"github.com/open-feature/cli/internal/manifest"
+	"github.com/open-feature/cli/internal/requests"
+	"github.com/pterm/pterm"
 	"github.com/spf13/cobra"
 )
 
+func promptForDefaultValue(flag *flagset.Flag) (any) {
+	var prompt string
+	switch flag.Type {
+	case flagset.BoolType:
+		var options []string = []string{"false", "true"}
+		prompt = fmt.Sprintf("Enter default value for flag '%s' (%s)", flag.Key, flag.Type)
+		boolStr, _ := pterm.DefaultInteractiveSelect.WithOptions(options).WithFilter(false).Show(prompt)
+		boolValue, _ := strconv.ParseBool(boolStr)
+		return boolValue
+	case flagset.IntType:
+		var err error = errors.New("Input a valid integer")
+		prompt = fmt.Sprintf("Enter default value for flag '%s' (%s)", flag.Key, flag.Type)
+		var defaultValue int
+		for err != nil {
+			defaultValueString, _ := pterm.DefaultInteractiveTextInput.WithDefaultText("0").Show(prompt)
+			defaultValue, err = strconv.Atoi(defaultValueString)
+		}
+		return defaultValue
+	case flagset.FloatType:
+		var err error = errors.New("Input a valid float")
+		prompt = fmt.Sprintf("Enter default value for flag '%s' (%s)", flag.Key, flag.Type)
+		var defaultValue float64
+		for err != nil {
+			defaultValueString, _ := pterm.DefaultInteractiveTextInput.WithDefaultText("0.0").Show(prompt)
+			defaultValue, err = strconv.ParseFloat(defaultValueString, 64)
+			if err != nil {
+				pterm.Error.Println("Input a valid float")
+			}
+		}
+		return defaultValue
+	case flagset.StringType:
+		prompt = fmt.Sprintf("Enter default value for flag '%s' (%s)", flag.Key, flag.Type)
+		defaultValue, _ := pterm.DefaultInteractiveTextInput.WithDefaultText("").Show(prompt)
+		return defaultValue
+	// TODO: Add proper support for object type
+	case flagset.ObjectType:
+		return map[string]any{}
+	default:
+		return nil
+	}
+}
+
 func GetPullCmd() *cobra.Command {
 	pullCmd := &cobra.Command{
 		Use:   "pull",
@@ -16,33 +65,43 @@ func GetPullCmd() *cobra.Command {
 			return initializeConfig(cmd, "pull")
 		},
 		RunE: func(cmd *cobra.Command, args []string) error {
-			flagSourceUrl, err := cmd.Flags().GetString("flagSourceUrl")
-			if err != nil {
+			flagSourceUrl := config.GetFlagSourceUrl(cmd)
+			manifestPath := config.GetManifestPath(cmd)
+			authToken := config.GetAuthToken(cmd)
+
+			var err error
+			if flagSourceUrl == "" {
 				flagSourceUrl, err = filesystem.GetFromYaml("flagSourceUrl")
 				if err != nil {
 					return fmt.Errorf("error getting flagSourceUrl from config: %w", err)
 				}
 			}
 
-			fmt.Println(flagSourceUrl)
+			// fetch the flags from the remote source
+			flags, err := requests.FetchFlags(flagSourceUrl, authToken)
+			if err != nil {
+				return fmt.Errorf("error fetching flags: %w", err)
+			}
 
-			// // fetch the flags from the remote source
-			// resp, err := http.Get(flagSourceUrl)
-			// if err != nil {
-			// 	return fmt.Errorf("error fetching flags: %w", err)
-			// }
-			// defer resp.Body.Close()
+			// Check each flag for null defaultValue
+			for index, flag := range flags.Flags {
+				if flag.DefaultValue == nil {
+					defaultValue := promptForDefaultValue(&flag)
+					flags.Flags[index].DefaultValue = defaultValue
+				}
+			}
 
-			// flags, err := io.ReadAll(resp.Body)
-			// if err != nil {
-			// 	return fmt.Errorf("error reading response body: %w", err)
-			// }
+			pterm.Success.Printf("Successfully fetched flags from %s", flagSourceUrl)
+			err = manifest.Write(manifestPath, flags)
+			if err != nil {
+				return fmt.Errorf("error writing manifest: %w", err)
+			}
 
 			return nil
 		},
 	}
 
-	pullCmd.Flags().String("flagSourceUrl", "", "The URL of the flag source")
+	config.AddPullFlags(pullCmd)
 
 	return pullCmd
 }

cmd/root.go

@@ -64,7 +64,7 @@ func GetRootCmd() *cobra.Command {
 
 	// Add a custom error handler after the command is created
 	rootCmd.SetFlagErrorFunc(func(cmd *cobra.Command, err error) error {
-		pterm.Error.Println("Invalid flag: %s", err)
+		pterm.Error.Printf("Invalid flag: %s\n", err)
 		pterm.Println("Run 'openfeature --help' for usage information")
 		return err
 	})

go.sum

@@ -176,8 +176,6 @@ gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15 h1:YR8cESwS4TdDjEe65xsg0ogR
 gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v2 v2.2.4/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY=
-gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ=
 gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=

internal/config/flags.go

@@ -11,6 +11,8 @@ const (
 	NoInputFlagName   = "no-input"
 	GoPackageFlagName = "package-name"
 	OverrideFlagName  = "override"
+	FlagSourceUrlFlagName = "flag-source-url"
+	AuthTokenFlagName = "auth-token"
 )
 
 // Default values for flags
@@ -39,6 +41,13 @@ func AddGoGenerateFlags(cmd *cobra.Command) {
 // AddInitFlags adds the init command specific flags
 func AddInitFlags(cmd *cobra.Command) {
 	cmd.Flags().Bool(OverrideFlagName, false, "Override an existing configuration")
+	cmd.Flags().String(FlagSourceUrlFlagName, "", "The URL of the flag source")
+}
+
+// AddPullFlags adds the pull command specific flags
+func AddPullFlags(cmd *cobra.Command) {
+	cmd.Flags().String(FlagSourceUrlFlagName, "", "The URL of the flag source")
+	cmd.Flags().String(AuthTokenFlagName, "", "The auth token for the flag source")
 }
 
 // GetManifestPath gets the manifest path from the given command
@@ -70,3 +79,15 @@ func GetOverride(cmd *cobra.Command) bool {
 	override, _ := cmd.Flags().GetBool(OverrideFlagName)
 	return override
 }
+
+// GetFlagSourceUrl gets the flag source URL from the given command
+func GetFlagSourceUrl(cmd *cobra.Command) string {
+	flagSourceUrl, _ := cmd.Flags().GetString(FlagSourceUrlFlagName)
+	return flagSourceUrl
+}
+
+// GetAuthToken gets the auth token from the given command
+func GetAuthToken(cmd *cobra.Command) string {
+	authToken, _ := cmd.Flags().GetString(AuthTokenFlagName)
+	return authToken
+}

internal/flagset/flagset.go

@@ -5,10 +5,6 @@ import (
 	"errors"
 	"fmt"
 	"sort"
-
-	"github.com/open-feature/cli/internal/filesystem"
-	"github.com/open-feature/cli/internal/manifest"
-	"github.com/spf13/afero"
 )
 
 // FlagType are the primitive types of flags.
@@ -31,7 +27,7 @@ func (f FlagType) String() string {
 	case FloatType:
 			return "float"
 	case BoolType:
-			return "bool"
+			return "boolean"
 	case StringType:
 			return "string"
 	case ObjectType:
@@ -52,29 +48,6 @@ type Flagset struct {
 	Flags []Flag
 }
 
-// Loads, validates, and unmarshals the manifest file at the given path into a flagset
-func Load(manifestPath string) (*Flagset, error) {
-	fs := filesystem.FileSystem()
-	data, err := afero.ReadFile(fs, manifestPath)
-	if err != nil {
-		return nil, fmt.Errorf("error reading contents from file %q", manifestPath)
-	}
-
-	validationErrors, err := manifest.Validate(data)
-	if err != nil {
-		return nil, err
-	} else if len(validationErrors) > 0 {
-		return nil, fmt.Errorf("validation failed: %v", validationErrors)
-	}
-
-	var flagset Flagset
-	if err := json.Unmarshal(data, &flagset); err != nil {
-		return nil, fmt.Errorf("error unmarshaling JSON: %v", validationErrors)
-	}
-
-	return &flagset, nil
-}
-
 // Filter removes flags from the Flagset that are of unsupported types.
 func (fs *Flagset) Filter(unsupportedFlagTypes map[FlagType]bool) *Flagset {
 	var filtered Flagset
@@ -131,4 +104,46 @@ func (fs *Flagset) UnmarshalJSON(data []byte) error {
 	})
 
 	return nil
-}
+}
+
+func LoadFromSourceFlags(data []byte) (*[]Flag, error) {
+	type SourceFlag struct {
+		Key string `json:"key"`
+		Type string `json:"type"`
+		Description string `json:"description"`
+		DefaultValue any `json:"defaultValue"`
+	}
+
+	var sourceFlags []SourceFlag
+	if err := json.Unmarshal(data, &sourceFlags); err != nil {
+		return nil, err
+	}
+
+	var flags []Flag
+	for _, sf := range sourceFlags {
+		var flagType FlagType
+		switch sf.Type {
+		case "integer", "Integer":
+			flagType = IntType
+		case "float", "Float", "Number":
+			flagType = FloatType
+		case "boolean", "bool", "Boolean":
+			flagType = BoolType
+		case "string", "String":
+			flagType = StringType
+		case "object", "Object", "JSON":
+			flagType = ObjectType
+		default:
+			return nil, fmt.Errorf("unknown flag type: %s", sf.Type)
+		}
+
+		flags = append(flags, Flag{
+			Key:          sf.Key,
+			Type:         flagType,
+			Description:  sf.Description,
+			DefaultValue: sf.DefaultValue,
+		})
+	}
+
+	return &flags, nil
+}

internal/generators/react/react.tmpl

@@ -3,6 +3,7 @@
 import {
   type ReactFlagEvaluationOptions,
   type ReactFlagEvaluationNoSuspenseOptions,
+  type FlagQuery,
   useFlag,
   useSuspenseFlag,
 } from "@openfeature/react-sdk";
@@ -15,7 +16,7 @@ import {
 * - default value: `{{ .DefaultValue }}`
 * - type: `{{ .Type | OpenFeatureType }}`
 */
-export const use{{ .Key | ToPascal }} = (options?: ReactFlagEvaluationOptions) => {
+export const use{{ .Key | ToPascal }} = (options?: ReactFlagEvaluationOptions): FlagQuery<{{ .Type | OpenFeatureType }}> => {
   return useFlag({{ .Key | Quote }}, {{ .DefaultValue | QuoteString }}, options);
 };
 
@@ -30,7 +31,7 @@ export const use{{ .Key | ToPascal }} = (options?: ReactFlagEvaluationOptions) =
 * Equivalent to useFlag with options: `{ suspend: true }`
 * @experimental — Suspense is an experimental feature subject to change in future versions.
 */
-export const useSuspense{{ .Key | ToPascal }} = (options?: ReactFlagEvaluationNoSuspenseOptions) => {
+export const useSuspense{{ .Key | ToPascal }} = (options?: ReactFlagEvaluationNoSuspenseOptions): FlagQuery<{{ .Type | OpenFeatureType }}> => {
   return useSuspenseFlag({{ .Key | Quote }}, {{ .DefaultValue | QuoteString }}, options);
 };
 {{ end}}