fix: normalize field policy

data/defaults.yml

@@ -32,11 +32,11 @@ settings:
 
   access:
     endpoints:
-      - !/v1/about
-      - !/v1/configuration
-      - !/v1/devices
-      - !/v1/register
-      - !/v1/unregister
-      - !/v1/qrcodelink
-      - !/v1/accounts
-      - !/v1/contacts
+      - "!/v1/about"
+      - "!/v1/configuration"
+      - "!/v1/devices"
+      - "!/v1/register"
+      - "!/v1/unregister"
+      - "!/v1/qrcodelink"
+      - "!/v1/accounts"
+      - "!/v1/contacts"

internals/config/loader.go

@@ -25,13 +25,15 @@ var ENV *structure.ENV = &structure.ENV{
 	INSECURE:      false,
 }
 
-var defaultsConf = configutils.New()
-var userConf = configutils.New()
-var tokenConf = configutils.New()
+var defaultsConf *configutils.Config
+var userConf *configutils.Config
+var tokenConf *configutils.Config
 
-var config = configutils.New()
+var mainConf *configutils.Config
 
 func Load() {
+	Clear()
+
 	InitReload()
 
 	LoadDefaults()
@@ -42,39 +44,90 @@ func Load() {
 
 	userConf.LoadEnv()
 
-	config.MergeLayers(defaultsConf.Layer, userConf.Layer)
+	NormalizeConfig(defaultsConf)
+	NormalizeConfig(userConf)
+
+	NormalizeTokens()
+
+	mainConf.MergeLayers(defaultsConf.Layer, userConf.Layer)
 
-	config.NormalizeKeys()
-	config.TemplateConfig()
+	mainConf.TemplateConfig()
 
 	InitTokens()
 
 	InitEnv()
 
 	log.Info("Finished Loading Configuration")
 
-	log.Dev("Loaded Config:\n" + jsonutils.ToJson(config.Layer.All()))
+	log.Dev("Loaded Config:\n" + jsonutils.ToJson(mainConf.Layer.All()))
 	log.Dev("Loaded Token Configs:\n" + jsonutils.ToJson(tokenConf.Layer.All()))
 }
 
+func Clear() {
+	defaultsConf = configutils.New()
+	userConf = configutils.New()
+	tokenConf = configutils.New()
+	mainConf = configutils.New()
+}
+
+func LowercaseKeys(config *configutils.Config) {
+	data := map[string]any{}
+
+	for _, key := range config.Layer.Keys() {
+		lower := strings.ToLower(key)
+
+		data[lower] = config.Layer.Get(key)
+	}
+
+	config.Layer.Delete("")
+	config.Load(data, "")
+}
+
+func NormalizeConfig(config *configutils.Config) {
+	Normalize(config, "settings", &structure.SETTINGS{})
+}
+
+func Normalize(config *configutils.Config, path string, structure any) {
+	data := config.Layer.Get(path)
+	old, ok := data.(map[string]any)
+
+	if !ok {
+		log.Warn("Could not load `"+path+"`")
+		return
+	}
+
+	// Create temporary config
+	tmpConf := configutils.New()
+	tmpConf.Load(old, "")
+
+	// Apply transforms to the new config
+	tmpConf.ApplyTransformFuncs(structure, "", transformFuncs)
+
+	// Lowercase actual config
+	LowercaseKeys(config)
+
+	// Load temporary config back into paths
+	config.Layer.Delete(path)
+
+	config.Load(tmpConf.Layer.All(), path)
+}
+
 func InitReload() {
 	defaultsConf.OnLoad(Load)
 	userConf.OnLoad(Load)
 	tokenConf.OnLoad(Load)
 }
 
 func InitEnv() {
-	ENV.PORT = strconv.Itoa(config.Layer.Int("service.port"))
+	ENV.PORT = strconv.Itoa(mainConf.Layer.Int("service.port"))
 
-	ENV.LOG_LEVEL = strings.ToLower(config.Layer.String("loglevel"))
+	ENV.LOG_LEVEL = strings.ToLower(mainConf.Layer.String("loglevel"))
 
-	ENV.API_URL = config.Layer.String("api.url")
+	ENV.API_URL = mainConf.Layer.String("api.url")
 
 	var settings structure.SETTINGS
 
-	config.TransformChildren("settings.message.variables", transformVariables)
-
-	config.Layer.Unmarshal("settings", &settings)
+	mainConf.Layer.Unmarshal("settings", &settings)
 
 	ENV.SETTINGS["*"] = &settings
 }
@@ -101,8 +154,4 @@ func LoadConfig() {
 
 		log.Error("Could not Load Config ", ENV.CONFIG_PATH, ": ", err.Error())
 	}
-}
-
-func transformVariables(key string, value any) (string, any) {
-	return strings.ToUpper(key), value
-}
+}

internals/config/parser.go

@@ -0,0 +1,23 @@
+package config
+
+import (
+	"strings"
+)
+
+var transformFuncs = map[string]func(string, any) (string, any) {
+	"default": defaultTransform,
+	"lower": lowercaseTransform,
+	"upper": uppercaseTransform,
+}
+
+func defaultTransform(key string, value any) (string, any) {
+	return key, value
+}
+
+func lowercaseTransform(key string, value any) (string, any) {
+	return strings.ToLower(key), value
+}
+
+func uppercaseTransform(key string, value any) (string, any) {
+	return strings.ToUpper(key), value
+}

internals/config/structure/structure.go

