feat(backend): configure database through separate DB_* fields

Co-Authored-By: Claude Haiku 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Qu4xuNCkFLDByYWUrjanny
This commit is contained in:
Jonas Leder 2026-11-04 14:27:07 +00:00
commit 46541ba221
14 changed files with 225 additions and 44 deletions

View file

@ -8,7 +8,14 @@ APP_LOG_LEVEL=info
# sqlite | mariadb | postgres
DB_DRIVER=sqlite
# sqlite: file path
DB_DSN=timetracker.db
# mariadb example: timetracker:secret@tcp(localhost:3306)/timetracker?parseTime=true&loc=Europe%2FBerlin&charset=utf8mb4
# postgres example: host=localhost user=timetracker password=secret dbname=timetracker port=5432 sslmode=disable TimeZone=Europe/Berlin
# sqlite: path of the database file (default timetracker.db)
# mariadb/postgres: name of the database (default timetracker)
DB_NAME=timetracker.db
# mariadb/postgres only
DB_HOST=localhost
# 0 or empty selects the driver default (mariadb 3306, postgres 5432)
DB_PORT=
DB_USER=timetracker
DB_PASSWORD=
# postgres only: disable | require | verify-full ...
DB_SSLMODE=disable

View file

@ -50,7 +50,7 @@ func run() error {
return fmt.Errorf("logging: %w", err)
}
db, err := database.Open(cfg.DBDriver, cfg.DBDSN)
db, err := database.Open(cfg.Database)
if err != nil {
return fmt.Errorf("database: %w", err)
}

View file

