Bakcend server for the Garmin Smart Knee Sleeve capstone project. This service powers the mobile application by exposing a REST API to manage the users workout sessions and metrics.
The other key repositories can be found here:
At a high level, the backend is responsible for:
- authenticating requests and associating them with application users
- storing calibration data used by the knee-tracking workflow
- creating and managing workout sessions, sets, and reps
- persisting workout history for providing data analytics in the app
- The Mobile Application sends HTTPS requests to the backend.
- Requests enter the HTTP handler layer
- Middle handlers authentication and logging
- The service layer applies our desired business logic and dictates application behaviour
- The repository layer persists and retrieves data from PostgreSQL.
The production environment is deployed on AWS and currently uses:
- Amazon EC2: Application server
- Amazon RDS for PostgreSQL: Persistent relational storage
- Amazon ECR: Container image storage
- Github Actions + OIDC for CI/CD deployment
- Cloudwatch Logs for backend request and application log collection
The application server runs and a public subnet and communicates with the PostgreSQL database, The database is deployed in private subnets, and both resources exist inside a Virtual Private Cloud (VPC).
cmd/ # Application entrypoint
internal/ # Core go application code
core/service/ # Business logic
data/ # Connection to repository layer
db/ # sqlc-generated database code
http/
handlers/ # HTTP handlers
middleware/ # Auth, logging, and HTTP middleware
responses/ # Shared response helpers
infra/ # AWS Infrastrucuture Configuration (OpenTofu)
db/
migration/ # Goose migrations
queries/ # Source SQL for sqlc
seeds/ # Development/Production seed data
scripts/ # CI/CD and production management scripts
-
Go Go 1.25 or higher: https://go.dev/dl/
-
Make (Optional) If on windows, a version of make must be installed, Chocolatey package manager is recommended: https://chocolatey.org/install
- Once Chocolatey is installed run the following command in an elevated powershell:
choco install make
- Once Chocolatey is installed run the following command in an elevated powershell:
-
Docker Desktop
Download: docker.com/products/docker-desktop
→ Make sure Docker is running in the background
-
Create environment file Mac/Unix:
cp .env.example .envWindows:copy .env.example .env -
Ensure Dependencies are up to date
go mod download
-
Ensure docker is running and launch container
docker compose up --build
-
Confirm server status
- Navigate to http://localhost:8080/health
- Status should be "OK"
This project uses Go Modules for dependency management. Here's how to work with packages:
To add a new dependency to the project:
go get github.com/example/packageThis will automatically update your go.mod and go.sum files.
After cloning the repository, install all dependencies:
go mod downloadTo update dependencies and clean up unused ones:
go mod tidyThis command ensures your go.mod file correctly reflects all dependencies used in the codebase.
This project includes a Makefile with common commands listed below.
Alternatively, run make to list all available commands
# Go Application
make build # Build the application
make run # Run the application
make dev # Run the application with live reload (docker-compose)
make test # Run the fast test suite
make test-integration # Run host-side DB-backed integration tests
make clean # Clean build artifacts
# Database & migrations
make migrations-status # Show goose migration status
make migrations-up # Apply all up migrations
make migrations-down # Roll back one migration
make migrations-reset # Roll back ALL migrations to base (dangerous in prod!)
make migrations-create # Create a new migration (pass name=foo)
make migrations-redo # Re-run the latest migration (down then up)
make migrations-up-to # Migrate up to a specific version (pass version=<num>)
make migrations-down-to # Migrate down to a specific version (pass version=<num>)
# DB helpers
make db-seed # Seed the database with test
# sqlc (DB codegen)
make sqlc-gen # Run sqlc generate inside the dev container
make sqlc-vet # Run sqlc vet (validate) inside the dev containerThe backend test setup uses a Go-friendly hybrid structure:
- Fast tests are colocated beside the packages they cover using
*_test.go - Shared helpers live in
internal/testutil - DB-backed integration helpers live in
internal/testutil/testdb
At a high level, the test suite is split into two layers:
-
Fast tests
- Middleware, handler, router, and pure service validation coverage
- Run with
go test ./...ormake test
-
Integration tests
- Real Postgres-backed tests for service flows that rely on sqlc queries and transactions
- Run with
go test -tags=integration ./...ormake test-integration - The integration harness applies the existing Goose migrations into an isolated schema before each test run
make testor
go test ./...- Start the local Postgres service:
docker compose up -d db- Ensure the repo
.envsetsTEST_DATABASE_URLto a host-resolvable URL.
Example:
POSTGRES_PORT=5432
TEST_POSTGRES_PORT=5433
TEST_DATABASE_URL=postgres://${POSTGRES_USER}:${POSTGRES_PASSWORD}@127.0.0.1:${TEST_POSTGRES_PORT}/${POSTGRES_DB}?sslmode=disable- Run the integration suite.
Default local command:
make test-integrationThis project supports live reload using Air via Docker. This allows you to automatically rebuild and restart the server when code changes are detected.
To use live reload, simply run:
# Using the make command (recommended)
make devThe configuration for Air is in the .air.toml file in the project root. No need to install Air locally as it runs in a Docker container.
To run migrations:
make migrations-up
This project uses sqlc to generate type-safe Go database code from SQL queries. sqlc is run inside the dev container so it uses the same database client and environment as the app.
Common commands
# Validate SQL and schema without generating code
make sqlc-vet
# Generate Go code from queries
make sqlc-genFor a simple web-based UI to inspect the database, this project includes pgweb.
Once the containers are running (make dev), pgweb will be available at:
From here you can:
- Browse tables and data
- Run ad-hoc SQL queries
- Inspect schema and relationships
This is useful for debugging or quick database exploration without using psql.
For local development and testing of protected endpoints:
In your .env file:
APP_ENV=development
DEV_BYPASS_SECRET=your-local-secretWhen calling protected endpoints, the following headers are required:
X-Dev-SecretX-Dev-User-Id