zog

package module
v0.19.2 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Apr 18, 2025 License: MIT Imports: 11 Imported by: 6

README

ZOG - A Zod & Yup like Schema Parser & Validator for GO

Coverage Status Go Report Card GitHub tag Go Reference

Mentioned in Awesome Go Mentioned in Awesome Templ stars - zog

view - Documentation

Zog is a schema builder for runtime value parsing and validation. Define a schema, transform a value to match, assert the shape of an existing value, or both. Zog schemas are extremely expressive and allow modeling complex, interdependent validations, or value transformations.

Killer Features:

  • Concise yet expressive schema interface, equipped to model simple to complex data models
  • Zod-like API, use method chaining to build schemas in a typesafe manner
  • Extensible: add your own Tests and Schemas
  • Rich errors with detailed context, make debugging a breeze
  • Fast: Zog is one of the fastest Go validation libraries. We are just behind the goplayground/validator for most of the govalidbench benchmarks.
  • Built-in coercion support for most types
  • Zero dependencies!
  • Four Helper Packages
    • zenv: parse environment variables
    • zhttp: parse http forms & query params
    • zjson: parse json
    • i18n: Opinionated solution to good i18n zog errors

API Stability:

  • I will consider the API stable when we reach v1.0.0
  • However, I believe very little API changes will happen from the current implementation. The APIs most likely to change are the data providers (please don't make your own if possible use the helpers whose APIs will not change meaningfully) and the z.Ctx most other APIs should remain the same. I could be wrong but I don't expect many breaking changes.
  • Although we want to keep breaking changes to a minimum, Zog is still in version 0 and will have breaking changes in the minor versions as per semver. So please be careful when upgrading minor versions.

Introduction

0. Read the docs at zog.dev

Or don't, below is the quickstart guide

1 Install
go get github.com/Oudwins/zog
2 Create a user schema and its struct
import (
	z "github.com/Oudwins/zog"
)

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),
})
3 Validate your schema

Using schema.Parse()

func main() {
	u := User{}
	m := map[string]string{
		"name": "Zog",
		"age":       "",    // won't return an error because fields are optional by default
	}
	errsMap := userSchema.Parse(m, &u)
	if errsMap != nil {
		// handle errors -> see Errors section
	}
	u.Name // "Zog"
	// note that this might look weird but we didn't say age was required so Zog just skipped the empty string and we are left with the uninitialized int
	// If we need 0 to be a valid value for age we can use a pointer to an int which will be nil if the value was not present in the input data
	u.Age // 0
}

Using schema.Validate()

func main() {
	u := User{
		Name: "Zog",
		Age:  0, // wont return an error because fields are optional by default otherwise it will error
	}
	errsMap := userSchema.Validate(&u)
	if errsMap != nil {
		// handle errors -> see Errors section
	}
}
4. Its easy to use with http & json

The zhttp package has you covered for JSON, Forms and Query Params, just do:

import (
	zhttp "github.com/Oudwins/zog/zhttp"
)

err := userSchema.Parse(zhttp.Request(r), &user)

If you are receiving json some other way you can use the zjson package

import (
	zjson "github.com/Oudwins/zog/zjson"
)

err := userSchema.Parse(zjson.Decode(bytes.NewReader(jsonBytes)), &user)
5. Or to validate your environment variables

The zenv package has you covered, just do:

import (
	zenv "github.com/Oudwins/zog/zenv"
)

err := envSchema.Parse(zenv.NewDataProvider(), &envs)
6. You can also parse individual fields
var t = time.Time
errsList := Time().Required().Parse("2020-01-01T00:00:00Z", &t)
7 And do stuff before and after parsing
var dest []string
Slice(String().Email().Required()).PreTransform(func(data any, ctx z.Ctx) (any, error) {
	s := data.(string)
	return strings.Split(s, ","), nil
}).PostTransform(func(destPtr any, ctx z.Ctx) error {
	s := destPtr.(*[]string)
	for i, v := range *s {
		(*s)[i] = strings.TrimSpace(v)
	}
	return nil
}).Parse("foo@bar.com,bar@foo.com", &dest) // dest = [foo@bar.com bar@foo.com]

Roadmap

These are some of the things I want to add to zog before v1.0.0

  • Support for schema.Clone()
  • support for catch & default for structs & slices
  • Struct generation from the schemas

Support

The damm domain costs me some outrageous amount like 100$ a year, so if any one wants to help cover that cost through github sponsors that is more than welcome.

