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.examplenew file mode 100644index 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_herediff --git a/backend/config/config.go b/backend/config/config.gonew file mode 100644index 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.gonew file mode 100644index 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.gonew file mode 100644index 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.gonew file mode 100644index 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.gonew file mode 100644index 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.gonew file mode 100644index 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.gonew file mode 100644index 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.gonew file mode 100644index 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.gonew file mode 100644index 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.modnew file mode 100644index 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.gonew file mode 100644index 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.gonew file mode 100644index 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.gonew file mode 100644index 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.gonew file mode 100644index 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.gonew file mode 100644index 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.gonew file mode 100644index 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.gonew file mode 100644index 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.gonew file mode 100644index 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()})+}