Awesome
yamagiconf
The heavily opinionated YAML Magic Configuration framework for Go keeps your configs simple and consistent by being more restrictive than your regular YAML parser 🚷 allowing only a subset of YAML and enforcing some restrictions to the target Go type.
If you hate YAML, and you're afraid of YAML documents from hell, and you can't stand complex, unexplorable and unintuitive configurations then yamagiconf is for you!
🪄 It's magic because it uses reflect to find recursively all
values of types that implement interface { Validate() error }
and calls them reporting
an error annotated with line and column in the YAML file if necessary.
(anti-)Features
- Go restrictions:
- 🚫 Forbids recursive Go types.
- 🚫 Forbids the use of
any
,int
&uint
(unspecified width), and other types. Only maps, slices, arrays and deterministic primitives are allowed. - ❗️ Requires
yaml
struct tags on all exported fields. - ❗️ Requires
env
struct tags to be POSIX-style. - 🚫 Forbids the use of
env
struct tag on non-primitive fields. Allows only floats, ints, strings, bool and types that implement theencoding.TextUnmarshaler
interface. - 🚫 Forbids the use of
env
on primitive fields implementing theyaml.Unmarshaler
interface. - 🚫 Forbids the use of
yaml
andenv
struct tags within implementations ofencoding.TextUnmarshaler
and/oryaml.Unmarshaler
. - 🚫 Forbids the use of YAML struct tag option
"inline"
for non-embedded structs and requires embedded structs to use option"inline"
.
- YAML restrictions:
- 🚫 Forbids the use of
no
,yes
,on
andoff
forbool
, allows onlytrue
andfalse
. - 🚫 Forbids the use of
~
,Null
and other variations, allows onlynull
for nilables. - 🚫 Forbids assigning
null
to non-nilables (which normally would assign zero value). - 🚫 Forbids fields in the YAML file that aren't specified by the Go type.
- 🚫 Forbids the use of YAML tags.
- 🚫 Forbids redeclaration of anchors.
- 🚫 Forbids unused anchors.
- 🚫 Forbids anchors with implicit
null
value (no value) likefoo: &bar
. - ❗️ Requires fields specified in the configuration type to be present in the YAML file.
- 🚫 Forbids assigning non-string values to Go types that implement
the
encoding.TextUnmarshaler
interface. - 🚫 Forbids empty array items (see rationale).
- 🚫 Forbids multi-document files.
- 🚫 Forbids YAML merge keys.
- 🚫 Forbids the use of
- Features:
- 🪄 If any type within your configuration struct implements the
Validate
interface, then its validation method will be called using reflection (doesn't apply to unexported fields which are invisible toreflect
). If it returns an error - the error will be reported. Keeps your validation logic close to your configuration type definitions. - Reports errors by
line:column
when possible. - Supports github.com/go-playground/validator validation struct tags.
- Implements
env
struct tags to overwrite fields from env vars if provided. - Supports
encoding.TextUnmarshaler
andyaml.Unmarshaler
(except for the root struct type). - Supports
time.Duration
.
- 🪄 If any type within your configuration struct implements the
Example
https://go.dev/play/p/PjV0aG7uIUH
list:
- foo: valid
bar: valid
- foo: valid
bar: valid
map:
valid: valid
secret: 'this will be overwritten from env var SECRET'
required: 'this must not be empty'
package main
import (
"fmt"
"github.com/romshark/yamagiconf"
)
type Config struct {
List []Struct `yaml:"list"`
Map map[ValidatedString]ValidatedString `yaml:"map"`
// Secret will be overwritten if env var SECRET is set.
Secret string `yaml:"secret" env:"SECRET"`
// See https://github.com/go-playground/validator
// for all available validation tags
Required string `yaml:"required" validate:"required"`
}
type Struct struct {
Foo string `yaml:"foo"`
Bar ValidatedString `yaml:"bar"`
}
// Validate will automatically be called by yamagiconf
func (v *Struct) Validate() error {
if v.Foo == "invalid" {
return fmt.Errorf("invalid foo")
}
if v.Bar == "invalid" {
return fmt.Errorf("invalid bar")
}
return nil
}
type ValidatedString string
// Validate will automatically be called by yamagiconf
func (v ValidatedString) Validate() error {
if v == "invalid" {
return fmt.Errorf("string is invalid")
}
return nil
}
func main() {
var c Config
if err := yamagiconf.LoadFile("./config.yaml", &c); err != nil {
fmt.Println("Whoops, something is wrong with your config!", err)
}
fmt.Printf("%#v\n", c)
}
FAQ
Why are empty array items forbidden?
Consider the following YAML array:
array:
-
- ''
- ""
- x
Even though this YAML array works as expect with a Go array:
[4]string{"", "", "", "x"}
, parsing the same YAML into a Go slice will result in
the empty item being ommited: []string{"", "", "x"}
which is counterintuitive.
Therefore, yamagiconf forbids empty array items in general to keep behavior
consistent and intuitive independent of the Go target type.