store: scope sync state, sync runs, and reset to a user_id

Completes the store-layer scoping pass -- every store method touching
per-user data now requires an explicit userID.

backend/internal/store/syncruns.go

@@ -31,56 +31,56 @@ type SyncRun struct {
 	ErrorMessage      *string
 }
 
-// StartSyncRun records a new in-progress sync run and returns its id.
+// StartSyncRun records a new in-progress sync run for userID and returns its id.
-func (db *DB) StartSyncRun(ctx context.Context, kind string) (int64, error) {
+func (db *DB) StartSyncRun(ctx context.Context, userID int64, kind string) (int64, error) {
 	res, err := db.ExecContext(ctx, `
-		INSERT INTO sync_runs (kind, started_at, status) VALUES (?, datetime('now'), ?)`,
+		INSERT INTO sync_runs (user_id, kind, started_at, status) VALUES (?, ?, datetime('now'), ?)`,
-		kind, SyncStatusRunning)
+		userID, kind, SyncStatusRunning)
 	if err != nil {
-		return 0, fmt.Errorf("start sync run: %w", err)
+		return 0, fmt.Errorf("start sync run for user %d: %w", userID, err)
 	}
 	return res.LastInsertId()
 }
 
-// FinishSyncRun marks a sync run as finished, recording how many activities
+// FinishSyncRun marks a sync run (owned by userID) as finished, recording
-// were fetched and whether it succeeded.
+// how many activities were fetched and whether it succeeded.
-func (db *DB) FinishSyncRun(ctx context.Context, id int64, activitiesFetched int, errMsg *string) error {
+func (db *DB) FinishSyncRun(ctx context.Context, userID, id int64, activitiesFetched int, errMsg *string) error {
 	status := SyncStatusSuccess
 	if errMsg != nil {
 		status = SyncStatusError
 	}
 	_, err := db.ExecContext(ctx, `
 		UPDATE sync_runs SET finished_at = datetime('now'), activities_fetched = ?, status = ?, error_message = ?
-		WHERE id = ?`, activitiesFetched, status, errMsg, id)
+		WHERE id = ? AND user_id = ?`, activitiesFetched, status, errMsg, id, userID)
 	if err != nil {
-		return fmt.Errorf("finish sync run %d: %w", id, err)
+		return fmt.Errorf("finish sync run %d for user %d: %w", id, userID, err)
 	}
 	return nil
 }
 
-// LatestSyncRun returns the most recent sync run, if any.
+// LatestSyncRun returns userID's most recent sync run, if any.
-func (db *DB) LatestSyncRun(ctx context.Context) (SyncRun, bool, error) {
+func (db *DB) LatestSyncRun(ctx context.Context, userID int64) (SyncRun, bool, error) {
 	row := db.QueryRowContext(ctx, `
 		SELECT id, kind, started_at, finished_at, activities_fetched, status, error_message
-		FROM sync_runs ORDER BY id DESC LIMIT 1`)
+		FROM sync_runs WHERE user_id = ? ORDER BY id DESC LIMIT 1`, userID)
 	var r SyncRun
 	err := row.Scan(&r.ID, &r.Kind, &r.StartedAt, &r.FinishedAt, &r.ActivitiesFetched, &r.Status, &r.ErrorMessage)
 	if err == sql.ErrNoRows {
 		return SyncRun{}, false, nil
 	}
 	if err != nil {
-		return SyncRun{}, false, fmt.Errorf("latest sync run: %w", err)
+		return SyncRun{}, false, fmt.Errorf("latest sync run for user %d: %w", userID, err)
 	}
 	return r, true, nil
 }
 
-// ListSyncRuns returns recent sync runs, newest first.
+// ListSyncRuns returns userID's recent sync runs, newest first.
-func (db *DB) ListSyncRuns(ctx context.Context, limit int) ([]SyncRun, error) {
+func (db *DB) ListSyncRuns(ctx context.Context, userID int64, limit int) ([]SyncRun, error) {
 	rows, err := db.QueryContext(ctx, `
 		SELECT id, kind, started_at, finished_at, activities_fetched, status, error_message
-		FROM sync_runs ORDER BY id DESC LIMIT ?`, limit)
+		FROM sync_runs WHERE user_id = ? ORDER BY id DESC LIMIT ?`, userID, limit)
 	if err != nil {
-		return nil, fmt.Errorf("list sync runs: %w", err)
+		return nil, fmt.Errorf("list sync runs for user %d: %w", userID, err)
 	}
 	defer rows.Close()