Skip to content

armgit / lyftr

Public Imported from GitHub
0

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.go
index 399438e..c1f2598 100644
--- a/backend/controllers/auth.go
+++ b/backend/controllers/auth.go
@@ -3,7 +3,6 @@ package controllers
import (
"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.go
new file mode 100644
index 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.go
index 4a91c6a..b87579b 100644
--- a/backend/controllers/user.go
+++ b/backend/controllers/user.go
@@ -1,7 +1,8 @@
package controllers
import (
- "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.go
index 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
+}