Workflow Template Enhancements

cmd/create.go

@@ -292,7 +292,7 @@ func (cc *createCmd) generateDockerfile(langConfig *config.DraftConfig, lowerLan
 			return err
 		}
 	} else {
-		inputs, err = validateConfigInputsToPrompts(langConfig.Variables, cc.createConfig.LanguageVariables)
+		inputs, err = validateConfigInputsToPrompts(langConfig, cc.createConfig.LanguageVariables)
 		if err != nil {
 			return err
 		}
@@ -330,7 +330,7 @@ func (cc *createCmd) createDeployment() error {
 		if deployConfig == nil {
 			return errors.New("invalid deployment type")
 		}
-		customInputs, err = validateConfigInputsToPrompts(deployConfig.Variables, cc.createConfig.DeployVariables)
+		customInputs, err = validateConfigInputsToPrompts(deployConfig, cc.createConfig.DeployVariables)
 		if err != nil {
 			return err
 		}
@@ -464,31 +464,19 @@ func init() {
 	rootCmd.AddCommand(newCreateCmd())
 }
 
-func validateConfigInputsToPrompts(required []config.BuilderVar, provided []UserInputs) (map[string]string, error) {
+func validateConfigInputsToPrompts(draftConfig *config.DraftConfig, provided []UserInputs) (map[string]string, error) {
 	customInputs := make(map[string]string)
 
 	// set inputs to provided values
 	for _, variable := range provided {
 		customInputs[variable.Name] = variable.Value
 	}
 
-	// fill in missing vars using variable default references
-	for _, variable := range required {
-		if customInputs[variable.Name] == "" && variable.Default.ReferenceVar != "" {
-			log.Debugf("variable %s is empty, using default referenceVar value from %s", variable.Name, variable.Default.ReferenceVar)
-			customInputs[variable.Name] = customInputs[variable.Default.ReferenceVar]
-		}
-	}
-
-	// fill in missing vars using variable default values
-	for _, variable := range required {
-		if customInputs[variable.Name] == "" && variable.Default.Value != "" {
-			log.Debugf("variable %s is empty, using default value %s", variable.Name, variable.Default.Value)
-			customInputs[variable.Name] = variable.Default.Value
-		}
+	if err := draftConfig.ApplyDefaultVariables(customInputs); err != nil {
+		return nil, fmt.Errorf("validate config inputs to prompts: %w", err)
 	}
 
-	for _, variable := range required {
+	for _, variable := range draftConfig.Variables {
 		value, ok := customInputs[variable.Name]
 		if !ok {
 			return nil, fmt.Errorf("config missing required variable: %s with description: %s", variable.Name, variable.Description)

cmd/create_test.go

@@ -142,40 +142,44 @@ func TestInitConfig(t *testing.T) {
 }
 
 func TestValidateConfigInputsToPromptsPass(t *testing.T) {
-	required := []config.BuilderVar{
-		{
-			Name: "REQUIRED_PROVIDED",
-		},
-		{
-			Name: "REQUIRED_DEFAULTED",
-			Default: config.BuilderVarDefault{
-				Value: "DEFAULT_VALUE",
+	required := config.DraftConfig{
+		Variables: []config.BuilderVar{
+			{
+				Name: "REQUIRED_PROVIDED",
+			},
+			{
+				Name: "REQUIRED_DEFAULTED",
+				Default: config.BuilderVarDefault{
+					Value: "DEFAULT_VALUE",
+				},
 			},
 		},
 	}
 	provided := []UserInputs{
 		{Name: "REQUIRED_PROVIDED", Value: "PROVIDED_VALUE"},
 	}
 
-	vars, err := validateConfigInputsToPrompts(required, provided)
+	vars, err := validateConfigInputsToPrompts(&required, provided)
 	assert.True(t, err == nil)
 	assert.Equal(t, vars["REQUIRED_DEFAULTED"], "DEFAULT_VALUE")
 }
 
 func TestValidateConfigInputsToPromptsMissing(t *testing.T) {
-	required := []config.BuilderVar{
-		{
-			Name: "REQUIRED_PROVIDED",
-		},
-		{
-			Name: "REQUIRED_MISSING",
+	required := config.DraftConfig{
+		Variables: []config.BuilderVar{
+			{
+				Name: "REQUIRED_PROVIDED",
+			},
+			{
+				Name: "REQUIRED_MISSING",
+			},
 		},
 	}
 	provided := []UserInputs{
 		{Name: "REQUIRED_PROVIDED"},
 	}
 
-	_, err := validateConfigInputsToPrompts(required, provided)
+	_, err := validateConfigInputsToPrompts(&required, provided)
 	assert.NotNil(t, err)
 }
 

cmd/generate-workflow.go

@@ -52,15 +52,20 @@ with draft on AKS. This command assumes the 'setup-gh' command has been run prop
 	}
 
 	f := cmd.Flags()
-	f.StringVarP(&gwCmd.workflowConfig.AksClusterName, "cluster-name", "c", emptyDefaultFlagValue, "specify the AKS cluster name")
-	f.StringVarP(&gwCmd.workflowConfig.AcrName, "registry-name", "r", emptyDefaultFlagValue, "specify the Azure container registry name")
-	f.StringVar(&gwCmd.workflowConfig.ContainerName, "container-name", emptyDefaultFlagValue, "specify the container image name")
-	f.StringVarP(&gwCmd.workflowConfig.ResourceGroupName, "resource-group", "g", emptyDefaultFlagValue, "specify the Azure resource group of your AKS cluster")
 	f.StringVarP(&gwCmd.dest, "destination", "d", currentDirDefaultFlagValue, "specify the path to the project directory")
-	f.StringVarP(&gwCmd.workflowConfig.BranchName, "branch", "b", emptyDefaultFlagValue, "specify the Github branch to automatically deploy from")
 	f.StringVar(&gwCmd.deployType, "deploy-type", emptyDefaultFlagValue, "specify the type of deployment")
-	f.StringArrayVarP(&gwCmd.flagVariables, "variable", "", []string{}, "pass additional variables")
+	f.StringVarP(&gwCmd.workflowConfig.WorkflowName, "workflow", "w", emptyDefaultFlagValue, "specify the Github workflow name")
+	f.StringVarP(&gwCmd.workflowConfig.BranchName, "branch", "b", emptyDefaultFlagValue, "specify the Github branch to automatically deploy from")
+	f.StringVar(&gwCmd.workflowConfig.AcrResourceGroup, "acr-resource-group", emptyDefaultFlagValue, "specify the Azure container registry resource group")
+	f.StringVarP(&gwCmd.workflowConfig.Acr, "registry-name", "r", emptyDefaultFlagValue, "specify the Azure container registry name")
+	f.StringVar(&gwCmd.workflowConfig.ContainerName, "container-name", emptyDefaultFlagValue, "specify the container image name")
+	f.StringVarP(&gwCmd.workflowConfig.ClusterResourceGroup, "cluster-resource-group", "g", emptyDefaultFlagValue, "specify the Azure resource group of your AKS cluster")
+	f.StringVarP(&gwCmd.workflowConfig.ClusterName, "cluster-name", "c", emptyDefaultFlagValue, "specify the AKS cluster name")
+	f.StringVar(&gwCmd.workflowConfig.Dockerfile, "dockerfile", emptyDefaultFlagValue, "specify the path to the Dockerfile")
 	f.StringVarP(&gwCmd.workflowConfig.BuildContextPath, "build-context-path", "x", emptyDefaultFlagValue, "specify the docker build context path")
+	f.StringVarP(&gwCmd.workflowConfig.Namespace, "namespace", "n", emptyDefaultFlagValue, "specify the Kubernetes namespace")
+	f.StringVar(&gwCmd.workflowConfig.PrivateCluster, "private-cluster", emptyDefaultFlagValue, "specify if the AKS cluster is private")
+	f.StringArrayVarP(&gwCmd.flagVariables, "variable", "", []string{}, "pass additional variables")
 	gwCmd.templateWriter = &writers.LocalFSWriter{}
 	return cmd
 }
@@ -109,4 +114,4 @@ func (gwc *generateWorkflowCmd) generateWorkflows(dest string, deployType string
 	maps.Copy(customInputs, flagValuesMap)
 
 	return workflow.CreateWorkflowFiles(deployType, customInputs, templateWriter)
-}
+}

pkg/config/draftconfig.go

@@ -2,6 +2,7 @@ package config
 
 import (
 	"errors"
+	"fmt"
 
 	log "github.com/sirupsen/logrus"
 )
@@ -26,6 +27,7 @@ type BuilderVar struct {
 	Description   string            `yaml:"description"`
 	ExampleValues []string          `yaml:"exampleValues"`
 	Type          string            `yaml:"type"`
+	Value         string            `yaml:"value"`
 }
 
 type BuilderVarDefault struct {
@@ -67,21 +69,49 @@ func (d *DraftConfig) GetNameOverride(path string) string {
 }
 
 // ApplyDefaultVariables will apply the defaults to variables that are not already set
-func (d *DraftConfig) ApplyDefaultVariables(customConfig map[string]string) error {
+func (d *DraftConfig) ApplyDefaultVariables(customInputs map[string]string) error {
+	varIdxMap := VariableIdxMap(d.Variables)
+
 	for _, variable := range d.Variables {
 		// handle where variable is not set or is set to an empty string from cli handling
-		if val, ok := customConfig[variable.Name]; !ok || val == "" {
-			if variable.Default.Value == "" {
-				return errors.New("variable " + variable.Name + " has no default value")
+		if customInputs[variable.Name] == "" {
+			if variable.Default.ReferenceVar != "" {
+				defaultVal, err := recurseReferenceVars(d.Variables, variable, customInputs, varIdxMap, variable, true)
+				if err != nil {
+					return fmt.Errorf("apply default variables: %w", err)
+				}
+				log.Infof("Variable %s defaulting to value %s", variable.Name, customInputs[variable.Name])
+				customInputs[variable.Name] = defaultVal
+			}
+
+			if customInputs[variable.Name] == "" {
+				if variable.Default.Value != "" {
+					log.Infof("Variable %s defaulting to value %s", variable.Name, variable.Default.Value)
+					customInputs[variable.Name] = variable.Default.Value
+				} else {
+					return errors.New("variable " + variable.Name + " has no default value")
+				}
 			}
-			log.Infof("Variable %s defaulting to value %s", variable.Name, variable.Default.Value)
-			customConfig[variable.Name] = variable.Default.Value
 		}
 	}
 
 	return nil
 }
 
+func recurseReferenceVars(variables []BuilderVar, variable BuilderVar, customInputs map[string]string, varIdxMap map[string]int, variableCheck BuilderVar, isFirst bool) (string, error) {
+	if !isFirst && variable.Name == variableCheck.Name {
+		return "", errors.New("circular reference detected")
+	}
+
+	if customInputs[variable.Default.ReferenceVar] != "" {
+		return customInputs[variable.Default.ReferenceVar], nil
+	} else if variable.Default.ReferenceVar != "" {
+		return recurseReferenceVars(variables, variables[varIdxMap[variable.Default.ReferenceVar]], customInputs, varIdxMap, variableCheck, false)
+	}
+
+	return variable.Default.Value, nil
+}
+
 func VariableIdxMap(variables []BuilderVar) map[string]int {
 	varIdxMap := make(map[string]int)
 
@@ -96,3 +126,28 @@ func VariableIdxMap(variables []BuilderVar) map[string]int {
 type TemplateVariableRecorder interface {
 	Record(key, value string)
 }
+
+func (d *DraftConfig) VariableMap() (map[string]string, error) {
+	envArgs := make(map[string]string)
+
+	for _, variable := range d.Variables {
+		envArgs[variable.Name] = variable.Value
+	}
+
+	err := d.ApplyDefaultVariables(envArgs)
+	if err != nil {
+		return nil, fmt.Errorf("creating variable map: %w", err)
+	}
+
+	return envArgs, nil
+}
+
+func (d *DraftConfig) VariableIdxMap() map[string]int {
+	varIdxMap := make(map[string]int)
+
+	for i, variable := range d.Variables {
+		varIdxMap[variable.Name] = i
+	}
+
+	return varIdxMap
+}

pkg/osutil/osutil.go

@@ -107,12 +107,12 @@ func CopyDir(
 				return err
 			}
 		} else {
-			fileContent, err := replaceTemplateVariables(fileSys, srcPath, customInputs)
+			fileContent, err := ReplaceTemplateVariables(fileSys, srcPath, customInputs)
 			if err != nil {
 				return err
 			}
 
-			if err = checkAllVariablesSubstituted(string(fileContent)); err != nil {
+			if err = CheckAllVariablesSubstituted(string(fileContent)); err != nil {
 				return fmt.Errorf("error substituting file %s: %w", srcPath, err)
 			}
 
@@ -131,15 +131,15 @@ If any draft variables are found, an error is returned.
 Draft variables are defined as a string of non-whitespace characters starting with a non-period character wrapped in double curly braces.
 The non-period first character constraint is used to avoid matching helm template functions.
 */
-func checkAllVariablesSubstituted(fileContent string) error {
+func CheckAllVariablesSubstituted(fileContent string) error {
 	if unsubstitutedVars := draftVariableRegex.FindAllString(fileContent, -1); len(unsubstitutedVars) > 0 {
 		unsubstitutedVarsString := strings.Join(unsubstitutedVars, ", ")
 		return fmt.Errorf("unsubstituted variable: %s", unsubstitutedVarsString)
 	}
 	return nil
 }
 
-func replaceTemplateVariables(fileSys fs.FS, srcPath string, customInputs map[string]string) ([]byte, error) {
+func ReplaceTemplateVariables(fileSys fs.FS, srcPath string, customInputs map[string]string) ([]byte, error) {
 	file, err := fs.ReadFile(fileSys, srcPath)
 	if err != nil {
 		return nil, err

pkg/osutil/osutil_test.go

@@ -110,7 +110,7 @@ func TestAllVariablesSubstituted(t *testing.T) {
 
 	for _, test := range tests {
 		t.Run(test.String, func(t *testing.T) {
-			err := checkAllVariablesSubstituted(test.String)
+			err := CheckAllVariablesSubstituted(test.String)
 			didError := err != nil
 			assert.Equal(t, test.ExpectError, didError)
 		})

pkg/prompts/prompts.go

@@ -20,26 +20,26 @@ const defaultAppName = "my-app"
 // Function to get current directory name
 var getCurrentDirNameFunc = getCurrentDirName
 
-func RunPromptsFromConfig(config *config.DraftConfig) (map[string]string, error) {
-	return RunPromptsFromConfigWithSkips(config, []string{})
+func RunPromptsFromConfig(draftConfig *config.DraftConfig) (map[string]string, error) {
+	return RunPromptsFromConfigWithSkips(draftConfig, []string{})
 }
 
-func RunPromptsFromConfigWithSkips(config *config.DraftConfig, varsToSkip []string) (map[string]string, error) {
-	return RunPromptsFromConfigWithSkipsIO(config, varsToSkip, nil, nil)
+func RunPromptsFromConfigWithSkips(draftConfig *config.DraftConfig, varsToSkip []string) (map[string]string, error) {
+	return RunPromptsFromConfigWithSkipsIO(draftConfig, varsToSkip, nil, nil)
 }
 
-// RunPromptsFromConfigWithSkipsIO runs the prompts for the given config
+// RunPromptsFromConfigWithSkipsIO runs the prompts for the given draftConfig
 // skipping any variables in varsToSkip or where the BuilderVar.IsPromptDisabled is true.
 // If Stdin or Stdout are nil, the default values will be used.
-func RunPromptsFromConfigWithSkipsIO(config *config.DraftConfig, varsToSkip []string, Stdin io.ReadCloser, Stdout io.WriteCloser) (map[string]string, error) {
+func RunPromptsFromConfigWithSkipsIO(draftConfig *config.DraftConfig, varsToSkip []string, Stdin io.ReadCloser, Stdout io.WriteCloser) (map[string]string, error) {
 	skipMap := make(map[string]interface{})
 	for _, v := range varsToSkip {
 		skipMap[v] = interface{}(nil)
 	}
 
 	inputs := make(map[string]string)
 
-	for _, variable := range config.Variables {
+	for _, variable := range draftConfig.Variables {
 		if val, ok := skipMap[variable.Name]; ok && val != "" {
 			log.Debugf("Skipping prompt for %s", variable.Name)
 			continue