#6 feat(web): review page polish and home page ordered by last activity

@@ -0,0 +1,43 @@
	1	+	// SPDX-License-Identifier: AGPL-3.0-or-later
	2	+
	3	+	package usecase
	4	+
	5	+	import (
	6	+	"context"
	7	+	"errors"
	8	+	"fmt"
	9	+	"time"
	10	+
	11	+	"github.com/bnema/zerowrap"
	12	+
	13	+	"bnema.dev/ermite/internal/domain"
	14	+	"bnema.dev/ermite/internal/ports"
	15	+	)
	16	+
	17	+	// recordActivity is best-effort: a metadata failure never fails the action.
	18	+	func recordActivity(ctx context.Context, meta ports.RepoMetaStore, name domain.RepoName, at time.Time) {
	19	+	if _, err := touchActiveAt(ctx, meta, name, at); err != nil {
	20	+	log := zerowrap.FromCtx(ctx)
	21	+	log.Error().Err(err).Str("repo", name.String()).Msg("record repository activity")
	22	+	}
	23	+	}
	24	+
	25	+	// touchActiveAt preserves later activity and retries concurrent metadata writes.
	26	+	// A repository deleted meanwhile is not an error.
	27	+	func touchActiveAt(ctx context.Context, meta ports.RepoMetaStore, name domain.RepoName, now time.Time) (domain.Repo, error) {
	28	+	repo, err := meta.Mutate(ctx, name, func(repo *domain.Repo) (bool, error) {
	29	+	changed := false
	30	+	if now.After(repo.ActiveAt) {
	31	+	repo.ActiveAt = now
	32	+	changed = true
	33	+	}
	34	+	return changed, nil
	35	+	})
	36	+	if errors.Is(err, domain.ErrNotFound) {
	37	+	return domain.Repo{}, nil
	38	+	}
	39	+	if err != nil {
	40	+	return repo, fmt.Errorf("update repository %q: %w", name, err)
	41	+	}
	42	+	return repo, nil
	43	+	}

@@ -0,0 +1,43 @@
	1	+	// SPDX-License-Identifier: AGPL-3.0-or-later
	2	+
	3	+	package usecase
	4	+
	5	+	import (
	6	+	"context"
	7	+	"errors"
	8	+	"fmt"
	9	+	"time"
	10	+
	11	+	"github.com/bnema/zerowrap"
	12	+
	13	+	"bnema.dev/ermite/internal/domain"
	14	+	"bnema.dev/ermite/internal/ports"
	15	+	)
	16	+
	17	+	// recordActivity is best-effort: a metadata failure never fails the action.
	18	+	func recordActivity(ctx context.Context, meta ports.RepoMetaStore, name domain.RepoName, at time.Time) {
	19	+	if _, err := touchActiveAt(ctx, meta, name, at); err != nil {
	20	+	log := zerowrap.FromCtx(ctx)
	21	+	log.Error().Err(err).Str("repo", name.String()).Msg("record repository activity")
	22	+	}
	23	+	}
	24	+
	25	+	// touchActiveAt preserves later activity and retries concurrent metadata writes.
	26	+	// A repository deleted meanwhile is not an error.
	27	+	func touchActiveAt(ctx context.Context, meta ports.RepoMetaStore, name domain.RepoName, now time.Time) (domain.Repo, error) {
	28	+	repo, err := meta.Mutate(ctx, name, func(repo *domain.Repo) (bool, error) {
	29	+	changed := false
	30	+	if now.After(repo.ActiveAt) {
	31	+	repo.ActiveAt = now
	32	+	changed = true
	33	+	}
	34	+	return changed, nil
	35	+	})
	36	+	if errors.Is(err, domain.ErrNotFound) {
	37	+	return domain.Repo{}, nil
	38	+	}
	39	+	if err != nil {
	40	+	return repo, fmt.Errorf("update repository %q: %w", name, err)
	41	+	}
	42	+	return repo, nil
	43	+	}

A internal/usecase/activity_store_test.go +46 -0

@@ -0,0 +1,46 @@
	1	+	// SPDX-License-Identifier: AGPL-3.0-or-later
	2	+
	3	+	package usecase_test
	4	+
	5	+	import (
	6	+	"testing"
	7	+	"time"
	8	+
	9	+	"github.com/stretchr/testify/require"
	10	+
	11	+	"bnema.dev/ermite/internal/adapters/kvstore"
	12	+	"bnema.dev/ermite/internal/domain"
	13	+	"bnema.dev/ermite/internal/usecase"
	14	+	)
	15	+
	16	+	func TestActivityTimestampsOverStore(t *testing.T) {
	17	+	ctx := t.Context()
	18	+	s, err := kvstore.Open(ctx, t.TempDir())
	19	+	require.NoError(t, err)
	20	+	t.Cleanup(func() { require.NoError(t, s.Close(ctx)) })
	21	+	n, err := domain.ParseRepoName("proj")
	22	+	require.NoError(t, err)
	23	+	at := time.Date(2026, 10, 19, 12, 0, 0, 0, time.UTC)
	24	+	require.NoError(t, s.Create(ctx, domain.Repo{Name: n, Visibility: domain.VisibilityPrivate, CreatedAt: at}))
	25	+	got, err := usecase.TouchPushedAt(ctx, s, n, at.Add(time.Hour))
	26	+	require.NoError(t, err)
	27	+	require.Equal(t, got.PushedAt, got.ActiveAt)
	28	+	_, err = usecase.TouchActiveAt(ctx, s, n, at.Add(3*time.Hour))
	29	+	require.NoError(t, err)
	30	+	_, err = usecase.TouchPushedAt(ctx, s, n, at.Add(2*time.Hour))
	31	+	require.NoError(t, err)
	32	+	_, err = usecase.TouchPushedAt(ctx, s, n, at)
	33	+	require.NoError(t, err)
	34	+	_, err = usecase.TouchActiveAt(ctx, s, n, at)
	35	+	require.NoError(t, err)
	36	+	got, err = s.Get(ctx, n)
	37	+	require.NoError(t, err)
	38	+	require.Equal(t, at.Add(2*time.Hour), got.PushedAt)
	39	+	require.Equal(t, at.Add(3*time.Hour), got.ActiveAt)
	40	+	require.Equal(t, domain.VisibilityPrivate, got.Visibility)
	41	+	require.NoError(t, s.Delete(ctx, n))
	42	+	_, err = usecase.TouchPushedAt(ctx, s, n, at)
	43	+	require.NoError(t, err)
	44	+	_, err = usecase.TouchActiveAt(ctx, s, n, at)
	45	+	require.NoError(t, err)
	46	+	}

@@ -0,0 +1,46 @@
	1	+	// SPDX-License-Identifier: AGPL-3.0-or-later
	2	+
	3	+	package usecase_test
	4	+
	5	+	import (
	6	+	"testing"
	7	+	"time"
	8	+
	9	+	"github.com/stretchr/testify/require"
	10	+
	11	+	"bnema.dev/ermite/internal/adapters/kvstore"
	12	+	"bnema.dev/ermite/internal/domain"
	13	+	"bnema.dev/ermite/internal/usecase"
	14	+	)
	15	+
	16	+	func TestActivityTimestampsOverStore(t *testing.T) {
	17	+	ctx := t.Context()
	18	+	s, err := kvstore.Open(ctx, t.TempDir())
	19	+	require.NoError(t, err)
	20	+	t.Cleanup(func() { require.NoError(t, s.Close(ctx)) })
	21	+	n, err := domain.ParseRepoName("proj")
	22	+	require.NoError(t, err)
	23	+	at := time.Date(2026, 10, 19, 12, 0, 0, 0, time.UTC)
	24	+	require.NoError(t, s.Create(ctx, domain.Repo{Name: n, Visibility: domain.VisibilityPrivate, CreatedAt: at}))
	25	+	got, err := usecase.TouchPushedAt(ctx, s, n, at.Add(time.Hour))
	26	+	require.NoError(t, err)
	27	+	require.Equal(t, got.PushedAt, got.ActiveAt)
	28	+	_, err = usecase.TouchActiveAt(ctx, s, n, at.Add(3*time.Hour))
	29	+	require.NoError(t, err)
	30	+	_, err = usecase.TouchPushedAt(ctx, s, n, at.Add(2*time.Hour))
	31	+	require.NoError(t, err)
	32	+	_, err = usecase.TouchPushedAt(ctx, s, n, at)
	33	+	require.NoError(t, err)
	34	+	_, err = usecase.TouchActiveAt(ctx, s, n, at)
	35	+	require.NoError(t, err)
	36	+	got, err = s.Get(ctx, n)
	37	+	require.NoError(t, err)
	38	+	require.Equal(t, at.Add(2*time.Hour), got.PushedAt)
	39	+	require.Equal(t, at.Add(3*time.Hour), got.ActiveAt)
	40	+	require.Equal(t, domain.VisibilityPrivate, got.Visibility)
	41	+	require.NoError(t, s.Delete(ctx, n))
	42	+	_, err = usecase.TouchPushedAt(ctx, s, n, at)
	43	+	require.NoError(t, err)
	44	+	_, err = usecase.TouchActiveAt(ctx, s, n, at)
	45	+	require.NoError(t, err)
	46	+	}

A internal/usecase/activity_test.go +47 -0

@@ -0,0 +1,47 @@
	1	+	// SPDX-License-Identifier: AGPL-3.0-or-later
	2	+
	3	+	package usecase
	4	+
	5	+	import (
	6	+	"context"
	7	+	"errors"
	8	+	"testing"
	9	+	"time"
	10	+
	11	+	"github.com/stretchr/testify/mock"
	12	+	"github.com/stretchr/testify/require"
	13	+
	14	+	"bnema.dev/ermite/internal/domain"
	15	+	"bnema.dev/ermite/internal/ports/mocks"
	16	+	)
	17	+
	18	+	func TestTouchActiveAt(t *testing.T) {
	19	+	name, err := domain.ParseRepoName("proj")
	20	+	require.NoError(t, err)
	21	+	now := time.Now().UTC()
	22	+	t.Run("preserves later activity", func(t *testing.T) {
	23	+	meta := mocks.NewRepoMetaStore(t)
	24	+	later := domain.Repo{Name: name, ActiveAt: now.Add(time.Hour)}
	25	+	meta.EXPECT().Mutate(mock.Anything, name, mock.Anything).RunAndReturn(func(_ context.Context, _ domain.RepoName, fn func(*domain.Repo) (bool, error)) (domain.Repo, error) {
	26	+	repo := later
	27	+	changed, err := fn(&repo)
	28	+	require.NoError(t, err)
	29	+	require.False(t, changed)
	30	+	return repo, nil
	31	+	})
	32	+	got, err := touchActiveAt(t.Context(), meta, name, now)
	33	+	require.NoError(t, err)
	34	+	require.Equal(t, later, got)
	35	+	})
	36	+	t.Run("deleted repository", func(t *testing.T) {
	37	+	meta := mocks.NewRepoMetaStore(t)
	38	+	meta.EXPECT().Mutate(mock.Anything, name, mock.Anything).Return(domain.Repo{}, domain.ErrNotFound)
	39	+	_, err := touchActiveAt(t.Context(), meta, name, now)
	40	+	require.NoError(t, err)
	41	+	})
	42	+	t.Run("best effort failure", func(t *testing.T) {
	43	+	meta := mocks.NewRepoMetaStore(t)
	44	+	meta.EXPECT().Mutate(mock.Anything, name, mock.Anything).Return(domain.Repo{}, errors.New("offline"))
	45	+	require.NotPanics(t, func() { recordActivity(t.Context(), meta, name, now) })
	46	+	})
	47	+	}

