gem-hunter

Note

This package is mostly unmaintained, if you're a fan of Go, codegen and Zod then check out Schemancer:

https://github.com/Southclaws/schemancer

Schemancer takes a different approach where your shared data structures' source of truth is not code, but JSON Schemas, from which you can generate Go structs and TypeScript Zod schemas.

Plus, Schemancer also supports discriminated unions which this package does not, as well as other features not as easy to express via Go structs alone.

Supervillain

type Post struct {
    Title string
}
type User struct {
    Name   string
    Nickname *string // pointers become optional
    Age    int
    Height float64
    Tags []string
    Favourites []struct { // nested structs are kept inline
        Name string
    }
    Posts []Post // external structs are emitted as separate exports
}

StructToZodSchema(User{})

export const PostSchema = z.object({
  title: z.string(),
});
export type Post = z.infer<typeof PostSchema>;

export const UserSchema = z.object({
  name: z.string(),
  nickname: z.string().optional(),
  age: z.number(),
  height: z.number(),
  tags: z.string().array(),
  favourites: z
    .object({
      name: z.string(),
    })
    .array(),
  posts: PostSchema.array(),
});
export type User = z.infer<typeof UserSchema>;

Custom Types

Skipping fields

package main

import (
	"fmt"
)

type BaseType struct {
	ID    string `json:"id"`
	Name  string `json:"name"`
	Start int    `json:"start"`
	End   int    `json:"end"`
}

type FinalType struct {
	Start    int `json:"-start"`
	End      int `json:"-end"`
	BaseType `json:",inline"`
}

func main() {
	fmt.Println(StructToZodSchema(FinalType{}))

	// export const FinalTypeSchema = z.object({
	//   id: z.string(),
	//   name: z.string(),
	// })
	// export type FinalType = z.infer<typeof FinalTypeSchema>
}

ZodSchema() method

ZodSchema() string
ZodSchema(c *supervillain.Converter, t reflect.Type, name, generic string, indent int) string
ZodSchema(convert func(t reflect.Type, name string, indent int) string, t reflect.Type, name, generic string, indent int) string

type State int

func (s State) MarshalJSON() ([]byte, error) {
  return json.Marshal(fmt.Sprint(s))
}

func (s State) ZodSchema() string {
  return "z.string()"
}

type Job struct {
  State State
}

c.Convert(Job{})

export const JobSchema = z.object({
  State: z.string(),
})
export type Job = z.infer<typeof JobSchema>

Mapping

c := supervillain.NewConverter(map[string]supervillain.CustomFn{
    "github.com/shopspring/decimal.Decimal": func(c *supervillain.Converter, t reflect.Type, s, g string, i int) string {
        // Shopspring's decimal type serialises to a string.
        return "z.string()"
    },
})

c.Convert(User{
    Money decimal.Decimal
})

export const UserSchema = z.object({
  Money: z.string(),
})
export type User = z.infer<typeof UserSchema>

func(c *supervillain.Converter, t reflect.Type, typeName, genericTypeName string, indentLevel int) string

Custom Schema Enforcement

c := NewConverter(map[string]CustomFn{}, WithStrictCustomSchemas(true))
// or
StructToZodSchema(User{}, WithStrictCustomSchemas(true))

Caveats