From e7a77a2fa3affe568fb593f843dfc7a97cbf7809 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?coffeegoddd=E2=98=95=EF=B8=8F=E2=9C=A8?= Date: Fri, 20 Mar 2026 13:58:17 -0700 Subject: [PATCH] /{cmd,internal}: pr feedback --- cmd/bd/diff_embedded_test.go | 4 ++-- internal/storage/dolt/versioned.go | 5 ++++- internal/storage/issueops/stale.go | 30 ++++++++++++++++++++++++++++-- 3 files changed, 34 insertions(+), 5 deletions(-) diff --git a/cmd/bd/diff_embedded_test.go b/cmd/bd/diff_embedded_test.go index 5072cc8db..1c41d910f 100644 --- a/cmd/bd/diff_embedded_test.go +++ b/cmd/bd/diff_embedded_test.go @@ -204,10 +204,10 @@ func TestEmbeddedDiff(t *testing.T) { e := entries[0] // Verify expected JSON keys if _, ok := e["IssueID"]; !ok { - t.Error("expected 'issue_id' key in JSON entry") + t.Error("expected 'IssueID' key in JSON entry") } if _, ok := e["DiffType"]; !ok { - t.Error("expected 'diff_type' key in JSON entry") + t.Error("expected 'DiffType' key in JSON entry") } }) diff --git a/internal/storage/dolt/versioned.go b/internal/storage/dolt/versioned.go index db2c03fa6..ed6ecde27 100644 --- a/internal/storage/dolt/versioned.go +++ b/internal/storage/dolt/versioned.go @@ -16,7 +16,10 @@ func (s *DoltStore) History(ctx context.Context, issueID string) ([]*storage.His err := s.withReadTx(ctx, func(tx *sql.Tx) error { var err error result, err = issueops.HistoryInTx(ctx, tx, issueID) - return err + if err != nil { + return wrapQueryError("get issue history", err) + } + return nil }) return result, err } diff --git a/internal/storage/issueops/stale.go b/internal/storage/issueops/stale.go index da8265815..7f707ac64 100644 --- a/internal/storage/issueops/stale.go +++ b/internal/storage/issueops/stale.go @@ -12,6 +12,7 @@ import ( // GetStaleIssuesInTx returns issues that haven't been updated within the // given number of days. Only non-ephemeral issues are considered. When // filter.Status is empty, open and in_progress issues are returned. +// Results are ordered by updated_at ascending (stalest first). // // nolint:gosec // G201: statusClause contains only literal SQL or a single ? placeholder func GetStaleIssuesInTx(ctx context.Context, tx *sql.Tx, filter types.StaleFilter) ([]*types.Issue, error) { @@ -42,24 +43,49 @@ func GetStaleIssuesInTx(ctx context.Context, tx *sql.Tx, filter types.StaleFilte if err != nil { return nil, fmt.Errorf("failed to get stale issues: %w", err) } - defer rows.Close() // Collect IDs first, then batch-fetch full issues. + // Close rows explicitly before the nested fetch — MySQL/Dolt drivers + // can't handle multiple active result sets on one connection. var ids []string for rows.Next() { var id string if err := rows.Scan(&id); err != nil { + rows.Close() return nil, fmt.Errorf("failed to scan stale issue id: %w", err) } ids = append(ids, id) } if err := rows.Err(); err != nil { + rows.Close() return nil, fmt.Errorf("stale issues rows: %w", err) } + rows.Close() if len(ids) == 0 { return nil, nil } - return GetIssuesByIDsInTx(ctx, tx, ids) + // GetIssuesByIDsInTx returns issues in arbitrary order (WHERE IN), + // so re-order to preserve the updated_at ASC ordering from the query. + issues, err := GetIssuesByIDsInTx(ctx, tx, ids) + if err != nil { + return nil, err + } + + issueByID := make(map[string]*types.Issue, len(issues)) + for _, iss := range issues { + if iss != nil { + issueByID[iss.ID] = iss + } + } + + ordered := make([]*types.Issue, 0, len(ids)) + for _, id := range ids { + if iss, ok := issueByID[id]; ok { + ordered = append(ordered, iss) + } + } + + return ordered, nil }