chore: restructure and move

internals/config/loader.go

@@ -4,7 +4,6 @@ import (
 	"errors"
 	"io/fs"
 	"os"
-	"strconv"
 	"strings"
 
 	"github.com/codeshelldev/gotl/pkg/configutils"
@@ -20,11 +19,12 @@ var ENV *structure.ENV = &structure.ENV{
 	DEFAULTS_PATH: os.Getenv("DEFAULTS_PATH"),
 	TOKENS_DIR:    os.Getenv("TOKENS_DIR"),
 	FAVICON_PATH:  os.Getenv("FAVICON_PATH"),
-	API_TOKENS:    []string{},
-	SETTINGS:      map[string]*structure.SETTINGS{},
+	CONFIGS:      	map[string]*structure.CONFIG{},
 	INSECURE:      false,
 }
 
+var DEFAULT	*structure.CONFIG
+
 var defaultsConf *configutils.Config
 var userConf *configutils.Config
 var tokenConf *configutils.Config
@@ -86,7 +86,7 @@ func LowercaseKeys(config *configutils.Config) {
 }
 
 func NormalizeConfig(config *configutils.Config) {
-	Normalize(config, "settings", &structure.SETTINGS{})
+	Normalize(config, "", &structure.CONFIG{})
 }
 
 func Normalize(config *configutils.Config, path string, structure any) {
@@ -127,17 +127,13 @@ func InitReload() {
 }
 
 func InitEnv() {
-	ENV.PORT = strconv.Itoa(mainConf.Layer.Int("service.port"))
-
-	ENV.LOG_LEVEL = strings.ToLower(mainConf.Layer.String("loglevel"))
-
-	ENV.API_URL = mainConf.Layer.String("api.url")
+	var config structure.CONFIG
 
-	var settings structure.SETTINGS
+	mainConf.Layer.Unmarshal("", &config)
 
-	mainConf.Layer.Unmarshal("settings", &settings)
+	ENV.CONFIGS["*"] = &config
 
-	ENV.SETTINGS["*"] = &settings
+	DEFAULT = ENV.CONFIGS["*"]
 }
 
 func LoadDefaults() {
@@ -165,11 +161,3 @@ func LoadConfig() {
 		log.Error("Could not Load Config ", ENV.CONFIG_PATH, ": ", err.Error())
 	}
 }
-
-func normalizeEnv(key string, value string) (string, any) {
-	key = strings.ToLower(key)
-	key = strings.ReplaceAll(key, "__", ".")
-	key = strings.ReplaceAll(key, "_", "")
-
-	return key, stringutils.ToType(value)
-}

internals/config/parser.go

@@ -5,12 +5,13 @@ import (
 )
 
 var transformFuncs = map[string]func(string, any) (string, any) {
-	"default": defaultTransform,
+	"default": lowercaseTransform,
 	"lower": lowercaseTransform,
 	"upper": uppercaseTransform,
+	"keep":  keepTransform,
 }
 
-func defaultTransform(key string, value any) (string, any) {
+func keepTransform(key string, value any) (string, any) {
 	return key, value
 }
 

internals/config/structure/structure.go

@@ -5,36 +5,49 @@ type ENV struct {
 	DEFAULTS_PATH 		string
 	FAVICON_PATH  		string
 	TOKENS_DIR    		string
-	LOG_LEVEL     		string
-	PORT          		string
-	API_URL       		string
-	API_TOKENS    		[]string
-	SETTINGS      		map[string]*SETTINGS		`koanf:"settings"`
 	INSECURE      		bool
+
+	CONFIGS      		map[string]*CONFIG
+}
+
+type CONFIG struct {
+	SERVICE				SERVICE 					`koanf:"service"`
+	API					API						    `koanf:"api"`
+	SETTINGS      		SETTINGS					`koanf:"settings"        aliases:"overrides"`
+}
+
+type SERVICE struct {
+	PORT				string						`koanf:"port"`
+	LOG_LEVEL			string						`koanf:"loglevel"`
+}
+
+type API struct {
+	URL					string						`koanf:"url"`
+	TOKENS				[]string					`koanf:"tokens"          aliases:"token"`
 }
 
 type SETTINGS struct {
-	ACCESS 				ACCESS_SETTINGS 			`koanf:"access"        transform:"lower"`
-	MESSAGE				MESSAGE_SETTINGS			`koanf:"message"       transform:"lower"`
+	ACCESS 				ACCESS_SETTINGS 			`koanf:"access"`
+	MESSAGE				MESSAGE_SETTINGS			`koanf:"message"`
 }
 
 type MESSAGE_SETTINGS struct {
-	VARIABLES         	map[string]any              `koanf:"variables"                       childtransform:"upper"`
-	FIELD_MAPPINGS      map[string][]FieldMapping	`koanf:"fieldmappings"                   childtransform:"default"`
-	TEMPLATE  			string                      `koanf:"template"      transform:"lower"`
+	VARIABLES         	map[string]any              `koanf:"variables"       childtransform:"upper"`
+	FIELD_MAPPINGS      map[string][]FieldMapping	`koanf:"fieldmappings"   childtransform:"default"`
+	TEMPLATE  			string                      `koanf:"template"`
 }
 
 type FieldMapping struct {
-	Field 				string 						`koanf:"field"         transform:"lower"`
-	Score 				int    						`koanf:"score"         transform:"lower"`
+	Field 				string 						`koanf:"field"`
+	Score 				int    						`koanf:"score"`
 }
 
 type ACCESS_SETTINGS struct {
-	ENDPOINTS			[]string					`koanf:"endpoints"     transform:"lower"`
-	FIELD_POLICIES		map[string]FieldPolicy		`koanf:"fieldpolicies" transform:"lower" childtransform:"default"`
+	ENDPOINTS			[]string					`koanf:"endpoints"`
+	FIELD_POLICIES		map[string]FieldPolicy		`koanf:"fieldpolicies"   childtransform:"default"`
 }
 
 type FieldPolicy struct {
-	Value				any						    `koanf:"value"         transform:"lower"`
-	Action				string						`koanf:"action"        transform:"lower"`
+	Value				any						    `koanf:"value"`
+	Action				string						`koanf:"action"`
 }

internals/config/tokens.go

@@ -9,11 +9,6 @@ import (
 	"github.com/knadh/koanf/parsers/yaml"
 )
 
-type TOKEN_CONFIG struct {
-	TOKENS    []string 				`koanf:"tokens"`
-	OVERRIDES structure.SETTINGS 	`koanf:"overrides"`
-}
-
 func LoadTokens() {
 	log.Debug("Loading Configs in ", ENV.TOKENS_DIR)
 
@@ -45,16 +40,16 @@ func NormalizeTokens() {
 func InitTokens() {
 	apiTokens := mainConf.Layer.Strings("api.tokens")
 
-	var tokenConfigs []TOKEN_CONFIG
+	var tokenConfigs []structure.CONFIG
 
 	tokenConf.Layer.Unmarshal("tokenconfigs", &tokenConfigs)
 
-	overrides := parseTokenConfigs(tokenConfigs)
+	config := parseTokenConfigs(tokenConfigs)
 
-	for token, override := range overrides {
+	for token, config := range config {
 		apiTokens = append(apiTokens, token)
 
-		ENV.SETTINGS[token] = &override
+		ENV.CONFIGS[token] = &config
 	}
 
 	if len(apiTokens) <= 0 {
@@ -71,19 +66,17 @@ func InitTokens() {
 
 	if len(apiTokens) > 0 {
 		log.Debug("Registered " + strconv.Itoa(len(apiTokens)) + " Tokens")
-
-		ENV.API_TOKENS = apiTokens
 	}
 }
 
-func parseTokenConfigs(configs []TOKEN_CONFIG) map[string]structure.SETTINGS {
-	settings := map[string]structure.SETTINGS{}
+func parseTokenConfigs(configArray []structure.CONFIG) map[string]structure.CONFIG {
+	configs := map[string]structure.CONFIG{}
 
-	for _, config := range configs {
-		for _, token := range config.TOKENS {
-			settings[token] = config.OVERRIDES
+	for _, config := range configArray {
+		for _, token := range config.API.TOKENS {
+			configs[token] = config
 		}
 	}
 
-	return settings
+	return configs
 }

internals/proxy/middlewares/auth.go

@@ -3,6 +3,7 @@ package middlewares
 import (
 	"context"
 	"encoding/base64"
+	"maps"
 	"net/http"
 	"slices"
 	"strings"
@@ -17,7 +18,12 @@ var Auth Middleware = Middleware{
 }
 
 func authHandler(next http.Handler) http.Handler {
-	tokens := config.ENV.API_TOKENS
+	tokenKeys := maps.Keys(config.ENV.CONFIGS)
+	tokens := slices.Collect(tokenKeys)
+
+	if tokens == nil {
+		tokens = []string{}
+	}
 
 	return http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
 		if len(tokens) <= 0 {

internals/proxy/middlewares/common.go

@@ -24,22 +24,18 @@ type contextKey string
 
 const tokenKey contextKey = "token"
 
-func getSettingsByReq(req *http.Request) *structure.SETTINGS {
-	token, ok := req.Context().Value(tokenKey).(string)
+func getConfigByReq(req *http.Request) *structure.CONFIG {
+	token := req.Context().Value(tokenKey).(string)
 
-	if !ok {
-		token = "*"
-	}
-
-	return getSettings(token)
+	return getConfig(token)
 }
 
-func getSettings(token string) *structure.SETTINGS {
-	settings, exists := config.ENV.SETTINGS[token]
+func getConfig(token string) *structure.CONFIG {
+	conf, exists := config.ENV.CONFIGS[token]
 
-	if !exists || settings == nil {
-		settings = config.ENV.SETTINGS["*"]
+	if !exists || conf == nil {
+		conf = config.DEFAULT
 	}
 
-	return settings
+	return conf
 }

internals/proxy/middlewares/endpoints.go

@@ -16,12 +16,12 @@ var Endpoints Middleware = Middleware{
 
 func endpointsHandler(next http.Handler) http.Handler {
 	return http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
-		settings := getSettingsByReq(req)
+		conf := getConfigByReq(req)
 
-		endpoints := settings.ACCESS.ENDPOINTS
+		endpoints := conf.SETTINGS.ACCESS.ENDPOINTS
 
 		if endpoints == nil {
-			endpoints = getSettings("*").ACCESS.ENDPOINTS
+			endpoints = getConfig("").SETTINGS.ACCESS.ENDPOINTS
 		}
 
 		reqPath := req.URL.Path

internals/proxy/middlewares/mapping.go

@@ -16,16 +16,17 @@ var Mapping Middleware = Middleware{
 
 func mappingHandler(next http.Handler) http.Handler {
 	return http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
-		settings := getSettingsByReq(req)
+		conf := getConfigByReq(req)
 
-		fieldMappings := settings.MESSAGE.FIELD_MAPPINGS
+		variables := conf.SETTINGS.MESSAGE.VARIABLES
+		fieldMappings := conf.SETTINGS.MESSAGE.FIELD_MAPPINGS
 
 		if fieldMappings == nil {
-			fieldMappings = getSettings("*").MESSAGE.FIELD_MAPPINGS
+			fieldMappings = getConfig("").SETTINGS.MESSAGE.FIELD_MAPPINGS
 		}
 
-		if settings.MESSAGE.VARIABLES == nil {
-			settings.MESSAGE.VARIABLES = getSettings("*").MESSAGE.VARIABLES
+		if variables == nil {
+			variables = getConfig("").SETTINGS.MESSAGE.VARIABLES
 		}
 
 		body, err := request.GetReqBody(req)
@@ -53,7 +54,7 @@ func mappingHandler(next http.Handler) http.Handler {
 					bodyData[keyWithoutPrefix] = value
 					modifiedBody = true
 				case ".":
-					settings.MESSAGE.VARIABLES[keyWithoutPrefix] = value
+					variables[keyWithoutPrefix] = value
 				}
 			}
 		}

internals/proxy/middlewares/message.go

@@ -14,17 +14,17 @@ var Message Middleware = Middleware{
 
 func messageHandler(next http.Handler) http.Handler {
 	return http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
-		settings := getSettingsByReq(req)
+		conf := getConfigByReq(req)
 
-		variables := settings.MESSAGE.VARIABLES
-		messageTemplate := settings.MESSAGE.TEMPLATE
+		variables := conf.SETTINGS.MESSAGE.VARIABLES
+		messageTemplate := conf.SETTINGS.MESSAGE.TEMPLATE
 
 		if variables == nil {
-			variables = getSettings("*").MESSAGE.VARIABLES
+			variables = getConfig("").SETTINGS.MESSAGE.VARIABLES
 		}
 
 		if messageTemplate == "" {
-			messageTemplate = getSettings("*").MESSAGE.TEMPLATE
+			messageTemplate = getConfig("").SETTINGS.MESSAGE.TEMPLATE
 		}
 
 		body, err := request.GetReqBody(req)

internals/proxy/middlewares/policy.go

@@ -18,12 +18,12 @@ var Policy Middleware = Middleware{
 
 func policyHandler(next http.Handler) http.Handler {
 	return http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
-		settings := getSettingsByReq(req)
+		conf := getConfigByReq(req)
 
-		policies := settings.ACCESS.FIELD_POLICIES
+		policies := conf.SETTINGS.ACCESS.FIELD_POLICIES
 
 		if policies == nil {
-			policies = getSettings("*").ACCESS.FIELD_POLICIES
+			policies = getConfig("").SETTINGS.ACCESS.FIELD_POLICIES
 		}
 
 		body, err := request.GetReqBody(req)

internals/proxy/middlewares/template.go

@@ -22,10 +22,12 @@ var Template Middleware = Middleware{
 
 func templateHandler(next http.Handler) http.Handler {
 	return http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
-		variables := getSettingsByReq(req).MESSAGE.VARIABLES
+		conf := getConfigByReq(req)
+
+		variables := conf.SETTINGS.MESSAGE.VARIABLES
 
 		if variables == nil {
-			variables = getSettings("*").MESSAGE.VARIABLES
+			variables = getConfig("").SETTINGS.MESSAGE.VARIABLES
 		}
 
 		body, err := request.GetReqBody(req)