Implementations for yaml based configuration management.

Author: mahadev-k

README.md

@@ -96,8 +96,8 @@ func TestMapRunner(t *testing.T) {
 	floatingStrings := []string{"0.1", "0.2", "22", "22.1"}
 
 	res, err := NewTransformer[string, float64](floatingStrings).
-		Map(MapIt[string, float64](func(item string) (float64, error) { return strconv.ParseFloat(item, 64) })).
-		Map(MapIt[float64, float64](func(item float64) (float64, error) { return item * 10, nil })).
+		Transform(MapIt[string, float64](func(item string) (float64, error) { return strconv.ParseFloat(item, 64) })).
+		Transform(MapIt[float64, float64](func(item float64) (float64, error) { return item * 10, nil })).
 		Result()
 	if err != nil {
 		t.Errorf("Testcase failed with error : %v", err)
@@ -126,10 +126,10 @@ func TestFilterIt(t *testing.T) {
 	floatingStrings := []string{"0.1", "0.2", "22", "22.1"}
 
 	res, err := NewTransformer[string, int64](floatingStrings).
-		Map(MapIt[string, float64](func(item string) (float64, error) {return strconv.ParseFloat(item, 64)})).
-		Map(MapIt[float64, float64](func(item float64) (float64, error) { return item * 10, nil })).
-		Map(MapIt[float64, int64](func(item float64) (int64, error) { return int64(item), nil })).
-		Map(FilterIt[int64](func(item int64) (bool, error) { return item%2 == 0, nil })).
+		Transform(MapIt[string, float64](func(item string) (float64, error) {return strconv.ParseFloat(item, 64)})).
+		Transform(MapIt[float64, float64](func(item float64) (float64, error) { return item * 10, nil })).
+		Transform(MapIt[float64, int64](func(item float64) (int64, error) { return int64(item), nil })).
+		Transform(FilterIt[int64](func(item int64) (bool, error) { return item%2 == 0, nil })).
 		Result()
 	if err != nil {
 		t.Errorf("Testcase failed with error : %v", err)
@@ -171,10 +171,10 @@ func TestMapRunnerLib(t *testing.T) {
 	floatingStrings := []string{"0.1", "0.2", "22", "22.1"}
 
 	res, err := streams.NewTransformer[string, int64](floatingStrings).
-		Map(streams.MapIt[string, float64](func(item string) (float64, error) { return strconv.ParseFloat(item, 64) })).
-		Map(streams.MapIt[float64, float64](func(item float64) (float64, error) { return item * 10, nil })).
-		Map(streams.MapIt[float64, int64](func(item float64) (int64, error) { return int64(item), nil })).
-		Map(streams.FilterIt[int64](func(item int64) (bool, error) { return item%2 == 0, nil })).
+		Transform(streams.MapIt[string, float64](func(item string) (float64, error) { return strconv.ParseFloat(item, 64) })).
+		Transform(streams.MapIt[float64, float64](func(item float64) (float64, error) { return item * 10, nil })).
+		Transform(streams.MapIt[float64, int64](func(item float64) (int64, error) { return int64(item), nil })).
+		Transform(streams.FilterIt[int64](func(item int64) (bool, error) { return item%2 == 0, nil })).
 		Result()
 	if err != nil {
 		t.Errorf("Testcase failed with error : %v", err)
@@ -217,4 +217,29 @@ func TestSqlWriteExec_CreateOrderTxn(t *testing.T) {
 		},
 	)
 }
-```
+```
+
+## Yaml Configs
+
+```go
+func ExampleLoadConfigWithOverrides() {
+	// Load configs in order of precedence
+	_, err := yaml_configs.LoadConfigWithSuffix(
+		"./test_data/env",
+		"local",
+	)
+}
+```
+
+This will load the configs from the files in the order of precedence. 
+Values from later files override earlier ones.
+
+```go
+func ExampleGet() {
+	// Get a value from the config
+	value := yaml_configs.Get[string]("database.host")
+	fmt.Println(value)
+}
+```
+
+

go.mod

@@ -8,5 +8,5 @@ require (
 	github.com/DATA-DOG/go-sqlmock v1.5.2
 	github.com/davecgh/go-spew v1.1.1 // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
-	gopkg.in/yaml.v3 v3.0.1 // indirect
+	gopkg.in/yaml.v3 v3.0.1
 )

yaml_configs/test_data/env.local.yaml

@@ -0,0 +1,6 @@
+database:
+  host: localhost
+  port: 5430
+  user: postgres
+  password: postgres
+  dbname: postgres

yaml_configs/test_data/env.yaml

@@ -0,0 +1,7 @@
+database:
+  host: localhost
+  port: 5432
+  user: postgres
+  password: postgres
+  dbname: postgres
+

yaml_configs/yaml_configs.go

@@ -0,0 +1,131 @@
+package yaml_configs
+
+import (
+	"fmt"
+	"os"
+	"strings"
+	"sync"
+
+	"gopkg.in/yaml.v3"
+)
+
+var (
+	configDoOnce sync.Once
+	config       *Config
+)
+
+type Config struct {
+	configMap     map[string]any
+	configFlatMap map[string]any
+}
+
+// LoadConfigWithSuffix loads a config file with a suffix, and overrides the config with the suffix file
+// file path is path.suffix.yaml
+// provide path without .yaml
+func LoadConfigWithSuffix(path string, suffix string) (*Config, error) {
+	return LoadConfigWithOverrides(
+		fmt.Sprintf("%s.yaml", path),
+		fmt.Sprintf("%s.%s.yaml", path, suffix),
+	)
+}
+
+// LoadConfigWithOverrides loads configs in order, with later files overriding earlier ones
+func LoadConfigWithOverrides(paths ...string) (*Config, error) {
+	var loadErr error
+
+	configDoOnce.Do(func() {
+		config = &Config{
+			configMap:     make(map[string]any),
+			configFlatMap: make(map[string]any),
+		}
+
+		// Load each config file in order
+		for _, path := range paths {
+			if err := loadAndMerge(path, config); err != nil {
+				loadErr = err
+				return
+			}
+		}
+	})
+
+	if loadErr != nil {
+		return nil, loadErr
+	}
+	return config, nil
+}
+
+func loadAndMerge(path string, cfg *Config) error {
+	yamlFile, err := os.Open(path)
+	if err != nil {
+		if os.IsNotExist(err) {
+			// Skip if file doesn't exist
+			fmt.Printf("File %s does not exist, skipping\n", path)
+			return nil
+		}
+		return err
+	}
+	defer yamlFile.Close()
+
+	var newConfig map[string]any
+	if err := yaml.NewDecoder(yamlFile).Decode(&newConfig); err != nil {
+		return err
+	}
+
+	// Merge new config into existing
+	mergeMap(cfg.configMap, newConfig)
+
+	// Rebuild flat map
+	cfg.configFlatMap = make(map[string]any)
+	flattenConfig(cfg.configMap, "", cfg.configFlatMap)
+
+	return nil
+}
+
+// mergeMap recursively merges src into dst
+func mergeMap(dst, src map[string]any) {
+	for key, srcVal := range src {
+		if dstVal, exists := dst[key]; exists {
+			// If both are maps, merge recursively
+			if dstMap, ok := dstVal.(map[string]any); ok {
+				if srcMap, ok := srcVal.(map[string]any); ok {
+					mergeMap(dstMap, srcMap)
+					continue
+				}
+			}
+		}
+		// Otherwise override the value
+		dst[key] = srcVal
+	}
+}
+
+func flattenConfig(configMap map[string]any, prefix string, flatMap map[string]any) {
+	for key, value := range configMap {
+		var newKey string
+		if prefix == "" {
+			newKey = key
+		} else {
+			newKey = fmt.Sprintf("%s.%s", prefix, key)
+		}
+		if nestedMap, ok := value.(map[string]any); ok {
+			flattenConfig(nestedMap, newKey, flatMap)
+		} else {
+
+			flatMap[newKey] = value
+			flatMap[strings.ToUpper(newKey)] = value
+			flatMap[strings.ToLower(newKey)] = value
+			flatMap[strings.ReplaceAll(newKey, ".", "_")] = value
+		}
+	}
+}
+
+func (c *Config) Get(key string) any {
+	return c.configFlatMap[key]
+}
+
+func Get[T any](key string) T {
+	value, ok := config.configFlatMap[key]
+	if !ok {
+		return *new(T)
+	}
+	return value.(T)
+}

yaml_configs/yaml_configs_test.go

@@ -0,0 +1,29 @@
+package yaml_configs
+
+import (
+	"fmt"
+	"log"
+)
+
+func ExampleLoadConfigWithOverrides() {
+	// Load configs in order of precedence
+	_, err := LoadConfigWithSuffix(
+		"./test_data/env",
+		"local",
+	)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	// Values from later files override earlier ones
+	fmt.Println(Get[string]("database.host"))
+	fmt.Println(Get[int]("database.port"))
+	fmt.Println(Get[string]("database.dbname"))
+	fmt.Println(Get[string]("database.user"))
+	fmt.Println(Get[string]("database.password"))
+	// Output: localhost
+	// 5430
+	// postgres
+	// postgres
+	// postgres
+}