- feat(config): TOML config with env overrides, strict parsing and validation - feat(storage): SQLite (modernc) and PostgreSQL (pgx) backends through bun, embedded per-driver SQL migrations with a transactional runner - feat(schema): catalog tables (artists, albums, tracks, audio_files with per-root paths), users and listening events with idempotency keys - feat(auth): Argon2id password hashing, HS256 JWT tokens, first-user-only registration and login - feat(api): gin REST API under /api/v1 (health, register, login, listens) with a consistent error envelope, body limit and request logging - feat(sondad): zap logger, graceful shutdown, composition root in main - chore: example config, .gitignore for secrets, DB files, IDE and agent files
145 lines
4 KiB
Go
145 lines
4 KiB
Go
// Package storage opens the database (SQLite or PostgreSQL) and applies schema
|
|
// migrations. Repositories live here too.
|
|
//
|
|
// This is the only place that should import the ORM (bun) and the database
|
|
// drivers. Services depend on small interfaces, never on this package directly.
|
|
package storage
|
|
|
|
import (
|
|
"context"
|
|
"database/sql"
|
|
"fmt"
|
|
"io/fs"
|
|
"strings"
|
|
"time"
|
|
|
|
_ "github.com/jackc/pgx/v5/stdlib" // PostgreSQL driver ("pgx")
|
|
"github.com/uptrace/bun"
|
|
"github.com/uptrace/bun/dialect/pgdialect"
|
|
"github.com/uptrace/bun/dialect/sqlitedialect"
|
|
_ "modernc.org/sqlite" // pure-Go SQLite driver ("sqlite")
|
|
)
|
|
|
|
// Supported database drivers.
|
|
const (
|
|
DriverSQLite = "sqlite"
|
|
DriverPostgres = "postgres"
|
|
)
|
|
|
|
// pathEscaper protects characters that are special in a file: URI.
|
|
var pathEscaper = strings.NewReplacer("%", "%25", "?", "%3F", "#", "%23")
|
|
|
|
// Open connects to the database. For "sqlite" target is a file path (created if
|
|
// needed); for "postgres" it is a connection string (DSN or URL).
|
|
func Open(driver, target string) (*bun.DB, error) {
|
|
switch driver {
|
|
case DriverSQLite:
|
|
return openSQLite(target)
|
|
case DriverPostgres:
|
|
return openPostgres(target)
|
|
default:
|
|
return nil, fmt.Errorf("unknown database driver %q", driver)
|
|
}
|
|
}
|
|
|
|
// openSQLite enables WAL, foreign keys and a busy timeout on every connection.
|
|
func openSQLite(path string) (*bun.DB, error) {
|
|
dsn := "file:" + pathEscaper.Replace(path) +
|
|
"?_pragma=foreign_keys(1)&_pragma=journal_mode(WAL)&_pragma=busy_timeout(5000)"
|
|
|
|
sqldb, err := sql.Open("sqlite", dsn)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("open sqlite: %w", err)
|
|
}
|
|
if err := sqldb.Ping(); err != nil {
|
|
_ = sqldb.Close()
|
|
return nil, fmt.Errorf("ping sqlite: %w", err)
|
|
}
|
|
return bun.NewDB(sqldb, sqlitedialect.New()), nil
|
|
}
|
|
|
|
func openPostgres(dsn string) (*bun.DB, error) {
|
|
sqldb, err := sql.Open("pgx", dsn)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("open postgres: %w", err)
|
|
}
|
|
if err := sqldb.Ping(); err != nil {
|
|
_ = sqldb.Close()
|
|
return nil, fmt.Errorf("ping postgres: %w", err)
|
|
}
|
|
return bun.NewDB(sqldb, pgdialect.New()), nil
|
|
}
|
|
|
|
// Migrate applies, in lexical order, every *.sql file in fsys that has not
|
|
// been applied yet. Each file runs in its own transaction.
|
|
func Migrate(ctx context.Context, db *bun.DB, fsys fs.FS) error {
|
|
_, err := db.ExecContext(ctx, `CREATE TABLE IF NOT EXISTS schema_migrations (
|
|
version TEXT PRIMARY KEY,
|
|
applied_at BIGINT NOT NULL
|
|
)`)
|
|
if err != nil {
|
|
return fmt.Errorf("create schema_migrations: %w", err)
|
|
}
|
|
|
|
applied, err := appliedVersions(ctx, db)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
entries, err := fs.ReadDir(fsys, ".")
|
|
if err != nil {
|
|
return fmt.Errorf("read migrations: %w", err)
|
|
}
|
|
for _, e := range entries {
|
|
name := e.Name()
|
|
if e.IsDir() || !strings.HasSuffix(name, ".sql") || applied[name] {
|
|
continue
|
|
}
|
|
if err := applyOne(ctx, db, fsys, name); err != nil {
|
|
return fmt.Errorf("migration %s: %w", name, err)
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func appliedVersions(ctx context.Context, db *bun.DB) (map[string]bool, error) {
|
|
rows, err := db.QueryContext(ctx, "SELECT version FROM schema_migrations")
|
|
if err != nil {
|
|
return nil, fmt.Errorf("list applied migrations: %w", err)
|
|
}
|
|
defer rows.Close()
|
|
|
|
applied := map[string]bool{}
|
|
for rows.Next() {
|
|
var v string
|
|
if err := rows.Scan(&v); err != nil {
|
|
return nil, err
|
|
}
|
|
applied[v] = true
|
|
}
|
|
return applied, rows.Err()
|
|
}
|
|
|
|
func applyOne(ctx context.Context, db *bun.DB, fsys fs.FS, name string) error {
|
|
body, err := fs.ReadFile(fsys, name)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
tx, err := db.BeginTx(ctx, nil)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer func() { _ = tx.Rollback() }() // no-op after a successful Commit
|
|
|
|
// The file body goes straight to the driver: it may contain several
|
|
// statements and must not go through placeholder formatting.
|
|
if _, err := tx.Tx.ExecContext(ctx, string(body)); err != nil {
|
|
return err
|
|
}
|
|
_, err = tx.ExecContext(ctx,
|
|
"INSERT INTO schema_migrations (version, applied_at) VALUES (?, ?)", name, time.Now().Unix())
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return tx.Commit()
|
|
}
|