added transformation functionality

Author: kthehatter

validator/transformers.go

@@ -0,0 +1,81 @@
+package validator
+
+import (
+	"strconv"
+	"strings"
+
+	"golang.org/x/text/cases"
+	"golang.org/x/text/language"
+)
+
+// RemoveSpecialChars removes special characters from a string.
+func RemoveSpecialChars(value interface{}) interface{} {
+	if str, ok := value.(string); ok {
+		var result strings.Builder
+		for _, char := range str {
+			if (char >= 'a' && char <= 'z') || (char >= 'A' && char <= 'Z') || (char >= '0' && char <= '9') || char == ' ' {
+				result.WriteRune(char)
+			}
+		}
+		return result.String()
+	}
+	return value
+}
+
+// ToTitleCase converts a string to title case.
+func ToTitleCase(value interface{}) interface{} {
+	if str, ok := value.(string); ok {
+		// Create a title caser for the English language
+		caser := cases.Title(language.French)
+		return caser.String(strings.ToLower(str))
+	}
+	return value
+}
+
+// ToInt converts a string or float to an integer.
+func ToInt(value interface{}) interface{} {
+	switch v := value.(type) {
+	case string:
+		if i, err := strconv.Atoi(v); err == nil {
+			return i
+		}
+	case float64:
+		return int(v)
+	}
+	return value
+}
+
+// ToFloat converts a string or integer to a float.
+func ToFloat(value interface{}) interface{} {
+	switch v := value.(type) {
+	case string:
+		if f, err := strconv.ParseFloat(v, 64); err == nil {
+			return f
+		}
+	case int:
+		return float64(v)
+	}
+	return value
+}
+
+// Truncate truncates a string to a specified maximum length.
+func Truncate(maxLength int) Transformer {
+	return func(value interface{}) interface{} {
+		if str, ok := value.(string); ok {
+			if len(str) > maxLength {
+				return str[:maxLength]
+			}
+		}
+		return value
+	}
+}
+
+// Replace replaces occurrences of a substring with another string.
+func Replace(old, new string) Transformer {
+	return func(value interface{}) interface{} {
+		if str, ok := value.(string); ok {
+			return strings.ReplaceAll(str, old, new)
+		}
+		return value
+	}
+}

validator/transformers_test.go

@@ -0,0 +1,120 @@
+package validator
+
+import (
+	"testing"
+)
+
+func TestRemoveSpecialChars(t *testing.T) {
+	tests := []struct {
+		input    interface{}
+		expected interface{}
+	}{
+		{"Hello!@# World!", "Hello World"},
+		{"123#456", "123456"},
+		{123, 123}, // Non-string input
+	}
+
+	for _, test := range tests {
+		result := RemoveSpecialChars(test.input)
+		if result != test.expected {
+			t.Errorf("RemoveSpecialChars(%v) = %v, expected %v", test.input, result, test.expected)
+		}
+	}
+}
+
+func TestToTitleCase(t *testing.T) {
+	tests := []struct {
+		input    interface{}
+		expected interface{}
+	}{
+		{"hello world", "Hello World"},
+		{"HELLO WORLD", "Hello World"},
+		{"çimant", "Çimant"},
+		{"hello, world!", "Hello, World!"}, // Handles punctuation correctly
+		{"123", "123"},                     // Non-alphabetic input
+		{123, 123},                         // Non-string input
+	}
+
+	for _, test := range tests {
+		result := ToTitleCase(test.input)
+		if result != test.expected {
+			t.Errorf("ToTitleCase(%v) = %v, expected %v", test.input, result, test.expected)
+		}
+	}
+}
+
+func TestToInt(t *testing.T) {
+	tests := []struct {
+		input    interface{}
+		expected interface{}
+	}{
+		{"123", 123},
+		{123.45, 123},
+		{"abc", "abc"}, // Invalid input
+	}
+
+	for _, test := range tests {
+		result := ToInt(test.input)
+		if result != test.expected {
+			t.Errorf("ToInt(%v) = %v, expected %v", test.input, result, test.expected)
+		}
+	}
+}
+
+func TestToFloat(t *testing.T) {
+	tests := []struct {
+		input    interface{}
+		expected interface{}
+	}{
+		{"123.45", 123.45},
+		{123, 123.0},
+		{"abc", "abc"}, // Invalid input
+	}
+
+	for _, test := range tests {
+		result := ToFloat(test.input)
+		if result != test.expected {
+			t.Errorf("ToFloat(%v) = %v, expected %v", test.input, result, test.expected)
+		}
+	}
+}
+
+func TestTruncate(t *testing.T) {
+	transformer := Truncate(5)
+
+	tests := []struct {
+		input    interface{}
+		expected interface{}
+	}{
+		{"hello world", "hello"},
+		{"hi", "hi"},
+		{123, 123}, // Non-string input
+	}
+
+	for _, test := range tests {
+		result := transformer(test.input)
+		if result != test.expected {
+			t.Errorf("Truncate(%v) = %v, expected %v", test.input, result, test.expected)
+		}
+	}
+}
+
+func TestReplace(t *testing.T) {
+	transformer := Replace("foo", "bar")
+
+	tests := []struct {
+		input    interface{}
+		expected interface{}
+	}{
+		{"foo bar", "bar bar"},
+		{"hello world", "hello world"},
+		{123, 123}, // Non-string input
+	}
+
+	for _, test := range tests {
+		result := transformer(test.input)
+		if result != test.expected {
+			t.Errorf("Replace(%v) = %v, expected %v", test.input, result, test.expected)
+		}
+	}
+}

validator/validator.go

@@ -5,6 +5,9 @@ import "fmt"
 // ValidatorFunc is a function that validates a field and returns an error if validation fails.
 type ValidatorFunc func(value interface{}) error
 
+// TransformerFunc is a function that transforms a value.
+type Transformer func(value interface{}) interface{}
+
 // Validator defines a validator function and its error message.
 type Validator struct {
 	Func    ValidatorFunc
@@ -13,10 +16,11 @@ type Validator struct {
 
 // ValidationOption defines the validation rules for a specific field.
 type ValidationOption struct {
-	Key        string             // Field name in the request body
-	IsOptional bool               // Whether the field is optional
-	Validators []Validator        // List of validators for the field
-	Nested     []ValidationOption // Validation options for nested objects
+	Key          string             // Field name in the request body
+	IsOptional   bool               // Whether the field is optional
+	Validators   []Validator        // List of validators for the field
+	Transformers []Transformer      // List of transformers for the field
+	Nested       []ValidationOption // Validation options for nested objects
 }
 
 // Validate checks the request body against the validation options and returns the first error.
@@ -29,6 +33,14 @@ func Validate(body map[string]interface{}, options []ValidationOption) error {
 			continue
 		}
 
+		// Apply transformations
+		if exists {
+			for _, transformer := range option.Transformers {
+				value = transformer(value)
+			}
+			body[option.Key] = value // Update the body with the transformed value
+		}
+
 		// Run all validators for the field (if it exists)
 		for _, validator := range option.Validators {
 			if err := validator.Func(value); err != nil {