z.Any() type proposition

[udfordria]

Hello,

I would to know if there is a way to add z.any() that matches with everything in zog.

Piece of a code that matches my need :

package zog

import (
	"reflect"

	"github.com/Oudwins/zog/conf"
	p "github.com/Oudwins/zog/internals"
	"github.com/Oudwins/zog/zconst"
)

var _ ComplexZogSchema = &AnySchema{}

type AnySchema struct {
}

func (v *AnySchema) getType() zconst.ZogType {
	return zconst.TypePtr
}

func (v *AnySchema) setCoercer(c conf.CoercerFunc) {
}

// Any creates a Any ZogSchema
func Any() *AnySchema {
	return &AnySchema{}
}

// Parse the data into the destination Any
func (v *AnySchema) Parse(data any, dest any, options ...ExecOption) p.ZogIssueMap {
	errs := p.NewErrsMap()
	defer errs.Free()
	ctx := p.NewExecCtx(errs, conf.IssueFormatter)
	defer ctx.Free()
	for _, opt := range options {
		opt(ctx)
	}
	path := p.NewPathBuilder()
	defer path.Free()
	v.process(ctx.NewSchemaCtx(data, dest, path, v.getType()))

	return errs.M
}

func (v *AnySchema) process(ctx *p.SchemaCtx) {
	d := reflect.ValueOf(ctx.Val)
	if !d.IsValid() {
		return
	}

	k := d.Kind()
	if (k == reflect.Ptr || k == reflect.Slice || k == reflect.Map || k == reflect.Chan) && d.IsNil() {
		return
	}

	rv := reflect.ValueOf(ctx.DestPtr)
	rv.Elem().Set(d)
}

// Validates a Any Any
func (v *AnySchema) Validate(data any, options ...ExecOption) p.ZogIssueMap {
	errs := p.NewErrsMap()
	defer errs.Free()
	ctx := p.NewExecCtx(errs, conf.IssueFormatter)
	defer ctx.Free()
	for _, opt := range options {
		opt(ctx)
	}
	path := p.NewPathBuilder()
	defer path.Free()
	v.validate(ctx.NewValidateSchemaCtx(data, path, v.getType()))
	return errs.M
}

func (v *AnySchema) validate(ctx *p.SchemaCtx) {
}

// Validate Existing Any

[Oudwins]

Interesting. I have thought about it before. But I'm curious what you need this for? What is the use case?

[udfordria]

It is useful in this scenario :

type Step[A any] struct {
	Name    string
	Payload A
}

type TestGenericsPayload struct {
	Steps []Step[any]
}

var StepZog = z.Struct(z.Schema{
	"name":    z.String().Required(),
	"payload": z.Any(),
})

var TestGenericsPayloadSchema = z.Schema{
	"steps": z.Slice(StepZog),
}

[Oudwins]

OK I see it but if you don't mind could you explain exactly what you are doing so I can better understand it? It will help me thinknof other possible ways of getting what you want before we settle on z.Any. Also what validation so you want to do with the payload?

[udfordria]

{"steps":[{"name":"foo","payload":11},{"name":"bar","payload":"cool"}]}

type StepFoo struct {
	Name    string // = "foo"
	Payload int
}

type StepBar struct {
	Name    string // = "bar"
	Payload string
}

type TestGenericsPayload struct {
	Steps [](StepFoo|StepBar)
}

var StepZog = z.Struct(z.Schema{
	"name":    z.String().Required(),
	"payload": z.Any(),
})

var TestGenericsPayloadSchema = z.Schema{
	"steps": z.Slice(StepZog),
}

[Oudwins]

So if I understand you correctly. This is about a payload that can be 2 different types and you would want to do something like this (this is just an example not actually valid zog atm):

var StepZog = z.Struct(z.Schema{
	"name":    z.String().Required(),
	"payload": z.Any().TestFunc(func(val any, ctx z.Ctx) {
            switch v := val.(type) {
                case *MyCustomStruct1:
                       return MyCustomStruct1Schema.Validate(v)
                case *MyCustomStruct2:
                       return MyCustomStruct2Schema.Validate(v)
}
 },
})

Is this sort of the idea you are going for? Because if you didn't want to validate the payload you can just not add it to the schema and zog will ignore it and that is fine. So something else you could do as of right now is:

type StepFoo struct {
	Name    string // = "foo"
	Payload int
}

type StepBar struct {
	Name    string // = "bar"
	Payload string
}

type TestGenericsPayload struct {
	Steps [](StepFoo|StepBar)
}

var StepZog = z.Struct(z.Schema{
	"name":    z.String().Required(),
})

var StepBarZog =StepZog.Extend(z.Schema{
	"payload":    z.String().Required(),
})

switch v := step.(type) {
     case StepBar:
            StepBarZog.Validate(&v)
}

var TestGenericsPayloadSchema = z.Schema{
	"steps": z.Slice(StepZog),
}

[udfordria]

Looks better but in my case:

• Payload is always an int when Name is equal to "foo"
• Payload is always a string when Name is equal to "bar"

var StepZog = z.Struct(z.Schema{
	"name":    z.String().Required(),
	"payload": z.Any().TestFunc(func(val any, ctx z.Ctx) {
            switch v := val.(type) {
                case *MyCustomStruct1:
                       return MyCustomStruct1Schema.Validate(v)
                case *MyCustomStruct2:
                       return MyCustomStruct2Schema.Validate(v)
}
 },
})

⬆️ This code doesn't validate Payload based on Name.

[Oudwins]

Understood. For what you want you could do this:

var StepZog = z.Struct(z.Schema{
	"name":    z.String().Required(),
 },
}).TestFunc(func(val any, ctx z.Ctx) bool {
   stepAny := val.(*StepAny)
   // manually check each field
}, z.IssuePath("payload"), z.Message("MyCustom message"))

edit obviously this only works if you are using validate and not parse. For parse you are right that we would need to implement z.Any()

[Oudwins]

Although we might still implement z.Any() schema. It is much more likely that these APIs will be released first (#132) and they could also help you achieve this, it would just mean extra work on your end