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.

fix(#37): settings PUT is a true partial update (stop zeroing omitted targets)

Cawlummcfecaf4bda6e
diff --git a/backend/controllers/settings_test.go b/backend/controllers/settings_test.go
new file mode 100644
index 0000000..0f74767
--- /dev/null
+++ b/backend/controllers/settings_test.go
@@ -0,0 +1,121 @@
+package controllers
+
+import (
+ "net/http"
+ "net/http/httptest"
+ "testing"
+)
+
+// settingsData pulls the UserSettings object out of a {"data": ...} envelope.
+func settingsData(t *testing.T, w *httptest.ResponseRecorder) map[string]any {
+ t.Helper()
+ resp := decodeResponse(t, w)
+ d, ok := resp["data"].(map[string]any)
+ if !ok {
+ t.Fatalf("data is not an object: %v", resp["data"])
+ }
+ return d
+}
+
+func assertNum(t *testing.T, d map[string]any, key string, want float64) {
+ t.Helper()
+ got, ok := d[key].(float64)
+ if !ok {
+ t.Fatalf("%s is not a number: %v", key, d[key])
+ }
+ if got != want {
+ t.Fatalf("%s = %v, want %v", key, got, want)
+ }
+}
+
+func TestGetSettings_defaultsWhenNoRow(t *testing.T) {
+ setupTestDB(t)
+ uid := createTestUser(t)
+
+ c, w := newContext(uid, http.MethodGet, "/api/v1/settings", nil)
+ th.GetSettings(c)
+
+ if w.Code != http.StatusOK {
+ t.Fatalf("expected 200, got %d", w.Code)
+ }
+ d := settingsData(t, w)
+ assertNum(t, d, "calorie_target", 2000)
+ assertNum(t, d, "protein_target", 150)
+ assertNum(t, d, "carb_target", 250)
+ assertNum(t, d, "fat_target", 65)
+ if d["weight_unit"] != "lbs" {
+ t.Fatalf("weight_unit = %v, want lbs", d["weight_unit"])
+ }
+}
+
+// The #37 regression: a weight-unit-only PATCH on a user with no settings row
+// must land the targets on their defaults, not zero them.
+func TestUpdateSettings_partialUpdateSeedsDefaultsNotZeros(t *testing.T) {
+ setupTestDB(t)
+ uid := createTestUser(t)
+
+ c, w := newContext(uid, http.MethodPut, "/api/v1/settings", map[string]any{"weight_unit": "kg"})
+ th.UpdateSettings(c)
+
+ if w.Code != http.StatusOK {
+ t.Fatalf("expected 200, got %d: %s", w.Code, w.Body.String())
+ }
+ d := settingsData(t, w)
+ if d["weight_unit"] != "kg" {
+ t.Fatalf("weight_unit = %v, want kg", d["weight_unit"])
+ }
+ assertNum(t, d, "calorie_target", 2000)
+ assertNum(t, d, "protein_target", 150)
+ assertNum(t, d, "carb_target", 250)
+ assertNum(t, d, "fat_target", 65)
+}
+
+// A partial update over an EXISTING custom row leaves the omitted fields intact.
+func TestUpdateSettings_partialUpdatePreservesCustomTargets(t *testing.T) {
+ setupTestDB(t)
+ uid := createTestUser(t)
+
+ // Set custom targets.
+ c, w := newContext(uid, http.MethodPut, "/api/v1/settings", map[string]any{
+ "calorie_target": 1800, "protein_target": 200, "carb_target": 100, "fat_target": 50,
+ })
+ th.UpdateSettings(c)
+ if w.Code != http.StatusOK {
+ t.Fatalf("setup expected 200, got %d: %s", w.Code, w.Body.String())
+ }
+
+ // Change only the weight unit — the custom targets must survive.
+ c, w = newContext(uid, http.MethodPut, "/api/v1/settings", map[string]any{"weight_unit": "kg"})
+ th.UpdateSettings(c)
+ if w.Code != http.StatusOK {
+ t.Fatalf("expected 200, got %d: %s", w.Code, w.Body.String())
+ }
+ d := settingsData(t, w)
+ if d["weight_unit"] != "kg" {
+ t.Fatalf("weight_unit = %v, want kg", d["weight_unit"])
+ }
+ assertNum(t, d, "calorie_target", 1800)
+ assertNum(t, d, "protein_target", 200)
+ assertNum(t, d, "carb_target", 100)
+ assertNum(t, d, "fat_target", 50)
+}
+
+// An explicit 0 is a real value (the pointer distinguishes it from "absent"),
+// so it must be stored while other omitted fields keep their values.
+func TestUpdateSettings_explicitZeroRespected(t *testing.T) {
+ setupTestDB(t)
+ uid := createTestUser(t)
+
+ c, w := newContext(uid, http.MethodPut, "/api/v1/settings", map[string]any{"protein_target": 0})
+ th.UpdateSettings(c)
+
+ if w.Code != http.StatusOK {
+ t.Fatalf("expected 200, got %d: %s", w.Code, w.Body.String())
+ }
+ d := settingsData(t, w)
+ assertNum(t, d, "protein_target", 0)
+ // Untouched fields stay on their defaults.
+ assertNum(t, d, "calorie_target", 2000)
+ assertNum(t, d, "carb_target", 250)
+ assertNum(t, d, "fat_target", 65)
+}
diff --git a/backend/controllers/user.go b/backend/controllers/user.go
index 0e82bf5..ea760b8 100644
--- a/backend/controllers/user.go
+++ b/backend/controllers/user.go
@@ -27,10 +27,7 @@ func (h *Handler) GetSettings(c *gin.Context) {
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,
- })
+ utils.OK(c, models.DefaultUserSettings(uid))
return
}
if utils.DBError(c, err) {
diff --git a/backend/models/models.go b/backend/models/models.go
index 5a4e754..93d2a02 100644
--- a/backend/models/models.go
+++ b/backend/models/models.go
@@ -19,6 +19,20 @@ type UserSettings struct {
FatTarget int `json:"fat_target" db:"fat_target"`
}
+// DefaultUserSettings is the single source of truth for a brand-new user's
+// settings — returned when no row exists yet and used as the base a partial
+// update merges onto. Must stay in sync with the user_settings column defaults.
+func DefaultUserSettings(uid int64) UserSettings {
+ return UserSettings{
+ UserID: uid,
+ WeightUnit: "lbs",
+ CalorieTarget: 2000,
+ ProteinTarget: 150,
+ CarbTarget: 250,
+ FatTarget: 65,
+ }
+}
+
type Exercise struct {
ID int64 `json:"id" db:"id"`
Name string `json:"name" db:"name"`
@@ -209,12 +223,15 @@ type SaveFoodRequest struct {
Barcode string `json:"barcode"`
}
+// UpdateSettingsRequest is a PATCH: every field is a pointer so a nil (absent
+// from the JSON) is distinguishable from an intentional 0. Only non-nil fields
+// are applied — a partial update never zeroes the fields it omits (#37).
type UpdateSettingsRequest struct {
- WeightUnit string `json:"weight_unit" validate:"omitempty,oneof=lbs kg"`
- CalorieTarget int `json:"calorie_target" validate:"omitempty,gte=0"`
- ProteinTarget int `json:"protein_target" validate:"omitempty,gte=0"`
- CarbTarget int `json:"carb_target" validate:"omitempty,gte=0"`
- FatTarget int `json:"fat_target" validate:"omitempty,gte=0"`
+ WeightUnit *string `json:"weight_unit" validate:"omitempty,oneof=lbs kg"`
+ CalorieTarget *int `json:"calorie_target" validate:"omitempty,gte=0"`
+ ProteinTarget *int `json:"protein_target" validate:"omitempty,gte=0"`
+ CarbTarget *int `json:"carb_target" validate:"omitempty,gte=0"`
+ FatTarget *int `json:"fat_target" validate:"omitempty,gte=0"`
}
type Program struct {
diff --git a/backend/stores/user.go b/backend/stores/user.go
index 6941117..b7fefd6 100644
--- a/backend/stores/user.go
+++ b/backend/stores/user.go
@@ -38,9 +38,34 @@ func (s *UserStore) GetSettings(uid int64) (models.UserSettings, error) {
return st, err
}
-// UpsertSettings writes the settings and returns the stored row (no controller-
-// to-controller call to render the response).
+// UpsertSettings applies a partial update and returns the stored row. It starts
+// from the current row (or the defaults if none exists), overlays only the fields
+// the client actually sent, then writes the merged row back — so a partial PUT
+// (e.g. weight-unit only) can never zero the targets it omitted (#37).
func (s *UserStore) UpsertSettings(uid int64, req models.UpdateSettingsRequest) (models.UserSettings, error) {
+ cur, err := s.GetSettings(uid)
+ if err == sql.ErrNoRows {
+ cur = models.DefaultUserSettings(uid)
+ } else if err != nil {
+ return models.UserSettings{}, err
+ }
+
+ if req.WeightUnit != nil {
+ cur.WeightUnit = *req.WeightUnit
+ }
+ if req.CalorieTarget != nil {
+ cur.CalorieTarget = *req.CalorieTarget
+ }
+ if req.ProteinTarget != nil {
+ cur.ProteinTarget = *req.ProteinTarget
+ }
+ if req.CarbTarget != nil {
+ cur.CarbTarget = *req.CarbTarget
+ }
+ if req.FatTarget != nil {
+ cur.FatTarget = *req.FatTarget
+ }
+
if _, err := s.db.Exec(
`INSERT INTO user_settings (user_id, weight_unit, calorie_target, protein_target, carb_target, fat_target)
VALUES (?, ?, ?, ?, ?, ?)
@@ -50,7 +75,7 @@ func (s *UserStore) UpsertSettings(uid int64, req models.UpdateSettingsRequest)
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,
+ uid, cur.WeightUnit, cur.CalorieTarget, cur.ProteinTarget, cur.CarbTarget, cur.FatTarget,
); err != nil {
return models.UserSettings{}, err
}