knowfoolery/backend/shared/utils/config.go

package utils

import (
	"fmt"
	"strings"
	"time"
)

// DatabaseConfig represents database configuration from environment
type DatabaseConfig struct {
	URL      string
	Driver   string
	Host     string
	Port     int
	User     string
	Password string
	Database string
	SSLMode  string
}

// ServerConfig represents server configuration from environment
type ServerConfig struct {
	Port            string
	Host            string
	ReadTimeout     time.Duration
	WriteTimeout    time.Duration
	ShutdownTimeout time.Duration
	LogLevel        string
}

// AuthConfig represents authentication configuration from environment
type AuthConfig struct {
	JWTSecret       string
	TokenExpiration time.Duration
	Issuer          string
	RequireMFA      bool
}

// GetDatabaseConfig loads database configuration from environment variables
func GetDatabaseConfig() DatabaseConfig {
	config := DatabaseConfig{
		URL:      GetEnvOrDefault("DATABASE_URL", "sqlite://./app.db"),
		Host:     GetEnvOrDefault("DB_HOST", "localhost"),
		Port:     GetEnvOrDefaultInt("DB_PORT", 5432),
		User:     GetEnvOrDefault("DB_USER", "app"),
		Password: GetEnvOrDefault("DB_PASSWORD", "password"),
		Database: GetEnvOrDefault("DB_NAME", "app"),
		SSLMode:  GetEnvOrDefault("DB_SSLMODE", "disable"),
	}

	// Determine driver from URL
	if strings.HasPrefix(config.URL, "postgres") {
		config.Driver = "postgres"
	} else {
		config.Driver = "sqlite3"
	}

	return config
}

// GetServerConfig loads server configuration from environment variables
func GetServerConfig(defaultPort string) ServerConfig {
	return ServerConfig{
		Port:            GetEnvOrDefault("PORT", defaultPort),
		Host:            GetEnvOrDefault("HOST", ""),
		ReadTimeout:     GetEnvOrDefaultDuration("READ_TIMEOUT", 30*time.Second),
		WriteTimeout:    GetEnvOrDefaultDuration("WRITE_TIMEOUT", 30*time.Second),
		ShutdownTimeout: GetEnvOrDefaultDuration("SHUTDOWN_TIMEOUT", 30*time.Second),
		LogLevel:        GetEnvOrDefault("LOG_LEVEL", "info"),
	}
}

// GetAuthConfig loads authentication configuration from environment variables
func GetAuthConfig(serviceName string) AuthConfig {
	return AuthConfig{
		JWTSecret:       GetEnvOrDefault("JWT_SECRET", "dev-secret-"+serviceName),
		TokenExpiration: GetEnvOrDefaultDuration("TOKEN_EXPIRATION", 24*time.Hour),
		Issuer:          GetEnvOrDefault("JWT_ISSUER", "knowfoolery-"+serviceName),
		RequireMFA:      GetEnvOrDefaultBool("REQUIRE_MFA", false),
	}
}

// GetListenAddress returns the address to listen on
func (c ServerConfig) GetListenAddress() string {
	if c.Host != "" {
		return fmt.Sprintf("%s:%s", c.Host, c.Port)
	}
	return ":" + c.Port
}

// IsProduction checks if the environment is production
func IsProduction() bool {
	env := GetEnvOrDefault("ENVIRONMENT", "development")
	return strings.ToLower(env) == "production" || strings.ToLower(env) == "prod"
}

// IsDevelopment checks if the environment is development
func IsDevelopment() bool {
	env := GetEnvOrDefault("ENVIRONMENT", "development")
	return strings.ToLower(env) == "development" || strings.ToLower(env) == "dev"
}

// GetEnvironment returns the current environment
func GetEnvironment() string {
	return GetEnvOrDefault("ENVIRONMENT", "development")
}

// GetServiceName returns the service name from environment or default
func GetServiceName(defaultName string) string {
	return GetEnvOrDefault("SERVICE_NAME", defaultName)
}

// GetVersion returns the service version from environment or default
func GetVersion() string {
	return GetEnvOrDefault("VERSION", "development")
}

// LogConfig logs the configuration (without sensitive data)
func (c DatabaseConfig) LogSafe() map[string]interface{} {
	return map[string]interface{}{
		"driver":   c.Driver,
		"host":     c.Host,
		"port":     c.Port,
		"database": c.Database,
		"ssl_mode": c.SSLMode,
		"user":     c.User,
		// Note: Never log passwords!
	}
}

// LogConfig logs the server configuration
func (c ServerConfig) LogSafe() map[string]interface{} {
	return map[string]interface{}{
		"port":             c.Port,
		"host":             c.Host,
		"read_timeout":     c.ReadTimeout.String(),
		"write_timeout":    c.WriteTimeout.String(),
		"shutdown_timeout": c.ShutdownTimeout.String(),
		"log_level":        c.LogLevel,
	}
}

// LogConfig logs the auth configuration (without sensitive data)
func (c AuthConfig) LogSafe() map[string]interface{} {
	return map[string]interface{}{
		"issuer":           c.Issuer,
		"token_expiration": c.TokenExpiration.String(),
		"require_mfa":      c.RequireMFA,
		// Note: Never log JWT secrets!
	}
}