@@ -9,32 +9,32 @@ type ENV struct {
 	PORT          		string
 	API_URL       		string
 	API_TOKENS    		[]string
-	SETTINGS      		map[string]*SETTINGS
+	SETTINGS      		map[string]*SETTINGS		`koanf:"settings"`
 	INSECURE      		bool
 }
 
 type SETTINGS struct {
-	ACCESS 				ACCESS_SETTINGS 			`koanf:"access"`
-	MESSAGE				MESSAGE_SETTINGS			`koanf:"message"`
+	ACCESS 				ACCESS_SETTINGS 			`koanf:"access"        transform:"lower"`
+	MESSAGE				MESSAGE_SETTINGS			`koanf:"message"       transform:"lower"`
 }
 
 type MESSAGE_SETTINGS struct {
-	VARIABLES         	map[string]any              `koanf:"variables"`
-	FIELD_MAPPINGS      map[string][]FieldMapping	`koanf:"fieldmappings"`
-	TEMPLATE  			string                      `koanf:"template"`
+	VARIABLES         	map[string]any              `koanf:"variables"                       childtransform:"upper"`
+	FIELD_MAPPINGS      map[string][]FieldMapping	`koanf:"fieldmappings"                   childtransform:"default"`
+	TEMPLATE  			string                      `koanf:"template"      transform:"lower"`
 }
 
 type FieldMapping struct {
-	Field 				string 						`koanf:"field"`
-	Score 				int    						`koanf:"score"`
+	Field 				string 						`koanf:"field"         transform:"lower"`
+	Score 				int    						`koanf:"score"         transform:"lower"`
 }
 
 type ACCESS_SETTINGS struct {
-	ENDPOINTS			[]string					`koanf:"endpoints"`
-	FIELD_POLOCIES		map[string]FieldPolicy		`koanf:"fieldpolicies"`
+	ENDPOINTS			[]string					`koanf:"endpoints"     transform:"lower"`
+	FIELD_POLICIES		map[string]FieldPolicy		`koanf:"fieldpolicies" transform:"lower" childtransform:"default"`
 }
 
 type FieldPolicy struct {
-	Value				any						    `koanf:"value"`
-	Action				string						`koanf:"action"`
+	Value				any						    `koanf:"value"         transform:"lower"`
+	Action				string						`koanf:"action"        transform:"lower"`
 }

internals/config/tokens.go

@@ -4,11 +4,12 @@ import (
 	"strconv"
 
 	"github.com/codeshelldev/secured-signal-api/internals/config/structure"
+	"github.com/codeshelldev/secured-signal-api/utils/configutils"
 	log "github.com/codeshelldev/secured-signal-api/utils/logger"
 	"github.com/knadh/koanf/parsers/yaml"
 )
 
-type TOKEN_CONFIG_ struct {
+type TOKEN_CONFIG struct {
 	TOKENS    []string 				`koanf:"tokens"`
 	OVERRIDES structure.SETTINGS 	`koanf:"overrides"`
 }
@@ -22,17 +23,29 @@ func LoadTokens() {
 		log.Error("Could not Load Configs in ", ENV.TOKENS_DIR, ": ", err.Error())
 	}
 
-	tokenConf.NormalizeKeys()
-
 	tokenConf.TemplateConfig()
 }
 
-func InitTokens() {
-	apiTokens := config.Layer.Strings("api.tokens")
+func NormalizeTokens() {
+	configArray := []map[string]any{}
+
+	for _, config := range tokenConf.Layer.Slices("tokenconfigs") {
+		tmpConf := configutils.New()
+		tmpConf.Load(config.All(), "")
+
+		Normalize(tmpConf, "overrides", &structure.SETTINGS{})
+
+		configArray = append(configArray, tmpConf.Layer.All())
+	}
+
+	// Merge token configs together into new temporary config
+	tokenConf.Layer.Set("tokenconfigs", configArray)
+}
 
-	var tokenConfigs []TOKEN_CONFIG_
+func InitTokens() {
+	apiTokens := mainConf.Layer.Strings("api.tokens")
 
-	tokenConf.TransformChildrenUnderArray("tokenconfigs", "overrides.message.variables", transformVariables)
+	var tokenConfigs []TOKEN_CONFIG
 
 	tokenConf.Layer.Unmarshal("tokenconfigs", &tokenConfigs)
 
@@ -53,7 +66,7 @@ func InitTokens() {
 
 		// Set Blocked Endpoints on Config to User Layer Value
 		// => effectively ignoring Default Layer
-		config.Layer.Set("settings.access.endpoints", userConf.Layer.Strings("settings.access.endpoints"))
+		mainConf.Layer.Set("settings.access.endpoints", userConf.Layer.Strings("settings.access.endpoints"))
 	}
 
 	if len(apiTokens) > 0 {
@@ -63,7 +76,7 @@ func InitTokens() {
 	}
 }
 
-func parseTokenConfigs(configs []TOKEN_CONFIG_) map[string]structure.SETTINGS {
+func parseTokenConfigs(configs []TOKEN_CONFIG) map[string]structure.SETTINGS {
 	settings := map[string]structure.SETTINGS{}
 
 	for _, config := range configs {

internals/proxy/middlewares/policy.go

@@ -19,10 +19,10 @@ func policyHandler(next http.Handler) http.Handler {
 	return http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
 		settings := getSettingsByReq(req)
 
-		policies := settings.ACCESS.FIELD_POLOCIES
+		policies := settings.ACCESS.FIELD_POLICIES
 
 		if policies == nil {
-			policies = getSettings("*").ACCESS.FIELD_POLOCIES
+			policies = getSettings("*").ACCESS.FIELD_POLICIES
 		}
 
 		body, err := request.GetReqBody(req)