strong-typed schema struct generation

[gm0stache]

hi there!
cool project!
are there any plans to support the generation of strong-typed schema structs?

[Oudwins]

Sorry but I'm not sure what you mean exactly. Could you elaborate and maybe give an example

[gm0stache]

@Oudwins sorry, sure!

• the readme contains an example in step 2, where you create a schema like this:

type User struct {
  Name string
  Age int
}

var userSchema = z.Struct(z.Schema{
  // its very important that schema keys like "name" match the struct field name NOT the input data
  "name": z.String().Min(3, z.Message("Override default message")).Max(10),
  "age": z.Int().GT(18).Required(z.Message("is required")),
})

• as already alluded within the docs, the error-prone part here is the linking between the schema and the struct fields by plain structs.
• i would love to be able to do this:

//go:generate go run github.com/Oudwins/zog . User
type User struct {
  Name string
  Age int
}

• the result of the generation should be a UserSchema struct with strong-typed fields where each field has the same name as the original struct, but a type of Schema

=> i know this all sound very vage, but i will hack on this this weekend and get back to you next week!

[Oudwins]

@gm0stache This is very interesting. I'm curious how this would work if ran after the schema is already defined (i.e runs the second time). I imagine you just nope out if it already exists. But if you want to support this working when you add a field you would have to check all the fields. If you come up with a prototype for this I would love to see it and would be 100% open to merging something like this.

Something that is similar which is already in the roadmap, is schema -> struct generation. Do you feel like struct -> schema is more interesting?

For example the idea is:

// file: schemas.go

// some go generate comment here
var UserSchema = z.Struct(
 "username": z.String(),
 'password": z.String(),
)

// file: schemas.struct.go
type User struct {
 Username string
 Password string
}

have a look at this -> #67
for some more thoughts on this approach

[gm0stache]

I'm curious how this would work if ran after the schema is already defined (i.e runs the second time)

it would simply be replaced then!

But if you want to support this working when you add a field you would have to check all the fields.

if you manipulate the struct, you would simply re-generate the schema struct again. then they are synced again. that the common workflow when working which generated-types derived from a predefined struct/interface.

Something that is similar which is already in the roadmap, is schema -> struct generation. Do you feel like struct -> schema is more interesting?

uh! haven't even thought about that! but intuitively i would say that i would always prefer the struct -> schema workflow, since writing go structs + calling methods is a way more pleasant (aka. IDE supported) way to define what i want (aka. the schema), than directly writing schemas in JSON/YAML without proper editor assistance etc. could be only me though 😇

finally: as said, i will look into my idea here this weekend and get back to you next week! thanks for the fast responses! highly appreciate it!!!

[Oudwins]

I think we are not understanding each other. There is no plan to write schemas in JSON/YAML. Let me try to clarify:

This is what I understood you meant. Which I am now thinking might not be what you were suggesting

// in a file I write:
type User struct {
 Name string
 CreatedAt time.Time
}

// go generate creates the skeleton for the schema
var UserSchema = z.Struct(z.Schema{
"name": z.String(),
"createdAt": z.Time(),
})

// But then I have to edit that schema with the tests/validations I want.
var UserSchema = z.Struct(z.Schema{
"name": z.String().Min(3).Required(),
"createdAt": z.Time().After(...).Required(),
})
/*
Meaning this approach only ensures that the names of the fields in the schema and the struct match
*/

This is what I want to implement in the future but haven't started looking into it

// in a file I write
var UserSchema = z.Struct(z.Schema{
"name": z.String().Min(3).Required(),
"createdAt": z.Time().After(...).Required(),
})

// go generate creates the struct instead
type User struct {
 Name string
 CreatedAt time.Time
}

/*
This way I don't have to touch the generated code. However, this has some issues:
- You cannot have fields in the struct that will not be validated
- We need to figure out a way of defining struct tags in the schema
*/

I hope that is clearer

[gm0stache]

ahhh, ok! now i get it!
cool idea too!
we indeed were talking past each other .XD
thanks for clarifying!