fix: update command now applies new default values

Author: lanathlor

internal/handlers/compose/update.go

@@ -96,7 +96,22 @@ func UpdateHandler(params UpdateHandlerParams) error {
 		"project", project,
 	)
 
-	// Pull config
+	// Load existing config FIRST, before any template pulls or scripts run
+	// This is critical to capture the OLD template defaults for smart merging
+	confFile, err := models.CreateFile(configPath, "values.yaml")
+	if err != nil {
+		logger.Error(err)
+
+		return err
+	}
+	existingConfig, err := models.LoadConfigFrom(confFile, false)
+	if err != nil {
+		logger.Error(err)
+
+		return err
+	}
+
+	// Pull config AFTER loading existing config to avoid overwriting old template
 	logger.Debug("pulling latest template")
 	if registry != "" {
 		registryInfo := models.RegistryInfo{
@@ -119,7 +134,7 @@ func UpdateHandler(params UpdateHandlerParams) error {
 		}
 	}
 
-	// Execute update script
+	// Execute update script AFTER loading existing config and pulling new template
 	// Validate script paths to prevent arbitrary code execution
 	allowedScriptDirs := []string{app.TemplatesFolder}
 	prerunPath := filepath.Join(destPath, "sbin/pre-run")
@@ -149,20 +164,6 @@ func UpdateHandler(params UpdateHandlerParams) error {
 		return err
 	}
 
-	// Load existing config
-	confFile, err := models.CreateFile(configPath, "values.yaml")
-	if err != nil {
-		logger.Error(err)
-
-		return err
-	}
-	existingConfig, err := models.LoadConfigFrom(confFile, false)
-	if err != nil {
-		logger.Error(err)
-
-		return err
-	}
-
 	// Create new config
 	newConfFile, err := models.CreateFile(templatePath, "config.yaml")
 	if err != nil {
@@ -187,7 +188,10 @@ func UpdateHandler(params UpdateHandlerParams) error {
 	// Extract and set values from args and existing config
 	paramsArgs := utils.ExtractArgs(args)
 	newConfig.SetProject(project)
-	newConfig.GetParams().SetValues(existingConfig.GetParams().GetVariablesValues())
+	// Use SetValuesSmartMerge to intelligently merge old values
+	// Only values that differ from old defaults are preserved (user customizations)
+	// Values that match old defaults are replaced with new defaults
+	newConfig.GetParams().SetValuesSmartMerge(existingConfig.GetParams())
 	newConfig.GetArbitrary().SetArbitrary(paramsArgs)
 	err = newConfig.GetParams().SetLooseValues(paramsArgs)
 	if err != nil {

internal/models/config.utils.go

@@ -256,9 +256,12 @@ func processTemplate(data map[string]interface{}, tpls []string,
 	// Execute the template
 	err = tmpl.Execute(destFile, data)
 	if err != nil {
-		splited := strings.Split(err.Error(), "error calling fail: ")
-		fmt.Println("Failed instanciating template.", splited[1])
-		return err
+		// Try to extract a more readable error message
+		errMsg := err.Error()
+		if parts := strings.Split(errMsg, "error calling fail: "); len(parts) > 1 {
+			errMsg = parts[1]
+		}
+		return fmt.Errorf("failed to instantiate template %s: %s", filepath.Base(path), errMsg)
 	}
 
 	// Set permissions for shell scripts

internal/models/parameters.go

@@ -190,6 +190,41 @@ func (p *Parameters) SetValues(values map[string]*Variable) {
 	}
 }
 
+// SetValuesSmartMerge intelligently merges values from an old configuration
+// It only preserves values that were actually customized by the user
+// A value is considered customized if it differs from the old template's default
+func (p *Parameters) SetValuesSmartMerge(oldParams *Parameters) {
+	for key, newParam := range *p {
+		oldParam, exists := (*oldParams)[key]
+		if !exists {
+			// Parameter doesn't exist in old config, use new default
+			continue
+		}
+
+		if oldParam.Variable.IsNil() {
+			// Old parameter has no value set, use new default
+			continue
+		}
+
+		if oldParam.Default.IsNil() {
+			// No old default to compare against, preserve the old value
+			newParam.Variable = oldParam.Variable
+			continue
+		}
+
+		// Compare old value against old default
+		oldValue := oldParam.Variable.AsString()
+		oldDefault := oldParam.Default.AsString()
+
+		if oldValue != oldDefault {
+			// Value differs from old default - user customized it
+			// Preserve the customization
+			newParam.Variable = oldParam.Variable
+		}
+		// else: value equals old default - let new default apply
+	}
+}
+
 func (p *Parameters) SetLooseValues(values map[string]string) error {
 	for key, value := range values {
 		if (*p)[key] != nil {

internal/models/parameters.map.go

@@ -56,6 +56,42 @@ func (p *Parameters) GetVariablesValues(keys ...string) map[string]*Variable {
 	return values
 }
 
+// Returns only the customized (non-default) variable values
+// A value is considered customized if it differs from its default
+func (p *Parameters) GetCustomizedValues(keys ...string) map[string]*Variable {
+	values := make(map[string]*Variable)
+	for key, param := range *p {
+		// Skip if keys filter is provided and key doesn't match
+		if len(keys) > 0 {
+			matched := false
+			for _, k := range keys {
+				if strings.HasPrefix(key, k) {
+					matched = true
+					break
+				}
+			}
+			if !matched {
+				continue
+			}
+		}
+
+		// Only include if the variable differs from the default
+		// This indicates the user customized this value
+		if !param.Variable.IsNil() && !param.Default.IsNil() {
+			// Compare variable against default to detect customization
+			varStr := param.Variable.AsString()
+			defStr := param.Default.AsString()
+			if varStr != defStr {
+				values[key] = &param.Variable
+			}
+		} else if !param.Variable.IsNil() && param.Default.IsNil() {
+			// If there's a variable but no default, preserve it
+			values[key] = &param.Variable
+		}
+	}
+	return values
+}
+
 // Returns an ordered slices of the parameters keys
 func (p *Parameters) GetOrdered() []string {
 	keys := make([]string, 0, len(*p))

internal/models/parameters_test.go

@@ -447,3 +447,87 @@ func TestGetParameters(t *testing.T) {
 		})
 	}
 }
+
+func TestGetCustomizedValues(t *testing.T) {
+	// Create parameters with both variable and default values
+	// param1: value equals default (not customized)
+	param1 := &Parameter{
+		Type:     "string",
+		Variable: CreateVariableString("default1"),
+		Default:  CreateVariableString("default1"),
+	}
+	// param2: value differs from default (customized)
+	param2 := &Parameter{
+		Type:     "string",
+		Variable: CreateVariableString("custom2"),
+		Default:  CreateVariableString("default2"),
+	}
+	// param3: value differs from default (customized)
+	param3 := &Parameter{
+		Type:     "int",
+		Variable: CreateVariableInt(10),
+		Default:  CreateVariableInt(5),
+	}
+	// param4: value equals default (not customized)
+	param4 := &Parameter{
+		Type:     "bool",
+		Variable: CreateVariableBool(true),
+		Default:  CreateVariableBool(true),
+	}
+	// param5: has variable but no default (should be included)
+	param5 := &Parameter{
+		Type:     "string",
+		Variable: CreateVariableString("value5"),
+	}
+
+	params := &Parameters{
+		"param1":       param1,
+		"param2":       param2,
+		"param3":       param3,
+		"param4":       param4,
+		"param5":       param5,
+		"other.param2": param2,
+	}
+
+	tests := []struct {
+		name string
+		keys []string
+		want map[string]*Variable
+	}{
+		{
+			name: "No keys - returns only customized values",
+			keys: []string{},
+			want: map[string]*Variable{
+				"param2":       &param2.Variable,
+				"param3":       &param3.Variable,
+				"param5":       &param5.Variable,
+				"other.param2": &param2.Variable,
+			},
+		},
+		{
+			name: "Filter by prefix - returns only customized matching prefix",
+			keys: []string{"param"},
+			want: map[string]*Variable{
+				"param2": &param2.Variable,
+				"param3": &param3.Variable,
+				"param5": &param5.Variable,
+			},
+		},
+		{
+			name: "Filter by other prefix",
+			keys: []string{"other"},
+			want: map[string]*Variable{
+				"other.param2": &param2.Variable,
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := params.GetCustomizedValues(tt.keys...)
+			if !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("GetCustomizedValues() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}