refactor(config): split validation into focused files with shared helpers (#220)

* refactor(config): extract extension validation into dedicated file

* refactor(config): add shared validation helpers to reduce duplication

Author: indaco

internal/config/validator.go

@@ -47,16 +47,9 @@ func (v *Validator) Validate(ctx context.Context) ([]ValidationResult, error) {
 	// Reset validations
 	v.validations = make([]ValidationResult, 0)
 
-	// Validate YAML syntax (by trying to load it)
 	v.validateYAMLSyntax(ctx)
-
-	// Validate plugin configurations
 	v.validatePluginConfigs(ctx)
-
-	// Validate workspace configuration
 	v.validateWorkspaceConfig(ctx)
-
-	// Validate extension configurations
 	v.validateExtensionConfigs(ctx)
 
 	return v.validations, nil

internal/config/validator_extensions.go

@@ -0,0 +1,83 @@
+package config
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"path/filepath"
+)
+
+// validateExtensionConfigs validates extension configurations.
+func (v *Validator) validateExtensionConfigs(ctx context.Context) {
+	if v.cfg == nil || len(v.cfg.Extensions) == 0 {
+		return
+	}
+
+	pathErrorCount := 0
+	manifestErrorCount := 0
+
+	for i, ext := range v.cfg.Extensions {
+		extPath := v.resolvePath(ext.Path)
+
+		if !v.validateExtensionPath(ctx, i, ext, extPath) {
+			pathErrorCount++
+			continue
+		}
+
+		if ext.Enabled && !v.validateExtensionManifest(ctx, i, ext, extPath) {
+			manifestErrorCount++
+		}
+	}
+
+	if pathErrorCount == 0 && manifestErrorCount == 0 {
+		enabledCount := v.countEnabledExtensions()
+		v.addValidation("Extensions", true,
+			fmt.Sprintf("Configured with %d extension(s) (%d enabled)", len(v.cfg.Extensions), enabledCount), false)
+	}
+}
+
+// validateExtensionPath checks if an extension path exists and is accessible.
+func (v *Validator) validateExtensionPath(ctx context.Context, index int, ext ExtensionConfig, extPath string) bool {
+	_, err := v.fs.Stat(ctx, extPath)
+	if err == nil {
+		return true
+	}
+
+	if os.IsNotExist(err) {
+		v.addValidation("Extensions", false,
+			fmt.Sprintf("Extension %d ('%s'): path '%s' does not exist", index+1, ext.Name, ext.Path), false)
+	} else {
+		v.addValidation("Extensions", false,
+			fmt.Sprintf("Extension %d ('%s'): cannot access path '%s': %v", index+1, ext.Name, ext.Path, err), false)
+	}
+	return false
+}
+
+// validateExtensionManifest checks if an enabled extension has a valid manifest file.
+func (v *Validator) validateExtensionManifest(ctx context.Context, index int, ext ExtensionConfig, extPath string) bool {
+	manifestPath := filepath.Join(extPath, "extension.yaml")
+	_, err := v.fs.Stat(ctx, manifestPath)
+	if err == nil {
+		return true
+	}
+
+	if os.IsNotExist(err) {
+		v.addValidation("Extensions", false,
+			fmt.Sprintf("Extension %d ('%s'): manifest file 'extension.yaml' not found", index+1, ext.Name), false)
+	} else {
+		v.addValidation("Extensions", false,
+			fmt.Sprintf("Extension %d ('%s'): cannot access manifest: %v", index+1, ext.Name, err), false)
+	}
+	return false
+}
+
+// countEnabledExtensions returns the number of enabled extensions.
+func (v *Validator) countEnabledExtensions() int {
+	count := 0
+	for _, ext := range v.cfg.Extensions {
+		if ext.Enabled {
+			count++
+		}
+	}
+	return count
+}

internal/config/validator_helpers.go

@@ -0,0 +1,89 @@
+package config
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"path/filepath"
+	"regexp"
+	"strings"
+)
+
+// validateEnum checks that a value is in the allowed set. Returns true if valid.
+func (v *Validator) validateEnum(category, field, value string, allowed map[string]bool) bool {
+	if !allowed[value] {
+		keys := make([]string, 0, len(allowed))
+		for k := range allowed {
+			if k != "" {
+				keys = append(keys, "'"+k+"'")
+			}
+		}
+		v.addValidation(category, false,
+			fmt.Sprintf("Invalid %s '%s': must be one of %s", field, value, joinWithOr(keys)), false)
+		return false
+	}
+	return true
+}
+
+// validateFileExists checks that a file exists at the given path.
+// label is used in the validation message (e.g., "File 1", "Changelog file").
+// Returns true if the file exists.
+func (v *Validator) validateFileExists(ctx context.Context, category, label, rawPath string) bool {
+	absPath := v.resolvePath(rawPath)
+
+	if _, err := v.fs.Stat(ctx, absPath); err != nil {
+		if os.IsNotExist(err) {
+			v.addValidation(category, false,
+				fmt.Sprintf("%s: '%s' does not exist", label, rawPath), false)
+		} else {
+			v.addValidation(category, false,
+				fmt.Sprintf("%s: cannot access '%s': %v", label, rawPath, err), false)
+		}
+		return false
+	}
+	return true
+}
+
+// validateRegex checks that a pattern is a valid regular expression.
+// Returns true if valid.
+func (v *Validator) validateRegex(category, label, pattern string) bool {
+	if _, err := regexp.Compile(pattern); err != nil {
+		v.addValidation(category, false,
+			fmt.Sprintf("%s: invalid regex: %v", label, err), false)
+		return false
+	}
+	return true
+}
+
+// resolvePath resolves a path relative to the validator's root directory.
+// Absolute paths are returned as-is.
+func (v *Validator) resolvePath(path string) string {
+	if filepath.IsAbs(path) {
+		return path
+	}
+	return filepath.Join(v.rootDir, path)
+}
+
+// joinWithOr joins strings with commas and "or" before the last element.
+func joinWithOr(items []string) string {
+	switch len(items) {
+	case 0:
+		return ""
+	case 1:
+		return items[0]
+	case 2:
+		return items[0] + " or " + items[1]
+	default:
+		var b strings.Builder
+		for i, item := range items {
+			if i == len(items)-1 {
+				b.WriteString("or ")
+				b.WriteString(item)
+			} else {
+				b.WriteString(item)
+				b.WriteString(", ")
+			}
+		}
+		return b.String()
+	}
+}