Init

Author: debug-ing

go.mod

@@ -0,0 +1,5 @@
+module github.com/debug-ing/validation-go
+
+go 1.22.3
+
+require github.com/google/uuid v1.6.0

go.sum

@@ -0,0 +1,2 @@
+github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
+github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=

main.go

@@ -0,0 +1,32 @@
+package main
+
+import (
+	"fmt"
+
+	"github.com/debug-ing/validation-go/pkg/validation"
+)
+
+type UpdateIAMUserRequest struct {
+	ID    string `validate:"required,uuid"`
+	Name  string `validate:"required,minlength=10"`
+	LName string `validate:"required,minlength=10"`
+	Age   int    `validate:"required,numeric,minmax=18-100"`
+	Nike  string `validate:"required,between=1-10"`
+}
+
+func main() {
+	req := UpdateIAMUserRequest{
+		ID:    "d89cb260-36ff-4206-8979-6c1ce693ab28",
+		Name:  "ddsffddddd",
+		LName: "ddsffddddd",
+		Age:   29,
+		Nike:  "sdfkjdf",
+	}
+	//
+	err := validation.ValidateStruct(req)
+	if err != nil {
+		fmt.Println("Validation error:", err)
+	} else {
+		fmt.Println("Validation passed")
+	}
+}

pkg/validation/rules.go

@@ -0,0 +1,62 @@
+package validation
+
+import (
+	"errors"
+	"strconv"
+	"strings"
+
+	"github.com/google/uuid"
+)
+
+func validateRequired(value string, errorMsg string) error {
+	if value == "" {
+		return errors.New(errorMsg)
+	}
+	return nil
+}
+
+func validationIsUUID(value string, errorMsg string) error {
+	_, err := uuid.Parse(value)
+	if err != nil {
+		return errors.New(errorMsg)
+	}
+	return nil
+}
+
+func validateMinLength(value string, min int, errorMsg string) error {
+	if len(value) < min {
+		return errors.New(errorMsg)
+	}
+	return nil
+}
+func validateIsEmail(value string, errorMsg string) error {
+	if !strings.Contains(value, "@") {
+		return errors.New(errorMsg)
+	}
+	return nil
+}
+func validateIsNumber(value string, errorMsg string) error {
+	if _, err := strconv.Atoi(value); err != nil {
+		return errors.New(errorMsg)
+	}
+	return nil
+}
+
+func validationBetween(value string, min, max int, errorMsg string) error {
+	if len(value) < min || len(value) > max {
+		return errors.New(errorMsg)
+	}
+	return nil
+}
+
+func validationMinMaxNumber(value string, min, max int, errorMsg string) error {
+	num, err := strconv.Atoi(value)
+	if err != nil {
+		return errors.New(errorMsg)
+	}
+
+	if num < min || num > max {
+		return errors.New(errorMsg)
+	}
+	return nil
+}

pkg/validation/validator.go

@@ -0,0 +1,107 @@
+package validation
+
+import (
+	"fmt"
+	"reflect"
+	"strconv"
+	"strings"
+)
+
+var validators = map[string]interface{}{
+	"required":  validateRequired,
+	"minlength": validateMinLength,
+	"uuid":      validationIsUUID,
+	"email":     validateIsEmail,
+	"numeric":   validateIsNumber,
+	"between":   validationBetween,
+	"minmax":    validationMinMaxNumber,
+}
+
+var data = map[string]map[string]string{
+	"required": {
+		"error_msg": "%s field is required.",
+	},
+	"minlength": {
+		"error_msg": "%s must be at least %d  characters long.",
+	},
+	"uuid": {
+		"error_msg": "%s must be a valid UUID.",
+	},
+	"email": {
+		"error_msg": "%s must be a valid email address.",
+	},
+	"numeric": {
+		"error_msg": "%s must be a number.",
+	},
+	"between": {
+		"error_msg": "%s must be between %d and %d characters long.",
+	},
+	"minmax": {
+		"error_msg": "%s must be between %d and %d.",
+	},
+}
+
+func ValidateStruct(s interface{}) error {
+	v := reflect.ValueOf(s)
+	t := v.Type()
+	for i := 0; i < t.NumField(); i++ {
+		field := t.Field(i)
+		value := v.Field(i)
+		fieldName := field.Name
+		validateTag := field.Tag.Get("validate")
+		data := strings.Split(validateTag, ",")
+		for _, d := range data {
+			parts := strings.SplitN(d, "=", 2)
+			tagName := parts[0]
+			var tagParam string
+			if len(parts) > 1 {
+				tagParam = parts[1]
+			}
+			if validator, exists := validators[tagName]; exists {
+				switch validator := validator.(type) {
+				case func(string, string) error:
+					errorMsg := getMessage(tagName, fieldName)
+					if err := validator(fmt.Sprint(value), errorMsg); err != nil {
+						return err
+					}
+				case func(string, int, string) error:
+					if param, err := strconv.Atoi(tagParam); err == nil {
+						errorMsg := getMessage(tagName, fieldName, param)
+						if err := validator(value.String(), param, errorMsg); err != nil {
+							return err
+						}
+					} else {
+						return fmt.Errorf("invalid parameter for tag %s", tagName)
+					}
+				case func(string, int, int, string) error:
+					params := strings.Split(tagParam, "-")
+					if len(params) != 2 {
+						return fmt.Errorf("invalid parameter for tag %s", tagName)
+					}
+					min, err := strconv.Atoi(params[0])
+					if err != nil {
+						return fmt.Errorf("invalid parameter for tag %s", tagName)
+					}
+
+					max, err := strconv.Atoi(params[1])
+					if err != nil {
+						return fmt.Errorf("invalid parameter for tag %s", tagName)
+					}
+					errorMsg := getMessage(tagName, fieldName, min, max)
+					if err := validator(fmt.Sprint(value), min, max, errorMsg); err != nil {
+						return err
+					} else {
+
+					}
+
+				}
+			}
+		}
+	}
+	return nil
+}
+
+func getMessage(tagName, fieldName string, args ...interface{}) string {
+	errorMsgTemplate := data[tagName]["error_msg"]
+	return fmt.Sprintf(errorMsgTemplate, append([]interface{}{fieldName}, args...)...)
+}