owl

package module
v1.0.0-beta.7 Latest Latest
Warning

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

 Go to latest Published: Oct 6, 2024 License: MIT Imports: 9 Imported by: 0

README

a zero dependency performant validation library

Install

go get github.com/aacebo/owl

Usage

schema := owl.String().Required()

if err := schema.Validate("..."); err != nil { // nil
	panic(err)
}

Documentation

Index

Examples

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type AnySchema 

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

func Any 

func Any() *AnySchema
Example 
package main

import (
	"github.com/aacebo/owl"
)

func main() {
	schema := owl.Any()

	if err := schema.Validate("..."); err != nil { // nil
		panic(err)
	}

	if err := schema.Validate(1); err != nil { // nil
		panic(err)
	}

	if err := schema.Validate(true); err != nil { // nil
		panic(err)
	}
}

Output:

func (*AnySchema) Enum 

func (self *AnySchema) Enum(values ...any) *AnySchema

func (AnySchema) MarshalJSON 

func (self AnySchema) MarshalJSON() ([]byte, error)

func (*AnySchema) Required 

func (self *AnySchema) Required() *AnySchema

func (*AnySchema) Rule 

func (self *AnySchema) Rule(key string, value any, rule RuleFn) *AnySchema

func (AnySchema) Type 

func (self AnySchema) Type() string

func (AnySchema) Validate 

func (self AnySchema) Validate(value any) error

type BoolSchema 

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

func Bool 

func Bool() *BoolSchema
Example 
package main

import (
	"github.com/aacebo/owl"
)

func main() {
	schema := owl.Bool()

	if err := schema.Validate(true); err != nil { // nil
		panic(err)
	}

	if err := schema.Validate(false); err != nil { // nil
		panic(err)
	}

	if err := schema.Validate("test"); err != nil { // error
		panic(err)
	}
}

Output:

func (*BoolSchema) Enum 

func (self *BoolSchema) Enum(values ...bool) *BoolSchema

func (BoolSchema) MarshalJSON 

func (self BoolSchema) MarshalJSON() ([]byte, error)

func (*BoolSchema) Required 

func (self *BoolSchema) Required() *BoolSchema

func (*BoolSchema) Rule 

func (self *BoolSchema) Rule(key string, value any, rule RuleFn) *BoolSchema

func (BoolSchema) Type 

func (self BoolSchema) Type() string

func (BoolSchema) Validate 

func (self BoolSchema) Validate(value any) error

type Error 

type Error struct {
	Rule    string `json:"rule,omitempty"`
	Key     string `json:"key,omitempty"`
	Message string `json:"message,omitempty"`
}

func (Error) Error 

func (self Error) Error() string

func (Error) String 

func (self Error) String() string

type ErrorGroup 

type ErrorGroup struct {
	Key    string  `json:"key,omitempty"`
	Errors []error `json:"errors,omitempty"`
}

func (ErrorGroup) Add 

func (self ErrorGroup) Add(err error) ErrorGroup

func (ErrorGroup) Error 

func (self ErrorGroup) Error() string

func (ErrorGroup) String 

func (self ErrorGroup) String() string

type FloatSchema 

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

func Float 

func Float() *FloatSchema
Example 
package main

import (
	"github.com/aacebo/owl"
)

func main() {
	schema := owl.Float()

	if err := schema.Validate(1.0); err != nil { // nil
		panic(err)
	}

	if err := schema.Validate(1); err != nil { // nil
		panic(err)
	}

	if err := schema.Validate("test"); err != nil { // error
		panic(err)
	}
}

Output:

func (*FloatSchema) Enum 

func (self *FloatSchema) Enum(values ...float64) *FloatSchema

func (FloatSchema) MarshalJSON 

func (self FloatSchema) MarshalJSON() ([]byte, error)

func (*FloatSchema) Max 

func (self *FloatSchema) Max(max float64) *FloatSchema
Example 
package main

import (
	"github.com/aacebo/owl"
)

func main() {
	schema := owl.Float().Max(5.0)

	if err := schema.Validate(5); err != nil { // nil
		panic(err)
	}

	if err := schema.Validate(5.5); err != nil { // error
		panic(err)
	}
}

Output:

func (*FloatSchema) Min 

func (self *FloatSchema) Min(min float64) *FloatSchema
Example 
package main

import (
	"github.com/aacebo/owl"
)

func main() {
	schema := owl.Float().Min(5.0)

	if err := schema.Validate(5); err != nil { // nil
		panic(err)
	}

	if err := schema.Validate(4.5); err != nil { // error
		panic(err)
	}
}

Output:

func (*FloatSchema) Required 

func (self *FloatSchema) Required() *FloatSchema

func (*FloatSchema) Rule 

func (self *FloatSchema) Rule(key string, value any, rule RuleFn) *FloatSchema

func (FloatSchema) Type 

