127 lines
3.3 KiB
Go
127 lines
3.3 KiB
Go
package configtypes
|
|
|
|
import (
|
|
"encoding/json"
|
|
"fmt"
|
|
"reflect"
|
|
|
|
"github.com/go-viper/mapstructure/v2"
|
|
)
|
|
|
|
type StringKeyValue struct {
|
|
// Key is the key of the key/value pair. Must be unique within a StringKeyValues list.
|
|
Key string `mapstructure:"key" json:"key" envconfig:"key" yaml:"key" toml:"key" expose:"full" doc:"Key of the key/value pair. Must be unique within the list."`
|
|
// Value is the value of the key/value pair.
|
|
Value string `mapstructure:"value" json:"value" envconfig:"value" yaml:"value" toml:"value" doc:"Value of the key/value pair. Supports <<\\${ENV_VAR}>> expansion from environment variables."`
|
|
}
|
|
|
|
type StringKeyValues []StringKeyValue
|
|
|
|
// ToMap converts StringKeyValues to a map[string]string for easier lookups.
|
|
func (s *StringKeyValues) ToMap() map[string]string {
|
|
if s == nil {
|
|
return nil
|
|
}
|
|
m := make(map[string]string, len(*s))
|
|
for _, kv := range *s {
|
|
m[kv.Key] = kv.Value
|
|
}
|
|
return m
|
|
}
|
|
|
|
func (s *StringKeyValues) Decode(value string) error {
|
|
// Try decoding as map[string]string first (simpler syntax).
|
|
var m map[string]string
|
|
if err := json.Unmarshal([]byte(value), &m); err == nil {
|
|
// Convert map to slice, applying env var expansion
|
|
if err := expandEnvVars(m); err != nil {
|
|
return err
|
|
}
|
|
result := make([]StringKeyValue, 0, len(m))
|
|
for k, v := range m {
|
|
result = append(result, StringKeyValue{Key: k, Value: v})
|
|
}
|
|
*s = result
|
|
return nil
|
|
}
|
|
|
|
// If that fails, try decoding as slice of key/value objects.
|
|
var kvList []StringKeyValue
|
|
if err := json.Unmarshal([]byte(value), &kvList); err != nil {
|
|
return fmt.Errorf("cannot decode StringKeyValues: %w", err)
|
|
}
|
|
|
|
// Validate and apply env var expansion
|
|
m2 := make(map[string]string)
|
|
for i, kv := range kvList {
|
|
if _, exists := m2[kv.Key]; exists {
|
|
return fmt.Errorf("duplicate key %q at element %d", kv.Key, i)
|
|
}
|
|
m2[kv.Key] = kv.Value
|
|
}
|
|
|
|
if err := expandEnvVars(m2); err != nil {
|
|
return err
|
|
}
|
|
|
|
// Update values with expanded env vars
|
|
for i := range kvList {
|
|
kvList[i].Value = m2[kvList[i].Key]
|
|
}
|
|
|
|
*s = kvList
|
|
return nil
|
|
}
|
|
|
|
func StringToStringKeyValuesHookFunc() mapstructure.DecodeHookFunc {
|
|
return func(f reflect.Type, t reflect.Type, data any) (any, error) {
|
|
if t != reflect.TypeOf(StringKeyValues{}) {
|
|
return data, nil
|
|
}
|
|
|
|
// Only support slice of key/value objects.
|
|
v, ok := data.([]any)
|
|
if !ok {
|
|
return nil, fmt.Errorf("unsupported type %T for StringKeyValues, expected slice of key/value objects", data)
|
|
}
|
|
|
|
result := make([]StringKeyValue, 0, len(v))
|
|
m := make(map[string]string)
|
|
for i, item := range v {
|
|
kvMap, ok := item.(map[string]any)
|
|
if !ok {
|
|
return nil, fmt.Errorf("expected map for element %d, got %T", i, item)
|
|
}
|
|
|
|
keyI, ok := kvMap["key"].(string)
|
|
if !ok {
|
|
return nil, fmt.Errorf("missing or invalid key in element %d", i)
|
|
}
|
|
|
|
if _, exists := m[keyI]; exists {
|
|
return nil, fmt.Errorf("duplicate key %q at element %d", keyI, i)
|
|
}
|
|
|
|
valI, ok := kvMap["value"].(string)
|
|
if !ok {
|
|
return nil, fmt.Errorf("missing or invalid value in element %d", i)
|
|
}
|
|
|
|
m[keyI] = valI
|
|
result = append(result, StringKeyValue{Key: keyI, Value: valI})
|
|
}
|
|
|
|
// Apply env var expansion
|
|
if err := expandEnvVars(m); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// Update values with expanded env vars
|
|
for i := range result {
|
|
result[i].Value = m[result[i].Key]
|
|
}
|
|
|
|
return StringKeyValues(result), nil
|
|
}
|
|
}
|