Rex Validation Extension (rextension-validation)

Overview

Installation

go get github.com/kryovyx/rextension-validation

Quick Start

package main
import (
 "net/http"
 "github.com/kryovyx/rex"
 "github.com/kryovyx/rex/route"
 validation "github.com/kryovyx/rextension-validation"
)
// CreateUserRequest is the expected request body.
type CreateUserRequest struct {
 Name string `json:"name" validate:"required,min=2"`
 Email string `json:"email" validate:"required,email"`
}
// CreateUserResponse is the response body.
type CreateUserResponse struct {
 ID int `json:"id"`
 Name string `json:"name"`
 Email string `json:"email"`
}
// CreateUserRoute implements both route.Route and ValidatableRoute.
type CreateUserRoute struct {
 route.Route
}
func (r *CreateUserRoute) RequestBody() validation.BodySchema {
 return validation.Scalar(CreateUserRequest{})
}
func (r *CreateUserRoute) Responses() map[int]validation.BodySchema {
 return map[int]validation.BodySchema{
 201: validation.Scalar(CreateUserResponse{}),
 }
}
func main() {
 app := rex.New()
 // Add the validation extension
 app.WithOptions(
 validation.WithValidation(nil),
 )
 // Register a validated route
 app.RegisterRoute(&CreateUserRoute{
 Route: route.New("POST", "/users", func(ctx route.Context) {
 body, ok := validation.GetRequestBody[CreateUserRequest](ctx.Request())
 if !ok {
 ctx.Text(http.StatusBadRequest, "missing body")
 return
 }
 resp := CreateUserResponse{ID: 1, Name: body.Name, Email: body.Email}
 codec := validation.GetAcceptCodec(ctx.Request())
 data, _ := codec.Marshal(resp)
 ctx.Respond(http.StatusCreated, codec.ContentType(), data)
 }),
 })
 if err := app.Run(); err != nil {
 panic(err)
 }
}

Core Concepts

Codecs

// The Codec interface
type Codec interface {
 ContentType() string // e.g., "application/json"
 Marshal(v interface{}) ([]byte, error) // Serialize
 Unmarshal(data []byte, v interface{}) error // Deserialize
}

validation.WithValidation(validation.NewConfig(
 validation.WithCodec(myXMLCodec),
 validation.WithCodec(myYAMLCodec),
))

Content Negotiation

Body Schemas

// Single type
validation.Scalar(CreateUserRequest{})
// Exactly one must match
validation.OneOf(AdminRequest{}, UserRequest{})
// Any may match
validation.AnyOf(JSONPayload{}, XMLPayload{})
// All must match (merged fields)
validation.AllOf(BaseRequest{}, ExtendedFields{})

Validation

type CreateUserRequest struct {
 Name string `json:"name" validate:"required,min=2,max=100"`
 Email string `json:"email" validate:"required,email"`
 Age int `json:"age" validate:"omitempty,gte=0,lte=150"`
}

ValidatableRoute Interface

type ValidatableRoute interface {
 // RequestBody returns the body schema for the request, or nil to skip.
 RequestBody() BodySchema
 // Responses returns a map of HTTP status code → body schema.
 // Return nil to skip response validation.
 Responses() map[int]BodySchema
}

func (r *GetUserRoute) RequestBody() validation.BodySchema {
 return nil // GET — no request body
}
func (r *GetUserRoute) Responses() map[int]validation.BodySchema {
 return map[int]validation.BodySchema{
 200: validation.Scalar(UserResponse{}),
 404: validation.Scalar(ErrorResponse{}),
 }
}

Context Helpers

GetRequestBody

body, ok := validation.GetRequestBody[CreateUserRequest](ctx.Request())
if !ok {
 // No decoded body — route may not implement ValidatableRoute
}

GetAcceptCodec

codec := validation.GetAcceptCodec(ctx.Request())
if codec != nil {
 data, _ := codec.Marshal(response)
 ctx.Respond(http.StatusOK, codec.ContentType(), data)
}

Response Validation

Strict Mode

validation.WithValidation(validation.NewConfig(
 validation.WithStrictResponses(true),
))

validation.WithValidation(validation.NewConfig(
 validation.WithValidateResponses(false),
))

Configuration Reference

Config Struct

Functional Options

cfg := validation.NewConfig(
 validation.WithCodec(myXMLCodec),
 validation.WithStrictResponses(true),
 validation.WithValidateResponses(true),
)
app.WithOptions(validation.WithValidation(cfg))

Custom Codec Example (XML)

package main
import "encoding/xml"
// XMLCodec handles application/xml.
type XMLCodec struct{}
func (XMLCodec) ContentType() string { return "application/xml" }
func (XMLCodec) Marshal(v interface{}) ([]byte, error) { return xml.Marshal(v) }
func (XMLCodec) Unmarshal(data []byte, v interface{}) error { return xml.Unmarshal(data, v) }

validation.WithValidation(validation.NewConfig(
 validation.WithCodec(XMLCodec{}),
))

Error Responses

{
 "status": 422,
 "message": "Validation failed",
 "errors": [
 {
 "field": "Name",
 "tag": "required",
 "value": "",
 "message": "field 'Name' failed on the 'required' tag"
 },
 {
 "field": "Email",
 "tag": "email",
 "value": "not-an-email",
 "message": "field 'Email' failed on the 'email' tag"
 }
 ]
}

type ValidationError struct {
 Field string `json:"field"`
 Tag string `json:"tag"`
 Value string `json:"value,omitempty"`
 Message string `json:"message"`
}
type ValidationErrorResponse struct {
 Status int `json:"status"`
 Message string `json:"message"`
 Errors []ValidationError `json:"errors"`
}

Best Practices

Upgrading

Contributing

License

Copyright