kriss/geniusrun
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

store: collapse migrations into a single schema.sql, drop legacy-owner path

Browse Source 
Pre-production app, no need to preserve incremental migration history:
replace the 26 migration files with one current-state schema.sql (the
schema.sql comments are now the living documentation), simplify db.go to
apply it once instead of tracking/rebuilding through schema_migrations,
and make user_id NOT NULL everywhere now that there's no staged migration
to accommodate a nullable backfill window.

This removes the reason ClaimLegacyOwner/GENIUSRUN_LEGACY_OWNER_OIDC_SUB
existed (binding a pre-existing singleton-schema database to one account
across a staged migration), so that whole path is gone too -- the
existing dev database was wiped and reseeded fresh under the new schema.

Add cmd/dumpschema, which regenerates docs/DATABASE.md straight from the
live schema (via store.Open + sqlite_master introspection) so the
database documentation can never drift out of sync with reality.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
This commit is contained in:
Kriss Vila
2026-07-25 19:24:19 +02:00
parent 0f2101bce5
commit 644d87f1dc
37 changed files with 648 additions and 1100 deletions
Download Patch File Download Diff File Expand all files Collapse all files

258
backend/internal/store/store_test.go
View File

@@ -2,10 +2,7 @@ package store
import (
"context"
"database/sql"
"io/fs"
"path/filepath"
"sort"
"strings"
"testing"
)
@@ -23,7 +20,7 @@ func openTestDB(t *testing.T) *DB {
func f(v float64) *float64 { return &v }
func TestMigrateIsIdempotent(t *testing.T) {
func TestOpenIsIdempotent(t *testing.T) {
path := filepath.Join(t.TempDir(), "geniusrun_test.db")
db1, err := Open(path)
if err != nil {
@@ -33,7 +30,7 @@ func TestMigrateIsIdempotent(t *testing.T) {
db2, err := Open(path)
if err != nil {
t.Fatalf("second Open (re-applying migrations): %v", err)
t.Fatalf("second Open (schema already applied): %v", err)
}
db2.Close()
}
@@ -242,22 +239,10 @@ func TestReplaceLapsIsIdempotent(t *testing.T) {
}
}
func TestUsersAndOwnershipSchema_AppliesCleanly(t *testing.T) {
func TestSchema_PerUserUniqueConstraints(t *testing.T) {
db := openTestDB(t)
ctx := context.Background()
// A fresh DB has no legacy singleton rows, so every user_id column
// should already be backfilled to nothing (fresh install, no rows at
// all yet in these tables besides the migration-seeded workout_kinds --
// which do have NULL user_id until a real user is provisioned).
var nullableCount int
if err := db.QueryRowContext(ctx, `SELECT COUNT(*) FROM workout_kinds WHERE user_id IS NULL`).Scan(&nullableCount); err != nil {
t.Fatalf("count workout_kinds: %v", err)
}
if nullableCount != 8 {
t.Fatalf("expected 8 migration-seeded workout_kinds with NULL user_id on a fresh DB, got %d", nullableCount)
}
// UNIQUE(user_id, name) allows the same name across two different users.
if _, err := db.ExecContext(ctx, `INSERT INTO users (oidc_sub, display_name) VALUES ('sub-a', 'A'), ('sub-b', 'B')`); err != nil {
t.Fatalf("insert users: %v", err)
@@ -278,14 +263,12 @@ func TestUsersAndOwnershipSchema_AppliesCleanly(t *testing.T) {
}
}
func TestForeignKeyEnforcementPostMigration(t *testing.T) {
func TestForeignKeyEnforcement(t *testing.T) {
db := openTestDB(t)
ctx := context.Background()
// Verify that FK enforcement is correctly active after migrations complete.
// This tests that the PRAGMA foreign_keys toggle in db.migrate() (for
// migrations 0023/0024/0025) is properly scoped and re-enabled after each
// table rebuild.
// Verify FK enforcement is genuinely active: a valid reference succeeds,
// a bogus one is rejected, not silently accepted.
userID, err := db.ProvisionUser(ctx, "test-sub", "Test")
if err != nil {
@@ -302,7 +285,7 @@ func TestForeignKeyEnforcementPostMigration(t *testing.T) {
t.Fatalf("UpsertActivity: %v", err)
}
// Get the ID of one of the 8 migration-seeded workout_kinds.
// Get the ID of one of the 8 workout_kinds ProvisionUser seeded.
var seedKindID int64
if err := db.QueryRowContext(ctx, `SELECT id FROM workout_kinds LIMIT 1`).Scan(&seedKindID); err != nil {
t.Fatalf("query seeded workout_kind: %v", err)
@@ -341,233 +324,6 @@ func TestForeignKeyEnforcementPostMigration(t *testing.T) {
}
}
// TestRebuildMigrationsPreserveForeignKeyReferences proves the specific
// property none of the other migration tests cover: every other test opens
// a fresh DB via store.Open, which runs migrations 0001-0026 in one
// uninterrupted pass over an empty database, so migrations 0023/0024/0025/0026's
// table-rebuild (create-new/copy/drop-old/rename-into-place) never has any
// real pre-existing rows to carry across. A real single-tenant deployment
// upgrading to this schema version has months of synced activities, laps,
// activity_samples, and kind_assignments rows referencing real activities/
// workout_kinds rows by foreign key (per this repo's CLAUDE.md: one profile,
// real Garmin history, a review queue with manual overrides already
// recorded). This test manually applies migrations up through 0022, inserts
// rows simulating that pre-existing install, then applies 0023/0024/0025/0026
// and verifies every FK-referencing row still resolves correctly -- and that
// FK enforcement is genuinely back on afterward -- rather than just checking
// that migrations apply to an empty DB without erroring. This is the
// regression guard for a real bug: migration 0026 (activities table rebuild)
// originally issued its own mid-transaction `PRAGMA foreign_keys = OFF/ON`,
// which SQLite documents as a no-op once a transaction is open, so
// `DROP TABLE activities` silently cascade-deleted every laps/
// activity_samples/kind_assignments row for every activity via
// `ON DELETE CASCADE` -- with no error at all. It was masked because every
// other test runs migrations back-to-back on an empty database with no
// pre-existing child rows.
func TestRebuildMigrationsPreserveForeignKeyReferences(t *testing.T) {
ctx := context.Background()
path := filepath.Join(t.TempDir(), "geniusrun_rebuild_test.db")
// Deliberately not store.Open: that always applies every migration in
// one uninterrupted pass with no way to stop partway through. The sqlite
// driver itself is already registered via db.go's blank import.
sqlDB, err := sql.Open("sqlite", path+"?_pragma=foreign_keys(1)")
if err != nil {
t.Fatalf("open sqlite: %v", err)
}
defer sqlDB.Close()
if _, err := sqlDB.ExecContext(ctx, `CREATE TABLE IF NOT EXISTS schema_migrations (
filename TEXT PRIMARY KEY,
applied_at TEXT NOT NULL DEFAULT (datetime('now'))
)`); err != nil {
t.Fatalf("create schema_migrations table: %v", err)
}
rebuildMigrations := map[string]bool{
"0023_profile_user_scoped.sql": true,
"0024_workout_kinds_user_scoped.sql": true,
"0025_sync_state_user_scoped.sql": true,
"0026_activities_unique_constraint.sql": true,
}
// Mirrors db.go's migrate() method: FK toggle in autocommit mode around
// the transaction, only for the four table-rebuild migrations.
applyMigration := func(name string) {
t.Helper()
content, err := migrationsFS.ReadFile("migrations/" + name)
if err != nil {
t.Fatalf("read migration %s: %v", name, err)
}
needsFKToggle := rebuildMigrations[name]
if needsFKToggle {
if _, err := sqlDB.ExecContext(ctx, `PRAGMA foreign_keys = OFF`); err != nil {
t.Fatalf("disable foreign keys before migration %s: %v", name, err)
}
}
tx, err := sqlDB.BeginTx(ctx, nil)
if err != nil {
t.Fatalf("begin migration tx for %s: %v", name, err)
}
if _, err := tx.ExecContext(ctx, string(content)); err != nil {
tx.Rollback()
t.Fatalf("apply migration %s: %v", name, err)
}
if _, err := tx.ExecContext(ctx, `INSERT INTO schema_migrations (filename) VALUES (?)`, name); err != nil {
tx.Rollback()
t.Fatalf("record migration %s: %v", name, err)
}
if err := tx.Commit(); err != nil {
t.Fatalf("commit migration %s: %v", name, err)
}
if needsFKToggle {
if _, err := sqlDB.ExecContext(ctx, `PRAGMA foreign_keys = ON`); err != nil {
t.Fatalf("enable foreign keys after migration %s: %v", name, err)
}
}
}
entries, err := fs.Glob(migrationsFS, "migrations/*.sql")
if err != nil {
t.Fatalf("glob migrations: %v", err)
}
sort.Strings(entries)
// Apply every migration up to (but not including) the three rebuilds.
for _, entry := range entries {
name := entry[len("migrations/"):]
if rebuildMigrations[name] {
continue
}
applyMigration(name)
}
// Simulate a real pre-existing single-tenant install at this point in
// schema history: a workout kind, a synced activity, and a
// kind_assignment referencing both by foreign key.
res, err := sqlDB.ExecContext(ctx, `INSERT INTO workout_kinds (name, rule_json) VALUES ('Pre-Existing Custom Kind', '{}')`)
if err != nil {
t.Fatalf("insert pre-existing workout_kinds row: %v", err)
}
kindID, err := res.LastInsertId()
if err != nil {
t.Fatalf("workout_kinds LastInsertId: %v", err)
}
res, err = sqlDB.ExecContext(ctx, `
INSERT INTO activities (garmin_activity_id, start_time_utc, duration_seconds, distance_meters, raw_json)
VALUES (123456789, '2026-01-01 06:00:00', 1800, 5000, '{}')`)
if err != nil {
t.Fatalf("insert pre-existing activities row: %v", err)
}
activityID, err := res.LastInsertId()
if err != nil {
t.Fatalf("activities LastInsertId: %v", err)
}
res, err = sqlDB.ExecContext(ctx, `
INSERT INTO kind_assignments (activity_id, workout_kind_id, assignment_source, status)
VALUES (?, ?, 'rule_engine', 'assigned')`, activityID, kindID)
if err != nil {
t.Fatalf("insert pre-existing kind_assignments row: %v", err)
}
assignmentID, err := res.LastInsertId()
if err != nil {
t.Fatalf("kind_assignments LastInsertId: %v", err)
}
res, err = sqlDB.ExecContext(ctx, `
INSERT INTO laps (activity_id, lap_index, raw_json)
VALUES (?, 0, '{}')`, activityID)
if err != nil {
t.Fatalf("insert pre-existing laps row: %v", err)
}
lapID, err := res.LastInsertId()
if err != nil {
t.Fatalf("laps LastInsertId: %v", err)
}
res, err = sqlDB.ExecContext(ctx, `
INSERT INTO activity_samples (activity_id, elapsed_seconds, timestamp_ms, heart_rate)
VALUES (?, 60, 1735711260000, 150)`, activityID)
if err != nil {
t.Fatalf("insert pre-existing activity_samples row: %v", err)
}
sampleID, err := res.LastInsertId()
if err != nil {
t.Fatalf("activity_samples LastInsertId: %v", err)
}
// Now apply the four rebuild migrations that drop/recreate profile,
// workout_kinds, sync_state, and (0026) activities itself.
for _, name := range []string{
"0023_profile_user_scoped.sql",
"0024_workout_kinds_user_scoped.sql",
"0025_sync_state_user_scoped.sql",
"0026_activities_unique_constraint.sql",
} {
applyMigration(name)
}
// The pre-existing kind_assignment row must still resolve to the same
// workout_kind, by the same name, across the drop/recreate/rename.
var resolvedName string
if err := sqlDB.QueryRowContext(ctx, `
SELECT wk.name FROM kind_assignments ka
JOIN workout_kinds wk ON wk.id = ka.workout_kind_id
WHERE ka.id = ?`, assignmentID).Scan(&resolvedName); err != nil {
t.Fatalf("join kind_assignments -> workout_kinds after rebuild: %v", err)
}
if resolvedName != "Pre-Existing Custom Kind" {
t.Fatalf("expected pre-existing kind_assignment to still resolve to 'Pre-Existing Custom Kind' after rebuild, got %q", resolvedName)
}
// The pre-existing laps row must still exist and still reference the
// same activity -- this is the exact regression guard for migration
// 0026's DROP TABLE activities silently cascade-deleting laps via
// ON DELETE CASCADE when FK enforcement wasn't actually disabled.
var lapActivityID int64
if err := sqlDB.QueryRowContext(ctx, `
SELECT activity_id FROM laps WHERE id = ?`, lapID).Scan(&lapActivityID); err != nil {
t.Fatalf("query pre-existing laps row after rebuild: %v", err)
}
if lapActivityID != activityID {
t.Fatalf("expected pre-existing laps row to still reference activity %d after rebuild, got %d", activityID, lapActivityID)
}
// Same guard for activity_samples.
var sampleActivityID int64
if err := sqlDB.QueryRowContext(ctx, `
SELECT activity_id FROM activity_samples WHERE id = ?`, sampleID).Scan(&sampleActivityID); err != nil {
t.Fatalf("query pre-existing activity_samples row after rebuild: %v", err)
}
if sampleActivityID != activityID {
t.Fatalf("expected pre-existing activity_samples row to still reference activity %d after rebuild, got %d", activityID, sampleActivityID)
}
// FK enforcement must be genuinely active again post-migration: a bogus
// workout_kind_id, activity_id (laps), and activity_id (activity_samples)
// must all be rejected, not silently accepted.
if _, err := sqlDB.ExecContext(ctx, `
INSERT INTO kind_assignments (activity_id, workout_kind_id, assignment_source, status)
VALUES (?, 999999, 'rule_engine', 'assigned')`, activityID); err == nil {
t.Fatal("expected FK constraint violation for nonexistent workout_kind_id after rebuild, but insert succeeded")
}
if _, err := sqlDB.ExecContext(ctx, `
INSERT INTO laps (activity_id, lap_index, raw_json)
VALUES (999999, 0, '{}')`); err == nil {
t.Fatal("expected FK constraint violation for nonexistent activity_id in laps after rebuild, but insert succeeded")
}
if _, err := sqlDB.ExecContext(ctx, `
INSERT INTO activity_samples (activity_id, elapsed_seconds, timestamp_ms, heart_rate)
VALUES (999999, 60, 1735711260000, 150)`); err == nil {
t.Fatal("expected FK constraint violation for nonexistent activity_id in activity_samples after rebuild, but insert succeeded")
}
}
func TestCurrentAssignment_ScopedToOwningUser(t *testing.T) {
db := openTestDB(t)
ctx := context.Background()