func (FloatSchema) Type() string

func (FloatSchema) Validate 

func (self FloatSchema) Validate(value any) error

type IntSchema 

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

func Int 

func Int() *IntSchema
Example 
package main

import (
	"github.com/aacebo/owl"
)

func main() {
	schema := owl.Int()

	if err := schema.Validate(1); err != nil { // nil
		panic(err)
	}

	if err := schema.Validate(1); err != nil { // nil
		panic(err)
	}

	if err := schema.Validate("test"); err != nil { // error
		panic(err)
	}
}

Output:

func (*IntSchema) Enum 

func (self *IntSchema) Enum(values ...int) *IntSchema

func (IntSchema) MarshalJSON 

func (self IntSchema) MarshalJSON() ([]byte, error)

func (*IntSchema) Max 

func (self *IntSchema) Max(max int) *IntSchema
Example 
package main

import (
	"github.com/aacebo/owl"
)

func main() {
	schema := owl.Int().Max(5)

	if err := schema.Validate(5); err != nil { // nil
		panic(err)
	}

	if err := schema.Validate(6); err != nil { // error
		panic(err)
	}
}

Output:

func (*IntSchema) Min 

func (self *IntSchema) Min(min int) *IntSchema
Example 
package main

import (
	"github.com/aacebo/owl"
)

func main() {
	schema := owl.Int().Min(5)

	if err := schema.Validate(5); err != nil { // nil
		panic(err)
	}

	if err := schema.Validate(4); err != nil { // error
		panic(err)
	}
}

Output:

func (*IntSchema) Required 

func (self *IntSchema) Required() *IntSchema

func (*IntSchema) Rule 

func (self *IntSchema) Rule(key string, value any, rule RuleFn) *IntSchema

func (IntSchema) Type 

func (self IntSchema) Type() string

func (IntSchema) Validate 

func (self IntSchema) Validate(value any) error

type ObjectSchema 

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

func Object 

func Object() *ObjectSchema
Example 
package main

import (
	"github.com/aacebo/owl"
)

func main() {
	schema := owl.Object().Field(
		"email", owl.String().Email().Required(),
	).Field(
		"password", owl.String().Min(5).Max(20).Required(),
	)

	if err := schema.Validate(map[string]any{
		"email":    "test@test.com",
		"password": "mytestpassword",
	}); err != nil { // nil
		panic(err)
	}

	if err := schema.Validate(map[string]any{
		"email": "test@test.com",
	}); err != nil { // error
		panic(err)
	}
}

Output:

func (*ObjectSchema) Field 

func (self *ObjectSchema) Field(key string, schema Schema) *ObjectSchema

func (ObjectSchema) MarshalJSON 

func (self ObjectSchema) MarshalJSON() ([]byte, error)

func (*ObjectSchema) Required 

func (self *ObjectSchema) Required() *ObjectSchema

func (*ObjectSchema) Rule 

func (self *ObjectSchema) Rule(key string, value any, rule RuleFn) *ObjectSchema

func (ObjectSchema) Type 

func (self ObjectSchema) Type() string

func (ObjectSchema) Validate 

func (self ObjectSchema) Validate(value any) error

type Rule 

type Rule struct {
	Key     string `json:"key"`
	Value   any    `json:"value"`
	Resolve RuleFn `json:"-"`
}

type RuleFn 

type RuleFn func(value reflect.Value) (any, error)

type Schema 

type Schema interface {
	Type() string
	Validate(value any) error
	// contains filtered or unexported methods
}

type StringSchema 

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

func String 

func String() *StringSchema
Example 
package main

import (
	"github.com/aacebo/owl"
)

func main() {
	schema := owl.String()

	if err := schema.Validate("test"); err != nil { // nil
		panic(err)
	}

	if err := schema.Validate(true); err != nil { // error
		panic(err)
	}
}

Output:

func (*StringSchema) Email 

func (self *StringSchema) Email() *StringSchema
Example 
package main

import (
	"github.com/aacebo/owl"
)

func main() {
	schema := owl.String().Email()

	if err := schema.Validate("test@gmail.com"); err != nil { // nil
		panic(err)
	}

	if err := schema.Validate("test"); err != nil { // error
		panic(err)
	}
}

Output:

func (*StringSchema) Enum 

func (self *StringSchema) Enum(values ...string) *StringSchema

func (StringSchema) MarshalJSON 

func (self StringSchema) MarshalJSON() ([]byte, error)

func (*StringSchema) Max 

func (self *StringSchema) Max(max int) *StringSchema
Example 
package main

import (
	"github.com/aacebo/owl"
)

func main() {
	schema := owl.String().Max(5)

	if err := schema.Validate("test"); err != nil { // nil
		panic(err)
	}

	if err := schema.Validate("tester"); err != nil { // error
		panic(err)
	}
}

Output:

func (*StringSchema) Min 