@@ -0,0 +1,47 @@
	1	+	// SPDX-License-Identifier: AGPL-3.0-or-later
	2	+
	3	+	package usecase
	4	+
	5	+	import (
	6	+	"context"
	7	+	"errors"
	8	+	"testing"
	9	+	"time"
	10	+
	11	+	"github.com/stretchr/testify/mock"
	12	+	"github.com/stretchr/testify/require"
	13	+
	14	+	"bnema.dev/ermite/internal/domain"
	15	+	"bnema.dev/ermite/internal/ports/mocks"
	16	+	)
	17	+
	18	+	func TestTouchActiveAt(t *testing.T) {
	19	+	name, err := domain.ParseRepoName("proj")
	20	+	require.NoError(t, err)
	21	+	now := time.Now().UTC()
	22	+	t.Run("preserves later activity", func(t *testing.T) {
	23	+	meta := mocks.NewRepoMetaStore(t)
	24	+	later := domain.Repo{Name: name, ActiveAt: now.Add(time.Hour)}
	25	+	meta.EXPECT().Mutate(mock.Anything, name, mock.Anything).RunAndReturn(func(_ context.Context, _ domain.RepoName, fn func(*domain.Repo) (bool, error)) (domain.Repo, error) {
	26	+	repo := later
	27	+	changed, err := fn(&repo)
	28	+	require.NoError(t, err)
	29	+	require.False(t, changed)
	30	+	return repo, nil
	31	+	})
	32	+	got, err := touchActiveAt(t.Context(), meta, name, now)
	33	+	require.NoError(t, err)
	34	+	require.Equal(t, later, got)
	35	+	})
	36	+	t.Run("deleted repository", func(t *testing.T) {
	37	+	meta := mocks.NewRepoMetaStore(t)
	38	+	meta.EXPECT().Mutate(mock.Anything, name, mock.Anything).Return(domain.Repo{}, domain.ErrNotFound)
	39	+	_, err := touchActiveAt(t.Context(), meta, name, now)
	40	+	require.NoError(t, err)
	41	+	})
	42	+	t.Run("best effort failure", func(t *testing.T) {
	43	+	meta := mocks.NewRepoMetaStore(t)
	44	+	meta.EXPECT().Mutate(mock.Anything, name, mock.Anything).Return(domain.Repo{}, errors.New("offline"))
	45	+	require.NotPanics(t, func() { recordActivity(t.Context(), meta, name, now) })
	46	+	})
	47	+	}

M internal/usecase/export_test.go +10 -0


