Как разработать веб-приложение уровня Enterprise Application с нуля. Часть 3

			package validator

import (
    "context"
    "github.com/go-playground/validator/v10"
    "google.golang.org/protobuf/reflect/protoreflect"
)

var (
    validate = validator.New()
)

// конкретная реализация для какого либо типа данных запроса
type Validator interface {
    Validate(ctx context.Context, value protoreflect.Value) error
}

// структура, позволяющая описывать валидаторы для всего запроса
type Form map[string]Validator

func (f Form) Validate(ctx context.Context, message protoreflect.Message) error {
    fields := message.Descriptor().Fields()
    for i := 0; i < fields.Len(); i++ {
        field := fields.Get(i)
        v, ok := f[string(field.Name())]
        if !ok {
            continue
        }

        err := v.Validate(ctx, message.Get(field))
        if err != nil {
            return err
        }
    }

    return nil
}
		

			package validator

import (
    "context"
    "fmt"
    "google.golang.org/protobuf/reflect/protoreflect"
)

func NewString(condition string) Validator {
    return &stringValidator{
        condition: condition,
    }
}

func NewUUID() Validator {
    return NewString("uuid4")
}

func NewPhoneNumber() Validator {
    return NewString("e164")
}

func NewStringWithMaxLen(l int) Validator {
    return NewString(fmt.Sprintf("required,max=%d", l))
}

func NewReqString() Validator {
    return NewString("required")
}

func NewAlphanumeric() Validator {
    return NewString("alphanum")
}

type stringValidator struct {
    condition string
}

func (v stringValidator) Validate(ctx context.Context, value protoreflect.Value) error {
    return validate.VarCtx(ctx, value.String(), v.condition)
}
		

			package validator_test

import (
    "context"
    "github.com/Pallinder/go-randomdata"
    "github.com/byorty/enterprise-application/pkg/common/adapter/validator"
    "github.com/google/uuid"
    "github.com/stretchr/testify/suite"
    "google.golang.org/protobuf/reflect/protoreflect"
    "testing"
)

func TestStringValidatorSuite(t *testing.T) {
    suite.Run(t, new(StringValidatorSuite))
}

type StringValidatorSuite struct {
    suite.Suite
}

func (s *StringValidatorSuite) TestUUID() {
    v := validator.NewUUID()
    s.NotNil(v.Validate(context.Background(), protoreflect.ValueOf("")))
    s.NotNil(v.Validate(context.Background(), protoreflect.ValueOf(randomdata.Alphanumeric(32))))
    s.Nil(v.Validate(context.Background(), protoreflect.ValueOf(uuid.NewString())))
}

func (s *StringValidatorSuite) TestPhoneNumber() {
    v := validator.NewPhoneNumber()
    s.NotNil(v.Validate(context.Background(), protoreflect.ValueOf("")))
    s.NotNil(v.Validate(context.Background(), protoreflect.ValueOf(randomdata.Alphanumeric(32))))
    s.Nil(v.Validate(context.Background(), protoreflect.ValueOf("+79008007060")))
}

func (s *StringValidatorSuite) TestMaxLen() {
    v := validator.NewStringWithMaxLen(10)
    s.NotNil(v.Validate(context.Background(), protoreflect.ValueOf("")))
    s.NotNil(v.Validate(context.Background(), protoreflect.ValueOf(randomdata.Alphanumeric(32))))
    s.Nil(v.Validate(context.Background(), protoreflect.ValueOf(randomdata.Alphanumeric(9))))
}

func (s *StringValidatorSuite) TestAlphanumeric() {
    v := validator.NewAlphanumeric()
    s.NotNil(v.Validate(context.Background(), protoreflect.ValueOf("")))
    s.NotNil(v.Validate(context.Background(), protoreflect.ValueOf("qazwsx!@#%%^")))
    s.Nil(v.Validate(context.Background(), protoreflect.ValueOf(randomdata.Alphanumeric(32))))
}
		

			type MethodDescriptor struct {
    …
    Form validator.Form
}
		

			package grpc_option

import (
    "context"
    "github.com/byorty/enterprise-application/pkg/common/adapter/server/grpc"
    gRPC "google.golang.org/grpc"
    "google.golang.org/protobuf/reflect/protoreflect"
)

func NewFxValidatorOption(
    methodDescriptorMap grpc.MethodDescriptorMap,
) grpc.MiddlewareOut {
    return grpc.MiddlewareOut{
        GrpcMiddleware: grpc.Middleware{
            Priority: 97,
            GrpcOption: func(ctx context.Context, req interface{}, info *gRPC.UnaryServerInfo, handler gRPC.UnaryHandler) (resp interface{}, err error) {
                protoMessage, ok := req.(protoreflect.ProtoMessage)
                if !ok {
                    return handler(ctx, req)
                }

                methodDescriptor, ok := methodDescriptorMap.GetByFullName(info.FullMethod)
                if !ok {
                    return handler(ctx, req)
                }

                if len(methodDescriptor.Form) == 0 {
                    return handler(ctx, req)
                }

                err = methodDescriptor.Form.Validate(ctx, protoMessage.ProtoReflect())
                if err != nil {
                    return nil, grpc.ErrInvalidArgument(err)
                }

                return handler(ctx, req)
            },
        },
    }
}
		

			package form

import "github.com/byorty/enterprise-application/pkg/common/adapter/validator"

var (
    CreateOrder = validator.Form{
        // идентификатором пользователя должен быть UUID v4
        "user_uuid": validator.NewUUID(),
        // параметрами запроса должнобыть сообщение
        "params": validator.NewMessage(validator.Form{
            // массив продуктов должен иметь хотя бы один элемент
            "products": validator.NewReqList(
                // элементом массива должно быть сообщение
                validator.NewMessage(validator.Form{
                    // идентификатором продукта должен быть UUID v4
                    "product_uuid": validator.NewUUID(),
                    // пользователь должен добавить в заказ хотя бы одну единицу продукта
                    "count":  validator.NewUint32Min(1),
                }),
            ),
            // любая строка не длиннее 255-ти символов
            "address":      validator.NewStringWithMaxLen(255),
            // дата равная текущей + двое суток
            "delivered_at": validator.NewDeliveredAt(),
        }),
    }
)
		

			make up