Acknowledgments

  • Big thank you to @AlexanderArvidsson for being there to talk about architecture and design decisions. It helped a lot to have someone to bounce ideas off of
  • Credit for all the inspiration goes to /colinhacks/zod & /jquense/yup
  • Credit for the initial idea goes to anthony (@anthonyGG) -> /anthdm/superkit he made a hacky version of this idea that I used as a starting point, I was never happy with it so I inspired me to rewrite it from scratch. I owe him a lot
  • Credit for the zod logo goes to /colinhacks/zod

License

This project is licensed under the MIT License - see the LICENSE file for details.

Documentation

Index

Constants

This section is empty.

Variables

View Source 
var Issues = issueHelpers{}

Functions

This section is empty.

Types

type BoolSchema added in v0.14.1 

type BoolSchema[T ~bool] struct {
	// contains filtered or unexported fields
}

func Bool 

func Bool(opts ...SchemaOption) *BoolSchema[bool]

Returns a new Bool Schema

func (*BoolSchema[T]) Catch added in v0.14.1 

func (v *BoolSchema[T]) Catch(val T) *BoolSchema[T]

sets the catch value (i.e the value to use if the validation fails)

func (*BoolSchema[T]) Default added in v0.14.1 

func (v *BoolSchema[T]) Default(val T) *BoolSchema[T]

sets the default value

func (*BoolSchema[T]) EQ added in v0.18.4 

func (v *BoolSchema[T]) EQ(val T) *BoolSchema[T]

func (*BoolSchema[T]) False added in v0.14.1 

func (v *BoolSchema[T]) False() *BoolSchema[T]

func (*BoolSchema[T]) Optional added in v0.14.1 

func (v *BoolSchema[T]) Optional() *BoolSchema[T]

marks field as optional

func (*BoolSchema[T]) Parse added in v0.14.1 

func (v *BoolSchema[T]) Parse(data any, dest *T, options ...ExecOption) ZogIssueList

Parse data into destination pointer

func (*BoolSchema[T]) PostTransform added in v0.14.1 

func (v *BoolSchema[T]) PostTransform(transform PostTransform) *BoolSchema[T]

Adds posttransform function to schema

func (*BoolSchema[T]) PreTransform added in v0.14.1 

func (v *BoolSchema[T]) PreTransform(transform PreTransform) *BoolSchema[T]

Adds pretransform function to schema

func (*BoolSchema[T]) Required added in v0.14.1 

func (v *BoolSchema[T]) Required(options ...TestOption) *BoolSchema[T]

! MODIFIERS marks field as required

func (*BoolSchema[T]) Test added in v0.16.0 

func (v *BoolSchema[T]) Test(t Test) *BoolSchema[T]

func (*BoolSchema[T]) TestFunc added in v0.16.0 

func (v *BoolSchema[T]) TestFunc(testFunc BoolTFunc, options ...TestOption) *BoolSchema[T]

Create a custom test function for the schema. This is similar to Zod's `.refine()` method.

func (*BoolSchema[T]) True added in v0.14.1 

func (v *BoolSchema[T]) True() *BoolSchema[T]

func (*BoolSchema[T]) Validate added in v0.15.0 

func (v *BoolSchema[T]) Validate(val *T, options ...ExecOption) ZogIssueList

Validate data against schema

type BoolTFunc added in v0.19.0 

type BoolTFunc = p.BoolTFunc

Function signature for bool tests. Takes the value and the context and returns a boolean. This is the function passed to the TestFunc method.

type CoercerFunc added in v0.18.4 

type CoercerFunc = conf.CoercerFunc

type ComplexZogSchema added in v0.14.1 

type ComplexZogSchema interface {
	ZogSchema
	Parse(val any, dest any, options ...ExecOption) ZogIssueMap
}

This is a common interface for all complex schemas (i.e structs, slices, pointers...) You can use this to pass any complex schema around

type Ctx added in v0.15.0 

type Ctx = p.Ctx

