Validate Golang request data with simple rules. Highly inspired by Laravel's request validation.

The numeric rule was not handling negative numbers correctly as the Numeric regexp was not accepting negative numbers which is valid.

Fixed that and added a bunch of test cases around negative numbers for numeric, numeric_between, min and max.

Using your example

package main

import (
	"encoding/json"
	"fmt"
	"net/http"
	"github.com/thedevsaddam/govalidator"
)

func handler(w http.ResponseWriter, r *http.Request) {
	rules := govalidator.MapData{
		"stock_image": []string{"ext:jpg,jpeg,png,bmp", "size:20000000", "required"},
	}

	opts := govalidator.Options{
		Request: r,     // request object
		Rules:   rules, // rules map
	}
	v := govalidator.New(opts)
	e := v.Validate()
	err := map[string]interface{}{"validationError": e}
	fmt.Fprintln(w, err)

}

func main() {
	http.HandleFunc("/", handler)
	fmt.Println("Listening on port: 9000")
	http.ListenAndServe(":9000", nil)
}

always yield me to map[validationError:map[stock_image:[The stock_image field is required]]] even though i already select a file to be upload.

I think the problem is in validator.go line 87 (v.Opts.Request.Form.Get) , since its files, its not available in v.Opts.Request.Form instead available in v.Opts.RequestMultiPartForm

Thats why validateCustomRules(field, rule, msg, reqVal, errsBag) always return an error, since reqVal always empty

these rules

	rules := govalidator.MapData{
		"mail1":   []string{"required", "email"},
		"mail2":      []string{"email"},
	}

give me mail2 The sender field must be a valid email address

I think that the correct behavior should be that the validation allows empty emails

Hey adam..

I think the form validation is not working when the rules is optional (no required)

func handler(w http.ResponseWriter, r *http.Request) {
	rules := govalidator.MapData{
                //Notice this rules is optional
		"file:photo": []string{"ext:jpg,png", "size:2000000", "mime:jpg,png"},
	}

	messages := govalidator.MapData{
		"file:photo": []string{"ext:Only jpg/png is allowed", "size:Maximux size is 2Mb"},
	}

	opts := govalidator.Options{
		Request: r,     // request object
		Rules:   rules, // rules map,
		Messages: messages,
	}

	v := govalidator.New(opts)
	e := v.Validate()
	err := map[string]interface{}{"validationError": e}
	w.Header().Set("Content-type", "applciation/json")
	json.NewEncoder(w).Encode(err)
}

Eventhough im not uploading any file, the validation still run through yielding me to Only jpg/png is allowed

Regarding this line: https://github.com/thedevsaddam/govalidator/blob/master/validator.go#L95

Even though there is no uploaded file, file is still not nil I think the correct way should be

if strings.HasPrefix(field, "file:") {
	fld := strings.TrimPrefix(field, "file:")
	file, fileHeader, _ := v.Opts.Request.FormFile(fld)
	if fileHeader.Filename  != "" {
		validateFiles(v.Opts.Request, fld, rule, msg, errsBag)
		validateCustomRules(fld, rule, msg, file, errsBag)
	} else {
		validateCustomRules(fld, rule, msg, nil, errsBag)
	}
}

Some additional info: Golang v1.10 I'm entirely not sure prior to v1.10 whether its working or not

The numeric_between is now able to be configured without a min value (numeric_between:,10) creating a validator that will accept any values lower or equal to 10 and without a max value (numeric_between:10,) creating a validator that will accept any values higher or equal to 10.

Hi, I have recently started using the govalidator library and I must say this has solved a lot of problems for me.

I am trying to validate the following request but I am getting an error. Could you please let me know if it's a bug or am I doing something wrong?

payload: {"user":"uewbf937rweab", "data": {"event": "cm", "messages": "["Hello to the world!"]"}}

rules: govalidator.MapData{ "user": []string{"required"}, "data": []string{"required"}, }

error: "the data field is required"

Hi, @thedevsaddam .

It seems that fields of Options.Rule are deleted in some case, so Options.Rule cannot be used more than once. This behavior seems a bit inconvenient, so I'd like to fix it. What do you think?

How about setting default value by providing default struct tag to set default value when the field was null in validation phrase. As below Username and Email fields

type user struct {
	Username string           `json:"username",default:"foo"`
	Email    string           `json:"email",default:"[email protected]"`
	Web      string           `json:"web"`
	Age      govalidator.Int  `json:"age"`
	Agree    govalidator.Bool `json:"agree"`
}

rules := govalidator.MapData{
	"username": []string{"required", "between:3,8"},
	"email":    []string{"required", "min:4", "max:20", "email"},
	"web":      []string{"url"},
	"phone":    []string{"digits:11"}
	"agree":    []string{"bool"},
	"dob":      []string{"date"},
}

opts := govalidator.Options{
	Request:         &user{Username: "test",  ....},        // use struct instead net.http
	Rules:           rules,    // rules map
	Messages:        messages, // custom message map (Optional)
	RequiredDefault: true,     // all the field to be pass the rules
} 

I want to check validation struct instead *net.http. I can't find any sample code. for example :

type user struct {
	Username string           `json:"username"`
	Email    string           `json:"email"`
	Web      string           `json:"web"`
	Age      govalidator.Int  `json:"age"`
	Agree    govalidator.Bool `json:"agree"`
}

