refactor: rework decoders using simpler and more efficient pattern

internal/utils/decoders/env_decoder.go

@@ -1,37 +1,16 @@
 package decoders
 
 import (
-	"fmt"
-	"slices"
-	"sort"
-	"strings"
 	"tinyauth/internal/config"
 
 	"github.com/traefik/paerser/parser"
 )
 
-// Based on https://github.com/traefik/paerser/blob/master/parser/labels_decode.go
-
 func DecodeEnv(env map[string]string) (config.Providers, error) {
-	normalized := normalizeEnv(env, "tinyauth")
-
-	node, err := decodeEnvsToNode(normalized, "tinyauth", "tinyauth_providers")
-
-	if err != nil {
-		return config.Providers{}, err
-	}
-
+	normalized := NormalizeKeys(env, "tinyauth", "_")
 	var providers config.Providers
 
-	metaOpts := parser.MetadataOpts{TagName: "env", AllowSliceAsStruct: true}
-
-	err = parser.AddMetadata(&providers, node, metaOpts)
-
-	if err != nil {
-		return config.Providers{}, err
-	}
-
-	err = parser.Fill(&providers, node, parser.FillerOpts{AllowSliceAsStruct: true})
+	err := parser.Decode(normalized, &providers, "tinyauth", "tinyauth.providers")
 
 	if err != nil {
 		return config.Providers{}, err
@@ -39,99 +18,3 @@ func DecodeEnv(env map[string]string) (config.Providers, error) {
 
 	return providers, nil
 }
-
-func decodeEnvsToNode(env map[string]string, rootName string, filters ...string) (*parser.Node, error) {
-	sorted := sortEnvKeys(env, filters)
-
-	var node *parser.Node
-
-	for i, k := range sorted {
-		split := strings.SplitN(k, "_", 4) // Something like PROVIDERS_MY_AWESOME_CLIENT is not supported because it will confuse the parser
-
-		if split[0] != rootName {
-			return nil, fmt.Errorf("invalid env root %s", split[0])
-		}
-
-		if slices.Contains(split, "") {
-			return nil, fmt.Errorf("invalid element: %s", k)
-		}
-
-		if i == 0 {
-			node = &parser.Node{}
-		}
-
-		decodeEnvToNode(node, split, env[k])
-	}
-
-	return node, nil
-}
-
-func decodeEnvToNode(root *parser.Node, path []string, value string) {
-	if len(root.Name) == 0 {
-		root.Name = path[0]
-	}
-
-	if len(path) <= 1 {
-		root.Value = value
-		return
-	}
-
-	if n := containsEnvNode(root.Children, path[1]); n != nil {
-		decodeEnvToNode(n, path[1:], value)
-		return
-	}
-
-	child := &parser.Node{Name: path[1]}
-	decodeEnvToNode(child, path[1:], value)
-	root.Children = append(root.Children, child)
-}
-
-func containsEnvNode(node []*parser.Node, name string) *parser.Node {
-	for _, n := range node {
-		if strings.EqualFold(n.Name, name) {
-			return n
-		}
-	}
-	return nil
-}
-
-func sortEnvKeys(env map[string]string, filters []string) []string {
-	var sorted []string
-
-	for k := range env {
-		if len(filters) == 0 {
-			sorted = append(sorted, k)
-			continue
-		}
-
-		for _, f := range filters {
-			if strings.HasPrefix(k, f) {
-				sorted = append(sorted, k)
-				break
-			}
-		}
-	}
-
-	sort.Strings(sorted)
-	return sorted
-}
-
-// normalizeEnv converts env vars from PROVIDERS_CLIENT1_CLIENT_ID to tinyauth_providers_client_clientId
-func normalizeEnv(env map[string]string, rootName string) map[string]string {
-	n := make(map[string]string)
-	for k, v := range env {
-		fk := strings.ToLower(k)
-		fks := strings.SplitN(fk, "_", 3)
-		fkb := ""
-		for i, s := range strings.Split(fks[len(fks)-1], "_") {
-			if i == 0 {
-				fkb += s
-				continue
-			}
-			fkb += strings.ToUpper(string([]rune(s)[0])) + string([]rune(s)[1:])
-		}
-		fk = rootName + "_" + strings.Join(fks[:len(fks)-1], "_") + "_" + fkb
-		n[fk] = v
-	}
-	return n
-}