config

Overview ¶

Package config provides a simple, structured, and extensible way to manage application configuration in Go.

It builds upon the Viper library and adds powerful features like validation, dynamic watching, default value registration, environment and flag integration, and structured config registration.

Key Features:

• Register typed configuration structs with default values.
• Parse YAML configuration files and bind fields to CLI flags and environment variables.
• Automatically generate flags based on struct field tags.
• Validate configuration using custom logic (via `Validate()` method).
• Watch configuration files for changes and hot-reload updated values.
• Write current configuration back to disk.
• Automatically fallbacks to default config creation if no file is found.

All configuration structs must implement the `Config` interface:

type Config interface {
    Validate() error
}

Example:

package config

import (
    "fmt"
    "github.com/valentin-kaiser/go-core/config"
    "github.com/valentin-kaiser/go-core/flag"
    "github.com/fsnotify/fsnotify"
)

type ServerConfig struct {
    Host string `yaml:"host" usage:"The host of the server"`
    Port int    `yaml:"port" usage:"The port of the server"`
}

func (c *ServerConfig) Validate() error {
    if c.Host == "" {
        return fmt.Errorf("host cannot be empty")
    }
    if c.Port <= 0 {
        return fmt.Errorf("port must be greater than 0")
    }
    return nil
}

func Get() *ServerConfig {
    c, ok := config.Get().(*ServerConfig)
    if !ok {
        return &ServerConfig{}
    }
    return c
}

func init() {
    cfg := &ServerConfig{
        Host: "localhost",
        Port: 8080,
    }

    // Register config - path parameter is ignored, flag.Path will be used
    if err := config.Register("", "server", cfg); err != nil {
        fmt.Println("Error registering config:", err)
        return
    }

    // Parse flags (including --path and config-specific flags)
    flag.Init()

    // Read config using the parsed --path flag
    if err := config.Read(); err != nil {
        fmt.Println("Error reading config:", err)
        return
    }

    config.Watch(func(e fsnotify.Event) {
        if err := config.Read(); err != nil {
            fmt.Println("Error reloading config:", err)
        }
    })

    if err := config.Write(cfg); err != nil {
        fmt.Println("Error writing config:", err)
    }
}