e6.2.0 Common validator functions added.

validator.go

@@ -0,0 +1,123 @@
+// FILE: lixenwraith/config/validator.go
+package config
+
+import (
+	"fmt"
+	"net"
+	"regexp"
+	"strings"
+)
+
+// Common validators for configuration values
+
+// Port validates TCP/UDP port range
+func Port(p int64) error {
+	if p < 1 || p > 65535 {
+		return fmt.Errorf("must be 1-65535, got %d", p)
+	}
+	return nil
+}
+
+// Positive validates positive numbers
+func Positive[T int64 | float64](n T) error {
+	if n <= 0 {
+		return fmt.Errorf("must be positive, got %v", n)
+	}
+	return nil
+}
+
+// NonNegative validates non-negative numbers
+func NonNegative[T int64 | float64](n T) error {
+	if n < 0 {
+		return fmt.Errorf("must be non-negative, got %v", n)
+	}
+	return nil
+}
+
+// IPAddress validates IP address format
+func IPAddress(s string) error {
+	if s == "" || s == "0.0.0.0" || s == "::" {
+		return nil // Allow common defaults
+	}
+	if net.ParseIP(s) == nil {
+		return fmt.Errorf("invalid IP address: %s", s)
+	}
+	return nil
+}
+
+// IPv4Address validates IPv4 address format
+func IPv4Address(s string) error {
+	if s == "" || s == "0.0.0.0" {
+		return nil // Allow common defaults
+	}
+	ip := net.ParseIP(s)
+	if ip == nil || ip.To4() == nil {
+		return fmt.Errorf("invalid IPv4 address: %s", s)
+	}
+	return nil
+}
+
+// IPv6Address validates IPv6 address format
+func IPv6Address(s string) error {
+	if s == "" || s == "::" {
+		return nil // Allow common defaults
+	}
+	ip := net.ParseIP(s)
+	if ip == nil {
+		return fmt.Errorf("invalid IPv6 address: %s", s)
+	}
+	// Valid net.ParseIP with nil ip.To4 indicates IPv6
+	if ip.To4() != nil {
+		return fmt.Errorf("invalid IPv6 address (is an IPv4 address): %s", s)
+	}
+	return nil
+}
+
+// URLPath validates URL path format
+func URLPath(s string) error {
+	if s != "" && !strings.HasPrefix(s, "/") {
+		return fmt.Errorf("must start with /: %s", s)
+	}
+	return nil
+}
+
+// OneOf creates a validator for allowed values
+func OneOf[T comparable](allowed ...T) func(T) error {
+	return func(val T) error {
+		for _, a := range allowed {
+			if val == a {
+				return nil
+			}
+		}
+		return fmt.Errorf("must be one of %v, got %v", allowed, val)
+	}
+}
+
+// Range creates a min/max validator
+func Range[T int64 | float64](min, max T) func(T) error {
+	return func(val T) error {
+		if val < min || val > max {
+			return fmt.Errorf("must be %v-%v, got %v", min, max, val)
+		}
+		return nil
+	}
+}
+
+// Pattern creates a regex validator
+func Pattern(pattern string) func(string) error {
+	re := regexp.MustCompile(pattern)
+	return func(s string) error {
+		if !re.MatchString(s) {
+			return fmt.Errorf("must match pattern %s", pattern)
+		}
+		return nil
+	}
+}
+
+// NonEmpty validates non-empty strings
+func NonEmpty(s string) error {
+	if strings.TrimSpace(s) == "" {
+		return fmt.Errorf("must not be empty")
+	}
+	return nil
+}