@ -6,6 +6,7 @@ require (
github.com/gin-gonic/gin v1.12.0
github.com/glebarez/sqlite v1.11.0
github.com/go-pdf/fpdf v0.9.0
github.com/go-sql-driver/mysql v1.8.1
github.com/golang-jwt/jwt/v5 v5.3.1
github.com/joho/godotenv v1.5.1
github.com/sirupsen/logrus v1.10.2
@ -39,7 +40,6 @@ require (
github.com/go-playground/locales v0.14.1 // indirect
github.com/go-playground/universal-translator v0.18.1 // indirect
github.com/go-playground/validator/v10 v10.30.1 // indirect
github.com/go-sql-driver/mysql v1.8.1 // indirect
github.com/goccy/go-json v0.10.5 // indirect
github.com/goccy/go-yaml v1.19.2 // indirect
github.com/google/uuid v1.3.0 // indirect

View file

@ -21,7 +21,7 @@ const testSecret = "test-secret"
func setup(t *testing.T) (*gorm.DB, *gin.Engine, *Service) {
t.Helper()
gin.SetMode(gin.TestMode)
db, err := database.Open("sqlite", ":memory:")
db, err := database.OpenSQLite(":memory:")
if err != nil {
t.Fatal(err)
}

View file

@ -18,8 +18,21 @@ type Config struct {
JWTSecret string
JWTTTLHours int
LogLevel string
DBDriver string
DBDSN string
Database Database
}
// Database describes the connection. Each field is a separate environment variable,
// so non-secret values and the password can come from different sources.
//
// For sqlite, Name is the file path. For mariadb and postgres, Name is the database name.
type Database struct {
Driver string // DB_DRIVER: sqlite | mariadb | postgres
Host string // DB_HOST
Port int // DB_PORT, 0 selects the driver default
Name string // DB_NAME
User string // DB_USER
Password string // DB_PASSWORD
SSLMode string // DB_SSLMODE, postgres only
}
// Load reads the configuration from the environment and validates it.
@ -28,14 +41,26 @@ func Load() (*Config, error) {
if err != nil {
return nil, err
}
dbPort, err := intEnv("DB_PORT", 0)
if err != nil {
return nil, err
}
driver := strings.ToLower(getEnv("DB_DRIVER", "sqlite"))
cfg := &Config{
Port: getEnv("APP_PORT", "8080"),
JWTSecret: os.Getenv("APP_JWT_SECRET"),
JWTTTLHours: ttl,
LogLevel: strings.ToLower(getEnv("APP_LOG_LEVEL", "info")),
DBDriver: strings.ToLower(getEnv("DB_DRIVER", "sqlite")),
DBDSN: getEnv("DB_DSN", "timetracker.db"),
Database: Database{
Driver: driver,
Host: os.Getenv("DB_HOST"),
Port: dbPort,
Name: getEnv("DB_NAME", defaultDBName(driver)),
User: getEnv("DB_USER", "timetracker"),
Password: os.Getenv("DB_PASSWORD"),
SSLMode: getEnv("DB_SSLMODE", "disable"),
},
}
if err := cfg.Validate(); err != nil {
@ -60,14 +85,39 @@ func (c *Config) Validate() error {
default:
return fmt.Errorf("APP_LOG_LEVEL %q is not supported", c.LogLevel)
}
switch c.DBDriver {
case "sqlite", "mariadb", "postgres":
return c.Database.Validate()
}
// Validate checks the database settings for the selected driver.
func (d Database) Validate() error {
switch d.Driver {
case "sqlite":
case "mariadb", "postgres":
if d.Host == "" {
return errors.New("DB_HOST must be set for mariadb and postgres")
}
if d.User == "" {
return errors.New("DB_USER must not be empty")
}
default:
return fmt.Errorf("DB_DRIVER %q is not supported", c.DBDriver)
return fmt.Errorf("DB_DRIVER %q is not supported", d.Driver)
}
if d.Name == "" {
return errors.New("DB_NAME must not be empty")
}
if d.Port < 0 || d.Port > 65535 {
return fmt.Errorf("DB_PORT %d is out of range", d.Port)
}
return nil
}
func defaultDBName(driver string) string {
if driver == "sqlite" {
return "timetracker.db"
}
return "timetracker"
}
func getEnv(key, fallback string) string {
if v, ok := os.LookupEnv(key); ok && v != "" {
return v

View file

@ -7,7 +7,10 @@ import (
func clearEnv(t *testing.T) {
t.Helper()
for _, k := range []string{"APP_PORT", "APP_JWT_SECRET", "APP_JWT_TTL_HOURS", "APP_LOG_LEVEL", "DB_DRIVER", "DB_DSN"} {
for _, k := range []string{
"APP_PORT", "APP_JWT_SECRET", "APP_JWT_TTL_HOURS", "APP_LOG_LEVEL",
"DB_DRIVER", "DB_HOST", "DB_PORT", "DB_NAME", "DB_USER", "DB_PASSWORD", "DB_SSLMODE",
} {
t.Setenv(k, "")
}
}
@ -23,8 +26,28 @@ func TestLoadDefaults(t *testing.T) {
if cfg.Port != "8080" || cfg.JWTTTLHours != 24 || cfg.LogLevel != "info" {
t.Errorf("unexpected defaults: %+v", cfg)
}
if cfg.DBDriver != "sqlite" || cfg.DBDSN != "timetracker.db" {
t.Errorf("unexpected db defaults: %+v", cfg)
db := cfg.Database
if db.Driver != "sqlite" || db.Name != "timetracker.db" || db.SSLMode != "disable" {
t.Errorf("unexpected db defaults: %+v", db)
}
}
func TestLoadServerDatabaseFields(t *testing.T) {
clearEnv(t)
t.Setenv("APP_JWT_SECRET", "secret")
t.Setenv("DB_DRIVER", "postgres")
t.Setenv("DB_HOST", "db.internal")
t.Setenv("DB_PORT", "5433")
t.Setenv("DB_USER", "anna")
t.Setenv("DB_PASSWORD", "p@ss word")
cfg, err := Load()
if err != nil {
t.Fatalf("Load() error = %v", err)
}
want := Database{Driver: "postgres", Host: "db.internal", Port: 5433, Name: "timetracker", User: "anna", Password: "p@ss word", SSLMode: "disable"}
if cfg.Database != want {
t.Errorf("database = %+v, want %+v", cfg.Database, want)
}
}
@ -57,12 +80,28 @@ func TestLoadRejectsUnknownDriver(t *testing.T) {
}
}
func TestLoadRejectsNonIntegerTTL(t *testing.T) {
func TestServerDatabaseNeedsHost(t *testing.T) {
clearEnv(t)
t.Setenv("APP_JWT_SECRET", "secret")
t.Setenv("DB_DRIVER", "mariadb")
_, err := Load()
if err == nil || !strings.Contains(err.Error(), "DB_HOST") {
t.Fatalf("expected DB_HOST error, got %v", err)
}
}
func TestLoadRejectsNonIntegerPorts(t *testing.T) {
clearEnv(t)
t.Setenv("APP_JWT_SECRET", "secret")
t.Setenv("APP_JWT_TTL_HOURS", "abc")
if _, err := Load(); err == nil {
t.Fatal("expected error for non-integer ttl")
}
t.Setenv("APP_JWT_TTL_HOURS", "")
t.Setenv("DB_PORT", "70000")
if _, err := Load(); err == nil {
t.Fatal("expected error for out of range DB_PORT")
}
}

View file

@ -3,41 +3,57 @@ package database
import (
"fmt"
"net/url"
"strconv"
"github.com/glebarez/sqlite"
mysqldriver "github.com/go-sql-driver/mysql"
"gorm.io/driver/mysql"
"gorm.io/driver/postgres"
"gorm.io/gorm"
"gorm.io/gorm/logger"
"jonasled.dev/jonasled/timetracker/internal/config"
"jonasled.dev/jonasled/timetracker/internal/models"
"jonasled.dev/jonasled/timetracker/internal/timeutil"
)
// Open connects to the database selected by driver ("sqlite", "mariadb" or "postgres").
func Open(driver, dsn string) (*gorm.DB, error) {
dialector, err := dialectFor(driver, dsn)
// Default ports used when DB_PORT is not set.
const (
defaultMariaDBPort = 3306
defaultPostgresPort = 5432
)
// Open connects to the database described by db.
func Open(db config.Database) (*gorm.DB, error) {
dialector, err := dialectFor(db)
if err != nil {
return nil, err
}
db, err := gorm.Open(dialector, &gorm.Config{
conn, err := gorm.Open(dialector, &gorm.Config{
Logger: logger.Default.LogMode(logger.Silent),
TranslateError: true,
})
if err != nil {
return nil, fmt.Errorf("open %s: %w", driver, err)
return nil, fmt.Errorf("open %s: %w", db.Driver, err)
}
if driver == "sqlite" {
if db.Driver == "sqlite" {
// SQLite serializes writes; a single connection avoids "database is locked" errors
// and keeps in-memory databases shared across the pool.
sqlDB, err := db.DB()
sqlDB, err := conn.DB()
if err != nil {
return nil, err
}
sqlDB.SetMaxOpenConns(1)
}
return db, nil
return conn, nil
}
// OpenSQLite opens a SQLite database at path. Tests use it with ":memory:".
func OpenSQLite(path string) (*gorm.DB, error) {
return Open(config.Database{Driver: "sqlite", Name: path})
}
// Migrate creates or updates all application tables.
@ -48,15 +64,55 @@ func Migrate(db *gorm.DB) error {
return nil
}
func dialectFor(driver, dsn string) (gorm.Dialector, error) {
switch driver {
func dialectFor(db config.Database) (gorm.Dialector, error) {
switch db.Driver {
case "sqlite":
return sqlite.Open(dsn), nil
return sqlite.Open(db.Name), nil
case "mariadb":
return mysql.Open(dsn), nil
return mysql.Open(mariaDBDSN(db)), nil
case "postgres":
return postgres.Open(dsn), nil
return postgres.Open(postgresURL(db)), nil
default:
return nil, fmt.Errorf("unsupported database driver %q", driver)
return nil, fmt.Errorf("unsupported database driver %q", db.Driver)
}
}
// mariaDBDSN uses the driver's config struct so that special characters in the password are escaped.
func mariaDBDSN(db config.Database) string {
cfg := mysqldriver.NewConfig()
cfg.User = db.User
cfg.Passwd = db.Password
cfg.Net = "tcp"
cfg.Addr = hostPort(db.Host, db.Port, defaultMariaDBPort)
cfg.DBName = db.Name
cfg.ParseTime = true
cfg.Loc = timeutil.Berlin
cfg.Params = map[string]string{"charset": "utf8mb4"}
return cfg.FormatDSN()
}
// postgresURL builds a connection URL; url.UserPassword escapes the password.
func postgresURL(db config.Database) string {
u := url.URL{
Scheme: "postgres",
Host: hostPort(db.Host, db.Port, defaultPostgresPort),
Path: "/" + db.Name,
RawQuery: url.Values{
"sslmode": {db.SSLMode},
"TimeZone": {timeutil.Berlin.String()},
}.Encode(),
}
if db.Password != "" {
u.User = url.UserPassword(db.User, db.Password)
} else {
u.User = url.User(db.User)
}
return u.String()
}
func hostPort(host string, port, fallback int) string {
if port == 0 {
port = fallback
}
return host + ":" + strconv.Itoa(port)
}

View file

@ -1,19 +1,21 @@
package database
import (
"strings"
"testing"
"time"
"gorm.io/gorm"
"jonasled.dev/jonasled/timetracker/internal/config"
"jonasled.dev/jonasled/timetracker/internal/models"
)
func openTestDB(t *testing.T) *gorm.DB {
t.Helper()
db, err := Open("sqlite", ":memory:")
db, err := OpenSQLite(":memory:")
if err != nil {
t.Fatalf("Open() error = %v", err)
t.Fatalf("OpenSQLite() error = %v", err)
}
if err := Migrate(db); err != nil {
t.Fatalf("Migrate() error = %v", err)
@ -57,9 +59,36 @@ func TestVacationDateIsUniquePerUser(t *testing.T) {
}
}
func TestMariaDBDSNUsesFieldsAndDefaultPort(t *testing.T) {
dsn := mariaDBDSN(config.Database{Driver: "mariadb", Host: "db", User: "anna", Password: "p@ss:word", Name: "zeit"})
for _, want := range []string{"anna:p@ss:word@tcp(db:3306)/zeit", "parseTime=true", "charset=utf8mb4", "loc=Europe%2FBerlin"} {
if !strings.Contains(dsn, want) {
t.Errorf("dsn %q does not contain %q", dsn, want)
}
}
}
func TestPostgresURLEscapesPassword(t *testing.T) {
u := postgresURL(config.Database{Driver: "postgres", Host: "db", Port: 5433, User: "anna", Password: "p@ss/word", Name: "zeit", SSLMode: "require"})
for _, want := range []string{"postgres://anna:p%40ss%2Fword@db:5433/zeit", "sslmode=require", "TimeZone=Europe%2FBerlin"} {
if !strings.Contains(u, want) {
t.Errorf("url %q does not contain %q", u, want)
}
}
}
func TestPostgresURLWithoutPassword(t *testing.T) {
u := postgresURL(config.Database{Driver: "postgres", Host: "db", User: "anna", Name: "zeit", SSLMode: "disable"})
if !strings.HasPrefix(u, "postgres://anna@db:5432/zeit") {
t.Errorf("url = %q", u)
}
}
func TestDialectForSupportedDrivers(t *testing.T) {
for _, driver := range []string{"sqlite", "mariadb", "postgres"} {
d, err := dialectFor(driver, "dsn")
d, err := dialectFor(config.Database{Driver: driver, Host: "db", Name: "x", User: "u"})
if err != nil || d == nil {
t.Errorf("dialectFor(%q) = %v, %v; want dialector", driver, d, err)
}
@ -67,14 +96,14 @@ func TestDialectForSupportedDrivers(t *testing.T) {
}
func TestOpenRejectsUnknownDriver(t *testing.T) {
if _, err := Open("oracle", "dsn"); err == nil {
if _, err := Open(config.Database{Driver: "oracle", Name: "x"}); err == nil {
t.Fatal("expected error for unknown driver")
}
}
func TestOpenSQLiteFailsForDirectoryPath(t *testing.T) {
// A directory cannot be opened as a database file.
if _, err := Open("sqlite", t.TempDir()); err == nil {
if _, err := OpenSQLite(t.TempDir()); err == nil {
t.Fatal("expected error opening a directory as sqlite file")
}
}

View file

@ -38,7 +38,7 @@ type fixture struct {
func setup(t *testing.T) *fixture {
t.Helper()
db, err := database.Open("sqlite", ":memory:")
db, err := database.OpenSQLite(":memory:")
if err != nil {
t.Fatal(err)
}

View file

@ -16,7 +16,7 @@ import (
func newTestDeps(t *testing.T) Dependencies {
t.Helper()
db, err := database.Open("sqlite", ":memory:")
db, err := database.OpenSQLite(":memory:")
if err != nil {
t.Fatal(err)
}

View file

@ -37,7 +37,7 @@ type fixture struct {
func setup(t *testing.T) *fixture {
t.Helper()
db, err := database.Open("sqlite", ":memory:")
db, err := database.OpenSQLite(":memory:")
if err != nil {
t.Fatal(err)
}

View file

@ -17,7 +17,7 @@ import (
func openDB(t *testing.T) *gorm.DB {
t.Helper()
db, err := database.Open("sqlite", ":memory:")
db, err := database.OpenSQLite(":memory:")
if err != nil {
t.Fatal(err)
}

View file

@ -40,7 +40,7 @@ type fixture struct {
func setup(t *testing.T) *fixture {
t.Helper()
db, err := database.Open("sqlite", ":memory:")
db, err := database.OpenSQLite(":memory:")
if err != nil {
t.Fatal(err)
}

View file

@ -21,7 +21,7 @@ import (
func setup(t *testing.T) (*Service, *gorm.DB) {
t.Helper()
db, err := database.Open("sqlite", ":memory:")
db, err := database.OpenSQLite(":memory:")
if err != nil {
t.Fatal(err)
}