@@ -19,6 +19,16 @@ import (
19	19		// Sweep exposes the daily sweep to the tests.
20	20		func (c *CI) Sweep(ctx context.Context) { c.sweep(ctx) }
21	21
	22	+	// TouchPushedAt exposes touchPushedAt to the tests.
	23	+	func TouchPushedAt(ctx context.Context, meta ports.RepoMetaStore, name domain.RepoName, now time.Time) (domain.Repo, error) {
	24	+	return touchPushedAt(ctx, meta, name, now)
	25	+	}
	26	+
	27	+	// TouchActiveAt exposes touchActiveAt to the tests.
	28	+	func TouchActiveAt(ctx context.Context, meta ports.RepoMetaStore, name domain.RepoName, now time.Time) (domain.Repo, error) {
	29	+	return touchActiveAt(ctx, meta, name, now)
	30	+	}
	31	+
22	32		// RunTitle gives the title of a run as startRun sets it: the evaluated
23	33		// run-name, else commitTitle.
24	34		func (c CI) RunTitle(ctx context.Context, wf workflow.Workflow, githubJSON, commitTitle string) string {


@@ -19,6 +19,16 @@ import (
19	// Sweep exposes the daily sweep to the tests.	19		// Sweep exposes the daily sweep to the tests.
20	func (c *CI) Sweep(ctx context.Context) { c.sweep(ctx) }	20		func (c *CI) Sweep(ctx context.Context) { c.sweep(ctx) }
21		21
		22	+	// TouchPushedAt exposes touchPushedAt to the tests.
		23	+	func TouchPushedAt(ctx context.Context, meta ports.RepoMetaStore, name domain.RepoName, now time.Time) (domain.Repo, error) {
		24	+	return touchPushedAt(ctx, meta, name, now)
		25	+	}
		26	+
		27	+	// TouchActiveAt exposes touchActiveAt to the tests.
		28	+	func TouchActiveAt(ctx context.Context, meta ports.RepoMetaStore, name domain.RepoName, now time.Time) (domain.Repo, error) {
		29	+	return touchActiveAt(ctx, meta, name, now)
		30	+	}
		31	+
22	// RunTitle gives the title of a run as startRun sets it: the evaluated	32		// RunTitle gives the title of a run as startRun sets it: the evaluated
23	// run-name, else commitTitle.	33		// run-name, else commitTitle.
24	func (c CI) RunTitle(ctx context.Context, wf workflow.Workflow, githubJSON, commitTitle string) string {	34		func (c CI) RunTitle(ctx context.Context, wf workflow.Workflow, githubJSON, commitTitle string) string {

M internal/usecase/issue_moderation.go +1 -0


@@ -85,6 +85,7 @@ func (m *IssueModeration) Approve(ctx context.Context, p domain.Principal, repo
85	85		log := zerowrap.FromCtx(ctx)
86	86		log.Info().Str("repo", repo.String()).Int64("number", issue.Number).
87	87		Str("principal", p.Label()).Str("token_id", p.TokenID()).Msg("pending issue approved")
	88	+	recordActivity(ctx, m.meta, repo, now)
88	89		m.bus.Publish(ctx, domain.IssueOpened{Issue: issue, At: now, Visibility: r.Visibility, CreatedAt: r.CreatedAt})
89	90		return issue, nil
90	91		}


@@ -85,6 +85,7 @@ func (m *IssueModeration) Approve(ctx context.Context, p domain.Principal, repo
85	log := zerowrap.FromCtx(ctx)	85		log := zerowrap.FromCtx(ctx)
86	log.Info().Str("repo", repo.String()).Int64("number", issue.Number).	86		log.Info().Str("repo", repo.String()).Int64("number", issue.Number).
87	Str("principal", p.Label()).Str("token_id", p.TokenID()).Msg("pending issue approved")	87		Str("principal", p.Label()).Str("token_id", p.TokenID()).Msg("pending issue approved")
		88	+	recordActivity(ctx, m.meta, repo, now)
88	m.bus.Publish(ctx, domain.IssueOpened{Issue: issue, At: now, Visibility: r.Visibility, CreatedAt: r.CreatedAt})	89		m.bus.Publish(ctx, domain.IssueOpened{Issue: issue, At: now, Visibility: r.Visibility, CreatedAt: r.CreatedAt})
89	return issue, nil	90		return issue, nil
90	}	91		}

M internal/usecase/issue_moderation_test.go +1 -0


@@ -89,6 +89,7 @@ func TestIssueModerationApprove(t *testing.T) {
89	89		u := newModerationUnit(t, domain.IssuesPublic)
90	90		issue := domain.Issue{Repo: u.repo.Name, Number: 7, State: domain.IssueStateOpen}
91	91		u.pending.EXPECT().Approve(mock.Anything, u.repo.Name, u.id, now).Return(issue, nil).Once()
	92	+	expectRepoMutation(t, u.meta, u.repo, mock.MatchedBy(func(r domain.Repo) bool { return r.ActiveAt.Equal(now) })).Once()
92	93		u.bus.EXPECT().Publish(mock.Anything, domain.IssueOpened{Issue: issue, At: now, Visibility: u.repo.Visibility, CreatedAt: u.repo.CreatedAt}).Once()
93	94		got, err := u.mod.Approve(ctx, domain.Owner(), u.repo.Name, u.id)
94	95		require.NoError(t, err)


@@ -89,6 +89,7 @@ func TestIssueModerationApprove(t *testing.T) {
89	u := newModerationUnit(t, domain.IssuesPublic)	89		u := newModerationUnit(t, domain.IssuesPublic)
90	issue := domain.Issue{Repo: u.repo.Name, Number: 7, State: domain.IssueStateOpen}	90		issue := domain.Issue{Repo: u.repo.Name, Number: 7, State: domain.IssueStateOpen}
91	u.pending.EXPECT().Approve(mock.Anything, u.repo.Name, u.id, now).Return(issue, nil).Once()	91		u.pending.EXPECT().Approve(mock.Anything, u.repo.Name, u.id, now).Return(issue, nil).Once()
		92	+	expectRepoMutation(t, u.meta, u.repo, mock.MatchedBy(func(r domain.Repo) bool { return r.ActiveAt.Equal(now) })).Once()
92	u.bus.EXPECT().Publish(mock.Anything, domain.IssueOpened{Issue: issue, At: now, Visibility: u.repo.Visibility, CreatedAt: u.repo.CreatedAt}).Once()	93		u.bus.EXPECT().Publish(mock.Anything, domain.IssueOpened{Issue: issue, At: now, Visibility: u.repo.Visibility, CreatedAt: u.repo.CreatedAt}).Once()
93	got, err := u.mod.Approve(ctx, domain.Owner(), u.repo.Name, u.id)	94		got, err := u.mod.Approve(ctx, domain.Owner(), u.repo.Name, u.id)
94	require.NoError(t, err)	95		require.NoError(t, err)

M internal/usecase/issues.go +3 -0


@@ -124,6 +124,7 @@ func (i *Issues) Create(ctx context.Context, p domain.Principal, name domain.Rep
124	124		log := zerowrap.FromCtx(ctx)
125	125		log.Info().Str("repo", name.String()).Int64("number", issue.Number).
126	126		Str("principal", p.Label()).Str("token_id", p.TokenID()).Msg("issue opened")
	127	+	recordActivity(ctx, i.meta, repo.Name, now)
127	128		i.bus.Publish(ctx, domain.IssueOpened{Issue: issue, At: now, Visibility: repo.Visibility, CreatedAt: repo.CreatedAt})
128	129		return issue, nil
129	130		}

@@ -211,6 +212,7 @@ func (i *Issues) AddComment(ctx context.Context, p domain.Principal, name domain
211	212		log := zerowrap.FromCtx(ctx)
212	213		log.Info().Str("repo", name.String()).Int64("number", number).Int64("comment", c.ID).
213	214		Str("principal", p.Label()).Str("token_id", p.TokenID()).Msg("issue comment added")
	215	+	recordActivity(ctx, i.meta, name, c.CreatedAt)
214	216		i.bus.Publish(ctx, domain.IssueCommented{
215	217		Repo: name, Number: number, Comment: c, At: c.CreatedAt, Visibility: repo.Visibility, CreatedAt: repo.CreatedAt,
216	218		})

@@ -260,6 +262,7 @@ func (i *Issues) transition(ctx context.Context, p domain.Principal, name domain
260	262		log := zerowrap.FromCtx(ctx)
261	263		log.Info().Str("repo", name.String()).Int64("number", number).
262	264		Str("principal", p.Label()).Str("token_id", p.TokenID()).Msg("issue " + verb + "d")
	265	+	recordActivity(ctx, i.meta, repo.Name, issue.UpdatedAt)
263	266		if to == domain.IssueStateOpen {
264	267		i.bus.Publish(ctx, domain.IssueReopened{Issue: issue, At: issue.UpdatedAt, Visibility: repo.Visibility, CreatedAt: repo.CreatedAt})
265	268		} else {


@@ -124,6 +124,7 @@ func (i *Issues) Create(ctx context.Context, p domain.Principal, name domain.Rep
124	log := zerowrap.FromCtx(ctx)	124		log := zerowrap.FromCtx(ctx)
125	log.Info().Str("repo", name.String()).Int64("number", issue.Number).	125		log.Info().Str("repo", name.String()).Int64("number", issue.Number).
126	Str("principal", p.Label()).Str("token_id", p.TokenID()).Msg("issue opened")	126		Str("principal", p.Label()).Str("token_id", p.TokenID()).Msg("issue opened")
		127	+	recordActivity(ctx, i.meta, repo.Name, now)
127	i.bus.Publish(ctx, domain.IssueOpened{Issue: issue, At: now, Visibility: repo.Visibility, CreatedAt: repo.CreatedAt})	128		i.bus.Publish(ctx, domain.IssueOpened{Issue: issue, At: now, Visibility: repo.Visibility, CreatedAt: repo.CreatedAt})
128	return issue, nil	129		return issue, nil
129	}	130		}

@@ -211,6 +212,7 @@ func (i *Issues) AddComment(ctx context.Context, p domain.Principal, name domain
211	log := zerowrap.FromCtx(ctx)	212		log := zerowrap.FromCtx(ctx)
212	log.Info().Str("repo", name.String()).Int64("number", number).Int64("comment", c.ID).	213		log.Info().Str("repo", name.String()).Int64("number", number).Int64("comment", c.ID).
213	Str("principal", p.Label()).Str("token_id", p.TokenID()).Msg("issue comment added")	214		Str("principal", p.Label()).Str("token_id", p.TokenID()).Msg("issue comment added")
		215	+	recordActivity(ctx, i.meta, name, c.CreatedAt)
214	i.bus.Publish(ctx, domain.IssueCommented{	216		i.bus.Publish(ctx, domain.IssueCommented{
215	Repo: name, Number: number, Comment: c, At: c.CreatedAt, Visibility: repo.Visibility, CreatedAt: repo.CreatedAt,	217		Repo: name, Number: number, Comment: c, At: c.CreatedAt, Visibility: repo.Visibility, CreatedAt: repo.CreatedAt,
216	})	218		})

@@ -260,6 +262,7 @@ func (i *Issues) transition(ctx context.Context, p domain.Principal, name domain
260	log := zerowrap.FromCtx(ctx)	262		log := zerowrap.FromCtx(ctx)
261	log.Info().Str("repo", name.String()).Int64("number", number).	263		log.Info().Str("repo", name.String()).Int64("number", number).
262	Str("principal", p.Label()).Str("token_id", p.TokenID()).Msg("issue " + verb + "d")	264		Str("principal", p.Label()).Str("token_id", p.TokenID()).Msg("issue " + verb + "d")
		265	+	recordActivity(ctx, i.meta, repo.Name, issue.UpdatedAt)
263	if to == domain.IssueStateOpen {	266		if to == domain.IssueStateOpen {
264	i.bus.Publish(ctx, domain.IssueReopened{Issue: issue, At: issue.UpdatedAt, Visibility: repo.Visibility, CreatedAt: repo.CreatedAt})	267		i.bus.Publish(ctx, domain.IssueReopened{Issue: issue, At: issue.UpdatedAt, Visibility: repo.Visibility, CreatedAt: repo.CreatedAt})
265	} else {	268		} else {

M internal/usecase/issues_integration_test.go +67 -0


@@ -6,14 +6,17 @@ import (
6	6		"context"
7	7		"path/filepath"
8	8		"testing"
	9	+	"time"
9	10
10	11		"github.com/stretchr/testify/assert"
	12	+	"github.com/stretchr/testify/mock"
11	13		"github.com/stretchr/testify/require"
12	14
13	15		"bnema.dev/ermite/internal/adapters/eventbus"
14	16		"bnema.dev/ermite/internal/adapters/kvstore"
15	17		"bnema.dev/ermite/internal/domain"
16	18		"bnema.dev/ermite/internal/ports"
	19	+	"bnema.dev/ermite/internal/ports/mocks"
17	20		"bnema.dev/ermite/internal/usecase"
18	21		)
19	22

@@ -46,6 +49,10 @@ func TestIssuesOverTheStore(t *testing.T) {
46	49		require.NoError(t, err)
47	50		assert.EqualValues(t, 2, issue.Number, "the number follows the merge request")
48	51		assert.Equal(t, "bot", issue.Author)
	52	+	repo, err := store.Get(ctx, n)
	53	+	require.NoError(t, err)
	54	+	assert.True(t, repo.ActiveAt.Equal(now))
	55	+	assert.True(t, repo.PushedAt.IsZero())
49	56
50	57		kind, err := issues.Kind(ctx, domain.Anonymous(), n, 1)
51	58		require.NoError(t, err)

@@ -85,3 +92,63 @@ func TestIssuesOverTheStore(t *testing.T) {
85	92		}
86	93		assert.Equal(t, []string{"issue.opened", "issue.commented", "issue.closed", "issue.commented", "issue.reopened"}, kinds)
87	94		}
	95	+
	96	+	// Moderated submissions are private work until approval makes them public activity.
	97	+	func TestModeratedIssueActivityOverStore(t *testing.T) {
	98	+	ctx := t.Context()
	99	+	store, err := kvstore.Open(ctx, t.TempDir())
	100	+	require.NoError(t, err)
	101	+	t.Cleanup(func() { require.NoError(t, store.Close(ctx)) })
	102	+	n := name(t, "proj")
	103	+	initial := now.Add(-time.Hour)
	104	+	require.NoError(t, store.Create(ctx, domain.Repo{Name: n, Visibility: domain.VisibilityPublic, CreatedAt: initial, ActiveAt: initial, Settings: withIssues(domain.IssuesPublic)}))
	105	+	clock := mocks.NewClock(t)
	106	+	at := now
	107	+	clock.EXPECT().Now().RunAndReturn(func() time.Time { return at }).Maybe()
	108	+	keys, err := usecase.NewIssueKeys(ctx, store.IssueKeys())
	109	+	require.NoError(t, err)
	110	+	limiter := mocks.NewSubmissionLimiter(t)
	111	+	limiter.EXPECT().Recent(mock.Anything, mock.Anything).Return(0, 0).Maybe()
	112	+	limiter.EXPECT().Reserve(mock.Anything, mock.Anything).Return(true, time.Duration(0), func() {}).Maybe()
	113	+	bus := mocks.NewEventBus(t)
	114	+	var kinds []string
	115	+	bus.EXPECT().Publish(mock.Anything, mock.Anything).Run(func(_ context.Context, ev domain.Event) {
	116	+	repo, err := store.Get(ctx, n)
	117	+	require.NoError(t, err)
	118	+	if ev.EventKind() == "issue.opened" {
	119	+	require.Equal(t, at, repo.ActiveAt)
	120	+	} else {
	121	+	require.Equal(t, initial, repo.ActiveAt)
	122	+	}
	123	+	kinds = append(kinds, ev.EventKind())
	124	+	}).Maybe()
	125	+	submissions := usecase.NewIssueSubmissions(usecase.IssueSubmissionsConfig{Meta: store, Pending: store.PendingIssues(), Bans: store.IssueBans(), Limiter: limiter, Keys: keys, Bus: bus, Clock: clock, BaseDifficulty: testBits, MaxDifficulty: testBits})
	126	+	moderation := usecase.NewIssueModeration(usecase.IssueModerationConfig{Meta: store, Pending: store.PendingIssues(), Bans: store.IssueBans(), Bus: bus, Clock: clock})
	127	+	submit := func() domain.PendingIssueID {
	128	+	ch, err := submissions.Challenge(ctx, n, "client")
	129	+	require.NoError(t, err)
	130	+	sub := ports.IssueSubmission{Token: ch.Token, FormToken: ch.FormToken, Solution: solve(t, ch), Title: "Bug", Body: "Details"}
	131	+	at = at.Add(usecase.MinFillTime)
	132	+	require.NoError(t, submissions.Submit(ctx, n, "client", sub))
	133	+	repo, err := store.Get(ctx, n)
	134	+	require.NoError(t, err)
	135	+	require.Equal(t, initial, repo.ActiveAt)
	136	+	page, err := store.PendingIssues().List(ctx, n, ports.ListPendingParams{PageSize: 10})
	137	+	require.NoError(t, err)
	138	+	require.Len(t, page.Issues, 1)
	139	+	return page.Issues[0].ID
	140	+	}
	141	+	id := submit()
	142	+	require.NoError(t, moderation.Reject(ctx, domain.Owner(), n, id, false))
	143	+	repo, err := store.Get(ctx, n)
	144	+	require.NoError(t, err)
	145	+	require.Equal(t, initial, repo.ActiveAt)
	146	+	id = submit()
	147	+	_, err = moderation.Approve(ctx, domain.Owner(), n, id)
	148	+	require.NoError(t, err)
	149	+	repo, err = store.Get(ctx, n)
	150	+	require.NoError(t, err)
	151	+	require.Equal(t, at, repo.ActiveAt)
	152	+	require.True(t, repo.PushedAt.IsZero())
	153	+	require.Equal(t, []string{"issue.submitted", "issue.pending_removed", "issue.submitted", "issue.opened"}, kinds)
	154	+	}


@@ -6,14 +6,17 @@ import (
6	"context"	6		"context"
7	"path/filepath"	7		"path/filepath"
8	"testing"	8		"testing"
		9	+	"time"
9		10
10	"github.com/stretchr/testify/assert"	11		"github.com/stretchr/testify/assert"
		12	+	"github.com/stretchr/testify/mock"
11	"github.com/stretchr/testify/require"	13		"github.com/stretchr/testify/require"
12		14
13	"bnema.dev/ermite/internal/adapters/eventbus"	15		"bnema.dev/ermite/internal/adapters/eventbus"
14	"bnema.dev/ermite/internal/adapters/kvstore"	16		"bnema.dev/ermite/internal/adapters/kvstore"
15	"bnema.dev/ermite/internal/domain"	17		"bnema.dev/ermite/internal/domain"
16	"bnema.dev/ermite/internal/ports"	18		"bnema.dev/ermite/internal/ports"
		19	+	"bnema.dev/ermite/internal/ports/mocks"
17	"bnema.dev/ermite/internal/usecase"	20		"bnema.dev/ermite/internal/usecase"
18	)	21		)
19		22

@@ -46,6 +49,10 @@ func TestIssuesOverTheStore(t *testing.T) {
46	require.NoError(t, err)	49		require.NoError(t, err)
47	assert.EqualValues(t, 2, issue.Number, "the number follows the merge request")	50		assert.EqualValues(t, 2, issue.Number, "the number follows the merge request")
48	assert.Equal(t, "bot", issue.Author)	51		assert.Equal(t, "bot", issue.Author)
		52	+	repo, err := store.Get(ctx, n)
		53	+	require.NoError(t, err)
		54	+	assert.True(t, repo.ActiveAt.Equal(now))
		55	+	assert.True(t, repo.PushedAt.IsZero())
49		56
50	kind, err := issues.Kind(ctx, domain.Anonymous(), n, 1)	57		kind, err := issues.Kind(ctx, domain.Anonymous(), n, 1)
51	require.NoError(t, err)	58		require.NoError(t, err)

@@ -85,3 +92,63 @@ func TestIssuesOverTheStore(t *testing.T) {
85	}	92		}
86	assert.Equal(t, []string{"issue.opened", "issue.commented", "issue.closed", "issue.commented", "issue.reopened"}, kinds)	93		assert.Equal(t, []string{"issue.opened", "issue.commented", "issue.closed", "issue.commented", "issue.reopened"}, kinds)
87	}	94		}
		95	+
		96	+	// Moderated submissions are private work until approval makes them public activity.
		97	+	func TestModeratedIssueActivityOverStore(t *testing.T) {
		98	+	ctx := t.Context()
		99	+	store, err := kvstore.Open(ctx, t.TempDir())
		100	+	require.NoError(t, err)
		101	+	t.Cleanup(func() { require.NoError(t, store.Close(ctx)) })
		102	+	n := name(t, "proj")
		103	+	initial := now.Add(-time.Hour)
		104	+	require.NoError(t, store.Create(ctx, domain.Repo{Name: n, Visibility: domain.VisibilityPublic, CreatedAt: initial, ActiveAt: initial, Settings: withIssues(domain.IssuesPublic)}))
		105	+	clock := mocks.NewClock(t)
		106	+	at := now
		107	+	clock.EXPECT().Now().RunAndReturn(func() time.Time { return at }).Maybe()
		108	+	keys, err := usecase.NewIssueKeys(ctx, store.IssueKeys())
		109	+	require.NoError(t, err)
		110	+	limiter := mocks.NewSubmissionLimiter(t)
		111	+	limiter.EXPECT().Recent(mock.Anything, mock.Anything).Return(0, 0).Maybe()
		112	+	limiter.EXPECT().Reserve(mock.Anything, mock.Anything).Return(true, time.Duration(0), func() {}).Maybe()
		113	+	bus := mocks.NewEventBus(t)
		114	+	var kinds []string
		115	+	bus.EXPECT().Publish(mock.Anything, mock.Anything).Run(func(_ context.Context, ev domain.Event) {
		116	+	repo, err := store.Get(ctx, n)
		117	+	require.NoError(t, err)
		118	+	if ev.EventKind() == "issue.opened" {
		119	+	require.Equal(t, at, repo.ActiveAt)
		120	+	} else {
		121	+	require.Equal(t, initial, repo.ActiveAt)
		122	+	}
		123	+	kinds = append(kinds, ev.EventKind())
		124	+	}).Maybe()
		125	+	submissions := usecase.NewIssueSubmissions(usecase.IssueSubmissionsConfig{Meta: store, Pending: store.PendingIssues(), Bans: store.IssueBans(), Limiter: limiter, Keys: keys, Bus: bus, Clock: clock, BaseDifficulty: testBits, MaxDifficulty: testBits})
		126	+	moderation := usecase.NewIssueModeration(usecase.IssueModerationConfig{Meta: store, Pending: store.PendingIssues(), Bans: store.IssueBans(), Bus: bus, Clock: clock})
		127	+	submit := func() domain.PendingIssueID {
		128	+	ch, err := submissions.Challenge(ctx, n, "client")
		129	+	require.NoError(t, err)
		130	+	sub := ports.IssueSubmission{Token: ch.Token, FormToken: ch.FormToken, Solution: solve(t, ch), Title: "Bug", Body: "Details"}
		131	+	at = at.Add(usecase.MinFillTime)
		132	+	require.NoError(t, submissions.Submit(ctx, n, "client", sub))
		133	+	repo, err := store.Get(ctx, n)
		134	+	require.NoError(t, err)
		135	+	require.Equal(t, initial, repo.ActiveAt)
		136	+	page, err := store.PendingIssues().List(ctx, n, ports.ListPendingParams{PageSize: 10})
		137	+	require.NoError(t, err)
		138	+	require.Len(t, page.Issues, 1)
		139	+	return page.Issues[0].ID
		140	+	}
		141	+	id := submit()
		142	+	require.NoError(t, moderation.Reject(ctx, domain.Owner(), n, id, false))
		143	+	repo, err := store.Get(ctx, n)
		144	+	require.NoError(t, err)
		145	+	require.Equal(t, initial, repo.ActiveAt)
		146	+	id = submit()
		147	+	_, err = moderation.Approve(ctx, domain.Owner(), n, id)
		148	+	require.NoError(t, err)
		149	+	repo, err = store.Get(ctx, n)
		150	+	require.NoError(t, err)
		151	+	require.Equal(t, at, repo.ActiveAt)
		152	+	require.True(t, repo.PushedAt.IsZero())
		153	+	require.Equal(t, []string{"issue.submitted", "issue.pending_removed", "issue.submitted", "issue.opened"}, kinds)
		154	+	}

M internal/usecase/issues_test.go +2 -0


@@ -39,6 +39,7 @@ func newIssueUnit(t testing.T, vis domain.Visibility, mode domain.IssuesMode)
39	39		clock := mocks.NewClock(t)
40	40		clock.EXPECT().Now().Return(now).Maybe()
41	41		u.meta.EXPECT().Get(mock.Anything, u.repo.Name).Return(u.repo, nil).Maybe()
	42	+	expectRepoMutation(t, u.meta, u.repo, mock.MatchedBy(func(r domain.Repo) bool { return r.ActiveAt.Equal(now) && r.PushedAt.IsZero() })).Maybe()
42	43		u.issues = usecase.NewIssues(usecase.IssuesConfig{Meta: u.meta, Store: u.store, MergeRequests: u.mrs, Bus: u.bus, Clock: clock})
43	44		return u
44	45		}

@@ -116,6 +117,7 @@ func TestIssueCreateAndTransitions(t *testing.T) {
116	117		got, err := u.issues.Create(ctx, p, u.repo.Name, ports.CreateIssueParams{Title: " Crash ", Body: "why"})
117	118		require.NoError(t, err)
118	119		assert.EqualValues(t, 7, got.Number)
	120	+	u.meta.AssertCalled(t, "Mutate", mock.Anything, u.repo.Name, mock.Anything)
119	121		})
120	122
121	123		t.Run("invalid text stores nothing", func(t *testing.T) {


@@ -39,6 +39,7 @@ func newIssueUnit(t testing.T, vis domain.Visibility, mode domain.IssuesMode)
39	clock := mocks.NewClock(t)	39		clock := mocks.NewClock(t)
40	clock.EXPECT().Now().Return(now).Maybe()	40		clock.EXPECT().Now().Return(now).Maybe()
41	u.meta.EXPECT().Get(mock.Anything, u.repo.Name).Return(u.repo, nil).Maybe()	41		u.meta.EXPECT().Get(mock.Anything, u.repo.Name).Return(u.repo, nil).Maybe()
		42	+	expectRepoMutation(t, u.meta, u.repo, mock.MatchedBy(func(r domain.Repo) bool { return r.ActiveAt.Equal(now) && r.PushedAt.IsZero() })).Maybe()
42	u.issues = usecase.NewIssues(usecase.IssuesConfig{Meta: u.meta, Store: u.store, MergeRequests: u.mrs, Bus: u.bus, Clock: clock})	43		u.issues = usecase.NewIssues(usecase.IssuesConfig{Meta: u.meta, Store: u.store, MergeRequests: u.mrs, Bus: u.bus, Clock: clock})
43	return u	44		return u
44	}	45		}

@@ -116,6 +117,7 @@ func TestIssueCreateAndTransitions(t *testing.T) {
116	got, err := u.issues.Create(ctx, p, u.repo.Name, ports.CreateIssueParams{Title: " Crash ", Body: "why"})	117		got, err := u.issues.Create(ctx, p, u.repo.Name, ports.CreateIssueParams{Title: " Crash ", Body: "why"})
117	require.NoError(t, err)	118		require.NoError(t, err)
118	assert.EqualValues(t, 7, got.Number)	119		assert.EqualValues(t, 7, got.Number)
		120	+	u.meta.AssertCalled(t, "Mutate", mock.Anything, u.repo.Name, mock.Anything)
119	})	121		})
120		122
121	t.Run("invalid text stores nothing", func(t *testing.T) {	123		t.Run("invalid text stores nothing", func(t *testing.T) {

M internal/usecase/mergerequests.go +5 -0


@@ -254,6 +254,7 @@ func (m *MergeRequests) Create(ctx context.Context, p domain.Principal, name dom
254	254		if err != nil {
255	255		return domain.MergeRequest{}, err
256	256		}
	257	+	recordActivity(ctx, m.meta, repo.Name, now)
257	258		m.bus.Publish(ctx, domain.MergeRequestOpened{MergeRequest: mr, At: now, Visibility: repo.Visibility, CreatedAt: repo.CreatedAt})
258	259		if m.pulls != nil {
259	260		// The commits the opening is for are the ones of now.

@@ -377,6 +378,7 @@ func (m *MergeRequests) MarkReady(ctx context.Context, p domain.Principal, name
377	378		if err != nil {
378	379		return domain.MergeRequest{}, fmt.Errorf("mark !%d of %q ready: %w", number, name, err)
379	380		}
	381	+	recordActivity(ctx, m.meta, repo.Name, mr.UpdatedAt)
380	382		m.bus.Publish(ctx, domain.MergeRequestReady{MergeRequest: mr, At: mr.UpdatedAt, Visibility: repo.Visibility, CreatedAt: repo.CreatedAt})
381	383		return m.withHead(ctx, mr)
382	384		}

@@ -656,6 +658,7 @@ func (m *MergeRequests) AddComment(ctx context.Context, p domain.Principal, name
656	658		log := zerowrap.FromCtx(ctx)
657	659		log.Info().Str("repo", name.String()).Int64("number", number).Int64("comment", c.ID).
658	660		Int64("reply_to", c.ReplyTo).Str("verdict", c.Verdict.String()).Bool("on_line", !general).Str("principal", p.Label()).Str("token_id", p.TokenID()).Msg("comment added")
	661	+	recordActivity(ctx, m.meta, name, c.CreatedAt)
659	662		m.bus.Publish(ctx, domain.CommentAdded{
660	663		Repo: name, Number: number, Comment: c, At: c.CreatedAt, Visibility: repo.Visibility, CreatedAt: repo.CreatedAt,
661	664		})

@@ -796,6 +799,7 @@ func (m *MergeRequests) Close(ctx context.Context, p domain.Principal, name doma
796	799		log := zerowrap.FromCtx(ctx)
797	800		log.Info().Str("repo", name.String()).Int64("number", number).
798	801		Str("principal", p.Label()).Str("token_id", p.TokenID()).Msg("merge request closed")
	802	+	recordActivity(ctx, m.meta, repo.Name, mr.UpdatedAt)
799	803		m.bus.Publish(ctx, domain.MergeRequestClosed{MergeRequest: mr, At: mr.UpdatedAt, Visibility: repo.Visibility, CreatedAt: repo.CreatedAt})
800	804		if m.pulls != nil {
801	805		m.pulls.OnPullRequest(ctx, name, ports.PullRequestEvent{Number: number, Action: domain.PullClosed, Head: mr.HeadID, Base: mr.BaseID}, p)

@@ -998,6 +1002,7 @@ func (m *MergeRequests) merge(ctx context.Context, p domain.Principal, name doma
998	1002		}
999	1003		}
1000	1004		at := mr.UpdatedAt
	1005	+	recordActivity(ctx, m.meta, repo.Name, at)
1001	1006		m.bus.Publish(ctx, domain.MergeRequestMerged{MergeRequest: mr, At: at, Visibility: repo.Visibility, CreatedAt: repo.CreatedAt})
1002	1007		m.bus.Publish(ctx, domain.PushEvent{
1003	1008		Repo: name, At: at, Visibility: repo.Visibility, CreatedAt: repo.CreatedAt, Updates: updates,


@@ -254,6 +254,7 @@ func (m *MergeRequests) Create(ctx context.Context, p domain.Principal, name dom
254	if err != nil {	254		if err != nil {
255	return domain.MergeRequest{}, err	255		return domain.MergeRequest{}, err
256	}	256		}
		257	+	recordActivity(ctx, m.meta, repo.Name, now)
257	m.bus.Publish(ctx, domain.MergeRequestOpened{MergeRequest: mr, At: now, Visibility: repo.Visibility, CreatedAt: repo.CreatedAt})	258		m.bus.Publish(ctx, domain.MergeRequestOpened{MergeRequest: mr, At: now, Visibility: repo.Visibility, CreatedAt: repo.CreatedAt})
258	if m.pulls != nil {	259		if m.pulls != nil {
259	// The commits the opening is for are the ones of now.	260		// The commits the opening is for are the ones of now.

@@ -377,6 +378,7 @@ func (m *MergeRequests) MarkReady(ctx context.Context, p domain.Principal, name
377	if err != nil {	378		if err != nil {
378	return domain.MergeRequest{}, fmt.Errorf("mark !%d of %q ready: %w", number, name, err)	379		return domain.MergeRequest{}, fmt.Errorf("mark !%d of %q ready: %w", number, name, err)
379	}	380		}
		381	+	recordActivity(ctx, m.meta, repo.Name, mr.UpdatedAt)
380	m.bus.Publish(ctx, domain.MergeRequestReady{MergeRequest: mr, At: mr.UpdatedAt, Visibility: repo.Visibility, CreatedAt: repo.CreatedAt})	382		m.bus.Publish(ctx, domain.MergeRequestReady{MergeRequest: mr, At: mr.UpdatedAt, Visibility: repo.Visibility, CreatedAt: repo.CreatedAt})
381	return m.withHead(ctx, mr)	383		return m.withHead(ctx, mr)
382	}	384		}

@@ -656,6 +658,7 @@ func (m *MergeRequests) AddComment(ctx context.Context, p domain.Principal, name
656	log := zerowrap.FromCtx(ctx)	658		log := zerowrap.FromCtx(ctx)
657	log.Info().Str("repo", name.String()).Int64("number", number).Int64("comment", c.ID).	659		log.Info().Str("repo", name.String()).Int64("number", number).Int64("comment", c.ID).
658	Int64("reply_to", c.ReplyTo).Str("verdict", c.Verdict.String()).Bool("on_line", !general).Str("principal", p.Label()).Str("token_id", p.TokenID()).Msg("comment added")	660		Int64("reply_to", c.ReplyTo).Str("verdict", c.Verdict.String()).Bool("on_line", !general).Str("principal", p.Label()).Str("token_id", p.TokenID()).Msg("comment added")
		661	+	recordActivity(ctx, m.meta, name, c.CreatedAt)
659	m.bus.Publish(ctx, domain.CommentAdded{	662		m.bus.Publish(ctx, domain.CommentAdded{
660	Repo: name, Number: number, Comment: c, At: c.CreatedAt, Visibility: repo.Visibility, CreatedAt: repo.CreatedAt,	663		Repo: name, Number: number, Comment: c, At: c.CreatedAt, Visibility: repo.Visibility, CreatedAt: repo.CreatedAt,
661	})	664		})

@@ -796,6 +799,7 @@ func (m *MergeRequests) Close(ctx context.Context, p domain.Principal, name doma
796	log := zerowrap.FromCtx(ctx)	799		log := zerowrap.FromCtx(ctx)
797	log.Info().Str("repo", name.String()).Int64("number", number).	800		log.Info().Str("repo", name.String()).Int64("number", number).
798	Str("principal", p.Label()).Str("token_id", p.TokenID()).Msg("merge request closed")	801		Str("principal", p.Label()).Str("token_id", p.TokenID()).Msg("merge request closed")
		802	+	recordActivity(ctx, m.meta, repo.Name, mr.UpdatedAt)
799	m.bus.Publish(ctx, domain.MergeRequestClosed{MergeRequest: mr, At: mr.UpdatedAt, Visibility: repo.Visibility, CreatedAt: repo.CreatedAt})	803		m.bus.Publish(ctx, domain.MergeRequestClosed{MergeRequest: mr, At: mr.UpdatedAt, Visibility: repo.Visibility, CreatedAt: repo.CreatedAt})
800	if m.pulls != nil {	804		if m.pulls != nil {
801	m.pulls.OnPullRequest(ctx, name, ports.PullRequestEvent{Number: number, Action: domain.PullClosed, Head: mr.HeadID, Base: mr.BaseID}, p)	805		m.pulls.OnPullRequest(ctx, name, ports.PullRequestEvent{Number: number, Action: domain.PullClosed, Head: mr.HeadID, Base: mr.BaseID}, p)

@@ -998,6 +1002,7 @@ func (m *MergeRequests) merge(ctx context.Context, p domain.Principal, name doma
998	}	1002		}
999	}	1003		}
1000	at := mr.UpdatedAt	1004		at := mr.UpdatedAt
		1005	+	recordActivity(ctx, m.meta, repo.Name, at)
1001	m.bus.Publish(ctx, domain.MergeRequestMerged{MergeRequest: mr, At: at, Visibility: repo.Visibility, CreatedAt: repo.CreatedAt})	1006		m.bus.Publish(ctx, domain.MergeRequestMerged{MergeRequest: mr, At: at, Visibility: repo.Visibility, CreatedAt: repo.CreatedAt})
1002	m.bus.Publish(ctx, domain.PushEvent{	1007		m.bus.Publish(ctx, domain.PushEvent{
1003	Repo: name, At: at, Visibility: repo.Visibility, CreatedAt: repo.CreatedAt, Updates: updates,	1008		Repo: name, At: at, Visibility: repo.Visibility, CreatedAt: repo.CreatedAt, Updates: updates,

M internal/usecase/mergerequests_integration_test.go +11 -0


@@ -1448,3 +1448,14 @@ func TestNoteThreadsRangesAndVerdicts(t *testing.T) {
1448	1448		_, err = r.mrs.DeleteComment(r.ctx, root, r.repo, mr.Number, changes.ID)
1449	1449		assert.ErrorIs(t, err, domain.ErrPreconditionFailed)
1450	1450		}
	1451	+
	1452	+	func TestMergeRequestRecordsRepositoryActivity(t *testing.T) {
	1453	+	r := newMRRig(t)
	1454	+	r.seed()
	1455	+	r.feature("activity")
	1456	+	_, err := r.mrs.Create(r.ctx, root, r.repo, ports.CreateMergeRequestParams{Title: "Activity", Source: "activity", Target: "main"})
	1457	+	require.NoError(t, err)
	1458	+	repo, err := r.store.Get(r.ctx, r.repo)
	1459	+	require.NoError(t, err)
	1460	+	assert.True(t, repo.ActiveAt.Equal(now))
	1461	+	}


@@ -1448,3 +1448,14 @@ func TestNoteThreadsRangesAndVerdicts(t *testing.T) {
1448	_, err = r.mrs.DeleteComment(r.ctx, root, r.repo, mr.Number, changes.ID)	1448		_, err = r.mrs.DeleteComment(r.ctx, root, r.repo, mr.Number, changes.ID)
1449	assert.ErrorIs(t, err, domain.ErrPreconditionFailed)	1449		assert.ErrorIs(t, err, domain.ErrPreconditionFailed)
1450	}	1450		}
		1451	+
		1452	+	func TestMergeRequestRecordsRepositoryActivity(t *testing.T) {
		1453	+	r := newMRRig(t)
		1454	+	r.seed()
		1455	+	r.feature("activity")
		1456	+	_, err := r.mrs.Create(r.ctx, root, r.repo, ports.CreateMergeRequestParams{Title: "Activity", Source: "activity", Target: "main"})
		1457	+	require.NoError(t, err)
		1458	+	repo, err := r.store.Get(r.ctx, r.repo)
		1459	+	require.NoError(t, err)
		1460	+	assert.True(t, repo.ActiveAt.Equal(now))
		1461	+	}

M internal/usecase/pushes.go +21 -29


@@ -15,9 +15,6 @@ import (
15	15		"bnema.dev/ermite/internal/ports"
16	16		)
17	17
18		-	// pushRetries bounds the retries of a metadata update that loses a race.
19		-	const pushRetries = 5
20		-
21	18		// Pushes are the use cases around a Git push.
22	19		type Pushes struct {
23	20		meta ports.RepoMetaStore

@@ -209,7 +206,7 @@ func (u *Pushes) checkWorkflows(ctx context.Context, name domain.RepoName, updat
209	206		return nil
210	207		}
211	208
212		-	// Record is the post-receive step of an accepted push: it sets pushed_at,
	209	+	// Record is the post-receive step of an accepted push: it sets pushed_at and active_at,
213	210		// repairs HEAD when it points to a missing branch, tells the reader that the
214	211		// repository changed, queues the workflows the push triggers, publishes a
215	212		// PushEvent and schedules maintenance. Every

@@ -245,36 +242,31 @@ func (u *Pushes) Record(ctx context.Context, p domain.Principal, name domain.Rep
245	242		return errors.Join(errs...)
246	243		}
247	244
248		-	// touchPushedAt stores pushed_at, retrying when another write got in between.
	245	+	// touchPushedAt stores pushed_at and active_at, preserving later timestamps
	246	+	// and retrying when another write got in between.
249	247		// A repository deleted meanwhile is not an error. It returns the repository
250		-	// as read, or the zero value when it is unknown. A push (Pushes.Record) and a
251		-	// merge, which moves a branch too, both record through it.
	248	+	// as stored after mutation, or the zero value when it is unknown. A push
	249	+	// (Pushes.Record) and a merge, which moves a branch too, both record through it.
252	250		func touchPushedAt(ctx context.Context, meta ports.RepoMetaStore, name domain.RepoName, now time.Time) (domain.Repo, error) {
253		-	for range pushRetries {
254		-	repo, err := meta.Get(ctx, name)
255		-	if errors.Is(err, domain.ErrNotFound) {
256		-	return domain.Repo{}, nil
257		-	}
258		-	if err != nil {
259		-	return domain.Repo{}, fmt.Errorf("get repository %q: %w", name, err)
260		-	}
261		-	if !now.After(repo.PushedAt) {
262		-	return repo, nil // a later push already recorded
263		-	}
264		-	repo.PushedAt = now
265		-	err = meta.Update(ctx, repo)
266		-	if errors.Is(err, domain.ErrConflict) {
267		-	continue
	251	+	repo, err := meta.Mutate(ctx, name, func(repo *domain.Repo) (bool, error) {
	252	+	changed := false
	253	+	if now.After(repo.PushedAt) {
	254	+	repo.PushedAt = now
	255	+	changed = true
268	256		}
269		-	if errors.Is(err, domain.ErrNotFound) {
270		-	return domain.Repo{}, nil
	257	+	if now.After(repo.ActiveAt) {
	258	+	repo.ActiveAt = now
	259	+	changed = true
271	260		}
272		-	if err != nil {
273		-	return repo, fmt.Errorf("update repository %q: %w", name, err)
274		-	}
275		-	return repo, nil
	261	+	return changed, nil
	262	+	})
	263	+	if errors.Is(err, domain.ErrNotFound) {
	264	+	return domain.Repo{}, nil
	265	+	}
	266	+	if err != nil {
	267	+	return repo, fmt.Errorf("update repository %q: %w", name, err)
276	268		}
277		-	return domain.Repo{}, fmt.Errorf("update pushed_at of %q: %w", name, domain.ErrConflict)
	269	+	return repo, nil
278	270		}
279	271
280	272		// fixDefaultBranch points HEAD to a branch that exists when it points to a

 	"bnema.dev/ermite/internal/ports"
 )
-// pushRetries bounds the retries of a metadata update that loses a race.
-const pushRetries = 5
 // Pushes are the use cases around a Git push.
 type Pushes struct {
 	meta  ports.RepoMetaStore
 	return nil
 }
-// Record is the post-receive step of an accepted push: it sets pushed_at,
+// Record is the post-receive step of an accepted push: it sets pushed_at and active_at,
 // repairs HEAD when it points to a missing branch, tells the reader that the
 // repository changed, queues the workflows the push triggers, publishes a
 // PushEvent and schedules maintenance. Every
 	return errors.Join(errs...)
 }
-// touchPushedAt stores pushed_at, retrying when another write got in between.
+// touchPushedAt stores pushed_at and active_at, preserving later timestamps
+// and retrying when another write got in between.
 // A repository deleted meanwhile is not an error. It returns the repository
-// as read, or the zero value when it is unknown. A push (Pushes.Record) and a
+// as stored after mutation, or the zero value when it is unknown. A push
-// merge, which moves a branch too, both record through it.
+// (Pushes.Record) and a merge, which moves a branch too, both record through it.
 func touchPushedAt(ctx context.Context, meta ports.RepoMetaStore, name domain.RepoName, now time.Time) (domain.Repo, error) {
-	for range pushRetries {
+	repo, err := meta.Mutate(ctx, name, func(repo *domain.Repo) (bool, error) {
-		repo, err := meta.Get(ctx, name)
+		changed := false
-		if errors.Is(err, domain.ErrNotFound) {
+		if now.After(repo.PushedAt) {
-			return domain.Repo{}, nil
+			repo.PushedAt = now
-		}
+			changed = true
-		if err != nil {
-			return domain.Repo{}, fmt.Errorf("get repository %q: %w", name, err)
-		}
-		if !now.After(repo.PushedAt) {
-			return repo, nil // a later push already recorded
-		}
-		repo.PushedAt = now
-		err = meta.Update(ctx, repo)
-		if errors.Is(err, domain.ErrConflict) {
-			continue
 		}
-		if errors.Is(err, domain.ErrNotFound) {
+		if now.After(repo.ActiveAt) {
-			return domain.Repo{}, nil
+			repo.ActiveAt = now
+			changed = true
 		}
-		if err != nil {
+		return changed, nil
-			return repo, fmt.Errorf("update repository %q: %w", name, err)
+	})
-		}
+	if errors.Is(err, domain.ErrNotFound) {
-		return repo, nil
+		return domain.Repo{}, nil
+	}
+	if err != nil {
+		return repo, fmt.Errorf("update repository %q: %w", name, err)
 	}
-	return domain.Repo{}, fmt.Errorf("update pushed_at of %q: %w", name, domain.ErrConflict)
+	return repo, nil
 }
 // fixDefaultBranch points HEAD to a branch that exists when it points to a

M internal/usecase/pushes_test.go +11 -16


@@ -305,8 +305,7 @@ func TestPushesRecord(t *testing.T) {
305	305		f := newPushFixture(t)
306	306		f.sched.EXPECT().Schedule(ctx, n).Return().Once()
307	307		repo := domain.Repo{Name: n, Visibility: domain.VisibilityPrivate, CreatedAt: now.Add(-time.Hour)}
308		-	f.meta.EXPECT().Get(ctx, n).Return(repo, nil)
309		-	f.meta.EXPECT().Update(ctx, domain.Repo{Name: n, Visibility: domain.VisibilityPrivate, CreatedAt: repo.CreatedAt, PushedAt: now}).Return(nil)
	308	+	expectRepoMutation(t, f.meta, repo, domain.Repo{Name: n, Visibility: repo.Visibility, CreatedAt: repo.CreatedAt, PushedAt: now, ActiveAt: now}).Once()
310	309		f.git.EXPECT().DefaultBranch(ctx, n).Return("main", true, nil)
311	310		f.bus.EXPECT().Publish(ctx, domain.PushEvent{Repo: n, Updates: ups, At: now, Visibility: repo.Visibility, CreatedAt: repo.CreatedAt}).Return()
312	311

@@ -320,22 +319,18 @@ func TestPushesRecord(t *testing.T) {
320	319		fresh := mocks.NewRepoFreshener(t)
321	320		fresh.EXPECT().Refresh(ctx, n).Return().Once()
322	321		f.pushes.WithFreshener(fresh)
323		-	f.meta.EXPECT().Get(ctx, n).Return(domain.Repo{Name: n}, nil)
324		-	f.meta.EXPECT().Update(ctx, mock.Anything).Return(nil)
	322	+	expectPushMutation(t, f.meta, domain.Repo{Name: n}, nil)
325	323		f.git.EXPECT().DefaultBranch(ctx, n).Return("main", true, nil)
326	324		f.bus.EXPECT().Publish(ctx, mock.Anything).Return()
327	325		require.NoError(t, f.pushes.Record(ctx, p, n, ups))
328	326		})
329	327
330		-	t.Run("pushed_at retries after a conflict and never goes backwards", func(t *testing.T) {
	328	+	t.Run("pushed_at preserves a later push", func(t *testing.T) {
331	329		t.Parallel()
332	330		f := newPushFixture(t)
333	331		f.sched.EXPECT().Schedule(ctx, n).Return().Once()
334		-	repo := domain.Repo{Name: n}
335		-	f.meta.EXPECT().Get(ctx, n).Return(repo, nil).Once()
336		-	f.meta.EXPECT().Update(ctx, mock.Anything).Return(domain.ErrConflict).Once()
337		-	later := domain.Repo{Name: n, PushedAt: now.Add(time.Second)}
338		-	f.meta.EXPECT().Get(ctx, n).Return(later, nil).Once() // a later push recorded meanwhile
	332	+	later := domain.Repo{Name: n, PushedAt: now.Add(time.Second), ActiveAt: now.Add(time.Second)}
	333	+	expectPushMutation(t, f.meta, later, nil) // a later push recorded meanwhile
339	334		f.git.EXPECT().DefaultBranch(ctx, n).Return("main", true, nil)
340	335		f.bus.EXPECT().Publish(ctx, mock.Anything).Return()
341	336		require.NoError(t, f.pushes.Record(ctx, p, n, ups))

@@ -345,7 +340,7 @@ func TestPushesRecord(t *testing.T) {
345	340		t.Parallel()
346	341		f := newPushFixture(t)
347	342		f.sched.EXPECT().Schedule(ctx, n).Return().Once()
348		-	f.meta.EXPECT().Get(ctx, n).Return(domain.Repo{}, domain.ErrNotFound)
	343	+	expectPushMutation(t, f.meta, domain.Repo{}, domain.ErrNotFound)
349	344		f.git.EXPECT().DefaultBranch(ctx, n).Return("main", true, nil)
350	345		f.bus.EXPECT().Publish(ctx, mock.Anything).Return()
351	346		require.NoError(t, f.pushes.Record(ctx, p, n, ups))

@@ -355,7 +350,7 @@ func TestPushesRecord(t *testing.T) {
355	350		t.Parallel()
356	351		f := newPushFixture(t)
357	352		f.sched.EXPECT().Schedule(ctx, n).Return().Once()
358		-	f.meta.EXPECT().Get(ctx, n).Return(domain.Repo{}, domain.ErrNotFound)
	353	+	expectPushMutation(t, f.meta, domain.Repo{}, domain.ErrNotFound)
359	354		f.git.EXPECT().DefaultBranch(ctx, n).Return("", false, domain.ErrNotFound)
360	355		f.bus.EXPECT().Publish(ctx, mock.Anything).Return()
361	356		require.NoError(t, f.pushes.Record(ctx, p, n, ups))

@@ -365,7 +360,7 @@ func TestPushesRecord(t *testing.T) {
365	360		t.Parallel()
366	361		f := newPushFixture(t)
367	362		f.sched.EXPECT().Schedule(ctx, n).Return().Once()
368		-	f.meta.EXPECT().Get(ctx, n).Return(domain.Repo{}, domain.ErrNotFound)
	363	+	expectPushMutation(t, f.meta, domain.Repo{}, domain.ErrNotFound)
369	364		f.git.EXPECT().DefaultBranch(ctx, n).Return("trunk", false, nil)
370	365		f.git.EXPECT().SetDefaultBranch(ctx, n, "main").Return(domain.ErrNotFound)
371	366		f.bus.EXPECT().Publish(ctx, mock.Anything).Return()

@@ -377,7 +372,7 @@ func TestPushesRecord(t *testing.T) {
377	372		f := newPushFixture(t)
378	373		f.sched.EXPECT().Schedule(ctx, n).Return().Once()
379	374		boom := errors.New("boom")
380		-	f.meta.EXPECT().Get(ctx, n).Return(domain.Repo{}, boom)
	375	+	expectPushMutation(t, f.meta, domain.Repo{}, boom)
381	376		f.git.EXPECT().DefaultBranch(ctx, n).Return("", false, boom)
382	377		f.bus.EXPECT().Publish(ctx, mock.Anything).Return()
383	378		err := f.pushes.Record(ctx, p, n, ups)

@@ -414,7 +409,7 @@ func TestPushesDefaultBranchRule(t *testing.T) {
414	409		t.Parallel()
415	410		f := newPushFixture(t)
416	411		f.sched.EXPECT().Schedule(ctx, n).Return().Once()
417		-	f.meta.EXPECT().Get(ctx, n).Return(domain.Repo{Name: n, PushedAt: now}, nil)
	412	+	expectPushMutation(t, f.meta, domain.Repo{Name: n, PushedAt: now, ActiveAt: now}, nil)
418	413		f.git.EXPECT().DefaultBranch(ctx, n).Return(tt.head, tt.exists, nil)
419	414		if tt.want != "" {
420	415		f.git.EXPECT().SetDefaultBranch(ctx, n, tt.want).Return(nil)

@@ -429,7 +424,7 @@ func TestPushesDefaultBranchRule(t *testing.T) {
429	424		f := newPushFixture(t)
430	425		f.sched.EXPECT().Schedule(ctx, n).Return().Once()
431	426		boom := errors.New("boom")
432		-	f.meta.EXPECT().Get(ctx, n).Return(domain.Repo{Name: n, PushedAt: now}, nil)
	427	+	expectPushMutation(t, f.meta, domain.Repo{Name: n, PushedAt: now, ActiveAt: now}, nil)
433	428		f.git.EXPECT().DefaultBranch(ctx, n).Return("main", false, nil)
434	429		f.git.EXPECT().SetDefaultBranch(ctx, n, "dev").Return(boom)
435	430		f.bus.EXPECT().Publish(ctx, mock.Anything).Return()

 		f := newPushFixture(t)
 		f.sched.EXPECT().Schedule(ctx, n).Return().Once()
 		repo := domain.Repo{Name: n, Visibility: domain.VisibilityPrivate, CreatedAt: now.Add(-time.Hour)}
-		f.meta.EXPECT().Get(ctx, n).Return(repo, nil)
+		expectRepoMutation(t, f.meta, repo, domain.Repo{Name: n, Visibility: repo.Visibility, CreatedAt: repo.CreatedAt, PushedAt: now, ActiveAt: now}).Once()
-		f.meta.EXPECT().Update(ctx, domain.Repo{Name: n, Visibility: domain.VisibilityPrivate, CreatedAt: repo.CreatedAt, PushedAt: now}).Return(nil)
 		f.git.EXPECT().DefaultBranch(ctx, n).Return("main", true, nil)
 		f.bus.EXPECT().Publish(ctx, domain.PushEvent{Repo: n, Updates: ups, At: now, Visibility: repo.Visibility, CreatedAt: repo.CreatedAt}).Return()
 		fresh := mocks.NewRepoFreshener(t)
 		fresh.EXPECT().Refresh(ctx, n).Return().Once()
 		f.pushes.WithFreshener(fresh)
-		f.meta.EXPECT().Get(ctx, n).Return(domain.Repo{Name: n}, nil)
+		expectPushMutation(t, f.meta, domain.Repo{Name: n}, nil)
-		f.meta.EXPECT().Update(ctx, mock.Anything).Return(nil)
 		f.git.EXPECT().DefaultBranch(ctx, n).Return("main", true, nil)
 		f.bus.EXPECT().Publish(ctx, mock.Anything).Return()
 		require.NoError(t, f.pushes.Record(ctx, p, n, ups))
 	})
-	t.Run("pushed_at retries after a conflict and never goes backwards", func(t *testing.T) {
+	t.Run("pushed_at preserves a later push", func(t *testing.T) {
 		t.Parallel()
 		f := newPushFixture(t)
 		f.sched.EXPECT().Schedule(ctx, n).Return().Once()
-		repo := domain.Repo{Name: n}
+		later := domain.Repo{Name: n, PushedAt: now.Add(time.Second), ActiveAt: now.Add(time.Second)}
-		f.meta.EXPECT().Get(ctx, n).Return(repo, nil).Once()
+		expectPushMutation(t, f.meta, later, nil) // a later push recorded meanwhile
-		f.meta.EXPECT().Update(ctx, mock.Anything).Return(domain.ErrConflict).Once()
-		later := domain.Repo{Name: n, PushedAt: now.Add(time.Second)}
-		f.meta.EXPECT().Get(ctx, n).Return(later, nil).Once() // a later push recorded meanwhile
 		f.git.EXPECT().DefaultBranch(ctx, n).Return("main", true, nil)
 		f.bus.EXPECT().Publish(ctx, mock.Anything).Return()
 		require.NoError(t, f.pushes.Record(ctx, p, n, ups))
 		t.Parallel()
 		f := newPushFixture(t)
 		f.sched.EXPECT().Schedule(ctx, n).Return().Once()
-		f.meta.EXPECT().Get(ctx, n).Return(domain.Repo{}, domain.ErrNotFound)
+		expectPushMutation(t, f.meta, domain.Repo{}, domain.ErrNotFound)
 		f.git.EXPECT().DefaultBranch(ctx, n).Return("main", true, nil)
 		f.bus.EXPECT().Publish(ctx, mock.Anything).Return()
 		require.NoError(t, f.pushes.Record(ctx, p, n, ups))
 		t.Parallel()
 		f := newPushFixture(t)
 		f.sched.EXPECT().Schedule(ctx, n).Return().Once()
-		f.meta.EXPECT().Get(ctx, n).Return(domain.Repo{}, domain.ErrNotFound)
+		expectPushMutation(t, f.meta, domain.Repo{}, domain.ErrNotFound)
 		f.git.EXPECT().DefaultBranch(ctx, n).Return("", false, domain.ErrNotFound)
 		f.bus.EXPECT().Publish(ctx, mock.Anything).Return()
 		require.NoError(t, f.pushes.Record(ctx, p, n, ups))
 		t.Parallel()
 		f := newPushFixture(t)
 		f.sched.EXPECT().Schedule(ctx, n).Return().Once()
-		f.meta.EXPECT().Get(ctx, n).Return(domain.Repo{}, domain.ErrNotFound)
+		expectPushMutation(t, f.meta, domain.Repo{}, domain.ErrNotFound)
 		f.git.EXPECT().DefaultBranch(ctx, n).Return("trunk", false, nil)
 		f.git.EXPECT().SetDefaultBranch(ctx, n, "main").Return(domain.ErrNotFound)
 		f.bus.EXPECT().Publish(ctx, mock.Anything).Return()
 		f := newPushFixture(t)
 		f.sched.EXPECT().Schedule(ctx, n).Return().Once()
 		boom := errors.New("boom")
-		f.meta.EXPECT().Get(ctx, n).Return(domain.Repo{}, boom)
+		expectPushMutation(t, f.meta, domain.Repo{}, boom)
 		f.git.EXPECT().DefaultBranch(ctx, n).Return("", false, boom)
 		f.bus.EXPECT().Publish(ctx, mock.Anything).Return()
 		err := f.pushes.Record(ctx, p, n, ups)
 			t.Parallel()
 			f := newPushFixture(t)
 			f.sched.EXPECT().Schedule(ctx, n).Return().Once()
-			f.meta.EXPECT().Get(ctx, n).Return(domain.Repo{Name: n, PushedAt: now}, nil)
+			expectPushMutation(t, f.meta, domain.Repo{Name: n, PushedAt: now, ActiveAt: now}, nil)
 			f.git.EXPECT().DefaultBranch(ctx, n).Return(tt.head, tt.exists, nil)
 			if tt.want != "" {
 				f.git.EXPECT().SetDefaultBranch(ctx, n, tt.want).Return(nil)
 		f := newPushFixture(t)
 		f.sched.EXPECT().Schedule(ctx, n).Return().Once()
 		boom := errors.New("boom")
-		f.meta.EXPECT().Get(ctx, n).Return(domain.Repo{Name: n, PushedAt: now}, nil)
+		expectPushMutation(t, f.meta, domain.Repo{Name: n, PushedAt: now, ActiveAt: now}, nil)
 		f.git.EXPECT().DefaultBranch(ctx, n).Return("main", false, nil)
 		f.git.EXPECT().SetDefaultBranch(ctx, n, "dev").Return(boom)
 		f.bus.EXPECT().Publish(ctx, mock.Anything).Return()

A internal/usecase/repo_mutation_test.go +34 -0

@@ -0,0 +1,34 @@
	1	+	// SPDX-License-Identifier: AGPL-3.0-or-later
	2	+
	3	+	package usecase_test
	4	+
	5	+	import (
	6	+	"context"
	7	+	"testing"
	8	+
	9	+	"github.com/stretchr/testify/mock"
	10	+	"github.com/stretchr/testify/require"
	11	+
	12	+	"bnema.dev/ermite/internal/domain"
	13	+	"bnema.dev/ermite/internal/ports/mocks"
	14	+	)
	15	+
	16	+	func expectRepoMutation(t testing.T, meta mocks.RepoMetaStore, repo domain.Repo, want any) *mocks.RepoMetaStore_Mutate_Call {
	17	+	t.Helper()
	18	+	return meta.EXPECT().Mutate(mock.Anything, repo.Name, mock.Anything).RunAndReturn(func(_ context.Context, _ domain.RepoName, fn func(*domain.Repo) (bool, error)) (domain.Repo, error) {
	19	+	result := repo
	20	+	_, err := fn(&result)
	21	+	require.NoError(t, err)
	22	+	_, differences := (mock.Arguments{want}).Diff([]any{result})
	23	+	require.Zero(t, differences, "unexpected mutated repository: %+v", result)
	24	+	return result, err
	25	+	})
	26	+	}
	27	+
	28	+	func expectPushMutation(t testing.T, meta mocks.RepoMetaStore, repo domain.Repo, err error) *mocks.RepoMetaStore_Mutate_Call {
	29	+	t.Helper()
	30	+	if err != nil {
	31	+	return meta.EXPECT().Mutate(mock.Anything, mock.Anything, mock.Anything).Return(repo, err)
	32	+	}
	33	+	return expectRepoMutation(t, meta, repo, mock.Anything)
	34	+	}

@@ -0,0 +1,34 @@
	1	+	// SPDX-License-Identifier: AGPL-3.0-or-later
	2	+
	3	+	package usecase_test
	4	+
	5	+	import (
	6	+	"context"
	7	+	"testing"
	8	+
	9	+	"github.com/stretchr/testify/mock"
	10	+	"github.com/stretchr/testify/require"
	11	+
	12	+	"bnema.dev/ermite/internal/domain"
	13	+	"bnema.dev/ermite/internal/ports/mocks"
	14	+	)
	15	+
	16	+	func expectRepoMutation(t testing.T, meta mocks.RepoMetaStore, repo domain.Repo, want any) *mocks.RepoMetaStore_Mutate_Call {
	17	+	t.Helper()
	18	+	return meta.EXPECT().Mutate(mock.Anything, repo.Name, mock.Anything).RunAndReturn(func(_ context.Context, _ domain.RepoName, fn func(*domain.Repo) (bool, error)) (domain.Repo, error) {
	19	+	result := repo
	20	+	_, err := fn(&result)
	21	+	require.NoError(t, err)
	22	+	_, differences := (mock.Arguments{want}).Diff([]any{result})
	23	+	require.Zero(t, differences, "unexpected mutated repository: %+v", result)
	24	+	return result, err
	25	+	})
	26	+	}
	27	+
	28	+	func expectPushMutation(t testing.T, meta mocks.RepoMetaStore, repo domain.Repo, err error) *mocks.RepoMetaStore_Mutate_Call {
	29	+	t.Helper()
	30	+	if err != nil {
	31	+	return meta.EXPECT().Mutate(mock.Anything, mock.Anything, mock.Anything).Return(repo, err)
	32	+	}
	33	+	return expectRepoMutation(t, meta, repo, mock.Anything)
	34	+	}

M internal/usecase/repos_write.go +6 -14


@@ -155,11 +155,7 @@ func (r *Repos) Update(ctx context.Context, p domain.Principal, name domain.Repo
155	155		// updateMeta applies the metadata fields, retrying when a write (a push
156	156		// recording pushed_at) gets in between.
157	157		func (r *Repos) updateMeta(ctx context.Context, name domain.RepoName, params ports.UpdateRepoParams) (domain.Repo, error) {
158		-	for range pushRetries {
159		-	repo, err := r.meta.Get(ctx, name)
160		-	if err != nil {
161		-	return domain.Repo{}, err
162		-	}
	158	+	repo, err := r.meta.Mutate(ctx, name, func(repo *domain.Repo) (bool, error) {
163	159		if params.Description != nil {
164	160		repo.Description = *params.Description
165	161		}

@@ -181,16 +177,12 @@ func (r *Repos) updateMeta(ctx context.Context, name domain.RepoName, params por
181	177		if params.Issues != nil {
182	178		repo.Settings.Issues = *params.Issues
183	179		}
184		-	err = r.meta.Update(ctx, repo)
185		-	if errors.Is(err, domain.ErrConflict) {
186		-	continue
187		-	}
188		-	if err != nil {
189		-	return domain.Repo{}, fmt.Errorf("update repository %q: %w", name, err)
190		-	}
191		-	return repo, nil
	180	+	return true, nil
	181	+	})
	182	+	if err != nil {
	183	+	return domain.Repo{}, fmt.Errorf("update repository %q: %w", name, err)
192	184		}
193		-	return domain.Repo{}, fmt.Errorf("update repository %q: %w", name, domain.ErrConflict)
	185	+	return repo, nil
194	186		}
195	187
196	188		// Delete moves the repository directory to the trash, removes its metadata

 // updateMeta applies the metadata fields, retrying when a write (a push
 // recording pushed_at) gets in between.
 func (r *Repos) updateMeta(ctx context.Context, name domain.RepoName, params ports.UpdateRepoParams) (domain.Repo, error) {
-	for range pushRetries {
+	repo, err := r.meta.Mutate(ctx, name, func(repo *domain.Repo) (bool, error) {
-		repo, err := r.meta.Get(ctx, name)
-		if err != nil {
-			return domain.Repo{}, err
-		}
 		if params.Description != nil {
 			repo.Description = *params.Description
 		}
 		if params.Issues != nil {
 			repo.Settings.Issues = *params.Issues
 		}
-		err = r.meta.Update(ctx, repo)
+		return true, nil
-		if errors.Is(err, domain.ErrConflict) {
+	})
-			continue
+	if err != nil {
-		}
+		return domain.Repo{}, fmt.Errorf("update repository %q: %w", name, err)
-		if err != nil {
-			return domain.Repo{}, fmt.Errorf("update repository %q: %w", name, err)
-		}
-		return repo, nil
 	}
-	return domain.Repo{}, fmt.Errorf("update repository %q: %w", name, domain.ErrConflict)
+	return repo, nil
 }
 // Delete moves the repository directory to the trash, removes its metadata

M internal/usecase/repos_write_test.go +20 -21


@@ -30,9 +30,9 @@ func TestUpdate(t *testing.T) {
30	30		t.Run("description and visibility are stored and RepoUpdated is published", func(t *testing.T) {
31	31		t.Parallel()
32	32		f := newFixture(t)
33		-	f.meta.EXPECT().Get(ctx, n).Return(priv, nil).Twice()
	33	+	f.meta.EXPECT().Get(ctx, n).Return(priv, nil).Once()
34	34		want := domain.Repo{Name: n, Visibility: domain.VisibilityPublic, Description: "new", Settings: domain.DefaultRepoSettings()}
35		-	f.meta.EXPECT().Update(ctx, want).Return(nil)
	35	+	expectRepoMutation(t, f.meta, priv, want)
36	36		f.bus.EXPECT().Publish(ctx, domain.RepoUpdated{
37	37		Repo: n, At: now, Visibility: domain.VisibilityPublic, Previous: domain.VisibilityPrivate,
38	38		}).Return().Once()

@@ -47,11 +47,11 @@ func TestUpdate(t *testing.T) {
47	47		t.Run("topics are normalized and stored, and RepoUpdated is published", func(t *testing.T) {
48	48		t.Parallel()
49	49		f := newFixture(t)
50		-	f.meta.EXPECT().Get(ctx, n).Return(priv, nil).Twice()
	50	+	f.meta.EXPECT().Get(ctx, n).Return(priv, nil).Once()
51	51		want := priv
52	52		want.Topics = []string{"cli", "go"}
53	53		want.Settings = domain.DefaultRepoSettings()
54		-	f.meta.EXPECT().Update(ctx, want).Return(nil)
	54	+	expectRepoMutation(t, f.meta, priv, want)
55	55		f.bus.EXPECT().Publish(ctx, domain.RepoUpdated{
56	56		Repo: n, At: now, Visibility: domain.VisibilityPrivate, Previous: domain.VisibilityPrivate,
57	57		}).Return().Once()

@@ -66,10 +66,10 @@ func TestUpdate(t *testing.T) {
66	66		f := newFixture(t)
67	67		withTopics := priv
68	68		withTopics.Topics = []string{"go"}
69		-	f.meta.EXPECT().Get(ctx, n).Return(withTopics, nil).Twice()
	69	+	f.meta.EXPECT().Get(ctx, n).Return(withTopics, nil).Once()
70	70		want := priv
71	71		want.Settings = domain.DefaultRepoSettings()
72		-	f.meta.EXPECT().Update(ctx, want).Return(nil)
	72	+	expectRepoMutation(t, f.meta, withTopics, want)
73	73		f.bus.EXPECT().Publish(ctx, mock.Anything).Return().Once()
74	74
75	75		got, err := f.repos.Update(ctx, admin, n, ports.UpdateRepoParams{Topics: &[]string{}})

@@ -77,15 +77,12 @@ func TestUpdate(t *testing.T) {
77	77		assert.Nil(t, got.Topics)
78	78		})
79	79
80		-	t.Run("a lost race on the metadata is retried", func(t *testing.T) {
81		-	t.Parallel()
	80	+	t.Run("exhausted mutation conflicts are returned", func(t *testing.T) {
82	81		f := newFixture(t)
83	82		f.meta.EXPECT().Get(ctx, n).Return(priv, nil)
84		-	f.meta.EXPECT().Update(ctx, mock.Anything).Return(domain.ErrConflict).Once()
85		-	f.meta.EXPECT().Update(ctx, mock.Anything).Return(nil).Once()
86		-	f.bus.EXPECT().Publish(ctx, mock.Anything).Return().Once()
	83	+	f.meta.EXPECT().Mutate(ctx, n, mock.Anything).Return(domain.Repo{}, domain.ErrConflict).Once()
87	84		_, err := f.repos.Update(ctx, admin, n, ports.UpdateRepoParams{Description: ptr("x")})
88		-	require.NoError(t, err)
	85	+	require.ErrorIs(t, err, domain.ErrConflict)
89	86		})
90	87
91	88		t.Run("the default branch is checked, then HEAD moves", func(t *testing.T) {

@@ -106,9 +103,11 @@ func TestUpdate(t *testing.T) {
106	103		var order []string
107	104		f.meta.EXPECT().Get(ctx, n).Return(priv, nil)
108	105		f.git.EXPECT().HasBranch(ctx, n, "dev").Return(true, nil)
109		-	f.meta.EXPECT().Update(ctx, mock.Anything).RunAndReturn(func(context.Context, domain.Repo) error {
	106	+	f.meta.EXPECT().Mutate(ctx, n, mock.Anything).RunAndReturn(func(_ context.Context, _ domain.RepoName, fn func(*domain.Repo) (bool, error)) (domain.Repo, error) {
110	107		order = append(order, "meta")
111		-	return nil
	108	+	repo := priv
	109	+	_, err := fn(&repo)
	110	+	return repo, err
112	111		})
113	112		f.git.EXPECT().SetDefaultBranch(ctx, n, "dev").RunAndReturn(func(context.Context, domain.RepoName, string) error {
114	113		order = append(order, "head")

@@ -127,7 +126,7 @@ func TestUpdate(t *testing.T) {
127	126		pub := domain.Repo{Name: n, Visibility: domain.VisibilityPublic, Description: "old"}
128	127		f.meta.EXPECT().Get(ctx, n).Return(pub, nil)
129	128		f.git.EXPECT().HasBranch(ctx, n, "dev").Return(true, nil)
130		-	f.meta.EXPECT().Update(ctx, mock.Anything).Return(nil)
	129	+	expectRepoMutation(t, f.meta, pub, mock.Anything)
131	130		f.git.EXPECT().SetDefaultBranch(ctx, n, "dev").Return(boom)
132	131		f.bus.EXPECT().Publish(ctx, domain.RepoUpdated{
133	132		Repo: n, At: now, Visibility: domain.VisibilityPrivate, Previous: domain.VisibilityPublic,

@@ -250,10 +249,10 @@ func TestUpdateIssuesMode(t *testing.T) {
250	249		t.Run("public is stored and published", func(t *testing.T) {
251	250		t.Parallel()
252	251		f := newFixture(t)
253		-	f.meta.EXPECT().Get(ctx, n).Return(priv, nil).Twice()
254		-	f.meta.EXPECT().Update(ctx, mock.MatchedBy(func(r domain.Repo) bool {
	252	+	f.meta.EXPECT().Get(ctx, n).Return(priv, nil).Once()
	253	+	expectRepoMutation(t, f.meta, priv, mock.MatchedBy(func(r domain.Repo) bool {
255	254		return r.Settings.Issues == domain.IssuesPublic
256		-	})).Return(nil)
	255	+	}))
257	256		f.bus.EXPECT().Publish(ctx, mock.Anything).Return().Once()
258	257		repo, err := f.repos.Update(ctx, domain.Root(), n, ports.UpdateRepoParams{Issues: ptr(domain.IssuesPublic)})
259	258		require.NoError(t, err)

@@ -271,10 +270,10 @@ func TestUpdateIssuesMode(t *testing.T) {
271	270		t.Run("owner is stored and published", func(t *testing.T) {
272	271		t.Parallel()
273	272		f := newFixture(t)
274		-	f.meta.EXPECT().Get(ctx, n).Return(priv, nil).Twice()
275		-	f.meta.EXPECT().Update(ctx, mock.MatchedBy(func(r domain.Repo) bool {
	273	+	f.meta.EXPECT().Get(ctx, n).Return(priv, nil).Once()
	274	+	expectRepoMutation(t, f.meta, priv, mock.MatchedBy(func(r domain.Repo) bool {
276	275		return r.Settings.Issues == domain.IssuesOwner && r.Settings.FailingChecksBlock
277		-	})).Return(nil)
	276	+	}))
278	277		f.bus.EXPECT().Publish(ctx, mock.Anything).Return().Once()
279	278		repo, err := f.repos.Update(ctx, domain.Root(), n, ports.UpdateRepoParams{Issues: ptr(domain.IssuesOwner)})
280	279		require.NoError(t, err)

 	t.Run("description and visibility are stored and RepoUpdated is published", func(t *testing.T) {
 		t.Parallel()
 		f := newFixture(t)
-		f.meta.EXPECT().Get(ctx, n).Return(priv, nil).Twice()
+		f.meta.EXPECT().Get(ctx, n).Return(priv, nil).Once()
 		want := domain.Repo{Name: n, Visibility: domain.VisibilityPublic, Description: "new", Settings: domain.DefaultRepoSettings()}
-		f.meta.EXPECT().Update(ctx, want).Return(nil)
+		expectRepoMutation(t, f.meta, priv, want)
 		f.bus.EXPECT().Publish(ctx, domain.RepoUpdated{
 			Repo: n, At: now, Visibility: domain.VisibilityPublic, Previous: domain.VisibilityPrivate,
 		}).Return().Once()
 	t.Run("topics are normalized and stored, and RepoUpdated is published", func(t *testing.T) {
 		t.Parallel()
 		f := newFixture(t)
-		f.meta.EXPECT().Get(ctx, n).Return(priv, nil).Twice()
+		f.meta.EXPECT().Get(ctx, n).Return(priv, nil).Once()
 		want := priv
 		want.Topics = []string{"cli", "go"}
 		want.Settings = domain.DefaultRepoSettings()
-		f.meta.EXPECT().Update(ctx, want).Return(nil)
+		expectRepoMutation(t, f.meta, priv, want)
 		f.bus.EXPECT().Publish(ctx, domain.RepoUpdated{
 			Repo: n, At: now, Visibility: domain.VisibilityPrivate, Previous: domain.VisibilityPrivate,
 		}).Return().Once()
 		f := newFixture(t)
 		withTopics := priv
 		withTopics.Topics = []string{"go"}
-		f.meta.EXPECT().Get(ctx, n).Return(withTopics, nil).Twice()
+		f.meta.EXPECT().Get(ctx, n).Return(withTopics, nil).Once()
 		want := priv
 		want.Settings = domain.DefaultRepoSettings()
-		f.meta.EXPECT().Update(ctx, want).Return(nil)
+		expectRepoMutation(t, f.meta, withTopics, want)
 		f.bus.EXPECT().Publish(ctx, mock.Anything).Return().Once()
 		got, err := f.repos.Update(ctx, admin, n, ports.UpdateRepoParams{Topics: &[]string{}})
 		assert.Nil(t, got.Topics)
 	})
-	t.Run("a lost race on the metadata is retried", func(t *testing.T) {
+	t.Run("exhausted mutation conflicts are returned", func(t *testing.T) {
-		t.Parallel()
 		f := newFixture(t)
 		f.meta.EXPECT().Get(ctx, n).Return(priv, nil)
-		f.meta.EXPECT().Update(ctx, mock.Anything).Return(domain.ErrConflict).Once()
+		f.meta.EXPECT().Mutate(ctx, n, mock.Anything).Return(domain.Repo{}, domain.ErrConflict).Once()
-		f.meta.EXPECT().Update(ctx, mock.Anything).Return(nil).Once()
-		f.bus.EXPECT().Publish(ctx, mock.Anything).Return().Once()
 		_, err := f.repos.Update(ctx, admin, n, ports.UpdateRepoParams{Description: ptr("x")})
-		require.NoError(t, err)
+		require.ErrorIs(t, err, domain.ErrConflict)
 	})
 	t.Run("the default branch is checked, then HEAD moves", func(t *testing.T) {
 		var order []string
 		f.meta.EXPECT().Get(ctx, n).Return(priv, nil)
 		f.git.EXPECT().HasBranch(ctx, n, "dev").Return(true, nil)
-		f.meta.EXPECT().Update(ctx, mock.Anything).RunAndReturn(func(context.Context, domain.Repo) error {
+		f.meta.EXPECT().Mutate(ctx, n, mock.Anything).RunAndReturn(func(_ context.Context, _ domain.RepoName, fn func(*domain.Repo) (bool, error)) (domain.Repo, error) {
 			order = append(order, "meta")
-			return nil
+			repo := priv
+			_, err := fn(&repo)
+			return repo, err
 		})
 		f.git.EXPECT().SetDefaultBranch(ctx, n, "dev").RunAndReturn(func(context.Context, domain.RepoName, string) error {
 			order = append(order, "head")
 		pub := domain.Repo{Name: n, Visibility: domain.VisibilityPublic, Description: "old"}
 		f.meta.EXPECT().Get(ctx, n).Return(pub, nil)
 		f.git.EXPECT().HasBranch(ctx, n, "dev").Return(true, nil)
-		f.meta.EXPECT().Update(ctx, mock.Anything).Return(nil)
+		expectRepoMutation(t, f.meta, pub, mock.Anything)
 		f.git.EXPECT().SetDefaultBranch(ctx, n, "dev").Return(boom)
 		f.bus.EXPECT().Publish(ctx, domain.RepoUpdated{
 			Repo: n, At: now, Visibility: domain.VisibilityPrivate, Previous: domain.VisibilityPublic,
 	t.Run("public is stored and published", func(t *testing.T) {
 		t.Parallel()
 		f := newFixture(t)
-		f.meta.EXPECT().Get(ctx, n).Return(priv, nil).Twice()
+		f.meta.EXPECT().Get(ctx, n).Return(priv, nil).Once()
-		f.meta.EXPECT().Update(ctx, mock.MatchedBy(func(r domain.Repo) bool {
+		expectRepoMutation(t, f.meta, priv, mock.MatchedBy(func(r domain.Repo) bool {
 			return r.Settings.Issues == domain.IssuesPublic
-		})).Return(nil)
+		}))
 		f.bus.EXPECT().Publish(ctx, mock.Anything).Return().Once()
 		repo, err := f.repos.Update(ctx, domain.Root(), n, ports.UpdateRepoParams{Issues: ptr(domain.IssuesPublic)})
 		require.NoError(t, err)
 	t.Run("owner is stored and published", func(t *testing.T) {
 		t.Parallel()
 		f := newFixture(t)
-		f.meta.EXPECT().Get(ctx, n).Return(priv, nil).Twice()
+		f.meta.EXPECT().Get(ctx, n).Return(priv, nil).Once()
-		f.meta.EXPECT().Update(ctx, mock.MatchedBy(func(r domain.Repo) bool {
+		expectRepoMutation(t, f.meta, priv, mock.MatchedBy(func(r domain.Repo) bool {
 			return r.Settings.Issues == domain.IssuesOwner && r.Settings.FailingChecksBlock
-		})).Return(nil)
+		}))
 		f.bus.EXPECT().Publish(ctx, mock.Anything).Return().Once()
 		repo, err := f.repos.Update(ctx, domain.Root(), n, ports.UpdateRepoParams{Issues: ptr(domain.IssuesOwner)})
 		require.NoError(t, err)

M proto/ermite/storage/repo.proto +2 -0


@@ -32,6 +32,8 @@ message Repo {
32	32		RepoSettings settings = 6;
33	33		// Normalized and sorted; empty on repositories stored before topics.
34	34		repeated string topics = 7;
	35	+	// Latest push, merge request or issue activity; unset until recorded.
	36	+	google.protobuf.Timestamp active_at = 8;
35	37		}
36	38
37	39		// SchemaVersion is stored under the key "meta/schema".


@@ -32,6 +32,8 @@ message Repo {
32	RepoSettings settings = 6;	32		RepoSettings settings = 6;
33	// Normalized and sorted; empty on repositories stored before topics.	33		// Normalized and sorted; empty on repositories stored before topics.
34	repeated string topics = 7;	34		repeated string topics = 7;
		35	+	// Latest push, merge request or issue activity; unset until recorded.
		36	+	google.protobuf.Timestamp active_at = 8;
35	}	37		}
36		38
37	// SchemaVersion is stored under the key "meta/schema".	39		// SchemaVersion is stored under the key "meta/schema".

Merge settings

Comments0 open / 0

Commit	Subject	Author	Date	Signature
0a9e349	test: run the activity store test outside the usecase package and its home row subtests in parallel	brice	2d ago	GPG Verified
9ca7c68	fix(repos): mutate metadata atomically and record approved issue activity	brice	2d ago	GPG Verified
32e9fe7	fix(web): match loaded lines to a selection by file key, keep the focus on a closing menu, close menus with escape on every page and restore the hunk header contrast	brice	2d ago	GPG Verified
4277264	feat(web): order the home page by last activity and move repositories up live	brice	2d ago	GPG Verified
4fc291e	feat(web): move the inbox button of the home page next to the logo, with a mailbox icon and a darker count badge	brice	2d ago	GPG Verified
5f6d2c6	test(app): refresh the web golden pages for the view menu, the w shortcut and the store script	brice	2d ago	GPG Verified
a772c1b	fix(web): a selected line range is one block, its title names the whole range and its hidden lines stay selected once loaded	brice	2d ago	GPG Verified
502935e	refactor(web): drop the Wide button of the diff bar, the w shortcut covers it	brice	2d ago	GPG Verified
a1f8e85	feat(web): make the wide mode a global w shortcut, set before the first paint, and tighten the merge request header	brice	2d ago	GPG Verified
fcc7703	feat(web): one merge request card, a diff view menu, a wide diff mode and quieter hunk rows	brice	2d ago	GPG Verified