feat(managers): add env interpolation (#7)

Author: gorillamoe

README.md

@@ -205,6 +205,45 @@ allowing you to fetch secrets from different cloud providers
 or projects as needed. Kuba currently supports GCP Secret Manager,
 AWS Secrets Manager, Azure Key Vault, and OpenBao.
 
+### Environment Variable Interpolation
+
+Kuba supports environment variable interpolation in the `value` field using `${VAR_NAME}` syntax. This allows you to:
+
+- Reference previously defined environment variables from the same configuration
+- Use system environment variables
+- Build complex connection strings and URLs dynamically
+
+**Example with interpolation:**
+```yaml
+default:
+  provider: gcp
+  project: 1337
+  mappings:
+    - environment-variable: "DB_PASSWORD"
+      secret-key: "db-password"
+    - environment-variable: "DB_HOST"
+      value: "mydbhost"
+    - environment-variable: "DB_CONNECTION_STRING"
+      value: "postgresql://user:${DB_PASSWORD}@${DB_HOST}:5432/mydb"
+    - environment-variable: "API_URL"
+      value: "https://api.${DOMAIN}/v1"
+    - environment-variable: "APP_ENV"
+      value: "${NODE_ENV:-development}"
+    - environment-variable: "REDIS_URL"
+      value: "redis://${REDIS_HOST:-localhost}:${REDIS_PORT:-6379}/0"
+```
+
+In this example:
+- `${DB_PASSWORD}` will be replaced with the value from the secret
+- `${DB_HOST}` will be replaced with the literal value "mydbhost"
+- `${DOMAIN}` will be replaced with the system environment variable if it exists
+- `${NODE_ENV:-development}` will use the `NODE_ENV` environment variable if set, otherwise default to "development"
+- `${REDIS_HOST:-localhost}` will use the `REDIS_HOST` environment variable if set, otherwise default to "localhost"
+
+**Note**: Interpolation is processed in order, so you can reference variables defined earlier in the same configuration. Unresolved variables will remain unchanged in the output.
+
+**Shell-style default values**: You can use `${VAR_NAME:-default}` syntax to provide fallback values when environment variables are not set. This is particularly useful for providing sensible defaults while allowing overrides through environment variables.
+
 ### Running with a specific environment
 
 You can also specify the environment you want to use:

internal/config/kuba_config.go

@@ -4,6 +4,8 @@ import (
 	"fmt"
 	"os"
 	"path/filepath"
+	"regexp"
+	"strings"
 
 	"gopkg.in/yaml.v3"
 )
@@ -30,6 +32,123 @@ type Mapping struct {
 	Project             string      `yaml:"project,omitempty"`
 }
 
+// interpolateEnvVars replaces ${VAR_NAME} patterns with actual environment variable values
+// It also supports previously resolved variables from the same configuration
+// Supports both ${VAR_NAME} and ${VAR_NAME:-default} syntax
+func interpolateEnvVars(value string, resolvedVars map[string]string) string {
+	// Regex to match ${VAR_NAME} and ${VAR_NAME:-default} patterns
+	re := regexp.MustCompile(`\$\{([^}]+)\}`)
+
+	return re.ReplaceAllStringFunc(value, func(match string) string {
+		// Extract the variable name and optional default from ${VAR_NAME} or ${VAR_NAME:-default}
+		content := match[2 : len(match)-1]
+
+		// Check if there's a default value specified
+		if strings.Contains(content, ":-") {
+			parts := strings.SplitN(content, ":-", 2)
+			varName := parts[0]
+			defaultValue := parts[1]
+
+			// First check if we have this variable from previously resolved mappings
+			if resolvedValue, exists := resolvedVars[varName]; exists {
+				return resolvedValue
+			}
+
+			// Then check if it's an environment variable
+			if envValue := os.Getenv(varName); envValue != "" {
+				return envValue
+			}
+
+			// If not found, return the default value
+			return defaultValue
+		}
+
+		// No default value specified, use original logic
+		varName := content
+
+		// First check if we have this variable from previously resolved mappings
+		if resolvedValue, exists := resolvedVars[varName]; exists {
+			return resolvedValue
+		}
+
+		// Then check if it's an environment variable
+		if envValue := os.Getenv(varName); envValue != "" {
+			return envValue
+		}
+
+		// If not found, return the original pattern (could be useful for debugging)
+		return match
+	})
+}
+
+// processValueInterpolations processes all value fields in mappings to resolve environment variable interpolations
+func processValueInterpolations(config *KubaConfig) error {
+	// Process environments in order to handle dependencies correctly
+	// We'll process each environment multiple times until no more interpolations are possible
+	// or until we detect a circular dependency
+
+	for envName, env := range config.Environments {
+		// Track resolved variables for this environment
+		resolvedVars := make(map[string]string)
+
+		// Process mappings multiple times to handle dependencies
+		maxIterations := len(env.Mappings) * 2 // Allow for some dependency depth
+		for iteration := 0; iteration < maxIterations; iteration++ {
+			changed := false
+
+			for i, mapping := range env.Mappings {
+				if mapping.Value != nil {
+					// Convert value to string for processing
+					var strValue string
+					switch v := mapping.Value.(type) {
+					case string:
+						strValue = v
+					case int, int32, int64:
+						strValue = fmt.Sprintf("%d", v)
+					case float32, float64:
+						strValue = fmt.Sprintf("%g", v)
+					default:
+						strValue = fmt.Sprintf("%v", v)
+					}
+
+					// Check if this value contains interpolation patterns
+					if strings.Contains(strValue, "${") {
+						// Interpolate the value
+						interpolatedValue := interpolateEnvVars(strValue, resolvedVars)
+
+						// If the value changed, update it
+						if interpolatedValue != strValue {
+							// Update the mapping value
+							env.Mappings[i].Value = interpolatedValue
+							// Update our resolved vars map
+							resolvedVars[mapping.EnvironmentVariable] = interpolatedValue
+							changed = true
+						}
+					} else {
+						// No interpolation needed, but convert numeric values to strings for consistency
+						if mapping.Value != strValue {
+							env.Mappings[i].Value = strValue
+							changed = true
+						}
+						// Store the value in resolved vars
+						resolvedVars[mapping.EnvironmentVariable] = strValue
+					}
+				}
+			}
+
+			// If no changes were made in this iteration, we're done
+			if !changed {
+				break
+			}
+		}
+
+		// Update the environment in the config
+		config.Environments[envName] = env
+	}
+
+	return nil
+}
+
 // LoadKubaConfig loads the kuba.yaml configuration file
 func LoadKubaConfig(configPath string) (*KubaConfig, error) {
 	if configPath == "" {
@@ -53,6 +172,11 @@ func LoadKubaConfig(configPath string) (*KubaConfig, error) {
 		return nil, fmt.Errorf("failed to parse configuration file: %w", err)
 	}
 
+	// Process environment variable interpolations
+	if err := processValueInterpolations(&config); err != nil {
+		return nil, fmt.Errorf("failed to process environment variable interpolations: %w", err)
+	}
+
 	// Validate configuration
 	if err := validateConfig(&config); err != nil {
 		return nil, fmt.Errorf("invalid configuration: %w", err)