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.

feat: scaffold Go backend API with SQLite and exercise seeding

Cawlumm13632a7c250f
diff --git a/backend/.env.example b/backend/.env.example
new file mode 100644
index 0000000..5e2133a
--- /dev/null
+++ b/backend/.env.example
@@ -0,0 +1,26 @@
+# Server
+PORT=3000
+ENV=development
+
+# Database (SQLite default — no changes needed for local dev)
+DB_TYPE=sqlite
+DB_PATH=./data/lyftr.db
+
+# PostgreSQL (only used if DB_TYPE=postgres)
+# DB_HOST=localhost
+# DB_PORT=5432
+# DB_NAME=lyftr
+# DB_USER=postgres
+# DB_PASSWORD=
+
+# Auth
+JWT_SECRET=change-me-in-production-min-32-chars!!
+JWT_EXPIRY=3600
+
+# CORS — set to your frontend origin
+CORS_ORIGIN=http://localhost:5173
+
+# ExerciseDB (RapidAPI)
+# Sign up free at https://rapidapi.com/justin-WFnsXH_t6/api/exercisedb
+# Paste your key below — exercises are fetched once and stored locally.
+# EXERCISEDB_KEY=your_rapidapi_key_here
diff --git a/backend/config/config.go b/backend/config/config.go
new file mode 100644
index 0000000..bc05026
--- /dev/null
+++ b/backend/config/config.go
@@ -0,0 +1,55 @@
+package config
+
+import (
+ "log"
+ "os"
+
+ "github.com/joho/godotenv"
+)
+
+type Config struct {
+ Port string
+ DBType string // "sqlite" or "postgres"
+ DBPath string // sqlite only
+ DBHost string // postgres only
+ DBPort string
+ DBName string
+ DBUser string
+ DBPassword string
+ JWTSecret string
+ JWTExpiry string
+ CORSOrigin string
+ Env string
+}
+
+var C *Config
+
+func Load() {
+ _ = godotenv.Load()
+
+ C = &Config{
+ Port: getEnv("PORT", "3000"),
+ DBType: getEnv("DB_TYPE", "sqlite"),
+ DBPath: getEnv("DB_PATH", "./data/lyftr.db"),
+ DBHost: getEnv("DB_HOST", "localhost"),
+ DBPort: getEnv("DB_PORT", "5432"),
+ DBName: getEnv("DB_NAME", "lyftr"),
+ DBUser: getEnv("DB_USER", "postgres"),
+ DBPassword: getEnv("DB_PASSWORD", ""),
+ JWTSecret: getEnv("JWT_SECRET", "change-me-in-production-min-32-chars!!"),
+ JWTExpiry: getEnv("JWT_EXPIRY", "3600"),
+ CORSOrigin: getEnv("CORS_ORIGIN", "http://localhost:5173"),
+ Env: getEnv("ENV", "development"),
+ }
+
+ if C.Env == "production" && C.JWTSecret == "change-me-in-production-min-32-chars!!" {
+ log.Fatal("JWT_SECRET must be set in production")
+ }
+}
+
+func getEnv(key, fallback string) string {
+ if v := os.Getenv(key); v != "" {
+ return v
+ }
+ return fallback
+}
diff --git a/backend/controllers/auth.go b/backend/controllers/auth.go
new file mode 100644
index 0000000..492d3c5
--- /dev/null
+++ b/backend/controllers/auth.go
@@ -0,0 +1,112 @@
+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"
+ "github.com/go-playground/validator/v10"
+)
+
+var validate = validator.New()
+
+func Register(c *gin.Context) {
+ var req models.RegisterRequest
+ if err := c.ShouldBindJSON(&req); err != nil {
+ utils.BadRequest(c, err.Error())
+ return
+ }
+ if err := validate.Struct(req); err != nil {
+ utils.ValidationError(c, err)
+ return
+ }
+
+ hash, err := utils.HashPassword(req.Password)
+ if err != nil {
+ utils.InternalError(c)
+ 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")
+ 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 {
+ utils.InternalError(c)
+ return
+ }
+
+ user := models.User{ID: userID, Email: req.Email}
+ utils.Created(c, models.AuthResponse{Token: access, RefreshToken: refresh, User: user})
+}
+
+func Login(c *gin.Context) {
+ var req models.LoginRequest
+ if err := c.ShouldBindJSON(&req); err != nil {
+ utils.BadRequest(c, err.Error())
+ return
+ }
+ if err := validate.Struct(req); err != nil {
+ utils.ValidationError(c, err)
+ 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) {
+ utils.Unauthorized(c, "invalid email or password")
+ return
+ }
+ if err != nil {
+ utils.InternalError(c)
+ return
+ }
+
+ access, refresh, err := utils.GenerateTokenPair(user.ID, user.Email)
+ if err != nil {
+ utils.InternalError(c)
+ return
+ }
+
+ user.Password = ""
+ utils.OK(c, models.AuthResponse{Token: access, RefreshToken: refresh, User: user})
+}
+
+func RefreshToken(c *gin.Context) {
+ var req models.RefreshRequest
+ if err := c.ShouldBindJSON(&req); err != nil {
+ utils.BadRequest(c, err.Error())
+ return
+ }
+
+ claims, err := utils.ValidateToken(req.RefreshToken)
+ if err != nil || claims.Type != "refresh" {
+ utils.Unauthorized(c, "invalid refresh token")
+ return
+ }
+
+ access, refresh, err := utils.GenerateTokenPair(claims.UserID, claims.Email)
+ if err != nil {
+ utils.InternalError(c)
+ return
+ }
+
+ utils.OK(c, gin.H{"token": access, "refresh_token": refresh})
+}
diff --git a/backend/controllers/exercises.go b/backend/controllers/exercises.go
new file mode 100644
index 0000000..5d8c60b
--- /dev/null
+++ b/backend/controllers/exercises.go
@@ -0,0 +1,96 @@
+package controllers
+
+import (
+ "encoding/json"
+ "strconv"
+
+ "github.com/Cawlumm/lyftr-backend/db"
+ "github.com/Cawlumm/lyftr-backend/models"
+ "github.com/Cawlumm/lyftr-backend/seed"
+ "github.com/Cawlumm/lyftr-backend/utils"
+ "github.com/gin-gonic/gin"
+)
+
+func ListExercises(c *gin.Context) {
+ query := `SELECT id, name, muscle_group, secondary_muscles, category, equipment, description, image_url
+ FROM exercises WHERE 1=1`
+ args := []any{}
+
+ if q := c.Query("q"); q != "" {
+ query += " AND name LIKE ?"
+ args = append(args, "%"+q+"%")
+ }
+ if mg := c.Query("muscle_group"); mg != "" {
+ query += " AND muscle_group = ?"
+ args = append(args, mg)
+ }
+ if cat := c.Query("category"); cat != "" {
+ query += " AND category = ?"
+ args = append(args, cat)
+ }
+ if eq := c.Query("equipment"); eq != "" {
+ query += " AND equipment = ?"
+ args = append(args, eq)
+ }
+
+ query += " ORDER BY name LIMIT 100"
+
+ rows, err := db.DB.Query(query, args...)
+ if err != nil {
+ utils.InternalError(c)
+ return
+ }
+ defer rows.Close()
+
+ exercises := []models.Exercise{}
+ for rows.Next() {
+ e := scanExercise(rows)
+ exercises = append(exercises, e)
+ }
+ utils.OK(c, exercises)
+}
+
+func GetExercise(c *gin.Context) {
+ id, err := strconv.ParseInt(c.Param("id"), 10, 64)
+ if err != nil {
+ utils.BadRequest(c, "invalid exercise id")
+ return
+ }
+
+ row := db.DB.QueryRow(
+ `SELECT id, name, muscle_group, secondary_muscles, category, equipment, description, image_url
+ FROM exercises WHERE id = ?`, id,
+ )
+ e := scanExercise(row)
+ if e.ID == 0 {
+ utils.NotFound(c, "exercise not found")
+ return
+ }
+ utils.OK(c, e)
+}
+
+// SyncExercises is an admin-only endpoint to re-pull from ExerciseDB.
+func SyncExercises(c *gin.Context) {
+ if err := seed.SyncExercises(db.DB); err != nil {
+ utils.BadRequest(c, err.Error())
+ return
+ }
+ var count int
+ db.DB.QueryRow(`SELECT COUNT(*) FROM exercises`).Scan(&count)
+ utils.OK(c, gin.H{"synced": true, "total": count})
+}
+
+type scanner interface {
+ Scan(dest ...any) error
+}
+
+func scanExercise(row scanner) models.Exercise {
+ var e models.Exercise
+ var secondaryRaw string
+ row.Scan(&e.ID, &e.Name, &e.MuscleGroup, &secondaryRaw, &e.Category, &e.Equipment, &e.Description, &e.ImageURL)
+ json.Unmarshal([]byte(secondaryRaw), &e.SecondaryMuscles)
+ if e.SecondaryMuscles == nil {
+ e.SecondaryMuscles = []string{}
+ }
+ return e
+}
diff --git a/backend/controllers/food.go b/backend/controllers/food.go
new file mode 100644
index 0000000..0d4365d
--- /dev/null
+++ b/backend/controllers/food.go
@@ -0,0 +1,131 @@
+package controllers
+
+import (
+ "strconv"
+ "time"
+
+ "github.com/Cawlumm/lyftr-backend/db"
+ "github.com/Cawlumm/lyftr-backend/middleware"
+ "github.com/Cawlumm/lyftr-backend/models"
+ "github.com/Cawlumm/lyftr-backend/utils"
+ "github.com/gin-gonic/gin"
+)
+
+func ListFoodLogs(c *gin.Context) {
+ uid := middleware.UserID(c)
+
+ // default to today
+ date := c.Query("date")
+ if date == "" {
+ date = time.Now().Format("2006-01-02")
+ }
+
+ rows, err := db.DB.Query(
+ `SELECT id, user_id, name, meal, calories, protein, carbs, fat, servings, serving_size, barcode, logged_at, created_at
+ FROM food_logs
+ WHERE user_id = ? AND date(logged_at) = ?
+ ORDER BY logged_at ASC`,
+ uid, date,
+ )
+ if err != nil {
+ utils.InternalError(c)
+ return
+ }
+ defer rows.Close()
+
+ logs := []models.FoodLog{}
+ for rows.Next() {
+ var f models.FoodLog
+ rows.Scan(&f.ID, &f.UserID, &f.Name, &f.Meal, &f.Calories, &f.Protein, &f.Carbs, &f.Fat,
+ &f.Servings, &f.ServingSize, &f.Barcode, &f.LoggedAt, &f.CreatedAt)
+ logs = append(logs, f)
+ }
+ utils.OK(c, logs)
+}
+
+func LogFood(c *gin.Context) {
+ uid := middleware.UserID(c)
+ var req models.LogFoodRequest
+ if err := c.ShouldBindJSON(&req); err != nil {
+ utils.BadRequest(c, err.Error())
+ return
+ }
+ if err := validate.Struct(req); err != nil {
+ utils.ValidationError(c, err)
+ return
+ }
+
+ if req.LoggedAt.IsZero() {
+ req.LoggedAt = time.Now()
+ }
+ if req.Servings == 0 {
+ req.Servings = 1
+ }
+
+ res, err := db.DB.Exec(
+ `INSERT INTO food_logs (user_id, name, meal, calories, protein, carbs, fat, servings, serving_size, barcode, logged_at)
+ VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+ uid, req.Name, req.Meal, req.Calories, req.Protein, req.Carbs, req.Fat,
+ req.Servings, req.ServingSize, req.Barcode, req.LoggedAt,
+ )
+ if err != nil {
+ utils.InternalError(c)
+ return
+ }
+
+ id, _ := res.LastInsertId()
+ var f models.FoodLog
+ db.DB.QueryRow(
+ `SELECT id, user_id, name, meal, calories, protein, carbs, fat, servings, serving_size, barcode, logged_at, created_at
+ FROM food_logs WHERE id = ?`, id,
+ ).Scan(&f.ID, &f.UserID, &f.Name, &f.Meal, &f.Calories, &f.Protein, &f.Carbs, &f.Fat,
+ &f.Servings, &f.ServingSize, &f.Barcode, &f.LoggedAt, &f.CreatedAt)
+
+ utils.Created(c, f)
+}
+
+func DeleteFoodLog(c *gin.Context) {
+ uid := middleware.UserID(c)
+ lid, err := strconv.ParseInt(c.Param("id"), 10, 64)
+ if err != nil {
+ utils.BadRequest(c, "invalid id")
+ return
+ }
+
+ res, err := db.DB.Exec(`DELETE FROM food_logs WHERE id = ? AND user_id = ?`, lid, uid)
+ if err != nil {
+ utils.InternalError(c)
+ return
+ }
+ n, _ := res.RowsAffected()
+ if n == 0 {
+ utils.NotFound(c, "log entry not found")
+ return
+ }
+ utils.OK(c, gin.H{"deleted": true})
+}
+
+func GetDailyStats(c *gin.Context) {
+ uid := middleware.UserID(c)
+ date := c.Query("date")
+ if date == "" {
+ date = time.Now().Format("2006-01-02")
+ }
+
+ var stats models.DailyStats
+ stats.Date = date
+
+ db.DB.QueryRow(
+ `SELECT COALESCE(SUM(calories),0), COALESCE(SUM(protein),0),
+ COALESCE(SUM(carbs),0), COALESCE(SUM(fat),0)
+ FROM food_logs WHERE user_id = ? AND date(logged_at) = ?`,
+ uid, date,
+ ).Scan(&stats.TotalCalories, &stats.TotalProtein, &stats.TotalCarbs, &stats.TotalFat)
+
+ db.DB.QueryRow(
+ `SELECT COUNT(*) FROM workouts WHERE user_id = ? AND date(started_at) = ?`,
+ uid, date,
+ ).Scan(&stats.WorkoutCount)
+
+ utils.OK(c, stats)
+}
diff --git a/backend/controllers/user.go b/backend/controllers/user.go
new file mode 100644
index 0000000..a7be823
--- /dev/null
+++ b/backend/controllers/user.go
@@ -0,0 +1,73 @@
+package controllers
+
+import (
+ "github.com/Cawlumm/lyftr-backend/db"
+ "github.com/Cawlumm/lyftr-backend/middleware"
+ "github.com/Cawlumm/lyftr-backend/models"
+ "github.com/Cawlumm/lyftr-backend/utils"
+ "github.com/gin-gonic/gin"
+)
+
+func 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)
+ return
+ }
+ utils.OK(c, u)
+}
+
+func 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
+ utils.OK(c, models.UserSettings{
+ UserID: uid, WeightUnit: "lbs",
+ CalorieTarget: 2000, ProteinTarget: 150, CarbTarget: 250, FatTarget: 65,
+ })
+ return
+ }
+ utils.OK(c, s)
+}
+
+func UpdateSettings(c *gin.Context) {
+ uid := middleware.UserID(c)
+ var req models.UpdateSettingsRequest
+ if err := c.ShouldBindJSON(&req); err != nil {
+ 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,
+ )
+
+ GetSettings(c)
+}
+
+func DeleteAccount(c *gin.Context) {
+ uid := middleware.UserID(c)
+ _, err := db.DB.Exec(`DELETE FROM users WHERE id = ?`, uid)
+ if err != nil {
+ utils.InternalError(c)
+ return
+ }
+ utils.OK(c, gin.H{"deleted": true})
+}
diff --git a/backend/controllers/weight.go b/backend/controllers/weight.go
new file mode 100644
index 0000000..ff9c90d
--- /dev/null
+++ b/backend/controllers/weight.go
@@ -0,0 +1,115 @@
+package controllers
+
+import (
+ "database/sql"
+ "strconv"
+ "time"
+
+ "github.com/Cawlumm/lyftr-backend/db"
+ "github.com/Cawlumm/lyftr-backend/middleware"
+ "github.com/Cawlumm/lyftr-backend/models"
+ "github.com/Cawlumm/lyftr-backend/utils"
+ "github.com/gin-gonic/gin"
+)
+
+func ListWeightLogs(c *gin.Context) {
+ uid := middleware.UserID(c)
+ limit := 90
+ if l, err := strconv.Atoi(c.Query("limit")); err == nil && l > 0 {
+ limit = l
+ }
+
+ rows, err := db.DB.Query(
+ `SELECT id, user_id, weight, notes, logged_at, created_at
+ FROM weight_logs WHERE user_id = ? ORDER BY logged_at DESC LIMIT ?`,
+ uid, limit,
+ )
+ if err != nil {
+ utils.InternalError(c)
+ return
+ }
+ defer rows.Close()
+
+ logs := []models.WeightLog{}
+ for rows.Next() {
+ var w models.WeightLog
+ rows.Scan(&w.ID, &w.UserID, &w.Weight, &w.Notes, &w.LoggedAt, &w.CreatedAt)
+ logs = append(logs, w)
+ }
+ utils.OK(c, logs)
+}
+
+func LogWeight(c *gin.Context) {
+ uid := middleware.UserID(c)
+ var req models.LogWeightRequest
+ if err := c.ShouldBindJSON(&req); err != nil {
+ utils.BadRequest(c, err.Error())
+ return
+ }
+ if err := validate.Struct(req); err != nil {
+ utils.ValidationError(c, err)
+ return
+ }
+
+ if req.LoggedAt.IsZero() {
+ req.LoggedAt = time.Now()
+ }
+
+ res, err := db.DB.Exec(
+ `INSERT INTO weight_logs (user_id, weight, notes, logged_at) VALUES (?, ?, ?, ?)`,
+ uid, req.Weight, req.Notes, req.LoggedAt,
+ )
+ if err != nil {
+ utils.InternalError(c)
+ return
+ }
+
+ id, _ := res.LastInsertId()
+ var log models.WeightLog
+ db.DB.QueryRow(
+ `SELECT id, user_id, weight, notes, logged_at, created_at FROM weight_logs WHERE id = ?`, id,
+ ).Scan(&log.ID, &log.UserID, &log.Weight, &log.Notes, &log.LoggedAt, &log.CreatedAt)
+
+ utils.Created(c, log)
+}
+
+func DeleteWeightLog(c *gin.Context) {
+ uid := middleware.UserID(c)
+ lid, err := strconv.ParseInt(c.Param("id"), 10, 64)
+ if err != nil {
+ utils.BadRequest(c, "invalid id")
+ return
+ }
+
+ res, err := db.DB.Exec(`DELETE FROM weight_logs WHERE id = ? AND user_id = ?`, lid, uid)
+ if err != nil {
+ utils.InternalError(c)
+ return
+ }
+ n, _ := res.RowsAffected()
+ if n == 0 {
+ utils.NotFound(c, "log entry not found")
+ return
+ }
+ utils.OK(c, gin.H{"deleted": true})
+}
+
+func GetWeightStats(c *gin.Context) {
+ uid := middleware.UserID(c)
+
+ var latest, oldest sql.NullFloat64
+ var count int
+ db.DB.QueryRow(
+ `SELECT
+ (SELECT weight FROM weight_logs WHERE user_id = ? ORDER BY logged_at DESC LIMIT 1),
+ (SELECT weight FROM weight_logs WHERE user_id = ? ORDER BY logged_at ASC LIMIT 1),
+ COUNT(*) FROM weight_logs WHERE user_id = ?`,
+ uid, uid, uid,
+ ).Scan(&latest, &oldest, &count)
+
+ utils.OK(c, gin.H{
+ "latest": latest.Float64,
+ "starting": oldest.Float64,
+ "total_entries": count,
+ })
+}
diff --git a/backend/controllers/workouts.go b/backend/controllers/workouts.go
new file mode 100644
index 0000000..eed68ca
--- /dev/null
+++ b/backend/controllers/workouts.go
@@ -0,0 +1,192 @@
+package controllers
+
+import (
+ "database/sql"
+ "strconv"
+ "time"
+
+ "github.com/Cawlumm/lyftr-backend/db"
+ "github.com/Cawlumm/lyftr-backend/middleware"
+ "github.com/Cawlumm/lyftr-backend/models"
+ "github.com/Cawlumm/lyftr-backend/utils"
+ "github.com/gin-gonic/gin"
+)
+
+func ListWorkouts(c *gin.Context) {
+ uid := middleware.UserID(c)
+ limit := 20
+ offset := 0
+ if l, err := strconv.Atoi(c.Query("limit")); err == nil && l > 0 {
+ limit = l
+ }
+ if o, err := strconv.Atoi(c.Query("offset")); err == nil && o >= 0 {
+ offset = o
+ }
+
+ rows, err := db.DB.Query(
+ `SELECT id, user_id, name, notes, duration, started_at, created_at
+ FROM workouts WHERE user_id = ? ORDER BY started_at DESC LIMIT ? OFFSET ?`,
+ uid, limit, offset,
+ )
+ if err != nil {
+ utils.InternalError(c)
+ return
+ }
+ defer rows.Close()
+
+ workouts := []models.Workout{}
+ for rows.Next() {
+ var w models.Workout
+ rows.Scan(&w.ID, &w.UserID, &w.Name, &w.Notes, &w.Duration, &w.StartedAt, &w.CreatedAt)
+ workouts = append(workouts, w)
+ }
+ utils.OK(c, workouts)
+}
+
+func GetWorkout(c *gin.Context) {
+ uid := middleware.UserID(c)
+ wid, err := strconv.ParseInt(c.Param("id"), 10, 64)
+ if err != nil {
+ utils.BadRequest(c, "invalid workout id")
+ return
+ }
+
+ var w models.Workout
+ err = db.DB.QueryRow(
+ `SELECT id, user_id, name, notes, duration, started_at, created_at
+ FROM workouts WHERE id = ? AND user_id = ?`, wid, uid,
+ ).Scan(&w.ID, &w.UserID, &w.Name, &w.Notes, &w.Duration, &w.StartedAt, &w.CreatedAt)
+ if err == sql.ErrNoRows {
+ utils.NotFound(c, "workout not found")
+ return
+ }
+ if err != nil {
+ utils.InternalError(c)
+ return
+ }
+
+ w.Exercises = loadWorkoutExercises(wid)
+ utils.OK(c, w)
+}
+
+func CreateWorkout(c *gin.Context) {
+ uid := middleware.UserID(c)
+ var req models.CreateWorkoutRequest
+ if err := c.ShouldBindJSON(&req); err != nil {
+ utils.BadRequest(c, err.Error())
+ return
+ }
+ if err := validate.Struct(req); err != nil {
+ utils.ValidationError(c, err)
+ return
+ }
+
+ if req.StartedAt.IsZero() {
+ req.StartedAt = time.Now()
+ }
+
+ res, err := db.DB.Exec(
+ `INSERT INTO workouts (user_id, name, notes, duration, started_at) VALUES (?, ?, ?, ?, ?)`,
+ uid, req.Name, req.Notes, req.Duration, req.StartedAt,
+ )
+ if err != nil {
+ utils.InternalError(c)
+ return
+ }
+ wid, _ := res.LastInsertId()
+
+ for i, ex := range req.Exercises {
+ exRes, err := db.DB.Exec(
+ `INSERT INTO workout_exercises (workout_id, exercise_id, order_index, notes) VALUES (?, ?, ?, ?)`,
+ wid, ex.ExerciseID, i, ex.Notes,
+ )
+ if err != nil {
+ continue
+ }
+ weid, _ := exRes.LastInsertId()
+ for j, s := range ex.Sets {
+ db.DB.Exec(
+ `INSERT INTO sets (workout_exercise_id, set_number, reps, weight, duration, distance, rpe, is_warmup)
+ VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
+ weid, j+1, s.Reps, s.Weight, s.Duration, s.Distance, s.RPE, s.IsWarmup,
+ )
+ }
+ }
+
+ var w models.Workout
+ db.DB.QueryRow(
+ `SELECT id, user_id, name, notes, duration, started_at, created_at FROM workouts WHERE id = ?`, wid,
+ ).Scan(&w.ID, &w.UserID, &w.Name, &w.Notes, &w.Duration, &w.StartedAt, &w.CreatedAt)
+ w.Exercises = loadWorkoutExercises(wid)
+ utils.Created(c, w)
+}
+
+func DeleteWorkout(c *gin.Context) {
+ uid := middleware.UserID(c)
+ wid, err := strconv.ParseInt(c.Param("id"), 10, 64)
+ if err != nil {
+ utils.BadRequest(c, "invalid workout id")
+ return
+ }
+
+ res, err := db.DB.Exec(`DELETE FROM workouts WHERE id = ? AND user_id = ?`, wid, uid)
+ if err != nil {
+ utils.InternalError(c)
+ return
+ }
+ n, _ := res.RowsAffected()
+ if n == 0 {
+ utils.NotFound(c, "workout not found")
+ return
+ }
+ utils.OK(c, gin.H{"deleted": true})
+}
+
+func loadWorkoutExercises(workoutID int64) []models.WorkoutExercise {
+ rows, err := db.DB.Query(
+ `SELECT we.id, we.workout_id, we.exercise_id, we.order_index, we.notes,
+ e.name, e.muscle_group, e.category, e.equipment, e.image_url
+ FROM workout_exercises we
+ JOIN exercises e ON e.id = we.exercise_id
+ WHERE we.workout_id = ? ORDER BY we.order_index`,
+ workoutID,
+ )
+ if err != nil {
+ return nil
+ }
+ defer rows.Close()
+
+ var exercises []models.WorkoutExercise
+ for rows.Next() {
+ var we models.WorkoutExercise
+ rows.Scan(
+ &we.ID, &we.WorkoutID, &we.ExerciseID, &we.OrderIndex, &we.Notes,
+ &we.Exercise.Name, &we.Exercise.MuscleGroup, &we.Exercise.Category,
+ &we.Exercise.Equipment, &we.Exercise.ImageURL,
+ )
+ we.Exercise.ID = we.ExerciseID
+ we.Sets = loadSets(we.ID)
+ exercises = append(exercises, we)
+ }
+ return exercises
+}
+
+func loadSets(workoutExerciseID int64) []models.Set {
+ rows, err := db.DB.Query(
+ `SELECT id, workout_exercise_id, set_number, reps, weight, duration, distance, rpe, is_warmup
+ FROM sets WHERE workout_exercise_id = ? ORDER BY set_number`,
+ workoutExerciseID,
+ )
+ if err != nil {
+ return nil
+ }
+ defer rows.Close()
+
+ var sets []models.Set
+ for rows.Next() {
+ var s models.Set
+ rows.Scan(&s.ID, &s.WorkoutExerciseID, &s.SetNumber, &s.Reps, &s.Weight, &s.Duration, &s.Distance, &s.RPE, &s.IsWarmup)
+ sets = append(sets, s)
+ }
+ return sets
+}
diff --git a/backend/db/migrations.go b/backend/db/migrations.go
new file mode 100644
index 0000000..7019307
--- /dev/null
+++ b/backend/db/migrations.go
@@ -0,0 +1,100 @@
+package db
+
+func migrate() error {
+ _, err := DB.Exec(schema)
+ return err
+}
+
+const schema = `
+CREATE TABLE IF NOT EXISTS users (
+ id INTEGER PRIMARY KEY AUTOINCREMENT,
+ email TEXT NOT NULL UNIQUE,
+ password_hash TEXT NOT NULL,
+ created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+ updated_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE TABLE IF NOT EXISTS user_settings (
+ user_id INTEGER PRIMARY KEY REFERENCES users(id) ON DELETE CASCADE,
+ weight_unit TEXT NOT NULL DEFAULT 'lbs',
+ calorie_target INTEGER NOT NULL DEFAULT 2000,
+ protein_target INTEGER NOT NULL DEFAULT 150,
+ carb_target INTEGER NOT NULL DEFAULT 250,
+ fat_target INTEGER NOT NULL DEFAULT 65
+);
+
+CREATE TABLE IF NOT EXISTS exercises (
+ id INTEGER PRIMARY KEY AUTOINCREMENT,
+ name TEXT NOT NULL,
+ muscle_group TEXT NOT NULL DEFAULT '',
+ secondary_muscles TEXT NOT NULL DEFAULT '[]', -- JSON array
+ category TEXT NOT NULL DEFAULT 'strength',
+ equipment TEXT NOT NULL DEFAULT '',
+ description TEXT NOT NULL DEFAULT '',
+ image_url TEXT NOT NULL DEFAULT '',
+ video_url TEXT NOT NULL DEFAULT ''
+);
+
+CREATE UNIQUE INDEX IF NOT EXISTS idx_exercises_name ON exercises(name);
+
+CREATE TABLE IF NOT EXISTS workouts (
+ id INTEGER PRIMARY KEY AUTOINCREMENT,
+ user_id INTEGER NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+ name TEXT NOT NULL,
+ notes TEXT NOT NULL DEFAULT '',
+ duration INTEGER NOT NULL DEFAULT 0,
+ started_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+ created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE INDEX IF NOT EXISTS idx_workouts_user ON workouts(user_id, started_at DESC);
+
+CREATE TABLE IF NOT EXISTS workout_exercises (
+ id INTEGER PRIMARY KEY AUTOINCREMENT,
+ workout_id INTEGER NOT NULL REFERENCES workouts(id) ON DELETE CASCADE,
+ exercise_id INTEGER NOT NULL REFERENCES exercises(id),
+ order_index INTEGER NOT NULL DEFAULT 0,
+ notes TEXT NOT NULL DEFAULT ''
+);
+
+CREATE TABLE IF NOT EXISTS sets (
+ id INTEGER PRIMARY KEY AUTOINCREMENT,
+ workout_exercise_id INTEGER NOT NULL REFERENCES workout_exercises(id) ON DELETE CASCADE,
+ set_number INTEGER NOT NULL DEFAULT 1,
+ reps INTEGER NOT NULL DEFAULT 0,
+ weight REAL NOT NULL DEFAULT 0,
+ duration INTEGER NOT NULL DEFAULT 0,
+ distance REAL NOT NULL DEFAULT 0,
+ rpe REAL NOT NULL DEFAULT 0,
+ is_warmup INTEGER NOT NULL DEFAULT 0
+);
+
+CREATE TABLE IF NOT EXISTS weight_logs (
+ id INTEGER PRIMARY KEY AUTOINCREMENT,
+ user_id INTEGER NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+ weight REAL NOT NULL,
+ notes TEXT NOT NULL DEFAULT '',
+ logged_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+ created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE INDEX IF NOT EXISTS idx_weight_logs_user ON weight_logs(user_id, logged_at DESC);
+
+CREATE TABLE IF NOT EXISTS food_logs (
+ id INTEGER PRIMARY KEY AUTOINCREMENT,
+ user_id INTEGER NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+ name TEXT NOT NULL,
+ meal TEXT NOT NULL DEFAULT 'snacks',
+ calories REAL NOT NULL DEFAULT 0,
+ protein REAL NOT NULL DEFAULT 0,
+ carbs REAL NOT NULL DEFAULT 0,
+ fat REAL NOT NULL DEFAULT 0,
+ servings REAL NOT NULL DEFAULT 1,
+ serving_size TEXT NOT NULL DEFAULT '',
+ barcode TEXT NOT NULL DEFAULT '',
+ logged_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+ created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE INDEX IF NOT EXISTS idx_food_logs_user ON food_logs(user_id, logged_at DESC);
+`
diff --git a/backend/db/sqlite.go b/backend/db/sqlite.go
new file mode 100644
index 0000000..97b5e72
--- /dev/null
+++ b/backend/db/sqlite.go
@@ -0,0 +1,41 @@
+package db
+
+import (
+ "database/sql"
+ "log"
+ "os"
+ "path/filepath"
+
+ "github.com/Cawlumm/lyftr-backend/config"
+ _ "modernc.org/sqlite"
+)
+
+var DB *sql.DB
+
+func Connect() {
+ dbPath := config.C.DBPath
+
+ // Ensure the directory exists
+ if err := os.MkdirAll(filepath.Dir(dbPath), 0755); err != nil {
+ log.Fatalf("failed to create db directory: %v", err)
+ }
+
+ var err error
+ DB, err = sql.Open("sqlite", dbPath+"?_journal_mode=WAL&_foreign_keys=on")
+ if err != nil {
+ log.Fatalf("failed to open database: %v", err)
+ }
+
+ DB.SetMaxOpenConns(1) // SQLite is single-writer
+ DB.SetMaxIdleConns(1)
+
+ if err = DB.Ping(); err != nil {
+ log.Fatalf("failed to ping database: %v", err)
+ }
+
+ if err = migrate(); err != nil {
+ log.Fatalf("migration failed: %v", err)
+ }
+
+ log.Printf("SQLite database ready at %s", dbPath)
+}
diff --git a/backend/go.mod b/backend/go.mod
new file mode 100644
index 0000000..5156105
--- /dev/null
+++ b/backend/go.mod
@@ -0,0 +1,50 @@
+module github.com/Cawlumm/lyftr-backend
+
+go 1.26.1
+
+require (
+ github.com/gin-contrib/cors v1.7.7
+ github.com/gin-gonic/gin v1.12.0
+ github.com/go-playground/validator/v10 v10.30.2
+ github.com/golang-jwt/jwt/v5 v5.3.1
+ github.com/joho/godotenv v1.5.1
+ golang.org/x/crypto v0.50.0
+ modernc.org/sqlite v1.49.1
+)
+
+require (
+ github.com/bytedance/gopkg v0.1.3 // indirect
+ github.com/bytedance/sonic v1.15.0 // indirect
+ github.com/bytedance/sonic/loader v0.5.0 // indirect
+ github.com/cloudwego/base64x v0.1.6 // indirect
+ github.com/dustin/go-humanize v1.0.1 // indirect
+ github.com/gabriel-vasile/mimetype v1.4.13 // indirect
+ github.com/gin-contrib/sse v1.1.0 // indirect
+ github.com/go-playground/locales v0.14.1 // indirect
+ github.com/go-playground/universal-translator v0.18.1 // indirect
+ github.com/goccy/go-json v0.10.5 // indirect
+ github.com/goccy/go-yaml v1.19.2 // indirect
+ github.com/google/uuid v1.6.0 // indirect
+ github.com/json-iterator/go v1.1.12 // indirect
+ github.com/klauspost/cpuid/v2 v2.3.0 // indirect
+ github.com/leodido/go-urn v1.4.0 // indirect
+ github.com/mattn/go-isatty v0.0.20 // indirect
+ github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
+ github.com/modern-go/reflect2 v1.0.2 // indirect
+ github.com/ncruces/go-strftime v1.0.0 // indirect
+ github.com/pelletier/go-toml/v2 v2.2.4 // indirect
+ github.com/quic-go/qpack v0.6.0 // indirect
+ github.com/quic-go/quic-go v0.59.0 // indirect
+ github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec // indirect
+ github.com/twitchyliquid64/golang-asm v0.15.1 // indirect
+ github.com/ugorji/go/codec v1.3.1 // indirect
+ go.mongodb.org/mongo-driver/v2 v2.5.0 // indirect
+ golang.org/x/arch v0.23.0 // indirect
+ golang.org/x/net v0.52.0 // indirect
+ golang.org/x/sys v0.43.0 // indirect
+ golang.org/x/text v0.36.0 // indirect
+ google.golang.org/protobuf v1.36.10 // indirect
+ modernc.org/libc v1.72.0 // indirect
+ modernc.org/mathutil v1.7.1 // indirect
+ modernc.org/memory v1.11.0 // indirect
+)
diff --git a/backend/main.go b/backend/main.go
new file mode 100644
index 0000000..3ef5c2e
--- /dev/null
+++ b/backend/main.go
@@ -0,0 +1,30 @@
+package main
+
+import (
+ "log"
+
+ "github.com/Cawlumm/lyftr-backend/config"
+ "github.com/Cawlumm/lyftr-backend/db"
+ "github.com/Cawlumm/lyftr-backend/routes"
+ "github.com/Cawlumm/lyftr-backend/seed"
+ "github.com/gin-gonic/gin"
+)
+
+func main() {
+ config.Load()
+ db.Connect()
+ seed.Exercises(db.DB)
+
+ if config.C.Env == "production" {
+ gin.SetMode(gin.ReleaseMode)
+ }
+
+ r := gin.Default()
+ routes.Setup(r)
+
+ addr := ":" + config.C.Port
+ log.Printf("lyftr API listening on %s (env=%s)", addr, config.C.Env)
+ if err := r.Run(addr); err != nil {
+ log.Fatalf("server error: %v", err)
+ }
+}
diff --git a/backend/middleware/auth.go b/backend/middleware/auth.go
new file mode 100644
index 0000000..6ccfc8b
--- /dev/null
+++ b/backend/middleware/auth.go
@@ -0,0 +1,45 @@
+package middleware
+
+import (
+ "strings"
+
+ "github.com/Cawlumm/lyftr-backend/utils"
+ "github.com/gin-gonic/gin"
+)
+
+const UserIDKey = "user_id"
+const UserEmailKey = "user_email"
+
+func Auth() gin.HandlerFunc {
+ return func(c *gin.Context) {
+ header := c.GetHeader("Authorization")
+ if !strings.HasPrefix(header, "Bearer ") {
+ utils.Unauthorized(c, "missing or invalid authorization header")
+ c.Abort()
+ return
+ }
+
+ claims, err := utils.ValidateToken(strings.TrimPrefix(header, "Bearer "))
+ if err != nil {
+ utils.Unauthorized(c, "invalid or expired token")
+ c.Abort()
+ return
+ }
+
+ if claims.Type != "access" {
+ utils.Unauthorized(c, "invalid token type")
+ c.Abort()
+ return
+ }
+
+ c.Set(UserIDKey, claims.UserID)
+ c.Set(UserEmailKey, claims.Email)
+ c.Next()
+ }
+}
+
+func UserID(c *gin.Context) int64 {
+ id, _ := c.Get(UserIDKey)
+ v, _ := id.(int64)
+ return v
+}
diff --git a/backend/models/models.go b/backend/models/models.go
new file mode 100644
index 0000000..a2eb840
--- /dev/null
+++ b/backend/models/models.go
@@ -0,0 +1,173 @@
+package models
+
+import "time"
+
+type User struct {
+ ID int64 `json:"id" db:"id"`
+ Email string `json:"email" db:"email"`
+ Password string `json:"-" db:"password_hash"`
+ CreatedAt time.Time `json:"created_at" db:"created_at"`
+ UpdatedAt time.Time `json:"updated_at" db:"updated_at"`
+}
+
+type UserSettings struct {
+ UserID int64 `json:"user_id" db:"user_id"`
+ WeightUnit string `json:"weight_unit" db:"weight_unit"` // "lbs" or "kg"
+ CalorieTarget int `json:"calorie_target" db:"calorie_target"`
+ ProteinTarget int `json:"protein_target" db:"protein_target"`
+ CarbTarget int `json:"carb_target" db:"carb_target"`
+ FatTarget int `json:"fat_target" db:"fat_target"`
+}
+
+type Exercise struct {
+ ID int64 `json:"id" db:"id"`
+ Name string `json:"name" db:"name"`
+ MuscleGroup string `json:"muscle_group" db:"muscle_group"`
+ SecondaryMuscles []string `json:"secondary_muscles" db:"-"` // decoded from JSON column
+ Category string `json:"category" db:"category"` // "strength", "cardio", "flexibility"
+ Equipment string `json:"equipment" db:"equipment"`
+ Description string `json:"description" db:"description"`
+ ImageURL string `json:"image_url,omitempty" db:"image_url"`
+ VideoURL string `json:"video_url,omitempty" db:"video_url"`
+}
+
+type Workout struct {
+ ID int64 `json:"id" db:"id"`
+ UserID int64 `json:"user_id" db:"user_id"`
+ Name string `json:"name" db:"name"`
+ Notes string `json:"notes,omitempty" db:"notes"`
+ Duration int `json:"duration" db:"duration"` // seconds
+ StartedAt time.Time `json:"started_at" db:"started_at"`
+ CreatedAt time.Time `json:"created_at" db:"created_at"`
+ Exercises []WorkoutExercise `json:"exercises,omitempty"`
+}
+
+type WorkoutExercise struct {
+ ID int64 `json:"id" db:"id"`
+ WorkoutID int64 `json:"workout_id" db:"workout_id"`
+ ExerciseID int64 `json:"exercise_id" db:"exercise_id"`
+ OrderIndex int `json:"order_index" db:"order_index"`
+ Notes string `json:"notes,omitempty" db:"notes"`
+ Exercise Exercise `json:"exercise,omitempty"`
+ Sets []Set `json:"sets,omitempty"`
+}
+
+type Set struct {
+ ID int64 `json:"id" db:"id"`
+ WorkoutExerciseID int64 `json:"workout_exercise_id" db:"workout_exercise_id"`
+ SetNumber int `json:"set_number" db:"set_number"`
+ Reps int `json:"reps,omitempty" db:"reps"`
+ Weight float64 `json:"weight,omitempty" db:"weight"` // stored in kg
+ Duration int `json:"duration,omitempty" db:"duration"` // seconds, for timed sets
+ Distance float64 `json:"distance,omitempty" db:"distance"` // meters
+ RPE float64 `json:"rpe,omitempty" db:"rpe"`
+ IsWarmup bool `json:"is_warmup" db:"is_warmup"`
+}
+
+type WeightLog struct {
+ ID int64 `json:"id" db:"id"`
+ UserID int64 `json:"user_id" db:"user_id"`
+ Weight float64 `json:"weight" db:"weight"` // stored in kg
+ Notes string `json:"notes,omitempty" db:"notes"`
+ LoggedAt time.Time `json:"logged_at" db:"logged_at"`
+ CreatedAt time.Time `json:"created_at" db:"created_at"`
+}
+
+type FoodLog struct {
+ ID int64 `json:"id" db:"id"`
+ UserID int64 `json:"user_id" db:"user_id"`
+ Name string `json:"name" db:"name"`
+ Meal string `json:"meal" db:"meal"` // "breakfast", "lunch", "dinner", "snacks"
+ Calories float64 `json:"calories" db:"calories"`
+ Protein float64 `json:"protein" db:"protein"`
+ Carbs float64 `json:"carbs" db:"carbs"`
+ Fat float64 `json:"fat" db:"fat"`
+ Servings float64 `json:"servings" db:"servings"`
+ ServingSize string `json:"serving_size" db:"serving_size"`
+ Barcode string `json:"barcode,omitempty" db:"barcode"`
+ LoggedAt time.Time `json:"logged_at" db:"logged_at"`
+ CreatedAt time.Time `json:"created_at" db:"created_at"`
+}
+
+// Request/Response types
+
+type RegisterRequest struct {
+ Email string `json:"email" validate:"required,email"`
+ Password string `json:"password" validate:"required,min=8"`
+}
+
+type LoginRequest struct {
+ Email string `json:"email" validate:"required,email"`
+ Password string `json:"password" validate:"required"`
+}
+
+type AuthResponse struct {
+ Token string `json:"token"`
+ RefreshToken string `json:"refresh_token"`
+ User User `json:"user"`
+}
+
+type RefreshRequest struct {
+ RefreshToken string `json:"refresh_token" validate:"required"`
+}
+
+type CreateWorkoutRequest struct {
+ Name string `json:"name" validate:"required"`
+ Notes string `json:"notes"`
+ Duration int `json:"duration"`
+ StartedAt time.Time `json:"started_at"`
+ Exercises []CreateWorkoutExerciseReq `json:"exercises"`
+}
+
+type CreateWorkoutExerciseReq struct {
+ ExerciseID int64 `json:"exercise_id" validate:"required"`
+ OrderIndex int `json:"order_index"`
+ Notes string `json:"notes"`
+ Sets []CreateSetReq `json:"sets"`
+}
+
+type CreateSetReq struct {
+ SetNumber int `json:"set_number"`
+ Reps int `json:"reps"`
+ Weight float64 `json:"weight"`
+ Duration int `json:"duration"`
+ Distance float64 `json:"distance"`
+ RPE float64 `json:"rpe"`
+ IsWarmup bool `json:"is_warmup"`
+}
+
+type LogWeightRequest struct {
+ Weight float64 `json:"weight" validate:"required,gt=0"`
+ Notes string `json:"notes"`
+ LoggedAt time.Time `json:"logged_at"`
+}
+
+type LogFoodRequest struct {
+ Name string `json:"name" validate:"required"`
+ Meal string `json:"meal" validate:"required,oneof=breakfast lunch dinner snacks"`
+ Calories float64 `json:"calories" validate:"gte=0"`
+ Protein float64 `json:"protein" validate:"gte=0"`
+ Carbs float64 `json:"carbs" validate:"gte=0"`
+ Fat float64 `json:"fat" validate:"gte=0"`
+ Servings float64 `json:"servings" validate:"gt=0"`
+ ServingSize string `json:"serving_size"`
+ Barcode string `json:"barcode"`
+ LoggedAt time.Time `json:"logged_at"`
+}
+
+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"`
+}
+
+type DailyStats struct {
+ Date string `json:"date"`
+ TotalCalories float64 `json:"total_calories"`
+ TotalProtein float64 `json:"total_protein"`
+ TotalCarbs float64 `json:"total_carbs"`
+ TotalFat float64 `json:"total_fat"`
+ WorkoutCount int `json:"workout_count"`
+}
diff --git a/backend/routes/routes.go b/backend/routes/routes.go
new file mode 100644
index 0000000..b8e44f6
--- /dev/null
+++ b/backend/routes/routes.go
@@ -0,0 +1,68 @@
+package routes
+
+import (
+ "github.com/Cawlumm/lyftr-backend/config"
+ "github.com/Cawlumm/lyftr-backend/controllers"
+ "github.com/Cawlumm/lyftr-backend/middleware"
+ "github.com/gin-contrib/cors"
+ "github.com/gin-gonic/gin"
+)
+
+func Setup(r *gin.Engine) {
+ r.Use(cors.New(cors.Config{
+ AllowOrigins: []string{config.C.CORSOrigin},
+ AllowMethods: []string{"GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"},
+ AllowHeaders: []string{"Origin", "Content-Type", "Authorization"},
+ AllowCredentials: true,
+ }))
+
+ r.GET("/health", func(c *gin.Context) {
+ c.JSON(200, gin.H{"status": "ok"})
+ })
+
+ api := r.Group("/api/v1")
+
+ // Auth (public)
+ auth := api.Group("/auth")
+ {
+ auth.POST("/register", controllers.Register)
+ auth.POST("/login", controllers.Login)
+ auth.POST("/refresh", controllers.RefreshToken)
+ }
+
+ // Protected routes
+ protected := api.Group("/")
+ protected.Use(middleware.Auth())
+ {
+ // User
+ protected.GET("me", controllers.GetMe)
+ protected.GET("settings", controllers.GetSettings)
+ protected.PUT("settings", controllers.UpdateSettings)
+ protected.DELETE("me", controllers.DeleteAccount)
+
+ // Workouts
+ protected.GET("workouts", controllers.ListWorkouts)
+ protected.POST("workouts", controllers.CreateWorkout)
+ protected.GET("workouts/:id", controllers.GetWorkout)
+ protected.DELETE("workouts/:id", controllers.DeleteWorkout)
+
+ // Weight
+ protected.GET("weight", controllers.ListWeightLogs)
+ protected.POST("weight", controllers.LogWeight)
+ protected.DELETE("weight/:id", controllers.DeleteWeightLog)
+ protected.GET("weight/stats", controllers.GetWeightStats)
+
+ // Food
+ protected.GET("food", controllers.ListFoodLogs)
+ protected.POST("food", controllers.LogFood)
+ protected.DELETE("food/:id", controllers.DeleteFoodLog)
+ protected.GET("food/stats", controllers.GetDailyStats)
+
+ // Exercises (read-only for users)
+ protected.GET("exercises", controllers.ListExercises)
+ protected.GET("exercises/:id", controllers.GetExercise)
+
+ // Admin
+ protected.POST("admin/sync-exercises", controllers.SyncExercises)
+ }
+}
diff --git a/backend/seed/exercises.go b/backend/seed/exercises.go
new file mode 100644
index 0000000..aaaad88
--- /dev/null
+++ b/backend/seed/exercises.go
@@ -0,0 +1,152 @@
+package seed
+
+import (
+ "database/sql"
+ "encoding/json"
+ "fmt"
+ "io"
+ "log"
+ "net/http"
+ "strings"
+ "time"
+)
+
+const (
+ exerciseDBURL = "https://raw.githubusercontent.com/yuhonas/free-exercise-db/main/dist/exercises.json"
+ imageBaseURL = "https://raw.githubusercontent.com/yuhonas/free-exercise-db/main/exercises"
+)
+
+type freeExerciseItem struct {
+ ID string `json:"id"`
+ Name string `json:"name"`
+ Force string `json:"force"`
+ Level string `json:"level"`
+ Mechanic string `json:"mechanic"`
+ Equipment string `json:"equipment"`
+ PrimaryMuscles []string `json:"primaryMuscles"`
+ SecondaryMuscles []string `json:"secondaryMuscles"`
+ Instructions []string `json:"instructions"`
+ Category string `json:"category"`
+ Images []string `json:"images"`
+}
+
+// Exercises seeds on first run if the table is empty.
+func Exercises(db *sql.DB) {
+ var count int
+ db.QueryRow(`SELECT COUNT(*) FROM exercises`).Scan(&count)
+ if count > 0 {
+ log.Printf("seed: %d exercises already in database, skipping sync", count)
+ return
+ }
+
+ log.Println("seed: fetching exercises from free-exercise-db...")
+ if err := fetchAndStore(db); err != nil {
+ log.Printf("seed: exercise sync failed: %v", err)
+ }
+}
+
+// SyncExercises forces a full re-sync (used by admin endpoint).
+func SyncExercises(db *sql.DB) error {
+ return fetchAndStore(db)
+}
+
+func fetchAndStore(db *sql.DB) error {
+ items, err := fetchAll()
+ if err != nil {
+ return err
+ }
+
+ tx, err := db.Begin()
+ if err != nil {
+ return err
+ }
+
+ stmt, err := tx.Prepare(`
+ INSERT INTO exercises (name, muscle_group, secondary_muscles, category, equipment, description, image_url)
+ VALUES (?, ?, ?, ?, ?, ?, ?)
+ ON CONFLICT(name) DO UPDATE SET
+ muscle_group = excluded.muscle_group,
+ secondary_muscles = excluded.secondary_muscles,
+ category = excluded.category,
+ equipment = excluded.equipment,
+ description = excluded.description,
+ image_url = excluded.image_url
+ `)
+ if err != nil {
+ tx.Rollback()
+ return err
+ }
+ defer stmt.Close()
+
+ inserted := 0
+ for _, e := range items {
+ primaryMuscle := ""
+ if len(e.PrimaryMuscles) > 0 {
+ primaryMuscle = e.PrimaryMuscles[0]
+ }
+
+ secondaryJSON, _ := json.Marshal(e.SecondaryMuscles)
+ if e.SecondaryMuscles == nil {
+ secondaryJSON = []byte("[]")
+ }
+
+ instructions := buildInstructions(e.Instructions)
+
+ imageURL := ""
+ if len(e.Images) > 0 {
+ imageURL = fmt.Sprintf("%s/%s/0.jpg", imageBaseURL, e.ID)
+ }
+
+ if _, err := stmt.Exec(
+ e.Name,
+ primaryMuscle,
+ string(secondaryJSON),
+ e.Category,
+ e.Equipment,
+ instructions,
+ imageURL,
+ ); err != nil {
+ log.Printf("seed: skip %q: %v", e.Name, err)
+ continue
+ }
+ inserted++
+ }
+
+ if err := tx.Commit(); err != nil {
+ return err
+ }
+
+ log.Printf("seed: synced %d exercises", inserted)
+ return nil
+}
+
+func fetchAll() ([]freeExerciseItem, error) {
+ client := &http.Client{Timeout: 30 * time.Second}
+ resp, err := client.Get(exerciseDBURL)
+ if err != nil {
+ return nil, fmt.Errorf("request failed: %w", err)
+ }
+ defer resp.Body.Close()
+
+ if resp.StatusCode != http.StatusOK {
+ body, _ := io.ReadAll(resp.Body)
+ return nil, fmt.Errorf("fetch returned %d: %s", resp.StatusCode, string(body))
+ }
+
+ var items []freeExerciseItem
+ if err := json.NewDecoder(resp.Body).Decode(&items); err != nil {
+ return nil, fmt.Errorf("decode failed: %w", err)
+ }
+ return items, nil
+}
+
+func buildInstructions(steps []string) string {
+ var b strings.Builder
+ for i, step := range steps {
+ if i > 0 {
+ b.WriteByte('\n')
+ }
+ fmt.Fprintf(&b, "%d. %s", i+1, step)
+ }
+ return b.String()
+}
diff --git a/backend/utils/jwt.go b/backend/utils/jwt.go
new file mode 100644
index 0000000..efe5bf6
--- /dev/null
+++ b/backend/utils/jwt.go
@@ -0,0 +1,61 @@
+package utils
+
+import (
+ "errors"
+ "strconv"
+ "time"
+
+ "github.com/Cawlumm/lyftr-backend/config"
+ "github.com/golang-jwt/jwt/v5"
+)
+
+type Claims struct {
+ UserID int64 `json:"user_id"`
+ Email string `json:"email"`
+ Type string `json:"type"` // "access" or "refresh"
+ jwt.RegisteredClaims
+}
+
+func GenerateTokenPair(userID int64, email string) (access, refresh string, err error) {
+ expiry, _ := strconv.Atoi(config.C.JWTExpiry)
+ if expiry == 0 {
+ expiry = 3600
+ }
+
+ access, err = generateToken(userID, email, "access", time.Duration(expiry)*time.Second)
+ if err != nil {
+ return
+ }
+ refresh, err = generateToken(userID, email, "refresh", 30*24*time.Hour)
+ return
+}
+
+func generateToken(userID int64, email, tokenType string, dur time.Duration) (string, error) {
+ claims := Claims{
+ UserID: userID,
+ Email: email,
+ Type: tokenType,
+ RegisteredClaims: jwt.RegisteredClaims{
+ ExpiresAt: jwt.NewNumericDate(time.Now().Add(dur)),
+ IssuedAt: jwt.NewNumericDate(time.Now()),
+ },
+ }
+ return jwt.NewWithClaims(jwt.SigningMethodHS256, claims).SignedString([]byte(config.C.JWTSecret))
+}
+
+func ValidateToken(tokenStr string) (*Claims, error) {
+ token, err := jwt.ParseWithClaims(tokenStr, &Claims{}, func(t *jwt.Token) (any, error) {
+ if _, ok := t.Method.(*jwt.SigningMethodHMAC); !ok {
+ return nil, errors.New("unexpected signing method")
+ }
+ return []byte(config.C.JWTSecret), nil
+ })
+ if err != nil {
+ return nil, err
+ }
+ claims, ok := token.Claims.(*Claims)
+ if !ok || !token.Valid {
+ return nil, errors.New("invalid token")
+ }
+ return claims, nil
+}
diff --git a/backend/utils/password.go b/backend/utils/password.go
new file mode 100644
index 0000000..ed7549a
--- /dev/null
+++ b/backend/utils/password.go
@@ -0,0 +1,12 @@
+package utils
+
+import "golang.org/x/crypto/bcrypt"
+
+func HashPassword(plain string) (string, error) {
+ b, err := bcrypt.GenerateFromPassword([]byte(plain), bcrypt.DefaultCost)
+ return string(b), err
+}
+
+func CheckPassword(plain, hash string) bool {
+ return bcrypt.CompareHashAndPassword([]byte(hash), []byte(plain)) == nil
+}
diff --git a/backend/utils/response.go b/backend/utils/response.go
new file mode 100644
index 0000000..547163f
--- /dev/null
+++ b/backend/utils/response.go
@@ -0,0 +1,35 @@
+package utils
+
+import (
+ "net/http"
+
+ "github.com/gin-gonic/gin"
+)
+
+func OK(c *gin.Context, data any) {
+ c.JSON(http.StatusOK, gin.H{"data": data})
+}
+
+func Created(c *gin.Context, data any) {
+ c.JSON(http.StatusCreated, gin.H{"data": data})
+}
+
+func BadRequest(c *gin.Context, msg string) {
+ c.JSON(http.StatusBadRequest, gin.H{"error": msg})
+}
+
+func Unauthorized(c *gin.Context, msg string) {
+ c.JSON(http.StatusUnauthorized, gin.H{"error": msg})
+}
+
+func NotFound(c *gin.Context, msg string) {
+ c.JSON(http.StatusNotFound, gin.H{"error": msg})
+}
+
+func InternalError(c *gin.Context) {
+ c.JSON(http.StatusInternalServerError, gin.H{"error": "internal server error"})
+}
+
+func ValidationError(c *gin.Context, err error) {
+ c.JSON(http.StatusUnprocessableEntity, gin.H{"error": err.Error()})
+}