refactor: added dest parameter to load environment variables-related functions

* Added dest parameter to load environment variables-related functions
* Added HTTP listener logger and related errors and functions

Author: ralvarezdev

env/errors.go

@@ -4,6 +4,7 @@ import "errors"
 
 var (
 	ErrNilLoader                        = errors.New("loader cannot be nil")
+	ErrNilDestination                   = "destination cannot be nil for the given key: %v"
 	ErrEnvironmentVariableNotFound      = "environment variable not found: %v"
 	ErrFailedToLoadEnvironmentVariables = errors.New("failed to load environment variables")
 	ErrInvalidDuration                  = "invalid key '%v' duration value: %v"

env/loader.go

@@ -10,10 +10,10 @@ import (
 type (
 	// Loader interface for loading environment variables
 	Loader interface {
-		LoadVariable(key string) (uri string, err error)
-		LoadDurationVariable(key string) (duration time.Duration, err error)
-		LoadSecondsVariable(key string) (seconds float64, err error)
-		LoadIntVariable(key string) (value int, err error)
+		LoadVariable(key string, dest *string) error
+		LoadDurationVariable(key string, dest *time.Duration) error
+		LoadSecondsVariable(key string, dest *float64) error
+		LoadIntVariable(key string, dest *int) error
 	}
 
 	// DefaultLoader struct
@@ -32,59 +32,80 @@ func NewDefaultLoader(loadFn func() error) (*DefaultLoader, error) {
 }
 
 // LoadVariable load variable from environment variables
-func (d *DefaultLoader) LoadVariable(key string) (uri string, err error) {
+func (d *DefaultLoader) LoadVariable(key string, dest *string) error {
+	// Check if the destination is nil
+	if dest == nil {
+		return fmt.Errorf(ErrNilDestination, key)
+	}
+
 	// Get environment variable
 	variable, exists := os.LookupEnv(key)
 	if !exists {
-		return "", fmt.Errorf(ErrEnvironmentVariableNotFound, key)
+		return fmt.Errorf(ErrEnvironmentVariableNotFound, key)
 	}
-	return variable, nil
+	*dest = variable
+	return nil
 }
 
 // LoadDurationVariable load duration variable from environment variables
-func (d *DefaultLoader) LoadDurationVariable(key string) (
-	duration time.Duration,
-	err error,
-) {
+func (d *DefaultLoader) LoadDurationVariable(
+	key string,
+	dest *time.Duration,
+) error {
+	// Check if the destination is nil
+	if dest == nil {
+		return fmt.Errorf(ErrNilDestination, key)
+	}
+
 	// Get environment variable
-	variable, err := d.LoadVariable(key)
-	if err != nil {
-		return 0, err
+	var durationStr string
+	if err := d.LoadVariable(key, &durationStr); err != nil {
+		return err
 	}
 
 	// Parse the duration
-	duration, err = time.ParseDuration(variable)
+	duration, err := time.ParseDuration(durationStr)
 	if err != nil {
-		return 0, fmt.Errorf(ErrInvalidDuration, key, variable)
+		return fmt.Errorf(ErrInvalidDuration, key, durationStr)
 	}
-	return duration, nil
+	*dest = duration
+	return nil
 }
 
 // LoadSecondsVariable load duration variable in seconds from environment variables
-func (d *DefaultLoader) LoadSecondsVariable(key string) (
-	seconds float64,
-	err error,
-) {
+func (d *DefaultLoader) LoadSecondsVariable(key string, dest *float64) error {
+	// Check if the destination is nil
+	if dest == nil {
+		return fmt.Errorf(ErrNilDestination, key)
+	}
+
 	// Get the duration
-	duration, err := d.LoadDurationVariable(key)
-	if err != nil {
-		return 0, err
+	var duration time.Duration
+	if err := d.LoadDurationVariable(key, &duration); err != nil {
+		return err
 	}
-	return duration.Seconds(), nil
+	*dest = duration.Seconds()
+	return nil
 }
 
 // LoadIntVariable load integer variable from environment variables
-func (d *DefaultLoader) LoadIntVariable(key string) (value int, err error) {
+func (d *DefaultLoader) LoadIntVariable(key string, dest *int) error {
+	// Check if the destination is nil
+	if dest == nil {
+		return fmt.Errorf(ErrNilDestination, key)
+	}
+
 	// Get environment variable
-	variable, err := d.LoadVariable(key)
-	if err != nil {
-		return 0, err
+	var valueStr string
+	if err := d.LoadVariable(key, &valueStr); err != nil {
+		return err
 	}
 
 	// Parse the integer
-	value, err = strconv.Atoi(variable)
+	value, err := strconv.Atoi(valueStr)
 	if err != nil {
-		return 0, fmt.Errorf(ErrInvalidInteger, key, variable)
+		return fmt.Errorf(ErrInvalidInteger, key, valueStr)
 	}
-	return value, nil
+	*dest = value
+	return nil
 }