job-search/internal/config/config.go

package config

import (
	"encoding/json"
	"fmt"
	"log/slog"
	"maps"
	"reflect"
	"slices"
	"strings"

	"github.com/spf13/viper"
	"go.yaml.in/yaml/v3"
)

// EnvPrefix prefixes environment variables that override configuration keys,
// e.g. JOBSEARCH_LOGGING_LEVEL for logging.level.
const EnvPrefix string = "JOBSEARCH"

// EtcConfigPath is searched for config.* when no config file is given, before
// the working directory.
const EtcConfigPath string = "/etc/job-search"

// JobSearchConfig is the application's whole configuration, one field per
// section. Each field's cfg tag must match the section's JSCK* constant.
type JobSearchConfig struct {
	Database JSCDatabase `cfg:"database"`
	Logging  JSCLogging  `cfg:"logging"`
	Server   JSCServer   `cfg:"server"`
	Sources  JSCSources  `cfg:"sources"`
}

// LoadDefaultConfig sets Viper's defaults from the configuration's default
// struct tags.
func LoadDefaultConfig() {
	var conf JobSearchConfig
	if err := applyDefaults(&conf); err != nil {
		panic(fmt.Sprintf("config: %v", err))
	}
	LoadToViper(conf)
}

// ---------- Section methods (see Section) ----------

func (c JobSearchConfig) Map() map[string]any { return mapOf(c) }

func (c JobSearchConfig) Flatten() map[string]any { return flattenOf("", c) }

func (c JobSearchConfig) TypeOf(key string) (reflect.Kind, error) {
	return typeOf(c, key)
}

func (c JobSearchConfig) ValueOf(key string) (any, error) {
	return valueOf(c, key)
}

func (c *JobSearchConfig) SetValue(key string, value any) error {
	return setValue(c, key, value)
}

// LoadFromViper copies every key Viper knows that conf also has into conf.
// Unknown keys are skipped; invalid values are logged and ignored.
func LoadFromViper(conf *JobSearchConfig) {
	keys := viper.AllKeys()
	for idx := range keys {
		key := keys[idx]
		keyType, _ := conf.TypeOf(key)
		if keyType == reflect.Invalid {
			continue
		}
		value, ok := viperValue(key, keyType)
		if !ok {
			slog.Error(fmt.Sprintf("unknown key type: %s", keyType))
			continue
		}
		if err := conf.SetValue(key, value); err != nil {
			slog.Warn("ignoring invalid config value", "key", key, "err", err)
		}
	}
}

// viperValue reads key from Viper as a value of kind. ok is false for a kind
// LoadFromViper doesn't handle.
func viperValue(key string, kind reflect.Kind) (value any, ok bool) {
	switch kind {
	case reflect.String:
		return viper.GetString(key), true
	case reflect.Int:
		return viper.GetInt(key), true
	case reflect.Bool:
		return viper.GetBool(key), true
	case reflect.Slice:
		// A string, e.g. from an environment variable, is passed on for
		// SetValue to split on commas; GetStringSlice would split it on
		// spaces. A list of objects (a list of sections) is passed on as it
		// is, as GetStringSlice would flatten it.
		switch v := viper.Get(key).(type) {
		case string:
			return v, true
		case []map[string]any: // as LoadToViper sets it
			return v, true
		case []any:
			if len(v) > 0 {
				if _, ok := v[0].(map[string]any); ok {
					return v, true
				}
			}
		}
		return viper.GetStringSlice(key), true
	}
	return nil, false
}

// LoadToViper sets every key of conf as a Viper default.
func LoadToViper(conf JobSearchConfig) {
	flatMap := conf.Flatten()
	for key := range flatMap {
		viper.SetDefault(key, flatMap[key])
	}
}

// String formats the configuration one "key = value <type>" line per key, with
// dotted keys, sorted by key.
func (conf JobSearchConfig) String() string {
	var sb strings.Builder
	flat := conf.Flatten()
	for _, k := range slices.Sorted(maps.Keys(flat)) {
		typ, _ := conf.TypeOf(k)
		fmt.Fprint(&sb, k, " = ", flat[k], " <", typ, ">\n")
	}
	return sb.String()
}

// JSON formats the configuration as indented JSON.
func (conf JobSearchConfig) JSON() string {
	confMap := conf.Map()
	jbytes, _ := json.MarshalIndent(confMap, "", "  ")
	return string(jbytes)
}

// YAML formats the configuration as YAML.
func (conf JobSearchConfig) YAML() string {
	confMap := conf.Map()
	ybytes, _ := yaml.Marshal(confMap)
	return string(ybytes)
}