Self-hosted fitness tracker. Log workouts, track nutrition, and monitor progress. Docker deployment, mobile-friendly.
refactor(stores): migrate user/auth to UserStore (folds #32 auth + lock test)
Cawlumm7583c16bee56
diff --git a/backend/controllers/auth.go b/backend/controllers/auth.goindex 399438e..c1f2598 100644--- a/backend/controllers/auth.go+++ b/backend/controllers/auth.go@@ -3,7 +3,6 @@ package controllersimport ("database/sql"- "github.com/Cawlumm/lyftr-backend/db""github.com/Cawlumm/lyftr-backend/models""github.com/Cawlumm/lyftr-backend/utils""github.com/gin-gonic/gin"@@ -29,19 +28,14 @@ func (h *Handler) Register(c *gin.Context) {return}- res, err := db.DB.Exec(- `INSERT INTO users (email, password_hash) VALUES (?, ?)`,- req.Email, hash,- )- if err != nil {- utils.BadRequest(c, "email already registered")+ userID, err := h.s.User.Create(req.Email, hash)+ if utils.IsUniqueViolation(err) {+ utils.Conflict(c, "email already registered")+ return+ }+ if utils.DBError(c, err) {return}-- userID, _ := res.LastInsertId()-- // Create default settings- db.DB.Exec(`INSERT INTO user_settings (user_id) VALUES (?)`, userID)access, refresh, err := utils.GenerateTokenPair(userID, req.Email)if err != nil {@@ -64,18 +58,16 @@ func (h *Handler) Login(c *gin.Context) {return}- var user models.User- err := db.DB.QueryRow(- `SELECT id, email, password_hash, created_at, updated_at FROM users WHERE email = ?`,- req.Email,- ).Scan(&user.ID, &user.Email, &user.Password, &user.CreatedAt, &user.UpdatedAt)-- if err == sql.ErrNoRows || !utils.CheckPassword(req.Password, user.Password) {+ user, err := h.s.User.GetByEmail(req.Email)+ if err == sql.ErrNoRows {utils.Unauthorized(c, "invalid email or password")return}- if err != nil {- utils.InternalError(c)+ if utils.DBError(c, err) {+ return+ }+ if !utils.CheckPassword(req.Password, user.Password) {+ utils.Unauthorized(c, "invalid email or password")return}diff --git a/backend/controllers/sqlite_lock_test.go b/backend/controllers/sqlite_lock_test.gonew file mode 100644index 0000000..1ae8284--- /dev/null+++ b/backend/controllers/sqlite_lock_test.go@@ -0,0 +1,98 @@+package controllers++import (+ "database/sql"+ "net/http"+ "path/filepath"+ "testing"++ "github.com/Cawlumm/lyftr-backend/db"+ "github.com/Cawlumm/lyftr-backend/stores"+ "github.com/Cawlumm/lyftr-backend/utils"+ _ "modernc.org/sqlite"+)++// setupFileDB points db.DB at a fresh on-disk database with busy_timeout(0), so a+// contended write lock surfaces as SQLITE_BUSY immediately instead of waiting. It+// also rebuilds the DI handler (th) bound to this DB.+func setupFileDB(t *testing.T) string {+ t.Helper()+ path := filepath.Join(t.TempDir(), "lock.db")+ var err error+ db.DB, err = sql.Open("sqlite", path+"?_pragma=busy_timeout(0)")+ if err != nil {+ t.Fatalf("open file db: %v", err)+ }+ db.DB.SetMaxOpenConns(1)+ if err = db.DB.Ping(); err != nil {+ t.Fatalf("ping file db: %v", err)+ }+ if err = applySchema(); err != nil {+ t.Fatalf("apply schema: %v", err)+ }+ th = NewHandler(stores.New(db.DB))+ t.Cleanup(func() { db.DB.Close() })+ return path+}++// TestRegister_lockedDBReturns503 reproduces issue #25: when the database is+// locked, Register must return a retryable 503 — not a misleading "email already+// registered" (which is what a blanket "any Exec error == duplicate" produced).+func TestRegister_lockedDBReturns503(t *testing.T) {+ path := setupFileDB(t)++ // Hold a write lock on a separate connection so Register's INSERT can't proceed.+ locker, err := sql.Open("sqlite", path+"?_pragma=busy_timeout(0)")+ if err != nil {+ t.Fatalf("open locker: %v", err)+ }+ defer locker.Close()+ tx, err := locker.Begin()+ if err != nil {+ t.Fatalf("begin lock tx: %v", err)+ }+ if _, err := tx.Exec(`INSERT INTO users (email, password_hash) VALUES ('[email protected]', 'h')`); err != nil {+ t.Fatalf("acquire write lock: %v", err)+ }+ defer tx.Rollback()++ c, w := newContext(0, http.MethodPost, "/api/v1/auth/register",+ map[string]string{"email": "[email protected]", "password": "password123"})+ th.Register(c)++ if w.Code != http.StatusServiceUnavailable {+ t.Fatalf("locked DB: expected 503, got %d (%s)", w.Code, w.Body.String())+ }+}++// TestRegister_duplicateEmailReturns409 confirms a genuine duplicate is still a+// conflict, and is now distinguishable from the lock case above.+func TestRegister_duplicateEmailReturns409(t *testing.T) {+ setupTestDB(t)+ createTestUser(t) // inserts [email protected]++ c, w := newContext(0, http.MethodPost, "/api/v1/auth/register",+ map[string]string{"email": "[email protected]", "password": "password123"})+ th.Register(c)++ if w.Code != http.StatusConflict {+ t.Fatalf("duplicate email: expected 409, got %d (%s)", w.Code, w.Body.String())+ }+}++// TestDBErrorClassifiers checks the shared classifier against real modernc errors.+func TestDBErrorClassifiers(t *testing.T) {+ setupTestDB(t)+ createTestUser(t)++ _, err := db.DB.Exec(`INSERT INTO users (email, password_hash) VALUES ('[email protected]', 'h')`)+ if err == nil {+ t.Fatal("expected a UNIQUE violation")+ }+ if !utils.IsUniqueViolation(err) {+ t.Errorf("IsUniqueViolation(%v) = false, want true", err)+ }+ if utils.IsLocked(err) {+ t.Errorf("IsLocked(%v) = true, want false", err)+ }+}diff --git a/backend/controllers/user.go b/backend/controllers/user.goindex 4a91c6a..b87579b 100644--- a/backend/controllers/user.go+++ b/backend/controllers/user.go@@ -1,7 +1,8 @@package controllersimport (- "github.com/Cawlumm/lyftr-backend/db"+ "database/sql"+"github.com/Cawlumm/lyftr-backend/middleware""github.com/Cawlumm/lyftr-backend/models""github.com/Cawlumm/lyftr-backend/utils"@@ -10,12 +11,8 @@ import (func (h *Handler) GetMe(c *gin.Context) {uid := middleware.UserID(c)- var u models.User- err := db.DB.QueryRow(- `SELECT id, email, created_at, updated_at FROM users WHERE id = ?`, uid,- ).Scan(&u.ID, &u.Email, &u.CreatedAt, &u.UpdatedAt)- if err != nil {- utils.InternalError(c)+ u, err := h.s.User.GetMe(uid)+ if utils.DBError(c, err) {return}utils.OK(c, u)@@ -23,19 +20,18 @@ func (h *Handler) GetMe(c *gin.Context) {func (h *Handler) GetSettings(c *gin.Context) {uid := middleware.UserID(c)- var s models.UserSettings- err := db.DB.QueryRow(- `SELECT user_id, weight_unit, calorie_target, protein_target, carb_target, fat_target- FROM user_settings WHERE user_id = ?`, uid,- ).Scan(&s.UserID, &s.WeightUnit, &s.CalorieTarget, &s.ProteinTarget, &s.CarbTarget, &s.FatTarget)- if err != nil {- // Return defaults if not found+ s, err := h.s.User.GetSettings(uid)+ if err == sql.ErrNoRows {+ // No row yet — return the defaults.utils.OK(c, models.UserSettings{UserID: uid, WeightUnit: "lbs",CalorieTarget: 2000, ProteinTarget: 150, CarbTarget: 250, FatTarget: 65,})return}+ if utils.DBError(c, err) {+ return+ }utils.OK(c, s)}@@ -46,27 +42,16 @@ func (h *Handler) UpdateSettings(c *gin.Context) {utils.BadRequest(c, err.Error())return}-- db.DB.Exec(- `INSERT INTO user_settings (user_id, weight_unit, calorie_target, protein_target, carb_target, fat_target)- VALUES (?, ?, ?, ?, ?, ?)- ON CONFLICT(user_id) DO UPDATE SET- weight_unit = excluded.weight_unit,- calorie_target = excluded.calorie_target,- protein_target = excluded.protein_target,- carb_target = excluded.carb_target,- fat_target = excluded.fat_target`,- uid, req.WeightUnit, req.CalorieTarget, req.ProteinTarget, req.CarbTarget, req.FatTarget,- )-- h.GetSettings(c)+ s, err := h.s.User.UpsertSettings(uid, req)+ if utils.DBError(c, err) {+ return+ }+ utils.OK(c, s)}func (h *Handler) DeleteAccount(c *gin.Context) {uid := middleware.UserID(c)- _, err := db.DB.Exec(`DELETE FROM users WHERE id = ?`, uid)- if err != nil {- utils.InternalError(c)+ if utils.DBError(c, h.s.User.Delete(uid)) {return}utils.OK(c, gin.H{"deleted": true})diff --git a/backend/stores/user.go b/backend/stores/user.goindex 741c94d..c1659c3 100644--- a/backend/stores/user.go+++ b/backend/stores/user.go@@ -1,8 +1,88 @@package stores-import "database/sql"+import (+ "database/sql"-// UserStore owns all SQL for the user entity.+ "github.com/Cawlumm/lyftr-backend/models"+)++// UserStore owns all SQL for users and user_settings.type UserStore struct{ db *sql.DB }func NewUserStore(db *sql.DB) *UserStore { return &UserStore{db: db} }++func (s *UserStore) GetMe(uid int64) (models.User, error) {+ var u models.User+ err := s.db.QueryRow(`SELECT id, email, created_at, updated_at FROM users WHERE id = ?`, uid).+ Scan(&u.ID, &u.Email, &u.CreatedAt, &u.UpdatedAt)+ return u, err+}++// GetByEmail loads a user incl. password_hash for login. sql.ErrNoRows if absent.+func (s *UserStore) GetByEmail(email string) (models.User, error) {+ var u models.User+ err := s.db.QueryRow(+ `SELECT id, email, password_hash, created_at, updated_at FROM users WHERE email = ?`, email,+ ).Scan(&u.ID, &u.Email, &u.Password, &u.CreatedAt, &u.UpdatedAt)+ return u, err+}++const userSettingsSelect = `SELECT user_id, weight_unit, calorie_target, protein_target, carb_target, fat_target FROM user_settings`++// GetSettings returns the user's settings row, or sql.ErrNoRows if none (the+// controller owns the default fallback).+func (s *UserStore) GetSettings(uid int64) (models.UserSettings, error) {+ var st models.UserSettings+ err := s.db.QueryRow(userSettingsSelect+` WHERE user_id = ?`, uid).+ Scan(&st.UserID, &st.WeightUnit, &st.CalorieTarget, &st.ProteinTarget, &st.CarbTarget, &st.FatTarget)+ return st, err+}++// UpsertSettings writes the settings and returns the stored row (no controller-+// to-controller call to render the response).+func (s *UserStore) UpsertSettings(uid int64, req models.UpdateSettingsRequest) (models.UserSettings, error) {+ if _, err := s.db.Exec(+ `INSERT INTO user_settings (user_id, weight_unit, calorie_target, protein_target, carb_target, fat_target)+ VALUES (?, ?, ?, ?, ?, ?)+ ON CONFLICT(user_id) DO UPDATE SET+ weight_unit = excluded.weight_unit,+ calorie_target = excluded.calorie_target,+ protein_target = excluded.protein_target,+ carb_target = excluded.carb_target,+ fat_target = excluded.fat_target`,+ uid, req.WeightUnit, req.CalorieTarget, req.ProteinTarget, req.CarbTarget, req.FatTarget,+ ); err != nil {+ return models.UserSettings{}, err+ }+ return s.GetSettings(uid)+}++// Create inserts a user and their default settings atomically (one transaction —+// fixes the previous non-transactional gap). A duplicate email surfaces as a+// UNIQUE violation for the controller to map to 409.+func (s *UserStore) Create(email, hash string) (int64, error) {+ tx, err := s.db.Begin()+ if err != nil {+ return 0, err+ }+ defer tx.Rollback()++ res, err := tx.Exec(`INSERT INTO users (email, password_hash) VALUES (?, ?)`, email, hash)+ if err != nil {+ return 0, err+ }+ uid, _ := res.LastInsertId()+ if _, err := tx.Exec(`INSERT INTO user_settings (user_id) VALUES (?)`, uid); err != nil {+ return 0, err+ }+ if err := tx.Commit(); err != nil {+ return 0, err+ }+ return uid, nil+}++// Delete removes the user; child rows go via ON DELETE CASCADE (foreign_keys=on).+func (s *UserStore) Delete(uid int64) error {+ _, err := s.db.Exec(`DELETE FROM users WHERE id = ?`, uid)+ return err+}