refactor: Replace switch statement with map-based config parsing

config/config.go

@@ -8,83 +8,105 @@ import (
 	"github.com/rs/zerolog"
 )
 
+// Environment variable names
+const (
+	EnvLogLevel        = "LOG_LEVEL"
+	EnvRootPath        = "ROOT_PATH"
+	EnvNumWorkers      = "NUM_OF_WORKERS"
+	EnvWorkerBatchSize = "WORKER_BATCH_SIZE"
+	EnvMaxResponseSize = "MAX_RESPONSE_SIZE"
+	EnvResponseTimeout = "RESPONSE_TIMEOUT"
+)
+
+// Config holds the application configuration loaded from environment variables
 type Config struct {
-	LogLevel        zerolog.Level
+	LogLevel        zerolog.Level // Logging level (debug, info, warn, error)
-	rootPath        string
+	RootPath        string        // Root path for the application
-	MaxResponseSize int
+	MaxResponseSize int           // Maximum size of response in bytes
-	NumOfWorkers    int
+	NumOfWorkers    int           // Number of concurrent workers
-	ResponseTimeout int
+	ResponseTimeout int           // Timeout for responses in seconds
-	WorkerBatchSize int
+	WorkerBatchSize int          // Batch size for worker processing
 }
 
 var CONFIG Config
 
-func GetConfig() *Config {
+// parsePositiveInt parses and validates positive integer values
-	var config Config
+func parsePositiveInt(value string) (int, error) {
-	for _, envVar := range []string{
+	val, err := strconv.Atoi(value)
-		"LOG_LEVEL",
-		"ROOT_PATH",
-		"NUM_OF_WORKERS",
-		"WORKER_BATCH_SIZE",
-		"MAX_RESPONSE_SIZE",
-		"RESPONSE_TIMEOUT",
-	} {
-		if env, ok := os.LookupEnv(envVar); !ok {
-			fmt.Fprintf(os.Stderr, "Missing env var %s\n", envVar)
-			os.Exit(1)
-		} else {
-			switch envVar {
-			case "LOG_LEVEL":
-				{
-					logLevel, err := zerolog.ParseLevel(env)
 	if err != nil {
-						fmt.Fprintf(os.Stderr, "Invalid LOG_LEVEL value\n")
+		return 0, err
-						os.Exit(1)
 	}
-					config.LogLevel = logLevel
+	if val <= 0 {
+		return 0, fmt.Errorf("value must be positive")
 	}
-			case "ROOT_PATH":
+	return val, nil
-				{
+}
-					config.rootPath = env
+
-				}
+// GetConfig loads and validates configuration from environment variables
-			case "NUM_OF_WORKERS":
+func GetConfig() *Config {
-				{
+	config := &Config{}
-					if numOfWorkers, err := strconv.Atoi(env); err != nil {
+	
-						fmt.Fprintf(os.Stderr, "Invalid NUM_OF_WORKERS value\n")
+	// Map of environment variables to their parsing functions
-						os.Exit(1)
+	parsers := map[string]func(string) error{
-					} else {
+		EnvLogLevel: func(v string) error {
-						config.NumOfWorkers = numOfWorkers
+			level, err := zerolog.ParseLevel(v)
-					}
+			if err != nil {
-				}
+				return fmt.Errorf("invalid log level: %w", err)
-			case "WORKER_BATCH_SIZE":
+			}
-				{
+			config.LogLevel = level
-					if workerBatchSize, err := strconv.Atoi(env); err != nil {
+			return nil
-						fmt.Fprintf(os.Stderr, "Invalid WORKER_BATCH_SIZE value\n")
+		},
-						os.Exit(1)
+		EnvRootPath: func(v string) error {
-					} else {
+			config.RootPath = v
-						config.WorkerBatchSize = workerBatchSize
+			return nil
-					}
+		},
-				}
+		EnvNumWorkers: func(v string) error {
-			case "MAX_RESPONSE_SIZE":
+			val, err := parsePositiveInt(v)
-				{
+			if err != nil {
-					if maxResponseSize, err := strconv.Atoi(env); err != nil {
+				return fmt.Errorf("invalid number of workers: %w", err)
-						fmt.Fprintf(os.Stderr, "Invalid MAX_RESPONSE_SIZE value\n")
+			}
-						os.Exit(1)
+			config.NumOfWorkers = val
-					} else {
+			return nil
-						config.MaxResponseSize = maxResponseSize
+		},
-					}
+		EnvWorkerBatchSize: func(v string) error {
-				}
+			val, err := parsePositiveInt(v)
-			case "RESPONSE_TIMEOUT":
+			if err != nil {
-				{
+				return fmt.Errorf("invalid worker batch size: %w", err)
-					if val, err := strconv.Atoi(env); err != nil {
+			}
-						fmt.Fprintf(os.Stderr, "Invalid RESPONSE_TIMEOUT value\n")
+			config.WorkerBatchSize = val
-						os.Exit(1)
+			return nil
-					} else {
+		},
-						config.ResponseTimeout = val
+		EnvMaxResponseSize: func(v string) error {
-					}
+			val, err := parsePositiveInt(v)
-				}
+			if err != nil {
-			}
+				return fmt.Errorf("invalid max response size: %w", err)
-		}
+			}
-	}
+			config.MaxResponseSize = val
-	return &config
+			return nil
+		},
+		EnvResponseTimeout: func(v string) error {
+			val, err := parsePositiveInt(v)
+			if err != nil {
+				return fmt.Errorf("invalid response timeout: %w", err)
+			}
+			config.ResponseTimeout = val
+			return nil
+		},
+	}
+
+	// Process each environment variable
+	for envVar, parser := range parsers {
+		value, ok := os.LookupEnv(envVar)
+		if !ok {
+			fmt.Fprintf(os.Stderr, "Missing required environment variable: %s\n", envVar)
+			os.Exit(1)
+		}
+		
+		if err := parser(value); err != nil {
+			fmt.Fprintf(os.Stderr, "Configuration error: %v\n", err)
+			os.Exit(1)
+		}
+	}
+
+	return config
 }