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): centralize transactions via inTx helper; close Update gap

Cawlummfac6cdf3bf50
diff --git a/backend/stores/program.go b/backend/stores/program.go
index 2ea48b7..4f5af79 100644
--- a/backend/stores/program.go
+++ b/backend/stores/program.go
@@ -96,53 +96,42 @@ func (s *ProgramStore) get(id int64) (models.Program, error) {
}
func (s *ProgramStore) Create(uid int64, req models.CreateProgramRequest) (models.Program, error) {
- tx, err := s.db.Begin()
- if err != nil {
- return models.Program{}, err
- }
- defer tx.Rollback()
-
- res, err := tx.Exec(`INSERT INTO programs (user_id, name, notes) VALUES (?, ?, ?)`, uid, req.Name, req.Notes)
- if err != nil {
- return models.Program{}, err
- }
- pid, err := res.LastInsertId()
+ pid, err := inTx(s.db, func(tx *sql.Tx) (int64, error) {
+ res, err := tx.Exec(`INSERT INTO programs (user_id, name, notes) VALUES (?, ?, ?)`, uid, req.Name, req.Notes)
+ if err != nil {
+ return 0, err
+ }
+ pid, err := res.LastInsertId()
+ if err != nil {
+ return 0, err
+ }
+ if err := insertProgramExercises(tx, pid, req.Exercises); err != nil {
+ return 0, err
+ }
+ return pid, nil
+ })
if err != nil {
return models.Program{}, err
}
- if err := insertProgramExercises(tx, pid, req.Exercises); err != nil {
- return models.Program{}, err
- }
- if err := tx.Commit(); err != nil {
- return models.Program{}, err
- }
return s.get(pid)
}
// Update replaces a user-owned program and its children in one tx. sql.ErrNoRows
// if the program isn't theirs (nothing is mutated).
func (s *ProgramStore) Update(uid, id int64, req models.CreateProgramRequest) (models.Program, error) {
- var ownedID int64
- if err := s.db.QueryRow(`SELECT id FROM programs WHERE id = ? AND user_id = ?`, id, uid).Scan(&ownedID); err != nil {
- return models.Program{}, err
- }
-
- tx, err := s.db.Begin()
- if err != nil {
- return models.Program{}, err
- }
- defer tx.Rollback()
-
- if _, err := tx.Exec(`UPDATE programs SET name = ?, notes = ? WHERE id = ?`, req.Name, req.Notes, id); err != nil {
- return models.Program{}, err
- }
- if _, err := tx.Exec(`DELETE FROM program_exercises WHERE program_id = ?`, id); err != nil {
- return models.Program{}, err
- }
- if err := insertProgramExercises(tx, id, req.Exercises); err != nil {
- return models.Program{}, err
- }
- if err := tx.Commit(); err != nil {
+ if err := inTxDo(s.db, func(tx *sql.Tx) error {
+ var ownedID int64
+ if err := tx.QueryRow(`SELECT id FROM programs WHERE id = ? AND user_id = ?`, id, uid).Scan(&ownedID); err != nil {
+ return err
+ }
+ if _, err := tx.Exec(`UPDATE programs SET name = ?, notes = ? WHERE id = ?`, req.Name, req.Notes, id); err != nil {
+ return err
+ }
+ if _, err := tx.Exec(`DELETE FROM program_exercises WHERE program_id = ?`, id); err != nil {
+ return err
+ }
+ return insertProgramExercises(tx, id, req.Exercises)
+ }); err != nil {
return models.Program{}, err
}
return s.get(id)
diff --git a/backend/stores/stores.go b/backend/stores/stores.go
index e77719e..13456ab 100644
--- a/backend/stores/stores.go
+++ b/backend/stores/stores.go
@@ -29,3 +29,32 @@ func New(db *sql.DB) *Stores {
Program: NewProgramStore(db),
}
}
+
+// inTx runs fn inside a transaction, committing on success and rolling back on
+// error. Use it for any store operation that issues two or more statements that
+// must commit as a unit (read-modify-write, or multiple writes). Single-statement
+// operations are already atomic and must NOT use it.
+func inTx[T any](db *sql.DB, fn func(*sql.Tx) (T, error)) (T, error) {
+ var zero T
+ tx, err := db.Begin()
+ if err != nil {
+ return zero, err
+ }
+ defer tx.Rollback() // no-op once Commit succeeds
+ v, err := fn(tx)
+ if err != nil {
+ return zero, err
+ }
+ if err := tx.Commit(); err != nil {
+ return zero, err
+ }
+ return v, nil
+}
+
+// inTxDo is inTx for operations that don't return a value.
+func inTxDo(db *sql.DB, fn func(*sql.Tx) error) error {
+ _, err := inTx(db, func(tx *sql.Tx) (struct{}, error) {
+ return struct{}{}, fn(tx)
+ })
+ return err
+}
diff --git a/backend/stores/user.go b/backend/stores/user.go
index c1659c3..6941117 100644
--- a/backend/stores/user.go
+++ b/backend/stores/user.go
@@ -61,24 +61,17 @@ func (s *UserStore) UpsertSettings(uid int64, req models.UpdateSettingsRequest)
// 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
+ return inTx(s.db, func(tx *sql.Tx) (int64, error) {
+ 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
+ }
+ return uid, nil
+ })
}
// Delete removes the user; child rows go via ON DELETE CASCADE (foreign_keys=on).
diff --git a/backend/stores/weight.go b/backend/stores/weight.go
index 2fe190d..cb3c48a 100644
--- a/backend/stores/weight.go
+++ b/backend/stores/weight.go
@@ -86,41 +86,38 @@ func dayBounds(t time.Time) (time.Time, time.Time) {
// entry if present, else insert. req.LoggedAt must already be normalized to UTC.
func (s *WeightStore) UpsertForDay(uid int64, req models.LogWeightRequest) (models.WeightLog, error) {
dayStart, dayEnd := dayBounds(req.LoggedAt)
- // One transaction so the existence check + insert/update is atomic: otherwise
- // the connection is released between the SELECT and the write, and two same-day
- // logs can both miss the row and both insert (duplicate day).
- tx, err := s.db.Begin()
- if err != nil {
- return models.WeightLog{}, err
- }
- defer tx.Rollback()
-
- var id int64
- err = tx.QueryRow(
- `SELECT id FROM weight_logs WHERE user_id = ? AND logged_at >= ? AND logged_at < ? ORDER BY id DESC LIMIT 1`,
- uid, dayStart, dayEnd,
- ).Scan(&id)
- switch err {
- case nil:
- if _, e := tx.Exec(
- `UPDATE weight_logs SET weight = ?, notes = ?, logged_at = ? WHERE id = ?`,
- req.Weight, req.Notes, req.LoggedAt, id,
- ); e != nil {
- return models.WeightLog{}, e
- }
- case sql.ErrNoRows:
- res, e := tx.Exec(
- `INSERT INTO weight_logs (user_id, weight, notes, logged_at) VALUES (?, ?, ?, ?)`,
- uid, req.Weight, req.Notes, req.LoggedAt,
- )
- if e != nil {
- return models.WeightLog{}, e
+ // Atomic check-then-write: without the transaction the connection is released
+ // between the SELECT and the write, so two same-day logs could both miss the
+ // row and both insert (duplicate day).
+ id, err := inTx(s.db, func(tx *sql.Tx) (int64, error) {
+ var id int64
+ err := tx.QueryRow(
+ `SELECT id FROM weight_logs WHERE user_id = ? AND logged_at >= ? AND logged_at < ? ORDER BY id DESC LIMIT 1`,
+ uid, dayStart, dayEnd,
+ ).Scan(&id)
+ switch err {
+ case nil:
+ if _, e := tx.Exec(
+ `UPDATE weight_logs SET weight = ?, notes = ?, logged_at = ? WHERE id = ?`,
+ req.Weight, req.Notes, req.LoggedAt, id,
+ ); e != nil {
+ return 0, e
+ }
+ case sql.ErrNoRows:
+ res, e := tx.Exec(
+ `INSERT INTO weight_logs (user_id, weight, notes, logged_at) VALUES (?, ?, ?, ?)`,
+ uid, req.Weight, req.Notes, req.LoggedAt,
+ )
+ if e != nil {
+ return 0, e
+ }
+ id, _ = res.LastInsertId()
+ default:
+ return 0, err
}
- id, _ = res.LastInsertId()
- default:
- return models.WeightLog{}, err
- }
- if err := tx.Commit(); err != nil {
+ return id, nil
+ })
+ if err != nil {
return models.WeightLog{}, err
}
return s.get(id)
@@ -129,21 +126,25 @@ func (s *WeightStore) UpsertForDay(uid int64, req models.LogWeightRequest) (mode
// Update edits an entry the user owns (sql.ErrNoRows if not theirs), then drops
// any other same-day entry so the day keeps a single entry. req.LoggedAt UTC.
func (s *WeightStore) Update(uid, id int64, req models.LogWeightRequest) (models.WeightLog, error) {
- res, err := s.db.Exec(
- `UPDATE weight_logs SET weight = ?, notes = ?, logged_at = ? WHERE id = ? AND user_id = ?`,
- req.Weight, req.Notes, req.LoggedAt, id, uid,
- )
- if err != nil {
- return models.WeightLog{}, err
- }
- if n, _ := res.RowsAffected(); n == 0 {
- return models.WeightLog{}, sql.ErrNoRows
- }
- dayStart, dayEnd := dayBounds(req.LoggedAt)
- if _, err := s.db.Exec(
- `DELETE FROM weight_logs WHERE user_id = ? AND id != ? AND logged_at >= ? AND logged_at < ?`,
- uid, id, dayStart, dayEnd,
- ); err != nil {
+ // Atomic: the row update + the same-day dedup delete must commit together.
+ if err := inTxDo(s.db, func(tx *sql.Tx) error {
+ res, err := tx.Exec(
+ `UPDATE weight_logs SET weight = ?, notes = ?, logged_at = ? WHERE id = ? AND user_id = ?`,
+ req.Weight, req.Notes, req.LoggedAt, id, uid,
+ )
+ if err != nil {
+ return err
+ }
+ if n, _ := res.RowsAffected(); n == 0 {
+ return sql.ErrNoRows
+ }
+ dayStart, dayEnd := dayBounds(req.LoggedAt)
+ _, err = tx.Exec(
+ `DELETE FROM weight_logs WHERE user_id = ? AND id != ? AND logged_at >= ? AND logged_at < ?`,
+ uid, id, dayStart, dayEnd,
+ )
+ return err
+ }); err != nil {
return models.WeightLog{}, err
}
return s.get(id)
diff --git a/backend/stores/workout.go b/backend/stores/workout.go
index 1adb71a..9769936 100644
--- a/backend/stores/workout.go
+++ b/backend/stores/workout.go
@@ -98,60 +98,50 @@ func (s *WorkoutStore) get(id int64) (models.Workout, error) {
}
func (s *WorkoutStore) Create(uid int64, req models.CreateWorkoutRequest) (models.Workout, error) {
- tx, err := s.db.Begin()
- if err != nil {
- return models.Workout{}, err
- }
- defer tx.Rollback()
-
- res, err := tx.Exec(
- `INSERT INTO workouts (user_id, name, notes, duration, started_at) VALUES (?, ?, ?, ?, ?)`,
- uid, req.Name, req.Notes, req.Duration, req.StartedAt,
- )
- if err != nil {
- return models.Workout{}, err
- }
- wid, err := res.LastInsertId()
+ wid, err := inTx(s.db, func(tx *sql.Tx) (int64, error) {
+ res, err := tx.Exec(
+ `INSERT INTO workouts (user_id, name, notes, duration, started_at) VALUES (?, ?, ?, ?, ?)`,
+ uid, req.Name, req.Notes, req.Duration, req.StartedAt,
+ )
+ if err != nil {
+ return 0, err
+ }
+ wid, err := res.LastInsertId()
+ if err != nil {
+ return 0, err
+ }
+ if err := insertWorkoutExercises(tx, wid, req.Exercises); err != nil {
+ return 0, err
+ }
+ return wid, nil
+ })
if err != nil {
return models.Workout{}, err
}
- if err := insertWorkoutExercises(tx, wid, req.Exercises); err != nil {
- return models.Workout{}, err
- }
- if err := tx.Commit(); err != nil {
- return models.Workout{}, err
- }
return s.get(wid)
}
// Update replaces a user-owned workout and its children in one tx. sql.ErrNoRows
// if the workout isn't theirs (nothing is mutated).
func (s *WorkoutStore) Update(uid, id int64, req models.CreateWorkoutRequest) (models.Workout, error) {
- var ownedID int64
- if err := s.db.QueryRow(`SELECT id FROM workouts WHERE id = ? AND user_id = ?`, id, uid).Scan(&ownedID); err != nil {
- return models.Workout{}, err // ErrNoRows = not theirs
- }
-
- tx, err := s.db.Begin()
- if err != nil {
- return models.Workout{}, err
- }
- defer tx.Rollback()
-
- if _, err := tx.Exec(
- `UPDATE workouts SET name = ?, notes = ?, duration = ?, started_at = ? WHERE id = ?`,
- req.Name, req.Notes, req.Duration, req.StartedAt, id,
- ); err != nil {
- return models.Workout{}, err
- }
- // Children replaced wholesale; sets cascade-delete with their workout_exercise.
- if _, err := tx.Exec(`DELETE FROM workout_exercises WHERE workout_id = ?`, id); err != nil {
- return models.Workout{}, err
- }
- if err := insertWorkoutExercises(tx, id, req.Exercises); err != nil {
- return models.Workout{}, err
- }
- if err := tx.Commit(); err != nil {
+ // Ownership check + replace-children, all in one transaction (no TOCTOU).
+ if err := inTxDo(s.db, func(tx *sql.Tx) error {
+ var ownedID int64
+ if err := tx.QueryRow(`SELECT id FROM workouts WHERE id = ? AND user_id = ?`, id, uid).Scan(&ownedID); err != nil {
+ return err // ErrNoRows = not theirs
+ }
+ if _, err := tx.Exec(
+ `UPDATE workouts SET name = ?, notes = ?, duration = ?, started_at = ? WHERE id = ?`,
+ req.Name, req.Notes, req.Duration, req.StartedAt, id,
+ ); err != nil {
+ return err
+ }
+ // Children replaced wholesale; sets cascade-delete with their workout_exercise.
+ if _, err := tx.Exec(`DELETE FROM workout_exercises WHERE workout_id = ?`, id); err != nil {
+ return err
+ }
+ return insertWorkoutExercises(tx, id, req.Exercises)
+ }); err != nil {
return models.Workout{}, err
}
return s.get(id)