func (self *StringSchema) Min(min int) *StringSchema
Example 
package main

import (
	"github.com/aacebo/owl"
)

func main() {
	schema := owl.String().Min(5)

	if err := schema.Validate("tester"); err != nil { // nil
		panic(err)
	}

	if err := schema.Validate("test"); err != nil { // error
		panic(err)
	}
}

Output:

func (*StringSchema) Regex 

func (self *StringSchema) Regex(re *regexp.Regexp) *StringSchema
Example 
package main

import (
	"regexp"

	"github.com/aacebo/owl"
)

func main() {
	schema := owl.String().Regex(regexp.MustCompile("^[0-9a-zA-Z_-]+$"))

	if err := schema.Validate("test"); err != nil { // nil
		panic(err)
	}

	if err := schema.Validate("hello world"); err != nil { // error
		panic(err)
	}
}

Output:

func (*StringSchema) Required 

func (self *StringSchema) Required() *StringSchema

func (*StringSchema) Rule 

func (self *StringSchema) Rule(key string, value any, rule RuleFn) *StringSchema

func (StringSchema) Type 

func (self StringSchema) Type() string

func (*StringSchema) URL 

func (self *StringSchema) URL() *StringSchema
Example 
package main

import (
	"github.com/aacebo/owl"
)

func main() {
	schema := owl.String().URL()

	if err := schema.Validate("https://www.google.com"); err != nil { // nil
		panic(err)
	}

	if err := schema.Validate("test"); err != nil { // error
		panic(err)
	}
}

Output:

func (*StringSchema) UUID 

func (self *StringSchema) UUID() *StringSchema
Example 
package main

import (
	"github.com/aacebo/owl"
)

func main() {
	schema := owl.String().UUID()

	if err := schema.Validate("afefc1ab-b8f2-4803-8e9a-60515854141a"); err != nil { // nil
		panic(err)
	}

	if err := schema.Validate("test"); err != nil { // error
		panic(err)
	}
}

Output:

func (StringSchema) Validate 

func (self StringSchema) Validate(value any) error

type TimeSchema 

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

func Time 

func Time() *TimeSchema
Example 
package main

import (
	"time"

	"github.com/aacebo/owl"
)

func main() {
	schema := owl.Time()

	if err := schema.Validate(time.Now()); err != nil { // nil
		panic(err)
	}

	if err := schema.Validate(time.Now().Format(time.RFC3339)); err != nil { // nil
		panic(err)
	}

	if err := schema.Validate("test"); err != nil { // error
		panic(err)
	}
}

Output:

func (*TimeSchema) Layout 

func (self *TimeSchema) Layout(layout string) *TimeSchema

func (TimeSchema) MarshalJSON 

func (self TimeSchema) MarshalJSON() ([]byte, error)

func (*TimeSchema) Max 

func (self *TimeSchema) Max(max time.Time) *TimeSchema
Example 
package main

import (
	"time"

	"github.com/aacebo/owl"
)

func main() {
	schema := owl.Time().Max(time.Now())

	if err := schema.Validate(time.Now().AddDate(1, 0, 0)); err != nil { // error
		panic(err)
	}
}

Output:

func (*TimeSchema) Min 

func (self *TimeSchema) Min(min time.Time) *TimeSchema
Example 
package main

import (
	"time"

	"github.com/aacebo/owl"
)

func main() {
	schema := owl.Time().Min(time.Now())

	if err := schema.Validate(time.Now().AddDate(-1, 0, 0)); err != nil { // error
		panic(err)
	}
}

Output:

func (*TimeSchema) Required 

func (self *TimeSchema) Required() *TimeSchema

func (*TimeSchema) Rule 

func (self *TimeSchema) Rule(key string, value any, rule RuleFn) *TimeSchema

func (TimeSchema) Type 

func (self TimeSchema) Type() string

func (TimeSchema) Validate 

func (self TimeSchema) Validate(value any) error

type UnionSchema 

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

func Union 

func Union(anyOf ...Schema) *UnionSchema
Example 
package main

import (
	"github.com/aacebo/owl"
)

func main() {
	schema := owl.Union(
		owl.String().Required(),
		owl.Int().Required(),
	)

	if err := schema.Validate("test"); err != nil { // nil
		panic(err)
	}

	if err := schema.Validate(1); err != nil { // nil
		panic(err)
	}

	if err := schema.Validate(true); err != nil { // error
		panic(err)
	}
}

Output:

func (UnionSchema) MarshalJSON 

func (self UnionSchema) MarshalJSON() ([]byte, error)

func (*UnionSchema) Rule 

func (self *UnionSchema) Rule(key string, value any, rule RuleFn) *UnionSchema

func (UnionSchema) Type 

func (self UnionSchema) Type() string

func (UnionSchema) Validate 

func (self UnionSchema) Validate(value any) error

Source Files

View all Source files

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.