This is the context that is passed through an entire execution of `schema.Parse()` or `schema.Validate()`. You can use it to pass a key/value for a specific execution. More about context in the [docs](https://zog.dev/context)

type Custom added in v0.19.1 

type Custom[T any] struct {
	// contains filtered or unexported fields
}

func CustomFunc added in v0.19.1 

func CustomFunc[T any](fn func(ptr *T, ctx Ctx) bool, opts ...TestOption) *Custom[T]

func (*Custom[T]) Parse added in v0.19.1 

func (c *Custom[T]) Parse(data T, destPtr *T, options ...ExecOption) ZogIssueList

func (*Custom[T]) Validate added in v0.19.1 

func (c *Custom[T]) Validate(dataPtr *T, options ...ExecOption) ZogIssueList

type ExecOption added in v0.16.0 

type ExecOption = func(p *p.ExecCtx)

Options that can be passed to a `schema.Parse()` call

func WithCtxValue 

func WithCtxValue(key string, val any) ExecOption

func WithErrFormatter deprecated 

func WithErrFormatter(fmter IssueFmtFunc) ExecOption

Deprecated: use WithIssueFormatter instead Deprecated for naming consistency

func WithIssueFormatter added in v0.16.0 

func WithIssueFormatter(fmter IssueFmtFunc) ExecOption

Sets the issue formatter for the execution context. This is used to format the issues messages during execution. This follows principle of most specific wins. So default formatter < execution formatter < test specific formatter (i.e MessageFunc)

type IssueFmtFunc added in v0.19.0 

type IssueFmtFunc = p.IssueFmtFunc

Function signature for issue formatters. Takes the issue and the context and returns the formatted issue.

type NotStringSchema added in v0.19.2 

type NotStringSchema[T likeString] interface {
	OneOf(enum []T, options ...TestOption) *StringSchema[T]
	Len(n int, options ...TestOption) *StringSchema[T]
	Email(options ...TestOption) *StringSchema[T]
	URL(options ...TestOption) *StringSchema[T]
	HasPrefix(s T, options ...TestOption) *StringSchema[T]
	HasSuffix(s T, options ...TestOption) *StringSchema[T]
	Contains(sub T, options ...TestOption) *StringSchema[T]
	ContainsUpper(options ...TestOption) *StringSchema[T]
	ContainsDigit(options ...TestOption) *StringSchema[T]
	ContainsSpecial(options ...TestOption) *StringSchema[T]
	UUID(options ...TestOption) *StringSchema[T]
	Match(regex *regexp.Regexp, options ...TestOption) *StringSchema[T]
}

type NumberSchema added in v0.14.1 

type NumberSchema[T Numeric] struct {
	// contains filtered or unexported fields
}

func Float deprecated 

func Float(opts ...SchemaOption) *NumberSchema[float64]

Deprecated: Use Float64 instead creates a new float64 schema

func Float32 added in v0.17.0 

func Float32(opts ...SchemaOption) *NumberSchema[float32]

func Float64 added in v0.17.0 

func Float64(opts ...SchemaOption) *NumberSchema[float64]

func Int 

func Int(opts ...SchemaOption) *NumberSchema[int]

creates a new int schema

func Int32 added in v0.17.0 

func Int32(opts ...SchemaOption) *NumberSchema[int32]

func Int64 added in v0.17.0 

func Int64(opts ...SchemaOption) *NumberSchema[int64]

func (*NumberSchema[T]) Catch added in v0.14.1 

func (v *NumberSchema[T]) Catch(val T) *NumberSchema[T]

sets the catch value (i.e the value to use if the validation fails)

func (*NumberSchema[T]) Default added in v0.14.1 

func (v *NumberSchema[T]) Default(val T) *NumberSchema[T]

sets the default value

func (*NumberSchema[T]) EQ added in v0.14.1 

func (v *NumberSchema[T]) EQ(n T, options ...TestOption) *NumberSchema[T]

checks for equality

func (*NumberSchema[T]) GT added in v0.14.1 

func (v *NumberSchema[T]) GT(n T, options ...TestOption) *NumberSchema[T]

checks for greater

func (*NumberSchema[T]) GTE added in v0.14.1 

func (v *NumberSchema[T]) GTE(n T, options ...TestOption) *NumberSchema[T]

checks for greater or equal

func (*NumberSchema[T]) LT added in v0.14.1 

func (v *NumberSchema[T]) LT(n T, options ...TestOption) *NumberSchema[T]

checks for lesser

func (*NumberSchema[T]) LTE added in v0.14.1 

func (v *NumberSchema[T]) LTE(n T, options ...TestOption) *NumberSchema[T]

checks for lesser or equal

func (*NumberSchema[T]) OneOf added in v0.14.1 

func (v *NumberSchema[T]) OneOf(enum []T, options ...TestOption) *NumberSchema[T]

Check that the value is one of the enum values

func (*NumberSchema[T]) Optional added in v0.14.1 

func (v *NumberSchema[T]) Optional() *NumberSchema[T]

marks field as optional

func (*NumberSchema[T]) Parse added in v0.14.1 

func (v *NumberSchema[T]) Parse(data any, dest *T, options ...ExecOption) ZogIssueList

parses the value and stores it in the destination

func (*NumberSchema[T]) PostTransform added in v0.14.1 

func (v *NumberSchema[T]) PostTransform(transform PostTransform) *NumberSchema[T]

Adds posttransform function to schema

func (*NumberSchema[T]) PreTransform added in v0.14.1 

func (v *NumberSchema[T]) PreTransform(transform PreTransform) *NumberSchema[T]

func (*NumberSchema[T]) Required added in v0.14.1 

func (v *NumberSchema[T]) Required(options ...TestOption) *NumberSchema[T]

marks field as required

func (*NumberSchema[T]) Test added in v0.14.1 

func (v *NumberSchema[T]) Test(t Test) *NumberSchema[T]

custom test function call it -> schema.Test(test, options)

func (*NumberSchema[T]) TestFunc added in v0.16.0 

func (v *NumberSchema[T]) TestFunc(testFunc BoolTFunc, options ...TestOption) *NumberSchema[T]

Create a custom test function for the schema. This is similar to Zod's `.refine()` method.

func (*NumberSchema[T]) Validate added in v0.15.0 

func (v *NumberSchema[T]) Validate(data *T, options ...ExecOption) ZogIssueList

Validates a number pointer

type Numeric 

type Numeric = constraints.Ordered

type ParsingOption deprecated 

type ParsingOption = ExecOption

Deprecated: use ExecOption instead

type PointerSchema added in v0.14.1 

type PointerSchema struct {
	// contains filtered or unexported fields
}

func Ptr added in v0.12.1 

func Ptr(schema ZogSchema) *PointerSchema

Ptr creates a pointer ZogSchema

func (*PointerSchema) NotNil added in v0.14.1 

func (v *PointerSchema) NotNil(options ...TestOption) *PointerSchema

func (*PointerSchema) Parse added in v0.14.1 

func (v *PointerSchema) Parse(data any, dest any, options ...ExecOption) ZogIssueMap

Parse the data into the destination pointer

func (*PointerSchema) Validate added in v0.15.0 

func (v *PointerSchema) Validate(data any, options ...ExecOption) ZogIssueMap

Validates a pointer pointer

type PostTransform added in v0.18.0 

type PostTransform = p.PostTransform

Function signature for postTransforms. Takes the value pointer and the context and returns an error.

type PreTransform added in v0.18.0 

type PreTransform = p.PreTransform

Function signature for preTransforms. Takes the value and the context and returns the new value and an error.

type PrimitiveZogSchema added in v0.14.1 

type PrimitiveZogSchema[T p.ZogPrimitive] interface {
	ZogSchema
	Parse(val any, dest *T, options ...ExecOption) ZogIssueList
}

This is a common interface for all primitive schemas (i.e strings, numbers, booleans, time.Time...) You can use this to pass any primitive schema around

type Schema 

type Schema map[string]ZogSchema

A map of field names to zog schemas

type SchemaOption added in v0.12.0 

type SchemaOption = func(s ZogSchema)

Options that can be passed to a `schema.New()` call

func WithCoercer added in v0.12.0 

func WithCoercer(c conf.CoercerFunc) SchemaOption

type SliceSchema added in v0.14.1 

type SliceSchema struct {
	// contains filtered or unexported fields
}

func Slice 

func Slice(schema ZogSchema, opts ...SchemaOption) *SliceSchema

Creates a slice schema. That is a Zog representation of a slice. It takes a ZogSchema which will be used to validate against all the items in the slice.

func (*SliceSchema) Contains added in v0.14.1 

func (v *SliceSchema) Contains(value any, options ...TestOption) *SliceSchema

Slice contains a specific value

func (*SliceSchema) Default added in v0.14.1 

func (v *SliceSchema) Default(val any) *SliceSchema

sets the default value

func (*SliceSchema) Len added in v0.14.1 

func (v *SliceSchema) Len(n int, options ...TestOption) *SliceSchema

Exact number of items

func (*SliceSchema) Max added in v0.14.1 

func (v *SliceSchema) Max(n int, options ...TestOption) *SliceSchema

Maximum number of items

func (*SliceSchema) Min added in v0.14.1 

func (v *SliceSchema) Min(n int, options ...TestOption) *SliceSchema

Minimum number of items

func (*SliceSchema) Optional added in v0.14.1 

func (v *SliceSchema) Optional() *SliceSchema

marks field as optional

func (*SliceSchema) Parse added in v0.14.1 

func (v *SliceSchema) Parse(data any, dest any, options ...ExecOption) ZogIssueMap

Only supports parsing from data=slice[any] to a dest =&slice[] (this can be typed. Doesn't have to be any)

func (*SliceSchema) PostTransform added in v0.14.1 

func (v *SliceSchema) PostTransform(transform PostTransform) *SliceSchema

Adds posttransform function to schema

func (*SliceSchema) PreTransform added in v0.14.1 

func (v *SliceSchema) PreTransform(transform PreTransform) *SliceSchema

Adds pretransform function to schema

func (*SliceSchema) Required added in v0.14.1 

func (v *SliceSchema) Required(options ...TestOption) *SliceSchema

marks field as required

func (*SliceSchema) Test added in v0.14.1 

func (v *SliceSchema) Test(t Test) *SliceSchema

custom test function call it -> schema.Test(t z.Test)

func (*SliceSchema) TestFunc added in v0.16.0 

func (v *SliceSchema) TestFunc(testFunc BoolTFunc, opts ...TestOption) *SliceSchema

Create a custom test function for the schema. This is similar to Zod's `.refine()` method.

func (*SliceSchema) Validate added in v0.15.0 

func (v *SliceSchema) Validate(data any, options ...ExecOption) ZogIssueMap

Validates a slice

type StringSchema added in v0.14.1 

type StringSchema[T likeString] struct {
	// contains filtered or unexported fields
}

func String 

func String(opts ...SchemaOption) *StringSchema[string]

Returns a new String Schema

func (*StringSchema[T]) Catch added in v0.14.1 

func (v *StringSchema[T]) Catch(val T) *StringSchema[T]

sets the catch value (i.e the value to use if the validation fails)

func (*StringSchema[T]) Contains added in v0.14.1 

func (v *StringSchema[T]) Contains(sub T, options ...TestOption) *StringSchema[T]

Test: checks that the value contains the substring

func (*StringSchema[T]) ContainsDigit added in v0.14.1 

func (v *StringSchema[T]) ContainsDigit(options ...TestOption) *StringSchema[T]

Test: checks that the value contains a digit

func (*StringSchema[T]) ContainsSpecial added in v0.14.1 

func (v *StringSchema[T]) ContainsSpecial(options ...TestOption) *StringSchema[T]

Test: checks that the value contains a special character

func (*StringSchema[T]) ContainsUpper added in v0.14.1 

func (v *StringSchema[T]) ContainsUpper(options ...TestOption) *StringSchema[T]

Test: checks that the value contains an uppercase letter

func (*StringSchema[T]) Default added in v0.14.1 

func (v *StringSchema[T]) Default(val T) *StringSchema[T]

sets the default value

func (*StringSchema[T]) Email added in v0.14.1 

func (v *StringSchema[T]) Email(options ...TestOption) *StringSchema[T]

Test: checks that the value is a valid email address

func (*StringSchema[T]) HasPrefix added in v0.14.1 

func (v *StringSchema[T]) HasPrefix(s T, options ...TestOption) *StringSchema[T]

Test: checks that the value has the prefix

func (*StringSchema[T]) HasSuffix added in v0.14.1 

func (v *StringSchema[T]) HasSuffix(s T, options ...TestOption) *StringSchema[T]

Test: checks that the value has the suffix

func (*StringSchema[T]) Len added in v0.14.1 

func (v *StringSchema[T]) Len(n int, options ...TestOption) *StringSchema[T]

Test: checks that the value is exactly n characters long

func (*StringSchema[T]) Match added in v0.14.1 

func (v *StringSchema[T]) Match(regex *regexp.Regexp, options ...TestOption) *StringSchema[T]

Test: checks that value matches to regex

func (*StringSchema[T]) Max added in v0.14.1 

func (v *StringSchema[T]) Max(n int, options ...TestOption) *StringSchema[T]

Test: checks that the value is at most n characters long

func (*StringSchema[T]) Min added in v0.14.1 

func (v *StringSchema[T]) Min(n int, options ...TestOption) *StringSchema[T]

Test: checks that the value is at least n characters long

func (*StringSchema[T]) Not added in v0.19.2 

func (v *StringSchema[T]) Not() NotStringSchema[T]

Not returns a schema that negates the next validation test. For example, `z.String().Not().Email()` validates that the string is NOT a valid email. Note: The negation only applies to the next validation test and is reset afterward.

func (*StringSchema[T]) OneOf added in v0.14.1 

func (v *StringSchema[T]) OneOf(enum []T, options ...TestOption) *StringSchema[T]

Test: checks that the value is one of the enum values

func (*StringSchema[T]) Optional added in v0.14.1 

func (v *StringSchema[T]) Optional() *StringSchema[T]

marks field as optional

func (*StringSchema[T]) Parse added in v0.14.1 

func (v *StringSchema[T]) Parse(data any, dest *T, options ...ExecOption) ZogIssueList

Parses the data into the destination string. Returns a list of ZogIssues

func (*StringSchema[T]) PostTransform added in v0.14.1 

func (v *StringSchema[T]) PostTransform(transform PostTransform) *StringSchema[T]

Adds posttransform function to schema

func (*StringSchema[T]) PreTransform added in v0.14.1 

func (v *StringSchema[T]) PreTransform(transform PreTransform) *StringSchema[T]

Adds pretransform function to schema

func (*StringSchema[T]) Required added in v0.14.1 

func (v *StringSchema[T]) Required(options ...TestOption) *StringSchema[T]

marks field as required

func (*StringSchema[T]) Test added in v0.14.1 

func (v *StringSchema[T]) Test(t Test) *StringSchema[T]

! Tests custom test function call it -> schema.Test(t z.Test, opts ...TestOption)

func (*StringSchema[T]) TestFunc added in v0.16.0 

func (v *StringSchema[T]) TestFunc(testFunc BoolTFunc, options ...TestOption) *StringSchema[T]

Create a custom test function for the schema. This is similar to Zod's `.refine()` method.

func (*StringSchema[T]) Trim added in v0.14.1 

func (v *StringSchema[T]) Trim() *StringSchema[T]

PreTransform: trims the input data of whitespace if it is a string

func (*StringSchema[T]) URL added in v0.14.1 

func (v *StringSchema[T]) URL(options ...TestOption) *StringSchema[T]

Test: checks that the value is a valid URL

func (*StringSchema[T]) UUID added in v0.14.1 

func (v *StringSchema[T]) UUID(options ...TestOption) *StringSchema[T]

Test: checks that the value is a valid uuid

func (*StringSchema[T]) Validate added in v0.15.0 

func (v *StringSchema[T]) Validate(data *T, options ...ExecOption) ZogIssueList

Validate Given string

type StructSchema added in v0.14.1 

type StructSchema struct {
	// contains filtered or unexported fields
}

func Struct 

func Struct(schema Schema) *StructSchema

Returns a new StructSchema which can be used to parse input data into a struct

func (*StructSchema) Extend added in v0.14.1 

func (v *StructSchema) Extend(schema Schema) *StructSchema

Extend creates a new schema by adding additional fields from the provided schema. Fields in the provided schema override any existing fields with the same key.

Parameters:

  • schema: The schema containing fields to add

Returns a new schema with the additional fields

func (*StructSchema) Merge added in v0.14.1 

func (v *StructSchema) Merge(other *StructSchema, others ...*StructSchema) *StructSchema

Merge combines two or more schemas into a new schema. It performs a shallow merge, meaning:

  • Fields with the same key from later schemas override earlier ones
  • PreTransforms, PostTransforms and tests are concatenated in order
  • Modifying nested schemas may affect the original schemas

Parameters:

  • other: The first schema to merge with
  • others: Additional schemas to merge

Returns a new schema containing the merged fields and transforms

func (*StructSchema) Omit added in v0.14.1 

func (v *StructSchema) Omit(vals ...any) *StructSchema

Omit creates a new schema with specified fields removed. It accepts either strings or map[string]bool as arguments:

  • Strings directly specify fields to omit
  • For maps, fields are omitted when their boolean value is true

Returns a new schema with the specified fields removed

func (*StructSchema) Optional deprecated added in v0.14.1 

func (v *StructSchema) Optional() *StructSchema

Deprecated: structs are not required or optional. They pass through to the fields. If you want to say that an entire struct may not exist you should use z.Ptr(z.Struct(...)) marks field as optional

func (*StructSchema) Parse added in v0.14.1 

func (v *StructSchema) Parse(data any, destPtr any, options ...ExecOption) ZogIssueMap

Parses val into destPtr and validates each field based on the schema. Only supports val = map[string]any & dest = &struct

func (*StructSchema) Pick added in v0.14.1 

func (v *StructSchema) Pick(picks ...any) *StructSchema

Pick creates a new schema keeping only the specified fields. It accepts either strings or map[string]bool as arguments:

  • Strings directly specify fields to keep
  • For maps, fields are kept when their boolean value is true

Returns a new schema containing only the specified fields

func (*StructSchema) PostTransform added in v0.14.1 

func (v *StructSchema) PostTransform(transform PostTransform) *StructSchema

Adds posttransform function to schema

func (*StructSchema) PreTransform added in v0.14.1 

func (v *StructSchema) PreTransform(transform PreTransform) *StructSchema

Add a pretransform step to the schema

func (*StructSchema) Required deprecated added in v0.14.1 

func (v *StructSchema) Required(options ...TestOption) *StructSchema

Deprecated: structs are not required or optional. They pass through to the fields. If you want to say that an entire struct may not exist you should use z.Ptr(z.Struct(...)) This now is a noop. But I believe most people expect it to work how it does now. marks field as required

func (*StructSchema) Test added in v0.14.1 

func (v *StructSchema) Test(t Test) *StructSchema

! VALIDATORS custom test function call it -> schema.Test(t z.Test)

func (*StructSchema) TestFunc added in v0.16.0 

func (v *StructSchema) TestFunc(testFunc BoolTFunc, options ...TestOption) *StructSchema

Create a custom test function for the schema. This is similar to Zod's `.refine()` method.

func (*StructSchema) Validate added in v0.15.0 

func (v *StructSchema) Validate(dataPtr any, options ...ExecOption) ZogIssueMap

Validate a struct pointer given the struct schema. Usage: userSchema.Validate(&User, ...options)

type TFunc added in v0.19.0 

type TFunc = p.TFunc

Function signature for tests. Takes the value and the context and returns a boolean. This used to be a function you could pass to the schema.Test method -> `s.Test(z.TFunc(fn))`. But that has been deprecated. Use `schema.TFunc(fn)` instead.

type Test 

type Test = p.Test

Test is the test object. It is the struct that represents an individual validation. For example `z.String().Min(3)` is a test that checks if the string is at least 3 characters long.

func TestFunc 

func TestFunc(IssueCode zconst.ZogIssueCode, fn BoolTFunc, options ...TestOption) Test

Creates a reusable testFunc you can add to schemas by doing schema.Test(z.TestFunc()). Has the same API as schema.TestFunc() so it is recommended you use that one for non reusable tests.

type TestOption 

type TestOption = p.TestOption

Options that can be passed to a test

func IssueCode added in v0.16.0 

func IssueCode(code zconst.ZogIssueCode) TestOption

IssueCode is a function that allows you to set a custom issue code for the test. Most useful for TestFuncs:

z.String().TestFunc(..., z.IssueCode("just_provide_a_string" or use values in zconst))

func IssuePath added in v0.16.0 

func IssuePath(path string) TestOption

IssuePath is a function that allows you to set a custom issue path for the test. Beware with using this as it is not typesafe and can lead to unexpected behavior if you change the schema or have a typo. Usage:

z.Struct( 

z.Schema {
    "Name": z.String().Required(z.IssuePath("fullname")),
	"Fullname": z.String(),
}

)

func Message 

func Message(msg string) TestOption

Message is a function that allows you to set a custom message for the test.

func MessageFunc 

func MessageFunc(fn IssueFmtFunc) TestOption

MessageFunc is a function that allows you to set a custom message formatter for the test.

func Params added in v0.16.1 

func Params(params map[string]any) TestOption

Params is a function that allows you to set a custom params for the test. You may then access these values when formatting test errors in the IssueFmtFunc

type TimeFunc added in v0.12.0 

type TimeFunc func(opts ...SchemaOption) *TimeSchema
var Time TimeFunc = func(opts ...SchemaOption) *TimeSchema {
	t := &TimeSchema{
		coercer: conf.Coercers.Time,
	}
	for _, opt := range opts {
		opt(t)
	}
	return t
}

Returns a new Time Schema

func (TimeFunc) Format added in v0.12.0 

func (t TimeFunc) Format(format string) SchemaOption

WARNING ONLY SUPPOORTS Schema.Parse! Sets the string format for the time schema Usage is: z.Time(z.Time.Format(time.RFC3339))

func (TimeFunc) FormatFunc added in v0.12.0 

func (t TimeFunc) FormatFunc(format func(data string) (time.Time, error)) SchemaOption

WARNING ONLY SUPPOORTS Schema.Parse! Sets the format function for the time schema. Usage is: 

z.Time(z.Time.FormatFunc(func(data string) (time.Time, error) {
	return time.Parse(time.RFC3339, data)
}))

type TimeSchema added in v0.14.1 

type TimeSchema struct {
	// contains filtered or unexported fields
}

func (*TimeSchema) After added in v0.14.1 

func (v *TimeSchema) After(t time.Time, opts ...TestOption) *TimeSchema

Checks that the value is after the given time

func (*TimeSchema) Before added in v0.14.1 

func (v *TimeSchema) Before(t time.Time, opts ...TestOption) *TimeSchema

Checks that the value is before the given time

func (*TimeSchema) Catch added in v0.14.1 

func (v *TimeSchema) Catch(val time.Time) *TimeSchema

sets the catch value (i.e the value to use if the validation fails)

func (*TimeSchema) Default added in v0.14.1 

func (v *TimeSchema) Default(val time.Time) *TimeSchema

sets the default value

func (*TimeSchema) EQ added in v0.14.1 

func (v *TimeSchema) EQ(t time.Time, opts ...TestOption) *TimeSchema

Checks that the value is equal to the given time

func (*TimeSchema) Optional added in v0.14.1 

func (v *TimeSchema) Optional() *TimeSchema

marks field as optional

func (*TimeSchema) Parse added in v0.14.1 

func (v *TimeSchema) Parse(data any, dest *time.Time, options ...ExecOption) ZogIssueList

Parses the data into the destination time.Time. Returns a list of errors

func (*TimeSchema) PostTransform added in v0.14.1 

func (v *TimeSchema) PostTransform(transform PostTransform) *TimeSchema

Adds posttransform function to schema

func (*TimeSchema) PreTransform added in v0.14.1 

func (v *TimeSchema) PreTransform(transform PreTransform) *TimeSchema

Adds pretransform function to schema

func (*TimeSchema) Required added in v0.14.1 

func (v *TimeSchema) Required(options ...TestOption) *TimeSchema

marks field as required

func (*TimeSchema) Test added in v0.14.1 

func (v *TimeSchema) Test(t Test) *TimeSchema

custom test function call it -> schema.Test(z.Test{Func: func (val any, ctx z.Ctx) { my test }})

func (*TimeSchema) TestFunc added in v0.16.0 

func (v *TimeSchema) TestFunc(testFunc BoolTFunc, options ...TestOption) *TimeSchema

Create a custom test function for the schema. This is similar to Zod's `.refine()` method.

func (*TimeSchema) Validate added in v0.15.0 

func (v *TimeSchema) Validate(data *time.Time, options ...ExecOption) ZogIssueList

Validates an existing time.Time

type ZogIssue added in v0.16.0 

type ZogIssue = p.ZogIssue

This is a type for the ZogIssue type. It is the type of all the errors returned from zog.

type ZogIssueList added in v0.16.0 

type ZogIssueList = p.ZogIssueList

This is a type for the ZogErrList type. It is a list of ZogIssues returned from parsing primitive schemas. The type is []ZogIssue

type ZogIssueMap added in v0.16.0 

type ZogIssueMap = p.ZogIssueMap

This is a type for the ZogIssueMap type. It is a map[string][]ZogIssue returned from parsing complex schemas. The type is map[string][]ZogIssue All errors are returned in a flat map, not matter how deep the schema is. For example: 

schema := z.Struct(z.Schema{
  "address": z.Struct(z.Schema{
    "street": z.String().Min(3).Max(10),
    "city": z.String().Min(3).Max(10),
  }),
  "fields": z.Slice(z.String().Min(3).Max(10)),
})

errors = map[string][]ZogIssue{
  "address.street": []ZogIssue{....}, // error for the street field in the address struct
  "fields[0]": []ZogIssue{...}, // error for the first field in the slice
}

type ZogSchema added in v0.12.0 

type ZogSchema interface {
	// contains filtered or unexported methods
}

The ZogSchema is the interface all schemas must implement This is most useful for internal use. If you are looking to pass schemas around, use the ComplexZogSchema or PrimitiveZogSchema interfaces if possible.

Source Files

View all Source files

Directories

Path Synopsis
en
es
parsers
zjson

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.