Gin example about mold HOT 4 OPEN

import (
	"context"
	"encoding/json"
	"errors"
	"io"
	"net/http"

	"github.com/gin-gonic/gin/binding"
	"github.com/go-playground/mold/v4/modifiers"
)

var conform = modifiers.New()

// customJSONBinding is mostly same as Gin JSON Binding, but it transforms data after decoding and before validating
type customJSONBinding struct{}

func (customJSONBinding) Name() string {
	return "supplier custom json binding"
}

func (customJSONBinding) Bind(req *http.Request, obj any) error {
	if req == nil || req.Body == nil {
		return errors.New("invalid request")
	}
	return decodeJSON(req.Body, obj)
}

func decodeJSON(r io.Reader, obj any) error {
	decoder := json.NewDecoder(r)
	if binding.EnableDecoderUseNumber {
		decoder.UseNumber()
	}
	if binding.EnableDecoderDisallowUnknownFields {
		decoder.DisallowUnknownFields()
	}
	if err := decoder.Decode(obj); err != nil {
		return err
	}
	if err := transform(obj); err != nil {
		return err
	}
	return validate(obj)
}

func transform(obj any) error {
	if conform == nil {
		return nil
	}
	return conform.Struct(context.Background(), obj)
}

func validate(obj any) error {
	if binding.Validator == nil {
		return nil
	}
	return binding.Validator.ValidateStruct(obj)
}

// You have to init an instance of `customJSONBinding` to use
var customJSON = customJSONBinding{}

type Request struct {
    Email string `json:"email" mod:"trim" binding:"required,email"`
    Name string `json:"name" mod:"trim" binding:"required"`
}

func myHandler(c *gin.Context) {
    var req Request
    if err := c.ShouldBindWith(&req, customJSON); err != nil {
	// Do smt...
    }
}

//  helpers/custom_validator_helper.go
package helpers

import (
	"context"
	"reflect"
	"github.com/go-playground/mold/v4/modifiers"
	"github.com/go-playground/validator/v10"
)

type CustomValidator struct {
	validator *validator.Validate
}

func NewCustomValidator() *CustomValidator {
	v := validator.New()
	// Set the tag name to "binding", SetTagName allows for changing of the default tag name of 'validate'
	v.SetTagName("binding")
	// Register Tag Name Function to get json name as alternate names for StructFields.
	v.RegisterTagNameFunc(func(fld reflect.StructField) string {
		return fld.Tag.Get("json")
	})
	// Register custom validation tags if needed
	v.RegisterValidation("customValidation", customValidationFunc)
	return &CustomValidator{validator: v}
}

// ValidateStruct is called by Gin to validate the struct
func (cv *CustomValidator) ValidateStruct(obj interface{}) error {
	// transform the object using mold before validating the struct
	transformer := modifiers.New()
	if err := transformer.Struct(context.Background(), obj); err != nil {
		return err
	}
	// validate the struct
	if err := cv.validator.Struct(obj); err != nil {
		return err
	}
	return nil
}

// Engine is called by Gin to retrieve the underlying validation engine
func (cv *CustomValidator) Engine() interface{} {
	return cv.validator
}

// Custom validation function
func customValidationFunc(fl validator.FieldLevel) bool {
	// Custom validation logic here
	return true
}

// main.go
package main

import (
	"github.com/gin-gonic/gin"
	"github.com/gin-gonic/gin/binding"
)



func main() {
	router := gin.Default()

	// Use custom validator
	customValidator := helpers.NewCustomValidator() // Create a new instance of your custom validator
	binding.Validator = customValidator             // Set the binding.Validator to your custom validator

	// Define your routes and handlers
	// ...

	// Run the server
	router.Run(":8080")
}

type Request struct {
	Email string `json:"email" mod:"trim" binding:"required,email"`
	Name string `json:"name" mod:"trim" binding:"required"`
}

func myHandler(c *gin.Context) {
	var req Request
	if err := c.ShouldBind(&req); err != nil {
		// Do smt...
	}
}