rules := govalidator.MapData{
	"username": []string{"required", "between:3,8"},
	"email":    []string{"required", "min:4", "max:20", "email"},
	"web":      []string{"url"},
	"phone":    []string{"digits:11"}
	"agree":    []string{"bool"},
	"dob":      []string{"date"},
}

opts := govalidator.Options{
	Request:         &user{Username: "test",  ....},        // use struct instead net.http
	Rules:           rules,    // rules map
	Messages:        messages, // custom message map (Optional)
	RequiredDefault: true,     // all the field to be pass the rules
} 

how I can do this ?

rule digits:12, no problem. rule digits:13 ends up taking a 13 digit integer and formatting to scientific notation, resulting in a string length of 15. Example:

rules := govalidator.MapData{ "createdEpochMs": []string{"required", "digits:13"} }

when passing 1541689038000 to rules:go:toString(value), a string value of 1.541689038e+12 is returned. utils:go:toString(value) formats interface{} to "%#v" which exceeds the default width.

Considering you know the intended length "l" based on the "digits:" suffix and that it's an integer type, one possible approach to resolve this might be to use an explicit width format on an alternate "toString" method:

func toNumericString(v interface{}, width int, precision int) string {
	str, ok := v.(string)
	if !ok {
		format := fmt.Sprintf("%%%d.%df", width, precision)
		str = fmt.Sprintf(format, v)
	}
	return str
}

This is what the call would look like:

str := toNumericString(value, l, 0)
if len(str) != l || !isNumeric(str) {
	return err
}

There may be even simpler ways to do it. Just looking to validate an epoch in milliseconds. I will likely fall back on regex validation for the time-being.

Just a small thing so hope you don't mind I'm opening a special pull request for it. But I noticed it right away when reading your docs.

Kind regards.

code like this

// QueryPageProjectGrailRequest Request 请求 type QueryPageProjectGrailRequest struct { PageNo int32 json:"page_no" // 页码 PageSize int32 json:"page_size" // 每页数量 Sort string json:"sort" // 排序，支持多个 such as "col1 desc, col2 asc" Filter []queryProjectGrailFilter json:"filter" // 筛选（高级查询） Keywords []string json:"keywords" // 全文检索能力 }

type queryProjectGrailFilter struct { Field string json:"field" Condition string json:"condition" Relation string json:"relation" Value string json:"value" }

I don't know how to validator field in filter? such as filter.relation

// relation didn't work rules := govalidator.MapData{ "page_no": []string{"required", "numeric_between:1,100000"}, "page_size": []string{"required", "numeric_between:1,1000"}, "relation": []string{"between:1,5"}, }

  type User struct {
	  FirstName string
	  LastName string
	  Address AddressSliceWrapper
  }
  
  type Address struct {
	  IsMailing bool 
  }
  
  type Addresses []Address

// AddressSliceWrapper embeds the alias type for the sake of embedding a slice. // This is very heavy-handed.

type AddressSliceWrapper struct {
	Addresses
}

Hey Saddam,

Great package 👍

I know that if I have a specific requirement for a rule I can use the AddCustomRule() method. However, it's hard to use it within a request-bound situation. For instance, consider a "password confirmation" situation like this:

// Somewhere in your handler

type RegisterRequest struct {
	FirstName            string `json:"firstName"`
	LastName             string `json:"lastName"`
	Email                string `json:"email"`
	Password             string `json:"password"`
	PasswordConfirmation string `json:"passwordConfirmation"`
}

var registerRequest RegisterRequest

rules := govalidator.MapData{
	"firstName": []string{"required", "max:64"},
	"lastName":  []string{"required", "max:64"},
	"email":     []string{"required", "email"},
	"password":  []string{"required", "confirmed"},
}

opts := govalidator.Options{
	Request: r,     // request object
	Rules:   rules, // rules map
	Data:    &registerRequest,
	RequiredDefault: true, // all the field to be pass the rules
}

govalidator.AddCustomRule("confirmed", func(field string, rule string, message string, value interface{}) error {
	val := value.(string)
	if val != registerRequest.PasswordConfirmation {
		return fmt.Errorf("The %s confirmation does not match", field)
	}
	return nil
})

This would only work on the first request, any subsequent request will fail because of this: https://github.com/thedevsaddam/govalidator/blob/410bf76327c31ef88a2cc858060b4016dcb80bb3/rules.go#L21-L24

You could say I could define the rule outside the handler, but as you can see the rule has a dependency on another field of the request body.

Is there any way I can get around this?

Off the top of my head, here are some of the things I thought about that would not cause a breaking change:

• We could export the isRuleExist function, making it public (IsRuleExist) from private:

  https://github.com/thedevsaddam/govalidator/blob/master/utils.go#L20

• Or, we could add a new method like AddCustomRuleOnce() which will internally check if the rule exists in the rulesFuncMap and if it does, skip adding the rule.

• Or, we could introduce a new method called RemoveCustomRule() which will remove an existing rule from the rulesFuncMap and the same rule can be added each time without panicing, even if the rule is request-bound. Because on every request, the rule is being added and destroyed.

this function will help you to convert fasthttp and gofiber context to a http/net request so that fasthttp and gofiber users can also utilize this package