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 programs to ProgramStore (folds #36 loaders)

Cawlumma9b7e59a9576
diff --git a/backend/controllers/concurrency_test.go b/backend/controllers/concurrency_test.go
index a03b987..f5223e0 100644
--- a/backend/controllers/concurrency_test.go
+++ b/backend/controllers/concurrency_test.go
@@ -72,3 +72,56 @@ func TestListWorkoutsConcurrentDoesNotExhaustPool(t *testing.T) {
t.Fatal("concurrent ListWorkouts deadlocked the connection pool (#30 regression)")
}
}
+
+// TestListProgramsConcurrentDoesNotExhaustPool is the program-side twin of the
+// workout test above (ProgramStore.loadExercises uses the same close-then-load fix).
+func TestListProgramsConcurrentDoesNotExhaustPool(t *testing.T) {
+ setupTestDB(t)
+ uid := createTestUser(t)
+ exID := createTestExercise(t)
+
+ res, err := db.DB.Exec(`INSERT INTO programs (user_id, name) VALUES (?, 'PPL')`, uid)
+ if err != nil {
+ t.Fatalf("insert program: %v", err)
+ }
+ pid, _ := res.LastInsertId()
+ peRes, err := db.DB.Exec(
+ `INSERT INTO program_exercises (program_id, exercise_id, order_index) VALUES (?, ?, 0)`, pid, exID,
+ )
+ if err != nil {
+ t.Fatalf("insert program_exercise: %v", err)
+ }
+ peid, _ := peRes.LastInsertId()
+ if _, err := db.DB.Exec(
+ `INSERT INTO program_sets (program_exercise_id, set_number, target_reps, target_weight) VALUES (?, 1, 5, 135)`, peid,
+ ); err != nil {
+ t.Fatalf("insert program_set: %v", err)
+ }
+
+ db.DB.SetMaxOpenConns(2)
+ const concurrency = 6
+
+ done := make(chan struct{})
+ go func() {
+ var wg sync.WaitGroup
+ for i := 0; i < concurrency; i++ {
+ wg.Add(1)
+ go func() {
+ defer wg.Done()
+ c, w := newContext(uid, "GET", "/programs", nil)
+ th.ListPrograms(c)
+ if w.Code != 200 {
+ t.Errorf("ListPrograms returned %d", w.Code)
+ }
+ }()
+ }
+ wg.Wait()
+ close(done)
+ }()
+
+ select {
+ case <-done:
+ case <-time.After(10 * time.Second):
+ t.Fatal("concurrent ListPrograms deadlocked the connection pool (#30 regression)")
+ }
+}
diff --git a/backend/controllers/programs.go b/backend/controllers/programs.go
index 8d2069f..3595d80 100644
--- a/backend/controllers/programs.go
+++ b/backend/controllers/programs.go
@@ -3,54 +3,27 @@ package controllers
import (
"database/sql"
"strconv"
- "strings"
- "github.com/Cawlumm/lyftr-backend/db"
"github.com/Cawlumm/lyftr-backend/middleware"
"github.com/Cawlumm/lyftr-backend/models"
+ "github.com/Cawlumm/lyftr-backend/stores"
"github.com/Cawlumm/lyftr-backend/utils"
"github.com/gin-gonic/gin"
)
func (h *Handler) ListPrograms(c *gin.Context) {
uid := middleware.UserID(c)
-
- limit := 20
- offset := 0
+ f := stores.ProgramFilter{Limit: 20, Query: c.Query("q")}
if l, err := strconv.Atoi(c.Query("limit")); err == nil && l > 0 && l <= 100 {
- limit = l
+ f.Limit = l
}
if o, err := strconv.Atoi(c.Query("offset")); err == nil && o >= 0 {
- offset = o
- }
- q := c.Query("q")
-
- var rows *sql.Rows
- var err error
- if q != "" {
- rows, err = db.DB.Query(
- `SELECT id, user_id, name, notes, created_at FROM programs WHERE user_id = ? AND LOWER(name) LIKE ? ORDER BY created_at DESC LIMIT ? OFFSET ?`,
- uid, "%"+strings.ToLower(q)+"%", limit, offset,
- )
- } else {
- rows, err = db.DB.Query(
- `SELECT id, user_id, name, notes, created_at FROM programs WHERE user_id = ? ORDER BY created_at DESC LIMIT ? OFFSET ?`,
- uid, limit, offset,
- )
+ f.Offset = o
}
- if err != nil {
- utils.InternalError(c)
+ programs, err := h.s.Program.List(uid, f)
+ if utils.DBError(c, err) {
return
}
- defer rows.Close()
-
- programs := []models.Program{}
- for rows.Next() {
- var p models.Program
- rows.Scan(&p.ID, &p.UserID, &p.Name, &p.Notes, &p.CreatedAt)
- p.Exercises = loadProgramExercises(p.ID)
- programs = append(programs, p)
- }
utils.OK(c, programs)
}
@@ -61,21 +34,14 @@ func (h *Handler) GetProgram(c *gin.Context) {
utils.BadRequest(c, "invalid program id")
return
}
-
- var p models.Program
- err = db.DB.QueryRow(
- `SELECT id, user_id, name, notes, created_at FROM programs WHERE id = ? AND user_id = ?`, pid, uid,
- ).Scan(&p.ID, &p.UserID, &p.Name, &p.Notes, &p.CreatedAt)
+ p, err := h.s.Program.Get(uid, pid)
if err == sql.ErrNoRows {
utils.NotFound(c, "program not found")
return
}
- if err != nil {
- utils.InternalError(c)
+ if utils.DBError(c, err) {
return
}
-
- p.Exercises = loadProgramExercises(pid)
utils.OK(c, p)
}
@@ -90,68 +56,10 @@ func (h *Handler) CreateProgram(c *gin.Context) {
utils.ValidationError(c, err)
return
}
-
- tx, err := db.DB.Begin()
- if err != nil {
- utils.InternalError(c)
- return
- }
- defer tx.Rollback()
-
- res, err := tx.Exec(
- `INSERT INTO programs (user_id, name, notes) VALUES (?, ?, ?)`,
- uid, req.Name, req.Notes,
- )
- if err != nil {
- utils.InternalError(c)
- return
- }
- pid, err := res.LastInsertId()
- if err != nil {
- utils.InternalError(c)
- return
- }
-
- for i, ex := range req.Exercises {
- exRes, err := tx.Exec(
- `INSERT INTO program_exercises (program_id, exercise_id, order_index, notes) VALUES (?, ?, ?, ?)`,
- pid, ex.ExerciseID, i, ex.Notes,
- )
- if err != nil {
- utils.InternalError(c)
- return
- }
- peid, err := exRes.LastInsertId()
- if err != nil {
- utils.InternalError(c)
- return
- }
- for j, s := range ex.Sets {
- sn := s.SetNumber
- if sn == 0 {
- sn = j + 1
- }
- _, err := tx.Exec(
- `INSERT INTO program_sets (program_exercise_id, set_number, target_reps, target_weight) VALUES (?, ?, ?, ?)`,
- peid, sn, s.TargetReps, s.TargetWeight,
- )
- if err != nil {
- utils.InternalError(c)
- return
- }
- }
- }
-
- if err := tx.Commit(); err != nil {
- utils.InternalError(c)
+ p, err := h.s.Program.Create(uid, req)
+ if utils.DBError(c, err) {
return
}
-
- var p models.Program
- db.DB.QueryRow(
- `SELECT id, user_id, name, notes, created_at FROM programs WHERE id = ?`, pid,
- ).Scan(&p.ID, &p.UserID, &p.Name, &p.Notes, &p.CreatedAt)
- p.Exercises = loadProgramExercises(pid)
utils.Created(c, p)
}
@@ -162,7 +70,6 @@ func (h *Handler) UpdateProgram(c *gin.Context) {
utils.BadRequest(c, "invalid program id")
return
}
-
var req models.CreateProgramRequest
if err := c.ShouldBindJSON(&req); err != nil {
utils.BadRequest(c, err.Error())
@@ -172,79 +79,14 @@ func (h *Handler) UpdateProgram(c *gin.Context) {
utils.ValidationError(c, err)
return
}
-
- var existing models.Program
- err = db.DB.QueryRow(
- `SELECT id FROM programs WHERE id = ? AND user_id = ?`, pid, uid,
- ).Scan(&existing.ID)
+ p, err := h.s.Program.Update(uid, pid, req)
if err == sql.ErrNoRows {
utils.NotFound(c, "program not found")
return
}
- if err != nil {
- utils.InternalError(c)
+ if utils.DBError(c, err) {
return
}
-
- tx, err := db.DB.Begin()
- if err != nil {
- utils.InternalError(c)
- return
- }
- defer tx.Rollback()
-
- _, err = tx.Exec(`UPDATE programs SET name = ?, notes = ? WHERE id = ?`, req.Name, req.Notes, pid)
- if err != nil {
- utils.InternalError(c)
- return
- }
-
- _, err = tx.Exec(`DELETE FROM program_exercises WHERE program_id = ?`, pid)
- if err != nil {
- utils.InternalError(c)
- return
- }
-
- for i, ex := range req.Exercises {
- exRes, err := tx.Exec(
- `INSERT INTO program_exercises (program_id, exercise_id, order_index, notes) VALUES (?, ?, ?, ?)`,
- pid, ex.ExerciseID, i, ex.Notes,
- )
- if err != nil {
- utils.InternalError(c)
- return
- }
- peid, err := exRes.LastInsertId()
- if err != nil {
- utils.InternalError(c)
- return
- }
- for j, s := range ex.Sets {
- sn := s.SetNumber
- if sn == 0 {
- sn = j + 1
- }
- _, err := tx.Exec(
- `INSERT INTO program_sets (program_exercise_id, set_number, target_reps, target_weight) VALUES (?, ?, ?, ?)`,
- peid, sn, s.TargetReps, s.TargetWeight,
- )
- if err != nil {
- utils.InternalError(c)
- return
- }
- }
- }
-
- if err := tx.Commit(); err != nil {
- utils.InternalError(c)
- return
- }
-
- var p models.Program
- db.DB.QueryRow(
- `SELECT id, user_id, name, notes, created_at FROM programs WHERE id = ?`, pid,
- ).Scan(&p.ID, &p.UserID, &p.Name, &p.Notes, &p.CreatedAt)
- p.Exercises = loadProgramExercises(pid)
utils.OK(c, p)
}
@@ -255,65 +97,13 @@ func (h *Handler) DeleteProgram(c *gin.Context) {
utils.BadRequest(c, "invalid program id")
return
}
-
- res, err := db.DB.Exec(`DELETE FROM programs WHERE id = ? AND user_id = ?`, pid, uid)
- if err != nil {
- utils.InternalError(c)
+ n, err := h.s.Program.Delete(uid, pid)
+ if utils.DBError(c, err) {
return
}
- n, _ := res.RowsAffected()
if n == 0 {
utils.NotFound(c, "program not found")
return
}
utils.OK(c, gin.H{"deleted": true})
}
-
-func loadProgramExercises(programID int64) []models.ProgramExercise {
- rows, err := db.DB.Query(
- `SELECT pe.id, pe.program_id, pe.exercise_id, pe.order_index, pe.notes,
- e.name, e.muscle_group, e.category, e.equipment, e.image_url
- FROM program_exercises pe
- JOIN exercises e ON e.id = pe.exercise_id
- WHERE pe.program_id = ? ORDER BY pe.order_index`,
- programID,
- )
- if err != nil {
- return nil
- }
- defer rows.Close()
-
- var exercises []models.ProgramExercise
- for rows.Next() {
- var pe models.ProgramExercise
- rows.Scan(
- &pe.ID, &pe.ProgramID, &pe.ExerciseID, &pe.OrderIndex, &pe.Notes,
- &pe.Exercise.Name, &pe.Exercise.MuscleGroup, &pe.Exercise.Category,
- &pe.Exercise.Equipment, &pe.Exercise.ImageURL,
- )
- pe.Exercise.ID = pe.ExerciseID
- pe.Sets = loadProgramSets(pe.ID)
- exercises = append(exercises, pe)
- }
- return exercises
-}
-
-func loadProgramSets(programExerciseID int64) []models.ProgramSet {
- rows, err := db.DB.Query(
- `SELECT id, program_exercise_id, set_number, target_reps, target_weight
- FROM program_sets WHERE program_exercise_id = ? ORDER BY set_number`,
- programExerciseID,
- )
- if err != nil {
- return nil
- }
- defer rows.Close()
-
- var sets []models.ProgramSet
- for rows.Next() {
- var s models.ProgramSet
- rows.Scan(&s.ID, &s.ProgramExerciseID, &s.SetNumber, &s.TargetReps, &s.TargetWeight)
- sets = append(sets, s)
- }
- return sets
-}
diff --git a/backend/stores/program.go b/backend/stores/program.go
index 05822a1..2ea48b7 100644
--- a/backend/stores/program.go
+++ b/backend/stores/program.go
@@ -1,8 +1,252 @@
package stores
-import "database/sql"
+import (
+ "database/sql"
+ "strings"
-// ProgramStore owns all SQL for the program entity.
+ "github.com/Cawlumm/lyftr-backend/models"
+)
+
+// ProgramStore owns all SQL for programs, program_exercises and program_sets.
type ProgramStore struct{ db *sql.DB }
func NewProgramStore(db *sql.DB) *ProgramStore { return &ProgramStore{db: db} }
+
+// ProgramFilter holds list paging + optional name search.
+type ProgramFilter struct {
+ Limit, Offset int
+ Query string
+}
+
+const programCols = `id, user_id, name, notes, created_at`
+
+func scanProgram(row interface{ Scan(...any) error }, p *models.Program) error {
+ return row.Scan(&p.ID, &p.UserID, &p.Name, &p.Notes, &p.CreatedAt)
+}
+
+func (s *ProgramStore) List(uid int64, f ProgramFilter) ([]models.Program, error) {
+ var rows *sql.Rows
+ var err error
+ if f.Query != "" {
+ rows, err = s.db.Query(
+ `SELECT `+programCols+` FROM programs WHERE user_id = ? AND LOWER(name) LIKE ? ORDER BY created_at DESC LIMIT ? OFFSET ?`,
+ uid, "%"+strings.ToLower(f.Query)+"%", f.Limit, f.Offset,
+ )
+ } else {
+ rows, err = s.db.Query(
+ `SELECT `+programCols+` FROM programs WHERE user_id = ? ORDER BY created_at DESC LIMIT ? OFFSET ?`,
+ uid, f.Limit, f.Offset,
+ )
+ }
+ if err != nil {
+ return nil, err
+ }
+ programs := []models.Program{}
+ for rows.Next() {
+ var p models.Program
+ if err := scanProgram(rows, &p); err != nil {
+ rows.Close()
+ return nil, err
+ }
+ programs = append(programs, p)
+ }
+ if err := rows.Err(); err != nil {
+ rows.Close()
+ return nil, err
+ }
+ rows.Close() // close the parent cursor BEFORE loading children (#36)
+
+ for i := range programs {
+ ex, err := s.loadExercises(programs[i].ID)
+ if err != nil {
+ return nil, err
+ }
+ programs[i].Exercises = ex
+ }
+ return programs, nil
+}
+
+// Get returns a user-owned program with its exercises/sets, or sql.ErrNoRows.
+func (s *ProgramStore) Get(uid, id int64) (models.Program, error) {
+ var p models.Program
+ if err := scanProgram(
+ s.db.QueryRow(`SELECT `+programCols+` FROM programs WHERE id = ? AND user_id = ?`, id, uid), &p,
+ ); err != nil {
+ return models.Program{}, err
+ }
+ ex, err := s.loadExercises(id)
+ if err != nil {
+ return models.Program{}, err
+ }
+ p.Exercises = ex
+ return p, nil
+}
+
+func (s *ProgramStore) get(id int64) (models.Program, error) {
+ var p models.Program
+ if err := scanProgram(s.db.QueryRow(`SELECT `+programCols+` FROM programs WHERE id = ?`, id), &p); err != nil {
+ return models.Program{}, err
+ }
+ ex, err := s.loadExercises(id)
+ if err != nil {
+ return models.Program{}, err
+ }
+ p.Exercises = ex
+ return p, nil
+}
+
+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()
+ 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 {
+ return models.Program{}, err
+ }
+ return s.get(id)
+}
+
+func (s *ProgramStore) Delete(uid, id int64) (int64, error) {
+ res, err := s.db.Exec(`DELETE FROM programs WHERE id = ? AND user_id = ?`, id, uid)
+ if err != nil {
+ return 0, err
+ }
+ n, _ := res.RowsAffected()
+ return n, nil
+}
+
+func insertProgramExercises(tx *sql.Tx, pid int64, exercises []models.CreateProgramExerciseReq) error {
+ for i, ex := range exercises {
+ exRes, err := tx.Exec(
+ `INSERT INTO program_exercises (program_id, exercise_id, order_index, notes) VALUES (?, ?, ?, ?)`,
+ pid, ex.ExerciseID, i, ex.Notes,
+ )
+ if err != nil {
+ return err
+ }
+ peid, err := exRes.LastInsertId()
+ if err != nil {
+ return err
+ }
+ for j, st := range ex.Sets {
+ sn := st.SetNumber
+ if sn == 0 {
+ sn = j + 1
+ }
+ if _, err := tx.Exec(
+ `INSERT INTO program_sets (program_exercise_id, set_number, target_reps, target_weight) VALUES (?, ?, ?, ?)`,
+ peid, sn, st.TargetReps, st.TargetWeight,
+ ); err != nil {
+ return err
+ }
+ }
+ }
+ return nil
+}
+
+// loadExercises scans + closes the parent cursor BEFORE loading each exercise's
+// sets (#36), and surfaces scan errors.
+func (s *ProgramStore) loadExercises(programID int64) ([]models.ProgramExercise, error) {
+ rows, err := s.db.Query(
+ `SELECT pe.id, pe.program_id, pe.exercise_id, pe.order_index, pe.notes,
+ e.name, e.muscle_group, e.category, e.equipment, e.image_url
+ FROM program_exercises pe
+ JOIN exercises e ON e.id = pe.exercise_id
+ WHERE pe.program_id = ? ORDER BY pe.order_index`,
+ programID,
+ )
+ if err != nil {
+ return nil, err
+ }
+ var exercises []models.ProgramExercise
+ for rows.Next() {
+ var pe models.ProgramExercise
+ if err := rows.Scan(
+ &pe.ID, &pe.ProgramID, &pe.ExerciseID, &pe.OrderIndex, &pe.Notes,
+ &pe.Exercise.Name, &pe.Exercise.MuscleGroup, &pe.Exercise.Category,
+ &pe.Exercise.Equipment, &pe.Exercise.ImageURL,
+ ); err != nil {
+ rows.Close()
+ return nil, err
+ }
+ pe.Exercise.ID = pe.ExerciseID
+ exercises = append(exercises, pe)
+ }
+ if err := rows.Err(); err != nil {
+ rows.Close()
+ return nil, err
+ }
+ rows.Close()
+
+ for i := range exercises {
+ sets, err := s.loadSets(exercises[i].ID)
+ if err != nil {
+ return nil, err
+ }
+ exercises[i].Sets = sets
+ }
+ return exercises, nil
+}
+
+func (s *ProgramStore) loadSets(programExerciseID int64) ([]models.ProgramSet, error) {
+ rows, err := s.db.Query(
+ `SELECT id, program_exercise_id, set_number, target_reps, target_weight
+ FROM program_sets WHERE program_exercise_id = ? ORDER BY set_number`,
+ programExerciseID,
+ )
+ if err != nil {
+ return nil, err
+ }
+ defer rows.Close()
+ var sets []models.ProgramSet
+ for rows.Next() {
+ var st models.ProgramSet
+ if err := rows.Scan(&st.ID, &st.ProgramExerciseID, &st.SetNumber, &st.TargetReps, &st.TargetWeight); err != nil {
+ return nil, err
+ }
+ sets = append(sets, st)
+ }
+ return sets, rows.Err()
+}