add custom rule messages

aacebo · Oct 7, 2024 · 4859e3a · 4859e3a
1 parent 26708f4
commit 4859e3a
Show file tree

Hide file tree

Showing 21 changed files with 225 additions and 31 deletions.
diff --git a/any.go b/any.go
@@ -13,7 +13,7 @@ type AnySchema struct {
 
 func Any() *AnySchema {
 	self := &AnySchema{[]Rule{}}
-	self.Rule("type", self.Type(), func(value reflect.Value) (any, error) {
+	self.Rule("type", self.Type(), func(rule Rule, value reflect.Value) (any, error) {
 		if !value.IsValid() {
 			return nil, nil
 		}
@@ -38,8 +38,13 @@ func (self *AnySchema) Rule(key string, value any, rule RuleFn) *AnySchema {
 	return self
 }
 
+func (self *AnySchema) Message(message string) *AnySchema {
+	self.rules[len(self.rules)-1].Message = message
+	return self
+}
+
 func (self *AnySchema) Required() *AnySchema {
-	return self.Rule("required", true, func(value reflect.Value) (any, error) {
+	return self.Rule("required", true, func(rule Rule, value reflect.Value) (any, error) {
 		if !value.IsValid() {
 			return nil, errors.New("required")
 		}
@@ -49,7 +54,7 @@ func (self *AnySchema) Required() *AnySchema {
 }
 
 func (self *AnySchema) Enum(values ...any) *AnySchema {
-	return self.Rule("enum", values, func(value reflect.Value) (any, error) {
+	return self.Rule("enum", values, func(rule Rule, value reflect.Value) (any, error) {
 		if !value.IsValid() {
 			return nil, nil
 		}
@@ -86,10 +91,16 @@ func (self AnySchema) validate(key string, value reflect.Value) error {
 			continue
 		}
 
-		v, e := rule.Resolve(value)
+		v, e := rule.Resolve(rule, value)
 
 		if e != nil {
-			err = err.Add(NewError(rule.Key, key, e.Error()))
+			message := e.Error()
+
+			if rule.Message != "" {
+				message = rule.Message
+			}
+
+			err = err.Add(NewError(rule.Key, key, message))
 			continue
 		}
 

diff --git a/any_test.go b/any_test.go
@@ -44,6 +44,24 @@ func Test_Any(t *testing.T) {
 		})
 	})
 
+	t.Run("message", func(t *testing.T) {
+		t.Run("should have custom error message", func(t *testing.T) {
+			err := owl.Any().Required().Message("a test message").Validate(nil)
+
+			if err == nil {
+				t.FailNow()
+			}
+
+			if err.Error() != `{"errors":[{"rule":"required","message":"a test message"}]}` {
+				t.Errorf(
+					"expected `%s`, received `%s`",
+					`{"errors":[{"rule":"required","message":"required"}]}`,
+					err.Error(),
+				)
+			}
+		})
+	})
+
 	t.Run("json", func(t *testing.T) {
 		t.Run("serialize", func(t *testing.T) {
 			schema := owl.Any().Enum(1, true, "hi").Required()

diff --git a/bool.go b/bool.go
@@ -12,7 +12,7 @@ type BoolSchema struct {
 
 func Bool() *BoolSchema {
 	self := &BoolSchema{Any()}
-	self.Rule("type", self.Type(), func(value reflect.Value) (any, error) {
+	self.Rule("type", self.Type(), func(rule Rule, value reflect.Value) (any, error) {
 		if !value.IsValid() {
 			return nil, nil
 		}
@@ -36,6 +36,11 @@ func (self *BoolSchema) Rule(key string, value any, rule RuleFn) *BoolSchema {
 	return self
 }
 
+func (self *BoolSchema) Message(message string) *BoolSchema {
+	self.schema.Message(message)
+	return self
+}
+
 func (self *BoolSchema) Required() *BoolSchema {
 	self.schema.Required()
 	return self

diff --git a/bool_test.go b/bool_test.go
@@ -44,6 +44,24 @@ func Test_Bool(t *testing.T) {
 		})
 	})
 
+	t.Run("message", func(t *testing.T) {
+		t.Run("should have custom error message", func(t *testing.T) {
+			err := owl.Bool().Required().Message("a test message").Validate(nil)
+
+			if err == nil {
+				t.FailNow()
+			}
+
+			if err.Error() != `{"errors":[{"rule":"required","message":"a test message"}]}` {
+				t.Errorf(
+					"expected `%s`, received `%s`",
+					`{"errors":[{"rule":"required","message":"required"}]}`,
+					err.Error(),
+				)
+			}
+		})
+	})
+
 	t.Run("json", func(t *testing.T) {
 		t.Run("serialize", func(t *testing.T) {
 			schema := owl.Bool()

diff --git a/error.go b/error.go
@@ -19,7 +19,7 @@ func NewError(rule string, key string, message string) Error {
 }
 
 func (self Error) Error() string {
-	b, _ := json.MarshalIndent(self, "", "  ")
+	b, _ := json.Marshal(self)
 	return string(b)
 }
 

diff --git a/error_group.go b/error_group.go
@@ -20,7 +20,7 @@ func (self ErrorGroup) Add(err error) ErrorGroup {
 }
 
 func (self ErrorGroup) Error() string {
-	b, _ := json.MarshalIndent(self, "", "  ")
+	b, _ := json.Marshal(self)
 	return string(b)
 }
 

diff --git a/error_group_test.go b/error_group_test.go
@@ -23,10 +23,10 @@ func Test_ErrorGroup(t *testing.T) {
 			t.FailNow()
 		}
 
-		if len(err.Error()) != 507 {
+		if len(err.Error()) != 238 {
 			t.Errorf(
 				"expected `%d`, received `%d`",
-				507,
+				238,
 				len(err.Error()),
 			)
 		}

diff --git a/error_test.go b/error_test.go
@@ -15,10 +15,10 @@ func Test_Error(t *testing.T) {
 			t.FailNow()
 		}
 
-		if len(err.Error()) != 91 {
+		if len(err.Error()) != 57 {
 			t.Errorf(
 				"expected `%d`, received `%d`",
-				91,
+				57,
 				len(err.Error()),
 			)
 		}

diff --git a/float.go b/float.go
@@ -13,7 +13,7 @@ type FloatSchema struct {
 
 func Float() *FloatSchema {
 	self := &FloatSchema{Any()}
-	self.Rule("type", self.Type(), func(value reflect.Value) (any, error) {
+	self.Rule("type", self.Type(), func(rule Rule, value reflect.Value) (any, error) {
 		if !value.IsValid() {
 			return nil, nil
 		}
@@ -41,6 +41,11 @@ func (self *FloatSchema) Rule(key string, value any, rule RuleFn) *FloatSchema {
 	return self
 }
 
+func (self *FloatSchema) Message(message string) *FloatSchema {
+	self.schema.Message(message)
+	return self
+}
+
 func (self *FloatSchema) Required() *FloatSchema {
 	self.schema.Required()
 	return self
@@ -58,7 +63,7 @@ func (self *FloatSchema) Enum(values ...float64) *FloatSchema {
 }
 
 func (self *FloatSchema) Min(min float64) *FloatSchema {
-	return self.Rule("min", min, func(value reflect.Value) (any, error) {
+	return self.Rule("min", min, func(rule Rule, value reflect.Value) (any, error) {
 		if !value.IsValid() {
 			return nil, nil
 		}
@@ -72,7 +77,7 @@ func (self *FloatSchema) Min(min float64) *FloatSchema {
 }
 
 func (self *FloatSchema) Max(max float64) *FloatSchema {
-	return self.Rule("max", max, func(value reflect.Value) (any, error) {
+	return self.Rule("max", max, func(rule Rule, value reflect.Value) (any, error) {
 		if !value.IsValid() {
 			return nil, nil
 		}

diff --git a/float_test.go b/float_test.go
@@ -44,6 +44,24 @@ func Test_Float(t *testing.T) {
 		})
 	})
 
+	t.Run("message", func(t *testing.T) {
+		t.Run("should have custom error message", func(t *testing.T) {
+			err := owl.Float().Required().Message("a test message").Validate(nil)
+
+			if err == nil {
+				t.FailNow()
+			}
+
+			if err.Error() != `{"errors":[{"rule":"required","message":"a test message"}]}` {
+				t.Errorf(
+					"expected `%s`, received `%s`",
+					`{"errors":[{"rule":"required","message":"required"}]}`,
+					err.Error(),
+				)
+			}
+		})
+	})
+
 	t.Run("type", func(t *testing.T) {
 		t.Run("should succeed when float", func(t *testing.T) {
 			err := owl.Float().Validate(1.5)

diff --git a/int.go b/int.go
@@ -13,7 +13,7 @@ type IntSchema struct {
 
 func Int() *IntSchema {
 	self := &IntSchema{Any()}
-	self.Rule("type", self.Type(), func(value reflect.Value) (any, error) {
+	self.Rule("type", self.Type(), func(rule Rule, value reflect.Value) (any, error) {
 		if !value.IsValid() {
 			return nil, nil
 		}
@@ -41,6 +41,11 @@ func (self *IntSchema) Rule(key string, value any, rule RuleFn) *IntSchema {
 	return self
 }
 
+func (self *IntSchema) Message(message string) *IntSchema {
+	self.schema.Message(message)
+	return self
+}
+
 func (self *IntSchema) Required() *IntSchema {
 	self.schema.Required()
 	return self
@@ -58,7 +63,7 @@ func (self *IntSchema) Enum(values ...int) *IntSchema {
 }
 
 func (self *IntSchema) Min(min int) *IntSchema {
-	return self.Rule("min", min, func(value reflect.Value) (any, error) {
+	return self.Rule("min", min, func(rule Rule, value reflect.Value) (any, error) {
 		if !value.IsValid() {
 			return nil, nil
 		}
@@ -72,7 +77,7 @@ func (self *IntSchema) Min(min int) *IntSchema {
 }
 
 func (self *IntSchema) Max(max int) *IntSchema {
-	return self.Rule("max", max, func(value reflect.Value) (any, error) {
+	return self.Rule("max", max, func(rule Rule, value reflect.Value) (any, error) {
 		if !value.IsValid() {
 			return nil, nil
 		}

diff --git a/int_test.go b/int_test.go
@@ -44,6 +44,24 @@ func Test_Int(t *testing.T) {
 		})
 	})
 
+	t.Run("message", func(t *testing.T) {
+		t.Run("should have custom error message", func(t *testing.T) {
+			err := owl.Int().Required().Message("a test message").Validate(nil)
+
+			if err == nil {
+				t.FailNow()
+			}
+
+			if err.Error() != `{"errors":[{"rule":"required","message":"a test message"}]}` {
+				t.Errorf(
+					"expected `%s`, received `%s`",
+					`{"errors":[{"rule":"required","message":"required"}]}`,
+					err.Error(),
+				)
+			}
+		})
+	})
+
 	t.Run("min", func(t *testing.T) {
 		t.Run("should succeed when nil", func(t *testing.T) {
 			err := owl.Int().Min(5).Validate(nil)

diff --git a/object.go b/object.go
@@ -14,7 +14,7 @@ type ObjectSchema struct {
 func Object() *ObjectSchema {
 	self := &ObjectSchema{Any(), map[string]Schema{}}
 	self.Rule("fields", self.fields, nil)
-	self.Rule("type", self.Type(), func(value reflect.Value) (any, error) {
+	self.Rule("type", self.Type(), func(rule Rule, value reflect.Value) (any, error) {
 		if !value.IsValid() {
 			return nil, nil
 		}
@@ -38,6 +38,11 @@ func (self *ObjectSchema) Rule(key string, value any, rule RuleFn) *ObjectSchema
 	return self
 }
 
+func (self *ObjectSchema) Message(message string) *ObjectSchema {
+	self.schema.Message(message)
+	return self
+}
+
 func (self *ObjectSchema) Required() *ObjectSchema {
 	self.schema.Required()
 	return self

diff --git a/object_test.go b/object_test.go
@@ -51,6 +51,24 @@ func Test_Object(t *testing.T) {
 		})
 	})
 
+	t.Run("message", func(t *testing.T) {
+		t.Run("should have custom error message", func(t *testing.T) {
+			err := owl.Object().Required().Message("a test message").Validate(nil)
+
+			if err == nil {
+				t.FailNow()
+			}
+
+			if err.Error() != `{"errors":[{"rule":"required","message":"a test message"}]}` {
+				t.Errorf(
+					"expected `%s`, received `%s`",
+					`{"errors":[{"rule":"required","message":"required"}]}`,
+					err.Error(),
+				)
+			}
+		})
+	})
+
 	t.Run("map", func(t *testing.T) {
 		t.Run("should succeed", func(t *testing.T) {
 			err := owl.Object().Field(

diff --git a/rule.go b/rule.go
@@ -5,7 +5,8 @@ import "reflect"
 type Rule struct {
 	Key     string `json:"key"`
 	Value   any    `json:"value"`
+	Message string `json:"message"`
 	Resolve RuleFn `json:"-"`
 }
 
-type RuleFn func(value reflect.Value) (any, error)
+type RuleFn func(rule Rule, value reflect.Value) (any, error)