feat: add sondad server with config, storage, auth and listening API
- 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
This commit is contained in:
commit
3a739dc3ae
30 changed files with 2739 additions and 0 deletions
23
.gitignore
vendored
Normal file
23
.gitignore
vendored
Normal file
|
|
@ -0,0 +1,23 @@
|
|||
/bin/
|
||||
*.test
|
||||
*.out
|
||||
sonda.toml
|
||||
*.db
|
||||
*.db-wal
|
||||
*.db-shm
|
||||
|
||||
# AI agent instruction files: never published (Codeberg EULA)
|
||||
agent.md
|
||||
Agent.md
|
||||
AGENT.md
|
||||
agents.md
|
||||
Agents.md
|
||||
AGENTS.md
|
||||
claude.md
|
||||
Claude.md
|
||||
CLAUDE.md
|
||||
GEMINI.md
|
||||
.claude/
|
||||
|
||||
# IDE
|
||||
.idea/
|
||||
14
cmd/sondad/logger.go
Normal file
14
cmd/sondad/logger.go
Normal file
|
|
@ -0,0 +1,14 @@
|
|||
package main
|
||||
|
||||
import (
|
||||
"go.uber.org/zap"
|
||||
)
|
||||
|
||||
// newLogger builds the application logger.
|
||||
// env "dev" gives a human-readable console logger; anything else gives JSON.
|
||||
func newLogger(env string) (*zap.Logger, error) {
|
||||
if env == "dev" {
|
||||
return zap.NewDevelopment()
|
||||
}
|
||||
return zap.NewProduction()
|
||||
}
|
||||
124
cmd/sondad/main.go
Normal file
124
cmd/sondad/main.go
Normal file
|
|
@ -0,0 +1,124 @@
|
|||
package main
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"flag"
|
||||
"fmt"
|
||||
"net/http"
|
||||
"os"
|
||||
"os/signal"
|
||||
"syscall"
|
||||
"time"
|
||||
|
||||
"github.com/gin-gonic/gin"
|
||||
"go.uber.org/zap"
|
||||
|
||||
httpapi "codeberg.org/squidd/sonda/internal/api/http"
|
||||
"codeberg.org/squidd/sonda/internal/auth"
|
||||
"codeberg.org/squidd/sonda/internal/config"
|
||||
"codeberg.org/squidd/sonda/internal/listening"
|
||||
"codeberg.org/squidd/sonda/internal/storage"
|
||||
"codeberg.org/squidd/sonda/migrations"
|
||||
)
|
||||
|
||||
const defaultConfigFile = "sonda.toml"
|
||||
|
||||
func main() {
|
||||
if err := run(); err != nil {
|
||||
fmt.Fprintln(os.Stderr, "sondad:", err)
|
||||
os.Exit(1)
|
||||
}
|
||||
}
|
||||
|
||||
func run() error {
|
||||
configPath := flag.String("config", "", "path to the TOML config file (default ./"+defaultConfigFile+" if present)")
|
||||
flag.Parse()
|
||||
|
||||
path := *configPath
|
||||
if path == "" {
|
||||
if _, err := os.Stat(defaultConfigFile); err == nil {
|
||||
path = defaultConfigFile
|
||||
}
|
||||
}
|
||||
|
||||
cfg, err := config.Load(path)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if err := cfg.Validate(); err != nil {
|
||||
return fmt.Errorf("invalid config: %w", err)
|
||||
}
|
||||
|
||||
logger, err := newLogger(cfg.Log.Env)
|
||||
if err != nil {
|
||||
return fmt.Errorf("create logger: %w", err)
|
||||
}
|
||||
defer func() { _ = logger.Sync() }()
|
||||
|
||||
ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
|
||||
defer stop()
|
||||
|
||||
target := cfg.Database.Path
|
||||
if cfg.Database.Driver == storage.DriverPostgres {
|
||||
target = cfg.Database.DSN
|
||||
}
|
||||
db, err := storage.Open(cfg.Database.Driver, target)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
defer func() { _ = db.Close() }()
|
||||
|
||||
dbMigrations, err := migrations.For(cfg.Database.Driver)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if err := storage.Migrate(ctx, db, dbMigrations); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
// Composition root: build services and hand them to the HTTP layer.
|
||||
tokens := auth.NewTokenIssuer(cfg.Auth.JWTSecret, cfg.Auth.TokenTTL())
|
||||
if cfg.Log.Env == "production" {
|
||||
gin.SetMode(gin.ReleaseMode)
|
||||
}
|
||||
router := httpapi.NewRouter(httpapi.Deps{
|
||||
Logger: logger,
|
||||
Auth: auth.NewService(storage.NewUserRepo(db), tokens),
|
||||
Tokens: tokens,
|
||||
Listening: listening.NewService(storage.NewListeningRepo(db)),
|
||||
})
|
||||
|
||||
// No WriteTimeout: audio streaming (later) needs long responses.
|
||||
srv := &http.Server{
|
||||
Addr: cfg.Server.Listen,
|
||||
Handler: router,
|
||||
ReadHeaderTimeout: 10 * time.Second,
|
||||
IdleTimeout: 2 * time.Minute,
|
||||
}
|
||||
|
||||
logger.Info("sondad starting",
|
||||
zap.String("config", path),
|
||||
zap.String("env", cfg.Log.Env),
|
||||
zap.String("listen", cfg.Server.Listen),
|
||||
zap.Strings("library_roots", cfg.Library.Roots),
|
||||
zap.String("database_driver", cfg.Database.Driver), // never log the DSN: it holds the password
|
||||
)
|
||||
|
||||
serveErr := make(chan error, 1)
|
||||
go func() { serveErr <- srv.ListenAndServe() }()
|
||||
|
||||
select {
|
||||
case err := <-serveErr:
|
||||
return fmt.Errorf("http server: %w", err)
|
||||
case <-ctx.Done():
|
||||
logger.Info("shutting down")
|
||||
}
|
||||
|
||||
shutdownCtx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
|
||||
defer cancel()
|
||||
if err := srv.Shutdown(shutdownCtx); err != nil && !errors.Is(err, http.ErrServerClosed) {
|
||||
return fmt.Errorf("shutdown: %w", err)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
63
go.mod
Normal file
63
go.mod
Normal file
|
|
@ -0,0 +1,63 @@
|
|||
module codeberg.org/squidd/sonda
|
||||
|
||||
go 1.27.1
|
||||
|
||||
require (
|
||||
github.com/gin-gonic/gin v1.12.0
|
||||
github.com/golang-jwt/jwt/v5 v5.3.1
|
||||
github.com/jackc/pgx/v5 v5.12.0
|
||||
github.com/pelletier/go-toml/v2 v2.4.3
|
||||
github.com/uptrace/bun v1.3.0
|
||||
github.com/uptrace/bun/dialect/pgdialect v1.3.0
|
||||
github.com/uptrace/bun/dialect/sqlitedialect v1.3.0
|
||||
go.uber.org/zap v1.28.0
|
||||
golang.org/x/crypto v0.58.0
|
||||
modernc.org/sqlite v1.62.0
|
||||
)
|
||||
|
||||
require (
|
||||
github.com/bytedance/gopkg v0.1.3 // indirect
|
||||
github.com/bytedance/sonic v1.15.0 // indirect
|
||||
github.com/bytedance/sonic/loader v0.5.0 // indirect
|
||||
github.com/cloudwego/base64x v0.1.6 // indirect
|
||||
github.com/dustin/go-humanize v1.1.0 // indirect
|
||||
github.com/gabriel-vasile/mimetype v1.4.12 // indirect
|
||||
github.com/gin-contrib/sse v1.1.0 // indirect
|
||||
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/goccy/go-json v0.10.5 // indirect
|
||||
github.com/goccy/go-yaml v1.19.2 // indirect
|
||||
github.com/google/uuid v1.6.0 // indirect
|
||||
github.com/jackc/pgpassfile v1.0.0 // indirect
|
||||
github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 // indirect
|
||||
github.com/jackc/puddle/v2 v2.2.3 // indirect
|
||||
github.com/jinzhu/inflection v1.0.0 // indirect
|
||||
github.com/json-iterator/go v1.1.12 // indirect
|
||||
github.com/klauspost/cpuid/v2 v2.3.0 // indirect
|
||||
github.com/leodido/go-urn v1.4.0 // indirect
|
||||
github.com/mattn/go-isatty v0.0.24 // indirect
|
||||
github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
|
||||
github.com/modern-go/reflect2 v1.0.2 // indirect
|
||||
github.com/ncruces/go-strftime v1.1.0 // indirect
|
||||
github.com/puzpuzpuz/xsync/v3 v3.5.1 // indirect
|
||||
github.com/quic-go/qpack v0.6.0 // indirect
|
||||
github.com/quic-go/quic-go v0.59.0 // indirect
|
||||
github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec // indirect
|
||||
github.com/tmthrgd/go-hex v0.0.0-20190904060850-447a3041c3bc // indirect
|
||||
github.com/twitchyliquid64/golang-asm v0.15.1 // indirect
|
||||
github.com/ugorji/go/codec v1.3.1 // indirect
|
||||
github.com/vmihailenco/msgpack/v5 v5.4.1 // indirect
|
||||
github.com/vmihailenco/tagparser/v2 v2.0.0 // indirect
|
||||
go.mongodb.org/mongo-driver/v2 v2.5.0 // indirect
|
||||
go.uber.org/multierr v1.11.0 // indirect
|
||||
golang.org/x/arch v0.22.0 // indirect
|
||||
golang.org/x/net v0.60.0 // indirect
|
||||
golang.org/x/sync v0.24.0 // indirect
|
||||
golang.org/x/sys v0.49.0 // indirect
|
||||
golang.org/x/text v0.43.0 // indirect
|
||||
google.golang.org/protobuf v1.36.10 // indirect
|
||||
modernc.org/libc v1.80.1 // indirect
|
||||
modernc.org/mathutil v1.7.1 // indirect
|
||||
modernc.org/memory v1.12.1 // indirect
|
||||
)
|
||||
169
go.sum
Normal file
169
go.sum
Normal file
|
|
@ -0,0 +1,169 @@
|
|||
github.com/bytedance/gopkg v0.1.3 h1:TPBSwH8RsouGCBcMBktLt1AymVo2TVsBVCY4b6TnZ/M=
|
||||
github.com/bytedance/gopkg v0.1.3/go.mod h1:576VvJ+eJgyCzdjS+c4+77QF3p7ubbtiKARP3TxducM=
|
||||
github.com/bytedance/sonic v1.15.0 h1:/PXeWFaR5ElNcVE84U0dOHjiMHQOwNIx3K4ymzh/uSE=
|
||||
github.com/bytedance/sonic v1.15.0/go.mod h1:tFkWrPz0/CUCLEF4ri4UkHekCIcdnkqXw9VduqpJh0k=
|
||||
github.com/bytedance/sonic/loader v0.5.0 h1:gXH3KVnatgY7loH5/TkeVyXPfESoqSBSBEiDd5VjlgE=
|
||||
github.com/bytedance/sonic/loader v0.5.0/go.mod h1:AR4NYCk5DdzZizZ5djGqQ92eEhCCcdf5x77udYiSJRo=
|
||||
github.com/cloudwego/base64x v0.1.6 h1:t11wG9AECkCDk5fMSoxmufanudBtJ+/HemLstXDLI2M=
|
||||
github.com/cloudwego/base64x v0.1.6/go.mod h1:OFcloc187FXDaYHvrNIjxSe8ncn0OOM8gEHfghB2IPU=
|
||||
github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
|
||||
github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
|
||||
github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
|
||||
github.com/dustin/go-humanize v1.1.0 h1:dbKTrvD0klcbBV/h4AWJdMuZogJACoMlvWIWZ5b2xWg=
|
||||
github.com/dustin/go-humanize v1.1.0/go.mod h1:hc1CvRkJMsgxqjmjMQF3QNRAZBwY8AXBAzKYoSX9sFI=
|
||||
github.com/gabriel-vasile/mimetype v1.4.12 h1:e9hWvmLYvtp846tLHam2o++qitpguFiYCKbn0w9jyqw=
|
||||
github.com/gabriel-vasile/mimetype v1.4.12/go.mod h1:d+9Oxyo1wTzWdyVUPMmXFvp4F9tea18J8ufA774AB3s=
|
||||
github.com/gin-contrib/sse v1.1.0 h1:n0w2GMuUpWDVp7qSpvze6fAu9iRxJY4Hmj6AmBOU05w=
|
||||
github.com/gin-contrib/sse v1.1.0/go.mod h1:hxRZ5gVpWMT7Z0B0gSNYqqsSCNIJMjzvm6fqCz9vjwM=
|
||||
github.com/gin-gonic/gin v1.12.0 h1:b3YAbrZtnf8N//yjKeU2+MQsh2mY5htkZidOM7O0wG8=
|
||||
github.com/gin-gonic/gin v1.12.0/go.mod h1:VxccKfsSllpKshkBWgVgRniFFAzFb9csfngsqANjnLc=
|
||||
github.com/go-playground/assert/v2 v2.2.0 h1:JvknZsQTYeFEAhQwI4qEt9cyV5ONwRHC+lYKSsYSR8s=
|
||||
github.com/go-playground/assert/v2 v2.2.0/go.mod h1:VDjEfimB/XKnb+ZQfWdccd7VUvScMdVu0Titje2rxJ4=
|
||||
github.com/go-playground/locales v0.14.1 h1:EWaQ/wswjilfKLTECiXz7Rh+3BjFhfDFKv/oXslEjJA=
|
||||
github.com/go-playground/locales v0.14.1/go.mod h1:hxrqLVvrK65+Rwrd5Fc6F2O76J/NuW9t0sjnWqG1slY=
|
||||
github.com/go-playground/universal-translator v0.18.1 h1:Bcnm0ZwsGyWbCzImXv+pAJnYK9S473LQFuzCbDbfSFY=
|
||||
github.com/go-playground/universal-translator v0.18.1/go.mod h1:xekY+UJKNuX9WP91TpwSH2VMlDf28Uj24BCp08ZFTUY=
|
||||
github.com/go-playground/validator/v10 v10.30.1 h1:f3zDSN/zOma+w6+1Wswgd9fLkdwy06ntQJp0BBvFG0w=
|
||||
github.com/go-playground/validator/v10 v10.30.1/go.mod h1:oSuBIQzuJxL//3MelwSLD5hc2Tu889bF0Idm9Dg26cM=
|
||||
github.com/goccy/go-json v0.10.5 h1:Fq85nIqj+gXn/S5ahsiTlK3TmC85qgirsdTP/+DeaC4=
|
||||
github.com/goccy/go-json v0.10.5/go.mod h1:oq7eo15ShAhp70Anwd5lgX2pLfOS3QCiwU/PULtXL6M=
|
||||
github.com/goccy/go-yaml v1.19.2 h1:PmFC1S6h8ljIz6gMRBopkjP1TVT7xuwrButHID66PoM=
|
||||
github.com/goccy/go-yaml v1.19.2/go.mod h1:XBurs7gK8ATbW4ZPGKgcbrY1Br56PdM69F7LkFRi1kA=
|
||||
github.com/golang-jwt/jwt/v5 v5.3.1 h1:kYf81DTWFe7t+1VvL7eS+jKFVWaUnK9cB1qbwn63YCY=
|
||||
github.com/golang-jwt/jwt/v5 v5.3.1/go.mod h1:fxCRLWMO43lRc8nhHWY6LGqRcf+1gQWArsqaEUEa5bE=
|
||||
github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
|
||||
github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
|
||||
github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
|
||||
github.com/google/pprof v0.0.0-20261016150608-1facf8f91b50 h1:PlNWJRxu5APSV0pWqfIsZ0qt9OOGHSWfZQ4zvx+WgWs=
|
||||
github.com/google/pprof v0.0.0-20261016150608-1facf8f91b50/go.mod h1:yUo1AMMpsPIDFGuwDK8nLcf8+vvAd5l2O6JDZ6hpwrM=
|
||||
github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
|
||||
github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
|
||||
github.com/hashicorp/golang-lru/v2 v2.0.7 h1:a+bsQ5rvGLjzHuww6tVxozPZFVghXaHOwFs4luLUK2k=
|
||||
github.com/hashicorp/golang-lru/v2 v2.0.7/go.mod h1:QeFd9opnmA6QUJc5vARoKUSoFhyfM2/ZepoAG6RGpeM=
|
||||
github.com/jackc/pgpassfile v1.0.0 h1:/6Hmqy13Ss2zCq62VdNG8tM1wchn8zjSGOBJ6icpsIM=
|
||||
github.com/jackc/pgpassfile v1.0.0/go.mod h1:CEx0iS5ambNFdcRtxPj5JhEz+xB6uRky5eyVu/W2HEg=
|
||||
github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 h1:iCEnooe7UlwOQYpKFhBabPMi4aNAfoODPEFNiAnClxo=
|
||||
github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761/go.mod h1:5TJZWKEWniPve33vlWYSoGYefn3gLQRzjfDlhSJ9ZKM=
|
||||
github.com/jackc/pgx/v5 v5.12.0 h1:hWwax8YiGT0YiN50U1oIDn5kgR7KC2tG3rmavwpPkxY=
|
||||
github.com/jackc/pgx/v5 v5.12.0/go.mod h1:u2Fi6no03HCSBYE+ZVdLxbwdu3xyi2vU+K/YNJioSds=
|
||||
github.com/jackc/puddle/v2 v2.2.3 h1:f8HoREISb3l5eO9coPgK7U3hKLhWGokOFVcThl5jrao=
|
||||
github.com/jackc/puddle/v2 v2.2.3/go.mod h1:vriiEXHvEE654aYKXXjOvZM39qJ0q+azkZFrfEOc3H4=
|
||||
github.com/jinzhu/inflection v1.0.0 h1:K317FqzuhWc8YvSVlFMCCUb36O/S9MCKRDI7QkRKD/E=
|
||||
github.com/jinzhu/inflection v1.0.0/go.mod h1:h+uFLlag+Qp1Va5pdKtLDYj+kHp5pxUVkryuEj+Srlc=
|
||||
github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM=
|
||||
github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo=
|
||||
github.com/klauspost/cpuid/v2 v2.3.0 h1:S4CRMLnYUhGeDFDqkGriYKdfoFlDnMtqTiI/sFzhA9Y=
|
||||
github.com/klauspost/cpuid/v2 v2.3.0/go.mod h1:hqwkgyIinND0mEev00jJYCxPNVRVXFQeu1XKlok6oO0=
|
||||
github.com/leodido/go-urn v1.4.0 h1:WT9HwE9SGECu3lg4d/dIA+jxlljEa1/ffXKmRjqdmIQ=
|
||||
github.com/leodido/go-urn v1.4.0/go.mod h1:bvxc+MVxLKB4z00jd1z+Dvzr47oO32F/QSNjSBOlFxI=
|
||||
github.com/mattn/go-isatty v0.0.24 h1:tGZZoVgT/KiqK1c8ocVLeDS8BSWMRd47J3Lbz7vsReI=
|
||||
github.com/mattn/go-isatty v0.0.24/go.mod h1:nMCL3Zebbrt45jsMDgnfIwz6ydEQApk5oEI3HqDio6A=
|
||||
github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
|
||||
github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w8PVh93nsPXa1VrQ6jlwL5oN8l14QlcNfg=
|
||||
github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
|
||||
github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9Gz0M=
|
||||
github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk=
|
||||
github.com/ncruces/go-strftime v1.1.0 h1:vtPmPWMkb539RGV9WpWT9EwJGvrOCKvMNI4obWL47Hk=
|
||||
github.com/ncruces/go-strftime v1.1.0/go.mod h1:yVaq7iwCN09vHRrKBrrflXT0M9tTMG2KmZ9Fj7xeG/g=
|
||||
github.com/pelletier/go-toml/v2 v2.4.3 h1:GTRvJQutkOSftxIFD5xw9aepkYNuPWmVJpffdDPYVpY=
|
||||
github.com/pelletier/go-toml/v2 v2.4.3/go.mod h1:2gIqNv+qfxSVS7cM2xJQKtLSTLUE9V8t9Stt+h56mCY=
|
||||
github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
|
||||
github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
|
||||
github.com/puzpuzpuz/xsync/v3 v3.5.1 h1:GJYJZwO6IdxN/IKbneznS6yPkVC+c3zyY/j19c++5Fg=
|
||||
github.com/puzpuzpuz/xsync/v3 v3.5.1/go.mod h1:VjzYrABPabuM4KyBh1Ftq6u8nhwY5tBPKP9jpmh0nnA=
|
||||
github.com/quic-go/qpack v0.6.0 h1:g7W+BMYynC1LbYLSqRt8PBg5Tgwxn214ZZR34VIOjz8=
|
||||
github.com/quic-go/qpack v0.6.0/go.mod h1:lUpLKChi8njB4ty2bFLX2x4gzDqXwUpaO1DP9qMDZII=
|
||||
github.com/quic-go/quic-go v0.59.0 h1:OLJkp1Mlm/aS7dpKgTc6cnpynnD2Xg7C1pwL6vy/SAw=
|
||||
github.com/quic-go/quic-go v0.59.0/go.mod h1:upnsH4Ju1YkqpLXC305eW3yDZ4NfnNbmQRCMWS58IKU=
|
||||
github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec h1:W09IVJc94icq4NjY3clb7Lk8O1qJ8BdBEF8z0ibU0rE=
|
||||
github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec/go.mod h1:qqbHyh8v60DhA7CoWK5oRCqLrMHRGoxYCSS9EjAz6Eo=
|
||||
github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
|
||||
github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
|
||||
github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
|
||||
github.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/8L+MA=
|
||||
github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
|
||||
github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
|
||||
github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
|
||||
github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
|
||||
github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
|
||||
github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
|
||||
github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
|
||||
github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
|
||||
github.com/tmthrgd/go-hex v0.0.0-20190904060850-447a3041c3bc h1:9lRDQMhESg+zvGYmW5DyG0UqvY96Bu5QYsTLvCHdrgo=
|
||||
github.com/tmthrgd/go-hex v0.0.0-20190904060850-447a3041c3bc/go.mod h1:bciPuU6GHm1iF1pBvUfxfsH0Wmnc2VbpgvbI9ZWuIRs=
|
||||
github.com/twitchyliquid64/golang-asm v0.15.1 h1:SU5vSMR7hnwNxj24w34ZyCi/FmDZTkS4MhqMhdFk5YI=
|
||||
github.com/twitchyliquid64/golang-asm v0.15.1/go.mod h1:a1lVb/DtPvCB8fslRZhAngC2+aY1QWCk3Cedj/Gdt08=
|
||||
github.com/ugorji/go/codec v1.3.1 h1:waO7eEiFDwidsBN6agj1vJQ4AG7lh2yqXyOXqhgQuyY=
|
||||
github.com/ugorji/go/codec v1.3.1/go.mod h1:pRBVtBSKl77K30Bv8R2P+cLSGaTtex6fsA2Wjqmfxj4=
|
||||
github.com/uptrace/bun v1.3.0 h1:hUcbfRpbQk4/upFSI+uZf6jSJw5A0lkIKt0XdpvbUZo=
|
||||
github.com/uptrace/bun v1.3.0/go.mod h1:wNltaKJk4JtOt4SG5I5zmA7v0/Mzjh1+/S906Rayd3Y=
|
||||
github.com/uptrace/bun/dialect/pgdialect v1.3.0 h1:0ZkGqGugxaPCxko4DV2f4d7i+FnM2Qj3rNpChfhiv54=
|
||||
github.com/uptrace/bun/dialect/pgdialect v1.3.0/go.mod h1:kP5HGEpAX8iJCqj3WHm04XnoeBPacdCN1P2HiwMtHpg=
|
||||
github.com/uptrace/bun/dialect/sqlitedialect v1.3.0 h1:XzxkORYksxkLsIQLJHFYUb3yDvqSQHzTungyKpJhHTw=
|
||||
github.com/uptrace/bun/dialect/sqlitedialect v1.3.0/go.mod h1:x2D1sY50Itio0I/FVdNe30oMUT2ObiAS+oILcMR+Wys=
|
||||
github.com/vmihailenco/msgpack/v5 v5.4.1 h1:cQriyiUvjTwOHg8QZaPihLWeRAAVoCpE00IUPn0Bjt8=
|
||||
github.com/vmihailenco/msgpack/v5 v5.4.1/go.mod h1:GaZTsDaehaPpQVyxrf5mtQlH+pc21PIudVV/E3rRQok=
|
||||
github.com/vmihailenco/tagparser/v2 v2.0.0 h1:y09buUbR+b5aycVFQs/g70pqKVZNBmxwAhO7/IwNM9g=
|
||||
github.com/vmihailenco/tagparser/v2 v2.0.0/go.mod h1:Wri+At7QHww0WTrCBeu4J6bNtoV6mEfg5OIWRZA9qds=
|
||||
go.mongodb.org/mongo-driver/v2 v2.5.0 h1:yXUhImUjjAInNcpTcAlPHiT7bIXhshCTL3jVBkF3xaE=
|
||||
go.mongodb.org/mongo-driver/v2 v2.5.0/go.mod h1:yOI9kBsufol30iFsl1slpdq1I0eHPzybRWdyYUs8K/0=
|
||||
go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto=
|
||||
go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE=
|
||||
go.uber.org/mock v0.6.0 h1:hyF9dfmbgIX5EfOdasqLsWD6xqpNZlXblLB/Dbnwv3Y=
|
||||
go.uber.org/mock v0.6.0/go.mod h1:KiVJ4BqZJaMj4svdfmHM0AUx4NJYO8ZNpPnZn1Z+BBU=
|
||||
go.uber.org/multierr v1.11.0 h1:blXXJkSxSSfBVBlC76pxqeO+LN3aDfLQo+309xJstO0=
|
||||
go.uber.org/multierr v1.11.0/go.mod h1:20+QtiLqy0Nd6FdQB9TLXag12DsQkrbs3htMFfDN80Y=
|
||||
go.uber.org/zap v1.28.0 h1:IZzaP1Fv73/T/pBMLk4VutPl36uNC+OSUh3JLG3FIjo=
|
||||
go.uber.org/zap v1.28.0/go.mod h1:rDLpOi171uODNm/mxFcuYWxDsqWSAVkFdX4XojSKg/Q=
|
||||
go.yaml.in/yaml/v3 v3.0.4 h1:tfq32ie2Jv2UxXFdLJdh3jXuOzWiL1fo0bu/FbuKpbc=
|
||||
go.yaml.in/yaml/v3 v3.0.4/go.mod h1:DhzuOOF2ATzADvBadXxruRBLzYTpT36CKvDb3+aBEFg=
|
||||
golang.org/x/arch v0.22.0 h1:c/Zle32i5ttqRXjdLyyHZESLD/bB90DCU1g9l/0YBDI=
|
||||
golang.org/x/arch v0.22.0/go.mod h1:dNHoOeKiyja7GTvF9NJS1l3Z2yntpQNzgrjh1cU103A=
|
||||
golang.org/x/crypto v0.58.0 h1:COkYLr4k7nDI4r6QtMML2AfzeIswWHAJthLS6K/M/54=
|
||||
golang.org/x/crypto v0.58.0/go.mod h1:Xh+kl5A+M0gMiWDytH2Hhr5Z7WbNCpv/eB/EFgfSk+w=
|
||||
golang.org/x/mod v0.42.0 h1:ICeL3t2L30ljSPHHxDnR4fqVcBt/zR2zJAb9juavmQg=
|
||||
golang.org/x/mod v0.42.0/go.mod h1:u5fzIrRInkL8MaO1cbRkUHT64v303YIT5KEqpNr7jRs=
|
||||
golang.org/x/net v0.60.0 h1:79p50tfZlm0J9YfoDsSi639qSXNGVwEzOPLCxM2FsYU=
|
||||
golang.org/x/net v0.60.0/go.mod h1:2DA/G1UfVbCpQPeWTmMPGY7Cs2PkBkwu743bVX5PIVg=
|
||||
golang.org/x/sync v0.24.0 h1:iqiDrGoDgyuvAKrhLQthUEzU/R378N78gXbBjxed7oA=
|
||||
golang.org/x/sync v0.24.0/go.mod h1:sUUOizhqBxiL6pEWpqNLUiaJn1ShEbZ6BBqskPbjZm0=
|
||||
golang.org/x/sys v0.49.0 h1:XbzkgYJHdqh/8m2Uu0W/dQv8nktxx4BFHp1M0gROTXA=
|
||||
golang.org/x/sys v0.49.0/go.mod h1:hNLxWAXmnKAxqDtdwIYC4bM9oQPEecfsnNMuSxOs3og=
|
||||
golang.org/x/text v0.43.0 h1:1QivrlhwAsnMOcqgOdl9my7s9OyZl8O5/UGUTJVXoWc=
|
||||
golang.org/x/text v0.43.0/go.mod h1:hbSIYA/amXcRXTFSZqh8tWHEoqRvvbKPJ2uz/KU+a+s=
|
||||
golang.org/x/tools v0.52.0 h1:ryxg4U63oaUYk7uOLTF37n43f4qgtGvqV4Ioit1BaEs=
|
||||
golang.org/x/tools v0.52.0/go.mod h1:ItcP5UNaVGG+Yc4eIYmaFLNJ4soEopkx5Y2d4lcEurs=
|
||||
google.golang.org/protobuf v1.36.10 h1:AYd7cD/uASjIL6Q9LiTjz8JLcrh/88q5UObnmY3aOOE=
|
||||
google.golang.org/protobuf v1.36.10/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco=
|
||||
gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
|
||||
gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
|
||||
gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
|
||||
gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
|
||||
modernc.org/cc/v4 v4.30.6-0.20261101114202-1b9d1a076f6b h1:WE5SLOURcNd8s6uPR/n4WV4weQxxYKi5OpEZkfNVvdE=
|
||||
modernc.org/cc/v4 v4.30.6-0.20261101114202-1b9d1a076f6b/go.mod h1:OnovgIhbbMXMu1aISnJ0wvVD1KnW+cAUJkIrAWh+kVI=
|
||||
modernc.org/ccgo/v4 v4.38.1 h1:wdxJVBuFT8JufZnnQyS6Bbz3NOWhViD0xJOGR96Bpd4=
|
||||
modernc.org/ccgo/v4 v4.38.1/go.mod h1:kOpEkJRbFwBvjUWwn4j1j9B7iFHbl1+orhgTMCDkDBk=
|
||||
modernc.org/fileutil v1.4.0 h1:j6ZzNTftVS054gi281TyLjHPp6CPHr2KCxEXjEbD6SM=
|
||||
modernc.org/fileutil v1.4.0/go.mod h1:EqdKFDxiByqxLk8ozOxObDSfcVOv/54xDs/DUHdvCUU=
|
||||
modernc.org/gc/v2 v2.6.5 h1:nyqdV8q46KvTpZlsw66kWqwXRHdjIlJOhG6kxiV/9xI=
|
||||
modernc.org/gc/v2 v2.6.5/go.mod h1:YgIahr1ypgfe7chRuJi2gD7DBQiKSLMPgBQe9oIiito=
|
||||
modernc.org/gc/v3 v3.2.0 h1:/Y3LGDMQaoYf55PebP1qsZ5FDGgAZyG1RYKEHeQzh1o=
|
||||
modernc.org/gc/v3 v3.2.0/go.mod h1:HFK/6AGESC7Ex+EZJhJ2Gni6cTaYpSMmU/cT9RmlfYY=
|
||||
modernc.org/goabi0 v0.2.0 h1:HvEowk7LxcPd0eq6mVOAEMai46V+i7Jrj13t4AzuNks=
|
||||
modernc.org/goabi0 v0.2.0/go.mod h1:CEFRnnJhKvWT1c1JTI3Avm+tgOWbkOu5oPA8eH8LnMI=
|
||||
modernc.org/libc v1.80.1 h1:ejn7HtTV3GknNKbklqWQ1nvUrfX8mTxs1D+xp/JQwy4=
|
||||
modernc.org/libc v1.80.1/go.mod h1:pvo25Rs3OJEbDqhUV9jdEGevxeLJrJeDmNid/AcQV1g=
|
||||
modernc.org/mathutil v1.7.1 h1:GCZVGXdaN8gTqB1Mf/usp1Y/hSqgI2vAGGP4jZMCxOU=
|
||||
modernc.org/mathutil v1.7.1/go.mod h1:4p5IwJITfppl0G4sUEDtCr4DthTaT47/N3aT6MhfgJg=
|
||||
modernc.org/memory v1.12.1 h1:nFMiWrpStgZczNl6XI9GnIk/rWhYIyHGUaR04pGbp9g=
|
||||
modernc.org/memory v1.12.1/go.mod h1:/JP4VbVC+K5sU2wZi9bHoq2MAkCnrt2r98UGeSK7Mjw=
|
||||
modernc.org/opt v0.2.0 h1:tGyef5ApycA7FSEOMraay9SaTk5zmbx7Tu+cJs4QKZg=
|
||||
modernc.org/opt v0.2.0/go.mod h1:03fq9lsNfvkYSfxrfUhZCWPk1lm4cq4N+Bh//bEtgns=
|
||||
modernc.org/sortutil v1.2.1 h1:+xyoGf15mM3NMlPDnFqrteY07klSFxLElE2PVuWIJ7w=
|
||||
modernc.org/sortutil v1.2.1/go.mod h1:7ZI3a3REbai7gzCLcotuw9AC4VZVpYMjDzETGsSMqJE=
|
||||
modernc.org/sqlite v1.62.0 h1:gMaCjSM1qpl+iOjiWhR1LYP3zqrYDI+5GYLGt6veP2g=
|
||||
modernc.org/sqlite v1.62.0/go.mod h1:Jzjh1mt4s0HuQ0KvtB1LIuHiGRmU2D5pgj8dUhW7/SE=
|
||||
modernc.org/strutil v1.2.1 h1:UneZBkQA+DX2Rp35KcM69cSsNES9ly8mQWD71HKlOA0=
|
||||
modernc.org/strutil v1.2.1/go.mod h1:EHkiggD70koQxjVdSBM3JKM7k6L0FbGE5eymy9i3B9A=
|
||||
modernc.org/token v1.1.0 h1:Xl7Ap9dKaEs5kLoOQeQmPWevfnk/DM5qcLcYlA8ys6Y=
|
||||
modernc.org/token v1.1.0/go.mod h1:UGzOrNV1mAFSEB63lOFHIpNRUVMvYTc6yu1SMY/XTDM=
|
||||
213
internal/api/http/api_test.go
Normal file
213
internal/api/http/api_test.go
Normal file
|
|
@ -0,0 +1,213 @@
|
|||
package httpapi
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"context"
|
||||
"encoding/json"
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"github.com/gin-gonic/gin"
|
||||
"go.uber.org/zap"
|
||||
|
||||
"codeberg.org/squidd/sonda/internal/auth"
|
||||
"codeberg.org/squidd/sonda/internal/listening"
|
||||
"codeberg.org/squidd/sonda/internal/storage"
|
||||
"codeberg.org/squidd/sonda/migrations"
|
||||
)
|
||||
|
||||
const secret = "0123456789abcdef0123456789abcdef"
|
||||
|
||||
func init() { gin.SetMode(gin.TestMode) }
|
||||
|
||||
// newTestAPI wires real services on a temporary SQLite database.
|
||||
func newTestAPI(t *testing.T) http.Handler {
|
||||
t.Helper()
|
||||
db, err := storage.Open(storage.DriverSQLite, filepath.Join(t.TempDir(), "api.db"))
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
t.Cleanup(func() { _ = db.Close() })
|
||||
fsys, err := migrations.For(storage.DriverSQLite)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := storage.Migrate(context.Background(), db, fsys); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if _, err := db.DB.Exec("INSERT INTO tracks (title) VALUES ('song')"); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
tokens := auth.NewTokenIssuer(secret, time.Hour)
|
||||
return NewRouter(Deps{
|
||||
Logger: zap.NewNop(),
|
||||
Auth: auth.NewService(storage.NewUserRepo(db), tokens),
|
||||
Tokens: tokens,
|
||||
Listening: listening.NewService(storage.NewListeningRepo(db)),
|
||||
})
|
||||
}
|
||||
|
||||
type resp struct {
|
||||
Code int
|
||||
Body map[string]any
|
||||
}
|
||||
|
||||
func do(t *testing.T, h http.Handler, method, path, token string, body any) resp {
|
||||
t.Helper()
|
||||
var buf bytes.Buffer
|
||||
if body != nil {
|
||||
if s, ok := body.(string); ok {
|
||||
buf.WriteString(s)
|
||||
} else if err := json.NewEncoder(&buf).Encode(body); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
req := httptest.NewRequest(method, path, &buf)
|
||||
req.Header.Set("Content-Type", "application/json")
|
||||
if token != "" {
|
||||
req.Header.Set("Authorization", "Bearer "+token)
|
||||
}
|
||||
rec := httptest.NewRecorder()
|
||||
h.ServeHTTP(rec, req)
|
||||
|
||||
out := resp{Code: rec.Code, Body: map[string]any{}}
|
||||
_ = json.Unmarshal(rec.Body.Bytes(), &out.Body)
|
||||
return out
|
||||
}
|
||||
|
||||
func errCode(r resp) string {
|
||||
e, _ := r.Body["error"].(map[string]any)
|
||||
c, _ := e["code"].(string)
|
||||
return c
|
||||
}
|
||||
|
||||
// registerAndLogin creates the first user and returns a valid token.
|
||||
func registerAndLogin(t *testing.T, h http.Handler) string {
|
||||
t.Helper()
|
||||
creds := map[string]string{"username": "alice", "password": "longenough"}
|
||||
if r := do(t, h, "POST", "/api/v1/auth/register", "", creds); r.Code != http.StatusCreated {
|
||||
t.Fatalf("register: %d %v", r.Code, r.Body)
|
||||
}
|
||||
r := do(t, h, "POST", "/api/v1/auth/login", "", creds)
|
||||
if r.Code != http.StatusOK {
|
||||
t.Fatalf("login: %d %v", r.Code, r.Body)
|
||||
}
|
||||
tok, _ := r.Body["token"].(string)
|
||||
if tok == "" {
|
||||
t.Fatal("no token in login response")
|
||||
}
|
||||
return tok
|
||||
}
|
||||
|
||||
func TestHealth(t *testing.T) {
|
||||
r := do(t, newTestAPI(t), "GET", "/api/v1/health", "", nil)
|
||||
if r.Code != http.StatusOK || r.Body["status"] != "ok" {
|
||||
t.Fatalf("health: %d %v", r.Code, r.Body)
|
||||
}
|
||||
}
|
||||
|
||||
func TestRegisterThenClosed(t *testing.T) {
|
||||
h := newTestAPI(t)
|
||||
registerAndLogin(t, h)
|
||||
|
||||
r := do(t, h, "POST", "/api/v1/auth/register", "", map[string]string{"username": "bob", "password": "longenough"})
|
||||
if r.Code != http.StatusForbidden || errCode(r) != "registration_closed" {
|
||||
t.Fatalf("second register: %d %v", r.Code, r.Body)
|
||||
}
|
||||
}
|
||||
|
||||
func TestRegisterInvalid(t *testing.T) {
|
||||
h := newTestAPI(t)
|
||||
for name, body := range map[string]any{
|
||||
"short password": map[string]string{"username": "alice", "password": "x"},
|
||||
"bad username": map[string]string{"username": "a", "password": "longenough"},
|
||||
"malformed json": "{not json",
|
||||
} {
|
||||
r := do(t, h, "POST", "/api/v1/auth/register", "", body)
|
||||
if r.Code != http.StatusBadRequest || errCode(r) != "invalid_input" {
|
||||
t.Errorf("%s: %d %v", name, r.Code, r.Body)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestLoginWrongPassword(t *testing.T) {
|
||||
h := newTestAPI(t)
|
||||
registerAndLogin(t, h)
|
||||
r := do(t, h, "POST", "/api/v1/auth/login", "", map[string]string{"username": "alice", "password": "nopenopenope"})
|
||||
if r.Code != http.StatusUnauthorized || errCode(r) != "invalid_credentials" {
|
||||
t.Fatalf("login: %d %v", r.Code, r.Body)
|
||||
}
|
||||
}
|
||||
|
||||
func TestListenRequiresAuth(t *testing.T) {
|
||||
h := newTestAPI(t)
|
||||
body := map[string]any{"track_id": 1, "event_type": "play", "idempotency_key": "k"}
|
||||
|
||||
if r := do(t, h, "POST", "/api/v1/listens", "", body); r.Code != http.StatusUnauthorized {
|
||||
t.Errorf("no token: %d", r.Code)
|
||||
}
|
||||
if r := do(t, h, "POST", "/api/v1/listens", "garbage", body); r.Code != http.StatusUnauthorized {
|
||||
t.Errorf("bad token: %d", r.Code)
|
||||
}
|
||||
|
||||
// A token signed with another secret is rejected.
|
||||
other, _, _ := auth.NewTokenIssuer("ffffffffffffffffffffffffffffffff", time.Hour).Issue(auth.User{ID: 1, Username: "alice"})
|
||||
if r := do(t, h, "POST", "/api/v1/listens", other, body); r.Code != http.StatusUnauthorized {
|
||||
t.Errorf("foreign token: %d", r.Code)
|
||||
}
|
||||
}
|
||||
|
||||
func TestListenFlow(t *testing.T) {
|
||||
h := newTestAPI(t)
|
||||
tok := registerAndLogin(t, h)
|
||||
body := map[string]any{
|
||||
"track_id": 1, "event_type": "complete", "duration_played_ms": 1000,
|
||||
"idempotency_key": "abc", "occurred_at": "2026-01-02T03:04:05Z",
|
||||
}
|
||||
|
||||
r := do(t, h, "POST", "/api/v1/listens", tok, body)
|
||||
if r.Code != http.StatusCreated || r.Body["status"] != "recorded" {
|
||||
t.Fatalf("first: %d %v", r.Code, r.Body)
|
||||
}
|
||||
|
||||
// Same idempotency key: accepted, not duplicated.
|
||||
r = do(t, h, "POST", "/api/v1/listens", tok, body)
|
||||
if r.Code != http.StatusOK || r.Body["status"] != "duplicate" {
|
||||
t.Fatalf("retry: %d %v", r.Code, r.Body)
|
||||
}
|
||||
|
||||
body["idempotency_key"] = "def"
|
||||
body["track_id"] = 999
|
||||
r = do(t, h, "POST", "/api/v1/listens", tok, body)
|
||||
if r.Code != http.StatusNotFound || errCode(r) != "track_not_found" {
|
||||
t.Fatalf("unknown track: %d %v", r.Code, r.Body)
|
||||
}
|
||||
|
||||
body["track_id"] = 1
|
||||
body["event_type"] = "dance"
|
||||
r = do(t, h, "POST", "/api/v1/listens", tok, body)
|
||||
if r.Code != http.StatusBadRequest || errCode(r) != "invalid_input" {
|
||||
t.Fatalf("bad type: %d %v", r.Code, r.Body)
|
||||
}
|
||||
|
||||
body["event_type"] = "play"
|
||||
body["occurred_at"] = "yesterday"
|
||||
r = do(t, h, "POST", "/api/v1/listens", tok, body)
|
||||
if r.Code != http.StatusBadRequest || errCode(r) != "invalid_input" {
|
||||
t.Fatalf("bad time: %d %v", r.Code, r.Body)
|
||||
}
|
||||
}
|
||||
|
||||
func TestBodyTooLarge(t *testing.T) {
|
||||
h := newTestAPI(t)
|
||||
huge := `{"username":"` + strings.Repeat("a", 200_000) + `","password":"longenough"}`
|
||||
r := do(t, h, "POST", "/api/v1/auth/register", "", huge)
|
||||
if r.Code != http.StatusBadRequest && r.Code != http.StatusRequestEntityTooLarge {
|
||||
t.Fatalf("huge body: %d", r.Code)
|
||||
}
|
||||
}
|
||||
18
internal/api/http/errors.go
Normal file
18
internal/api/http/errors.go
Normal file
|
|
@ -0,0 +1,18 @@
|
|||
package httpapi
|
||||
|
||||
import "github.com/gin-gonic/gin"
|
||||
|
||||
// errorBody is the consistent error envelope: {"error":{"code":"...","message":"..."}}.
|
||||
type errorBody struct {
|
||||
Error errorDetail `json:"error"`
|
||||
}
|
||||
|
||||
type errorDetail struct {
|
||||
Code string `json:"code"`
|
||||
Message string `json:"message"`
|
||||
}
|
||||
|
||||
// writeError aborts the request with the standard error envelope.
|
||||
func writeError(c *gin.Context, status int, code, message string) {
|
||||
c.AbortWithStatusJSON(status, errorBody{Error: errorDetail{Code: code, Message: message}})
|
||||
}
|
||||
68
internal/api/http/handlers_auth.go
Normal file
68
internal/api/http/handlers_auth.go
Normal file
|
|
@ -0,0 +1,68 @@
|
|||
package httpapi
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"net/http"
|
||||
"time"
|
||||
|
||||
"github.com/gin-gonic/gin"
|
||||
|
||||
"codeberg.org/squidd/sonda/internal/auth"
|
||||
)
|
||||
|
||||
type authHandlers struct{ svc authService }
|
||||
|
||||
type credentials struct {
|
||||
Username string `json:"username"`
|
||||
Password string `json:"password"`
|
||||
}
|
||||
|
||||
type userJSON struct {
|
||||
ID int64 `json:"id"`
|
||||
Username string `json:"username"`
|
||||
}
|
||||
|
||||
// register creates the first user. It is closed once any user exists.
|
||||
func (h *authHandlers) register(c *gin.Context) {
|
||||
var req credentials
|
||||
if err := c.ShouldBindJSON(&req); err != nil {
|
||||
writeError(c, http.StatusBadRequest, "invalid_input", "malformed JSON body")
|
||||
return
|
||||
}
|
||||
user, err := h.svc.Register(c.Request.Context(), req.Username, req.Password)
|
||||
switch {
|
||||
case errors.Is(err, auth.ErrInvalidInput):
|
||||
writeError(c, http.StatusBadRequest, "invalid_input", err.Error())
|
||||
case errors.Is(err, auth.ErrRegistrationClosed):
|
||||
writeError(c, http.StatusForbidden, "registration_closed", err.Error())
|
||||
case errors.Is(err, auth.ErrUsernameTaken):
|
||||
writeError(c, http.StatusConflict, "username_taken", err.Error())
|
||||
case err != nil:
|
||||
_ = c.Error(err)
|
||||
writeError(c, http.StatusInternalServerError, "internal", "internal error")
|
||||
default:
|
||||
c.JSON(http.StatusCreated, userJSON{ID: user.ID, Username: user.Username})
|
||||
}
|
||||
}
|
||||
|
||||
func (h *authHandlers) login(c *gin.Context) {
|
||||
var req credentials
|
||||
if err := c.ShouldBindJSON(&req); err != nil {
|
||||
writeError(c, http.StatusBadRequest, "invalid_input", "malformed JSON body")
|
||||
return
|
||||
}
|
||||
res, err := h.svc.Login(c.Request.Context(), req.Username, req.Password)
|
||||
switch {
|
||||
case errors.Is(err, auth.ErrInvalidCredentials):
|
||||
writeError(c, http.StatusUnauthorized, "invalid_credentials", err.Error())
|
||||
case err != nil:
|
||||
_ = c.Error(err)
|
||||
writeError(c, http.StatusInternalServerError, "internal", "internal error")
|
||||
default:
|
||||
c.JSON(http.StatusOK, gin.H{
|
||||
"token": res.Token,
|
||||
"expires_at": res.ExpiresAt.UTC().Format(time.RFC3339),
|
||||
"user": userJSON{ID: res.User.ID, Username: res.User.Username},
|
||||
})
|
||||
}
|
||||
}
|
||||
65
internal/api/http/handlers_listen.go
Normal file
65
internal/api/http/handlers_listen.go
Normal file
|
|
@ -0,0 +1,65 @@
|
|||
package httpapi
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"net/http"
|
||||
"time"
|
||||
|
||||
"github.com/gin-gonic/gin"
|
||||
|
||||
"codeberg.org/squidd/sonda/internal/listening"
|
||||
)
|
||||
|
||||
type listenHandlers struct{ svc listenService }
|
||||
|
||||
type listenRequest struct {
|
||||
TrackID int64 `json:"track_id"`
|
||||
EventType string `json:"event_type"`
|
||||
OccurredAt string `json:"occurred_at"` // RFC 3339, optional
|
||||
DurationPlayedMs int64 `json:"duration_played_ms"`
|
||||
IdempotencyKey string `json:"idempotency_key"`
|
||||
}
|
||||
|
||||
// record ingests one explicit listen event for the authenticated user.
|
||||
func (h *listenHandlers) record(c *gin.Context) {
|
||||
var req listenRequest
|
||||
if err := c.ShouldBindJSON(&req); err != nil {
|
||||
writeError(c, http.StatusBadRequest, "invalid_input", "malformed JSON body")
|
||||
return
|
||||
}
|
||||
|
||||
var occurred time.Time
|
||||
if req.OccurredAt != "" {
|
||||
t, err := time.Parse(time.RFC3339, req.OccurredAt)
|
||||
if err != nil {
|
||||
writeError(c, http.StatusBadRequest, "invalid_input", "occurred_at must be RFC 3339")
|
||||
return
|
||||
}
|
||||
occurred = t
|
||||
}
|
||||
|
||||
userID, _ := c.Get(ctxUserID)
|
||||
uid, _ := userID.(int64)
|
||||
|
||||
created, err := h.svc.Record(c.Request.Context(), listening.Event{
|
||||
UserID: uid,
|
||||
TrackID: req.TrackID,
|
||||
Type: listening.EventType(req.EventType),
|
||||
OccurredAt: occurred,
|
||||
DurationPlayedMs: req.DurationPlayedMs,
|
||||
IdempotencyKey: req.IdempotencyKey,
|
||||
})
|
||||
switch {
|
||||
case errors.Is(err, listening.ErrInvalidEvent):
|
||||
writeError(c, http.StatusBadRequest, "invalid_input", err.Error())
|
||||
case errors.Is(err, listening.ErrTrackNotFound):
|
||||
writeError(c, http.StatusNotFound, "track_not_found", err.Error())
|
||||
case err != nil:
|
||||
_ = c.Error(err)
|
||||
writeError(c, http.StatusInternalServerError, "internal", "internal error")
|
||||
case created:
|
||||
c.JSON(http.StatusCreated, gin.H{"status": "recorded"})
|
||||
default:
|
||||
c.JSON(http.StatusOK, gin.H{"status": "duplicate"})
|
||||
}
|
||||
}
|
||||
58
internal/api/http/middleware.go
Normal file
58
internal/api/http/middleware.go
Normal file
|
|
@ -0,0 +1,58 @@
|
|||
package httpapi
|
||||
|
||||
import (
|
||||
"net/http"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"github.com/gin-gonic/gin"
|
||||
"go.uber.org/zap"
|
||||
)
|
||||
|
||||
const (
|
||||
ctxUserID = "user_id"
|
||||
ctxUsername = "username"
|
||||
)
|
||||
|
||||
// limitBody caps the request body size.
|
||||
func limitBody(max int64) gin.HandlerFunc {
|
||||
return func(c *gin.Context) {
|
||||
c.Request.Body = http.MaxBytesReader(c.Writer, c.Request.Body, max)
|
||||
c.Next()
|
||||
}
|
||||
}
|
||||
|
||||
// requestLog logs one line per request. It never logs headers, query strings
|
||||
// or bodies, so tokens and passwords cannot leak into the log.
|
||||
func requestLog(logger *zap.Logger) gin.HandlerFunc {
|
||||
return func(c *gin.Context) {
|
||||
start := time.Now()
|
||||
c.Next()
|
||||
logger.Info("http request",
|
||||
zap.String("method", c.Request.Method),
|
||||
zap.String("path", c.Request.URL.Path),
|
||||
zap.Int("status", c.Writer.Status()),
|
||||
zap.Duration("latency", time.Since(start)),
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
// requireAuth accepts only "Authorization: Bearer <jwt>".
|
||||
func requireAuth(tokens tokenParser) gin.HandlerFunc {
|
||||
return func(c *gin.Context) {
|
||||
header := c.GetHeader("Authorization")
|
||||
token, ok := strings.CutPrefix(header, "Bearer ")
|
||||
if !ok || token == "" {
|
||||
writeError(c, http.StatusUnauthorized, "unauthorized", "missing bearer token")
|
||||
return
|
||||
}
|
||||
claims, err := tokens.Parse(token)
|
||||
if err != nil {
|
||||
writeError(c, http.StatusUnauthorized, "unauthorized", "invalid or expired token")
|
||||
return
|
||||
}
|
||||
c.Set(ctxUserID, claims.UserID)
|
||||
c.Set(ctxUsername, claims.Username)
|
||||
c.Next()
|
||||
}
|
||||
}
|
||||
64
internal/api/http/router.go
Normal file
64
internal/api/http/router.go
Normal file
|
|
@ -0,0 +1,64 @@
|
|||
// Package httpapi is the first-party REST API (/api/v1).
|
||||
//
|
||||
// Handlers stay thin: they validate and serialize, then call services.
|
||||
package httpapi
|
||||
|
||||
import (
|
||||
"context"
|
||||
"net/http"
|
||||
|
||||
"github.com/gin-gonic/gin"
|
||||
"go.uber.org/zap"
|
||||
|
||||
"codeberg.org/squidd/sonda/internal/auth"
|
||||
"codeberg.org/squidd/sonda/internal/listening"
|
||||
)
|
||||
|
||||
// maxBodyBytes bounds every request body.
|
||||
const maxBodyBytes = 64 << 10
|
||||
|
||||
type authService interface {
|
||||
Register(ctx context.Context, username, password string) (auth.User, error)
|
||||
Login(ctx context.Context, username, password string) (auth.LoginResult, error)
|
||||
}
|
||||
|
||||
type tokenParser interface {
|
||||
Parse(token string) (auth.Claims, error)
|
||||
}
|
||||
|
||||
type listenService interface {
|
||||
Record(ctx context.Context, e listening.Event) (bool, error)
|
||||
}
|
||||
|
||||
// Deps are the services the API needs.
|
||||
type Deps struct {
|
||||
Logger *zap.Logger
|
||||
Auth authService
|
||||
Tokens tokenParser
|
||||
Listening listenService
|
||||
}
|
||||
|
||||
// NewRouter builds the gin engine with all routes.
|
||||
func NewRouter(d Deps) *gin.Engine {
|
||||
r := gin.New()
|
||||
_ = r.SetTrustedProxies(nil) // use the socket address; no forwarded-header trust yet
|
||||
r.Use(gin.Recovery(), limitBody(maxBodyBytes), requestLog(d.Logger))
|
||||
r.NoRoute(func(c *gin.Context) { writeError(c, http.StatusNotFound, "not_found", "no such route") })
|
||||
|
||||
v1 := r.Group("/api/v1")
|
||||
v1.GET("/health", health)
|
||||
|
||||
a := &authHandlers{svc: d.Auth}
|
||||
v1.POST("/auth/register", a.register)
|
||||
v1.POST("/auth/login", a.login)
|
||||
|
||||
protected := v1.Group("", requireAuth(d.Tokens))
|
||||
l := &listenHandlers{svc: d.Listening}
|
||||
protected.POST("/listens", l.record)
|
||||
|
||||
return r
|
||||
}
|
||||
|
||||
func health(c *gin.Context) {
|
||||
c.JSON(http.StatusOK, gin.H{"status": "ok"})
|
||||
}
|
||||
202
internal/auth/auth_test.go
Normal file
202
internal/auth/auth_test.go
Normal file
|
|
@ -0,0 +1,202 @@
|
|||
package auth
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"strings"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"github.com/golang-jwt/jwt/v5"
|
||||
)
|
||||
|
||||
// ---- password hashing ----
|
||||
|
||||
func TestHashAndVerify(t *testing.T) {
|
||||
h, err := HashPassword("correct horse")
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if !strings.HasPrefix(h, "$argon2id$") {
|
||||
t.Fatalf("hash = %q, want argon2id PHC string", h)
|
||||
}
|
||||
if !VerifyPassword(h, "correct horse") {
|
||||
t.Error("correct password rejected")
|
||||
}
|
||||
if VerifyPassword(h, "wrong") {
|
||||
t.Error("wrong password accepted")
|
||||
}
|
||||
}
|
||||
|
||||
func TestHashIsSalted(t *testing.T) {
|
||||
a, _ := HashPassword("same")
|
||||
b, _ := HashPassword("same")
|
||||
if a == b {
|
||||
t.Error("two hashes of the same password are identical")
|
||||
}
|
||||
}
|
||||
|
||||
func TestVerifyRejectsGarbage(t *testing.T) {
|
||||
for _, h := range []string{"", "plaintext", "$argon2id$v=19$m=1,t=1,p=1$bad", "$bcrypt$x$y"} {
|
||||
if VerifyPassword(h, "x") {
|
||||
t.Errorf("garbage hash %q accepted", h)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// ---- tokens ----
|
||||
|
||||
const testSecret = "0123456789abcdef0123456789abcdef"
|
||||
|
||||
func TestTokenRoundTrip(t *testing.T) {
|
||||
iss := NewTokenIssuer(testSecret, time.Hour)
|
||||
tok, exp, err := iss.Issue(User{ID: 7, Username: "bob"})
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if time.Until(exp) <= 0 {
|
||||
t.Error("expiry is not in the future")
|
||||
}
|
||||
claims, err := iss.Parse(tok)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if claims.UserID != 7 || claims.Username != "bob" {
|
||||
t.Errorf("claims = %+v", claims)
|
||||
}
|
||||
}
|
||||
|
||||
func TestTokenExpired(t *testing.T) {
|
||||
iss := NewTokenIssuer(testSecret, time.Hour)
|
||||
iss.now = func() time.Time { return time.Now().Add(-2 * time.Hour) }
|
||||
tok, _, err := iss.Issue(User{ID: 1, Username: "a"})
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
iss.now = time.Now
|
||||
if _, err := iss.Parse(tok); err == nil {
|
||||
t.Fatal("expired token accepted")
|
||||
}
|
||||
}
|
||||
|
||||
func TestTokenWrongSecret(t *testing.T) {
|
||||
tok, _, _ := NewTokenIssuer(testSecret, time.Hour).Issue(User{ID: 1, Username: "a"})
|
||||
other := NewTokenIssuer("ffffffffffffffffffffffffffffffff", time.Hour)
|
||||
if _, err := other.Parse(tok); err == nil {
|
||||
t.Fatal("token signed with another secret accepted")
|
||||
}
|
||||
}
|
||||
|
||||
func TestTokenRejectsAlgNone(t *testing.T) {
|
||||
claims := jwt.RegisteredClaims{
|
||||
Subject: "1",
|
||||
Issuer: tokenIssuerName,
|
||||
ExpiresAt: jwt.NewNumericDate(time.Now().Add(time.Hour)),
|
||||
}
|
||||
tok, err := jwt.NewWithClaims(jwt.SigningMethodNone, claims).SignedString(jwt.UnsafeAllowNoneSignatureType)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if _, err := NewTokenIssuer(testSecret, time.Hour).Parse(tok); err == nil {
|
||||
t.Fatal("alg=none token accepted")
|
||||
}
|
||||
}
|
||||
|
||||
func TestTokenGarbage(t *testing.T) {
|
||||
if _, err := NewTokenIssuer(testSecret, time.Hour).Parse("not.a.jwt"); err == nil {
|
||||
t.Fatal("garbage token accepted")
|
||||
}
|
||||
}
|
||||
|
||||
// ---- service ----
|
||||
|
||||
type fakeStore struct {
|
||||
users map[string]fakeUser
|
||||
next int64
|
||||
}
|
||||
|
||||
type fakeUser struct {
|
||||
u User
|
||||
hash string
|
||||
}
|
||||
|
||||
func newFakeStore() *fakeStore { return &fakeStore{users: map[string]fakeUser{}} }
|
||||
|
||||
func (f *fakeStore) CountUsers(context.Context) (int, error) { return len(f.users), nil }
|
||||
|
||||
func (f *fakeStore) CreateUser(_ context.Context, username, hash string) (User, error) {
|
||||
key := strings.ToLower(username)
|
||||
if _, ok := f.users[key]; ok {
|
||||
return User{}, ErrUsernameTaken
|
||||
}
|
||||
f.next++
|
||||
u := User{ID: f.next, Username: username, CreatedAt: time.Now()}
|
||||
f.users[key] = fakeUser{u: u, hash: hash}
|
||||
return u, nil
|
||||
}
|
||||
|
||||
func (f *fakeStore) UserByUsername(_ context.Context, username string) (User, string, error) {
|
||||
fu, ok := f.users[strings.ToLower(username)]
|
||||
if !ok {
|
||||
return User{}, "", ErrUserNotFound
|
||||
}
|
||||
return fu.u, fu.hash, nil
|
||||
}
|
||||
|
||||
func newTestService() *Service {
|
||||
return NewService(newFakeStore(), NewTokenIssuer(testSecret, time.Hour))
|
||||
}
|
||||
|
||||
func TestRegisterFirstUserThenClosed(t *testing.T) {
|
||||
s := newTestService()
|
||||
ctx := context.Background()
|
||||
if _, err := s.Register(ctx, "alice", "longenough"); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if _, err := s.Register(ctx, "bob", "longenough"); !errors.Is(err, ErrRegistrationClosed) {
|
||||
t.Fatalf("err = %v, want ErrRegistrationClosed", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestRegisterValidation(t *testing.T) {
|
||||
tests := []struct {
|
||||
name, user, pass string
|
||||
}{
|
||||
{"short username", "ab", "longenough"},
|
||||
{"long username", strings.Repeat("a", 65), "longenough"},
|
||||
{"bad chars", "bad name!", "longenough"},
|
||||
{"short password", "alice", "short"},
|
||||
{"huge password", "alice", strings.Repeat("x", 300)},
|
||||
}
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
_, err := newTestService().Register(context.Background(), tt.user, tt.pass)
|
||||
if !errors.Is(err, ErrInvalidInput) {
|
||||
t.Fatalf("err = %v, want ErrInvalidInput", err)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestLogin(t *testing.T) {
|
||||
s := newTestService()
|
||||
ctx := context.Background()
|
||||
if _, err := s.Register(ctx, "alice", "longenough"); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
res, err := s.Login(ctx, "ALICE", "longenough") // usernames are case-insensitive
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if res.Token == "" || res.User.Username != "alice" {
|
||||
t.Errorf("result = %+v", res)
|
||||
}
|
||||
|
||||
if _, err := s.Login(ctx, "alice", "wrongpass1"); !errors.Is(err, ErrInvalidCredentials) {
|
||||
t.Errorf("wrong password: err = %v", err)
|
||||
}
|
||||
if _, err := s.Login(ctx, "nobody", "longenough"); !errors.Is(err, ErrInvalidCredentials) {
|
||||
t.Errorf("unknown user: err = %v", err)
|
||||
}
|
||||
}
|
||||
68
internal/auth/password.go
Normal file
68
internal/auth/password.go
Normal file
|
|
@ -0,0 +1,68 @@
|
|||
package auth
|
||||
|
||||
import (
|
||||
"crypto/rand"
|
||||
"crypto/subtle"
|
||||
"encoding/base64"
|
||||
"fmt"
|
||||
"strings"
|
||||
|
||||
"golang.org/x/crypto/argon2"
|
||||
)
|
||||
|
||||
// Argon2id parameters (64 MiB, 2 passes, 2 lanes).
|
||||
const (
|
||||
argonTime = 2
|
||||
argonMemory = 64 * 1024 // KiB
|
||||
argonThreads = 2
|
||||
argonKeyLen = 32
|
||||
argonSaltLen = 16
|
||||
)
|
||||
|
||||
// HashPassword returns an Argon2id hash as a PHC-format string.
|
||||
func HashPassword(password string) (string, error) {
|
||||
salt := make([]byte, argonSaltLen)
|
||||
if _, err := rand.Read(salt); err != nil {
|
||||
return "", fmt.Errorf("generate salt: %w", err)
|
||||
}
|
||||
key := argon2.IDKey([]byte(password), salt, argonTime, argonMemory, argonThreads, argonKeyLen)
|
||||
return fmt.Sprintf("$argon2id$v=%d$m=%d,t=%d,p=%d$%s$%s",
|
||||
argon2.Version, argonMemory, argonTime, argonThreads,
|
||||
base64.RawStdEncoding.EncodeToString(salt),
|
||||
base64.RawStdEncoding.EncodeToString(key)), nil
|
||||
}
|
||||
|
||||
// VerifyPassword reports whether password matches a hash made by HashPassword.
|
||||
// Any malformed hash simply returns false.
|
||||
func VerifyPassword(encoded, password string) bool {
|
||||
parts := strings.Split(encoded, "$")
|
||||
if len(parts) != 6 || parts[1] != "argon2id" {
|
||||
return false
|
||||
}
|
||||
|
||||
var version int
|
||||
if _, err := fmt.Sscanf(parts[2], "v=%d", &version); err != nil || version != argon2.Version {
|
||||
return false
|
||||
}
|
||||
|
||||
var memory, time uint32
|
||||
var threads uint8
|
||||
if _, err := fmt.Sscanf(parts[3], "m=%d,t=%d,p=%d", &memory, &time, &threads); err != nil {
|
||||
return false
|
||||
}
|
||||
if memory == 0 || time == 0 || threads == 0 {
|
||||
return false
|
||||
}
|
||||
|
||||
salt, err := base64.RawStdEncoding.DecodeString(parts[4])
|
||||
if err != nil {
|
||||
return false
|
||||
}
|
||||
want, err := base64.RawStdEncoding.DecodeString(parts[5])
|
||||
if err != nil || len(want) == 0 {
|
||||
return false
|
||||
}
|
||||
|
||||
got := argon2.IDKey([]byte(password), salt, time, memory, threads, uint32(len(want)))
|
||||
return subtle.ConstantTimeCompare(got, want) == 1
|
||||
}
|
||||
121
internal/auth/service.go
Normal file
121
internal/auth/service.go
Normal file
|
|
@ -0,0 +1,121 @@
|
|||
// Package auth implements local users, password hashing and JWT access tokens.
|
||||
package auth
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"fmt"
|
||||
"regexp"
|
||||
"sync"
|
||||
"time"
|
||||
)
|
||||
|
||||
// Errors returned by the service. Handlers map them to HTTP statuses.
|
||||
var (
|
||||
ErrInvalidInput = errors.New("invalid input")
|
||||
ErrUsernameTaken = errors.New("username already taken")
|
||||
ErrUserNotFound = errors.New("user not found")
|
||||
ErrInvalidCredentials = errors.New("invalid username or password")
|
||||
ErrRegistrationClosed = errors.New("registration is closed")
|
||||
)
|
||||
|
||||
var usernameRe = regexp.MustCompile(`^[A-Za-z0-9._-]{3,64}$`)
|
||||
|
||||
const (
|
||||
minPasswordLen = 8
|
||||
maxPasswordLen = 256 // caps the work an attacker can force on the KDF
|
||||
)
|
||||
|
||||
// User is a local account. The password hash never leaves the store layer.
|
||||
type User struct {
|
||||
ID int64
|
||||
Username string
|
||||
CreatedAt time.Time
|
||||
}
|
||||
|
||||
// UserStore is what the service needs from persistence.
|
||||
type UserStore interface {
|
||||
CountUsers(ctx context.Context) (int, error)
|
||||
// CreateUser returns ErrUsernameTaken when the name exists (case-insensitive).
|
||||
CreateUser(ctx context.Context, username, passwordHash string) (User, error)
|
||||
// UserByUsername returns ErrUserNotFound when there is no such user.
|
||||
UserByUsername(ctx context.Context, username string) (User, string, error)
|
||||
}
|
||||
|
||||
// LoginResult is returned by a successful login.
|
||||
type LoginResult struct {
|
||||
Token string
|
||||
ExpiresAt time.Time
|
||||
User User
|
||||
}
|
||||
|
||||
// Service registers users and logs them in.
|
||||
type Service struct {
|
||||
store UserStore
|
||||
tokens *TokenIssuer
|
||||
|
||||
mu sync.Mutex // serialises Register so only one first user can win
|
||||
dummyOnce sync.Once
|
||||
dummyHash string
|
||||
}
|
||||
|
||||
// NewService builds a Service.
|
||||
func NewService(store UserStore, tokens *TokenIssuer) *Service {
|
||||
return &Service{store: store, tokens: tokens}
|
||||
}
|
||||
|
||||
// Register creates the first user. Once any user exists, registration is
|
||||
// closed: there is no admin flow yet.
|
||||
func (s *Service) Register(ctx context.Context, username, password string) (User, error) {
|
||||
if !usernameRe.MatchString(username) {
|
||||
return User{}, fmt.Errorf("%w: username must be 3-64 characters: letters, digits, '.', '_' or '-'", ErrInvalidInput)
|
||||
}
|
||||
if len(password) < minPasswordLen || len(password) > maxPasswordLen {
|
||||
return User{}, fmt.Errorf("%w: password must be %d-%d bytes", ErrInvalidInput, minPasswordLen, maxPasswordLen)
|
||||
}
|
||||
|
||||
s.mu.Lock()
|
||||
defer s.mu.Unlock()
|
||||
|
||||
n, err := s.store.CountUsers(ctx)
|
||||
if err != nil {
|
||||
return User{}, fmt.Errorf("count users: %w", err)
|
||||
}
|
||||
if n > 0 {
|
||||
return User{}, ErrRegistrationClosed
|
||||
}
|
||||
|
||||
hash, err := HashPassword(password)
|
||||
if err != nil {
|
||||
return User{}, err
|
||||
}
|
||||
return s.store.CreateUser(ctx, username, hash)
|
||||
}
|
||||
|
||||
// Login checks the credentials and returns a signed token.
|
||||
// Unknown user and wrong password are indistinguishable to the caller.
|
||||
func (s *Service) Login(ctx context.Context, username, password string) (LoginResult, error) {
|
||||
user, hash, err := s.store.UserByUsername(ctx, username)
|
||||
if errors.Is(err, ErrUserNotFound) {
|
||||
// Spend the same time as a real check to avoid revealing which names exist.
|
||||
VerifyPassword(s.fakeHash(), password)
|
||||
return LoginResult{}, ErrInvalidCredentials
|
||||
}
|
||||
if err != nil {
|
||||
return LoginResult{}, fmt.Errorf("find user: %w", err)
|
||||
}
|
||||
if !VerifyPassword(hash, password) {
|
||||
return LoginResult{}, ErrInvalidCredentials
|
||||
}
|
||||
|
||||
token, exp, err := s.tokens.Issue(user)
|
||||
if err != nil {
|
||||
return LoginResult{}, err
|
||||
}
|
||||
return LoginResult{Token: token, ExpiresAt: exp, User: user}, nil
|
||||
}
|
||||
|
||||
func (s *Service) fakeHash() string {
|
||||
s.dummyOnce.Do(func() { s.dummyHash, _ = HashPassword("sonda-dummy-password") })
|
||||
return s.dummyHash
|
||||
}
|
||||
71
internal/auth/token.go
Normal file
71
internal/auth/token.go
Normal file
|
|
@ -0,0 +1,71 @@
|
|||
package auth
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"strconv"
|
||||
"time"
|
||||
|
||||
"github.com/golang-jwt/jwt/v5"
|
||||
)
|
||||
|
||||
const tokenIssuerName = "sonda"
|
||||
|
||||
// Claims is what a valid access token tells us about the caller.
|
||||
type Claims struct {
|
||||
UserID int64
|
||||
Username string
|
||||
}
|
||||
|
||||
type tokenClaims struct {
|
||||
Username string `json:"username"`
|
||||
jwt.RegisteredClaims
|
||||
}
|
||||
|
||||
// TokenIssuer creates and verifies HS256 JWT access tokens.
|
||||
type TokenIssuer struct {
|
||||
secret []byte
|
||||
ttl time.Duration
|
||||
now func() time.Time
|
||||
}
|
||||
|
||||
// NewTokenIssuer builds an issuer. The secret must be long and random.
|
||||
func NewTokenIssuer(secret string, ttl time.Duration) *TokenIssuer {
|
||||
return &TokenIssuer{secret: []byte(secret), ttl: ttl, now: time.Now}
|
||||
}
|
||||
|
||||
// Issue signs a token for user and returns it with its expiry time.
|
||||
func (i *TokenIssuer) Issue(user User) (string, time.Time, error) {
|
||||
now := i.now()
|
||||
exp := now.Add(i.ttl)
|
||||
claims := tokenClaims{Username: user.Username,
|
||||
Issuer: tokenIssuerName,
|
||||
Subject: strconv.FormatInt(user.ID, 10),
|
||||
IssuedAt: jwt.NewNumericDate(now),
|
||||
ExpiresAt: jwt.NewNumericDate(exp)}
|
||||
|
||||
signed, err := jwt.NewWithClaims(jwt.SigningMethodHS256, claims).SignedString(i.secret)
|
||||
if err != nil {
|
||||
return "", time.Time{}, fmt.Errorf("sign token: %w", err)
|
||||
}
|
||||
return signed, exp, nil
|
||||
}
|
||||
|
||||
// Parse verifies the signature, algorithm, issuer and expiry of token.
|
||||
func (i *TokenIssuer) Parse(token string) (Claims, error) {
|
||||
var tc tokenClaims
|
||||
_, err := jwt.ParseWithClaims(token, &tc,
|
||||
func(*jwt.Token) (any, error) { return i.secret, nil },
|
||||
jwt.WithValidMethods([]string{jwt.SigningMethodHS256.Alg()}),
|
||||
jwt.WithIssuer(tokenIssuerName),
|
||||
jwt.WithExpirationRequired(),
|
||||
jwt.WithTimeFunc(i.now),
|
||||
)
|
||||
if err != nil {
|
||||
return Claims{}, fmt.Errorf("invalid token: %w", err)
|
||||
}
|
||||
id, err := strconv.ParseInt(tc.Subject, 10, 64)
|
||||
if err != nil || id <= 0 {
|
||||
return Claims{}, fmt.Errorf("invalid token: bad subject")
|
||||
}
|
||||
return Claims{UserID: id, Username: tc.Username}, nil
|
||||
}
|
||||
171
internal/config/config.go
Normal file
171
internal/config/config.go
Normal file
|
|
@ -0,0 +1,171 @@
|
|||
// Package config loads and validates the sondad configuration.
|
||||
//
|
||||
// Precedence: built-in defaults, then the TOML file, then environment variables.
|
||||
package config
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"errors"
|
||||
"fmt"
|
||||
"os"
|
||||
"time"
|
||||
|
||||
"github.com/pelletier/go-toml/v2"
|
||||
)
|
||||
|
||||
const minJWTSecretLen = 32
|
||||
|
||||
// Config is the full sondad configuration.
|
||||
type Config struct {
|
||||
Server Server `toml:"server"`
|
||||
Library Library `toml:"library"`
|
||||
Database Database `toml:"database"`
|
||||
Log Log `toml:"log"`
|
||||
Auth Auth `toml:"auth"`
|
||||
Providers Providers `toml:"providers"`
|
||||
}
|
||||
|
||||
// Server holds HTTP listener settings.
|
||||
type Server struct {
|
||||
Listen string `toml:"listen"`
|
||||
}
|
||||
|
||||
// Library holds the music directories. They are treated as read-only.
|
||||
type Library struct {
|
||||
Roots []string `toml:"roots"`
|
||||
}
|
||||
|
||||
// Database selects and configures the storage backend.
|
||||
//
|
||||
// Driver is "sqlite" (uses Path) or "postgres" (uses DSN).
|
||||
type Database struct {
|
||||
Driver string `toml:"driver"`
|
||||
Path string `toml:"path"`
|
||||
DSN string `toml:"dsn"`
|
||||
}
|
||||
|
||||
// Log holds logging settings. Env is "dev" or "production".
|
||||
type Log struct {
|
||||
Env string `toml:"env"`
|
||||
}
|
||||
|
||||
// Auth holds token settings. JWTSecret must be long and random,
|
||||
// for example: openssl rand -hex 32.
|
||||
type Auth struct {
|
||||
JWTSecret string `toml:"jwt_secret"`
|
||||
TokenTTLHours int `toml:"token_ttl_hours"`
|
||||
}
|
||||
|
||||
// TokenTTL returns the access token lifetime.
|
||||
func (a Auth) TokenTTL() time.Duration {
|
||||
return time.Duration(a.TokenTTLHours) * time.Hour
|
||||
}
|
||||
|
||||
// Providers holds external provider settings.
|
||||
type Providers struct {
|
||||
LastFM LastFM `toml:"lastfm"`
|
||||
}
|
||||
|
||||
// LastFM holds the Last.fm API settings.
|
||||
type LastFM struct {
|
||||
APIKey string `toml:"api_key"`
|
||||
}
|
||||
|
||||
// Default returns the configuration used when nothing else is set.
|
||||
func Default() Config {
|
||||
return Config{
|
||||
Server: Server{Listen: "127.0.0.1:8080"},
|
||||
Database: Database{Driver: "sqlite", Path: "sonda.db"},
|
||||
Log: Log{Env: "production"},
|
||||
Auth: Auth{TokenTTLHours: 168}, // one week
|
||||
}
|
||||
}
|
||||
|
||||
// Load builds a Config from defaults, the TOML file at path, and environment
|
||||
// variables. An empty path skips the file. Unknown keys in the file are errors.
|
||||
func Load(path string) (Config, error) {
|
||||
cfg := Default()
|
||||
|
||||
if path != "" {
|
||||
data, err := os.ReadFile(path)
|
||||
if err != nil {
|
||||
return Config{}, fmt.Errorf("read config: %w", err)
|
||||
}
|
||||
dec := toml.NewDecoder(bytes.NewReader(data))
|
||||
dec.DisallowUnknownFields()
|
||||
if err := dec.Decode(&cfg); err != nil {
|
||||
return Config{}, fmt.Errorf("parse config %s: %w", path, err)
|
||||
}
|
||||
}
|
||||
|
||||
applyEnv(&cfg)
|
||||
return cfg, nil
|
||||
}
|
||||
|
||||
func applyEnv(cfg *Config) {
|
||||
if v := os.Getenv("SONDA_ENV"); v != "" {
|
||||
cfg.Log.Env = v
|
||||
}
|
||||
if v := os.Getenv("SONDA_LISTEN"); v != "" {
|
||||
cfg.Server.Listen = v
|
||||
}
|
||||
if v := os.Getenv("SONDA_DB_DRIVER"); v != "" {
|
||||
cfg.Database.Driver = v
|
||||
}
|
||||
if v := os.Getenv("SONDA_DB_PATH"); v != "" {
|
||||
cfg.Database.Path = v
|
||||
}
|
||||
if v := os.Getenv("SONDA_DB_DSN"); v != "" {
|
||||
cfg.Database.DSN = v
|
||||
}
|
||||
if v := os.Getenv("SONDA_JWT_SECRET"); v != "" {
|
||||
cfg.Auth.JWTSecret = v
|
||||
}
|
||||
if v := os.Getenv("SONDA_LASTFM_API_KEY"); v != "" {
|
||||
cfg.Providers.LastFM.APIKey = v
|
||||
}
|
||||
}
|
||||
|
||||
// Validate checks that the configuration is usable.
|
||||
func (c Config) Validate() error {
|
||||
var errs []error
|
||||
|
||||
if c.Server.Listen == "" {
|
||||
errs = append(errs, errors.New("server.listen is required"))
|
||||
}
|
||||
switch c.Database.Driver {
|
||||
case "sqlite":
|
||||
if c.Database.Path == "" {
|
||||
errs = append(errs, errors.New("database.path is required for the sqlite driver"))
|
||||
}
|
||||
case "postgres":
|
||||
if c.Database.DSN == "" {
|
||||
errs = append(errs, errors.New("database.dsn is required for the postgres driver"))
|
||||
}
|
||||
default:
|
||||
errs = append(errs, fmt.Errorf("database.driver must be \"sqlite\" or \"postgres\", got %q", c.Database.Driver))
|
||||
}
|
||||
if c.Log.Env != "dev" && c.Log.Env != "production" {
|
||||
errs = append(errs, fmt.Errorf("log.env must be \"dev\" or \"production\", got %q", c.Log.Env))
|
||||
}
|
||||
if len(c.Auth.JWTSecret) < minJWTSecretLen {
|
||||
errs = append(errs, fmt.Errorf("auth.jwt_secret must be at least %d characters (try: openssl rand -hex 32)", minJWTSecretLen))
|
||||
}
|
||||
if c.Auth.TokenTTLHours <= 0 {
|
||||
errs = append(errs, errors.New("auth.token_ttl_hours must be greater than 0"))
|
||||
}
|
||||
if len(c.Library.Roots) == 0 {
|
||||
errs = append(errs, errors.New("library.roots needs at least one directory"))
|
||||
}
|
||||
for _, root := range c.Library.Roots {
|
||||
info, err := os.Stat(root)
|
||||
switch {
|
||||
case err != nil:
|
||||
errs = append(errs, fmt.Errorf("library.roots: %w", err))
|
||||
case !info.IsDir():
|
||||
errs = append(errs, fmt.Errorf("library.roots: %s is not a directory", root))
|
||||
}
|
||||
}
|
||||
|
||||
return errors.Join(errs...)
|
||||
}
|
||||
160
internal/config/config_test.go
Normal file
160
internal/config/config_test.go
Normal file
|
|
@ -0,0 +1,160 @@
|
|||
package config
|
||||
|
||||
import (
|
||||
"os"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
"testing"
|
||||
"time"
|
||||
)
|
||||
|
||||
func writeFile(t *testing.T, dir, content string) string {
|
||||
t.Helper()
|
||||
p := filepath.Join(dir, "sonda.toml")
|
||||
if err := os.WriteFile(p, []byte(content), 0o600); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
return p
|
||||
}
|
||||
|
||||
func TestLoadEmptyPathReturnsDefaults(t *testing.T) {
|
||||
cfg, err := Load("")
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if cfg.Server.Listen != "127.0.0.1:8080" {
|
||||
t.Errorf("listen = %q", cfg.Server.Listen)
|
||||
}
|
||||
if cfg.Database.Path != "sonda.db" {
|
||||
t.Errorf("db path = %q", cfg.Database.Path)
|
||||
}
|
||||
if cfg.Database.Driver != "sqlite" {
|
||||
t.Errorf("db driver = %q", cfg.Database.Driver)
|
||||
}
|
||||
if cfg.Log.Env != "production" {
|
||||
t.Errorf("env = %q", cfg.Log.Env)
|
||||
}
|
||||
if cfg.Auth.TokenTTL() != 168*time.Hour {
|
||||
t.Errorf("token ttl = %v", cfg.Auth.TokenTTL())
|
||||
}
|
||||
}
|
||||
|
||||
func TestLoadFileOverridesDefaults(t *testing.T) {
|
||||
dir := t.TempDir()
|
||||
p := writeFile(t, dir, `
|
||||
[server]
|
||||
listen = "0.0.0.0:9000"
|
||||
|
||||
[library]
|
||||
roots = ["/a", "/b"]
|
||||
|
||||
[providers.lastfm]
|
||||
api_key = "k"
|
||||
`)
|
||||
cfg, err := Load(p)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if cfg.Server.Listen != "0.0.0.0:9000" {
|
||||
t.Errorf("listen = %q", cfg.Server.Listen)
|
||||
}
|
||||
if len(cfg.Library.Roots) != 2 {
|
||||
t.Errorf("roots = %v", cfg.Library.Roots)
|
||||
}
|
||||
if cfg.Providers.LastFM.APIKey != "k" {
|
||||
t.Errorf("api key = %q", cfg.Providers.LastFM.APIKey)
|
||||
}
|
||||
// untouched keys keep their defaults
|
||||
if cfg.Database.Path != "sonda.db" {
|
||||
t.Errorf("db path = %q", cfg.Database.Path)
|
||||
}
|
||||
}
|
||||
|
||||
func TestLoadEnvOverridesFile(t *testing.T) {
|
||||
dir := t.TempDir()
|
||||
p := writeFile(t, dir, "[log]\nenv = \"production\"\n")
|
||||
t.Setenv("SONDA_ENV", "dev")
|
||||
t.Setenv("SONDA_LISTEN", "127.0.0.1:1")
|
||||
t.Setenv("SONDA_DB_PATH", "x.db")
|
||||
t.Setenv("SONDA_DB_DRIVER", "postgres")
|
||||
t.Setenv("SONDA_DB_DSN", "postgres://u:p@h/db")
|
||||
t.Setenv("SONDA_LASTFM_API_KEY", "envkey")
|
||||
t.Setenv("SONDA_JWT_SECRET", "envsecret")
|
||||
cfg, err := Load(p)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if cfg.Log.Env != "dev" || cfg.Server.Listen != "127.0.0.1:1" ||
|
||||
cfg.Database.Path != "x.db" || cfg.Providers.LastFM.APIKey != "envkey" ||
|
||||
cfg.Auth.JWTSecret != "envsecret" ||
|
||||
cfg.Database.Driver != "postgres" || cfg.Database.DSN != "postgres://u:p@h/db" {
|
||||
t.Errorf("env not applied: %+v", cfg)
|
||||
}
|
||||
}
|
||||
|
||||
func TestLoadRejectsUnknownField(t *testing.T) {
|
||||
dir := t.TempDir()
|
||||
p := writeFile(t, dir, "[server]\nlisten_addr = \"x\"\n")
|
||||
if _, err := Load(p); err == nil {
|
||||
t.Fatal("expected error for unknown field")
|
||||
}
|
||||
}
|
||||
|
||||
func TestLoadMissingFile(t *testing.T) {
|
||||
if _, err := Load(filepath.Join(t.TempDir(), "nope.toml")); err == nil {
|
||||
t.Fatal("expected error for missing file")
|
||||
}
|
||||
}
|
||||
|
||||
func TestValidate(t *testing.T) {
|
||||
good := t.TempDir()
|
||||
file := filepath.Join(good, "f")
|
||||
if err := os.WriteFile(file, nil, 0o600); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
tests := []struct {
|
||||
name string
|
||||
mutate func(*Config)
|
||||
wantErr string
|
||||
}{
|
||||
{"ok", func(c *Config) {}, ""},
|
||||
{"no roots", func(c *Config) { c.Library.Roots = nil }, "library.roots"},
|
||||
{"root missing", func(c *Config) { c.Library.Roots = []string{filepath.Join(good, "nope")} }, "library.roots"},
|
||||
{"root is file", func(c *Config) { c.Library.Roots = []string{file} }, "not a directory"},
|
||||
{"bad env", func(c *Config) { c.Log.Env = "staging" }, "log.env"},
|
||||
{"empty listen", func(c *Config) { c.Server.Listen = "" }, "server.listen"},
|
||||
{"empty db", func(c *Config) { c.Database.Path = "" }, "database.path"},
|
||||
{"bad driver", func(c *Config) { c.Database.Driver = "mysql" }, "database.driver"},
|
||||
{"postgres without dsn", func(c *Config) { c.Database.Driver = "postgres" }, "database.dsn"},
|
||||
{"postgres ok", func(c *Config) {
|
||||
c.Database.Driver = "postgres"
|
||||
c.Database.Path = ""
|
||||
c.Database.DSN = "postgres://u:p@localhost/db"
|
||||
}, ""},
|
||||
{"no secret", func(c *Config) { c.Auth.JWTSecret = "" }, "auth.jwt_secret"},
|
||||
{"short secret", func(c *Config) { c.Auth.JWTSecret = "short" }, "auth.jwt_secret"},
|
||||
{"bad ttl", func(c *Config) { c.Auth.TokenTTLHours = 0 }, "auth.token_ttl_hours"},
|
||||
}
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
cfg, err := Load("")
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
cfg.Library.Roots = []string{good}
|
||||
cfg.Auth.JWTSecret = strings.Repeat("s", 32)
|
||||
tt.mutate(&cfg)
|
||||
err = cfg.Validate()
|
||||
if tt.wantErr == "" {
|
||||
if err != nil {
|
||||
t.Fatalf("unexpected error: %v", err)
|
||||
}
|
||||
return
|
||||
}
|
||||
if err == nil || !strings.Contains(err.Error(), tt.wantErr) {
|
||||
t.Fatalf("err = %v, want containing %q", err, tt.wantErr)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
81
internal/listening/listening.go
Normal file
81
internal/listening/listening.go
Normal file
|
|
@ -0,0 +1,81 @@
|
|||
// Package listening records explicit listen events (play, complete, skip).
|
||||
//
|
||||
// These events feed the recommendation engine. Merely opening or prefetching
|
||||
// an audio URL must never create one.
|
||||
package listening
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"fmt"
|
||||
"time"
|
||||
)
|
||||
|
||||
// Errors returned by the service.
|
||||
var (
|
||||
ErrInvalidEvent = errors.New("invalid listening event")
|
||||
ErrTrackNotFound = errors.New("track not found")
|
||||
)
|
||||
|
||||
// EventType says what the listener did.
|
||||
type EventType string
|
||||
|
||||
// Supported event types.
|
||||
const (
|
||||
Play EventType = "play"
|
||||
Complete EventType = "complete"
|
||||
Skip EventType = "skip"
|
||||
)
|
||||
|
||||
const maxKeyLen = 128
|
||||
|
||||
// Event is one listen reported by a client.
|
||||
type Event struct {
|
||||
UserID int64
|
||||
TrackID int64
|
||||
Type EventType
|
||||
OccurredAt time.Time // zero means "now"
|
||||
DurationPlayedMs int64
|
||||
IdempotencyKey string // client generated; retries with the same key are no-ops
|
||||
}
|
||||
|
||||
// Store persists events.
|
||||
type Store interface {
|
||||
// Record saves e. It returns created=false when an event with the same
|
||||
// (user, idempotency key) already exists, and ErrTrackNotFound for an
|
||||
// unknown track.
|
||||
Record(ctx context.Context, e Event) (created bool, err error)
|
||||
}
|
||||
|
||||
// Service validates and records events.
|
||||
type Service struct {
|
||||
store Store
|
||||
now func() time.Time
|
||||
}
|
||||
|
||||
// NewService builds a Service.
|
||||
func NewService(store Store) *Service {
|
||||
return &Service{store: store, now: time.Now}
|
||||
}
|
||||
|
||||
// Record validates e and stores it.
|
||||
func (s *Service) Record(ctx context.Context, e Event) (bool, error) {
|
||||
switch e.Type {
|
||||
case Play, Complete, Skip:
|
||||
default:
|
||||
return false, fmt.Errorf("%w: event_type must be play, complete or skip", ErrInvalidEvent)
|
||||
}
|
||||
if e.UserID <= 0 || e.TrackID <= 0 {
|
||||
return false, fmt.Errorf("%w: user and track are required", ErrInvalidEvent)
|
||||
}
|
||||
if e.IdempotencyKey == "" || len(e.IdempotencyKey) > maxKeyLen {
|
||||
return false, fmt.Errorf("%w: idempotency_key must be 1-%d characters", ErrInvalidEvent, maxKeyLen)
|
||||
}
|
||||
if e.DurationPlayedMs < 0 {
|
||||
return false, fmt.Errorf("%w: duration_played_ms cannot be negative", ErrInvalidEvent)
|
||||
}
|
||||
if e.OccurredAt.IsZero() {
|
||||
e.OccurredAt = s.now()
|
||||
}
|
||||
return s.store.Record(ctx, e)
|
||||
}
|
||||
86
internal/listening/listening_test.go
Normal file
86
internal/listening/listening_test.go
Normal file
|
|
@ -0,0 +1,86 @@
|
|||
package listening
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"strings"
|
||||
"testing"
|
||||
"time"
|
||||
)
|
||||
|
||||
type fakeStore struct {
|
||||
got []Event
|
||||
created bool
|
||||
err error
|
||||
}
|
||||
|
||||
func (f *fakeStore) Record(_ context.Context, e Event) (bool, error) {
|
||||
f.got = append(f.got, e)
|
||||
return f.created, f.err
|
||||
}
|
||||
|
||||
func TestRecordValidation(t *testing.T) {
|
||||
valid := Event{UserID: 1, TrackID: 2, Type: Play, IdempotencyKey: "k1"}
|
||||
tests := []struct {
|
||||
name string
|
||||
mutate func(*Event)
|
||||
}{
|
||||
{"bad type", func(e *Event) { e.Type = "like" }},
|
||||
{"empty type", func(e *Event) { e.Type = "" }},
|
||||
{"no key", func(e *Event) { e.IdempotencyKey = "" }},
|
||||
{"long key", func(e *Event) { e.IdempotencyKey = strings.Repeat("k", 129) }},
|
||||
{"no track", func(e *Event) { e.TrackID = 0 }},
|
||||
{"no user", func(e *Event) { e.UserID = 0 }},
|
||||
{"negative duration", func(e *Event) { e.DurationPlayedMs = -1 }},
|
||||
}
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
store := &fakeStore{}
|
||||
e := valid
|
||||
tt.mutate(&e)
|
||||
if _, err := NewService(store).Record(context.Background(), e); !errors.Is(err, ErrInvalidEvent) {
|
||||
t.Fatalf("err = %v, want ErrInvalidEvent", err)
|
||||
}
|
||||
if len(store.got) != 0 {
|
||||
t.Error("invalid event reached the store")
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestRecordDefaultsTimestamp(t *testing.T) {
|
||||
store := &fakeStore{created: true}
|
||||
now := time.Unix(1_700_000_000, 0)
|
||||
s := NewService(store)
|
||||
s.now = func() time.Time { return now }
|
||||
|
||||
created, err := s.Record(context.Background(), Event{UserID: 1, TrackID: 2, Type: Complete, IdempotencyKey: "k"})
|
||||
if err != nil || !created {
|
||||
t.Fatalf("created=%v err=%v", created, err)
|
||||
}
|
||||
if !store.got[0].OccurredAt.Equal(now) {
|
||||
t.Errorf("OccurredAt = %v, want %v", store.got[0].OccurredAt, now)
|
||||
}
|
||||
}
|
||||
|
||||
func TestRecordKeepsClientTimestamp(t *testing.T) {
|
||||
store := &fakeStore{created: true}
|
||||
ts := time.Unix(1_600_000_000, 0)
|
||||
_, err := NewService(store).Record(context.Background(),
|
||||
Event{UserID: 1, TrackID: 2, Type: Skip, IdempotencyKey: "k", OccurredAt: ts})
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if !store.got[0].OccurredAt.Equal(ts) {
|
||||
t.Errorf("OccurredAt = %v, want %v", store.got[0].OccurredAt, ts)
|
||||
}
|
||||
}
|
||||
|
||||
func TestRecordPropagatesStoreError(t *testing.T) {
|
||||
store := &fakeStore{err: ErrTrackNotFound}
|
||||
_, err := NewService(store).Record(context.Background(),
|
||||
Event{UserID: 1, TrackID: 2, Type: Play, IdempotencyKey: "k"})
|
||||
if !errors.Is(err, ErrTrackNotFound) {
|
||||
t.Fatalf("err = %v, want ErrTrackNotFound", err)
|
||||
}
|
||||
}
|
||||
66
internal/storage/listening.go
Normal file
66
internal/storage/listening.go
Normal file
|
|
@ -0,0 +1,66 @@
|
|||
package storage
|
||||
|
||||
import (
|
||||
"context"
|
||||
"fmt"
|
||||
|
||||
"github.com/uptrace/bun"
|
||||
|
||||
"codeberg.org/squidd/sonda/internal/listening"
|
||||
)
|
||||
|
||||
type listeningRow struct {
|
||||
bun.BaseModel `bun:"table:listening_events"`
|
||||
|
||||
ID int64 `bun:"id,pk,autoincrement"`
|
||||
UserID int64 `bun:"user_id,notnull"`
|
||||
TrackID int64 `bun:"track_id,notnull"`
|
||||
EventType string `bun:"event_type,notnull"`
|
||||
OccurredAt int64 `bun:"occurred_at,notnull"`
|
||||
DurationPlayedMs int64 `bun:"duration_played_ms,notnull"`
|
||||
IdempotencyKey string `bun:"idempotency_key,notnull"`
|
||||
}
|
||||
|
||||
type trackRow struct {
|
||||
bun.BaseModel `bun:"table:tracks"`
|
||||
|
||||
ID int64 `bun:"id,pk"`
|
||||
}
|
||||
|
||||
// ListeningRepo stores listen events. It implements listening.Store.
|
||||
type ListeningRepo struct{ db *bun.DB }
|
||||
|
||||
// NewListeningRepo builds a ListeningRepo.
|
||||
func NewListeningRepo(db *bun.DB) *ListeningRepo { return &ListeningRepo{db: db} }
|
||||
|
||||
// Record inserts e. A repeated (user, idempotency key) is ignored and reported
|
||||
// as created=false.
|
||||
func (r *ListeningRepo) Record(ctx context.Context, e listening.Event) (bool, error) {
|
||||
exists, err := r.db.NewSelect().Model((*trackRow)(nil)).Where("id = ?", e.TrackID).Exists(ctx)
|
||||
if err != nil {
|
||||
return false, fmt.Errorf("check track: %w", err)
|
||||
}
|
||||
if !exists {
|
||||
return false, listening.ErrTrackNotFound
|
||||
}
|
||||
|
||||
row := &listeningRow{
|
||||
UserID: e.UserID,
|
||||
TrackID: e.TrackID,
|
||||
EventType: string(e.Type),
|
||||
OccurredAt: e.OccurredAt.Unix(),
|
||||
DurationPlayedMs: e.DurationPlayedMs,
|
||||
IdempotencyKey: e.IdempotencyKey,
|
||||
}
|
||||
res, err := r.db.NewInsert().Model(row).
|
||||
On("CONFLICT (user_id, idempotency_key) DO NOTHING").
|
||||
Exec(ctx)
|
||||
if err != nil {
|
||||
return false, fmt.Errorf("insert listening event: %w", err)
|
||||
}
|
||||
n, err := res.RowsAffected()
|
||||
if err != nil {
|
||||
return false, fmt.Errorf("rows affected: %w", err)
|
||||
}
|
||||
return n > 0, nil
|
||||
}
|
||||
Some files were not shown because too many files have changed in this diff Show more
Loading…
Reference in a new issue